Your AI Coding History Is Trapped in Proprietary Silos

The Polyglot Developer Problem

The modern developer’s workflow is no longer monogamous. One developer recently described testing more than forty AI coding tools over four months before settling on a daily rotation of Cursor, Claude Code, and Windsurf [12]. Another two-week evaluation pitted the same three tools against identical refactoring and debugging tasks, finding that each excelled in different dimensions—Claude Code for cross-file pattern recognition, Cursor for surgical inline edits, Windsurf for autonomous execution [3]. The result is a fragmented landscape where a single project might accumulate conversational history across a terminal-based agent, a VS Code fork, and a standalone IDE.

This fragmentation creates a data problem that vendors have little incentive to solve. Each tool buries your conversations in its own undocumented local format: SQLite databases with shifting schemas, nested JSON trees, JSONL session files, or—in the case of terminal tools like Aider—scattered Markdown transcripts tucked inside individual project directories. When you want to fine-tune a model on your own coding patterns, audit your prompt history, or simply back up years of problem-solving before an app update wipes its local cache, you are stuck performing manual archaeology on your own hard drive. A growing chorus of users is already asking how to export chat history to train custom GPTs or build specialized models [11], but the tools themselves offer no escape hatch.

Forensic Extraction as Infrastructure

The ai-data-extractor toolkit treats this mess as a filesystem forensics problem. It is a collection of Python scripts—standard library only, no external dependencies—that auto-discovers and normalizes chat history from ten distinct AI coding assistants into a single JSONL schema. The supported list reads like a market map of the current AI coding landscape: Claude Code, Codex CLI, Cursor, Windsurf, Trae, Continue, Gemini CLI, OpenCode, Cline/Roo Code, and Aider.

The technical premise is straightforward but labor-intensive. The toolkit detects the host operating system, builds a list of plausible application-data roots across macOS, Linux, and Windows conventions, then searches each root for known folder names. Once it locates a tool’s storage, it reads the native format—JSONL line-by-line, SQLite via read-only connections, JSON trees, or Markdown transcripts—and normalizes the contents into a consistent conversation schema. That schema preserves not just the text of user and assistant messages, but also code context with file paths and snippets, suggested edits and diffs, tool calls and their results, timestamps, session IDs, project paths, and model names. The only guaranteed fields across all sources are messages, source, and session_id; everything else depends on what the vendor actually bothered to store.

The Undocumented Schema Arms Race

Where the project gets technically interesting is in its handling of opacity. Cursor, Windsurf, and Trae do not publish their storage schemas, and Cursor’s SQLite layout has changed at least three times: from workspace ItemTable chat storage, to inline composer arrays, to split bubbleId composer keys. The Cursor extractor implements all three shapes explicitly. For Windsurf and Trae, which are similarly secretive about their SQLite layouts, the toolkit falls back to a generic heuristic that scans key-value stores for objects shaped like role-plus-text pairs. The authors are candid about this limitation: it is “honest best-effort,” and future updates that stop matching the heuristic are expected rather than surprising.

Then there is Aider, the popular terminal-only pair-programming tool, which breaks the entire mental model of centralized application data. Aider maintains no global session database; instead, it drops a .aider.chat.history.md file into every project directory it touches. The toolkit handles this by scanning common project-root names up to five directories deep, or by accepting explicit search paths. Including Aider serves a deliberate architectural purpose: it proves the toolkit generalizes beyond the “SQLite or JSONL in one app-data folder” pattern that dominates the rest of the list.

Cline and its fork Roo Code represent yet another pattern. As popular open-source autonomous coding agent extensions, they store raw Anthropic-format message arrays per task. Their extractor doubles as the simplest reference implementation for parsing that format, making the toolkit extensible for developers who want to add support for new tools. Every extractor conforms to the same two-function interface—find installations, then extract conversations—so adding a new source is a matter of implementing a directory search and a format parser.

Why Now? The Personal Training Data Imperative

The timing of this utility is not accidental. Developers are increasingly treating their conversation history not as ephemeral prompts but as a personal dataset—a record of debugging reasoning, refactoring decisions, and domain-specific problem-solving that is potentially more valuable for fine-tuning than any generic instruction dataset. The normalized JSONL output is explicitly designed for this pipeline: timestamped files that can be loaded directly into machine learning datasets, filtered for assistant turns, and formatted with chat templates. The repository’s MIT license explicitly permits use for training machine learning models.

This shift reflects a maturation in how developers interact with coding assistants. The first wave treated AI chat as disposable Q&A. The current wave recognizes that months of paired debugging, architectural debate, and incremental refinement constitute a behavioral fingerprint. Reclaiming that data from proprietary silos turns it into portable training fuel.

Brittleness, Privacy, and the Maintenance Treadmill

The project is admirably frank about its rough edges. Because it relies on reverse-engineering undocumented formats, it lives on a maintenance treadmill. A Cursor update that renames a SQLite column or restructures its JSON composer storage will break extraction until the script is patched. The heuristic extractors for Windsurf and Trae are even more fragile, scanning for key hints that may vanish in the next release. The toolkit mitigates runtime failures by opening every database read-only and wrapping readers so that one corrupt or locked file cannot crash the entire run, but semantic breakage—silently missing conversations because a schema changed—is harder to guard against.

Privacy is another acknowledged minefield. The extracted data frequently contains proprietary code snippets, API keys, and absolute file paths embedded in code context and tool use fields. The toolkit warns users to scan for secrets before sharing or training on the output, and it keeps the output directory in .gitignore by default. It never writes to source databases, but the responsibility for sanitization remains entirely with the user.

The Outlook: Data Liberation in the Agentic Era

As AI coding tools proliferate from inline completions to autonomous agents, the question of who owns the interaction history becomes more urgent. Vendors benefit from lock-in; your prompts and their responses stay inside their ecosystems by default, stored in formats that change without notice. Projects like this one—along with related efforts that have attracted significant community attention [6]—treat local storage as a rightful source of truth that users should be able to extract, inspect, and repurpose.

The unresolved tension is whether this remains a perpetual game of catch-up or evolves into something more stable. If the major tools begin offering native, structured export APIs, the need for filesystem archaeology diminishes. Until then, the toolkit serves as both a utility and a quiet argument for data portability: your coding conversations belong to you, even when they are hidden in undocumented SQLite tables and scattered Markdown files.