@wrongstack/tools 0.236.0 → 0.250.0

package/dist/codebase-index/worker.js

@@ -0,0 +1,2321 @@
+import { parentPort } from 'node:worker_threads';
+import { expectDefined, resolveWstackPaths, compileGlob, truncate } from '@wrongstack/core';
+import * as fs3 from 'node:fs/promises';
+import * as path4 from 'node:path';
+import { createRequire } from 'node:module';
+import * as fs from 'node:fs';
+import { writeFileSync, mkdirSync } from 'node:fs';
+import * as ts from 'typescript';
+import { execFileSync, spawnSync } from 'node:child_process';
+import * as os from 'node:os';
+
+// src/codebase-index/worker.ts
+
+// src/codebase-index/circuit-breaker.ts
+var LockError = class extends Error {
+  name = "LockError";
+};
+var IndexCircuitBreaker = class {
+  failureThreshold;
+  cooldownMs;
+  now;
+  state = "closed";
+  consecutiveFailures = 0;
+  openedAt = 0;
+  lastFailure = null;
+  probeInFlight = false;
+  constructor(opts = {}) {
+    this.failureThreshold = opts.failureThreshold ?? 3;
+    this.cooldownMs = opts.cooldownMs ?? 6e4;
+    this.now = opts.now ?? Date.now;
+  }
+  /**
+   * True when a run may proceed. An open circuit transitions to half-open once
+   * the cooldown has elapsed, admitting exactly one probe; further requests
+   * are rejected until that probe settles via recordSuccess/recordFailure.
+   */
+  allowRequest() {
+    if (this.state === "closed") return true;
+    if (this.state === "open") {
+      if (this.now() - this.openedAt < this.cooldownMs) return false;
+      this.state = "half-open";
+      this.probeInFlight = true;
+      return true;
+    }
+    if (this.probeInFlight) return false;
+    this.probeInFlight = true;
+    return true;
+  }
+  recordSuccess() {
+    this.state = "closed";
+    this.consecutiveFailures = 0;
+    this.lastFailure = null;
+    this.probeInFlight = false;
+  }
+  recordFailure(err) {
+    if (err instanceof LockError) {
+      this.lastFailure = `[transient/lock] ${err.message}`;
+      this.probeInFlight = false;
+      return;
+    }
+    this.lastFailure = err instanceof Error ? err.message : String(err);
+    this.probeInFlight = false;
+    this.consecutiveFailures++;
+    if (this.state === "half-open" || this.consecutiveFailures >= this.failureThreshold) {
+      this.state = "open";
+      this.openedAt = this.now();
+    }
+  }
+  /** Force-close the circuit (manual recovery: `/codebase-reindex`). */
+  reset() {
+    this.state = "closed";
+    this.consecutiveFailures = 0;
+    this.lastFailure = null;
+    this.probeInFlight = false;
+    this.openedAt = 0;
+  }
+  snapshot() {
+    return {
+      state: this.state,
+      consecutiveFailures: this.consecutiveFailures,
+      lastFailure: this.lastFailure,
+      cooldownRemainingMs: this.state === "open" ? Math.max(0, this.cooldownMs - (this.now() - this.openedAt)) : 0
+    };
+  }
+};
+new IndexCircuitBreaker();
+
+// src/codebase-index/schema.ts
+var SCHEMA_VERSION = 2;
+
+// src/codebase-index/lsp-kind.ts
+function lspKindToInternalKind(k) {
+  switch (k) {
+    case 5 /* Class */:
+      return "class";
+    case 6 /* Method */:
+      return "method";
+    case 7 /* Property */:
+    case 8 /* Field */:
+      return "property";
+    case 9 /* Constructor */:
+      return "class";
+    case 10 /* Enum */:
+      return "enum";
+    case 11 /* Interface */:
+      return "interface";
+    case 12 /* Function */:
+      return "function";
+    case 13 /* Variable */:
+      return "var";
+    case 14 /* Constant */:
+      return "const";
+    case 22 /* EnumMember */:
+      return "enum";
+    case 26 /* TypeParameter */:
+      return "type";
+    case 3 /* Namespace */:
+      return "namespace";
+    default:
+      return null;
+  }
+}
+
+// src/codebase-index/bm25.ts
+var K1 = 1.5;
+var B = 0.75;
+function tokenise(text) {
+  const sanitised = text.replace(/[^\p{L}\p{N}$'_]/gu, " ").replace(/_/g, " ");
+  return sanitised.toLowerCase().split(" ").filter(Boolean);
+}
+function splitName(name) {
+  return name.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").trim();
+}
+function buildIndexableText(name, signature, docComment) {
+  return [splitName(name), name, signature, docComment].filter(Boolean).join(" ");
+}
+function buildBm25Index(docs) {
+  const documents = docs.map((d) => {
+    const tokens = tokenise(d.text);
+    return { id: d.id, tokens, raw: d.text, len: tokens.length };
+  });
+  const df = {};
+  for (const doc of documents) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const t of doc.tokens) {
+      if (!seen.has(t)) {
+        df[t] = (df[t] ?? 0) + 1;
+        seen.add(t);
+      }
+    }
+  }
+  const N = documents.length;
+  const totalLen = documents.reduce((sum, d) => sum + d.len, 0);
+  const avgLen = N === 0 ? 0 : totalLen / N;
+  return new Bm25Index(documents, df, N, avgLen);
+}
+var Bm25Index = class {
+  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) {
+    const qTokens = tokenise(query);
+    if (qTokens.length === 0) return [];
+    const results = [];
+    for (const doc of this.documents) {
+      if (filter && !filter(doc.id)) continue;
+      let docScore = 0;
+      for (const qTerm of qTokens) {
+        let tf = 0;
+        for (const t of doc.tokens) {
+          if (t === qTerm) tf++;
+        }
+        if (tf === 0) continue;
+        const dfVal = this.df[qTerm] ?? 0;
+        if (dfVal === 0) continue;
+        const idf = Math.log((this.N - dfVal + 0.5) / (dfVal + 0.5) + 1);
+        const lenRatio = B * (doc.len / this.safeAvgLen);
+        const tfComponent = tf * (K1 + 1) / (tf + K1 * (1 - B + lenRatio));
+        docScore += idf * tfComponent;
+      }
+      if (docScore > 0) results.push({ id: doc.id, score: docScore });
+    }
+    return results;
+  }
+  getDoc(id) {
+    return this.documents.find((d) => d.id === id);
+  }
+  extractSnippet(docId, queryTokens, radius = 40) {
+    const doc = this.getDoc(docId);
+    if (!doc) return "";
+    for (const tok of queryTokens) {
+      const idx = doc.raw.toLowerCase().indexOf(tok);
+      if (idx !== -1) {
+        const start = Math.max(0, idx - radius);
+        const end = Math.min(doc.raw.length, idx + tok.length + radius);
+        const excerpt = doc.raw.slice(start, end);
+        const ellipsis = "\u2026";
+        return (start > 0 ? ellipsis : "") + excerpt + (end < doc.raw.length ? ellipsis : "");
+      }
+    }
+    return doc.raw.slice(0, radius * 2) + (doc.raw.length > radius * 2 ? "\u2026" : "");
+  }
+};
+
+// src/codebase-index/writer.ts
+var DB_FILE = "index.db";
+function resolveIndexDir(projectRoot, override) {
+  return override ?? resolveWstackPaths({ projectRoot }).projectCodebaseIndex;
+}
+var warningSilenced = false;
+function silenceSqliteExperimentalWarning() {
+  if (warningSilenced) return;
+  warningSilenced = true;
+  const original = process.emitWarning.bind(process);
+  process.emitWarning = ((warning, ...rest) => {
+    const msg = typeof warning === "string" ? warning : warning?.message ?? "";
+    const name = typeof warning === "string" ? String(rest[0] ?? "") : warning?.name ?? "";
+    if (/sqlite/i.test(msg) && /experimental/i.test(`${name} ${msg}`)) return;
+    original(warning, ...rest);
+  });
+}
+var DatabaseSyncCtor;
+function loadDatabaseSync() {
+  if (DatabaseSyncCtor) return DatabaseSyncCtor;
+  silenceSqliteExperimentalWarning();
+  try {
+    const req = createRequire(import.meta.url);
+    DatabaseSyncCtor = req("node:sqlite").DatabaseSync;
+  } catch (err) {
+    throw new Error(
+      `The codebase index needs Node's built-in SQLite (node:sqlite), available since Node 22.5. This runtime doesn't provide it: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  return DatabaseSyncCtor;
+}
+var MAX_LOCK_RETRIES = 3;
+var LOCK_RETRY_BASE_DELAY_MS = 50;
+var LOCK_RETRY_MAX_DELAY_MS = 500;
+function isLockError(err) {
+  if (!(err instanceof Error)) return false;
+  const e = err;
+  const code = e.code ?? e.sqliteCode;
+  if (typeof code === "string" && /SQLITE_(BUSY|LOCKED)/.test(code)) return true;
+  if (typeof code === "number" && (code === 5 || code === 6)) return true;
+  if (/SQLITE_(BUSY|LOCKED)/.test(err.message)) return true;
+  return false;
+}
+function sleepSync(ms) {
+  try {
+    const sab = new SharedArrayBuffer(4);
+    const view = new Int32Array(sab);
+    Atomics.wait(view, 0, 0, ms);
+  } catch {
+  }
+}
+var IndexStore = class {
+  db;
+  /** Absolute path to this project's index directory. */
+  indexDir;
+  /**
+   * True when the SQLite build provides FTS5 (Node's bundled SQLite does).
+   * When false, ranked search falls back to the LIKE + in-process BM25 path.
+   */
+  ftsAvailable = false;
+  /**
+   * Execute a SQLite write operation with automatic retry on lock conflicts.
+   *
+   * When another wstack process is holding the write lock the statement first
+   * waits up to `busy_timeout` ms, then throws SQLITE_BUSY.  This wrapper catches
+   * that error and retries (up to MAX_LOCK_RETRIES) with exponential backoff,
+   * giving the competing writer time to finish and release the lock.
+   *
+   * @param fn  The write operation to execute. Can return a value which is
+   *            returned to the caller on success.
+   * @throws   {@link LockError} when all retries are exhausted on a lock conflict
+   *            (non-lock errors always propagate on the first attempt).
+   */
+  runWithRetry(fn) {
+    let lastError;
+    for (let attempt = 0; attempt <= MAX_LOCK_RETRIES; attempt++) {
+      try {
+        return fn();
+      } catch (err) {
+        lastError = err;
+        if (!isLockError(err)) throw err;
+        if (attempt === MAX_LOCK_RETRIES) {
+          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 * Math.pow(2, attempt),
+          LOCK_RETRY_MAX_DELAY_MS
+        );
+        sleepSync(delay);
+      }
+    }
+    throw lastError;
+  }
+  constructor(projectRoot, opts = {}) {
+    this.indexDir = resolveIndexDir(projectRoot, opts.indexDir);
+    fs.mkdirSync(this.indexDir, { recursive: true });
+    const Database = loadDatabaseSync();
+    this.db = new Database(path4.join(this.indexDir, DB_FILE));
+    try {
+      this.db.exec("PRAGMA journal_mode = WAL");
+      this.db.exec("PRAGMA busy_timeout = 5000");
+    } catch {
+    }
+    this.initSchema();
+  }
+  initSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS metadata (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+    `);
+    const storedRows = this.db.prepare("SELECT value FROM metadata WHERE key = ?").all("version");
+    const storedVersion = storedRows.length ? Number(storedRows[0]?.value) : null;
+    if (storedVersion !== null && storedVersion !== SCHEMA_VERSION) {
+      this.db.exec(`
+        DROP TABLE IF EXISTS symbols;
+        DROP TABLE IF EXISTS files;
+        DROP TABLE IF EXISTS refs;
+      `);
+      this.db.exec("DROP TABLE IF EXISTS symbols_fts");
+      this.db.prepare("UPDATE metadata SET value = ? WHERE key = ?").run(String(SCHEMA_VERSION), "version");
+    } else if (storedVersion === null) {
+      this.db.prepare("INSERT INTO metadata(key, value) VALUES (?, ?)").run("version", String(SCHEMA_VERSION));
+    }
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS files (
+        file TEXT PRIMARY KEY,
+        lang TEXT NOT NULL,
+        mtime_ms INTEGER NOT NULL,
+        symbol_count INTEGER NOT NULL DEFAULT 0,
+        last_indexed INTEGER NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS symbols (
+        id INTEGER PRIMARY KEY,
+        lang TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        name TEXT NOT NULL,
+        file TEXT NOT NULL,
+        line INTEGER NOT NULL,
+        col INTEGER NOT NULL,
+        signature TEXT NOT NULL DEFAULT '',
+        doc_comment TEXT NOT NULL DEFAULT '',
+        scope TEXT NOT NULL DEFAULT '',
+        text TEXT NOT NULL DEFAULT '',
+        file_fk TEXT NOT NULL
+      );
+    `);
+    this.db.exec("CREATE INDEX IF NOT EXISTS idx_s_name ON symbols(name)");
+    this.db.exec("CREATE INDEX IF NOT EXISTS idx_s_kind ON symbols(kind)");
+    this.db.exec("CREATE INDEX IF NOT EXISTS idx_s_lang ON symbols(lang)");
+    this.db.exec("CREATE INDEX IF NOT EXISTS idx_s_file ON symbols(file)");
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS refs (
+        id INTEGER PRIMARY KEY,
+        from_id INTEGER NOT NULL,
+        to_name TEXT NOT NULL,
+        to_id INTEGER,
+        call_type TEXT NOT NULL,
+        line INTEGER NOT NULL
+      );
+    `);
+    this.db.exec("CREATE INDEX IF NOT EXISTS idx_r_from ON refs(from_id)");
+    this.db.exec("CREATE INDEX IF NOT EXISTS idx_r_to_id ON refs(to_id)");
+    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.ftsAvailable = true;
+    } catch {
+      this.ftsAvailable = false;
+    }
+  }
+  // ─── Symbol CRUD ─────────────────────────────────────────────────────────────
+  insertSymbols(symbols, nextId) {
+    return this.runWithRetry(() => {
+      const stmt = this.db.prepare(
+        `INSERT INTO symbols(id, lang, kind, name, file, line, col, signature, doc_comment, scope, text, file_fk)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      );
+      const ftsStmt = this.ftsAvailable ? this.db.prepare("INSERT INTO symbols_fts(rowid, text) VALUES (?, ?)") : null;
+      let id = nextId;
+      for (const s of symbols) {
+        stmt.run(
+          id,
+          s.lang,
+          s.kind,
+          s.name,
+          s.file,
+          s.line,
+          s.col,
+          s.signature,
+          s.docComment,
+          s.scope,
+          s.text,
+          s.file
+        );
+        ftsStmt?.run(id, buildIndexableText(s.name, s.signature, s.docComment));
+        id++;
+      }
+      return id;
+    });
+  }
+  deleteSymbolsForFile(file) {
+    this.runWithRetry(() => {
+      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 symbols WHERE file_fk = ?").run(file);
+    });
+  }
+  /**
+   * Remove every trace of a file (refs, symbols, FTS rows, file meta). Used
+   * when a source file disappears between index runs — previously this only
+   * dropped the `files` row, leaving its symbols orphaned but still searchable.
+   */
+  deleteFile(file) {
+    this.runWithRetry(() => {
+      this.deleteRefsForFile(file);
+      this.deleteSymbolsForFile(file);
+      this.db.prepare("DELETE FROM files WHERE file = ?").run(file);
+    });
+  }
+  // ─── File metadata ──────────────────────────────────────────────────────────
+  upsertFile(meta) {
+    this.runWithRetry(() => {
+      this.db.prepare(
+        `INSERT INTO files(file, lang, mtime_ms, symbol_count, last_indexed)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(file) DO UPDATE SET
+           lang = excluded.lang,
+           mtime_ms = excluded.mtime_ms,
+           symbol_count = excluded.symbol_count,
+           last_indexed = excluded.last_indexed`
+      ).run(meta.file, meta.lang, meta.mtimeMs, meta.symbolCount, meta.lastIndexed);
+    });
+  }
+  getFileMeta(file) {
+    const rows = this.db.prepare(
+      "SELECT file, lang, mtime_ms, symbol_count, last_indexed FROM files WHERE file = ?"
+    ).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 };
+  }
+  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 })
+    );
+  }
+  // ─── Search ──────────────────────────────────────────────────────────────────
+  search(query, filter) {
+    const conditions = [];
+    const values = [];
+    let effectiveKind = filter?.kind;
+    if (filter?.lspKind !== void 0) {
+      const mapped = lspKindToInternalKind(filter.lspKind);
+      if (mapped !== null) {
+        effectiveKind = mapped;
+      } else {
+        return [];
+      }
+    }
+    if (effectiveKind) {
+      conditions.push("kind = ?");
+      values.push(effectiveKind);
+    }
+    if (filter?.lang) {
+      conditions.push("lang = ?");
+      values.push(filter.lang);
+    }
+    if (filter?.file) {
+      conditions.push("file LIKE ?");
+      values.push(`%${filter.file}%`);
+    }
+    if (query.trim()) {
+      const tokens = query.toLowerCase().split(/\s+/).filter(Boolean);
+      const tokenConds = tokens.map(() => "text LIKE ?");
+      conditions.push(`(${tokenConds.join(" OR ")})`);
+      for (const t of tokens) values.push(`%${t}%`);
+    }
+    const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+    const sql = `SELECT id, lang, kind, name, file, line, col, signature, doc_comment, text FROM symbols ${where}`;
+    const stmt = this.db.prepare(sql);
+    const rows = stmt.all(...values);
+    return rows.map((r) => ({
+      id: r.id,
+      lang: r.lang,
+      kind: r.kind,
+      name: r.name,
+      file: r.file,
+      line: r.line,
+      col: r.col,
+      signature: r.signature,
+      docComment: r.doc_comment,
+      score: 0,
+      snippet: "",
+      lspKind: filter?.lspKind
+    }));
+  }
+  /**
+   * Ranked search — the one-stop query the codebase-search tool and plug-lsp
+   * use. With FTS5 this is a single indexed `MATCH` ranked by SQLite's native
+   * `bm25()` with a built-in `snippet()`; without FTS5 it falls back to the
+   * legacy LIKE scan + in-process BM25 (identical semantics, slower).
+   *
+   * Tokens are matched as prefixes (`"tok"*`), mirroring the old
+   * `LIKE '%tok%'` recall for the common symbol-search shapes ("user" finds
+   * "users", camelCase-split text makes "complex" find "complexOperation").
+   */
+  searchRanked(query, filter, limit) {
+    const tokens = tokenise(query);
+    if (tokens.length === 0 || !this.ftsAvailable) {
+      return this.searchRankedFallback(query, filter, limit);
+    }
+    let effectiveKind = filter?.kind;
+    if (filter?.lspKind !== void 0) {
+      const mapped = lspKindToInternalKind(filter.lspKind);
+      if (mapped === null) return { results: [], total: 0 };
+      effectiveKind = mapped;
+    }
+    const match = tokens.map((t) => `"${t.replaceAll('"', "")}"*`).join(" OR ");
+    const conditions = ["symbols_fts MATCH ?"];
+    const values = [match];
+    if (effectiveKind) {
+      conditions.push("s.kind = ?");
+      values.push(effectiveKind);
+    }
+    if (filter?.lang) {
+      conditions.push("s.lang = ?");
+      values.push(filter.lang);
+    }
+    if (filter?.file) {
+      conditions.push("s.file LIKE ?");
+      values.push(`%${filter.file}%`);
+    }
+    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 total = countRows[0] ? Number(countRows[0].n) : 0;
+    if (total === 0) return { results: [], total: 0 };
+    const rows = this.db.prepare(
+      `SELECT s.id, s.lang, s.kind, s.name, s.file, s.line, s.col, s.signature, s.doc_comment,
+                -bm25(symbols_fts) AS score,
+                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)
+         LIMIT ?`
+    ).all(...values, limit);
+    return {
+      results: rows.map((r) => ({
+        id: r.id,
+        lang: r.lang,
+        kind: r.kind,
+        name: r.name,
+        file: r.file,
+        line: r.line,
+        col: r.col,
+        signature: r.signature,
+        docComment: r.doc_comment,
+        // bm25() is negative-is-better; negate so callers keep "higher is
+        // better" and clamp so a match never reports a zero score.
+        score: Math.max(1e-4, r.score),
+        snippet: r.snippet,
+        lspKind: filter?.lspKind
+      })),
+      total
+    };
+  }
+  /** Legacy ranked path: LIKE candidates + in-process BM25 + JS snippets. */
+  searchRankedFallback(query, filter, limit) {
+    const candidates = this.search(query, filter);
+    if (candidates.length === 0) return { results: [], total: 0 };
+    if (!query.trim()) {
+      return { results: candidates.slice(0, limit), total: candidates.length };
+    }
+    const bm25 = buildBm25Index(
+      candidates.map((c) => ({ id: c.id, text: buildIndexableText(c.name, c.signature, c.docComment) }))
+    );
+    const scored = bm25.score(query, (id) => candidates.some((c) => c.id === id));
+    scored.sort((a, b) => b.score - a.score);
+    const qTokens = tokenise(query);
+    const results = scored.slice(0, limit).map(({ id, score }) => {
+      const c = expectDefined(candidates.find((cand) => cand.id === id));
+      return { ...c, score, snippet: bm25.extractSnippet(id, qTokens) };
+    });
+    return { results, total: candidates.length };
+  }
+  getAllIndexable() {
+    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
+   * allocated from this, NOT from `COUNT(*)`: incremental reindexes delete a
+   * changed file's rows, so the row count drops below the max id and a
+   * count-based id would collide with a surviving row (UNIQUE constraint on
+   * `symbols.id`). Ids may have gaps — that is fine.
+   */
+  getMaxSymbolId() {
+    const rows = this.db.prepare("SELECT MAX(id) AS m FROM symbols").all();
+    return rows[0]?.m ?? 0;
+  }
+  // ─── Stats ───────────────────────────────────────────────────────────────────
+  getStats() {
+    const sizeBytes = this.sizeBytes();
+    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 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 byKind = {};
+    for (const row of kindRows) byKind[row.kind] = Number(row["COUNT(*)"]);
+    return {
+      totalSymbols,
+      totalFiles,
+      byLang,
+      byKind,
+      indexPath: this.indexDir,
+      lastIndexed,
+      sizeBytes,
+      version: SCHEMA_VERSION
+    };
+  }
+  setLastIndexed(ts2) {
+    this.runWithRetry(() => {
+      this.db.prepare(
+        "INSERT OR REPLACE INTO metadata(key, value) VALUES('last_indexed', ?)"
+      ).run(String(ts2));
+    });
+  }
+  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");
+    });
+  }
+  // ─── Ref CRUD ────────────────────────────────────────────────────────────────
+  /**
+   * Insert cross-references for a given source symbol id.
+   * Replaces any existing refs from the same source (idempotent on re-index).
+   */
+  insertRefs(fromId, refs) {
+    this.runWithRetry(() => {
+      this.db.prepare("DELETE FROM refs WHERE from_id = ?").run(fromId);
+      if (refs.length === 0) return;
+      const stmt = this.db.prepare(
+        `INSERT INTO refs(from_id, to_name, to_id, call_type, line)
+         VALUES (?, ?, ?, ?, ?)`
+      );
+      for (const ref of refs) {
+        stmt.run(fromId, ref.toName, ref.toId ?? null, ref.callType, ref.line);
+      }
+    });
+  }
+  /**
+   * Delete all refs whose source symbols are in a given file.
+   * Used when re-indexing a file to clear stale refs.
+   */
+  deleteRefsForFile(file) {
+    this.runWithRetry(() => {
+      const ids = this.db.prepare(
+        "SELECT id FROM symbols WHERE file = ?"
+      ).all(file);
+      if (!ids.length) return;
+      const placeholders = ids.map(() => "?").join(",");
+      this.db.prepare(`DELETE FROM refs WHERE from_id IN (${placeholders})`).run(...ids.map((r) => r.id));
+    });
+  }
+  /**
+   * Resolve `to_name` → `to_id` for all refs that have a name but no id.
+   * Call this after all symbols have been inserted to fill in cross-references.
+   */
+  resolveRefs() {
+    return this.runWithRetry(() => {
+      const unresolved = this.db.prepare(
+        "SELECT id, to_name FROM refs WHERE to_id IS NULL AND to_name IS NOT NULL"
+      ).all();
+      let resolved = 0;
+      for (const row of unresolved) {
+        const target = this.db.prepare("SELECT id FROM symbols WHERE name = ? LIMIT 1").all(row.to_name);
+        const first = target[0];
+        if (first) {
+          this.db.prepare("UPDATE refs SET to_id = ? WHERE id = ?").run(first.id, row.id);
+          resolved++;
+        }
+      }
+      return resolved;
+    });
+  }
+  /**
+   * Find all references TO a given symbol (who calls / uses this symbol?).
+   */
+  findRefsTo(symbolId) {
+    return this.db.prepare(
+      "SELECT id, from_id, to_name, to_id, call_type, line FROM refs WHERE to_id = ? OR to_name = (SELECT name FROM symbols WHERE id = ?)"
+    ).all(symbolId, symbolId).map((r) => ({
+      id: r.id,
+      fromId: r.from_id,
+      toName: r.to_name,
+      toId: r.to_id ?? void 0,
+      callType: r.call_type,
+      line: r.line
+    }));
+  }
+  /**
+   * 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) => ({
+      id: r.id,
+      fromId: r.from_id,
+      toName: r.to_name,
+      toId: r.to_id ?? void 0,
+      callType: r.call_type,
+      line: r.line
+    }));
+  }
+  sizeBytes() {
+    const dbPath = path4.join(this.indexDir, DB_FILE);
+    try {
+      return fs.statSync(dbPath).size;
+    } catch {
+      return 0;
+    }
+  }
+  close() {
+    try {
+      this.db.close();
+    } catch {
+    }
+  }
+};
+var KIND_MAP = {
+  [ts.SyntaxKind.ClassDeclaration]: "class",
+  [ts.SyntaxKind.InterfaceDeclaration]: "interface",
+  [ts.SyntaxKind.EnumDeclaration]: "enum",
+  [ts.SyntaxKind.TypeAliasDeclaration]: "type",
+  [ts.SyntaxKind.FunctionDeclaration]: "function",
+  [ts.SyntaxKind.MethodDeclaration]: "method",
+  [ts.SyntaxKind.GetAccessor]: "property",
+  [ts.SyntaxKind.SetAccessor]: "property",
+  [ts.SyntaxKind.PropertyDeclaration]: "property",
+  [ts.SyntaxKind.Parameter]: "parameter",
+  [ts.SyntaxKind.NamespaceExportDeclaration]: "namespace"
+};
+function kindOf(node) {
+  if (ts.isVariableDeclaration(node)) {
+    const parent = node.parent;
+    if (ts.isVariableDeclarationList(parent)) {
+      const flags = parent.flags;
+      if (flags & ts.NodeFlags.Let) return "let";
+      if (flags & ts.NodeFlags.Const) return "const";
+      return "var";
+    }
+  }
+  if (ts.isModuleDeclaration(node)) return "namespace";
+  return KIND_MAP[node.kind] ?? null;
+}
+function extToLang(ext) {
+  switch (ext) {
+    case ".ts":
+      return "ts";
+    case ".tsx":
+      return "tsx";
+    case ".js":
+      return "js";
+    case ".jsx":
+      return "jsx";
+    case ".go":
+      return "go";
+    case ".py":
+      return "py";
+    case ".rs":
+      return "rs";
+    case ".json":
+      return "json";
+    case ".yaml":
+      return "yaml";
+    case ".yml":
+      return "yaml";
+    default:
+      return null;
+  }
+}
+function getSignature(node, sourceFile) {
+  const printer = ts.createPrinter({});
+  const raw = printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
+  return raw.replace(/\s+/g, " ").slice(0, 500);
+}
+function getJsDoc(node, sourceFile) {
+  const fullText = sourceFile.getFullText();
+  const nodePos = node.getFullWidth();
+  const comments = ts.getLeadingCommentRanges(fullText, nodePos);
+  if (!comments) return "";
+  for (const range of comments) {
+    const commentText = fullText.slice(range.pos, range.end);
+    const trimmed = commentText.trim();
+    if (trimmed.startsWith("/**") && trimmed.endsWith("*/")) {
+      const inner = trimmed.slice(3, -2).replace(/^[ \t]*\*[ ]?/gm, "").trim();
+      return inner.split("\n")[0]?.trim().slice(0, 200) ?? "";
+    }
+  }
+  return "";
+}
+function buildScope(node) {
+  const parts = [];
+  let current = node.parent;
+  while (current) {
+    if (ts.isClassDeclaration(current) || ts.isInterfaceDeclaration(current) || ts.isEnumDeclaration(current) || ts.isTypeAliasDeclaration(current)) {
+      parts.unshift(current.name?.text ?? "Anon");
+    } else if (ts.isMethodDeclaration(current) || ts.isGetAccessor(current) || ts.isSetAccessor(current) || ts.isPropertyDeclaration(current) || ts.isFunctionDeclaration(current)) {
+      if (current.name && ts.isIdentifier(current.name)) {
+        parts.unshift(current.name.text);
+      }
+    }
+    current = current.parent;
+  }
+  return parts.join(".");
+}
+function parseSymbols(opts) {
+  const { file, content, lang } = opts;
+  let sourceFile;
+  try {
+    sourceFile = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true);
+  } catch {
+    return { file, lang, symbols: [], mtimeMs: Date.now() };
+  }
+  const symbols = [];
+  function visit(node) {
+    const kind = kindOf(node);
+    if (kind) {
+      const nameNode = node.name;
+      if (!nameNode || !ts.isIdentifier(nameNode)) return;
+      const name = nameNode.text;
+      const pos = nameNode.getStart(sourceFile);
+      const { line, character } = sourceFile.getLineAndCharacterOfPosition(pos);
+      const scope = buildScope(node);
+      const signature = getSignature(node, sourceFile);
+      const docComment = getJsDoc(node, sourceFile);
+      const text = [name, signature, docComment].filter(Boolean).join(" | ");
+      symbols.push({
+        id: 0,
+        lang,
+        kind,
+        name,
+        file,
+        line: line + 1,
+        col: character,
+        signature,
+        docComment,
+        scope,
+        text
+      });
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  const refs = extractRefs(sourceFile);
+  return { file, lang, symbols, refs, mtimeMs: Date.now() };
+}
+function extractRefs(sourceFile) {
+  const refs = [];
+  function visit(node) {
+    const pos = node.getStart(sourceFile);
+    const { line } = sourceFile.getLineAndCharacterOfPosition(pos);
+    const lineNum = line + 1;
+    if (ts.isCallExpression(node)) {
+      const expr = node.expression;
+      if (ts.isIdentifier(expr)) {
+        refs.push({ fromId: 0, toName: expr.text, callType: "call", line: lineNum });
+      }
+    } else if (ts.isPropertyAccessExpression(node)) {
+      if (ts.isIdentifier(node.expression)) {
+        refs.push({ fromId: 0, toName: node.expression.text, callType: "call", line: lineNum });
+      }
+    } else if (ts.isTypeReferenceNode(node)) {
+      const name = getTypeName(node.typeName);
+      if (name) refs.push({ fromId: 0, toName: name, callType: "type_ref", line: lineNum });
+    } else if (ts.isHeritageClause(node)) {
+      for (const t of node.types) {
+        const name = getTypeName(t.expression);
+        if (name) refs.push({ fromId: 0, toName: name, callType: node.token === ts.SyntaxKind.ExtendsKeyword ? "inherit" : "implement", line: lineNum });
+      }
+    } else if (ts.isImportDeclaration(node)) {
+      const moduleName = getModuleName(node);
+      if (moduleName) refs.push({ fromId: 0, toName: moduleName, callType: "import", line: lineNum });
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return deduplicateRefs(refs);
+}
+function getTypeName(name) {
+  if (ts.isIdentifier(name)) return name.text;
+  if (ts.isQualifiedName(name)) return `${getTypeName(name.left)}.${name.right.text}`;
+  return "";
+}
+function getModuleName(node) {
+  const moduleSpecifier = node.moduleSpecifier;
+  if (ts.isStringLiteral(moduleSpecifier)) return moduleSpecifier.text;
+  return "";
+}
+function deduplicateRefs(refs) {
+  const seen = /* @__PURE__ */ new Set();
+  return refs.filter((r) => {
+    const key = `${r.toName}:${r.callType}:${r.line}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function detectLang(file) {
+  const idx = file.lastIndexOf(".");
+  if (idx < 0) return null;
+  return extToLang(file.slice(idx));
+}
+function parseSymbols2(opts) {
+  const { file, content, lang } = opts;
+  try {
+    return syncGoParse(file, content, lang);
+  } catch {
+    return { file, lang, symbols: [], mtimeMs: Date.now() };
+  }
+}
+var GO_PARSE_SCRIPT = `
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"io"
+	"os"
+	"strings"
+)
+
+type Sym struct {
+	Name      string \`json:"name"\`
+	Kind      string \`json:"kind"\`
+	Line      int    \`json:"line"\`
+	Col       int    \`json:"col"\`
+	Signature string \`json:"signature"\`
+	Scope     string \`json:"scope"\`
+}
+
+func main() {
+	src, err := io.ReadAll(os.Stdin)
+	if err != nil {
+		fmt.Print("[]")
+		return
+	}
+	fset := token.NewFileSet()
+	node, err := parser.ParseFile(fset, "src.go", src, 0)
+	if err != nil {
+		fmt.Print("[]")
+		return
+	}
+
+	var syms []Sym
+
+	// Package-level scope
+	pkgScope := node.Name.Name
+
+	// Collect all top-level declarations
+	for _, decl := range node.Decls {
+		switch d := decl.(type) {
+		case *ast.FuncDecl:
+			name := d.Name.Name
+			kind := "function"
+			scope := pkgScope
+			if d.Recv != nil && len(d.Recv.List) > 0 {
+				scope = pkgScope + "." + recvTypeName(d.Recv.List[0].Type) + "." + name
+				kind = "method"
+			} else {
+				scope = pkgScope + "." + name
+			}
+			pos := fset.Position(d.Pos())
+			sig := formatFuncSig(d)
+			syms = append(syms, Sym{Name: name, Kind: kind, Line: pos.Line, Col: pos.Column, Signature: sig, Scope: scope})
+
+		case *ast.GenDecl:
+			for _, spec := range d.Specs {
+				switch s := spec.(type) {
+				case *ast.TypeSpec:
+					name := s.Name.Name
+					pos := fset.Position(s.Pos())
+					sig := "type " + name
+					if s.TypeParams != nil {
+						sig += formatTypeParams(s.TypeParams)
+					}
+					if st, ok := s.Type.(*ast.StructType); ok {
+						sig += " = struct { " + formatFields(st.Fields.List) + " }"
+					} else if it, ok := s.Type.(*ast.InterfaceType); ok {
+						sig += " = interface { " + formatMethods(it.Methods.List) + " }"
+					} else {
+						sig += " = " + formatType(s.Type)
+					}
+					syms = append(syms, Sym{Name: name, Kind: "type", Line: pos.Line, Col: pos.Column, Signature: sig, Scope: pkgScope})
+
+				case *ast.ValueSpec:
+					for _, n := range s.Names {
+						name := n.Name
+						pos := fset.Position(n.Pos())
+						kind := "var"
+						if d.Tok == token.CONST {
+							kind = "const"
+						}
+						sig := kind + " " + name
+						if s.Type != nil {
+							sig += " " + formatType(s.Type)
+						}
+						syms = append(syms, Sym{Name: name, Kind: kind, Line: pos.Line, Col: pos.Column, Signature: sig, Scope: pkgScope})
+					}
+				}
+			}
+		}
+	}
+
+	data, err := json.Marshal(syms)
+	if err != nil {
+		fmt.Print("[]")
+		return
+	}
+	fmt.Print(string(data))
+}
+
+func recvTypeName(t ast.Expr) string {
+	switch v := t.(type) {
+	case *ast.Ident:
+		return v.Name
+	case *ast.StarExpr:
+		return recvTypeName(v.X)
+	default:
+		return "?"
+	}
+}
+
+func formatFuncSig(d *ast.FuncDecl) string {
+	scope := ""
+	if d.Recv != nil && len(d.Recv.List) > 0 {
+		scope = "(" + formatFieldList(d.Recv.List) + ") "
+	}
+	scope += formatFuncType(d.Type)
+	return "func " + scope
+}
+
+func formatFuncType(f *ast.FuncType) string {
+	params := formatFieldList(f.Params.List)
+	results := ""
+	if f.Results != nil {
+		results = " -> " + formatFieldList(f.Results.List)
+	}
+	return params + results
+}
+
+func formatFieldList(fields []*ast.Field) string {
+	if len(fields) == 0 {
+		return "()"
+	}
+	names := make([]string, 0, len(fields))
+	for _, f := range fields {
+		name := ""
+		if len(f.Names) > 0 {
+			name = f.Names[0].Name
+		}
+		t := formatType(f.Type)
+		if name != "" {
+			names = append(names, name+" "+t)
+		} else {
+			names = append(names, t)
+		}
+	}
+	return "(" + strings.Join(names, ", ") + ")"
+}
+
+func formatFields(fields []*ast.Field) string {
+	lines := make([]string, 0)
+	for _, f := range fields {
+		name := ""
+		if len(f.Names) > 0 {
+			name = f.Names[0].Name
+		}
+		t := formatType(f.Type)
+		if name != "" {
+			lines = append(lines, name+" "+t)
+		} else {
+			lines = append(lines, t)
+		}
+	}
+	return strings.Join(lines, "; ")
+}
+
+func formatMethods(fields []*ast.Field) string {
+	return formatFields(fields)
+}
+
+func formatTypeParams(tp *ast.FieldList) string {
+	if tp == nil || len(tp.List) == 0 {
+		return ""
+	}
+	params := make([]string, len(tp.List))
+	for i, p := range tp.List {
+		if len(p.Names) > 0 {
+			params[i] = p.Names[0].Name
+		} else {
+			params[i] = "T"
+		}
+	}
+	return "[" + strings.Join(params, ", ") + "]"
+}
+
+func formatType(t ast.Expr) string {
+	if t == nil {
+		return "?"
+	}
+	switch v := t.(type) {
+	case *ast.Ident:
+		return v.Name
+	case *ast.SelectorExpr:
+		return formatType(v.X) + "." + v.Sel.Name
+	case *ast.StarExpr:
+		return "*" + formatType(v.X)
+	case *ast.ArrayType:
+		if v.Len == nil {
+			return "[]" + formatType(v.Elt)
+		}
+		return "[...]" + formatType(v.Elt)
+	case *ast.MapType:
+		return "map[" + formatType(v.Key) + "]" + formatType(v.Value)
+	case *ast.InterfaceType:
+		return "interface{}"
+	case *ast.StructType:
+		return "struct{}"
+	case *ast.FuncType:
+		return formatFuncType(v)
+	case *ast.ChanType:
+		return "chan " + formatType(v.Value)
+	case *ast.BasicLit:
+		return v.Value
+	case *ast.IndexExpr:
+		// Generic instantiation with one type arg, e.g. Logger[int].
+		return formatType(v.X) + "[" + formatType(v.Index) + "]"
+	case *ast.IndexListExpr:
+		// Generic instantiation with multiple type args, e.g. Map[K, V].
+		args := make([]string, len(v.Indices))
+		for i, idx := range v.Indices {
+			args[i] = formatType(idx)
+		}
+		return formatType(v.X) + "[" + strings.Join(args, ", ") + "]"
+	default:
+		return "?"
+	}
+}
+`;
+function syncGoParse(filePath, content, lang) {
+  const tmpDir = path4.join(os.tmpdir(), "ws-go-parse");
+  try {
+    mkdirSync(tmpDir, { recursive: true });
+    const scriptPath = path4.join(tmpDir, "parse.go");
+    writeFileSync(scriptPath, GO_PARSE_SCRIPT, "utf8");
+    const stdout = execFileSync("go", ["run", scriptPath], {
+      input: content,
+      timeout: 15e3,
+      encoding: "utf8",
+      windowsHide: true
+    });
+    if (!stdout.trim()) {
+      return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
+    }
+    const raw = JSON.parse(stdout.trim());
+    const symbols = raw.map((s) => ({
+      id: 0,
+      lang,
+      kind: s.kind,
+      name: s.name,
+      file: filePath,
+      line: s.line,
+      col: s.col,
+      signature: s.signature ?? "",
+      docComment: "",
+      scope: s.scope ?? "",
+      text: `${s.name} ${s.signature ?? ""}`.trim()
+    }));
+    return { file: filePath, lang, symbols, mtimeMs: Date.now() };
+  } catch {
+    return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
+  }
+}
+function parseSymbols3(opts) {
+  const { file, lang } = opts;
+  try {
+    return syncPyParse(file, lang);
+  } catch {
+    return { file, lang, symbols: [], mtimeMs: Date.now() };
+  }
+}
+var PY_PARSE_SCRIPT = `import ast, json, sys, os
+
+def get_name(node):
+    if isinstance(node, ast.Name):
+        return node.id
+    elif isinstance(node, ast.Attribute):
+        return get_name(node.value) + "." + node.attr
+    elif isinstance(node, ast.Subscript):
+        return get_name(node.value)
+    elif isinstance(node, ast.Call):
+        return get_name(node.func)
+    elif isinstance(node, ast.Constant):
+        return str(node.value)
+    return ""
+
+def get_decorators(node):
+    decs = []
+    for dec in node.decorator_list:
+        decs.append(get_name(dec))
+    return decs
+
+def get_bases(node):
+    bases = []
+    for base in node.bases:
+        bases.append(get_name(base))
+    return bases
+
+def get_args(args):
+    parts = []
+    for arg in args.args:
+        parts.append(arg.arg)
+    return ", ".join(parts)
+
+def get_returns(node):
+    if node.returns is None:
+        return ""
+    return get_name(node.returns)
+
+class Sym:
+    def __init__(self, name, kind, line, col, signature, scope):
+        self.name = name
+        self.kind = kind
+        self.line = line
+        self.col = col
+        self.signature = signature
+        self.scope = scope
+    def to_dict(self):
+        return {
+            "name": self.name,
+            "kind": self.kind,
+            "line": self.line,
+            "col": self.col,
+            "signature": self.signature,
+            "scope": self.scope,
+        }
+
+def is_private(name):
+    return name.startswith("__") and not name.endswith("__")
+
+syms = []
+errors = []
+
+try:
+    with open(sys.argv[1], "r", encoding="utf-8") as f:
+        source = f.read()
+    tree = ast.parse(source, filename=sys.argv[1])
+except Exception as e:
+    errors.append(str(e))
+    print("[]")
+    sys.exit(0)
+
+# Module-level scope
+module_scope = os.path.basename(sys.argv[1])[:-3]  # strip .py
+
+class ModuleVisitor(ast.NodeVisitor):
+    def __init__(self):
+        self.scope_stack = [module_scope]
+
+    def visit_ClassDef(self, node):
+        bases = get_bases(node)
+        decs = get_decorators(node)
+        sig = "class " + node.name
+        if bases:
+            sig += "(" + ", ".join(bases) + ")"
+        sig += ": ..."
+        syms.append(Sym(
+            name=node.name,
+            kind="class",
+            line=node.lineno,
+            col=node.col_offset,
+            signature=sig,
+            scope=".".join(self.scope_stack) + "." + node.name,
+        ))
+        self.scope_stack.append(node.name)
+        self.generic_visit(node)
+        self.scope_stack.pop()
+
+    def visit_FunctionDef(self, node):
+        decs = get_decorators(node)
+        args = get_args(node.args)
+        returns = get_returns(node)
+        is_async = isinstance(node, ast.AsyncFunctionDef)
+
+        kind = "function"
+        prefix = "def "
+        if decs:
+            for d in decs:
+                if d.endswith(".staticmethod"):
+                    kind = "staticmethod"
+                elif d.endswith(".classmethod"):
+                    kind = "classmethod"
+                elif d == "property":
+                    kind = "property"
+
+        if is_async:
+            kind = "async_" + kind
+
+        sig = f"{prefix}{node.name}({args})"
+        if returns:
+            sig += f" -> {returns}"
+        scope = ".".join(self.scope_stack) + "." + node.name
+
+        syms.append(Sym(
+            name=node.name,
+            kind=kind,
+            line=node.lineno,
+            col=node.col_offset,
+            signature=sig,
+            scope=scope,
+        ))
+        # Don't descend into function bodies to avoid local symbols
+        # self.generic_visit(node)
+
+    def visit_AsyncFunctionDef(self, node):
+        # Treat as function
+        self.visit_FunctionDef(node)
+
+    def visit_Assign(self, node):
+        for target in node.targets:
+            if isinstance(target, ast.Name):
+                name = target.id
+                if is_private(name):
+                    continue
+                # Infer constness from UPPER_CASE naming
+                kind = "const" if name.isupper() else "var"
+                col = target.col_offset if hasattr(target, 'col_offset') else 0
+                syms.append(Sym(
+                    name=name,
+                    kind=kind,
+                    line=node.lineno,
+                    col=col,
+                    signature=f"{name} = ...",
+                    scope=".".join(self.scope_stack),
+                ))
+
+    def visit_AnnAssign(self, node):
+        if isinstance(node.target, ast.Name):
+            name = node.target.id
+            if is_private(name):
+                return
+            kind = "const" if name.isupper() else "var"
+            col = node.target.col_offset if hasattr(node.target, 'col_offset') else 0
+            sig = f"{name}: {get_name(node.annotation)}"
+            if node.value:
+                sig += " = ..."
+            syms.append(Sym(
+                name=name,
+                kind=kind,
+                line=node.lineno,
+                col=col,
+                signature=sig,
+                scope=".".join(self.scope_stack),
+            ))
+
+    def visit_Import(self, node):
+        for alias in node.names:
+            name = alias.asname or alias.name
+            syms.append(Sym(
+                name=name,
+                kind="import",
+                line=node.lineno,
+                col=node.col_offset,
+                signature=f"import {alias.name}",
+                scope=".".join(self.scope_stack),
+            ))
+
+    def visit_ImportFrom(self, node):
+        module = node.module or ""
+        for alias in node.names:
+            name = alias.asname or alias.name
+            syms.append(Sym(
+                name=name,
+                kind="import",
+                line=node.lineno,
+                col=node.col_offset,
+                signature=f"from {module} import {alias.name}",
+                scope=".".join(self.scope_stack),
+            ))
+
+visitor = ModuleVisitor()
+visitor.visit(tree)
+
+print(json.dumps([s.to_dict() for s in syms]))
+`;
+function syncPyParse(filePath, lang) {
+  try {
+    const tmpDir = path4.join(os.tmpdir(), "ws-py-parse");
+    mkdirSync(tmpDir, { recursive: true });
+    const scriptPath = path4.join(tmpDir, "parse.py");
+    writeFileSync(scriptPath, PY_PARSE_SCRIPT, "utf8");
+    const stdout = execFileSync("python", [scriptPath, filePath], {
+      timeout: 15e3,
+      encoding: "utf8",
+      windowsHide: true
+    });
+    if (!stdout.trim()) {
+      return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
+    }
+    const raw = JSON.parse(stdout.trim());
+    const symbols = raw.map((s) => ({
+      id: 0,
+      lang,
+      kind: s.kind,
+      name: s.name,
+      file: filePath,
+      line: s.line,
+      col: s.col,
+      signature: s.signature ?? "",
+      docComment: "",
+      scope: s.scope ?? "",
+      text: `${s.name} ${s.signature ?? ""}`.trim()
+    }));
+    return { file: filePath, lang, symbols, mtimeMs: Date.now() };
+  } catch {
+    return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
+  }
+}
+function parseSymbols4(opts) {
+  const { file, content, lang } = opts;
+  const nativeAvailable = checkNativeParser();
+  if (nativeAvailable) {
+    const result = tryNativeParse(file, content);
+    if (result) return result;
+  }
+  return regexParse({ file, content, lang });
+}
+function checkNativeParser() {
+  try {
+    execFileSync("rustc", ["--version"], { stdio: "pipe", windowsHide: true });
+    const toolsDir = path4.join(process.cwd(), "tools");
+    try {
+      execFileSync(
+        "cargo",
+        [
+          "metadata",
+          "--no-deps",
+          "--format-version",
+          "1",
+          "--manifest-path",
+          path4.join(toolsDir, "Cargo.toml")
+        ],
+        { stdio: "pipe", windowsHide: true }
+      );
+      return true;
+    } catch {
+      return false;
+    }
+  } catch {
+    return false;
+  }
+}
+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");
+    writeFileSync(tmpFile, content, "utf8");
+    const result = spawnSync(
+      "cargo",
+      ["run", "--manifest-path", path4.join(toolsDir, "Cargo.toml")],
+      {
+        cwd: process.cwd(),
+        encoding: "utf8",
+        timeout: 15e3,
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true
+      }
+    );
+    if (result.status === 0 && result.stdout) {
+      const symbols = JSON.parse(result.stdout);
+      return {
+        file,
+        lang: "rs",
+        symbols: symbols.map((s) => ({ ...s, id: 0, lang: "rs" })),
+        mtimeMs: Date.now()
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+var RS_PATTERNS = [
+  { regex: /fn\s+(\w+)\s*\([^)]*\)/g, kind: "function" },
+  { regex: /struct\s+(\w+)/g, kind: "struct" },
+  { regex: /enum\s+(\w+)/g, kind: "enum" },
+  { regex: /trait\s+(\w+)/g, kind: "trait" },
+  { regex: /impl\s+(?:<[^>]+>)?(\w+)/g, kind: "impl" },
+  { regex: /type\s+(\w+)\s*=/g, kind: "type" },
+  { regex: /const\s+(\w+)/g, kind: "const" },
+  { regex: /static\s+(\w+)/g, kind: "static" },
+  { regex: /mod\s+(\w+)/g, kind: "mod" }
+];
+function regexParse(opts) {
+  const { file, content, lang } = opts;
+  const symbols = [];
+  const lines = content.split("\n");
+  const lineOffsets = [0];
+  for (let i = 0; i < lines.length; i++) {
+    lineOffsets.push((lineOffsets[i] ?? 0) + (lines[i]?.length ?? 0) + 1);
+  }
+  function lineFromOffset(offset) {
+    let lo = 0;
+    let hi = lineOffsets.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >>> 1;
+      if (expectDefined(lineOffsets[mid]) <= offset) lo = mid;
+      else hi = mid - 1;
+    }
+    return lo + 1;
+  }
+  function extractDeclaration(lineIdx, _match) {
+    const line = lines[lineIdx] ?? "";
+    return line.trim().slice(0, 500);
+  }
+  for (const pattern of RS_PATTERNS) {
+    pattern.regex.lastIndex = 0;
+    for (let match = pattern.regex.exec(content); match !== null; match = pattern.regex.exec(content)) {
+      const name = expectDefined(match[1]);
+      const offset = match.index ?? 0;
+      const line = lineFromOffset(offset);
+      const col = offset - (lineOffsets[line - 1] ?? 0);
+      const lineIdx = line - 1;
+      const signature = extractDeclaration(lineIdx);
+      symbols.push({
+        id: 0,
+        lang,
+        kind: pattern.kind,
+        name,
+        file,
+        line,
+        col,
+        signature,
+        docComment: "",
+        scope: "",
+        text: `${name} ${signature}`.trim()
+      });
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = symbols.filter((s) => {
+    const key = `${s.name}:${s.line}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  return { file, lang, symbols: deduped, mtimeMs: Date.now() };
+}
+function parseSymbols5(opts) {
+  const { file, content, lang } = opts;
+  try {
+    return regexParse2({ file, content, lang });
+  } catch {
+    return { file, lang, symbols: [], mtimeMs: Date.now() };
+  }
+}
+function regexParse2(opts) {
+  const { file, content, lang } = opts;
+  const symbols = [];
+  const basename2 = path4.basename(file).toLowerCase();
+  const isPackageJson = basename2 === "package.json";
+  const isTsconfig = basename2 === "tsconfig.json" || basename2 === "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");
+  const lineOffsets = [0];
+  for (let i = 0; i < lines.length; i++) {
+    lineOffsets.push((lineOffsets[i] ?? 0) + (lines[i]?.length ?? 0) + 1);
+  }
+  function lineFromOffset(offset) {
+    let lo = 0;
+    let hi = lineOffsets.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >>> 1;
+      if (expectDefined(lineOffsets[mid]) <= offset) lo = mid;
+      else hi = mid - 1;
+    }
+    return lo + 1;
+  }
+  const rootMatch = content.match(/^\s*\{/m);
+  if (rootMatch) {
+    const offset = expectDefined(rootMatch.index);
+    const line = lineFromOffset(offset);
+    symbols.push(
+      makeSymbol({
+        name: path4.basename(file),
+        kind: "object",
+        line,
+        col: 0,
+        signature: `"${path4.basename(file)}" = { ... }`,
+        file,
+        lang
+      })
+    );
+  }
+  const topLevelKeyRegex = /^\s*"([^"]+)"\s*:/gm;
+  for (let match = topLevelKeyRegex.exec(content); match !== null; match = topLevelKeyRegex.exec(content)) {
+    const key = expectDefined(match[1]);
+    const offset = match.index ?? 0;
+    const line = lineFromOffset(offset);
+    const col = offset - (lineOffsets[line - 1] ?? 0);
+    let kind = "property";
+    let signature = `"${key}": ..."`;
+    if (isPackageJson) {
+      if (key === "scripts" || key === "dependencies" || key === "devDependencies" || key === "peerDependencies" || key === "optionalDependencies") {
+        kind = "const";
+        signature = `"${key}": { ... }`;
+      }
+    } else if (isTsconfig) {
+      if (key === "compilerOptions") {
+        kind = "property";
+        signature = `"compilerOptions": { ... }`;
+      }
+    }
+    if (isJsonSchema || isOpenApi) {
+      if (key === "$schema" || key === "$id") {
+        kind = "schema";
+        signature = `"${key}": "..."`;
+      } else if (key === "$ref") {
+        kind = "schema";
+        signature = `"$ref": "..."`;
+      }
+    }
+    symbols.push(
+      makeSymbol({
+        name: key,
+        kind,
+        line,
+        col,
+        signature,
+        file,
+        lang
+      })
+    );
+    if (isPackageJson && key === "scripts") {
+      extractPackageScripts(content, symbols, file, lang, lineOffsets, lineFromOffset);
+    }
+    if (isTsconfig && key === "compilerOptions") {
+      extractCompilerOptions(content, symbols, file, lang, lineOffsets, line, lineFromOffset);
+    }
+  }
+  const defsRegex = /"\$defs"\s*:|"\$defs"\s*:/g;
+  const defsMatch = defsRegex.exec(content);
+  if (defsMatch !== null) {
+    const offset = expectDefined(defsMatch.index);
+    const line = lineFromOffset(offset);
+    symbols.push(
+      makeSymbol({
+        name: "$defs",
+        kind: "property",
+        line,
+        col: offset - (lineOffsets[line - 1] ?? 0),
+        signature: '"$defs": { ... }',
+        file,
+        lang
+      })
+    );
+  }
+  const defsPatterns = [
+    /"\$defs"\s*:/g,
+    /"definitions"\s*:/g,
+    /"components"\s*:/g,
+    /"schemas"\s*:/g
+  ];
+  for (const pat of defsPatterns) {
+    pat.lastIndex = 0;
+    for (let match = pat.exec(content); match !== null; match = pat.exec(content)) {
+      const offset = match.index ?? 0;
+      const line = lineFromOffset(offset);
+      const key = match[0]?.match(/"([^"]+)"/)?.[1] ?? expectDefined(match[0]);
+      symbols.push(
+        makeSymbol({
+          name: key,
+          kind: "property",
+          line,
+          col: offset - (lineOffsets[line - 1] ?? 0),
+          signature: `"${key}": { ... }`,
+          file,
+          lang
+        })
+      );
+    }
+  }
+  return { file, lang, symbols, mtimeMs: Date.now() };
+}
+function extractPackageScripts(content, symbols, file, lang, lineOffsets, lineFromOffset) {
+  const scriptsBlockRegex = /"scripts"\s*:\s*\{([^}]+)\}/g;
+  for (let match = scriptsBlockRegex.exec(content); match !== null; match = scriptsBlockRegex.exec(content)) {
+    const blockContent = expectDefined(match[0]);
+    const blockOffset = match.index ?? 0;
+    const scriptKeyRegex = /"(\w[\w-]*)"\s*:/g;
+    for (let scriptMatch = scriptKeyRegex.exec(blockContent); scriptMatch !== null; scriptMatch = scriptKeyRegex.exec(blockContent)) {
+      const key = expectDefined(scriptMatch[1]);
+      const keyOffset = blockOffset + expectDefined(scriptMatch.index);
+      const line = lineFromOffset(keyOffset);
+      symbols.push(
+        makeSymbol({
+          name: key,
+          kind: "function",
+          line,
+          col: keyOffset - (lineOffsets[line - 1] ?? 0),
+          signature: `"${key}": "..."`,
+          file,
+          lang
+        })
+      );
+    }
+  }
+}
+function extractCompilerOptions(content, symbols, file, lang, lineOffsets, parentLine, lineFromOffset) {
+  const optsBlockRegex = /"compilerOptions"\s*:\s*\{([^}]+)\}/g;
+  for (let match = optsBlockRegex.exec(content); match !== null; match = optsBlockRegex.exec(content)) {
+    const blockContent = expectDefined(match[0]);
+    const blockOffset = match.index ?? 0;
+    const optKeyRegex = /"(\w[\w]*)"\s*:/g;
+    for (let optMatch = optKeyRegex.exec(blockContent); optMatch !== null; optMatch = optKeyRegex.exec(blockContent)) {
+      const key = expectDefined(optMatch[1]);
+      const keyOffset = blockOffset + expectDefined(optMatch.index);
+      const line = lineFromOffset(keyOffset);
+      if (line <= parentLine) continue;
+      symbols.push(
+        makeSymbol({
+          name: key,
+          kind: "property",
+          line,
+          col: keyOffset - (lineOffsets[line - 1] ?? 0),
+          signature: `"${key}": ...`,
+          file,
+          lang
+        })
+      );
+    }
+  }
+}
+function makeSymbol(opts) {
+  return {
+    id: 0,
+    lang: opts.lang,
+    kind: opts.kind,
+    name: opts.name,
+    file: opts.file,
+    line: opts.line,
+    col: opts.col,
+    signature: opts.signature,
+    docComment: "",
+    scope: "",
+    text: `${opts.name} ${opts.signature}`.trim()
+  };
+}
+function parseSymbols6(opts) {
+  const { file, content, lang } = opts;
+  try {
+    return regexParse3({ file, content, lang });
+  } catch {
+    return { file, lang, symbols: [], mtimeMs: Date.now() };
+  }
+}
+function regexParse3(opts) {
+  const { file, content, lang } = opts;
+  const symbols = [];
+  const lines = content.split("\n");
+  const lineOffsets = [0];
+  for (let i = 0; i < lines.length; i++) {
+    lineOffsets.push((lineOffsets[i] ?? 0) + (lines[i]?.length ?? 0) + 1);
+  }
+  function lineFromOffset(offset) {
+    let lo = 0;
+    let hi = lineOffsets.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >>> 1;
+      if (expectDefined(lineOffsets[mid]) <= offset) lo = mid;
+      else hi = mid - 1;
+    }
+    return lo + 1;
+  }
+  const anchorRegex = /&(\w[\w-]*)/g;
+  for (let match = anchorRegex.exec(content); match !== null; match = anchorRegex.exec(content)) {
+    const name = expectDefined(match[1]);
+    const offset = match.index ?? 0;
+    const line = lineFromOffset(offset);
+    const col = offset - (lineOffsets[line - 1] ?? 0);
+    symbols.push(
+      makeSymbol2({
+        name,
+        kind: "const",
+        line,
+        col,
+        signature: `&${name}`,
+        file,
+        lang
+      })
+    );
+  }
+  const aliasRegex = /\*(\w[\w-]*)/g;
+  for (let match = aliasRegex.exec(content); match !== null; match = aliasRegex.exec(content)) {
+    const name = expectDefined(match[1]);
+    const offset = match.index ?? 0;
+    const line = lineFromOffset(offset);
+    const col = offset - (lineOffsets[line - 1] ?? 0);
+    symbols.push(
+      makeSymbol2({
+        name,
+        kind: "const",
+        line,
+        col,
+        signature: `*${name}`,
+        file,
+        lang
+      })
+    );
+  }
+  const kvRegex = /^(\s*)([^:#\s][^:#\s]*)\s*:/gm;
+  for (let match = kvRegex.exec(content); match !== null; match = kvRegex.exec(content)) {
+    const indent = match[1]?.length ?? 0;
+    const key = match[2];
+    if (!key) continue;
+    const offset = match.index ?? 0;
+    const line = lineFromOffset(offset);
+    const col = offset - (lineOffsets[line - 1] ?? 0);
+    const lineContent = lines[line - 1] ?? "";
+    if (/^[|&>]/.test(lineContent.trim())) continue;
+    if (key === "---" || key === "...") continue;
+    if (indent > 12) continue;
+    const value = extractValue(content, match.index ?? 0);
+    const kind = isScalar(value) ? "literal" : "property";
+    const signature = `${key}: ${truncate(value, 60)}`;
+    symbols.push(makeSymbol2({ name: key, kind, line, col, signature, file, lang }));
+  }
+  const listItemRegex = /^-(\s+)([^:#\s][^:#\s]*)\s*:/gm;
+  for (let match = listItemRegex.exec(content); match !== null; match = listItemRegex.exec(content)) {
+    const key = expectDefined(match[2]);
+    const offset = match.index ?? 0;
+    const line = lineFromOffset(offset);
+    const col = offset - (lineOffsets[line - 1] ?? 0);
+    const value = extractValue(content, offset + match[0]?.length);
+    const kind = isScalar(value) ? "literal" : "property";
+    symbols.push(
+      makeSymbol2({
+        name: key,
+        kind,
+        line,
+        col,
+        signature: `- ${key}: ${truncate(value, 60)}`,
+        file,
+        lang
+      })
+    );
+  }
+  const blockScalarRegex = /^(\s*)([^:#\s][^:#\s]*)\s*:\s*[|>](\s|$)/gm;
+  for (let match = blockScalarRegex.exec(content); match !== null; match = blockScalarRegex.exec(content)) {
+    const key = expectDefined(match[2]);
+    const offset = match.index ?? 0;
+    const line = lineFromOffset(offset);
+    const col = offset - (lineOffsets[line - 1] ?? 0);
+    symbols.push(
+      makeSymbol2({
+        name: key,
+        kind: "property",
+        line,
+        col,
+        signature: `${key}: | ...`,
+        file,
+        lang
+      })
+    );
+  }
+  return { file, lang, symbols, mtimeMs: Date.now() };
+}
+function extractValue(content, afterColonOffset) {
+  const lineEnd = content.indexOf("\n", afterColonOffset);
+  const rest = content.slice(afterColonOffset, lineEnd < 0 ? void 0 : lineEnd);
+  return rest.trim();
+}
+function isScalar(value) {
+  if (!value) return false;
+  if (/^-?\d+(\.\d+)?([eE][+-]?\d+)?$/.test(value)) return true;
+  if (/^(true|false|null|undefined)$/i.test(value)) return true;
+  if (/^'[^']*'$/.test(value) || /^"[^"]*"$/.test(value)) return true;
+  return false;
+}
+function makeSymbol2(opts) {
+  return {
+    id: 0,
+    lang: opts.lang,
+    kind: opts.kind,
+    name: opts.name,
+    file: opts.file,
+    line: opts.line,
+    col: opts.col,
+    signature: opts.signature,
+    docComment: "",
+    scope: "",
+    text: `${opts.name} ${opts.signature}`.trim()
+  };
+}
+function globBody(glob) {
+  return compileGlob(glob).source.replace(/^\^/, "").replace(/\$$/, "");
+}
+function compileGitignore(lines) {
+  const rules = [];
+  for (const raw of lines) {
+    let line = raw.replace(/\r$/, "");
+    if (!line.trim() || line.trimStart().startsWith("#")) continue;
+    line = line.trim();
+    let negated = false;
+    if (line.startsWith("!")) {
+      negated = true;
+      line = line.slice(1);
+    }
+    let dirOnly = false;
+    if (line.endsWith("/")) {
+      dirOnly = true;
+      line = line.slice(0, -1);
+    }
+    if (!line) continue;
+    const anchored = line.startsWith("/") || line.includes("/");
+    if (line.startsWith("/")) line = line.slice(1);
+    const body = globBody(line);
+    const prefix = anchored ? "^" : "(?:^|.*/)";
+    rules.push({
+      eqOrUnder: new RegExp(`${prefix}${body}(?:/.*)?$`),
+      under: new RegExp(`${prefix}${body}/.*$`),
+      negated,
+      dirOnly
+    });
+  }
+  return (relPath, isDir) => {
+    const p = relPath.replace(/\\/g, "/").replace(/^\/+/, "");
+    let ignored = false;
+    for (const r of rules) {
+      const re = r.dirOnly && !isDir ? r.under : r.eqOrUnder;
+      if (re.test(p)) ignored = !r.negated;
+    }
+    return ignored;
+  };
+}
+async function loadGitignoreMatcher(projectRoot) {
+  let lines = [];
+  try {
+    const raw = await fs3.readFile(path4.join(projectRoot, ".gitignore"), "utf8");
+    lines = raw.split("\n");
+  } catch {
+  }
+  return compileGitignore(lines);
+}
+
+// src/codebase-index/indexer.ts
+var YIELD_EVERY_N = 50;
+function yieldEventLoop() {
+  return new Promise((resolve2) => setImmediate(resolve2));
+}
+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"
+  );
+}
+function isAbortError(err) {
+  return err instanceof DOMException && err.name === "AbortError";
+}
+var DEFAULT_IGNORE = [
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  "coverage",
+  ".turbo",
+  "__snapshots__",
+  ".nyc_output"
+];
+async function findSourceFiles(projectRoot, ignore, isGitIgnored, signal) {
+  const results = [];
+  const ignoreSet = /* @__PURE__ */ new Set([...DEFAULT_IGNORE, ...ignore]);
+  const globs = [
+    { ext: ".ts", pat: compileGlob("**/*.ts") },
+    { ext: ".tsx", pat: compileGlob("**/*.tsx") },
+    { ext: ".js", pat: compileGlob("**/*.js") },
+    { ext: ".jsx", pat: compileGlob("**/*.jsx") },
+    { ext: ".go", pat: compileGlob("**/*.go") },
+    { ext: ".py", pat: compileGlob("**/*.py") },
+    { ext: ".rs", pat: compileGlob("**/*.rs") },
+    { ext: ".json", pat: compileGlob("**/*.json") },
+    { ext: ".yaml", pat: compileGlob("**/*.yaml") },
+    { ext: ".yml", pat: compileGlob("**/*.yml") }
+  ];
+  let dirCount = 0;
+  const walk = async (dir) => {
+    throwIfAborted(signal);
+    if (dirCount > 0 && dirCount % YIELD_EVERY_N === 0) {
+      await yieldEventLoop();
+      throwIfAborted(signal);
+    }
+    let entries;
+    try {
+      entries = await fs3.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    dirCount++;
+    for (const e of entries) {
+      if (ignoreSet.has(e.name)) continue;
+      const full = path4.join(dir, e.name);
+      const rel = path4.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 = path4.extname(e.name);
+        for (const { ext: extName, pat } of globs) {
+          if (ext === extName && (pat.test(rel) || pat.test(e.name))) {
+            results.push(full);
+            break;
+          }
+        }
+      }
+    }
+  };
+  await walk(projectRoot);
+  return results;
+}
+async function parseFile(file, content, lang) {
+  switch (lang) {
+    case "ts":
+    case "tsx":
+    case "js":
+    case "jsx":
+      return parseSymbols({ file, content, lang });
+    case "go":
+      return parseSymbols2({ file, content, lang: "go" });
+    case "py":
+      return parseSymbols3({ file, lang: "py" });
+    case "rs":
+      return parseSymbols4({ file, content, lang: "rs" });
+    case "json":
+      return parseSymbols5({ file, content, lang: "json" });
+    case "yaml":
+      return parseSymbols6({ file, content, lang: "yaml" });
+    default:
+      return { file, lang, symbols: [], mtimeMs: Date.now() };
+  }
+}
+async function runIndexer(_ctx, opts) {
+  const store = new IndexStore(opts.projectRoot, { indexDir: opts.indexDir });
+  try {
+    return await runIndexerWithStore(store, opts);
+  } finally {
+    try {
+      store.close();
+    } catch {
+    }
+  }
+}
+async function runIndexerWithStore(store, opts) {
+  const { projectRoot, force = false, langs, ignore = [], signal } = opts;
+  const startMs = Date.now();
+  const errors = [];
+  const langStats = {};
+  let filesIndexed = 0;
+  let symbolsIndexed = 0;
+  const isGitIgnored = await loadGitignoreMatcher(projectRoot);
+  let files;
+  if (opts.files && opts.files.length > 0) {
+    files = opts.files.map((f) => path4.resolve(projectRoot, f)).filter((f) => !isGitIgnored(path4.relative(projectRoot, f).replace(/\\/g, "/"), false));
+  } else {
+    files = await findSourceFiles(projectRoot, ignore, isGitIgnored, signal);
+  }
+  if (langs && langs.length > 0) {
+    const langSet = new Set(langs);
+    files = files.filter((f) => {
+      const lang = detectLang(f);
+      return lang ? langSet.has(lang) : false;
+    });
+  }
+  if (force) store.clearAll();
+  const existingMeta = /* @__PURE__ */ new Map();
+  if (!force) {
+    for (const meta of store.getAllFileMetas()) existingMeta.set(meta.file, meta);
+  }
+  for (let fi = 0; fi < files.length; fi++) {
+    const file = expectDefined(files[fi]);
+    opts.onProgress?.(fi + 1, files.length);
+    if (fi > 0 && fi % YIELD_EVERY_N === 0) {
+      await yieldEventLoop();
+      throwIfAborted(signal);
+    }
+    let stat2;
+    try {
+      const statOpts = signal ? { signal } : {};
+      stat2 = await fs3.stat(file, statOpts);
+    } catch (e) {
+      if (isAbortError(e)) throw e;
+      store.deleteFile(file);
+      continue;
+    }
+    if (!stat2.isFile()) continue;
+    const lang = detectLang(file);
+    if (!lang) continue;
+    const meta = existingMeta.get(file);
+    if (!force && meta && meta.mtimeMs === Math.floor(stat2.mtimeMs)) {
+      langStats[lang] = (langStats[lang] ?? 0) + meta.symbolCount;
+      symbolsIndexed += meta.symbolCount;
+      filesIndexed++;
+      continue;
+    }
+    store.deleteRefsForFile(file);
+    store.deleteSymbolsForFile(file);
+    let content;
+    try {
+      content = await fs3.readFile(file, { encoding: "utf8", signal });
+    } catch (e) {
+      if (isAbortError(e)) throw e;
+      errors.push(`read error: ${file}: ${e instanceof Error ? e.message : String(e)}`);
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = await parseFile(file, content, lang);
+    } catch (e) {
+      errors.push(`parse error: ${file}: ${e instanceof Error ? e.message : String(e)}`);
+      continue;
+    }
+    if (parsed.symbols.length === 0) {
+      store.upsertFile({
+        file,
+        lang,
+        mtimeMs: Math.floor(stat2.mtimeMs),
+        symbolCount: 0,
+        lastIndexed: Date.now()
+      });
+      filesIndexed++;
+      continue;
+    }
+    const nextId = store.getMaxSymbolId() + 1;
+    const symbolsWithIds = parsed.symbols.map((s, i) => ({ ...s, id: nextId + i }));
+    store.insertSymbols(symbolsWithIds, nextId);
+    const count = symbolsWithIds.length;
+    symbolsIndexed += count;
+    langStats[lang] = (langStats[lang] ?? 0) + count;
+    if (parsed.refs && parsed.refs.length > 0) {
+      for (let i = 0; i < symbolsWithIds.length; i++) {
+        const sym = expectDefined(symbolsWithIds[i]);
+        const symRefs = parsed.refs.filter((r) => r.line === sym.line);
+        if (symRefs.length > 0) {
+          const refsWithFromId = symRefs.map((r) => ({ ...r, fromId: sym.id }));
+          store.insertRefs(sym.id, refsWithFromId);
+        }
+      }
+    }
+    store.upsertFile({
+      file,
+      lang,
+      mtimeMs: Math.floor(stat2.mtimeMs),
+      symbolCount: count,
+      lastIndexed: Date.now()
+    });
+    filesIndexed++;
+  }
+  for (const [file_] of existingMeta) {
+    try {
+      await fs3.stat(file_);
+    } catch {
+      store.deleteFile(file_);
+    }
+  }
+  const durationMs = Date.now() - startMs;
+  store.setLastIndexed(Date.now());
+  return {
+    filesIndexed,
+    symbolsIndexed,
+    langStats,
+    durationMs,
+    errors
+  };
+}
+
+// src/codebase-index/index-service.ts
+function stubCtx(projectRoot) {
+  return {
+    projectRoot,
+    cwd: projectRoot,
+    messages: [],
+    todos: [],
+    readFiles: /* @__PURE__ */ new Set(),
+    fileMtimes: /* @__PURE__ */ new Map()
+  };
+}
+async function indexService(args, hooks = {}) {
+  return runIndexer(stubCtx(args.projectRoot), {
+    projectRoot: args.projectRoot,
+    indexDir: args.indexDir,
+    files: args.files,
+    force: args.force,
+    langs: args.langs,
+    ignore: args.ignore,
+    signal: hooks.signal,
+    onProgress: hooks.onProgress
+  });
+}
+function searchService(args) {
+  const store = new IndexStore(args.projectRoot, { indexDir: args.indexDir });
+  try {
+    return store.searchRanked(
+      args.query,
+      {
+        kind: args.kind,
+        lang: args.lang,
+        file: args.file,
+        lspKind: args.lspKind
+      },
+      args.limit
+    );
+  } finally {
+    store.close();
+  }
+}
+function statsService(args) {
+  const store = new IndexStore(args.projectRoot, { indexDir: args.indexDir });
+  try {
+    return store.getStats();
+  } finally {
+    store.close();
+  }
+}
+
+// src/codebase-index/worker.ts
+if (!parentPort) throw new Error("codebase-index worker must be started as a worker thread");
+var port = parentPort;
+var inFlight = /* @__PURE__ */ new Map();
+function post(msg) {
+  port.postMessage(msg);
+}
+async function dispatch(msg) {
+  switch (msg.op) {
+    case "index": {
+      const ac = new AbortController();
+      inFlight.set(msg.id, ac);
+      try {
+        return await indexService(msg.args, {
+          signal: ac.signal,
+          onProgress: (current, total) => post({ type: "progress", id: msg.id, current, total })
+        });
+      } finally {
+        inFlight.delete(msg.id);
+      }
+    }
+    case "search":
+      return searchService(msg.args);
+    case "stats":
+      return statsService(msg.args);
+    default:
+      throw new Error(`unknown index op: ${msg.op}`);
+  }
+}
+port.on("message", (msg) => {
+  if (msg.type === "cancel") {
+    inFlight.get(msg.id)?.abort(new Error("Indexing cancelled"));
+    return;
+  }
+  void dispatch(msg).then(
+    (result) => post({ type: "response", id: msg.id, ok: true, result }),
+    (err) => post({
+      type: "response",
+      id: msg.id,
+      ok: false,
+      error: err instanceof Error ? err.message : String(err)
+    })
+  );
+});
+//# sourceMappingURL=worker.js.map
+//# sourceMappingURL=worker.js.map