@wrongstack/tools 0.7.5 → 0.7.7

package/dist/pack.js

@@ -1,15 +1,23 @@
-import { spawn } from 'child_process';
+import { spawn, execSync, spawnSync } from 'node:child_process';
 import { buildChildEnv, stripAnsi, detectNewlineStyle, normalizeToLf, toStyle, atomicWrite, unifiedDiff, compileGlob, loadPlan, emptyPlan, clearPlan, savePlan, getPlanTemplate, addPlanItem, deriveTodosFromPlanItem, removePlanItem, setPlanItemStatus, formatPlan } from '@wrongstack/core';
-import * as path from 'path';
-import { dirname } from 'path';
-import * as os from 'os';
-import { statSync } from 'fs';
-import * as fs9 from 'fs/promises';
-import { stat } from 'fs/promises';
-import * as dns from 'dns/promises';
-import * as net from 'net';
+import * as path from 'node:path';
+import { dirname } from 'node:path';
+import * as os from 'node:os';
+import * as fs11 from 'node:fs/promises';
+import { stat } from 'node:fs/promises';
+import * as fs from 'node:fs';
+import { statSync, mkdirSync, writeFileSync, unlinkSync } from 'node:fs';
+import { DatabaseSync } from 'node:sqlite';
+import * as ts from 'typescript';
+import * as dns from 'node:dns/promises';
+import * as net from 'node:net';
 
