@wrongstack/tools 0.7.5 → 0.7.7

package/dist/codebase-index/index.js

@@ -0,0 +1,1974 @@
+import * as fs2 from 'node:fs/promises';
+import * as path3 from 'node:path';
+import { compileGlob } from '@wrongstack/core';
+import * as fs from 'node:fs';
+import { mkdirSync, writeFileSync, unlinkSync } from 'node:fs';
+import { DatabaseSync } from 'node:sqlite';
+import * as ts from 'typescript';
+import { execSync, spawnSync } from 'node:child_process';
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/codebase-index/schema.ts
+var SCHEMA_VERSION = 1;
+
+// 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;
+  }
+}
+function internalKindToLspKind(k) {
+  switch (k) {
+    case "class":
+      return 5 /* Class */;
+    case "method":
+      return 6 /* Method */;
+    case "property":
+      return 7 /* Property */;
+    case "function":
+      return 12 /* Function */;
+    case "var":
+      return 13 /* Variable */;
+    case "const":
+      return 14 /* Constant */;
+    case "let":
+      return 13 /* Variable */;
+    case "enum":
+      return 10 /* Enum */;
+    case "interface":
+      return 11 /* Interface */;
+    case "namespace":
+      return 3 /* Namespace */;
+    case "type":
+      return 26 /* TypeParameter */;
+    // parameter and other internal-only kinds have no LSP equivalent
+    default:
+      return null;
+  }
+}
+
+// src/codebase-index/writer.ts
+var INDEX_DIR = ".codebase-index";
+var DB_FILE = "index.db";
+var IndexStore = class {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    const dir = path3.join(projectRoot, INDEX_DIR);
+    fs.mkdirSync(dir, { recursive: true });
+    this.db = new DatabaseSync(path3.join(dir, DB_FILE));
+    this.initSchema();
+  }
+  projectRoot;
+  db;
+  initSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS metadata (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+      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)");
+    const versionRows = this.db.prepare("SELECT value FROM metadata WHERE key = ?").all("version");
+    if (!versionRows.length) {
+      this.db.prepare("INSERT INTO metadata(key, value) VALUES (?, ?)").run("version", String(SCHEMA_VERSION));
+    }
+  }
+  // ─── Symbol CRUD ─────────────────────────────────────────────────────────────
+  insertSymbols(symbols, nextId) {
+    const stmt = this.db.prepare(
+      `INSERT INTO symbols(id, lang, kind, name, file, line, col, signature, doc_comment, scope, text, file_fk)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    );
+    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
+      );
+    }
+    return id;
+  }
+  deleteSymbolsForFile(file) {
+    this.db.prepare("DELETE FROM symbols WHERE file_fk = ?").run(file);
+  }
+  deleteFile(file) {
+    this.db.prepare("DELETE FROM files WHERE file = ?").run(file);
+  }
+  // ─── File metadata ──────────────────────────────────────────────────────────
+  upsertFile(meta) {
+    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 = 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
+    }));
+  }
+  getAllIndexable() {
+    return this.db.prepare("SELECT id, text FROM symbols").all().map(
+      ({ id, text }) => ({ id, text })
+    );
+  }
+  // ─── 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: path3.join(this.projectRoot, INDEX_DIR),
+      lastIndexed,
+      sizeBytes,
+      version: SCHEMA_VERSION
+    };
+  }
+  setLastIndexed(ts2) {
+    this.db.prepare(
+      "INSERT OR REPLACE INTO metadata(key, value) VALUES('last_indexed', ?)"
+    ).run(String(ts2));
+  }
+  clearAll() {
+    this.db.exec("DELETE FROM symbols");
+    this.db.exec("DELETE FROM files");
+    this.db.exec("DELETE FROM refs");
+  }
+  // ─── 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.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) {
+    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() {
+    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);
+      if (target.length) {
+        this.db.prepare("UPDATE refs SET to_id = ? WHERE id = ?").run(target[0].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 = path3.join(this.projectRoot, INDEX_DIR, 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"
+	"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() {
+	if len(os.Args) < 2 {
+		fmt.Print("[]")
+		return
+	}
+	src, err := os.ReadFile(os.Args[1])
+	if err != nil {
+		fmt.Print("[]")
+		return
+	}
+	fset := token.NewFileSet()
+	node, err := parser.ParseFile(fset, os.Args[1], 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.TypeParams) 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
+	default:
+		return "?"
+	}
+}
+`;
+function syncGoParse(filePath, _content, lang) {
+  const tmpDir = path3.join(process.env.TEMP ?? "/tmp", "ws-go-parse");
+  try {
+    mkdirSync(tmpDir, { recursive: true });
+    const scriptPath = path3.join(tmpDir, "parse.go");
+    writeFileSync(scriptPath, GO_PARSE_SCRIPT, "utf8");
+    let stdout;
+    try {
+      stdout = execSync(`go run "${scriptPath}" "${filePath}"`, {
+        timeout: 15e3,
+        encoding: "utf8",
+        windowsHide: true
+      });
+    } finally {
+      try {
+        unlinkSync(scriptPath);
+      } catch {
+      }
+    }
+    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 stdout = execSync(`python -c "${PY_PARSE_SCRIPT.replace(/"/g, '\\"')}" "${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 {
+    execSync("rustc --version", { stdio: "pipe" });
+    const toolsDir = path3.join(process.cwd(), "tools");
+    try {
+      execSync("cargo metadata --no-deps --format-version 1 --manifest-path " + path3.join(toolsDir, "Cargo.toml"), { stdio: "pipe" });
+      return true;
+    } catch {
+      return false;
+    }
+  } catch {
+    return false;
+  }
+}
+function tryNativeParse(file, content) {
+  try {
+    const toolsDir = path3.join(process.cwd(), "tools");
+    const crateDir = path3.join(toolsDir, "syn-parser");
+    const tmpFile = path3.join(crateDir, "src", "input.rs");
+    const { writeFileSync: writeFileSync2 } = __require("node:fs");
+    writeFileSync2(tmpFile, content, "utf8");
+    const result = spawnSync("cargo", ["run", "--manifest-path", path3.join(toolsDir, "Cargo.toml")], {
+      cwd: process.cwd(),
+      encoding: "utf8",
+      timeout: 15e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    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] + lines[i].length + 1);
+  }
+  function lineFromOffset(offset) {
+    let lo = 0, hi = lineOffsets.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >>> 1;
+      if (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;
+    let match;
+    while ((match = pattern.regex.exec(content)) !== null) {
+      const name = match[1];
+      const offset = match.index;
+      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 = path3.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] + lines[i].length + 1);
+  }
+  function lineFromOffset(offset) {
+    let lo = 0, hi = lineOffsets.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >>> 1;
+      if (lineOffsets[mid] <= offset) lo = mid;
+      else hi = mid - 1;
+    }
+    return lo + 1;
+  }
+  const rootMatch = content.match(/^\s*\{/m);
+  if (rootMatch) {
+    const offset = rootMatch.index;
+    const line = lineFromOffset(offset);
+    symbols.push(makeSymbol({
+      name: path3.basename(file),
+      kind: "object",
+      line,
+      col: 0,
+      signature: `"${path3.basename(file)}" = { ... }`,
+      file,
+      lang
+    }));
+  }
+  const topLevelKeyRegex = /^\s*"([^"]+)"\s*:/gm;
+  let match;
+  while ((match = topLevelKeyRegex.exec(content)) !== null) {
+    const key = match[1];
+    const offset = match.index;
+    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;
+  let defsMatch;
+  while ((defsMatch = defsRegex.exec(content)) !== null) {
+    const offset = defsMatch.index;
+    const line = lineFromOffset(offset);
+    symbols.push(makeSymbol({
+      name: "$defs",
+      kind: "property",
+      line,
+      col: offset - (lineOffsets[line - 1] ?? 0),
+      signature: '"$defs": { ... }',
+      file,
+      lang
+    }));
+    break;
+  }
+  const defsPatterns = [
+    /"\$defs"\s*:/g,
+    /"definitions"\s*:/g,
+    /"components"\s*:/g,
+    /"schemas"\s*:/g
+  ];
+  for (const pat of defsPatterns) {
+    pat.lastIndex = 0;
+    while ((match = pat.exec(content)) !== null) {
+      const offset = match.index;
+      const line = lineFromOffset(offset);
+      const key = match[0].match(/"([^"]+)"/)?.[1] ?? 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;
+  let match;
+  while ((match = scriptsBlockRegex.exec(content)) !== null) {
+    const blockContent = match[0];
+    const blockOffset = match.index;
+    const scriptKeyRegex = /"(\w[\w-]*)"\s*:/g;
+    let scriptMatch;
+    while ((scriptMatch = scriptKeyRegex.exec(blockContent)) !== null) {
+      const key = scriptMatch[1];
+      const keyOffset = blockOffset + 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;
+  let match;
+  while ((match = optsBlockRegex.exec(content)) !== null) {
+    const blockContent = match[0];
+    const blockOffset = match.index;
+    const optKeyRegex = /"(\w[\w]*)"\s*:/g;
+    let optMatch;
+    while ((optMatch = optKeyRegex.exec(blockContent)) !== null) {
+      const key = optMatch[1];
+      const keyOffset = blockOffset + 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()
+  };
+}
+
+// src/codebase-index/yaml-parser.ts
+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] + lines[i].length + 1);
+  }
+  function lineFromOffset(offset) {
+    let lo = 0, hi = lineOffsets.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >>> 1;
+      if (lineOffsets[mid] <= offset) lo = mid;
+      else hi = mid - 1;
+    }
+    return lo + 1;
+  }
+  const anchorRegex = /&(\w[\w-]*)/g;
+  let match;
+  while ((match = anchorRegex.exec(content)) !== null) {
+    const name = match[1];
+    const offset = match.index;
+    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;
+  while ((match = aliasRegex.exec(content)) !== null) {
+    const name = match[1];
+    const offset = match.index;
+    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;
+  while ((match = kvRegex.exec(content)) !== null) {
+    const indent = match[1].length;
+    const key = match[2];
+    const offset = match.index;
+    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);
+    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;
+  while ((match = listItemRegex.exec(content)) !== null) {
+    const key = match[2];
+    const offset = match.index;
+    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;
+  while ((match = blockScalarRegex.exec(content)) !== null) {
+    const key = match[2];
+    const offset = match.index;
+    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 truncate(s, max) {
+  if (s.length <= max) return s;
+  return s.slice(0, max) + "...";
+}
+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()
+  };
+}
+
+// src/codebase-index/indexer.ts
+var DEFAULT_IGNORE = [
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  "coverage",
+  ".turbo",
+  "__snapshots__",
+  ".nyc_output"
+];
+async function findSourceFiles(projectRoot, ignore) {
+  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") }
+  ];
+  const walk = async (dir) => {
+    let entries;
+    try {
+      entries = await fs2.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (ignoreSet.has(e.name)) continue;
+      const full = path3.join(dir, e.name);
+      if (e.isDirectory()) {
+        await walk(full);
+      } else if (e.isFile()) {
+        const rel = path3.relative(projectRoot, full).replace(/\\/g, "/");
+        const ext = path3.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 { projectRoot, force = false, langs, ignore = [] } = opts;
+  const store = new IndexStore(projectRoot);
+  const startMs = Date.now();
+  const errors = [];
+  const langStats = {};
+  let filesIndexed = 0;
+  let symbolsIndexed = 0;
+  let files;
+  if (opts.files && opts.files.length > 0) {
+    files = opts.files.map((f) => path3.resolve(projectRoot, f));
+  } else {
+    files = await findSourceFiles(projectRoot, ignore);
+  }
+  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 (const file of files) {
+    let stat2;
+    try {
+      stat2 = await fs2.stat(file);
+    } catch {
+      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.deleteSymbolsForFile(file);
+    store.deleteRefsForFile(file);
+    let content;
+    try {
+      content = await fs2.readFile(file, "utf8");
+    } catch (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.getStats().totalSymbols + 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 = 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 fs2.stat(file_);
+    } catch {
+      store.deleteFile(file_);
+    }
+  }
+  const durationMs = Date.now() - startMs;
+  store.setLastIndexed(Date.now());
+  store.close();
+  return {
+    filesIndexed,
+    symbolsIndexed,
+    langStats,
+    durationMs,
+    errors
+  };
+}
+
+// src/codebase-index/codebase-index-tool.ts
+var codebaseIndexTool = {
+  name: "codebase-index",
+  category: "Project",
+  description: "Build or update the symbol index for the project. Runs incrementally by default \u2014 only re-indexes files that changed since the last run.",
+  usageHint: "Call with `force: true` to wipe and rebuild the index from scratch. Use `langs` to limit to specific languages. First call without arguments to do an incremental index.",
+  permission: "auto",
+  mutating: true,
+  timeoutMs: 12e4,
+  inputSchema: {
+    type: "object",
+    properties: {
+      force: {
+        type: "boolean",
+        description: "Force a full reindex \u2014 clears the index first and reindexes all files."
+      },
+      langs: {
+        type: "array",
+        items: { type: "string" },
+        description: "Limit reindex to specific languages: ts, tsx, js, jsx, go, py, rs"
+      }
+    }
+  },
+  async execute(input, ctx) {
+    const result = await runIndexer(ctx, {
+      projectRoot: ctx.projectRoot,
+      force: input.force ?? false,
+      langs: input.langs
+    });
+    return result;
+  }
+};
+
+// 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/codebase-search-tool.ts
+var codebaseSearchTool = {
+  name: "codebase-search",
+  category: "Project",
+  description: "Search indexed code symbols by name, signature, or doc comment. Uses BM25 ranking for relevance.",
+  usageHint: "Pass `query` for keyword search. Filter with `kind` (class/function/interface/etc), `lang` (ts/js/etc), `file` (substring). `limit` caps results (default 20).",
+  permission: "auto",
+  mutating: false,
+  timeoutMs: 1e4,
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: "Search query \u2014 searches symbol names, signatures, and doc comments"
+      },
+      kind: {
+        type: "string",
+        description: "Filter by symbol kind: class, function, interface, method, const, let, var, property, type, enum"
+      },
+      lang: {
+        type: "string",
+        description: "Filter by language: ts, tsx, js, jsx"
+      },
+      lspKind: {
+        type: "integer",
+        description: "Filter by LSP SymbolKind number (e.g. 5=Class, 12=Function, 11=Interface, 10=Enum)"
+      },
+      file: {
+        type: "string",
+        description: "Filter to files matching this path substring"
+      },
+      limit: {
+        type: "integer",
+        description: "Maximum results to return (default 20, max 100)",
+        minimum: 1,
+        maximum: 100
+      }
+    },
+    required: ["query"]
+  },
+  async execute(input, ctx) {
+    const store = new IndexStore(ctx.projectRoot);
+    try {
+      const limit = Math.min(input.limit ?? 20, 100);
+      const candidates = store.search(input.query, {
+        kind: input.kind,
+        lang: input.lang,
+        file: input.file,
+        lspKind: input.lspKind
+      });
+      if (candidates.length === 0) {
+        return { results: [], total: 0, query: input.query };
+      }
+      const indexable = candidates.map((c) => ({
+        id: c.id,
+        text: buildIndexableText(c.name, c.signature, c.docComment)
+      }));
+      const bm25 = buildBm25Index(indexable);
+      const scored = bm25.score(input.query, (id) => candidates.some((c) => c.id === id));
+      scored.sort((a, b) => b.score - a.score);
+      const top = scored.slice(0, limit);
+      const qTokens = tokenise(input.query);
+      const results = top.map(({ id, score }) => {
+        const c = candidates.find((c2) => c2.id === id);
+        const snippet = bm25.extractSnippet(id, qTokens);
+        return {
+          ...c,
+          score,
+          snippet
+        };
+      });
+      return {
+        results,
+        total: candidates.length,
+        query: input.query
+      };
+    } finally {
+      store.close();
+    }
+  }
+};
+
+// src/codebase-index/codebase-stats-tool.ts
+var codebaseStatsTool = {
+  name: "codebase-stats",
+  category: "Project",
+  description: "Return statistics about the symbol index: total symbols, files, breakdown by language and kind, index size, and last update time.",
+  usageHint: "No arguments needed. Use to check if the index is stale or healthy before running a search.",
+  permission: "auto",
+  mutating: false,
+  timeoutMs: 5e3,
+  inputSchema: {
+    type: "object",
+    properties: {},
+    additionalProperties: false
+  },
+  async execute(_input, ctx) {
+    const store = new IndexStore(ctx.projectRoot);
+    try {
+      const stats = store.getStats();
+      return {
+        totalSymbols: stats.totalSymbols,
+        totalFiles: stats.totalFiles,
+        byLang: stats.byLang,
+        byKind: stats.byKind,
+        lastIndexed: stats.lastIndexed,
+        sizeBytes: stats.sizeBytes,
+        indexPath: stats.indexPath,
+        version: stats.version
+      };
+    } finally {
+      store.close();
+    }
+  }
+};
+
+export { IndexStore, SCHEMA_VERSION, buildBm25Index, buildIndexableText, codebaseIndexTool, codebaseSearchTool, codebaseStatsTool, internalKindToLspKind, lspKindToInternalKind, tokenise };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map