thread-archive 0.0.2__py3-none-any.whl

thread_archive-0.0.2.dist-info/METADATA

@@ -0,0 +1,296 @@
+Metadata-Version: 2.4
+Name: thread-archive
+Version: 0.0.2
+Summary: Serverless-native local archive for AI conversations: JSONL truth log + rebuildable SQLite index, searched and read locally, exposed over MCP.
+Project-URL: Repository, https://github.com/ellamental/thread_archive
+Project-URL: Changelog, https://github.com/ellamental/thread_archive/blob/main/CHANGELOG.md
+Author: Ella
+License-Expression: MIT
+License-File: LICENSE
+Keywords: archive,conversations,jsonl,mcp,serverless,sqlite
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Text Processing :: Indexing
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Requires-Dist: leidenalg>=0.10
+Requires-Dist: mcp>=1.0
+Requires-Dist: networkx>=3.2
+Requires-Dist: numpy>=1.26
+Requires-Dist: python-igraph>=0.11
+Requires-Dist: scipy>=1.11
+Requires-Dist: sqlalchemy>=2.0
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Provides-Extra: embeddings
+Requires-Dist: einops>=0.7; extra == 'embeddings'
+Requires-Dist: sentence-transformers>=3.0; extra == 'embeddings'
+Description-Content-Type: text/markdown
+
+# thread-archive
+
+A serverless-native, single-user local archive for AI conversations.
+
+It watches local AI-tool stores, imports provider transcripts into one event
+model, writes an append-only **JSONL truth log**, rebuilds a **SQLite** index from
+that truth, and searches/reads conversations locally — exposed as a Python library
+and over MCP (`thread_search`, `thread_read`).
+
+There is one storage/runtime path: **JSONL + SQLite**. No Postgres, no Neo4j, no
+external search engines, no ops service. JSONL is truth; SQLite is a rebuildable
+projection — deleting `index.db` and running `archive reindex` loses nothing.
+
+It is a standalone, dependency-free package: a conversation-archive engine with
+no server, no external services, and no ties to any host application.
+
+## Install
+
+Needs Python ≥ 3.11. Installs the `thread_archive` setup command, the
+`archive` operator CLI, both MCP servers (`archive-mcp`,
+`archive-librarian-mcp`), and the pre-built web viewer — no node.
+
+```bash
+pip install thread-archive                 # lexical core (+ Leiden community detection)
+pip install 'thread-archive[embeddings]'   # optional: local semantic search (heavy: torch)
+thread_archive                             # then: run setup
+```
+
+`thread_archive` is the front door. On first run it discovers this machine's
+conversation stores and shows what it found — counts, sizes, date ranges —
+*before* touching anything, then asks: import (all, a selection, or skip),
+install the always-on watcher (macOS LaunchAgent; includes the web viewer at
+:8787), and wire the MCP servers into detected clients (the `claude` CLI, or
+it prints the JSON block for any other client). Every choice is skippable and
+persists in `<home>/config.json`; a disabled source stays disabled across
+every ingest path. Re-running `thread_archive` shows status; `thread_archive
+setup` revisits the choices. Non-interactive (agents, scripts):
+`thread_archive --yes` accepts every default — without `--yes`, a non-TTY run
+only prints guidance and never ingests.
+
+Skipped the watcher? Still covered: `archive-mcp` cohosts **lazy catch-up
+ingest** — a background pass at startup and (throttled) around tool calls
+imports whatever landed in your local AI-tool stores since the last pass. On
+a fresh archive give the first pass a minute to chew before expecting search
+hits; the watcher install (`thread_archive setup`, or `archive daemon
+install`) is the always-fresh upgrade. With the daemon installed, the MCP
+servers' lazy passes degrade to no-op lock probes — exactly one process
+ingests at a time, however many Claude Code sessions are open.
+
+**The clone path — for curation.** Clone the repo, open it in Claude Code, and
+say *"install this — follow claude-install.md"*. The clone carries what a pip
+install doesn't: the `.mcp.json` template and the `/librarian` skill (+ its
+enforcement hook) that drives topic-graph curation. Take this route when you
+want the knowledge layer worked, not just search.
+
+```bash
+git clone https://github.com/ellamental/thread_archive.git thread-archive && cd thread-archive
+claude     # then: "install this, following claude-install.md"
+```
+
+**Manual path (from a clone).**
+
+```bash
+python3 -m venv .venv
+.venv/bin/pip install -e .                 # lexical core (+ Leiden community detection)
+.venv/bin/pip install -e '.[embeddings]'   # optional: local semantic search (heavy: torch)
+.venv/bin/pytest tests/ -q                 # confirm green (add `-m package` for the wheel/sdist release lane)
+
+# wire the two MCP servers into this clone's .mcp.json (absolute venv paths)
+sed "s|ABSOLUTE_REPO_PATH|$(pwd)|g" .mcp.json.example > .mcp.json
+
+# bring conversations in, then check
+.venv/bin/archive watch --once             # or: archive import <path> --provider <name>
+.venv/bin/archive status
+```
+
+Restart Claude Code in the repo so it loads `.mcp.json` (the search + librarian MCP
+servers) and `.claude/` (the `/librarian` skill + its enforcement hook). Then curate the
+topic graph — `/librarian` interactively, or for a large backlog the bulk driver:
+
+```bash
+.venv/bin/python scripts/librarian_backfill.py --workers 4 --batch 25
+```
+
+## CLI
+
+Two commands, split human from operator. **`thread_archive`** is the human
+front door — first-run setup (discover → consent → import → watcher → MCP
+wiring), then the status view; `thread_archive setup` re-enters the flow.
+**`archive`** is the operator seam:
+
+```bash
+archive import <path>     # import a transcript / provider store
+archive watch             # watch local AI-tool stores and import incrementally
+archive reindex           # rebuild index.db from the JSONL truth directory
+archive verify            # integrity check: truth parses + matches the index
+archive repair            # quarantine damaged truth lines; restore committed content from the index
+archive backup <dest>     # mirror the truth dir (keeps hardlink generations under <dest>/.generations)
+archive restore-drill <dest>  # prove the backup restores: rebuild an index from the mirror + smoke read/search
+archive nightly <dest>    # the scheduled pipeline: backup → verify (age-gated escalation) → restore drill
+archive status            # archive health / counts / last verify + backup + drill outcomes
+archive daemon <action>   # macOS: install/uninstall/restart/status the always-on watcher LaunchAgent
+```
+
+The CLI is private operational tooling (see Stability below) — the process
+seam the LaunchAgents, cron, and operators use. Retrieval deliberately has no
+CLI verbs: search and read are the public `archive-mcp` tools, and the web
+viewer is cohosted by `archive watch --web`.
+
+## Layout
+
+```text
+src/thread_archive/
+  _api.py           # internal coordination layer the CLI / MCP / web call into
+  cli.py            # the `archive` command
+  _setup/           # the `thread_archive` command: first-run setup + status
+  _config.py        # truth dir + index path resolution, config.json (source opt-outs)
+  _store/           # SQLite store + schema
+  _truth/           # JSONL truth log + reindex
+  _importers/       # incremental import orchestration
+  _retrieval/       # FTS5 + vector search, read reconstruction
+  _knowledge/       # topic graph: event-sourced curation + Leiden analytics
+  _watcher/         # local-source watcher (self-feeding ingest)
+  _mcp/             # library-native MCP servers (read + librarian)
+  _web/             # read-only viewer: stdlib server + built bundle (cohosted by `watch --web`)
+  _launchd.py       # `archive daemon`: generates + loads the watcher LaunchAgent (macOS)
+  _thread_import/   # vendored provider parsers (a clean, dependency-free island)
+frontend/           # the viewer's React+Vite source (dev-only; builds into _web/static/)
+host/               # operator layer: Makefile over `archive daemon`, backup agent, family-manifest writer
+scripts/            # operator tools (e.g. the librarian backfill driver)
+tests/install/      # isolated Docker install test + fixtures
+```
+
+## Stability
+
+The public API is exactly two things:
+
+- **the retrieval MCP tools** — `thread_search` and `thread_read`, served by
+  `archive-mcp`;
+- **the on-disk truth format** — versioned by `manifest.json`'s `version` and
+  specified in [docs/format.md](https://github.com/ellamental/thread_archive/blob/main/docs/format.md).
+  Data written by one release
+  stays readable by the next; a reader refuses a truth directory newer than it
+  understands. Programmatic read access to the documented stores (`index.db`
+  is plain SQLite; the truth directory is documented JSONL) rides on this
+  contract.
+
+Everything else is private support machinery and may change without notice:
+the `thread_archive` and `archive` CLIs, the librarian MCP server, the web
+viewer, and every Python module — there is **no public Python API**. More surface gets exposed
+deliberately as it matures. `tests/test_public_api.py` ratchets the boundary.
+
+## Web viewer
+
+The always-on watcher cohosts a local search + reader UI: `archive watch --web`
+(the shipped LaunchAgent passes it) serves at `http://127.0.0.1:8787` — a stdlib
+HTTP server handing out a pre-built React bundle plus a few JSON endpoints, in
+the watcher's *own* process. One process, one SQLite engine — the viewer reads
+concurrently with the watcher's writes, which WAL makes safe (`store/_base.py`).
+No second daemon, and no standalone `web` verb: the viewer exists where the
+persistent URL is.
+
+**Runtime is node-free**: the bundle is built ahead of time and committed under
+`web/static/`, so `pip install` never touches node. Node is a *build*-only tool:
+
+```bash
+# rebuild the bundle after editing the frontend (node only here):
+cd frontend && npm install && npm run build   # → ../src/thread_archive/web/static/
+```
+
+**Archive-links.** With that persistent server, the archive owns the editor
+"open this conversation" link itself: `GET /api/archive-link?id=<session-uuid>&source=claude-code`
+resolves the session to its thread via `ImportState` and returns `{thread_id, url}`,
+or `&redirect=1` → a `302` to `/archive/<id>`. (Local — no separate backend
+involved.) `id` may repeat — a caller that cannot tell which uuid it holds is the
+session id sends every candidate, best guess first, and the first that resolves
+wins; ids that were never imported are skipped, not fatal.
+
+## What it does
+
+- **Ingests 9 providers** into one event model — Claude Code, Codex, Grok, Antigravity,
+  cloth, Cowork (transcript line-streams) and Cursor, OpenCode, Claude Science (SQLite
+  scanners). Imports are idempotent, atomic, and survive a full reindex losslessly. A
+  `cc-exthost` watcher also recovers mid-turn Claude Code steering messages that never
+  reach the session JSONL.
+- **Self-feeds** — the watcher tails local stores and ingests incrementally; events land
+  in the JSONL truth *before* their commit (no checkpoint in the hot loop). Zero-daemon
+  by default (`archive-mcp` cohosts lazy catch-up ingest), with a one-command macOS
+  LaunchAgent upgrade (`archive daemon install`) for always-fresh — no external service
+  either way.
+- **Declares itself** — the installer writes the thread-family manifest
+  `<home>/product.json` (`host/write-manifest.py`; `make install-agent` runs
+  it), so family consumers discover the archive by enumeration. Spec:
+  `docs/spec/product-json.md` in the thread monorepo.
+- **Searches locally** — FTS5 lexical (boolean / phrase / pipe-OR / code-identifier),
+  optionally fused with local semantic vectors and a cross-encoder re-rank; plus
+  transcript reconstruction for reading.
+- **Rebuilds losslessly** — `rm index.db && archive reindex` reconstructs the entire
+  index from the JSONL truth; a `cp`/`rsync` of the truth dir *is* the backup.
+- **Curatable** — an event-sourced topic graph with Leiden communities (see below),
+  driven on demand by the `/librarian` skill.
+
+## MCP
+
+Two servers, split read from write. **`thread-archive`** (`archive-mcp`) serves the
+read-only tools — `thread_search` / `thread_read` — and cohosts lazy catch-up
+ingest in its own process (throttled, cross-process-safe via the ingest-owner
+lock; `THREAD_ARCHIVE_MCP_INGEST=0` disables it). **`thread-archive-librarian`**
+(`archive-librarian-mcp`) is the curatorial *write* surface — topic/link/citation
+writes + the reads a librarian needs (`review_queue`, `topic_search`,
+`thread_user_messages`). Keeping them separate means a read-only client never gets
+curation power. Client config:
+
+```json
+{
+  "mcpServers": {
+    "thread-archive": {
+      "command": "archive-mcp",
+      "env": { "THREAD_ARCHIVE_HOME": "~/.thread/archive" }
+    },
+    "thread-archive-librarian": {
+      "command": "archive-librarian-mcp",
+      "env": { "THREAD_ARCHIVE_HOME": "~/.thread/archive" }
+    }
+  }
+}
+```
+
+## Knowledge layer (the topic graph)
+
+There are exactly two kinds of thread: imported **conversations** and curated **topics**
+(`thread_type='topic'`). A topic is modeled as a thread on purpose — so the graph's edges
+(`thread_links`) and message→topic citations (`topic_messages`) reference one id space.
+Reads/analytics live in the knowledge layer (`_knowledge/`) — PageRank,
+communities (**Leiden**, the algorithm Neo4j GDS ran, with a networkx-Louvain fail-soft
+fallback), bridges, peers.
+
+Curation is **event-sourced**. Every write (`create_topic`, `link_threads`,
+`add_topic_evidence`, `merge_topics`, …) appends a `KgEvent` to an
+append-only `truth/kg_events.jsonl` and folds it into the SQLite projection in one
+transaction. The log is the source of truth for curation; `thread_links` / `topic_messages`
+are rebuildable from it — `reindex` replays the log (idempotent upsert + tombstone) to
+reconstruct them, so an unlink/merge/archive is recorded history, never silent loss. The
+librarian skill (`.claude/skills/librarian/`) drives the write MCP to clear the
+citation backlog on demand (a conversation is 'reviewed' once it gains its first
+citation/link — there is no per-thread summary).
+
+## License
+
+MIT — see [LICENSE](https://github.com/ellamental/thread_archive/blob/main/LICENSE).
+
+## Origin
+
+thread-archive is the standalone member of a larger personal project ("thread"), built to
+stand on its own — serverless, dependency-free, no backend or external services. The
+package is self-contained, but it's young: expect the occasional rough edge or stray
+reference to its parent project.

thread_archive-0.0.2.dist-info/RECORD

@@ -0,0 +1,132 @@
+thread_archive/__init__.py,sha256=1YtZeHc1ZrjnIZde0t1QkUPEqRPGaorkzRpsaHEJGEM,1581
+thread_archive/_api.py,sha256=VHR198pQUEt1EJBc5PXBVqugxEkEBIIp_qWDYUmkJiY,103578
+thread_archive/_config.py,sha256=51DKgkYDTY88KVxotc5-Va4pxjNG0fOvQhojuV6aquU,4795
+thread_archive/_launchd.py,sha256=Cr9AeUXCLn4bIm0H2B4VtyXbgXoQfVA0hPoWJw1p6Tg,5887
+thread_archive/cli.py,sha256=gCrim9tkPpc7EEjYzqDRGDJszU7xpgHp110HjnvB2vo,31582
+thread_archive/_importers/__init__.py,sha256=E8F5-GwjQh8upq-kxCSRDAbyAOo5zUbgDkdOkpp8NxY,2709
+thread_archive/_importers/_continuation.py,sha256=XAyG-THeOIaWWdwGz8JfDLySqtAbBv3U99inVTxOZQw,5522
+thread_archive/_importers/_cursor.py,sha256=3Izh5SS9tSX6pq3V_ycxUG86EZ0YhQ8jAnb6ODtqGCo,4545
+thread_archive/_importers/_events.py,sha256=79mzog_ftaAW_J5ELc_vTvLCvwXB6ET9lNDG18MAF-w,9713
+thread_archive/_importers/_line_stream.py,sha256=d8uQBLViIblb8Pl1NN8TbOx9-aU5Q5kzu62mL-wXJ4A,6790
+thread_archive/_importers/_read.py,sha256=OzgqxJkGvoO5siBoa6dGT2GAfoCbFtYCg4OHDUejYn0,3201
+thread_archive/_importers/_result.py,sha256=Uko5Vi97SHk5hEPnhisiN-Qp8meq2PhlResc2FCRmro,379
+thread_archive/_importers/_sidecar.py,sha256=SxW_Gm2wrJicXkzGFPsoF32D4nBbi2EJos1sly-zIRU,3993
+thread_archive/_importers/_state.py,sha256=jqrniKpnNovskFHkuCoBODI6Eil9WqqUF11IaLgBvgw,9294
+thread_archive/_importers/_titles.py,sha256=PRtiAEq3w5cZaxF3i9HnGKtRPfT8E-jvarFHrT3lmFM,7124
+thread_archive/_importers/antigravity.py,sha256=O0_Bts8Ak8PTi1xpk0GzWATagwy7cYyT0f035jwzRVk,9488
+thread_archive/_importers/claude_code.py,sha256=Bqz3tmhhCfsoWZQEt-3sEyOm9EDukgPd1wBhomknS74,12486
+thread_archive/_importers/claude_science.py,sha256=bS6tpSwW_q3N9nm1d5DA2ZUy2Ekg3M0fgEpq1OLUZDU,13321
+thread_archive/_importers/cloth.py,sha256=Xwy8nqkVPeEEs42x7tHSkUB4X_guY8P4aXSmBniNvUg,1107
+thread_archive/_importers/codex.py,sha256=YuB5SjwxCheixbSAqUxDVxsqnw7DNCfc3FE-vBXmztI,11915
+thread_archive/_importers/cowork.py,sha256=vwlEefqMoKmbn9YZUYz7QD6DxhXfQ_4wFFpRRWxmUyQ,4222
+thread_archive/_importers/cursor.py,sha256=DAGR30vsKLN8UHpTxikTuXQXB_-QY8cQ0-OLCelNaUg,17695
+thread_archive/_importers/exports.py,sha256=LmUI4Ip-Mxy71pIyzy5gFHP5cIibvp-RevdeJxBP1OE,16154
+thread_archive/_importers/grok.py,sha256=4VQg7sIrKXjyz8DhhnEFoa5GCPhcCJKEB1mn4_mG9_E,22079
+thread_archive/_importers/opencode.py,sha256=NG-tFmb6FjpQWM3W0N9xuJZrRiGc0kQx8SPWUwM8-P4,22949
+thread_archive/_knowledge/__init__.py,sha256=cnSYqwdQ87c1jekkl_DxoSW5wX9sKGXQ-g4vp8qyUNo,1825
+thread_archive/_knowledge/_claims.py,sha256=3_usBaoTSjqYD-9qol3y1oSQPlYJt1qVf_EfDKx2YwA,4484
+thread_archive/_knowledge/_community.py,sha256=SspOc0H3kFEY1dowlYEIKaU_IerSZ8md2oqqTO0my04,3030
+thread_archive/_knowledge/graph.py,sha256=bP34HkFCndcXkSrqqNOMYxf0ve9BxcYURLt7yoCldug,7437
+thread_archive/_knowledge/materialize.py,sha256=s9bbiLMN2zBtoAoz2ChOGQn0k8jQkLy6GvHnukKXifM,9273
+thread_archive/_knowledge/write.py,sha256=KcOZtDoFSzlA-XG1SDz3AcbuISiZ29hZ3x5CaBpFsM4,19193
+thread_archive/_mcp/__init__.py,sha256=6PSpxiOHcC2T8kz3HeYhLOJRtwuTBnxzv88WRsvVPDo,89
+thread_archive/_mcp/librarian.py,sha256=vMmNlfcYjmecGhn1g_CIHVGO20uqTjEXb6Yx4RLG1uc,6094
+thread_archive/_mcp/server.py,sha256=mjE9ENyxYCzUdhgMuXtY6xklKvB36ug_4vVxdRG1-IM,14577
+thread_archive/_retrieval/__init__.py,sha256=xv2EMZrtMQ1JTqqptFOa8ht4a5ghcw4-vmqp5Q7iyuI,13355
+thread_archive/_retrieval/_classify.py,sha256=bUMTHTkZXUs-bg945sBIgUAIFg-abPMPmSZLCt7aNZI,3053
+thread_archive/_retrieval/_codex.py,sha256=0RTn90Etdz8nr6e56KQEGClieNK_32WorAQQsPhHO78,6199
+thread_archive/_retrieval/_context.py,sha256=b3mXGaxMag90vlSgEm7PiwrveD4HyT4A88Re-8rFBv4,5199
+thread_archive/_retrieval/_extract.py,sha256=Gj5TAZSfHVu3mMB4FD5ECZ5HsVTt_58Js4-ln0OZJ8I,7506
+thread_archive/_retrieval/embed.py,sha256=_lhaWkEwmocF3lksjvQIUt5qzmXoIeFrIhsyVShiAkY,7304
+thread_archive/_retrieval/format.py,sha256=gwTRut2Z-8TZzXHAXdvBSMw353sOEoEZj8PJkBCrNP0,5803
+thread_archive/_retrieval/fts.py,sha256=MOfBVhcIKal_MZuQm7WXOBCh0ZKm08O0ylqIzNQ6eTA,23647
+thread_archive/_retrieval/rank.py,sha256=xNl35MUGY3KQhDShsmEHZrPnfKul3uykV_pO4io1jP8,10268
+thread_archive/_retrieval/read.py,sha256=jD2QGWzPazaqsP3H138suBnZxFIev0RqJdJL0mn6vlg,40982
+thread_archive/_retrieval/rerank.py,sha256=q2x5_p7gxv6y6ReuNB2rODGC2-PtUGfWA0U1qIq2YA4,5604
+thread_archive/_retrieval/vectors.py,sha256=0HDlcSkH3AR_6Y4nH0DkeUvTcaYZtCE5Gp9vIoF1drA,26391
+thread_archive/_scripts/__init__.py,sha256=BawS1JIk0h9jfCS39xSZVmxL5f_wK9CsVhgiob6BztM,63
+thread_archive/_scripts/backfill_recompute.py,sha256=--rYFaZijXt1ySWWmmRzelEemXrOjUgoC1wfQYUAe-c,16322
+thread_archive/_scripts/backfill_reconcile.py,sha256=5BkG2FwXb-n2qrbyjoGOPtAWD7x0CrgC1lo63FDiRwY,13285
+thread_archive/_scripts/denamespace_dedup_keys.py,sha256=70z_ESpq8sKhbk0DvbdfLY_niceBGeoNhFAPvZ0vb4U,5211
+thread_archive/_scripts/recover_dropped_events.py,sha256=2_lCwMjow8XZwRnyU5Ch8i3lua2f7j--hTw4Xw-s2qE,8562
+thread_archive/_scripts/repair_grok_tool_names.py,sha256=f5oBLIC6phCUgJ5uT0p1wx8_N126gltI3JgfUSinPTw,5253
+thread_archive/_scripts/repair_grok_tool_names_backup_20260704T155625Z.json,sha256=2T05ysx16NFvn5B3nTbNdTm-fcz3dF9lRy74Ae9PvaU,42961
+thread_archive/_scripts/repair_grok_tool_names_plan_20260704.json,sha256=gCVYZKLAzhOnWuMskkP09FhygzLg1Ju9sKuK2EZTnOs,163203
+thread_archive/_setup/__init__.py,sha256=qPb6X0ydZAix5afnprGNeB3zD1R0mSHx6hmNCeeQbsM,367
+thread_archive/_setup/clients.py,sha256=ETGbNcsFKUzuCXUspEJbJo_1WacI4rM3qTuSj_9uLQQ,3088
+thread_archive/_setup/wizard.py,sha256=gcrIMHGBTnrvc4TiPPmd6Yi6LOXm3kKOatywP0vo9I4,20003
+thread_archive/_store/__init__.py,sha256=5cyA3Ym9A09I3WoGl9X-7BcaV5OeV428gKwgCDRpu5k,863
+thread_archive/_store/_base.py,sha256=eAQ8rRFZPkn3kS5QYh1bg2pfbalqa35CmfsxbBEOBMM,5838
+thread_archive/_store/_defaults.py,sha256=Ka7FhzF52pIG9hL1OaKXsPFHeOYp2VP9KxowACGOODA,1497
+thread_archive/_store/_types.py,sha256=x5RU9vCCAReplCKpIkTaG9ig0YCD44svfQgHSSY-GdM,1828
+thread_archive/_store/models.py,sha256=Wvd-Em8A3JQi1s20o2_ZKsjdCmKOcgyoZ_x-AjXVf6c,18496
+thread_archive/_store/schema.py,sha256=6Fl9GsluiTJSodi44qVxpvkP1YTg6oNRISlt75iS_xg,3699
+thread_archive/_thread_import/__init__.py,sha256=0jBlCqhcygUcIqFm8sKJ6AY59N8UeHRAUeqlyWpk9Gw,1177
+thread_archive/_thread_import/api.py,sha256=zLEoSmuEy51FZG_VYuvbZFt84bI6yg-1b8JVOk7xoGs,2314
+thread_archive/_thread_import/event_builder.py,sha256=nNPEn0N-fokyNkBBUzpteOc7hJd2KpXziu5XjatS2gM,33209
+thread_archive/_thread_import/timestamps.py,sha256=QB1rUK0BMMaGs5Y5uN7mrLPdBE0V7CYNRoV5x-1O_O4,2030
+thread_archive/_thread_import/tool_names.py,sha256=SppZCIvgxC1cjQmxkLdnss9E3J7u9io2Eh0vO44vy54,1696
+thread_archive/_thread_import/exporters/__init__.py,sha256=lQy_oUdYkXXEUzEfhq96Va5BXnh3a0MaORcJZ83Vp18,155
+thread_archive/_thread_import/exporters/_cursor_kv_mixin.py,sha256=c3-QzLAmEL16V6Cow53Cdvn5Oh-7Ip2DkMiDMsk8ELA,6209
+thread_archive/_thread_import/exporters/_cursor_parse_mixin.py,sha256=dmKfno75SgnIqS0LafugVQJysT3_6TJRN_5IC6DP_iI,5970
+thread_archive/_thread_import/exporters/cursor.py,sha256=BvRY_OiQXFqpd5_5a7cv1a8GrCxnBhv4HkOD0D2CEfE,21011
+thread_archive/_thread_import/exporters/cursor_parse.py,sha256=Vgb2Y5prKfKHXMAoDT9ZS6IBGOJL-sPfXCLKnSCwWRE,5129
+thread_archive/_thread_import/parsers/__init__.py,sha256=djz7PVrCUMF57IQh2JAAaqR13C-rKfzjxgNKLyPrHts,4683
+thread_archive/_thread_import/parsers/base.py,sha256=S1vLZg5w7R07C1pxddSmNFU6awTHNH3Hg-KmLW4qglY,24065
+thread_archive/_thread_import/parsers/chatgpt.py,sha256=32uxzpOSPyZ1ZgexwKajYza0pJO_dKaRh8lzjpHYJ5Q,27899
+thread_archive/_thread_import/parsers/chatgpt_content.py,sha256=YhwZiJQb2f34g6fQjfP0nUmbYdAQ7UeZsIsdjwhLzTc,11473
+thread_archive/_thread_import/parsers/claude.py,sha256=S8YRq8oaU7hEtEBxdr1w0denorgv1pXz9U2mZBWLK3o,16594
+thread_archive/_thread_import/parsers/claude_code.py,sha256=J9fXP9bVaccqAJ0bY28z9KT7Cp-0ZtCd6FdXaAyYi7Q,42236
+thread_archive/_thread_import/parsers/claude_code_blocks.py,sha256=RMjjYaIBGpQpJEh6Mwgh2mF6wVukaBCviaJQzyXeV3E,15296
+thread_archive/_thread_import/parsers/claude_code_ide.py,sha256=JjVWdpkPxBiM8exQwZ3yA0aKIEIvd8FEmY8QNMfH6NI,4509
+thread_archive/_thread_import/parsers/claude_code_sessions.py,sha256=1FPnWyPTEnhLHqVU9qg9B54OJPLFqivUn-WKcXhQ5z8,2911
+thread_archive/_thread_import/parsers/cursor.py,sha256=3UTCfiDinW_razvdO46dC_O4tqayl8Ts9DzLWWcnwkc,18845
+thread_archive/_thread_import/parsers/cursor_blocks.py,sha256=zDto4MkmFzi-5Q0Y0qoKiWdKdxxonInb39HjTH-EZU4,13650
+thread_archive/_thread_import/parsers/config/__init__.py,sha256=a2sScw18UxdsCjxt9Z_TkEHq_XJD5RICzlDuqpxlWW8,543
+thread_archive/_thread_import/parsers/config/base.py,sha256=XkWanwBbXPzkMGcwVX1Howr8pkhiatUpDTwYM8I7CdI,7184
+thread_archive/_thread_import/parsers/pipeline/__init__.py,sha256=gE3A8Zp8v-BHraL091WrmTbgbwf5DSPN7KFVtsHyUq0,698
+thread_archive/_thread_import/parsers/pipeline/base.py,sha256=XOKGnVcnXI4tMFWB3tz1a-Znib2sHAOnwC2NCPs_1Uw,8081
+thread_archive/_thread_import/parsers/pipeline/interfaces.py,sha256=94lQs_eocP8BHYggo4V-8VExa-9fTrzyIwfcNQ_4fi4,6139
+thread_archive/_thread_import/parsers/transformers/__init__.py,sha256=Bsv_BmGcS_lEPGN_ocFzE_OwoW9HRncYNSk_iuhqxEA,633
+thread_archive/_thread_import/parsers/transformers/active_path.py,sha256=S7Wz4BQ96IKoM0QKVXAc_GMOxdTGFIyafMWJ681c8Yo,2792
+thread_archive/_thread_import/parsers/transformers/coalescing.py,sha256=SWLOCHGFBTq1pHCFfV364JhWXtjLkwWVYtY2KW4Vk5E,13470
+thread_archive/_thread_import/parsers/transformers/ide_context.py,sha256=djA0VFa_s9VE5BvfU20WrT20NxVqjyVqYxJ3wdxbHTE,5227
+thread_archive/_thread_import/parsers/transformers/thinking_merge.py,sha256=0pBAd1-t96cHc2u_KZxB1PDnYRnycSNj9cFaOiy8SzY,2374
+thread_archive/_thread_import/parsers/types/__init__.py,sha256=6NLXrGmSChcN63qRBSyz0eWUEkq00vhOa8oLl9-FXtU,1136
+thread_archive/_thread_import/parsers/types/chatgpt.py,sha256=MGWK5gi0Gbs6J1ZRB7j7iOkdtr7Al6PaclMxqURcKoU,3283
+thread_archive/_thread_import/parsers/types/claude.py,sha256=vEnd3wlRLIqNuzA0HUQ_CRY7lb4FHrD1Xc9PRgLjgAQ,3628
+thread_archive/_thread_import/parsers/types/claude_code.py,sha256=Ql_JfUiQ4Z36z9GImJsWAF5HYykcjZpEKi1UzIPa7c4,4627
+thread_archive/_thread_import/parsers/types/cursor.py,sha256=bOty8b070yGNE6amgdAvWxOTA9teN1VIDHxviKl7ajw,3867
+thread_archive/_thread_import/parsers/validators/__init__.py,sha256=RuMVB7DeGIAb8HO5cY4S-eey8r62l85WHgcX4TZAYPo,3272
+thread_archive/_thread_import/parsers/validators/base.py,sha256=VieqEJLc6daZDOrVyF_s-IdoM5jcvYJjgHWOQVJ1kIQ,5223
+thread_archive/_thread_import/parsers/validators/content.py,sha256=9eB4UOedRMaKgOBYy7qubQQUT4qj0cDWPFGBB3uJtrA,2746
+thread_archive/_thread_import/parsers/validators/referential.py,sha256=01i8EbOZ9XSDCLsUeGefqeLpX4V7rdhCZsK5RLTqTMo,1936
+thread_archive/_thread_import/parsers/validators/thinking.py,sha256=gqBzN9iVm1FPPzBqnabomAD2jorBY7joVHUySdLTTu4,5351
+thread_archive/_thread_import/parsers/validators/types.py,sha256=qM99w6pIxFRCj66L8P4m3cgh_cQBU_2fLBOid3JLLqg,2810
+thread_archive/_thread_import/schemas/__init__.py,sha256=YK23WcIDX9d8v_YwkmMGVyYnIvcMogZDvrUYIE1wE6c,6905
+thread_archive/_thread_import/schemas/chatgpt/v1.json,sha256=-0g9cpRCdpSUVKTucdgDCERp1mNGgIXg_Yr__CMtLg4,4980
+thread_archive/_thread_import/schemas/chatgpt/v2.json,sha256=EDYDnqalPDGGOPFuWXJVXkp_ns9uZiSJh2qPtWaWEwc,5367
+thread_archive/_thread_import/schemas/claude/v1.json,sha256=vcpuXiDQo7TnLoZ_dB8fA6fXBzlcTwSJqVYrYY1eu_M,4338
+thread_archive/_thread_import/schemas/claude_code/v1.json,sha256=kDLBgIJYCDd66fAnD0ts7SedpeeyhaNbhBFW4fac-3w,4769
+thread_archive/_thread_import/schemas/cursor/v1.json,sha256=YYRP7uCHsPUBErZDY4ayDmKcp1CsGatGLh3tVcx-TWg,3705
+thread_archive/_thread_import/schemas/cursor/v2.json,sha256=XYEZiDoNqgh3yZZBWL8PJrQ7qDC3johTMUnUkwunT1g,5273
+thread_archive/_truth/__init__.py,sha256=AD_01J7xRtoi6Vgsx0VdQgXb4ArzOUbR1hTRkILZ4VM,861
+thread_archive/_truth/jsonl_log.py,sha256=a44C5fnAybZ_hfMqdC-Z3GInv0aTfgPzqXrRSfVrNpg,112625
+thread_archive/_truth/repair.py,sha256=6ucXIdwDfIf9cRFB0d84xhoz_qSRBhJvLYY8inlwl7U,13946
+thread_archive/_watcher/__init__.py,sha256=UrB72M14OMceMnLHb0w5GRv4hRrd6TuEKd_Bk4ZhuZo,1646
+thread_archive/_watcher/base.py,sha256=7Gr8mYatuWNHAhyyTY13qgDjZd5V4VGXxHVoB9USfBI,2090
+thread_archive/_watcher/daemon.py,sha256=LL1Yia61r0SmOSd3yOUj1lMi_f8FwjmVFYRvolRLC7w,14057
+thread_archive/_watcher/export_drop.py,sha256=091W0oSaKk3XAfgNpYLtoHsMQWrXp_-ZXnccsnG8N0U,8299
+thread_archive/_watcher/exthost.py,sha256=mn_tEJ3C-cao1ut4TVrPVhPi0fzvdmG3FVje2_aSW3E,14169
+thread_archive/_watcher/lazy.py,sha256=vIgov52JXvPi6VtK_uD8ExWQPqtmW3QHNry8vjxRSEE,4381
+thread_archive/_watcher/sources.py,sha256=njMKFnmJFqNS3tgae1QrWoFXVBpPl-mtpgeTc26Prt8,24835
+thread_archive/_web/__init__.py,sha256=1V2Wgv6-t4LVSJsqfU5osC6q4JI1ezJ-lnHXtFvnruE,658
+thread_archive/_web/server.py,sha256=nh56fIahpgvLruO-dOgA_8ei-ltVC49rNS7x67YL2G8,12236
+thread_archive/_web/static/index.html,sha256=pirPsnwD7f181FtpGG-4TToCPE-1rlj044ZW30Twn6k,399
+thread_archive/_web/static/assets/index-DECSH1Mz.css,sha256=SFnjTv3L91novFjCV7U1bmdKTBW-J2qFqeO0Jn2X1Ms,9386
+thread_archive/_web/static/assets/index-Djq0FK0y.js,sha256=gOz_YDHPDYrgXFSOg8YyC01VlrEytoiFce81eIsfMAU,511764
+thread_archive-0.0.2.dist-info/METADATA,sha256=Cp370oTP1Cj7c0eBbSmZVKvluGNOGeMEl-oLJUz-b8o,14991
+thread_archive-0.0.2.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+thread_archive-0.0.2.dist-info/entry_points.txt,sha256=QjJSKuUc-5HM01pMPReWzLqTXvPH5HGEScGwAPwuSvM,245
+thread_archive-0.0.2.dist-info/licenses/LICENSE,sha256=XcDY4f99OtZKWxDBAAAasHoz5dgYFAHMdv2X9pjDt-0,1061
+thread_archive-0.0.2.dist-info/RECORD,,

thread_archive-0.0.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

thread_archive-0.0.2.dist-info/entry_points.txt

@@ -0,0 +1,6 @@
+[console_scripts]
+archive = thread_archive.cli:main
+archive-librarian-mcp = thread_archive._mcp.librarian:main
+archive-mcp = thread_archive._mcp.server:main
+thread-archive = thread_archive._setup:main
+thread_archive = thread_archive._setup:main

thread_archive-0.0.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ella
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.