@wrongstack/tools 0.286.0 → 0.289.0

package/dist/codebase-index/worker.js

@@ -3,8 +3,8 @@ import { parentPort } from "node:worker_threads";
 
 // src/codebase-index/indexer.ts
 import { expectDefined as expectDefined5 } from "@wrongstack/core";
-import * as fs6 from "node:fs/promises";
-import * as path7 from "node:path";
+import * as fs7 from "node:fs/promises";
+import * as path8 from "node:path";
 import { compileGlob as compileGlob2 } from "@wrongstack/core";
 
 // src/codebase-index/writer.ts
@@ -92,7 +92,7 @@ import * as path from "node:path";
 import { resolveWstackPaths } from "@wrongstack/core";
 
 // src/codebase-index/schema.ts
-var SCHEMA_VERSION = 2;
+var SCHEMA_VERSION = 3;
 
 // src/codebase-index/lsp-kind.ts
 function lspKindToInternalKind(k) {
@@ -135,7 +135,7 @@ function tokenise(text) {
   return sanitised.toLowerCase().split(" ").filter(Boolean);
 }
 function splitName(name) {
-  return name.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").trim();
+  return name.replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([\p{L}])(\d)/gu, "$1 $2").replace(/(\d)([\p{L}])/gu, "$1 $2").replace(/[_-]+/g, " ").trim();
 }
 function buildIndexableText(name, signature, docComment) {
   return [splitName(name), name, signature, docComment].filter(Boolean).join(" ");
@@ -161,14 +161,12 @@ function buildBm25Index(docs) {
   return new Bm25Index(documents, df, N, avgLen);
 }
 var Bm25Index = class {
-  constructor(documents, df, N, avgLen) {
+  constructor(documents, _df, N, avgLen) {
     this.documents = documents;
-    this.df = df;
     this.N = N;
     this.safeAvgLen = avgLen === 0 ? 1 : avgLen;
   }
   documents;
-  df;
   N;
   safeAvgLen;
   score(query, filter) {
@@ -181,10 +179,13 @@ var Bm25Index = class {
       for (const qTerm of qTokens) {
         let tf = 0;
         for (const t of doc.tokens) {
-          if (t === qTerm) tf++;
+          if (t.startsWith(qTerm)) tf++;
         }
         if (tf === 0) continue;
-        const dfVal = this.df[qTerm] ?? 0;
+        let dfVal = 0;
+        for (const candidate of this.documents) {
+          if (candidate.tokens.some((t) => t.startsWith(qTerm))) dfVal++;
+        }
         if (dfVal === 0) continue;
         const idf = Math.log((this.N - dfVal + 0.5) / (dfVal + 0.5) + 1);
         const lenRatio = B * (doc.len / this.safeAvgLen);
@@ -217,6 +218,29 @@ var Bm25Index = class {
 
 // src/codebase-index/writer.ts
 var DB_FILE = "index.db";
+function escapeLike(value) {
+  return value.replace(/[\\%_]/g, (char) => `\\${char}`);
+}
+function assignRefsToSymbols(refs, symbols) {
+  if (refs.length === 0 || symbols.length === 0) return [];
+  const ordered = [...symbols].sort((a, b) => a.line - b.line || a.col - b.col || a.id - b.id);
+  const seen = /* @__PURE__ */ new Set();
+  const assigned = [];
+  for (const ref of refs) {
+    let owner;
+    for (const symbol of ordered) {
+      if (symbol.line > ref.line) break;
+      owner = symbol;
+    }
+    if (!owner && ref.callType === "import") owner = ordered[0];
+    if (!owner || owner.id <= 0) continue;
+    const key = `${owner.id}:${ref.toName}:${ref.callType}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    assigned.push({ ...ref, fromId: owner.id });
+  }
+  return assigned;
+}
 function resolveIndexDir(projectRoot, override) {
   return override ?? resolveWstackPaths({ projectRoot }).projectCodebaseIndex;
 }
@@ -266,7 +290,7 @@ function sleepSync(ms) {
   } catch {
   }
 }
-var IndexStore = class {
+var IndexStore = class _IndexStore {
   db;
   /** Absolute path to this project's index directory. */
   indexDir;
@@ -318,10 +342,7 @@ var IndexStore = class {
           const msg = lastError instanceof Error ? lastError.message : String(lastError);
           throw new LockError(`SQLite lock conflict after ${MAX_LOCK_RETRIES} retries: ${msg}`);
         }
-        const delay = Math.min(
-          LOCK_RETRY_BASE_DELAY_MS * 2 ** attempt,
-          LOCK_RETRY_MAX_DELAY_MS
-        );
+        const delay = Math.min(LOCK_RETRY_BASE_DELAY_MS * 2 ** attempt, LOCK_RETRY_MAX_DELAY_MS);
         sleepSync(delay);
       }
     }
@@ -403,8 +424,24 @@ var IndexStore = class {
     this.db.exec("CREATE INDEX IF NOT EXISTS idx_r_to_name ON refs(to_name)");
     this.db.exec("CREATE INDEX IF NOT EXISTS idx_r_call_type ON refs(call_type)");
     try {
-      this.db.exec("CREATE VIRTUAL TABLE IF NOT EXISTS symbols_fts USING fts5(text, tokenize = 'unicode61')");
+      this.db.exec(
+        "CREATE VIRTUAL TABLE IF NOT EXISTS symbols_fts USING fts5(text, tokenize = 'unicode61')"
+      );
       this.ftsAvailable = true;
+      const symbolCount = Number(
+        this.db.prepare("SELECT COUNT(*) AS n FROM symbols").get()?.n ?? 0
+      );
+      const ftsCount = Number(
+        this.db.prepare("SELECT COUNT(*) AS n FROM symbols_fts").get()?.n ?? 0
+      );
+      if (symbolCount !== ftsCount) {
+        this.db.exec("DELETE FROM symbols_fts");
+        const insert = this.db.prepare("INSERT INTO symbols_fts(rowid, text) VALUES (?, ?)");
+        const rows = this.db.prepare("SELECT id, name, signature, doc_comment FROM symbols ORDER BY id").all();
+        for (const row of rows) {
+          insert.run(row.id, buildIndexableText(row.name, row.signature, row.doc_comment));
+        }
+      }
     } catch {
       this.ftsAvailable = false;
     }
@@ -462,7 +499,9 @@ var IndexStore = class {
   deleteSymbolsForFile(file) {
     this.runWithRetry(() => {
       if (this.ftsAvailable) {
-        this.stmt("DELETE FROM symbols_fts WHERE rowid IN (SELECT id FROM symbols WHERE file_fk = ?)").run(file);
+        this.stmt(
+          "DELETE FROM symbols_fts WHERE rowid IN (SELECT id FROM symbols WHERE file_fk = ?)"
+        ).run(file);
       }
       this.stmt("DELETE FROM symbols WHERE file_fk = ?").run(file);
     });
@@ -474,9 +513,21 @@ var IndexStore = class {
    */
   deleteFile(file) {
     this.runWithRetry(() => {
-      this.deleteRefsForFile(file);
-      this.deleteSymbolsForFile(file);
-      this.stmt("DELETE FROM files WHERE file = ?").run(file);
+      this.db.exec("BEGIN IMMEDIATE");
+      try {
+        if (this.ftsAvailable) {
+          this.db.prepare(
+            "DELETE FROM symbols_fts WHERE rowid IN (SELECT id FROM symbols WHERE file_fk = ?)"
+          ).run(file);
+        }
+        this.db.prepare("DELETE FROM refs WHERE from_id IN (SELECT id FROM symbols WHERE file_fk = ?)").run(file);
+        this.db.prepare("DELETE FROM symbols WHERE file_fk = ?").run(file);
+        this.db.prepare("DELETE FROM files WHERE file = ?").run(file);
+        this.db.exec("COMMIT");
+      } catch (err) {
+        this.db.exec("ROLLBACK");
+        throw err;
+      }
     });
   }
   // ─── File metadata ──────────────────────────────────────────────────────────
@@ -499,14 +550,22 @@ var IndexStore = class {
     ).all(file);
     if (!rows.length) return null;
     const r = expectDefined(rows[0]);
-    return { file: r.file, lang: r.lang, mtimeMs: r.mtime_ms, symbolCount: r.symbol_count, lastIndexed: r.last_indexed };
+    return {
+      file: r.file,
+      lang: r.lang,
+      mtimeMs: r.mtime_ms,
+      symbolCount: r.symbol_count,
+      lastIndexed: r.last_indexed
+    };
   }
   getAllFileMetas() {
-    return this.db.prepare(
-      "SELECT file, lang, mtime_ms, symbol_count, last_indexed FROM files"
-    ).all().map(
-      (r) => ({ file: r.file, lang: r.lang, mtimeMs: r.mtime_ms, symbolCount: r.symbol_count, lastIndexed: r.last_indexed })
-    );
+    return this.db.prepare("SELECT file, lang, mtime_ms, symbol_count, last_indexed FROM files").all().map((r) => ({
+      file: r.file,
+      lang: r.lang,
+      mtimeMs: r.mtime_ms,
+      symbolCount: r.symbol_count,
+      lastIndexed: r.last_indexed
+    }));
   }
   // ─── Search ──────────────────────────────────────────────────────────────────
   search(query, filter) {
@@ -530,8 +589,8 @@ var IndexStore = class {
       values.push(filter.lang);
     }
     if (filter?.file) {
-      conditions.push("file LIKE ?");
-      values.push(`%${filter.file}%`);
+      conditions.push("replace(file, '\\', '/') LIKE ? ESCAPE '\\'");
+      values.push(`%${escapeLike(filter.file.replace(/\\/g, "/"))}%`);
     }
     if (query.trim()) {
       const tokens = query.toLowerCase().split(/\s+/).filter(Boolean);
@@ -569,9 +628,11 @@ var IndexStore = class {
    * "users", camelCase-split text makes "complex" find "complexOperation").
    */
   searchRanked(query, filter, limit) {
+    const rawLimit = Number.isFinite(limit) ? Math.trunc(limit) : 20;
+    const safeLimit = Math.max(1, Math.min(rawLimit, 100));
     const tokens = tokenise(query);
     if (tokens.length === 0 || !this.ftsAvailable) {
-      return this.searchRankedFallback(query, filter, limit);
+      return this.searchRankedFallback(query, filter, safeLimit);
     }
     let effectiveKind = filter?.kind;
     if (filter?.lspKind !== void 0) {
@@ -591,11 +652,13 @@ var IndexStore = class {
       values.push(filter.lang);
     }
     if (filter?.file) {
-      conditions.push("s.file LIKE ?");
-      values.push(`%${filter.file}%`);
+      conditions.push("replace(s.file, '\\', '/') LIKE ? ESCAPE '\\'");
+      values.push(`%${escapeLike(filter.file.replace(/\\/g, "/"))}%`);
     }
     const where = conditions.join(" AND ");
-    const countRows = this.db.prepare(`SELECT COUNT(*) AS n FROM symbols_fts JOIN symbols s ON s.id = symbols_fts.rowid WHERE ${where}`).all(...values);
+    const countRows = this.db.prepare(
+      `SELECT COUNT(*) AS n FROM symbols_fts JOIN symbols s ON s.id = symbols_fts.rowid WHERE ${where}`
+    ).all(...values);
     const total = countRows[0] ? Number(countRows[0].n) : 0;
     if (total === 0) return { results: [], total: 0 };
     const rows = this.db.prepare(
@@ -604,9 +667,13 @@ var IndexStore = class {
                 snippet(symbols_fts, 0, '', '', '\u2026', 12) AS snippet
          FROM symbols_fts JOIN symbols s ON s.id = symbols_fts.rowid
          WHERE ${where}
-         ORDER BY bm25(symbols_fts)
+         ORDER BY
+           CASE WHEN lower(s.name) = lower(?) THEN 0
+                WHEN lower(s.name) LIKE lower(?) ESCAPE '\\' THEN 1
+                ELSE 2 END,
+           bm25(symbols_fts), lower(s.name), s.file, s.line, s.col, s.id
          LIMIT ?`
-    ).all(...values, limit);
+    ).all(...values, query.trim(), `${escapeLike(query.trim())}%`, safeLimit);
     return {
       results: rows.map((r) => ({
         id: r.id,
@@ -636,10 +703,28 @@ var IndexStore = class {
     }
     const candidateById = new Map(candidates.map((c) => [c.id, c]));
     const bm25 = buildBm25Index(
-      candidates.map((c) => ({ id: c.id, text: buildIndexableText(c.name, c.signature, c.docComment) }))
+      candidates.map((c) => ({
+        id: c.id,
+        text: buildIndexableText(c.name, c.signature, c.docComment)
+      }))
     );
     const scored = bm25.score(query, (id) => candidateById.has(id));
-    scored.sort((a, b) => b.score - a.score);
+    const q = query.trim().toLowerCase();
+    const rank = (id) => {
+      const name = candidateById.get(id)?.name.toLowerCase() ?? "";
+      if (name === q) return 0;
+      if (name.startsWith(q)) return 1;
+      return 2;
+    };
+    scored.sort((a, b) => {
+      const rankDiff = rank(a.id) - rank(b.id);
+      if (rankDiff !== 0) return rankDiff;
+      const scoreDiff = b.score - a.score;
+      if (scoreDiff !== 0) return scoreDiff;
+      const left = expectDefined(candidateById.get(a.id));
+      const right = expectDefined(candidateById.get(b.id));
+      return left.name.localeCompare(right.name) || left.file.localeCompare(right.file) || left.line - right.line || left.col - right.col || left.id - right.id;
+    });
     const qTokens = tokenise(query);
     const results = scored.slice(0, limit).map(({ id, score }) => {
       const c = expectDefined(candidateById.get(id));
@@ -648,9 +733,7 @@ var IndexStore = class {
     return { results, total: candidates.length };
   }
   getAllIndexable() {
-    return this.db.prepare("SELECT id, text FROM symbols").all().map(
-      ({ id, text }) => ({ id, text })
-    );
+    return this.db.prepare("SELECT id, text FROM symbols").all().map(({ id, text }) => ({ id, text }));
   }
   /**
    * Largest symbol id currently in the table (0 when empty). New ids must be
@@ -666,22 +749,16 @@ var IndexStore = class {
   // ─── Stats ───────────────────────────────────────────────────────────────────
   getStats() {
     const sizeBytes = this.sizeBytes();
-    const lastRows = this.db.prepare(
-      "SELECT value FROM metadata WHERE key = 'last_indexed'"
-    ).all();
+    const lastRows = this.db.prepare("SELECT value FROM metadata WHERE key = 'last_indexed'").all();
     const lastIndexed = lastRows.length ? Number(lastRows[0]?.value) : null;
     const totalRows = this.db.prepare("SELECT COUNT(*) FROM symbols").all();
     const totalSymbols = totalRows[0] ? Number(totalRows[0]["COUNT(*)"]) : 0;
     const fileRows = this.db.prepare("SELECT COUNT(*) FROM files").all();
     const totalFiles = fileRows[0] ? Number(fileRows[0]["COUNT(*)"]) : 0;
-    const langRows = this.db.prepare(
-      "SELECT lang, COUNT(*) FROM symbols GROUP BY lang"
-    ).all();
+    const langRows = this.db.prepare("SELECT lang, COUNT(*) FROM symbols GROUP BY lang").all();
     const byLang = {};
     for (const row of langRows) byLang[row.lang] = Number(row["COUNT(*)"]);
-    const kindRows = this.db.prepare(
-      "SELECT kind, COUNT(*) FROM symbols GROUP BY kind"
-    ).all();
+    const kindRows = this.db.prepare("SELECT kind, COUNT(*) FROM symbols GROUP BY kind").all();
     const byKind = {};
     for (const row of kindRows) byKind[row.kind] = Number(row["COUNT(*)"]);
     return {
@@ -697,17 +774,31 @@ var IndexStore = class {
   }
   setLastIndexed(ts2) {
     this.runWithRetry(() => {
-      this.db.prepare(
-        "INSERT OR REPLACE INTO metadata(key, value) VALUES('last_indexed', ?)"
-      ).run(String(ts2));
+      this.db.prepare("INSERT OR REPLACE INTO metadata(key, value) VALUES('last_indexed', ?)").run(String(ts2));
+    });
+  }
+  getMetadata(key) {
+    const rows = this.db.prepare("SELECT value FROM metadata WHERE key = ?").all(key);
+    return rows[0]?.value;
+  }
+  setMetadata(key, value) {
+    this.runWithRetry(() => {
+      this.db.prepare("INSERT OR REPLACE INTO metadata(key, value) VALUES(?, ?)").run(key, value);
     });
   }
   clearAll() {
     this.runWithRetry(() => {
-      this.db.exec("DELETE FROM symbols");
-      this.db.exec("DELETE FROM files");
-      this.db.exec("DELETE FROM refs");
-      if (this.ftsAvailable) this.db.exec("DELETE FROM symbols_fts");
+      this.db.exec("BEGIN IMMEDIATE");
+      try {
+        this.db.exec("DELETE FROM refs");
+        this.db.exec("DELETE FROM symbols");
+        this.db.exec("DELETE FROM files");
+        if (this.ftsAvailable) this.db.exec("DELETE FROM symbols_fts");
+        this.db.exec("COMMIT");
+      } catch (err) {
+        this.db.exec("ROLLBACK");
+        throw err;
+      }
     });
   }
   // ─── Ref CRUD ────────────────────────────────────────────────────────────────
@@ -798,6 +889,7 @@ var IndexStore = class {
         const allInserted = [];
         const refsToInsert = [];
         for (const entry of entries) {
+          const insertedForEntry = [];
           for (const s of entry.symbols) {
             const id = nextId++;
             symStmt.run(
@@ -815,9 +907,11 @@ var IndexStore = class {
               s.file
             );
             ftsStmt?.run(id, buildIndexableText(s.name, s.signature, s.docComment));
-            allInserted.push({ ...s, id });
+            const inserted = { ...s, id };
+            allInserted.push(inserted);
+            insertedForEntry.push(inserted);
           }
-          for (const r of entry.refs) refsToInsert.push(r);
+          refsToInsert.push(...assignRefsToSymbols(entry.refs, insertedForEntry));
         }
         if (refsToInsert.length > 0) {
           const refStmt = this.db.prepare(
@@ -855,9 +949,7 @@ var IndexStore = class {
    */
   deleteRefsForFile(file) {
     this.runWithRetry(() => {
-      this.db.prepare(
-        "DELETE FROM refs WHERE from_id IN (SELECT id FROM symbols WHERE file = ?)"
-      ).run(file);
+      this.db.prepare("DELETE FROM refs WHERE from_id IN (SELECT id FROM symbols WHERE file = ?)").run(file);
     });
   }
   /**
@@ -898,9 +990,7 @@ var IndexStore = class {
    * Find all references FROM a given symbol (what does this symbol call/use?).
    */
   findRefsFrom(symbolId) {
-    return this.db.prepare(
-      "SELECT id, from_id, to_name, to_id, call_type, line FROM refs WHERE from_id = ?"
-    ).all(symbolId).map((r) => ({
+    return this.db.prepare("SELECT id, from_id, to_name, to_id, call_type, line FROM refs WHERE from_id = ?").all(symbolId).map((r) => ({
       id: r.id,
       fromId: r.from_id,
       toName: r.to_name,
@@ -917,6 +1007,325 @@ var IndexStore = class {
       return 0;
     }
   }
+  // ─── CodeMap graph aggregation ──────────────────────────────────────────────
+  /**
+   * Derive a monorepo package name from an absolute file path.
+   * Handles both `packages/<name>/...` (workspace) and `src/<name>/...` layouts.
+   * Returns `undefined` for files outside any recognisable package structure.
+   */
+  static derivePackage(filePath) {
+    const f = filePath.replace(/\\/g, "/");
+    const pkgsIdx = f.indexOf("/packages/");
+    if (pkgsIdx !== -1) {
+      const rest = f.slice(pkgsIdx + "/packages/".length);
+      const seg = rest.split("/")[0];
+      return seg ? `@wrongstack/${seg}` : void 0;
+    }
+    const appsIdx = f.indexOf("/apps/");
+    if (appsIdx !== -1) {
+      const rest = f.slice(appsIdx + "/apps/".length);
+      const seg = rest.split("/")[0];
+      return seg ? `app:${seg}` : void 0;
+    }
+    return void 0;
+  }
+  static packageFromImport(moduleName) {
+    if (!moduleName.startsWith("@wrongstack/")) return void 0;
+    const parts = moduleName.split("/");
+    return parts[1] ? `@wrongstack/${parts[1]}` : void 0;
+  }
+  static resolveRelativeImport(fromFile, moduleName, indexedFiles) {
+    if (!moduleName.startsWith(".")) return void 0;
+    const normalizedFrom = fromFile.replace(/\\/g, "/");
+    const absolute = path.posix.normalize(
+      path.posix.join(path.posix.dirname(normalizedFrom), moduleName)
+    );
+    const extension = path.posix.extname(absolute);
+    const base = extension ? absolute.slice(0, -extension.length) : absolute;
+    const candidates = [
+      absolute,
+      ...[".ts", ".tsx", ".js", ".jsx", ".mts", ".cts"].map((ext) => `${base}${ext}`),
+      ...[".ts", ".tsx", ".js", ".jsx"].map((ext) => path.posix.join(absolute, `index${ext}`)),
+      ...[".ts", ".tsx", ".js", ".jsx"].map((ext) => path.posix.join(base, `index${ext}`))
+    ];
+    const indexedByPortablePath = new Map(
+      [...indexedFiles].map((file) => [file.replace(/\\/g, "/").toLocaleLowerCase(), file])
+    );
+    for (const candidate of candidates) {
+      const indexed = indexedByPortablePath.get(candidate.toLocaleLowerCase());
+      if (indexed) return indexed;
+    }
+    return void 0;
+  }
+  /**
+   * Package-level graph: each workspace package is a node; edges are derived
+   * from cross-package symbol references (a symbol in package A references a
+   * symbol resolved in package B). Node metadata includes symbol/file counts.
+   */
+  getPackageGraph() {
+    const symbols = this.db.prepare("SELECT file, id, name, kind, lang, line FROM symbols ORDER BY id").all();
+    const pkgNodes = /* @__PURE__ */ new Map();
+    const fileToPkg = /* @__PURE__ */ new Map();
+    const symbolToPkg = /* @__PURE__ */ new Map();
+    for (const s of symbols) {
+      const pkg = _IndexStore.derivePackage(s.file) ?? "(root)";
+      fileToPkg.set(s.file, pkg);
+      symbolToPkg.set(s.id, pkg);
+      const node = pkgNodes.get(pkg);
+      if (node) {
+        node.symbolCount = (node.symbolCount ?? 0) + 1;
+      } else {
+        pkgNodes.set(pkg, {
+          id: `pkg:${pkg}`,
+          label: pkg,
+          kind: "package",
+          package: pkg,
+          symbolCount: 1,
+          fileCount: 0
+        });
+      }
+    }
+    const files = this.db.prepare("SELECT DISTINCT file FROM files").all();
+    for (const { file } of files) {
+      const pkg = _IndexStore.derivePackage(file) ?? "(root)";
+      const node = pkgNodes.get(pkg);
+      if (node) node.fileCount = (node.fileCount ?? 0) + 1;
+    }
+    const refRows = this.db.prepare(
+      `SELECT r.from_id, r.to_id, r.call_type
+       FROM refs r
+       WHERE r.to_id IS NOT NULL`
+    ).all();
+    const edgeMap = /* @__PURE__ */ new Map();
+    for (const r of refRows) {
+      if (r.call_type === "import") continue;
+      const fromPkg = symbolToPkg.get(r.from_id);
+      const toPkg = symbolToPkg.get(r.to_id);
+      if (!fromPkg || !toPkg || fromPkg === toPkg) continue;
+      const key = `${fromPkg}\0${toPkg}`;
+      let e = edgeMap.get(key);
+      if (!e) {
+        e = { weight: 0, types: /* @__PURE__ */ new Map() };
+        edgeMap.set(key, e);
+      }
+      e.weight++;
+      e.types.set(r.call_type, (e.types.get(r.call_type) ?? 0) + 1);
+    }
+    const importRows = this.db.prepare(
+      `SELECT r.from_id, r.to_name
+       FROM refs r
+       WHERE r.call_type = 'import'`
+    ).all();
+    for (const r of importRows) {
+      const fromPkg = symbolToPkg.get(r.from_id);
+      const toPkg = _IndexStore.packageFromImport(r.to_name);
+      if (!fromPkg || !toPkg || fromPkg === toPkg || !pkgNodes.has(toPkg)) continue;
+      const key = `${fromPkg}\0${toPkg}`;
+      let edge = edgeMap.get(key);
+      if (!edge) {
+        edge = { weight: 0, types: /* @__PURE__ */ new Map() };
+        edgeMap.set(key, edge);
+      }
+      edge.weight++;
+      edge.types.set("import", (edge.types.get("import") ?? 0) + 1);
+    }
+    const edges = [];
+    for (const [key, e] of edgeMap) {
+      const [source, target] = key.split("\0");
+      let bestType = "call";
+      let bestCount = 0;
+      for (const [t, c] of e.types) {
+        if (c > bestCount) {
+          bestType = t;
+          bestCount = c;
+        }
+      }
+      edges.push({
+        source: `pkg:${source}`,
+        target: `pkg:${target}`,
+        weight: e.weight,
+        refType: bestType
+      });
+    }
+    return { nodes: [...pkgNodes.values()], edges };
+  }
+  /**
+   * File-level graph for a single package: each file is a node; edges are
+   * derived from cross-file symbol references within the package.
+   */
+  getFileGraph(packageFilter) {
+    const allSymbols = this.db.prepare("SELECT file, id, name, kind, lang, line FROM symbols ORDER BY id").all();
+    const pkgSyms = allSymbols.filter(
+      (s) => (_IndexStore.derivePackage(s.file) ?? "(root)") === packageFilter
+    );
+    if (pkgSyms.length === 0) return { nodes: [], edges: [] };
+    const fileNodes = /* @__PURE__ */ new Map();
+    const symToFile = /* @__PURE__ */ new Map();
+    const fileStats = /* @__PURE__ */ new Map();
+    for (const s of allSymbols) {
+      symToFile.set(s.id, s.file);
+      const current = fileStats.get(s.file);
+      fileStats.set(s.file, {
+        count: (current?.count ?? 0) + 1,
+        lang: current?.lang ?? s.lang
+      });
+    }
+    const localFiles = new Set(pkgSyms.map((s) => s.file));
+    const indexedFiles = new Set(allSymbols.map((s) => s.file));
+    const ensureFileNode = (file) => {
+      if (fileNodes.has(file)) return;
+      const stats = fileStats.get(file);
+      fileNodes.set(file, {
+        id: `file:${file}`,
+        label: file.replace(/\\/g, "/").split("/").pop() ?? file,
+        kind: "file",
+        package: _IndexStore.derivePackage(file) ?? "(root)",
+        file,
+        symbolCount: stats?.count ?? 0,
+        lang: stats?.lang,
+        external: !localFiles.has(file)
+      });
+    };
+    for (const file of localFiles) {
+      ensureFileNode(file);
+    }
+    const refRows = this.db.prepare(
+      `SELECT r.from_id, r.to_id, r.call_type
+       FROM refs r
+       WHERE r.to_id IS NOT NULL`
+    ).all();
+    const edgeMap = /* @__PURE__ */ new Map();
+    for (const r of refRows) {
+      if (r.call_type === "import") continue;
+      const fromFile = symToFile.get(r.from_id);
+      const toFile = symToFile.get(r.to_id);
+      if (!fromFile || !toFile || fromFile === toFile) continue;
+      if (!localFiles.has(fromFile) && !localFiles.has(toFile)) continue;
+      ensureFileNode(fromFile);
+      ensureFileNode(toFile);
+      const key = `${fromFile}\0${toFile}`;
+      let e = edgeMap.get(key);
+      if (!e) {
+        e = { weight: 0, types: /* @__PURE__ */ new Map() };
+        edgeMap.set(key, e);
+      }
+      e.weight++;
+      e.types.set(r.call_type, (e.types.get(r.call_type) ?? 0) + 1);
+    }
+    const importRows = this.db.prepare(
+      `SELECT r.from_id, r.to_name
+       FROM refs r
+       WHERE r.call_type = 'import'`
+    ).all();
+    for (const r of importRows) {
+      const fromFile = symToFile.get(r.from_id);
+      if (!fromFile || !localFiles.has(fromFile)) continue;
+      const toFile = _IndexStore.resolveRelativeImport(fromFile, r.to_name, indexedFiles);
+      if (!toFile || fromFile === toFile) continue;
+      ensureFileNode(fromFile);
+      ensureFileNode(toFile);
+      const key = `${fromFile}\0${toFile}`;
+      let edge = edgeMap.get(key);
+      if (!edge) {
+        edge = { weight: 0, types: /* @__PURE__ */ new Map() };
+        edgeMap.set(key, edge);
+      }
+      edge.weight++;
+      edge.types.set("import", (edge.types.get("import") ?? 0) + 1);
+    }
+    const edges = [];
+    for (const [key, e] of edgeMap) {
+      const [source, target] = key.split("\0");
+      let bestType = "call";
+      let bestCount = 0;
+      for (const [t, c] of e.types) {
+        if (c > bestCount) {
+          bestType = t;
+          bestCount = c;
+        }
+      }
+      edges.push({
+        source: `file:${source}`,
+        target: `file:${target}`,
+        weight: e.weight,
+        refType: bestType
+      });
+    }
+    return { nodes: [...fileNodes.values()], edges };
+  }
+  /**
+   * Symbol-level graph for a single file: each symbol is a node; edges are
+   * derived from intra-file and cross-file symbol references (who calls whom).
+   */
+  getSymbolGraph(fileFilter) {
+    const allSymbols = this.db.prepare(
+      "SELECT id, name, kind, lang, file, line, signature, scope FROM symbols ORDER BY file, line, id"
+    ).all();
+    const syms = allSymbols.filter((symbol) => symbol.file === fileFilter);
+    if (syms.length === 0) return { nodes: [], edges: [] };
+    const symById = new Map(allSymbols.map((symbol) => [symbol.id, symbol]));
+    const relatedIds = new Set(syms.map((symbol) => symbol.id));
+    const toGraphNode = (s) => ({
+      id: `sym:${s.id}`,
+      label: s.name,
+      kind: "symbol",
+      symbolId: s.id,
+      symbolKind: s.kind,
+      file: s.file,
+      package: _IndexStore.derivePackage(s.file) ?? "(root)",
+      lang: s.lang,
+      line: s.line,
+      signature: s.signature,
+      scope: s.scope,
+      external: s.file !== fileFilter
+    });
+    const symIds = new Set(syms.map((s) => s.id));
+    const refRows = this.db.prepare(
+      `SELECT r.from_id, r.to_id, r.to_name, r.call_type, r.line
+       FROM refs r
+       WHERE r.from_id IN (SELECT id FROM symbols WHERE file = ?)
+          OR r.to_id IN (SELECT id FROM symbols WHERE file = ?)`
+    ).all(fileFilter, fileFilter);
+    const edgeMap = /* @__PURE__ */ new Map();
+    for (const r of refRows) {
+      if (r.to_id === null) continue;
+      if (!symIds.has(r.from_id) && !symIds.has(r.to_id)) continue;
+      relatedIds.add(r.from_id);
+      relatedIds.add(r.to_id);
+      const key = `${r.from_id}\0${r.to_id}`;
+      let e = edgeMap.get(key);
+      if (!e) {
+        e = { weight: 0, types: /* @__PURE__ */ new Map() };
+        edgeMap.set(key, e);
+      }
+      e.weight++;
+      e.types.set(r.call_type, (e.types.get(r.call_type) ?? 0) + 1);
+    }
+    const edges = [];
+    for (const [key, e] of edgeMap) {
+      const [fromId, toId] = key.split("\0").map(Number);
+      let bestType = "call";
+      let bestCount = 0;
+      for (const [t, c] of e.types) {
+        if (c > bestCount) {
+          bestType = t;
+          bestCount = c;
+        }
+      }
+      edges.push({
+        source: `sym:${fromId}`,
+        target: `sym:${toId}`,
+        weight: e.weight,
+        refType: bestType
+      });
+    }
+    const nodes = [...relatedIds].map((id) => symById.get(id)).filter((symbol) => symbol !== void 0).sort((a, b) => {
+      const aExternal = a.file === fileFilter ? 0 : 1;
+      const bExternal = b.file === fileFilter ? 0 : 1;
+      return aExternal - bExternal || a.file.localeCompare(b.file) || a.line - b.line || a.id - b.id;
+    }).map(toGraphNode);
+    return { nodes, edges };
+  }
   close() {
     this.stmtCache.clear();
     try {
@@ -1000,6 +1409,14 @@ function getJsDoc(node, sourceFile) {
   }
   return "";
 }
+function hasFunctionLikeAncestor(node) {
+  let current = node.parent;
+  while (current) {
+    if (ts.isFunctionLike(current)) return true;
+    current = current.parent;
+  }
+  return false;
+}
 function buildScope(node) {
   const parts = [];
   let current = node.parent;
@@ -1027,6 +1444,10 @@ function parseSymbols(opts) {
   function visit(node) {
     const kind = kindOf(node);
     if (kind) {
+      if ((kind === "const" || kind === "let" || kind === "var" || kind === "parameter") && hasFunctionLikeAncestor(node)) {
+        ts.forEachChild(node, visit);
+        return;
+      }
       const nameNode = node.name;
       if (!nameNode || !ts.isIdentifier(nameNode)) return;
       const name = nameNode.text;
@@ -1116,8 +1537,34 @@ function detectLang(file) {
 // src/codebase-index/go-parser.ts
 import { spawn } from "node:child_process";
 import * as os from "node:os";
+import * as path3 from "node:path";
+import * as fs3 from "node:fs/promises";
+
+// src/_win32-resolve.ts
+import * as fs2 from "node:fs";
 import * as path2 from "node:path";
-import * as fs2 from "node:fs/promises";
+function resolveWin32Command(cmd) {
+  if (process.platform !== "win32") return cmd;
+  if (cmd.includes("/") || cmd.includes("\\") || path2.extname(cmd.replace(/\//g, "\\"))) {
+    return cmd;
+  }
+  const pathext = (process.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD;.VBS;.JS;.WS;.MSC").toLowerCase().split(";");
+  const pathDirs = (process.env["PATH"] ?? "").split(path2.delimiter);
+  for (const dir of pathDirs) {
+    const base = path2.join(dir, cmd);
+    for (const ext of pathext) {
+      const full = `${base}${ext}`;
+      try {
+        fs2.accessSync(full, fs2.constants.X_OK);
+        return full;
+      } catch {
+      }
+    }
+  }
+  return cmd;
+}
+
+// src/codebase-index/go-parser.ts
 async function parseSymbols2(opts) {
   const { file, content, lang } = opts;
   try {
@@ -1418,31 +1865,46 @@ func formatType(t ast.Expr) string {
 }
 `;
 async function syncGoParse(filePath, content, lang) {
-  const tmpDir = await fs2.mkdtemp(path2.join(os.tmpdir(), "ws-go-parse-"));
+  const tmpDir = await fs3.mkdtemp(path3.join(os.tmpdir(), "ws-go-parse-"));
   try {
-    const scriptPath = path2.join(tmpDir, "parse.go");
-    await fs2.writeFile(scriptPath, GO_PARSE_SCRIPT, "utf8");
-    const proc = spawn("go", ["run", scriptPath], {
-      stdio: ["pipe", "pipe", "pipe"],
-      windowsHide: true
-    });
-    let stdout = "";
-    proc.stdout?.on("data", (chunk) => {
-      stdout += chunk.toString();
-    });
-    proc.stdin?.write(content);
-    proc.stdin?.end();
-    const { code } = await Promise.race([
-      new Promise((resolve2) => {
-        proc.on("close", (c) => resolve2({ code: c }));
-      }),
-      new Promise(
-        (_, reject) => setTimeout(() => {
+    const scriptPath = path3.join(tmpDir, "parse.go");
+    await fs3.writeFile(scriptPath, GO_PARSE_SCRIPT, "utf8");
+    const goBinary = resolveWin32Command("go");
+    const goResult = await new Promise(
+      (resolve2, reject) => {
+        let settled = false;
+        const proc = spawn(goBinary, ["run", scriptPath], {
+          stdio: ["pipe", "pipe", "pipe"],
+          windowsHide: true
+        });
+        proc.on("error", (err) => {
+          if (settled) return;
+          settled = true;
+          reject(err);
+        });
+        let stdout2 = "";
+        proc.stdout?.on("data", (chunk) => {
+          stdout2 += chunk.toString();
+        });
+        proc.stderr?.resume();
+        proc.stdin?.write(content);
+        proc.stdin?.end();
+        const timer = setTimeout(() => {
+          if (settled) return;
+          settled = true;
           proc.kill("SIGKILL");
           reject(new Error("timeout"));
-        }, 15e3)
-      )
-    ]).catch(() => ({ code: -1 }));
+        }, 15e3);
+        timer.unref?.();
+        proc.on("close", (code2) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          resolve2({ code: code2, stdout: stdout2 });
+        });
+      }
+    );
+    const { code, stdout } = goResult;
     if (code !== 0 || !stdout.trim()) {
       return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
     }
@@ -1464,15 +1926,15 @@ async function syncGoParse(filePath, content, lang) {
   } catch {
     return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
   } finally {
-    await fs2.rm(tmpDir, { recursive: true, force: true });
+    await fs3.rm(tmpDir, { recursive: true, force: true });
   }
 }
 
 // src/codebase-index/py-parser.ts
-import { spawn as spawn2 } from "node:child_process";
-import * as fs3 from "node:fs/promises";
+import { spawn as spawn2, spawnSync } from "node:child_process";
+import * as fs4 from "node:fs/promises";
 import * as os2 from "node:os";
-import * as path3 from "node:path";
+import * as path4 from "node:path";
 async function parseSymbols3(opts) {
   const { file, content, lang } = opts;
   try {
@@ -1684,36 +2146,74 @@ visitor.visit(tree)
 
 print(json.dumps([s.to_dict() for s in syms]))
 `;
-var _cachedScriptPath = null;
-async function syncPyParse(filePath, content, lang) {
-  try {
-    if (!_cachedScriptPath) {
-      const tmpDir = path3.join(os2.tmpdir(), "ws-py-parse");
-      await fs3.mkdir(tmpDir, { recursive: true });
-      _cachedScriptPath = path3.join(tmpDir, "parse.py");
-      await fs3.writeFile(_cachedScriptPath, PY_PARSE_SCRIPT, "utf8");
-    }
-    const proc = spawn2("python", [_cachedScriptPath, filePath], {
+function resolvePython() {
+  const candidates = process.platform === "win32" ? ["python3", "python", "py"] : ["python3", "python"];
+  for (const name of candidates) {
+    const resolved = resolveWin32Command(name);
+    const result = spawnSync(resolved, ["--version"], {
+      stdio: "pipe",
+      timeout: 5e3
+    });
+    if (result.error) continue;
+    if (result.status !== 0) continue;
+    return resolved;
+  }
+  return null;
+}
+function spawnPyParser(pyBinary, scriptPath, filePath, content) {
+  return new Promise((resolve2, reject) => {
+    let settled = false;
+    const proc = spawn2(pyBinary, [scriptPath, filePath], {
       stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true
     });
+    proc.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      reject(err);
+    });
     proc.stdin?.write(content);
     proc.stdin?.end();
     let stdout = "";
     proc.stdout?.on("data", (chunk) => {
       stdout += chunk.toString();
     });
-    const { code } = await Promise.race([
-      new Promise((resolve2) => {
-        proc.on("close", (c) => resolve2({ code: c }));
-      }),
-      new Promise(
-        (_, reject) => setTimeout(() => {
-          proc.kill("SIGKILL");
-          reject(new Error("timeout"));
-        }, 15e3)
-      )
-    ]).catch(() => ({ code: -1 }));
+    proc.stderr?.resume();
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      proc.kill("SIGKILL");
+      reject(new Error("timeout"));
+    }, 15e3);
+    timer.unref?.();
+    proc.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve2({ code, stdout });
+    });
+  });
+}
+var _cachedScriptPath = null;
+var _cachedPyBinary = null;
+async function syncPyParse(filePath, content, lang) {
+  try {
+    if (!_cachedScriptPath) {
+      const tmpDir = path4.join(os2.tmpdir(), "ws-py-parse");
+      await fs4.mkdir(tmpDir, { recursive: true });
+      _cachedScriptPath = path4.join(tmpDir, "parse.py");
+      await fs4.writeFile(_cachedScriptPath, PY_PARSE_SCRIPT, "utf8");
+    }
+    if (!_cachedPyBinary) {
+      _cachedPyBinary = resolvePython();
+      if (!_cachedPyBinary) return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
+    }
+    const { code, stdout } = await spawnPyParser(
+      _cachedPyBinary,
+      _cachedScriptPath,
+      filePath,
+      content
+    );
     if (code !== 0 || !stdout.trim()) {
       return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
     }
@@ -1740,8 +2240,8 @@ async function syncPyParse(filePath, content, lang) {
 // src/codebase-index/rs-parser.ts
 import { expectDefined as expectDefined2 } from "@wrongstack/core";
 import { execFileSync, spawn as spawn3 } from "node:child_process";
-import * as fs4 from "node:fs/promises";
-import * as path4 from "node:path";
+import * as fs5 from "node:fs/promises";
+import * as path5 from "node:path";
 async function parseSymbols4(opts) {
   const { file, content, lang } = opts;
   const nativeAvailable = checkNativeParser();
@@ -1754,7 +2254,7 @@ async function parseSymbols4(opts) {
 function checkNativeParser() {
   try {
     execFileSync("rustc", ["--version"], { stdio: "pipe", windowsHide: true });
-    const toolsDir = path4.join(process.cwd(), "tools");
+    const toolsDir = path5.join(process.cwd(), "tools");
     try {
       execFileSync(
         "cargo",
@@ -1764,7 +2264,7 @@ function checkNativeParser() {
           "--format-version",
           "1",
           "--manifest-path",
-          path4.join(toolsDir, "Cargo.toml")
+          path5.join(toolsDir, "Cargo.toml")
         ],
         { stdio: "pipe", windowsHide: true }
       );
@@ -1778,34 +2278,49 @@ function checkNativeParser() {
 }
 async function tryNativeParse(file, content) {
   try {
-    const toolsDir = path4.join(process.cwd(), "tools");
-    const crateDir = path4.join(toolsDir, "syn-parser");
-    const tmpFile = path4.join(crateDir, "src", "input.rs");
-    await fs4.writeFile(tmpFile, content, "utf8");
-    const proc = spawn3(
-      "cargo",
-      ["run", "--manifest-path", path4.join(toolsDir, "Cargo.toml")],
-      {
-        cwd: process.cwd(),
-        stdio: ["pipe", "pipe", "pipe"],
-        windowsHide: true
-      }
-    );
-    let stdout = "";
-    proc.stdout?.on("data", (chunk) => {
-      stdout += chunk.toString();
-    });
-    const { code } = await Promise.race([
-      new Promise((resolve2) => {
-        proc.on("close", (c) => resolve2({ code: c }));
-      }),
-      new Promise(
-        (_, reject) => setTimeout(() => {
+    const toolsDir = path5.join(process.cwd(), "tools");
+    const crateDir = path5.join(toolsDir, "syn-parser");
+    const tmpFile = path5.join(crateDir, "src", "input.rs");
+    await fs5.writeFile(tmpFile, content, "utf8");
+    const cargoBinary = resolveWin32Command("cargo");
+    const result = await new Promise(
+      (resolve2, reject) => {
+        let settled = false;
+        const proc = spawn3(
+          cargoBinary,
+          ["run", "--manifest-path", path5.join(toolsDir, "Cargo.toml")],
+          {
+            cwd: process.cwd(),
+            stdio: ["pipe", "pipe", "pipe"],
+            windowsHide: true
+          }
+        );
+        proc.on("error", (err) => {
+          if (settled) return;
+          settled = true;
+          reject(err);
+        });
+        let stdout2 = "";
+        proc.stdout?.on("data", (chunk) => {
+          stdout2 += chunk.toString();
+        });
+        proc.stderr?.resume();
+        const timer = setTimeout(() => {
+          if (settled) return;
+          settled = true;
           proc.kill("SIGKILL");
           reject(new Error("timeout"));
-        }, 15e3)
-      )
-    ]).catch(() => ({ code: -1 }));
+        }, 15e3);
+        timer.unref?.();
+        proc.on("close", (c) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          resolve2({ code: c, stdout: stdout2 });
+        });
+      }
+    );
+    const { code, stdout } = result;
     if (code === 0 && stdout.trim()) {
       const symbols = JSON.parse(stdout.trim());
       return {
@@ -1888,7 +2403,7 @@ function regexParse(opts) {
 
 // src/codebase-index/json-parser.ts
 import { expectDefined as expectDefined3 } from "@wrongstack/core";
-import * as path5 from "node:path";
+import * as path6 from "node:path";
 function parseSymbols5(opts) {
   const { file, content, lang } = opts;
   try {
@@ -1900,9 +2415,9 @@ function parseSymbols5(opts) {
 function regexParse2(opts) {
   const { file, content, lang } = opts;
   const symbols = [];
-  const basename2 = path5.basename(file).toLowerCase();
-  const isPackageJson = basename2 === "package.json";
-  const isTsconfig = basename2 === "tsconfig.json" || basename2 === "tsconfig.build.json";
+  const basename3 = path6.basename(file).toLowerCase();
+  const isPackageJson = basename3 === "package.json";
+  const isTsconfig = basename3 === "tsconfig.json" || basename3 === "tsconfig.build.json";
   const isJsonSchema = content.includes("$schema") || content.includes("$id") || content.includes("$ref");
   const isOpenApi = content.includes("openapi") || content.includes("swagger");
   const lines = content.split("\n");
@@ -1926,11 +2441,11 @@ function regexParse2(opts) {
     const line = lineFromOffset(offset);
     symbols.push(
       makeSymbol({
-        name: path5.basename(file),
+        name: path6.basename(file),
         kind: "object",
         line,
         col: 0,
-        signature: `"${path5.basename(file)}" = { ... }`,
+        signature: `"${path6.basename(file)}" = { ... }`,
         file,
         lang
       })
@@ -2241,8 +2756,8 @@ function makeSymbol2(opts) {
 }
 
 // src/codebase-index/gitignore.ts
-import * as fs5 from "node:fs/promises";
-import * as path6 from "node:path";
+import * as fs6 from "node:fs/promises";
+import * as path7 from "node:path";
 import { compileGlob } from "@wrongstack/core";
 function globBody(glob) {
   return compileGlob(glob).source.replace(/^\^/, "").replace(/\$$/, "");
@@ -2288,7 +2803,7 @@ function compileGitignore(lines) {
 async function loadGitignoreMatcher(projectRoot) {
   let lines = [];
   try {
-    const raw = await fs5.readFile(path6.join(projectRoot, ".gitignore"), "utf8");
+    const raw = await fs6.readFile(path7.join(projectRoot, ".gitignore"), "utf8");
     lines = raw.split("\n");
   } catch {
   }
@@ -2304,9 +2819,7 @@ function yieldEventLoop() {
 function throwIfAborted(signal) {
   if (!signal?.aborted) return;
   if (signal.reason instanceof Error) throw signal.reason;
-  throw new Error(
-    typeof signal.reason === "string" ? signal.reason : "Indexing cancelled"
-  );
+  throw new Error(typeof signal.reason === "string" ? signal.reason : "Indexing cancelled");
 }
 function isAbortError(err) {
   return err instanceof DOMException && err.name === "AbortError";
@@ -2322,8 +2835,20 @@ var DEFAULT_IGNORE = [
   "__snapshots__",
   ".nyc_output"
 ];
+var DEFAULT_IGNORE_FILES = /* @__PURE__ */ new Set(["package-lock.json", "pnpm-lock.yaml", "pnpm-lock.yml"]);
+var MAX_INDEX_FILE_BYTES = 5 * 1024 * 1024;
+function isWithinProject(projectRoot, file) {
+  const rel = path8.relative(projectRoot, file);
+  return rel !== "" && !rel.startsWith(`..${path8.sep}`) && rel !== ".." && !path8.isAbsolute(rel);
+}
+function isMissingPathError(err) {
+  const code = err?.code;
+  return code === "ENOENT" || code === "ENOTDIR";
+}
 async function findSourceFiles(projectRoot, ignore, isGitIgnored, signal) {
   const results = [];
+  const errors = [];
+  let complete = true;
   const ignoreSet = /* @__PURE__ */ new Set([...DEFAULT_IGNORE, ...ignore]);
   const globs = [
     { ext: ".ts", pat: compileGlob2("**/*.ts") },
@@ -2346,21 +2871,23 @@ async function findSourceFiles(projectRoot, ignore, isGitIgnored, signal) {
     }
     let entries;
     try {
-      entries = await fs6.readdir(dir, { withFileTypes: true });
-    } catch {
+      entries = await fs7.readdir(dir, { withFileTypes: true });
+    } catch (err) {
+      complete = false;
+      errors.push(`scan error: ${dir}: ${err instanceof Error ? err.message : String(err)}`);
       return;
     }
     dirCount++;
     for (const e of entries) {
       if (ignoreSet.has(e.name)) continue;
-      const full = path7.join(dir, e.name);
-      const rel = path7.relative(projectRoot, full).replace(/\\/g, "/");
+      const full = path8.join(dir, e.name);
+      const rel = path8.relative(projectRoot, full).replace(/\\/g, "/");
       if (e.isDirectory()) {
         if (isGitIgnored(rel, true)) continue;
         await walk(full);
       } else if (e.isFile()) {
-        if (isGitIgnored(rel, false)) continue;
-        const ext = path7.extname(e.name);
+        if (DEFAULT_IGNORE_FILES.has(e.name) || isGitIgnored(rel, false)) continue;
+        const ext = path8.extname(e.name).toLowerCase();
         for (const { ext: extName, pat } of globs) {
           if (ext === extName && (pat.test(rel) || pat.test(e.name))) {
             results.push(full);
@@ -2371,7 +2898,7 @@ async function findSourceFiles(projectRoot, ignore, isGitIgnored, signal) {
     }
   };
   await walk(projectRoot);
-  return results;
+  return { files: results, complete, errors };
 }
 async function parseFile(file, content, lang) {
   switch (lang) {
@@ -2394,6 +2921,26 @@ async function parseFile(file, content, lang) {
       return { file, lang, symbols: [], mtimeMs: Date.now() };
   }
 }
+function assignRefsToSymbols2(refs, symbols) {
+  if (refs.length === 0 || symbols.length === 0) return [];
+  const ordered = [...symbols].sort((a, b) => a.line - b.line || a.col - b.col || a.id - b.id);
+  const seen = /* @__PURE__ */ new Set();
+  const assigned = [];
+  for (const ref of refs) {
+    let owner;
+    for (const symbol of ordered) {
+      if (symbol.line > ref.line) break;
+      owner = symbol;
+    }
+    if (!owner && ref.callType === "import") owner = ordered[0];
+    if (!owner || owner.id <= 0) continue;
+    const key = `${owner.id}:${ref.toName}:${ref.callType}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    assigned.push({ ...ref, fromId: owner.id });
+  }
+  return assigned;
+}
 async function runIndexer(_ctx, opts) {
   const store = new IndexStore(opts.projectRoot, { indexDir: opts.indexDir });
   try {
@@ -2406,7 +2953,9 @@ async function runIndexer(_ctx, opts) {
   }
 }
 async function runIndexerWithStore(store, opts) {
-  const { projectRoot, force = false, langs, ignore = [], signal } = opts;
+  const { projectRoot, langs, ignore = [], signal } = opts;
+  const relationGraphVersion = "2";
+  const force = (opts.force ?? false) || store.getMetadata("relation_graph_version") !== relationGraphVersion;
   const startMs = Date.now();
   const errors = [];
   const langStats = {};
@@ -2415,10 +2964,18 @@ async function runIndexerWithStore(store, opts) {
   const isGitIgnored = await loadGitignoreMatcher(projectRoot);
   let files;
   let discoveredFiles = null;
+  let discoveryComplete = true;
   if (opts.files && opts.files.length > 0) {
-    files = opts.files.map((f) => path7.resolve(projectRoot, f)).filter((f) => !isGitIgnored(path7.relative(projectRoot, f).replace(/\\/g, "/"), false));
+    files = opts.files.map((f) => path8.resolve(projectRoot, f)).filter((f) => {
+      if (!isWithinProject(projectRoot, f)) return false;
+      const rel = path8.relative(projectRoot, f).replace(/\\/g, "/");
+      return !rel.split("/").some((seg) => DEFAULT_IGNORE.includes(seg)) && !DEFAULT_IGNORE_FILES.has(path8.basename(f)) && !isGitIgnored(rel, false);
+    });
   } else {
-    files = await findSourceFiles(projectRoot, ignore, isGitIgnored, signal);
+    const discovery = await findSourceFiles(projectRoot, ignore, isGitIgnored, signal);
+    files = discovery.files;
+    errors.push(...discovery.errors);
+    discoveryComplete = discovery.complete;
     discoveredFiles = new Set(files);
   }
   if (langs && langs.length > 0) {
@@ -2443,36 +3000,66 @@ async function runIndexerWithStore(store, opts) {
     }
     const statOpts = signal ? { signal } : {};
     const statReadParse = await Promise.allSettled(
-      batchFiles.map(async (file) => {
-        let stat2;
-        try {
-          stat2 = await fs6.stat(file, statOpts);
-        } catch (e) {
-          if (isAbortError(e)) throw e;
-          return { file, stat: null, lang: "", parsed: null, error: `stat error: ${e instanceof Error ? e.message : String(e)}` };
-        }
-        if (!stat2.isFile()) return { file, stat: stat2, lang: "", parsed: null };
-        const lang = detectLang(file);
-        if (!lang) return { file, stat: stat2, lang: "", parsed: null };
-        const meta = existingMeta.get(file);
-        if (!force && meta && meta.mtimeMs === Math.floor(stat2.mtimeMs)) {
-          return { file, stat: stat2, lang, parsed: null, skippedMeta: meta };
-        }
-        let content;
-        try {
-          content = await fs6.readFile(file, { encoding: "utf8", signal });
-        } catch (e) {
-          if (isAbortError(e)) throw e;
-          return { file, stat: stat2, lang, parsed: null, error: `read error: ${e instanceof Error ? e.message : String(e)}` };
-        }
-        let parsed;
-        try {
-          parsed = await parseFile(file, content, lang);
-        } catch (e) {
-          return { file, stat: stat2, lang, parsed: null, error: `parse error: ${e instanceof Error ? e.message : String(e)}` };
+      batchFiles.map(
+        async (file) => {
+          let stat2;
+          try {
+            stat2 = await fs7.stat(file, statOpts);
+          } catch (e) {
+            if (isAbortError(e)) throw e;
+            return {
+              file,
+              stat: null,
+              lang: "",
+              parsed: null,
+              error: `stat error: ${e instanceof Error ? e.message : String(e)}`,
+              missing: isMissingPathError(e)
+            };
+          }
+          if (!stat2.isFile()) return { file, stat: stat2, lang: "", parsed: null };
+          const lang = detectLang(file);
+          if (!lang) return { file, stat: stat2, lang: "", parsed: null };
+          if (stat2.size > MAX_INDEX_FILE_BYTES) {
+            return {
+              file,
+              stat: stat2,
+              lang,
+              parsed: null,
+              error: `file too large (${stat2.size} bytes; max ${MAX_INDEX_FILE_BYTES})`
+            };
+          }
+          const meta = existingMeta.get(file);
+          if (!force && meta && meta.mtimeMs === Math.floor(stat2.mtimeMs)) {
+            return { file, stat: stat2, lang, parsed: null, skippedMeta: meta };
+          }
+          let content;
+          try {
+            content = await fs7.readFile(file, { encoding: "utf8", signal });
+          } catch (e) {
+            if (isAbortError(e)) throw e;
+            return {
+              file,
+              stat: stat2,
+              lang,
+              parsed: null,
+              error: `read error: ${e instanceof Error ? e.message : String(e)}`
+            };
+          }
+          let parsed;
+          try {
+            parsed = await parseFile(file, content, lang);
+          } catch (e) {
+            return {
+              file,
+              stat: stat2,
+              lang,
+              parsed: null,
+              error: `parse error: ${e instanceof Error ? e.message : String(e)}`
+            };
+          }
+          return { file, stat: stat2, lang, parsed, content };
         }
-        return { file, stat: stat2, lang, parsed, content };
-      })
+      )
     );
     const batchEntries = [];
     const deleteForFiles = [];
@@ -2487,8 +3074,8 @@ async function runIndexerWithStore(store, opts) {
       }
       const result = settled.value;
       if (result.error) {
-        if (result.stat) store.deleteFile(file);
-        if (result.error.includes("error:")) errors.push(result.error);
+        if (result.missing) store.deleteFile(file);
+        errors.push(`${file}: ${result.error}`);
         continue;
       }
       const { stat: stat2, lang, parsed } = result;
@@ -2512,6 +3099,8 @@ async function runIndexerWithStore(store, opts) {
         continue;
       }
       if (parsed.symbols.length === 0) {
+        store.deleteRefsForFile(file);
+        store.deleteSymbolsForFile(file);
         store.upsertFile({
           file,
           lang,
@@ -2522,15 +3111,11 @@ async function runIndexerWithStore(store, opts) {
         filesIndexed++;
         continue;
       }
-      const refs = [];
-      if (parsed.refs && parsed.refs.length > 0) {
-        for (const r of parsed.refs) refs.push({ ...r, fromId: 0 });
-      }
       batchEntries.push({
         file,
         lang,
         symbols: parsed.symbols,
-        refs,
+        refs: parsed.refs ?? [],
         mtimeMs: Math.floor(stat2.mtimeMs),
         symbolCount: parsed.symbols.length
       });
@@ -2538,34 +3123,12 @@ async function runIndexerWithStore(store, opts) {
     }
     if (batchEntries.length > 0) {
       try {
-        const inserted = store.commitBatch(batchEntries, { deleteForFiles });
-        let cursor = 0;
+        store.commitBatch(batchEntries, { deleteForFiles });
         for (const entry of batchEntries) {
           const count = entry.symbols.length;
-          const symbolsWithIds = inserted.slice(cursor, cursor + count);
-          cursor += count;
           symbolsIndexed += count;
           langStats[entry.lang] = (langStats[entry.lang] ?? 0) + count;
           filesIndexed++;
-          if (entry.refs.length > 0 && symbolsWithIds.length > 0) {
-            const refsByLine = /* @__PURE__ */ new Map();
-            for (let i = 0; i < symbolsWithIds.length; i++) {
-              const sym = symbolsWithIds[i];
-              let arr = refsByLine.get(sym.line);
-              if (!arr) {
-                arr = [];
-                refsByLine.set(sym.line, arr);
-              }
-              arr.push(i);
-            }
-            for (const ref of entry.refs) {
-              const indices = refsByLine.get(ref.line);
-              if (indices && indices.length > 0) {
-                const idx = indices.shift();
-                ref.fromId = symbolsWithIds[idx].id;
-              }
-            }
-          }
         }
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
@@ -2579,23 +3142,7 @@ async function runIndexerWithStore(store, opts) {
             langStats[entry.lang] = (langStats[entry.lang] ?? 0) + symbolsWithIds.length;
             filesIndexed++;
             if (entry.refs.length > 0 && symbolsWithIds.length > 0) {
-              const refsByLine = /* @__PURE__ */ new Map();
-              for (const sym of symbolsWithIds) {
-                let arr = refsByLine.get(sym.line);
-                if (!arr) {
-                  arr = [];
-                  refsByLine.set(sym.line, arr);
-                }
-                arr.push(sym);
-              }
-              const fallbackBatch = [];
-              for (const ref of entry.refs) {
-                const syms = refsByLine.get(ref.line);
-                if (syms && syms.length > 0) {
-                  const sym = syms.shift();
-                  fallbackBatch.push({ ...ref, fromId: sym.id });
-                }
-              }
+              const fallbackBatch = assignRefsToSymbols2(entry.refs, symbolsWithIds);
               if (fallbackBatch.length > 0) store.insertRefsBatch(fallbackBatch);
             }
             store.upsertFile({
@@ -2606,19 +3153,23 @@ async function runIndexerWithStore(store, opts) {
               lastIndexed: Date.now()
             });
           } catch (innerErr) {
-            errors.push(`fallback write failed: ${entry.file}: ${innerErr instanceof Error ? innerErr.message : String(innerErr)}`);
+            errors.push(
+              `fallback write failed: ${entry.file}: ${innerErr instanceof Error ? innerErr.message : String(innerErr)}`
+            );
           }
         }
       }
     }
   }
-  if (discoveredFiles) {
+  if (discoveredFiles && discoveryComplete) {
     for (const [file_] of existingMeta) {
       if (!discoveredFiles.has(file_)) {
         store.deleteFile(file_);
       }
     }
   }
+  store.resolveRefs();
+  store.setMetadata("relation_graph_version", relationGraphVersion);
   const durationMs = Date.now() - startMs;
   store.setLastIndexed(Date.now());
   return {
@@ -2721,7 +3272,8 @@ port.on("message", (msg) => {
           type: "response",
           id: msg.id,
           ok: false,
-          error: err instanceof Error ? err.message : String(err)
+          error: err instanceof Error ? err.message : String(err),
+          errorName: err instanceof Error ? err.name : void 0
         });
       } catch {
       }