-// src/_spawn-stream.ts
+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');
+});
 async function* spawnStream(opts) {
   const max = opts.maxBytes ?? 2e5;
   const flushAt = opts.flushBytes ?? 4 * 1024;
@@ -57,8 +65,8 @@ async function* spawnStream(opts) {
   let spawnFailed = false;
   for (; ; ) {
     while (queue.length === 0) {
-      await new Promise((resolve5) => {
-        waiter = resolve5;
+      await new Promise((resolve6) => {
+        waiter = resolve6;
       });
     }
     const chunk = queue.shift();
@@ -169,14 +177,14 @@ var auditTool = {
   }
 };
 async function detectManager(cwd) {
-  const { stat: stat10 } = await import('fs/promises');
+  const { stat: stat11 } = await import('node:fs/promises');
   try {
-    await stat10(`${cwd}/pnpm-lock.yaml`);
+    await stat11(`${cwd}/pnpm-lock.yaml`);
     return "pnpm";
   } catch {
   }
   try {
-    await stat10(`${cwd}/yarn.lock`);
+    await stat11(`${cwd}/yarn.lock`);
     return "yarn";
   } catch {
   }
@@ -733,10 +741,10 @@ var bashTool = {
         queue.push(c);
       }
     };
-    const next = () => new Promise((resolve5) => {
+    const next = () => new Promise((resolve6) => {
       const c = queue.shift();
-      if (c) resolve5(c);
-      else resolveNext = resolve5;
+      if (c) resolve6(c);
+      else resolveNext = resolve6;
     });
     let lastFlush = Date.now();
     const flush = () => {
@@ -904,6 +912,1932 @@ async function executeSingle(call, ctx, opts) {
     };
   }
 }
+
+// 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;
+  }
+}
+
+// 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 = path.join(projectRoot, INDEX_DIR);
+    fs.mkdirSync(dir, { recursive: true });
+    this.db = new DatabaseSync(path.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(query2, 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 (query2.trim()) {
+      const tokens = query2.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: path.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 = path.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 = path.join(process.env.TEMP ?? "/tmp", "ws-go-parse");
+  try {
+    mkdirSync(tmpDir, { recursive: true });
+    const scriptPath = path.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 = path.join(process.cwd(), "tools");
+    try {
+      execSync("cargo metadata --no-deps --format-version 1 --manifest-path " + path.join(toolsDir, "Cargo.toml"), { stdio: "pipe" });
+      return true;
+    } catch {
+      return false;
+    }
+  } catch {
+    return false;
+  }
+}
+function tryNativeParse(file, content) {
+  try {
+    const toolsDir = path.join(process.cwd(), "tools");
+    const crateDir = path.join(toolsDir, "syn-parser");
+    const tmpFile = path.join(crateDir, "src", "input.rs");
+    const { writeFileSync: writeFileSync2 } = __require("node:fs");
+    writeFileSync2(tmpFile, content, "utf8");
+    const result = spawnSync("cargo", ["run", "--manifest-path", path.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 = path.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: path.basename(file),
+      kind: "object",
+      line,
+      col: 0,
+      signature: `"${path.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 fs11.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (ignoreSet.has(e.name)) continue;
+      const full = path.join(dir, e.name);
+      if (e.isDirectory()) {
+        await walk(full);
+      } else if (e.isFile()) {
+        const rel = path.relative(projectRoot, full).replace(/\\/g, "/");
+        const ext = path.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) => path.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 stat11;
+    try {
+      stat11 = await fs11.stat(file);
+    } catch {
+      store.deleteFile(file);
+      continue;
+    }
+    if (!stat11.isFile()) continue;
+    const lang = detectLang(file);
+    if (!lang) continue;
+    const meta = existingMeta.get(file);
+    if (!force && meta && meta.mtimeMs === Math.floor(stat11.mtimeMs)) {
+      langStats[lang] = (langStats[lang] ?? 0) + meta.symbolCount;
+      symbolsIndexed += meta.symbolCount;
+      filesIndexed++;
+      continue;
+    }
+    store.deleteSymbolsForFile(file);
+    store.deleteRefsForFile(file);
+    let content;
+    try {
+      content = await fs11.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(stat11.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(stat11.mtimeMs),
+      symbolCount: count,
+      lastIndexed: Date.now()
+    });
+    filesIndexed++;
+  }
+  for (const [file_] of existingMeta) {
+    try {
+      await fs11.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(query2, filter) {
+    const qTokens = tokenise(query2);
+    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();
+    }
+  }
+};
 var diffTool = {
   name: "diff",
   category: "Filesystem",
@@ -963,8 +2897,8 @@ function findGitDir(cwd) {
   let dir = cwd;
   for (let i = 0; i < 20; i++) {
     try {
-      const stat10 = statSync(path.join(dir, ".git"));
-      if (stat10.isDirectory()) return dir;
+      const stat11 = statSync(path.join(dir, ".git"));
+      if (stat11.isDirectory()) return dir;
     } catch {
     }
     const parent = path.dirname(dir);
@@ -974,7 +2908,7 @@ function findGitDir(cwd) {
   return null;
 }
 function runGit(args, cwd, signal) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     let stdout = "";
     let stderr = "";
     const child = spawn("git", args, { cwd, signal, env: buildChildEnv(), stdio: ["ignore", "pipe", "pipe"] });
@@ -984,8 +2918,8 @@ function runGit(args, cwd, signal) {
     child.stderr?.on("data", (c) => {
       stderr += c.toString();
     });
-    child.on("close", (code) => resolve5({ stdout, stderr, exitCode: code ?? 0 }));
-    child.on("error", (e) => resolve5({ stdout: "", stderr: e.message, exitCode: 1 }));
+    child.on("close", (code) => resolve6({ stdout, stderr, exitCode: code ?? 0 }));
+    child.on("error", (e) => resolve6({ stdout: "", stderr: e.message, exitCode: 1 }));
   });
 }
 async function fileDiff(input, ctx, signal) {
@@ -1003,9 +2937,9 @@ async function fileDiff(input, ctx, signal) {
   const results = [];
   for (const file of files) {
     const absPath = safeResolve(file, ctx);
-    const stat10 = await fs9.stat(absPath).catch(() => null);
-    if (!stat10?.isFile()) continue;
-    const content = await fs9.readFile(absPath, "utf8");
+    const stat11 = await fs11.stat(absPath).catch(() => null);
+    if (!stat11?.isFile()) continue;
+    const content = await fs11.readFile(absPath, "utf8");
     const lines = content.split(/\r?\n/);
     results.push(`--- ${file}
 +++ ${file}
@@ -1066,7 +3000,7 @@ var documentTool = {
     const fileList = input.files ? await resolveFiles(Array.isArray(input.files) ? input.files.join(",") : input.files, cwd) : input.path ? [safeResolve(input.path, ctx)] : [];
     for (const absPath of fileList) {
       try {
-        const content = await fs9.readFile(absPath, "utf8");
+        const content = await fs11.readFile(absPath, "utf8");
         filesProcessed++;
         const processed = processFile(
           content,
@@ -1102,8 +3036,8 @@ async function resolveFiles(filesInput, cwd) {
   for (const f of files) {
     const absPath = f.trim().startsWith("/") ? f.trim() : `${cwd}/${f.trim()}`;
     try {
-      const stat10 = await fs9.stat(absPath);
-      if (stat10.isFile()) resolved.push(absPath);
+      const stat11 = await fs11.stat(absPath);
+      if (stat11.isFile()) resolved.push(absPath);
     } catch {
     }
   }
@@ -1194,18 +3128,18 @@ var editTool = {
     if (input.new_string === void 0) throw new Error("edit: new_string is required");
     if (input.old_string === "") throw new Error("edit: old_string cannot be empty");
     const absPath = safeResolve(input.path, ctx);
-    const stat10 = await fs9.stat(absPath).catch((err) => {
+    const stat11 = await fs11.stat(absPath).catch((err) => {
       if (err.code === "ENOENT") {
         throw new Error(`edit: file "${input.path}" does not exist. Use \`write\` instead.`);
       }
       throw err;
     });
-    if (!stat10.isFile()) throw new Error(`edit: "${input.path}" is not a regular file`);
+    if (!stat11.isFile()) throw new Error(`edit: "${input.path}" is not a regular file`);
     if (!ctx.hasRead(absPath)) {
       throw new Error(`edit: file "${input.path}" was not read in this session. Read it first.`);
     }
-    const original = await fs9.readFile(absPath, "utf8");
-    const updated = await fs9.stat(absPath);
+    const original = await fs11.readFile(absPath, "utf8");
+    const updated = await fs11.stat(absPath);
     const mtimeTolerance = process.platform === "win32" ? 2e3 : 1;
     const lastReadMtime = ctx.lastReadMtime(absPath);
     if (lastReadMtime !== void 0 && updated.mtimeMs > lastReadMtime + mtimeTolerance) {
@@ -1350,8 +3284,8 @@ var BLOCKED_ARG_PATTERNS = {
   docker: [/^build$/, /^run$/, /^exec$/, /^push$/, /^pull$/],
   // find -exec/-ok/-execdir execute arbitrary commands
   find: [/^-exec$/, /^-exec;$/, /^-ok$/, /^-ok;$/, /^-execdir$/, /^-execdir;$/, /^-exec=/, /^-ok=/, /^-execdir=/],
-  // rm -rf / is catastrophic — block root and home targets
-  rm: [/^\/$/, /^\/\*$/, /^~$/],
+  // rm -rf / is catastrophic — block absolute paths, home, and dot-dir targets
+  rm: [/^\//, /^~/, /^\.{1,2}$/],
   // npm run/exec/create/pack/publish can execute arbitrary scripts or publish malware
   npm: [/^run$/, /^exec$/, /^create$/, /^init$/, /^pack$/, /^publish$/, /^deploy$/],
   // pnpm run/dlx/exec/create can execute arbitrary scripts
@@ -1458,7 +3392,7 @@ var execTool = {
   }
 };
 function runCommand(cmd, args, cwd, timeout, signal, sessionId) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     let stdout = "";
     let stderr = "";
     let killed = false;
@@ -1492,7 +3426,7 @@ function runCommand(cmd, args, cwd, timeout, signal, sessionId) {
       const durationMs = Date.now() - startedAt;
       const exitCode = killed ? 124 : code ?? 1;
       registry.afterCall(durationMs, exitCode !== 0);
-      resolve5({
+      resolve6({
         command: cmd,
         args,
         stdout: stdout.slice(0, MAX_OUTPUT2),
@@ -1506,7 +3440,7 @@ function runCommand(cmd, args, cwd, timeout, signal, sessionId) {
       clearTimeout(timer);
       if (typeof pid === "number") registry.unregister(pid);
       registry.afterCall(Date.now() - startedAt, true);
-      resolve5({
+      resolve6({
         command: cmd,
         args,
         stdout: stdout.slice(0, MAX_OUTPUT2),
@@ -1892,13 +3826,13 @@ var formatTool = {
   }
 };
 async function detectFixer(cwd) {
-  const { stat: stat10 } = await import('fs/promises');
+  const { stat: stat11 } = await import('node:fs/promises');
   try {
-    await stat10(`${cwd}/biome.json`);
+    await stat11(`${cwd}/biome.json`);
     return "biome";
   } catch {
     try {
-      await stat10(`${cwd}/.prettierrc`);
+      await stat11(`${cwd}/.prettierrc`);
       return "prettier";
     } catch {
       return "biome";
@@ -2002,8 +3936,8 @@ function findGitDir2(cwd, projectRoot) {
   let dir = cwd;
   for (let i = 0; i < 20; i++) {
     try {
-      const stat10 = statSync(`${dir}/.git`);
-      if (stat10.isDirectory()) return dir;
+      const stat11 = statSync(`${dir}/.git`);
+      if (stat11.isDirectory()) return dir;
     } catch {
     }
     if (dir === root) break;
@@ -2084,7 +4018,7 @@ function buildArgs(input) {
   }
 }
 function runGit2(args, cwd, signal) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     let stdout = "";
     let stderr = "";
     const child = spawn("git", args, {
@@ -2104,7 +4038,7 @@ function runGit2(args, cwd, signal) {
       }
     });
     child.on("error", (err) => {
-      resolve5({
+      resolve6({
         command: args[0],
         stdout,
         stderr: err.message,
@@ -2113,7 +4047,7 @@ function runGit2(args, cwd, signal) {
       });
     });
     child.on("close", (code) => {
-      resolve5({
+      resolve6({
         command: args[0],
         stdout: stdout.slice(0, MAX_OUTPUT3),
         stderr: stderr.slice(0, MAX_OUTPUT3),
@@ -2123,7 +4057,7 @@ function runGit2(args, cwd, signal) {
     });
   });
 }
-var DEFAULT_IGNORE = ["node_modules", ".git", "dist", "build", ".next", "coverage", ".turbo"];
+var DEFAULT_IGNORE2 = ["node_modules", ".git", "dist", "build", ".next", "coverage", ".turbo"];
 var globTool = {
   name: "glob",
   category: "Filesystem",
@@ -2157,13 +4091,13 @@ var globTool = {
       }
       let entries;
       try {
-        entries = await fs9.readdir(dir, { withFileTypes: true });
+        entries = await fs11.readdir(dir, { withFileTypes: true });
       } catch {
         return;
       }
       for (const e of entries) {
         const name = e.name;
-        if (DEFAULT_IGNORE.includes(name)) continue;
+        if (DEFAULT_IGNORE2.includes(name)) continue;
         if (ignored.includes(name)) continue;
         const rel = relPrefix ? `${relPrefix}/${name}` : name;
         const full = path.join(dir, name);
@@ -2173,7 +4107,7 @@ var globTool = {
         } else if (e.isFile()) {
           if (re.test(rel) || re.test(name)) {
             try {
-              const st = await fs9.stat(full);
+              const st = await fs11.stat(full);
               results.push({ rel: full, mtime: st.mtimeMs });
               if (results.length >= limit) {
                 truncated = true;
@@ -2192,7 +4126,7 @@ var globTool = {
 };
 async function readGitignore(dir) {
   try {
-    const raw = await fs9.readFile(path.join(dir, ".gitignore"), "utf8");
+    const raw = await fs11.readFile(path.join(dir, ".gitignore"), "utf8");
     return raw.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
   } catch {
     return [];
@@ -2245,7 +4179,7 @@ function capSubject(line) {
 }
 
 // src/grep.ts
-var DEFAULT_IGNORE2 = ["node_modules", ".git", "dist", "build", ".next", "coverage"];
+var DEFAULT_IGNORE3 = ["node_modules", ".git", "dist", "build", ".next", "coverage"];
 var grepTool = {
   name: "grep",
   category: "Search",
@@ -2299,13 +4233,13 @@ var grepTool = {
   }
 };
 async function detectRg(signal) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     try {
       const p = spawn("rg", ["--version"], { env: buildChildEnv(), stdio: "ignore", signal });
-      p.on("error", () => resolve5(false));
-      p.on("close", (code) => resolve5(code === 0));
+      p.on("error", () => resolve6(false));
+      p.on("close", (code) => resolve6(code === 0));
     } catch {
-      resolve5(false);
+      resolve6(false);
     }
   });
 }
@@ -2318,7 +4252,7 @@ async function* runRgStream(input, base, mode, limit, signal) {
     args.push("-n");
     if (input.context_lines) args.push("-C", String(input.context_lines));
   }
-  for (const ignored of DEFAULT_IGNORE2) {
+  for (const ignored of DEFAULT_IGNORE3) {
     args.push("--glob", `!${ignored}/**`, "--glob", `!**/${ignored}/**`);
   }
   if (input.glob) args.push("--glob", input.glob);
@@ -2451,13 +4385,13 @@ async function runNative(input, base, mode, limit, signal) {
     if (stopped || signal.aborted) return;
     let entries;
     try {
-      entries = await fs9.readdir(dir, { withFileTypes: true });
+      entries = await fs11.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
       if (stopped) return;
-      if (DEFAULT_IGNORE2.includes(e.name)) continue;
+      if (DEFAULT_IGNORE3.includes(e.name)) continue;
       if (e.isSymbolicLink()) continue;
       const full = path.join(dir, e.name);
       if (e.isDirectory()) {
@@ -2466,9 +4400,9 @@ async function runNative(input, base, mode, limit, signal) {
         if (globRe && !globRe.test(e.name) && !globRe.test(full)) continue;
         if (globRe) globRe.lastIndex = 0;
         try {
-          const stat10 = await fs9.stat(full);
-          if (stat10.size > 1e6) continue;
-          const head = await fs9.readFile(full);
+          const stat11 = await fs11.stat(full);
+          if (stat11.size > 1e6) continue;
+          const head = await fs11.readFile(full);
           if (isBinaryBuffer(head)) continue;
           const text = head.toString("utf8");
           const lines = text.split(/\r?\n/);
@@ -2606,13 +4540,13 @@ var installTool = {
   }
 };
 async function detectPackageManager(cwd) {
-  const { stat: stat10 } = await import('fs/promises');
+  const { stat: stat11 } = await import('node:fs/promises');
   try {
-    await stat10(`${cwd}/pnpm-lock.yaml`);
+    await stat11(`${cwd}/pnpm-lock.yaml`);
     return "pnpm";
   } catch {
     try {
-      await stat10(`${cwd}/yarn.lock`);
+      await stat11(`${cwd}/yarn.lock`);
       return "yarn";
     } catch {
       return "npm";
@@ -2653,7 +4587,7 @@ var jsonTool = {
     let raw;
     if (input.file) {
       try {
-        raw = await fs9.readFile(input.file, "utf8");
+        raw = await fs11.readFile(input.file, "utf8");
       } catch {
         return { data: null, formatted: "", type: "unknown", error: `Could not read file` };
       }
@@ -2691,8 +4625,8 @@ var jsonTool = {
     };
   }
 };
-function query(data, path12) {
-  const parts = path12.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
+function query(data, path17) {
+  const parts = path17.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
   let current = data;
   for (const part of parts) {
     if (current === null || current === void 0) return void 0;
@@ -2819,11 +4753,11 @@ var lintTool = {
   }
 };
 async function detectLinter(cwd) {
-  const { stat: stat10 } = await import('fs/promises');
+  const { stat: stat11 } = await import('node:fs/promises');
   const checks = ["biome.json", ".eslintrc.json", "tslint.json", ".eslintrc.js", "tsconfig.json"];
   for (const f of checks) {
     try {
-      await stat10(`${cwd}/${f}`);
+      await stat11(`${cwd}/${f}`);
       if (f.includes("biome")) return "biome";
       if (f.includes("eslint")) return "eslint";
       if (f.includes("tslint")) return "tslint";
@@ -2912,7 +4846,7 @@ async function dockerLogs(service, lines, filterRe, cwd, signal, since) {
     };
   }
   args.push("--timestamps", service);
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     let stdout = "";
     let stderr = "";
     const MAX = 2e5;
@@ -2926,7 +4860,7 @@ async function dockerLogs(service, lines, filterRe, cwd, signal, since) {
     child.on("close", (code) => {
       const output = stdout + stderr;
       const entries = parseLogLines(output, filterRe);
-      resolve5({
+      resolve6({
         source: `docker:${service}`,
         entries,
         total: entries.length,
@@ -2935,7 +4869,7 @@ async function dockerLogs(service, lines, filterRe, cwd, signal, since) {
       });
     });
     child.on("error", (e) => {
-      resolve5({
+      resolve6({
         source: `docker:${service}`,
         entries: [],
         total: 0,
@@ -2946,16 +4880,16 @@ async function dockerLogs(service, lines, filterRe, cwd, signal, since) {
   });
 }
 var MAX_TAIL_LINES = 1e5;
-async function fileLogs(path12, lines, filterRe, stream) {
-  const { createInterface } = await import('readline');
-  const { createReadStream } = await import('fs');
+async function fileLogs(path17, lines, filterRe, stream) {
+  const { createInterface } = await import('node:readline');
+  const { createReadStream } = await import('node:fs');
   const entries = [];
   const effLines = lines > 0 ? Math.min(lines, MAX_TAIL_LINES) : MAX_TAIL_LINES;
   const window = new Array(effLines);
   let writeIdx = 0;
   let totalLines = 0;
   const rl = createInterface({
-    input: createReadStream(path12),
+    input: createReadStream(path17),
     crlfDelay: Number.POSITIVE_INFINITY
   });
   for await (const line of rl) {
@@ -2976,7 +4910,7 @@ async function fileLogs(path12, lines, filterRe, stream) {
     if (parsed) entries.push(parsed);
   }
   return {
-    source: path12,
+    source: path17,
     entries,
     total: entries.length,
     truncated: totalLines > effLines,
@@ -3003,7 +4937,7 @@ function parseLine(line) {
       message: match[3] ?? ""
     };
   }
-  const levelRe = /(?:ERROR|WARN|INFO|DEBUG|TRACE)\s+(.*)/i;
+  const levelRe = /(ERROR|WARN|INFO|DEBUG|TRACE)\s+(.*)/i;
   const levelMatch = levelRe.exec(line);
   if (levelMatch) {
     return {
@@ -3068,7 +5002,7 @@ async function detectManager2(cwd) {
   return "npm";
 }
 function runOutdated(manager, args, cwd, signal) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     let stdout = "";
     let stderr = "";
     const MAX = 1e5;
@@ -3081,10 +5015,10 @@ function runOutdated(manager, args, cwd, signal) {
     });
     child.on("close", (code) => {
       const result = parseOutdatedOutput(stdout, code ?? 0);
-      resolve5(result);
+      resolve6(result);
     });
     child.on("error", (e) => {
-      resolve5({
+      resolve6({
         exit_code: 1,
         packages: [],
         total: 0,
@@ -3167,12 +5101,12 @@ var patchTool = {
         };
       }
     }
-    const tmpDir = await fs9.mkdtemp(path.join(os.tmpdir(), ".wstack_patch_"));
+    const tmpDir = await fs11.mkdtemp(path.join(os.tmpdir(), ".wstack_patch_"));
     try {
-      await fs9.chmod(tmpDir, 448).catch(() => {
+      await fs11.chmod(tmpDir, 448).catch(() => {
       });
       const patchFile = path.join(tmpDir, "in.diff");
-      await fs9.writeFile(patchFile, input.patch, { mode: 384 });
+      await fs11.writeFile(patchFile, input.patch, { mode: 384 });
       const args = [`-p${strip}`, "--merge", ...dryRun ? ["--dry-run"] : [], "-i", patchFile];
       const result = await runPatch(args, dir, opts.signal);
       if (result.exitCode !== 0 && !dryRun) {
@@ -3193,7 +5127,7 @@ var patchTool = {
         message: result.stdout || "patch applied"
       };
     } finally {
-      await fs9.rm(tmpDir, { recursive: true, force: true }).catch(() => {
+      await fs11.rm(tmpDir, { recursive: true, force: true }).catch(() => {
       });
     }
   }
@@ -3214,7 +5148,7 @@ function stripPathComponents(p, strip) {
   return parts.slice(strip).join("/");
 }
 function runPatch(args, cwd, signal) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     let stdout = "";
     let stderr = "";
     const env = { ...buildChildEnv(), LANG: "C", LC_ALL: "C" };
@@ -3225,8 +5159,8 @@ function runPatch(args, cwd, signal) {
     child.stderr?.on("data", (c) => {
       stderr += c.toString();
     });
-    child.on("close", (code) => resolve5({ exitCode: code ?? 1, stdout, stderr }));
-    child.on("error", (e) => resolve5({ exitCode: 1, stdout: "", stderr: e.message }));
+    child.on("close", (code) => resolve6({ exitCode: code ?? 1, stdout, stderr }));
+    child.on("error", (e) => resolve6({ exitCode: 1, stdout: "", stderr: e.message }));
   });
 }
 function extractPatchedFiles(output) {
@@ -3396,19 +5330,19 @@ var readTool = {
   async execute(input, ctx) {
     if (!input?.path) throw new Error("read: path is required");
     const absPath = safeResolve(input.path, ctx);
-    let stat10;
+    let stat11;
     try {
-      stat10 = await fs9.stat(absPath);
+      stat11 = await fs11.stat(absPath);
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") throw new Error(`read: file not found "${input.path}"`);
       throw new Error(`read: failed to stat "${input.path}": ${err instanceof Error ? err.message : String(err)}`);
     }
-    if (!stat10.isFile()) throw new Error(`read: "${input.path}" is not a regular file`);
-    if (stat10.size > MAX_BYTES2) {
-      throw new Error(`read: file too large (${stat10.size} bytes, limit ${MAX_BYTES2})`);
+    if (!stat11.isFile()) throw new Error(`read: "${input.path}" is not a regular file`);
+    if (stat11.size > MAX_BYTES2) {
+      throw new Error(`read: file too large (${stat11.size} bytes, limit ${MAX_BYTES2})`);
     }
-    const buf = await fs9.readFile(absPath);
+    const buf = await fs11.readFile(absPath);
     if (isBinaryBuffer(buf)) {
       throw new Error(`read: "${input.path}" appears to be binary`);
     }
@@ -3418,14 +5352,14 @@ var readTool = {
     const offset = Math.max(1, input.offset ?? 1);
     const limit = Math.max(0, Math.min(input.limit ?? 2e3, 5e3));
     if (limit === 0) {
-      ctx.recordRead(absPath, stat10.mtimeMs);
+      ctx.recordRead(absPath, stat11.mtimeMs);
       return { text: "", total_lines: total, encoding: "utf8", truncated: total > 0 };
     }
     const slice = allLines.slice(offset - 1, offset - 1 + limit);
     const truncated = offset - 1 + slice.length < total;
     const width = String(offset + slice.length - 1).length;
     const numbered = slice.map((line, i) => `${String(offset + i).padStart(width, " ")}\u2192${line}`).join("\n");
-    ctx.recordRead(absPath, stat10.mtimeMs);
+    ctx.recordRead(absPath, stat11.mtimeMs);
     return {
       text: numbered,
       total_lines: total,
@@ -3434,7 +5368,7 @@ var readTool = {
     };
   }
 };
-var DEFAULT_IGNORE3 = ["node_modules", ".git", "dist", "build", ".next", "coverage"];
+var DEFAULT_IGNORE4 = ["node_modules", ".git", "dist", "build", ".next", "coverage"];
 var replaceTool = {
   name: "replace",
   category: "Transform",
@@ -3478,7 +5412,7 @@ var replaceTool = {
     const results = [];
     let totalReplacements = 0;
     for (const absPath of fileList) {
-      const lstat2 = await fs9.lstat(absPath).catch((err) => {
+      const lstat2 = await fs11.lstat(absPath).catch((err) => {
         if (err.code === "ENOENT") return null;
         throw err;
       });
@@ -3486,17 +5420,17 @@ var replaceTool = {
       if (lstat2.isSymbolicLink()) continue;
       let realPath;
       try {
-        realPath = await fs9.realpath(absPath);
+        realPath = await fs11.realpath(absPath);
       } catch {
         continue;
       }
       const rel = path.relative(ctx.projectRoot, realPath);
       if (rel.startsWith("..") || path.isAbsolute(rel)) continue;
-      const stat10 = await fs9.stat(realPath).catch(() => null);
-      if (!stat10 || !stat10.isFile()) continue;
+      const stat11 = await fs11.stat(realPath).catch(() => null);
+      if (!stat11 || !stat11.isFile()) continue;
       let content;
       try {
-        const buf = await fs9.readFile(realPath);
+        const buf = await fs11.readFile(realPath);
         if (isBinaryBuffer(buf)) continue;
         content = buf.toString("utf8");
       } catch {
@@ -3518,7 +5452,7 @@ var replaceTool = {
       totalReplacements += count;
       if (!dryRun) {
         const newContent = toStyle(newContentLf, style);
-        await atomicWrite(realPath, newContent, { mode: stat10.mode & 511 });
+        await atomicWrite(realPath, newContent, { mode: stat11.mode & 511 });
       }
       const diff = dryRun || matches.length > 0 ? unifiedDiff(content, toStyle(newContentLf, style), {
         fromFile: absPath,
@@ -3548,15 +5482,15 @@ async function resolveFiles2(filesInput, ctx, extraGlob) {
   const resolved = [];
   for (const p of parts) {
     const absPath = safeResolve(p, ctx);
-    const stat10 = await fs9.stat(absPath).catch(() => null);
-    if (stat10?.isFile()) {
+    const stat11 = await fs11.stat(absPath).catch(() => null);
+    if (stat11?.isFile()) {
       resolved.push(absPath);
     }
   }
   return resolved;
 }
 async function globFiles(pattern, base, extraGlob) {
-  const { spawn: spawn11 } = await import('child_process');
+  const { spawn: spawn11 } = await import('node:child_process');
   const rgAvailable = await checkRg();
   if (rgAvailable) {
     try {
@@ -3568,13 +5502,13 @@ async function globFiles(pattern, base, extraGlob) {
   return await globNative(pattern, base, extraGlob);
 }
 function checkRg() {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     try {
       const p = spawn("rg", ["--version"], { env: buildChildEnv(), stdio: "ignore" });
-      p.on("error", () => resolve5(false));
-      p.on("close", (code) => resolve5(code === 0));
+      p.on("error", () => resolve6(false));
+      p.on("close", (code) => resolve6(code === 0));
     } catch {
-      resolve5(false);
+      resolve6(false);
     }
   });
 }
@@ -3586,10 +5520,10 @@ function spawnRgFind(pattern, base) {
     buf += chunk.toString();
   });
   return {
-    promise: new Promise((resolve5, reject) => {
+    promise: new Promise((resolve6, reject) => {
       child.on("error", reject);
       child.on("close", () => {
-        resolve5(buf.split("\n").filter(Boolean));
+        resolve6(buf.split("\n").filter(Boolean));
       });
     })
   };
@@ -3600,16 +5534,16 @@ async function globNative(pattern, base, extraGlob) {
   const walk = async (dir) => {
     let entries;
     try {
-      entries = await fs9.readdir(dir, { withFileTypes: true });
+      entries = await fs11.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
-      if (DEFAULT_IGNORE3.includes(e.name)) continue;
+      if (DEFAULT_IGNORE4.includes(e.name)) continue;
       const full = path.join(dir, e.name);
       try {
-        const stat10 = await fs9.lstat(full);
-        if (stat10.isSymbolicLink()) continue;
+        const stat11 = await fs11.lstat(full);
+        if (stat11.isSymbolicLink()) continue;
       } catch {
         continue;
       }
@@ -3784,7 +5718,7 @@ async function handleBuiltIn(name, templateFiles, cwd, ctx, dryRun, vars) {
     }
     const fullPath = target;
     if (!dryRun) {
-      await fs9.mkdir(path.dirname(fullPath), { recursive: true });
+      await fs11.mkdir(path.dirname(fullPath), { recursive: true });
       await atomicWrite(fullPath, substituteVars(content, name, vars));
     }
     files.push(resolvedPath);
@@ -4095,11 +6029,11 @@ var testTool = {
   }
 };
 async function detectRunner(cwd) {
-  const { stat: stat10 } = await import('fs/promises');
+  const { stat: stat11 } = await import('node:fs/promises');
   const candidates = ["vitest.config.ts", "jest.config.js", ".mocharc.json"];
   for (const f of candidates) {
     try {
-      await stat10(path.join(cwd, f));
+      await stat11(path.join(cwd, f));
       if (f.includes("vitest")) return "vitest";
       if (f.includes("jest")) return "jest";
       if (f.includes("mocha")) return "mocha";
@@ -4487,7 +6421,7 @@ var toolUseTool = {
     }
   }
 };
-var DEFAULT_IGNORE4 = [
+var DEFAULT_IGNORE5 = [
   "node_modules",
   ".git",
   "dist",
@@ -4552,7 +6486,7 @@ var treeTool = {
     const showFiles = input.show_files ?? true;
     const showDirs = input.show_dirs ?? true;
     const showHidden = input.show_hidden ?? false;
-    const exclude = /* @__PURE__ */ new Set([...DEFAULT_IGNORE4, ...input.exclude ?? []]);
+    const exclude = /* @__PURE__ */ new Set([...DEFAULT_IGNORE5, ...input.exclude ?? []]);
     const filterGlob = input.glob;
     const lines = [basePath];
     const totals = { totalFiles: { value: 0 }, totalDirs: { value: 0 } };
@@ -4617,7 +6551,7 @@ var treeTool = {
   }
 };
 async function walkDir(dir, depth, opts) {
-  const entries = await fs9.readdir(dir, { withFileTypes: true }).catch(() => []);
+  const entries = await fs11.readdir(dir, { withFileTypes: true }).catch(() => []);
   const filtered = entries.filter((e) => {
     if (!opts.showHidden && e.name.startsWith(".")) return false;
     if (opts.exclude.has(e.name)) return false;
@@ -4724,11 +6658,11 @@ var typecheckTool = {
   }
 };
 async function findTsConfig(cwd) {
-  const { stat: stat10 } = await import('fs/promises');
+  const { stat: stat11 } = await import('node:fs/promises');
   const candidates = ["tsconfig.json", "tsconfig.base.json"];
   for (const f of candidates) {
     try {
-      const s = await stat10(path.join(cwd, f));
+      const s = await stat11(path.join(cwd, f));
       if (s.isFile()) return path.join(cwd, f);
     } catch {
     }
@@ -4758,14 +6692,14 @@ var writeTool = {
     let existed = false;
     let prev = "";
     try {
-      const stat11 = await fs9.stat(absPath);
-      existed = stat11.isFile();
+      const stat12 = await fs11.stat(absPath);
+      existed = stat12.isFile();
       if (existed) {
         if (!ctx.hasRead(absPath)) {
-          prev = await fs9.readFile(absPath, "utf8");
-          ctx.recordRead(absPath, stat11.mtimeMs);
+          prev = await fs11.readFile(absPath, "utf8");
+          ctx.recordRead(absPath, stat12.mtimeMs);
         } else {
-          prev = await fs9.readFile(absPath, "utf8");
+          prev = await fs11.readFile(absPath, "utf8");
         }
       }
     } catch (err) {
@@ -4776,8 +6710,8 @@ var writeTool = {
     await atomicWrite(absPath, input.content);
     const diff = existed ? unifiedDiff(prev, input.content, { fromFile: input.path, toFile: input.path }) : `+++ ${input.path}
 + (new file, ${input.content.split("\n").length} lines)`;
-    const stat10 = await fs9.stat(absPath);
-    ctx.recordRead(absPath, stat10.mtimeMs);
+    const stat11 = await fs11.stat(absPath);
+    ctx.recordRead(absPath, stat11.mtimeMs);
     ctx.session.recordFileChange({
       path: absPath,
       action: existed ? "modified" : "created",
@@ -4825,7 +6759,10 @@ var builtinTools = [
   toolSearchTool,
   toolUseTool,
   batchToolUseTool,
-  toolHelpTool
+  toolHelpTool,
+  codebaseIndexTool,
+  codebaseSearchTool,
+  codebaseStatsTool
 ];
 
 // src/pack.ts