codesift-mcp 0.13.1 → 0.15.0

package/dist/storage/shared-embedding-cache.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, appendFileSync, createReadStream } from "node:fs";
-import { createInterface } from "node:readline";
-import { homedir } from "node:os";
+import { existsSync, mkdirSync, appendFileSync, statSync } from "node:fs";
+import { open } from "node:fs/promises";
+import { homedir, totalmem } from "node:os";
 import { join } from "node:path";
 /**
  * Embeddings keyed by CONTENT, shared across every repository.
@@ -13,26 +13,147 @@ import { join } from "node:path";
  * That is not a marginal cost here. A linked worktree is a separate repo to
  * CodeSift, and its files are usually IDENTICAL to the checkout it came from:
  * `backlog-wave-1-integration` had 1,799 files and differed from main by zero.
- * With 40 worktrees registered, the same text was embedded up to 40 times. Half
- * of the 2M symbols still queued for embedding are worktrees or temp dirs.
- *
- * Auto-indexing no longer creates those entries, but an EXPLICIT
- * `index_folder(path=<worktree>)` still should work — the H19 hint tells agents
- * to do exactly that when they are working in one. This makes that cheap
- * instead of forbidden: the second repo containing a given symbol pays a hash
- * lookup, not a model call.
- *
- * Format: ndjson, append-only, one `{k, v}` per line. Append-only because
- * concurrent writers are the norm (one process per agent window) and appending
- * a line is the only operation that is safe without a lock. Duplicate keys are
- * harmless — the last one read wins, and they carry the same value by
- * construction.
+ * With 40 worktrees registered, the same text was embedded up to 40 times.
+ *
+ * ---------------------------------------------------------------------------
+ * v2: fixed-width binary records. Why the format changed (measured 2026-08-09)
+ * ---------------------------------------------------------------------------
+ *
+ * v1 was ndjson, and it had three defects that together made it a wasted
+ * optimization — it held **4.56%** of the symbol corpus (36,420 of 798,638
+ * vectors) and had not grown since 2026-08-07 despite 35 live processes:
+ *
+ *  1. `appendSharedCache` accumulated the whole batch into ONE string
+ *     (`payload += …`). At ~16,248 bytes per vector line that hits V8's hard
+ *     `MAX_STRING_LENGTH` (536,870,888) at exactly **33,042 entries**, throwing
+ *     `RangeError: Invalid string length` straight into a bare `catch {}`.
+ *     7 of 37 symbol files exceed that ceiling and they hold **64%** of the
+ *     corpus, so the repos that would benefit most were the only ones that
+ *     silently wrote nothing.
+ *  2. Every key was appended whether or not the file already had it: **11.3%**
+ *     of lines were repeats.
+ *  3. Text encoding. A 768-dim float32 vector is 3,072 bytes; as JSON decimals
+ *     it took 16,248. A float32 round-trip of the stored values is bit-exact on
+ *     1,300 sampled vectors, so this was pure waste, not precision.
+ *
+ * Fixing only (1) would have been worse than leaving it broken: the corpus at
+ * v1's density projects to **12.1 GB**, against **2.28 GB** at fixed-width
+ * float32. The V8 ceiling had been acting as an accidental circuit breaker.
+ *
+ * v2 record layout, little-endian throughout:
+ *
+ *     [16 B key][2 B dim][4 B crc32 of the vector bytes][dim*4 B float32 vector]
+ *
+ * The checksum is not ceremony. Corruption injection against the first draft of this reader
+ * (2026-08-09) measured what a record without one costs: two flipped bytes inside a vector were
+ * served as a valid embedding — 1000 of 1000 records "read successfully", one of them silently
+ * wrong — and 99.417% of a 3,090-byte record was payload that nothing verified. A wrong vector is
+ * worse than a missing one: it produces a plausible similarity score instead of a cache miss.
+ *
+ * It also buys RESYNC. That same pass showed one implausible dim byte at record 10 cost 99% of the
+ * file, because the reader stopped rather than guess. With a checksum the reader can skip exactly
+ * one record and carry on, and be right about having skipped it.
+ *
+ * The key is `contentKey`'s 32 hex chars as raw bytes. `dim` is per record
+ * rather than in a header because two models with different dimensions can
+ * legitimately share this file; a header would force one file per model and a
+ * mismatch would be indistinguishable from corruption.
+ *
+ * Append-only is retained deliberately: concurrent writers are the norm (one
+ * process per agent window) and a single `appendFileSync` under `O_APPEND` is
+ * the only write that is safe without a lock. Writes are now CHUNKED to a fixed
+ * byte budget, on record boundaries, so no buffer approaches any engine limit
+ * and a partially-written chunk can never split a record.
+ *
+ * The file remains DERIVED and safe to delete at any time. That is what makes
+ * changing its format cheap: worst case the next index recomputes. There is no
+ * v1 migration for the same reason — the old file is simply ignored, and
+ * whoever wants the disk back deletes it.
+ */
+/** Bump when the record layout changes in a way that invalidates old entries. */
+const CACHE_VERSION = 2;
+/** Bytes of key stored per record — `contentKey` is 32 hex chars = 16 bytes. */
+const KEY_BYTES = 16;
+/** key + dim + crc, before the vector payload. */
+const HEADER_BYTES = KEY_BYTES + 2 + 4;
+/**
+ * CRC-32 of the vector bytes.
+ *
+ * Not cryptographic and not meant to be: the threat is a torn write or a flipped bit, not an
+ * adversary. 4 bytes on a 3,090-byte record is 0.13% for the difference between "this vector is
+ * wrong" and "this vector is wrong and nobody can tell".
+ */
+const CRC_TABLE = (() => {
+    const t = new Uint32Array(256);
+    for (let i = 0; i < 256; i++) {
+        let c = i;
+        for (let k = 0; k < 8; k++)
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        t[i] = c >>> 0;
+    }
+    return t;
+})();
+function crc32(buf, start, end) {
+    let c = 0xffffffff;
+    for (let i = start; i < end; i++)
+        c = CRC_TABLE[(c ^ buf[i]) & 0xff] ^ (c >>> 8);
+    return (c ^ 0xffffffff) >>> 0;
+}
+/**
+ * Largest single `appendFileSync` payload.
+ *
+ * Bounded so no buffer can approach an engine limit as the corpus grows — the
+ * v1 bug was exactly an unbounded accumulator. 8 MiB is ~2,700 vectors at 768
+ * dims: few enough syscalls to be irrelevant, small enough that the ceiling is
+ * three orders of magnitude away.
+ */
+const MAX_APPEND_BYTES = 8 * 1024 * 1024;
+/** Sanity bound on a decoded dimension, so a corrupt byte cannot request a huge allocation. */
+const MAX_DIM = 8192;
+/**
+ * Ceiling on how much of the cache is held resident, in bytes of vector payload.
+ *
+ * This bound is not optional decoration. Until the writer was fixed, appends threw
+ * `RangeError` above ~33k entries into a bare catch, so the file was accidentally frozen at 4.56%
+ * of the corpus and nobody had to think about the read side. Fixing the writer — and adding chunk
+ * texts to the same cache — let it grow for real, and `loadSharedCache` materialises EVERY record
+ * into a `Map` that no budget governs: measured +1.17 GB RSS and a multi-second event-loop freeze
+ * in a long-lived MCP server, on a machine that routinely runs 24–37 codesift processes at once.
+ *
+ * Stopping early is the correct degradation for this structure. The cache is a write-side
+ * optimization whose only failure mode is a cache MISS, so a partially loaded one is still
+ * completely correct — it just recomputes more. That is the same contract as an unreadable file.
+ *
+ * Default is deliberately modest and scales with the machine, matching the embedding/index budgets
+ * (`CODESIFT_MAX_EMBEDDING_MEM_MB`, `CODESIFT_MAX_INDEX_CACHE_MB`). Override with
+ * `CODESIFT_MAX_SHARED_CACHE_MB`; `0` disables the shared cache read entirely.
  */
-/** Bump when the vector layout changes in a way that invalidates old entries. */
-const CACHE_VERSION = 1;
+function sharedCacheBudgetBytes() {
+    const raw = process.env["CODESIFT_MAX_SHARED_CACHE_MB"];
+    if (raw !== undefined) {
+        const n = Number.parseInt(raw, 10);
+        if (Number.isFinite(n) && n >= 0)
+            return n * 1024 * 1024;
+    }
+    const totalGb = totalmem() / 1024 ** 3;
+    const mb = totalGb <= 16 ? 64 : totalGb <= 32 ? 128 : 256;
+    return mb * 1024 * 1024;
+}
+/**
+ * Basename of the cache file this build reads and writes.
+ *
+ * Exported so `prune` can reclaim SUPERSEDED versions without hard-coding a name
+ * that would drift on the next format bump: it deletes every `shared-embeddings.*`
+ * that is not this one. A format bump otherwise strands the old file forever —
+ * nothing opens it and nothing deletes it, because it has no hash prefix for the
+ * artifact sweep to match (1.05 GB measured after the v1→v2 bump).
+ */
+export function currentSharedCacheFilename() {
+    return `shared-embeddings.v${CACHE_VERSION}.bin`;
+}
 function cachePath() {
     const dataDir = process.env["CODESIFT_DATA_DIR"] ?? join(homedir(), ".codesift");
-    return join(dataDir, `shared-embeddings.v${CACHE_VERSION}.ndjson`);
+    return join(dataDir, currentSharedCacheFilename());
 }
 /**
  * Key for a piece of text under a specific model.
@@ -51,46 +172,147 @@ export function contentKey(model, dimensions, text) {
 }
 let memory = null;
 let loadedFrom = null;
+let warnedWriteFailure = false;
 /**
  * Read the cache into memory once per process.
  *
- * Missing file, unreadable line, malformed JSON: all skipped. A cache that
- * cannot be read must degrade into "compute it again", never into an error —
- * it is an optimization, and a broken one has to stay invisible.
+ * Missing file, truncated tail, impossible dimension: all skipped. A cache that
+ * cannot be read must degrade into "compute it again", never into an error — it
+ * is an optimization, and a broken one has to stay invisible.
+ *
+ * A torn final record is the expected failure, not an exotic one: a writer
+ * killed mid-append leaves one. Reading stops at the first record that does not
+ * fit in the remaining bytes and keeps everything before it.
  */
 export async function loadSharedCache() {
     const path = cachePath();
     if (memory && loadedFrom === path)
         return memory;
     const map = new Map();
-    if (existsSync(path)) {
+    const budget = sharedCacheBudgetBytes();
+    if (budget > 0 && existsSync(path)) {
+        let handle;
+        let corrupt = 0;
+        let skippedTail = false;
+        let resident = 0;
+        let stoppedAtBudget = false;
         try {
-            const rl = createInterface({ input: createReadStream(path, { encoding: "utf-8" }), crlfDelay: Infinity });
-            for await (const line of rl) {
-                if (!line)
-                    continue;
-                try {
-                    const entry = JSON.parse(line);
-                    if (typeof entry.k === "string" && Array.isArray(entry.v)) {
-                        map.set(entry.k, new Float32Array(entry.v));
+            const size = statSync(path).size;
+            // Async open/read: this runs inside the long-lived MCP server, where the
+            // synchronous version blocked the event loop for seconds on a file that is
+            // now hundreds of megabytes. Nothing here needs to be synchronous — the
+            // function has always been async, it just was not using it.
+            handle = await open(path, "r");
+            // Read in slabs rather than one buffer: the file is expected to outgrow
+            // any single comfortable allocation, which is how v1 died.
+            const SLAB = 4 * 1024 * 1024;
+            let carry = Buffer.alloc(0);
+            let offset = 0;
+            while (offset < size) {
+                const want = Math.min(SLAB, size - offset);
+                const buf = Buffer.allocUnsafe(want);
+                const { bytesRead: got } = await handle.read(buf, 0, want, offset);
+                if (got <= 0)
+                    break;
+                offset += got;
+                const data = carry.length > 0 ? Buffer.concat([carry, buf.subarray(0, got)]) : buf.subarray(0, got);
+                let p = 0;
+                for (;;) {
+                    if (p + HEADER_BYTES > data.length)
+                        break;
+                    const dim = data.readUInt16LE(p + KEY_BYTES);
+                    if (dim === 0 || dim > MAX_DIM) {
+                        // Cannot know where the next record starts, so this is where reading ends. Say how much
+                        // was kept: the first draft did this silently, and one bad byte at record 10 cost 99%
+                        // of the file with no way to notice.
+                        skippedTail = true;
+                        p = data.length;
+                        offset = size;
+                        break;
                     }
+                    const total = HEADER_BYTES + dim * 4;
+                    if (p + total > data.length)
+                        break; // record spans the slab boundary
+                    const want = data.readUInt32LE(p + KEY_BYTES + 2);
+                    if (crc32(data, p + HEADER_BYTES, p + total) !== want) {
+                        // The length is intact, so the NEXT record's offset is still known: skip exactly this
+                        // one and keep going. Without the checksum this record would have been served as a
+                        // valid vector — a wrong embedding produces a plausible score, not a cache miss.
+                        corrupt++;
+                        p += total;
+                        continue;
+                    }
+                    if (resident + dim * 4 > budget) {
+                        // Stop, do not evict. Entries are equally valuable here — there is no recency to
+                        // exploit, since a key is looked up once per corpus pass — so the cheapest correct
+                        // policy is to keep the prefix already paid for and let the rest be recomputed.
+                        stoppedAtBudget = true;
+                        offset = size;
+                        break;
+                    }
+                    const key = data.subarray(p, p + KEY_BYTES).toString("hex");
+                    const vec = new Float32Array(dim);
+                    for (let i = 0; i < dim; i++)
+                        vec[i] = data.readFloatLE(p + HEADER_BYTES + i * 4);
+                    map.set(key, vec);
+                    resident += dim * 4;
+                    p += total;
                 }
-                catch {
-                    // Skip a malformed line rather than abandoning the whole cache.
-                }
+                carry = p < data.length ? Buffer.from(data.subarray(p)) : Buffer.alloc(0);
+                if (carry.length > 0)
+                    skippedTail = true;
             }
         }
         catch {
-            // Unreadable file — behave as if empty.
+            // Unreadable — behave as if empty.
+        }
+        finally {
+            if (corrupt > 0 || skippedTail) {
+                console.error(`[codesift] shared embedding cache: kept ${map.size} vectors, dropped ${corrupt} failing ` +
+                    `checksum${skippedTail ? " and stopped early at an unreadable record" : ""}. ` +
+                    `It is derived — delete ${path} to rebuild.`);
+            }
+            if (stoppedAtBudget) {
+                console.error(`[codesift] shared embedding cache: loaded ${map.size} vectors ` +
+                    `(${(resident / 1024 ** 2).toFixed(0)} MB), stopping at the ` +
+                    `${(budget / 1024 ** 2).toFixed(0)} MB budget. The rest will be recomputed rather than ` +
+                    `looked up. Raise CODESIFT_MAX_SHARED_CACHE_MB to trade memory for fewer model calls.`);
+            }
+            if (handle !== undefined) {
+                try {
+                    await handle.close();
+                }
+                catch {
+                    /* already gone */
+                }
+            }
         }
     }
     memory = map;
     loadedFrom = path;
     return map;
 }
+function encodeRecord(key, vec) {
+    if (key.length !== KEY_BYTES * 2 || !/^[0-9a-f]+$/.test(key) ||
+        vec.length === 0 || vec.length > MAX_DIM)
+        return null;
+    const rec = Buffer.allocUnsafe(HEADER_BYTES + vec.length * 4);
+    rec.write(key, 0, KEY_BYTES, "hex");
+    rec.writeUInt16LE(vec.length, KEY_BYTES);
+    for (let i = 0; i < vec.length; i++)
+        rec.writeFloatLE(vec[i], HEADER_BYTES + i * 4);
+    rec.writeUInt32LE(crc32(rec, HEADER_BYTES, rec.length), KEY_BYTES + 2);
+    return rec;
+}
 /**
  * Append new vectors. Both the file and the in-memory map are updated, so a
  * second repo indexed in the same process hits memory rather than disk.
+ *
+ * Entries already present are skipped: v1 appended unconditionally and 11.3% of
+ * its lines were repeats of a key it already held. Dedup happens against the
+ * in-memory map, so it is exact within a process and best-effort across them —
+ * which is the same guarantee append-only gave before, at a fraction of the
+ * bytes.
  */
 export function appendSharedCache(entries) {
     if (entries.length === 0)
@@ -98,23 +320,56 @@ export function appendSharedCache(entries) {
     const path = cachePath();
     try {
         mkdirSync(join(path, ".."), { recursive: true });
-        let payload = "";
+        let batch = [];
+        let batchEntries = [];
+        const pendingKeys = new Set();
+        let batchBytes = 0;
+        const flush = () => {
+            if (batch.length === 0)
+                return;
+            // One append per chunk, always ending on a record boundary, so a
+            // concurrent writer can interleave BETWEEN records but never inside one.
+            appendFileSync(path, Buffer.concat(batch));
+            if (memory) {
+                for (const { key, vec } of batchEntries)
+                    memory.set(key, vec);
+            }
+            batch = [];
+            batchEntries = [];
+            pendingKeys.clear();
+            batchBytes = 0;
+        };
         for (const { key, vec } of entries) {
-            if (memory && !memory.has(key))
-                memory.set(key, vec);
-            payload += JSON.stringify({ k: key, v: Array.from(vec) }) + "\n";
+            const normalizedKey = key.toLowerCase();
+            if (memory?.has(normalizedKey) || pendingKeys.has(normalizedKey))
+                continue;
+            const rec = encodeRecord(normalizedKey, vec);
+            if (!rec)
+                continue;
+            if (batchBytes + rec.length > MAX_APPEND_BYTES)
+                flush();
+            batch.push(rec);
+            batchEntries.push({ key: normalizedKey, vec });
+            pendingKeys.add(normalizedKey);
+            batchBytes += rec.length;
         }
-        // One append for the batch: fewer syscalls, and a single write is far less
-        // likely to interleave with another process mid-line than many small ones.
-        appendFileSync(path, payload, "utf-8");
+        flush();
     }
-    catch {
-        // A cache that cannot be written must not fail the indexing run.
+    catch (err) {
+        // A cache that cannot be written must not fail the indexing run — but v1's
+        // silence is how a total write failure went unnoticed for days while the
+        // cache held 4.56% of the corpus. Say it once per process.
+        if (!warnedWriteFailure) {
+            warnedWriteFailure = true;
+            console.error(`[codesift] shared embedding cache is not being written (${err.message}). ` +
+                `Indexing continues; embeddings will be recomputed per repo.`);
+        }
     }
 }
 /** Test-only: forget the in-memory copy so a fresh path is picked up. */
 export function _resetSharedCacheForTests() {
     memory = null;
     loadedFrom = null;
+    warnedWriteFailure = false;
 }
 //# sourceMappingURL=shared-embedding-cache.js.map

package/dist/storage/shared-embedding-cache.js.map

@@ -1 +1 @@
-{"version":3,"file":"shared-embedding-cache.js","sourceRoot":"","sources":["../../src/storage/shared-embedding-cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAClF,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAClC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,iFAAiF;AACjF,MAAM,aAAa,GAAG,CAAC,CAAC;AAExB,SAAS,SAAS;IAChB,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,mBAAmB,CAAC,IAAI,IAAI,CAAC,OAAO,EAAE,EAAE,WAAW,CAAC,CAAC;IACjF,OAAO,IAAI,CAAC,OAAO,EAAE,sBAAsB,aAAa,SAAS,CAAC,CAAC;AACrE,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,UAAU,CAAC,KAAa,EAAE,UAAkB,EAAE,IAAY;IACxE,OAAO,UAAU,CAAC,QAAQ,CAAC;SACxB,MAAM,CAAC,GAAG,KAAK,KAAK,UAAU,KAAK,IAAI,EAAE,CAAC;SAC1C,MAAM,CAAC,KAAK,CAAC;SACb,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAClB,CAAC;AAED,IAAI,MAAM,GAAqC,IAAI,CAAC;AACpD,IAAI,UAAU,GAAkB,IAAI,CAAC;AAErC;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe;IACnC,MAAM,IAAI,GAAG,SAAS,EAAE,CAAC;IACzB,IAAI,MAAM,IAAI,UAAU,KAAK,IAAI;QAAE,OAAO,MAAM,CAAC;IACjD,MAAM,GAAG,GAAG,IAAI,GAAG,EAAwB,CAAC;IAC5C,IAAI,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QACrB,IAAI,CAAC;YACH,MAAM,EAAE,GAAG,eAAe,CAAC,EAAE,KAAK,EAAE,gBAAgB,CAAC,IAAI,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,CAAC;YAC1G,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,EAAE,EAAE,CAAC;gBAC5B,IAAI,CAAC,IAAI;oBAAE,SAAS;gBACpB,IAAI,CAAC;oBACH,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAiC,CAAC;oBAC/D,IAAI,OAAO,KAAK,CAAC,CAAC,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;wBAC1D,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;oBAC9C,CAAC;gBACH,CAAC;gBAAC,MAAM,CAAC;oBACP,gEAAgE;gBAClE,CAAC;YACH,CAAC;QACH,CAAC;QAAC,MAAM,CAAC;YACP,wCAAwC;QAC1C,CAAC;IACH,CAAC;IACD,MAAM,GAAG,GAAG,CAAC;IACb,UAAU,GAAG,IAAI,CAAC;IAClB,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,iBAAiB,CAAC,OAAkD;IAClF,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO;IACjC,MAAM,IAAI,GAAG,SAAS,EAAE,CAAC;IACzB,IAAI,CAAC;QACH,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACjD,IAAI,OAAO,GAAG,EAAE,CAAC;QACjB,KAAK,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,OAAO,EAAE,CAAC;YACnC,IAAI,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC;gBAAE,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;YACrD,OAAO,IAAI,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC;QACnE,CAAC;QACD,2EAA2E;QAC3E,2EAA2E;QAC3E,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;IACzC,CAAC;IAAC,MAAM,CAAC;QACP,iEAAiE;IACnE,CAAC;AACH,CAAC;AAED,yEAAyE;AACzE,MAAM,UAAU,yBAAyB;IACvC,MAAM,GAAG,IAAI,CAAC;IACd,UAAU,GAAG,IAAI,CAAC;AACpB,CAAC"}
+{"version":3,"file":"shared-embedding-cache.js","sourceRoot":"","sources":["../../src/storage/shared-embedding-cache.ts"],"names":[],"mappings":"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"}

package/dist/storage/sqlite/accessors.d.ts

@@ -0,0 +1,34 @@
+import type { CodeSymbol, FileEntry } from "../../types.js";
+import { type IndexSummary } from "./meta.js";
+/**
+ * One file's `mtime_ms`, without materialising the index.
+ *
+ * `file-indexer.ts` used to parse the whole blob for exactly this value and then
+ * `saveIncremental` parsed it a second time — two full parses of 262 MB to decide whether a
+ * 40-line file had changed.
+ */
+export declare function getFileMtimeSqlite(dbPath: string, filePath: string): Promise<number | undefined>;
+/**
+ * Read an index without constructing its symbols.
+ *
+ * Measured on the real tgm-survey-platform index (240,137 symbols): a full load costs ~1.0 s and
+ * 349 MB of resident heap, essentially all of it building symbol objects. Tools that never touch
+ * `index.symbols` — `index_status` is the clearest, it reports counts it reads from metadata — paid
+ * that in full for nothing.
+ */
+export declare function loadIndexSummarySqlite(dbPath: string): Promise<IndexSummary | null>;
+/** One file's `files[]` entry, without materialising the index. */
+export declare function getFileEntrySqlite(dbPath: string, filePath: string): Promise<FileEntry | undefined>;
+/** Replace one file's symbols (and optionally its files[] entry) in a single transaction. */
+export declare function saveIncrementalSqlite(dbPath: string, updatedFile: string, newSymbols: CodeSymbol[], fileEntry?: FileEntry): Promise<void>;
+/** Drop a deleted file's symbols and its files[] entry. */
+export declare function removeFileFromIndexSqlite(dbPath: string, deletedFile: string): Promise<void>;
+/** All symbols for one file — lets per-file tools skip the whole-index load. */
+export declare function getSymbolsForFileSqlite(dbPath: string, filePath: string): Promise<CodeSymbol[]>;
+/**
+ * Cross-process change counter. SQLite bumps `data_version` when *another* connection
+ * commits, which is the invalidation signal a plain JSON file never had — and the reason an
+ * in-memory index cache becomes safe here despite the hook writing from its own process.
+ */
+export declare function getDataVersion(dbPath: string): Promise<number>;
+//# sourceMappingURL=accessors.d.ts.map

package/dist/storage/sqlite/accessors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessors.d.ts","sourceRoot":"","sources":["../../../src/storage/sqlite/accessors.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAS5D,OAAO,EAAkB,KAAK,YAAY,EAAE,MAAM,WAAW,CAAC;AAqC9D;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAQ7B;AAED;;;;;;;GAOG;AACH,wBAAsB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAwDzF;AAED,mEAAmE;AACnE,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAQhC;AAED,6FAA6F;AAC7F,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,UAAU,EAAE,EACxB,SAAS,CAAC,EAAE,SAAS,GACpB,OAAO,CAAC,IAAI,CAAC,CAsBf;AAED,2DAA2D;AAC3D,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC,CAcf;AAED,gFAAgF;AAChF,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,UAAU,EAAE,CAAC,CAUvB;AAED;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAMpE"}

package/dist/storage/sqlite/accessors.js

@@ -0,0 +1,178 @@
+import { openIndexDb, openReadConnection, readMetaValue, rollbackQuietly, writeMetaValue, } from "./connection.js";
+import { rethrowOperational } from "./errors.js";
+import { readMetaExtras } from "./meta.js";
+import { INSERT_FILE_SQL, INSERT_SYMBOL_SQL, fileEntryToRow, rowToFileEntry, rowToSymbol, symbolToRow, } from "./rows.js";
+/**
+ * Narrow accessors — the reason this backend exists.
+ *
+ * Every function here answers a question WITHOUT materialising the index. Under the JSON backend
+ * each of these cost a full parse of the whole repo's symbols; that is the cost ADR-003 set out to
+ * remove and ADR-004 stage 2 is still working through call site by call site.
+ */
+/**
+ * Run a read against an already-open index, classifying any storage fault it surfaces.
+ *
+ * `openIndexDb` classifies what fails at open time, but corruption and I/O faults frequently only
+ * surface on the first page actually touched — and these accessors are the fast paths precisely
+ * because they touch one row late rather than the whole table early. Without this, a caller using
+ * `isIndexStorageError` (rather than `classifyStorageError`) does not recognise the fault, and the
+ * read falls into the "unexpected error" branch that reports an unindexed repo.
+ */
+function classifyingRead(dbPath, read) {
+    try {
+        return read();
+    }
+    catch (err) {
+        rethrowOperational(err, dbPath);
+    }
+}
+/**
+ * One file's `mtime_ms`, without materialising the index.
+ *
+ * `file-indexer.ts` used to parse the whole blob for exactly this value and then
+ * `saveIncremental` parsed it a second time — two full parses of 262 MB to decide whether a
+ * 40-line file had changed.
+ */
+export async function getFileMtimeSqlite(dbPath, filePath) {
+    const db = await openIndexDb(dbPath);
+    return classifyingRead(dbPath, () => {
+        const row = db.prepare("SELECT mtime_ms FROM files WHERE path = ?").get(filePath);
+        return row?.mtime_ms ?? undefined;
+    });
+}
+/**
+ * Read an index without constructing its symbols.
+ *
+ * Measured on the real tgm-survey-platform index (240,137 symbols): a full load costs ~1.0 s and
+ * 349 MB of resident heap, essentially all of it building symbol objects. Tools that never touch
+ * `index.symbols` — `index_status` is the clearest, it reports counts it reads from metadata — paid
+ * that in full for nothing.
+ */
+export async function loadIndexSummarySqlite(dbPath) {
+    await openIndexDb(dbPath);
+    let reader;
+    let out = null;
+    try {
+        // Same one-transaction rule as `loadIndexSqlite`: files and meta must describe one instant,
+        // or the summary reports a file list from one revision with counts from another.
+        // Bound to a `const` as well as to `reader`: the closure below outlives the narrowing of the
+        // `let`, so reading it through `reader` needed an `as` cast that asserted away an `undefined`
+        // the compiler was right to track. The local carries the non-optional type honestly.
+        const snapshot = await openReadConnection(dbPath);
+        reader = snapshot;
+        snapshot.exec("BEGIN");
+        try {
+            const meta = (key) => readMetaValue(snapshot, key);
+            const repo = meta("repo");
+            const root = meta("root");
+            if (repo === undefined || root === undefined) {
+                snapshot.exec("COMMIT");
+                return null; // genuinely empty — not a fault
+            }
+            // ORDER BY rowid, matching `readTablePaged`'s keyset walk. Without it the two SQLite read
+            // paths could hand back the same files in different orders, so a caller comparing a summary
+            // against a full load would see a difference that is not in the data.
+            const files = snapshot.prepare("SELECT * FROM files ORDER BY rowid").all().map(rowToFileEntry);
+            const counted = snapshot.prepare("SELECT COUNT(*) AS n FROM symbols").get();
+            const summary = {
+                repo,
+                root,
+                files,
+                created_at: Number(meta("created_at") ?? 0),
+                updated_at: Number(meta("updated_at") ?? 0),
+                symbol_count: Number(counted?.n ?? 0),
+                file_count: files.length,
+            };
+            Object.assign(summary, readMetaExtras(meta));
+            snapshot.exec("COMMIT");
+            out = summary;
+        }
+        catch (err) {
+            rollbackQuietly(snapshot);
+            throw err;
+        }
+    }
+    catch (err) {
+        rethrowOperational(err, dbPath);
+    }
+    finally {
+        try {
+            reader?.close();
+        }
+        catch { /* best-effort */ }
+    }
+    return out;
+}
+/** One file's `files[]` entry, without materialising the index. */
+export async function getFileEntrySqlite(dbPath, filePath) {
+    const db = await openIndexDb(dbPath);
+    return classifyingRead(dbPath, () => {
+        const row = db.prepare("SELECT * FROM files WHERE path = ?").get(filePath);
+        return row ? rowToFileEntry(row) : undefined;
+    });
+}
+/** Replace one file's symbols (and optionally its files[] entry) in a single transaction. */
+export async function saveIncrementalSqlite(dbPath, updatedFile, newSymbols, fileEntry) {
+    const db = await openIndexDb(dbPath);
+    if (readMetaValue(db, "repo") === undefined) {
+        throw new Error(`Cannot incrementally update: index not found at ${dbPath}`);
+    }
+    db.exec("BEGIN");
+    try {
+        db.prepare("DELETE FROM symbols WHERE file = ?").run(updatedFile);
+        const insSym = db.prepare(INSERT_SYMBOL_SQL);
+        for (const sym of newSymbols)
+            insSym.run(...symbolToRow(sym));
+        if (fileEntry)
+            db.prepare(INSERT_FILE_SQL).run(...fileEntryToRow(fileEntry));
+        writeMetaValue(db, "updated_at", String(Date.now()));
+        db.exec("COMMIT");
+    }
+    catch (err) {
+        rollbackQuietly(db);
+        rethrowOperational(err, dbPath);
+    }
+}
+/** Drop a deleted file's symbols and its files[] entry. */
+export async function removeFileFromIndexSqlite(dbPath, deletedFile) {
+    const db = await openIndexDb(dbPath);
+    if (readMetaValue(db, "repo") === undefined)
+        return; // nothing to remove
+    db.exec("BEGIN");
+    try {
+        db.prepare("DELETE FROM symbols WHERE file = ?").run(deletedFile);
+        db.prepare("DELETE FROM files WHERE path = ?").run(deletedFile);
+        writeMetaValue(db, "updated_at", String(Date.now()));
+        db.exec("COMMIT");
+    }
+    catch (err) {
+        rollbackQuietly(db);
+        rethrowOperational(err, dbPath);
+    }
+}
+/** All symbols for one file — lets per-file tools skip the whole-index load. */
+export async function getSymbolsForFileSqlite(dbPath, filePath) {
+    const db = await openIndexDb(dbPath);
+    return classifyingRead(dbPath, () => {
+        const repo = readMetaValue(db, "repo");
+        if (repo === undefined)
+            return [];
+        const rows = db
+            .prepare("SELECT * FROM symbols WHERE file = ?")
+            .all(filePath);
+        return rows.map((row) => rowToSymbol(row, repo));
+    });
+}
+/**
+ * Cross-process change counter. SQLite bumps `data_version` when *another* connection
+ * commits, which is the invalidation signal a plain JSON file never had — and the reason an
+ * in-memory index cache becomes safe here despite the hook writing from its own process.
+ */
+export async function getDataVersion(dbPath) {
+    const db = await openIndexDb(dbPath);
+    return classifyingRead(dbPath, () => {
+        const row = db.prepare("PRAGMA data_version").get();
+        return row.data_version;
+    });
+}
+//# sourceMappingURL=accessors.js.map