@wrongstack/tools 0.313.0 → 0.313.1

package/dist/chunk-OZC255IC.js

@@ -0,0 +1,2830 @@
+import {
+  parseTreeSitterAst
+} from "./chunk-B2CIOKWP.js";
+import {
+  spawnStream
+} from "./chunk-MAN26PZ5.js";
+import {
+  codebaseIndexStats,
+  enqueueReindex,
+  getIndexState,
+  incomingCallsService,
+  isIndexing,
+  outgoingCallsService,
+  runStartupIndex,
+  searchCodebaseIndex
+} from "./chunk-2ME7ZWDD.js";
+import {
+  IndexTimeoutError,
+  SCHEMA_VERSION,
+  codebaseIndexDirOverride,
+  indexCircuitBreaker,
+  indexStorePool,
+  resolveIndexDir
+} from "./chunk-OA6YJIWL.js";
+import {
+  EXT_TO_LANG,
+  detectLang,
+  isIndexablePath
+} from "./chunk-ILESNGNM.js";
+import {
+  normalizeCommandOutput
+} from "./chunk-D33S4RQG.js";
+
+// src/codebase-index/codebase-ast-replace-tool.ts
+import * as path2 from "node:path";
+import { toErrorMessage } from "@wrongstack/core/utils";
+
+// src/codebase-index/ast-symbol-mutator.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { atomicWrite } from "@wrongstack/core/utils";
+
+// src/codebase-index/ast-invariant-engine.ts
+var tsModule = null;
+async function loadTs() {
+  if (!tsModule) {
+    const mod = await import("@typescript/typescript6");
+    tsModule = mod.default ?? mod;
+  }
+  return tsModule;
+}
+var PolyglotInvariantEngine = class {
+  /**
+   * Evaluate whether a code mutation respects backward compatibility invariants.
+   */
+  async evaluate(opts) {
+    const startMs = Date.now();
+    const detected = opts.filePath ? detectLang(opts.filePath) : null;
+    const lang = opts.lang ?? detected ?? "ts";
+    const [origContract, modContract] = await Promise.all([
+      this.extractContract(opts.originalCode, lang),
+      this.extractContract(opts.modifiedCode, lang)
+    ]);
+    const violations = [];
+    for (const exp of origContract.exports) {
+      if (!modContract.exports.has(exp)) {
+        violations.push({
+          ruleId: "INV-001",
+          symbolName: exp,
+          lang,
+          severity: "CRITICAL",
+          message: `Public/exported symbol '${exp}' was deleted or renamed in ${lang.toUpperCase()}. Dependent modules or consumers will break.`
+        });
+      }
+    }
+    for (const [name, origFunc] of origContract.functions) {
+      const modFunc = modContract.functions.get(name);
+      if (!modFunc) continue;
+      const origRequired = origFunc.params.filter(
+        (p) => !p.isOptional && !p.hasDefault && !p.isRest
+      );
+      const modRequired = modFunc.params.filter((p) => !p.isOptional && !p.hasDefault && !p.isRest);
+      if (lang === "go" || lang === "rs") {
+        if (modFunc.params.length > origFunc.params.length) {
+          const addedParam = modFunc.params[origFunc.params.length];
+          violations.push({
+            ruleId: "INV-002",
+            symbolName: name,
+            lang,
+            severity: "CRITICAL",
+            message: `Function/method '${name}' in ${lang.toUpperCase()} had new parameter ('${addedParam?.name ?? "param"}') added. In ${lang.toUpperCase()}, signatures cannot take optional parameters without breaking all existing callers. Introduce a new function or options struct instead.`,
+            details: {
+              addedParameter: addedParam?.name
+            }
+          });
+        }
+      } else if (modRequired.length > origRequired.length) {
+        const addedReq = modFunc.params.find(
+          (p, i) => !p.isOptional && !p.hasDefault && !p.isRest && i >= origRequired.length
+        ) ?? modRequired[modRequired.length - 1];
+        violations.push({
+          ruleId: "INV-002",
+          symbolName: name,
+          lang,
+          severity: "CRITICAL",
+          message: `Function '${name}' had new mandatory parameter ('${addedReq?.name}') added. For backward compatibility, make it optional (e.g. '?', default value '= value', or '*args/**kwargs').`,
+          details: {
+            addedParameter: addedReq?.name
+          }
+        });
+      }
+      if (origFunc.returnType && modFunc.returnType && origFunc.returnType !== modFunc.returnType) {
+        const isBreakingAsync = origFunc.returnType.includes("Promise<") && !modFunc.returnType.includes("Promise<");
+        const isBreakingResult = origFunc.returnType.includes("Result<") && !modFunc.returnType.includes("Result<");
+        if (isBreakingAsync || isBreakingResult) {
+          violations.push({
+            ruleId: "INV-004",
+            symbolName: name,
+            lang,
+            severity: "CRITICAL",
+            message: `Return type of '${name}' changed incompatibly from '${origFunc.returnType}' to '${modFunc.returnType}'. Callers awaiting or unpacking results will fail.`,
+            details: {
+              originalSignature: origFunc.returnType,
+              modifiedSignature: modFunc.returnType
+            }
+          });
+        }
+      }
+    }
+    for (const [name, origIface] of origContract.interfaces) {
+      const modIface = modContract.interfaces.get(name);
+      if (!modIface) continue;
+      const origPropNames = new Set(origIface.properties.map((p) => p.name));
+      for (const prop of modIface.properties) {
+        if (!origPropNames.has(prop.name) && !prop.isOptional && !prop.hasDefault) {
+          violations.push({
+            ruleId: "INV-003",
+            symbolName: `${name}.${prop.name}`,
+            lang,
+            severity: "CRITICAL",
+            message: `Interface/model '${name}' had new mandatory property ('${prop.name}') added. All implementations and mock objects will break. Mark it optional ('${prop.name}?') or provide a default value.`,
+            details: {
+              addedProperty: prop.name
+            }
+          });
+        }
+      }
+      const origMethodNames = new Set(origIface.methods.map((m) => m.name));
+      for (const method of modIface.methods) {
+        if (!origMethodNames.has(method.name) && !method.isOptional) {
+          violations.push({
+            ruleId: "INV-003",
+            symbolName: `${name}.${method.name}()`,
+            lang,
+            severity: "CRITICAL",
+            message: `Interface/trait '${name}' had new mandatory method ('${method.name}') added. Existing implementors will fail to compile.`,
+            details: {
+              addedProperty: method.name
+            }
+          });
+        }
+      }
+    }
+    const durationMs = Date.now() - startMs;
+    return {
+      valid: violations.length === 0,
+      violations,
+      stats: {
+        originalSymbols: origContract.functions.size + origContract.interfaces.size,
+        modifiedSymbols: modContract.functions.size + modContract.interfaces.size,
+        durationMs
+      }
+    };
+  }
+  /**
+   * Extract high-level contract signatures from source code.
+   */
+  async extractContract(code, lang) {
+    if (["ts", "tsx", "js", "jsx"].includes(lang)) {
+      try {
+        return await this.extractTsContract(code, lang);
+      } catch {
+      }
+    }
+    return await this.extractTreeSitterContract(code, lang);
+  }
+  /**
+   * TypeScript & JavaScript extraction via TS Compiler API.
+   */
+  async extractTsContract(code, lang) {
+    const ts = await loadTs();
+    const scriptKind = lang === "tsx" ? ts.ScriptKind.TSX : lang === "jsx" ? ts.ScriptKind.JSX : lang === "js" ? ts.ScriptKind.JS : ts.ScriptKind.TS;
+    const sourceFile = ts.createSourceFile(
+      lang === "tsx" ? "contract.tsx" : "contract.ts",
+      code,
+      ts.ScriptTarget.Latest,
+      true,
+      scriptKind
+    );
+    const exports = /* @__PURE__ */ new Set();
+    const functions = /* @__PURE__ */ new Map();
+    const interfaces = /* @__PURE__ */ new Map();
+    function isExportedNode(node) {
+      if (ts.canHaveModifiers(node)) {
+        const modifiers = ts.getModifiers(node);
+        if (modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function visit(node) {
+      if (ts.isExportDeclaration(node) && node.exportClause && ts.isNamedExports(node.exportClause)) {
+        for (const element of node.exportClause.elements) {
+          exports.add(element.name.text);
+        }
+      }
+      if (ts.isFunctionDeclaration(node) && node.name) {
+        const name = node.name.text;
+        const isExp = isExportedNode(node);
+        if (isExp) exports.add(name);
+        const params = node.parameters.map((p) => {
+          const pName = p.name.getText(sourceFile);
+          const isOptional = Boolean(p.questionToken);
+          const hasDefault = Boolean(p.initializer);
+          const isRest = Boolean(p.dotDotDotToken);
+          const type = p.type ? p.type.getText(sourceFile) : void 0;
+          return { name: pName, isOptional, hasDefault, isRest, type };
+        });
+        const returnType = node.type ? node.type.getText(sourceFile) : void 0;
+        functions.set(name, { name, isExported: isExp, params, returnType });
+      }
+      if (ts.isClassDeclaration(node) && node.name) {
+        const className = node.name.text;
+        const isExp = isExportedNode(node);
+        if (isExp) exports.add(className);
+        for (const member of node.members) {
+          if (ts.isMethodDeclaration(member) && member.name && ts.isIdentifier(member.name)) {
+            const methodName = member.name.text;
+            const fullMethodName = `${className}.${methodName}`;
+            const params = member.parameters.map((p) => {
+              const pName = p.name.getText(sourceFile);
+              const isOptional = Boolean(p.questionToken);
+              const hasDefault = Boolean(p.initializer);
+              const isRest = Boolean(p.dotDotDotToken);
+              const type = p.type ? p.type.getText(sourceFile) : void 0;
+              return { name: pName, isOptional, hasDefault, isRest, type };
+            });
+            const returnType = member.type ? member.type.getText(sourceFile) : void 0;
+            functions.set(fullMethodName, {
+              name: fullMethodName,
+              isExported: isExp,
+              params,
+              returnType
+            });
+            functions.set(methodName, {
+              name: methodName,
+              isExported: isExp,
+              params,
+              returnType
+            });
+          }
+        }
+      }
+      if (ts.isInterfaceDeclaration(node) && node.name) {
+        const name = node.name.text;
+        const isExp = isExportedNode(node);
+        if (isExp) exports.add(name);
+        const properties = [];
+        const methods = [];
+        for (const member of node.members) {
+          if (ts.isPropertySignature(member) && member.name) {
+            const propName = member.name.getText(sourceFile);
+            const isOptional = Boolean(member.questionToken);
+            const type = member.type ? member.type.getText(sourceFile) : void 0;
+            properties.push({ name: propName, isOptional, type });
+          } else if (ts.isMethodSignature(member) && member.name) {
+            const methodName = member.name.getText(sourceFile);
+            const isOptional = Boolean(member.questionToken);
+            const params = member.parameters.map((p) => ({
+              name: p.name.getText(sourceFile),
+              isOptional: Boolean(p.questionToken),
+              hasDefault: Boolean(p.initializer),
+              isRest: Boolean(p.dotDotDotToken)
+            }));
+            const returnType = member.type ? member.type.getText(sourceFile) : void 0;
+            methods.push({ name: methodName, isOptional, params, returnType });
+          }
+        }
+        interfaces.set(name, { name, isExported: isExp, properties, methods });
+      }
+      if (ts.isTypeAliasDeclaration(node) && node.name && ts.isTypeLiteralNode(node.type)) {
+        const name = node.name.text;
+        const isExp = isExportedNode(node);
+        if (isExp) exports.add(name);
+        const properties = [];
+        for (const member of node.type.members) {
+          if (ts.isPropertySignature(member) && member.name) {
+            const propName = member.name.getText(sourceFile);
+            const isOptional = Boolean(member.questionToken);
+            const type = member.type ? member.type.getText(sourceFile) : void 0;
+            properties.push({ name: propName, isOptional, type });
+          }
+        }
+        interfaces.set(name, { name, isExported: isExp, properties, methods: [] });
+      }
+      ts.forEachChild(node, visit);
+    }
+    ts.forEachChild(sourceFile, visit);
+    return { lang, exports, functions, interfaces };
+  }
+  /**
+   * Polyglot extraction (Python, Go, Rust, Java, etc.) via Tree-sitter WASM.
+   */
+  async extractTreeSitterContract(code, lang) {
+    const exports = /* @__PURE__ */ new Set();
+    const functions = /* @__PURE__ */ new Map();
+    const interfaces = /* @__PURE__ */ new Map();
+    const parsed = await parseTreeSitterAst({ content: code, lang });
+    if (!parsed) {
+      return { lang, exports, functions, interfaces };
+    }
+    const { tree, parser } = parsed;
+    try {
+      let walk2 = function(node) {
+        const type = node.type;
+        if (lang === "py") {
+          if (type === "function_definition") {
+            const nameNode = node.childForFieldName("name");
+            if (nameNode) {
+              const name = nameNode.text;
+              const isExported = !name.startsWith("_");
+              if (isExported) exports.add(name);
+              const paramsNode = node.childForFieldName("parameters");
+              const params = [];
+              if (paramsNode) {
+                for (let i = 0; i < paramsNode.namedChildCount; i++) {
+                  const param = paramsNode.namedChild(i);
+                  if (!param) continue;
+                  const pText = param.text;
+                  const isRest = pText.startsWith("*");
+                  const hasDefault = param.type === "default_parameter" || param.type === "typed_default_parameter" || pText.includes("=");
+                  const idNode = param.childForFieldName("name") ?? param;
+                  params.push({
+                    name: idNode.text.split(":")[0]?.trim() ?? idNode.text,
+                    isOptional: hasDefault || isRest,
+                    hasDefault,
+                    isRest
+                  });
+                }
+              }
+              functions.set(name, { name, isExported, params });
+            }
+          } else if (type === "class_definition") {
+            const nameNode = node.childForFieldName("name");
+            if (nameNode) {
+              const name = nameNode.text;
+              if (!name.startsWith("_")) exports.add(name);
+            }
+          }
+        } else if (lang === "go") {
+          if (type === "function_declaration" || type === "method_declaration") {
+            const nameNode = node.childForFieldName("name");
+            if (nameNode) {
+              const name = nameNode.text;
+              const isExported = /^[A-Z]/.test(name);
+              if (isExported) exports.add(name);
+              const paramsNode = node.childForFieldName("parameters");
+              const params = [];
+              if (paramsNode) {
+                for (let i = 0; i < paramsNode.namedChildCount; i++) {
+                  const param = paramsNode.namedChild(i);
+                  if (!param) continue;
+                  params.push({
+                    name: param.text,
+                    isOptional: false,
+                    hasDefault: false,
+                    isRest: param.type === "variadic_parameter_declaration"
+                  });
+                }
+              }
+              functions.set(name, { name, isExported, params });
+            }
+          } else if (type === "type_spec") {
+            const nameNode = node.childForFieldName("name");
+            const typeNode = node.childForFieldName("type");
+            if (nameNode) {
+              const name = nameNode.text;
+              const isExported = /^[A-Z]/.test(name);
+              if (isExported) exports.add(name);
+              if (typeNode && typeNode.type === "interface_type") {
+                const methods = [];
+                for (let i = 0; i < typeNode.namedChildCount; i++) {
+                  const elem = typeNode.namedChild(i);
+                  if (elem && (elem.type === "method_spec" || elem.type === "method_elem")) {
+                    const mName = elem.childForFieldName("name")?.text ?? elem.text.split("(")[0]?.trim() ?? "";
+                    if (mName) {
+                      methods.push({ name: mName, isOptional: false, params: [] });
+                    }
+                  }
+                }
+                interfaces.set(name, { name, isExported, properties: [], methods });
+              }
+            }
+          }
+        } else if (lang === "rs") {
+          if (type === "function_item") {
+            const nameNode = node.childForFieldName("name");
+            if (nameNode) {
+              const name = nameNode.text;
+              const isExported = node.children.some((c) => c.type === "visibility_modifier");
+              if (isExported) exports.add(name);
+              const paramsNode = node.childForFieldName("parameters");
+              const params = [];
+              if (paramsNode) {
+                for (let i = 0; i < paramsNode.namedChildCount; i++) {
+                  const param = paramsNode.namedChild(i);
+                  if (!param) continue;
+                  params.push({
+                    name: param.text,
+                    isOptional: false,
+                    hasDefault: false,
+                    isRest: false
+                  });
+                }
+              }
+              functions.set(name, { name, isExported, params });
+            }
+          } else if (type === "trait_item") {
+            const nameNode = node.childForFieldName("name");
+            if (nameNode) {
+              const name = nameNode.text;
+              const isExported = node.children.some((c) => c.type === "visibility_modifier");
+              if (isExported) exports.add(name);
+              const methods = [];
+              const bodyNode = node.childForFieldName("body");
+              if (bodyNode) {
+                for (let i = 0; i < bodyNode.namedChildCount; i++) {
+                  const child = bodyNode.namedChild(i);
+                  if (child && child.type === "function_item") {
+                    const mName = child.childForFieldName("name")?.text;
+                    const hasDefaultBody = Boolean(child.childForFieldName("body"));
+                    if (mName) {
+                      methods.push({
+                        name: mName,
+                        isOptional: hasDefaultBody,
+                        params: []
+                      });
+                    }
+                  }
+                }
+              }
+              interfaces.set(name, { name, isExported, properties: [], methods });
+            }
+          }
+        }
+        for (let i = 0; i < node.namedChildCount; i++) {
+          const child = node.namedChild(i);
+          if (child) walk2(child);
+        }
+      };
+      var walk = walk2;
+      const root = tree.rootNode;
+      walk2(root);
+      return { lang, exports, functions, interfaces };
+    } finally {
+      tree.delete();
+      parser.delete();
+    }
+  }
+};
+var polyglotInvariantEngine = new PolyglotInvariantEngine();
+
+// src/codebase-index/ast-symbol-mutator.ts
+var tsModule2 = null;
+async function loadTs2() {
+  if (!tsModule2) {
+    const mod = await import("@typescript/typescript6");
+    tsModule2 = mod.default ?? mod;
+  }
+  return tsModule2;
+}
+async function mutateTsSymbol(content, lang, symbolName, newBody, target = "body") {
+  const ts = await loadTs2();
+  const scriptKind = lang === "tsx" ? ts.ScriptKind.TSX : lang === "jsx" ? ts.ScriptKind.JSX : lang === "js" ? ts.ScriptKind.JS : ts.ScriptKind.TS;
+  const sourceFile = ts.createSourceFile(
+    lang === "tsx" ? "temp.tsx" : "temp.ts",
+    content,
+    ts.ScriptTarget.Latest,
+    true,
+    scriptKind
+  );
+  let targetNode = null;
+  let bodyNode = null;
+  function visit(node) {
+    if (targetNode) return;
+    if (ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node) || ts.isConstructorDeclaration(node) || ts.isGetAccessor(node) || ts.isSetAccessor(node) || ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node)) {
+      let name;
+      if ("name" in node && node.name && ts.isIdentifier(node.name)) {
+        name = node.name.text;
+      }
+      if (name === symbolName) {
+        targetNode = node;
+        if ("body" in node && node.body) {
+          bodyNode = node.body;
+        }
+        return;
+      }
+    } else if (ts.isVariableStatement(node)) {
+      for (const decl of node.declarationList.declarations) {
+        if (ts.isIdentifier(decl.name) && decl.name.text === symbolName) {
+          targetNode = decl;
+          if (decl.initializer && (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer))) {
+            bodyNode = decl.initializer.body;
+          }
+          return;
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  ts.forEachChild(sourceFile, visit);
+  if (!targetNode) return null;
+  const replaceTarget = target === "full" || !bodyNode ? targetNode : bodyNode;
+  const startPos = replaceTarget.getStart(sourceFile);
+  const endPos = replaceTarget.getEnd();
+  const startLine = sourceFile.getLineAndCharacterOfPosition(startPos).line + 1;
+  const endLine = sourceFile.getLineAndCharacterOfPosition(endPos).line + 1;
+  let formattedReplacement = newBody.trim();
+  if (target === "body" && bodyNode && ts.isBlock(bodyNode)) {
+    if (!formattedReplacement.startsWith("{")) {
+      formattedReplacement = `{
+  ${formattedReplacement.split("\n").join("\n  ")}
+}`;
+    }
+  }
+  const updatedContent = content.slice(0, startPos) + formattedReplacement + content.slice(endPos);
+  const newEndLine = startLine + formattedReplacement.split("\n").length - 1;
+  return {
+    file: "",
+    symbol: symbolName,
+    originalRange: { startLine, endLine },
+    newRange: { startLine, endLine: newEndLine },
+    updatedContent
+  };
+}
+async function mutateTreeSitterSymbol(content, lang, symbolName, newBody, target = "body") {
+  const parsed = await parseTreeSitterAst({ content, lang });
+  if (!parsed) return null;
+  const { tree, parser } = parsed;
+  try {
+    let walk2 = function(node) {
+      if (targetNode) return;
+      const nameNode = node.childForFieldName("name") ?? node.childForFieldName("declarator");
+      if (nameNode && nameNode.text === symbolName) {
+        targetNode = node;
+        bodyNode = node.childForFieldName("body") ?? node.children.find(
+          (c) => [
+            "compound_statement",
+            "statement_block",
+            "block",
+            "function_body",
+            "body_statement",
+            "code_block",
+            "do_block"
+          ].includes(c.type)
+        ) ?? null;
+        return;
+      }
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child) walk2(child);
+      }
+    };
+    var walk = walk2;
+    const root = tree.rootNode;
+    let targetNode = null;
+    let bodyNode = null;
+    walk2(root);
+    if (!targetNode) return null;
+    const replaceTarget = target === "full" || !bodyNode ? targetNode : bodyNode;
+    const startPos = replaceTarget.startIndex;
+    const endPos = replaceTarget.endIndex;
+    const startLine = replaceTarget.startPosition.row + 1;
+    const endLine = replaceTarget.endPosition.row + 1;
+    let formattedReplacement = newBody.trim();
+    if (target === "body" && lang === "py") {
+      const indent = "    ";
+      formattedReplacement = formattedReplacement.split("\n").map((l) => l.trim() ? `${indent}${l}` : "").join("\n");
+    }
+    const updatedContent = content.slice(0, startPos) + formattedReplacement + content.slice(endPos);
+    const newEndLine = startLine + formattedReplacement.split("\n").length - 1;
+    return {
+      file: "",
+      symbol: symbolName,
+      originalRange: { startLine, endLine },
+      newRange: { startLine, endLine: newEndLine },
+      updatedContent
+    };
+  } finally {
+    tree.delete();
+    parser.delete();
+  }
+}
+async function replaceSymbolInFile(opts, projectRoot) {
+  const resolved = path.isAbsolute(opts.file) ? opts.file : path.resolve(projectRoot, opts.file);
+  const content = await fs.readFile(resolved, "utf8");
+  const lang = detectLang(resolved) ?? "other";
+  let result = null;
+  if (["ts", "tsx", "js", "jsx"].includes(lang)) {
+    result = await mutateTsSymbol(content, lang, opts.symbol, opts.newBody, opts.target);
+  } else {
+    result = await mutateTreeSitterSymbol(content, lang, opts.symbol, opts.newBody, opts.target);
+  }
+  if (!result) {
+    throw new Error(
+      `Symbol '${opts.symbol}' could not be located in AST of '${path.relative(projectRoot, resolved)}'`
+    );
+  }
+  result.file = resolved;
+  if (opts.checkInvariants !== false) {
+    const inv = await polyglotInvariantEngine.evaluate({
+      originalCode: content,
+      modifiedCode: result.updatedContent,
+      lang,
+      filePath: resolved
+    });
+    if (!inv.valid && !opts.allowBreakingChanges) {
+      const summary = inv.violations.map((v) => `[${v.ruleId}] ${v.message}`).join("\n");
+      throw new Error(
+        `AST Invariant Violation: Mutating '${opts.symbol}' introduces breaking changes:
+${summary}
+Pass allowBreakingChanges: true if this breaking change is intended.`
+      );
+    }
+    result.violations = inv.violations;
+  }
+  await atomicWrite(resolved, result.updatedContent);
+  try {
+    enqueueReindex({ projectRoot, files: [resolved] });
+  } catch {
+  }
+  return result;
+}
+
+// src/codebase-index/codebase-ast-replace-tool.ts
+var codebaseAstReplaceTool = {
+  name: "codebase-ast-replace",
+  category: "Edit",
+  icon: "edit",
+  permission: "confirm",
+  subjectKey: "file",
+  mutating: true,
+  capabilities: ["fs.write", "fs.read"],
+  description: "Surgically replace the implementation body or full definition of a function, method, class, or type alias using AST parsing. Guarantees zero string-matching errors, regex escape bugs, or whitespace indentation mismatches. Automatically verifies AST backward-compatibility invariants (no mandatory param addition, no export deletion, no interface breaking).",
+  usageHint: 'SURGICAL AST-BASED CODE EDITING:\n\n- Use when updating an existing function, method, or class without worrying about context lines.\n- Pass `symbol: "calculateTotal"` and `newBody: "return items.reduce(...);"`.\n- Default `target: "body"` replaces only the inner `{ ... }` block while preserving the signature and JSDoc.\n- Use `target: "full"` if you also need to modify the function parameters or return type.\n- Setting `allowBreakingChanges: true` bypasses the invariant engine if breaking changes are deliberate.',
+  inputSchema: {
+    type: "object",
+    properties: {
+      file: {
+        type: "string",
+        description: "Target file path (relative to project root or absolute)."
+      },
+      symbol: {
+        type: "string",
+        description: "Name of the function, method, class, interface, or variable to replace."
+      },
+      newBody: {
+        type: "string",
+        description: 'The new body implementation (or complete declaration if target="full").'
+      },
+      target: {
+        type: "string",
+        enum: ["body", "full"],
+        description: "Whether to replace only the inner body ('body', default) or the entire symbol declaration ('full')."
+      },
+      checkInvariants: {
+        type: "boolean",
+        description: "Whether to check AST backward-compatibility invariants before write. Defaults to true."
+      },
+      allowBreakingChanges: {
+        type: "boolean",
+        description: "Explicitly allow breaking changes (e.g. adding mandatory parameter, removing export) if intentional."
+      }
+    },
+    required: ["file", "symbol", "newBody"],
+    additionalProperties: false
+  },
+  async execute(input, ctx) {
+    try {
+      const projectRoot = ctx.projectRoot;
+      const result = await replaceSymbolInFile(input, projectRoot);
+      return {
+        status: "ok",
+        file: path2.relative(projectRoot, result.file).replace(/\\/g, "/"),
+        symbol: result.symbol,
+        originalRange: result.originalRange,
+        newRange: result.newRange
+      };
+    } catch (err) {
+      return {
+        status: "error",
+        file: input.file,
+        symbol: input.symbol,
+        error: toErrorMessage(err)
+      };
+    }
+  }
+};
+
+// src/codebase-index/codebase-invariant-check-tool.ts
+import * as fs2 from "node:fs/promises";
+import * as path3 from "node:path";
+import { toErrorMessage as toErrorMessage2 } from "@wrongstack/core/utils";
+var codebaseInvariantCheckTool = {
+  name: "codebase-invariant-check",
+  category: "Inspect",
+  icon: "index",
+  permission: "auto",
+  subjectKey: "file",
+  mutating: false,
+  capabilities: ["fs.read"],
+  description: "Mathematically verify AST backward-compatibility invariants between original code and candidate mutations across TypeScript, Python, Go, Rust, Java, etc. Detects missing exports (INV-001), mandatory parameter additions (INV-002), interface breaking expansions (INV-003), and return type changes (INV-004) with zero hallucinations.",
+  usageHint: "PRE-FLIGHT AST INVARIANT AUDIT:\n\n- Provide `file` and `modifiedCode` (or both `originalCode` and `modifiedCode`).\n- Returns `valid: true` if changes are strictly backward compatible.\n- Returns structured `violations[]` with exact rule IDs, offending symbol names, and fix instructions.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      file: {
+        type: "string",
+        description: "Path to existing source file to compare against candidate modifications."
+      },
+      originalCode: {
+        type: "string",
+        description: "Original source code string (if not reading from an existing file)."
+      },
+      modifiedCode: {
+        type: "string",
+        description: "The candidate modified code string to validate."
+      },
+      lang: {
+        type: "string",
+        description: "Language hint (ts, py, go, rs, etc.). Inferred from file path if omitted."
+      }
+    },
+    required: ["modifiedCode"],
+    additionalProperties: false
+  },
+  async execute(input, ctx) {
+    try {
+      let originalCode = input.originalCode;
+      let lang = input.lang;
+      if (!originalCode && input.file) {
+        const resolved = path3.isAbsolute(input.file) ? input.file : path3.resolve(ctx.projectRoot, input.file);
+        originalCode = await fs2.readFile(resolved, "utf8");
+        if (!lang) {
+          lang = detectLang(resolved) ?? "ts";
+        }
+      }
+      if (originalCode === void 0) {
+        return {
+          valid: false,
+          violations: [],
+          summary: "Neither originalCode nor file was provided for invariant comparison.",
+          error: "Missing originalCode or file path."
+        };
+      }
+      const res = await polyglotInvariantEngine.evaluate({
+        originalCode,
+        modifiedCode: input.modifiedCode,
+        lang,
+        filePath: input.file
+      });
+      const summary = res.valid ? "AST Invariants PASSED. Mutation is 100% backward compatible." : `AST Invariants FAILED with ${res.violations.length} violation(s):
+` + res.violations.map((v) => ` - [${v.ruleId}] ${v.symbolName}: ${v.message}`).join("\n");
+      return {
+        valid: res.valid,
+        violations: res.violations,
+        summary
+      };
+    } catch (err) {
+      return {
+        valid: false,
+        violations: [],
+        summary: `Error during invariant evaluation: ${toErrorMessage2(err)}`,
+        error: toErrorMessage2(err)
+      };
+    }
+  }
+};
+
+// src/codebase-index/codebase-impact-analysis-tool.ts
+import * as path4 from "node:path";
+import { toErrorMessage as toErrorMessage3 } from "@wrongstack/core/utils";
+var TEST_FILE_REGEX = /(?:test|spec|mock|fixture|bench)[s]?[/\\._]/i;
+var codebaseImpactAnalysisTool = {
+  name: "codebase-impact-analysis",
+  category: "Project",
+  icon: "index",
+  permission: "auto",
+  mutating: false,
+  capabilities: ["fs.read"],
+  description: "Perform a blast radius and impact analysis before modifying or refactoring a function, class, or type. Identifies all production call sites, affected test suites, and breaking change risks across the entire codebase.",
+  usageHint: 'CALL BEFORE MODIFYING FUNCTION SIGNATURES, PARAMETERS, OR RETURN TYPES:\n\n- Pass `symbol: "calculateDiscount"` to get the complete blast radius.\n- Groups affected code into production callers vs. test files.\n- Provides a step-by-step action plan of every file and line that must be updated alongside the change.\n- Pair with `codebase-targeted-test` to verify affected test suites afterwards.',
+  inputSchema: {
+    type: "object",
+    properties: {
+      symbol: {
+        type: "string",
+        description: "The function/method/class/type name to analyze."
+      },
+      file: {
+        type: "string",
+        description: "Optional file path to disambiguate when multiple symbols share the same name."
+      },
+      transitive: {
+        type: "boolean",
+        description: "Whether to traverse transitive callers (callers of callers). Defaults to true."
+      }
+    },
+    required: ["symbol"],
+    additionalProperties: false
+  },
+  async execute(input, ctx) {
+    try {
+      const projectRoot = ctx.projectRoot;
+      const indexDir = codebaseIndexDirOverride(ctx);
+      const limit = 200;
+      const transitive = input.transitive ?? true;
+      let rawSites = [];
+      let symbolFound = true;
+      let indexUnavailable = false;
+      let indexError;
+      try {
+        const serviced = await incomingCallsService({
+          projectRoot,
+          indexDir,
+          symbol: input.symbol,
+          file: input.file,
+          limit,
+          transitive
+        });
+        rawSites = serviced.calls;
+        symbolFound = serviced.symbolFound;
+      } catch (err) {
+        symbolFound = false;
+        indexUnavailable = true;
+        indexError = toErrorMessage3(err);
+      }
+      if (indexUnavailable) {
+        const detail = indexError ? ` (${indexError})` : "";
+        const reason = `Index query failed for '${input.symbol}'. Run codebase-index, then retry.${detail}`;
+        return {
+          status: "error",
+          symbol: input.symbol,
+          riskLevel: "low",
+          summary: reason,
+          totalCallSites: 0,
+          affectedProductionFiles: [],
+          affectedTestFiles: [],
+          callSites: [],
+          recommendedActionPlan: [reason],
+          symbolFound: false,
+          error: reason
+        };
+      }
+      if (!symbolFound) {
+        const reason = `Symbol '${input.symbol}' was not found in the index` + (input.file ? ` for file filter '${input.file}'` : "") + ". Use codebase-search to verify the name.";
+        return {
+          status: "ok",
+          symbol: input.symbol,
+          riskLevel: "low",
+          summary: reason,
+          totalCallSites: 0,
+          affectedProductionFiles: [],
+          affectedTestFiles: [],
+          callSites: [],
+          recommendedActionPlan: [reason],
+          symbolFound: false
+        };
+      }
+      const prodFilesSet = /* @__PURE__ */ new Set();
+      const testFilesSet = /* @__PURE__ */ new Set();
+      const callSites = [];
+      for (const site of rawSites) {
+        const relPath = path4.relative(projectRoot, site.symbol.file).replace(/\\/g, "/");
+        const isTest = TEST_FILE_REGEX.test(relPath);
+        if (isTest) {
+          testFilesSet.add(relPath);
+        } else {
+          prodFilesSet.add(relPath);
+        }
+        callSites.push({
+          file: relPath,
+          line: site.line,
+          callerName: site.symbol.name,
+          callerKind: site.symbol.kind,
+          callType: site.callType,
+          isTest
+        });
+      }
+      const prodFiles = [...prodFilesSet];
+      const testFiles = [...testFilesSet];
+      const totalCallSites = callSites.length;
+      let riskLevel = "low";
+      if (prodFiles.length > 5 || totalCallSites > 10) {
+        riskLevel = "high";
+      } else if (prodFiles.length > 1 || totalCallSites > 3) {
+        riskLevel = "medium";
+      }
+      const recommendedActionPlan = [];
+      if (prodFiles.length > 0) {
+        recommendedActionPlan.push(
+          `Update ${totalCallSites} call site(s) across ${prodFiles.length} production file(s): ${prodFiles.slice(0, 3).join(", ")}${prodFiles.length > 3 ? ` +${prodFiles.length - 3} more` : ""}`
+        );
+      }
+      if (testFiles.length > 0) {
+        recommendedActionPlan.push(
+          `Run targeted tests in ${testFiles.length} test suite(s): ${testFiles.join(", ")}`
+        );
+      } else {
+        recommendedActionPlan.push(
+          `No existing test files directly cover '${input.symbol}'. Consider adding a test suite.`
+        );
+      }
+      const summary = `Blast Radius for '${input.symbol}': ${riskLevel.toUpperCase()} RISK (${totalCallSites} call sites in ${prodFiles.length} prod files, ${testFiles.length} test suites).`;
+      return {
+        status: "ok",
+        symbol: input.symbol,
+        riskLevel,
+        summary,
+        totalCallSites,
+        affectedProductionFiles: prodFiles,
+        affectedTestFiles: testFiles,
+        callSites,
+        recommendedActionPlan,
+        symbolFound: true
+      };
+    } catch (err) {
+      return {
+        status: "error",
+        symbol: input.symbol,
+        riskLevel: "low",
+        summary: "",
+        totalCallSites: 0,
+        affectedProductionFiles: [],
+        affectedTestFiles: [],
+        callSites: [],
+        recommendedActionPlan: [],
+        symbolFound: false,
+        error: toErrorMessage3(err)
+      };
+    }
+  }
+};
+
+// src/codebase-index/codebase-incoming-calls-tool.ts
+import { toErrorMessage as toErrorMessage4 } from "@wrongstack/core/utils";
+var codebaseIncomingCallsTool = {
+  name: "codebase-incoming-calls",
+  category: "Project",
+  icon: "index",
+  description: "Find all callers of a function, method, or symbol \u2014 who invokes or references it. Uses the codebase index ref graph for instant, exact results. Prefer this over grep for change-impact checks when the index is available.",
+  usageHint: 'CALL THIS BEFORE REFACTORING OR CHANGING ANY FUNCTION:\n\n- Prefer this over grep when the index is available; fall back to grep when the index is cold/unavailable or for dynamic dispatch the ref graph cannot see.\n- Call codebase-incoming-calls({ symbol: "funcName" }) before editing the symbol.\n- Returns exact files, line numbers, caller signatures, and call types in milliseconds.\n- Use `file` to disambiguate when multiple symbols share a name.\n- Combine with codebase-outgoing-calls to see what the symbol itself calls.\nIf the index is not built, run codebase-index first.',
+  permission: "auto",
+  mutating: false,
+  capabilities: ["fs.read"],
+  timeoutMs: 35e3,
+  inputSchema: {
+    type: "object",
+    properties: {
+      symbol: {
+        type: "string",
+        description: "The function/method/type name to find callers for"
+      },
+      file: {
+        type: "string",
+        description: "Scope to a specific file when multiple symbols share the same name"
+      },
+      limit: {
+        type: "integer",
+        description: "Maximum call sites to return (default 50, max 200)",
+        minimum: 1,
+        maximum: 200
+      },
+      transitive: {
+        type: "boolean",
+        description: "When true, traverse the full transitive call chain (callers of callers, to unlimited depth). Default false: return only direct callers. Cycle-safe via SQL recursive CTE.",
+        default: false
+      }
+    },
+    required: ["symbol"]
+  },
+  async execute(input, ctx) {
+    const state = getIndexState();
+    if (state.lastError) {
+      const circuit = state.circuit;
+      const retryHint = circuit.state === "open" ? `Indexing is paused (circuit open, retry in ${Math.ceil(circuit.cooldownRemainingMs / 1e3)}s).` : "Try /codebase-reindex.";
+      return {
+        symbol: input.symbol,
+        calls: [],
+        total: 0,
+        indexStatus: `Index build failed: ${state.lastError}. ${retryHint}`
+      };
+    }
+    const limit = Math.max(1, Math.min(Math.trunc(input.limit ?? 50), 200));
+    const transitive = input.transitive === true;
+    let serviced;
+    try {
+      serviced = await incomingCallsService({
+        projectRoot: ctx.projectRoot,
+        indexDir: codebaseIndexDirOverride(ctx),
+        symbol: input.symbol,
+        file: input.file,
+        limit,
+        transitive
+      });
+    } catch (err) {
+      if (err.name === "IndexRefreshInProgressError") {
+        return {
+          symbol: input.symbol,
+          calls: [],
+          total: 0,
+          indexStatus: `Index refresh in progress (${state.currentFile}/${state.totalFiles} files); this symbol has no cached answer yet \u2014 retry after the completed generation is published.`
+        };
+      }
+      return {
+        symbol: input.symbol,
+        calls: [],
+        total: 0,
+        indexStatus: `Index query failed: ${toErrorMessage4(err)}. Fall back to grep for this lookup.`
+      };
+    }
+    const { calls, symbolFound, ambiguous, totalMatches, stale } = serviced;
+    if (!symbolFound) {
+      let hasPersistedIndex = state.ready;
+      if (!hasPersistedIndex) {
+        try {
+          const stats = await codebaseIndexStats({
+            projectRoot: ctx.projectRoot,
+            indexDir: codebaseIndexDirOverride(ctx)
+          });
+          hasPersistedIndex = stats.totalFiles > 0 || stats.lastIndexed !== null;
+        } catch {
+        }
+      }
+      if (!hasPersistedIndex) {
+        return {
+          symbol: input.symbol,
+          calls: [],
+          total: 0,
+          indexStatus: "No persisted index data found. Run codebase-index to build it."
+        };
+      }
+      return {
+        symbol: input.symbol,
+        calls: [],
+        total: 0,
+        note: `Symbol "${input.symbol}" not found in the index. Use codebase-search to verify the name.`
+      };
+    }
+    const notes = [];
+    if (totalMatches > limit) {
+      notes.push(
+        `Results capped at ${limit} of ${totalMatches} call sites. Increase \`limit\` or use \`file\` to narrow.`
+      );
+    }
+    if (ambiguous) {
+      notes.push(
+        `Symbol "${input.symbol}" exists in multiple files. Results include callers of all same-named symbols. Use codebase-search to find the exact file and pass it as \`file\`.`
+      );
+    }
+    if (stale) {
+      notes.push(
+        `Index refresh in progress (${state.currentFile}/${state.totalFiles} files); callers served from the previous generation \u2014 call sites in files being indexed may lag.`
+      );
+    }
+    return {
+      symbol: input.symbol,
+      calls,
+      total: calls.length,
+      ...stale ? { stale: true } : {},
+      ...notes.length > 0 ? { note: notes.join(" ") } : {}
+    };
+  }
+};
+
+// src/codebase-index/codebase-index-tool.ts
+import { ToolValidationError } from "@wrongstack/core/types";
+
+// src/codebase-index/codebase-search-tool.ts
+import { toErrorMessage as toErrorMessage5 } from "@wrongstack/core/utils";
+var INDEXABLE_LANG_IDS = [
+  ...new Set(Object.values(EXT_TO_LANG))
+].sort();
+var codebaseSearchTool = {
+  name: "codebase-search",
+  category: "Project",
+  icon: "index",
+  description: "Search code symbols using a fast SQLite+BM25 index, with optional LSP fallback. Prefer this before broad `tree`, `glob`, or `grep` exploration when finding code by name or concept. Use `grep` instead for exact text, regexes, unsupported content, or concrete usage sites. Set `preferLsp: true` for live precision when the LSP plugin is active (supersedes codebase-lsp-search).",
+  usageHint: "FIRST CHOICE FOR INDEXABLE CODE UNDERSTANDING:\n\n- Call before broad `tree`, `glob`, or `grep` exploration when locating symbols, concepts, definitions, or candidate modules.\n- `kind` filter is very useful (e.g. only functions or only interfaces).\n- Combine with `file` filter to scope to a specific directory or module.\n- If `indexStatus` reports no persisted data, run `codebase-index` and retry.",
+  permission: "auto",
+  mutating: false,
+  capabilities: ["fs.read"],
+  // The index host has its own 30s read watchdog. Leave enough headroom for
+  // worker teardown and structured timeout reporting.
+  timeoutMs: 35e3,
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: "Search query \u2014 searches symbol names, signatures, and doc comments"
+      },
+      kind: {
+        type: "string",
+        enum: [
+          "class",
+          "interface",
+          "enum",
+          "type",
+          "function",
+          "method",
+          "var",
+          "const",
+          "let",
+          "property",
+          "parameter",
+          "namespace",
+          "object",
+          "literal",
+          "schema",
+          "struct",
+          "trait",
+          "impl",
+          "static",
+          "mod"
+        ],
+        description: "Filter by indexed symbol kind"
+      },
+      lang: {
+        type: "string",
+        enum: [...INDEXABLE_LANG_IDS],
+        description: "Filter by indexed language"
+      },
+      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
+      },
+      preferLsp: {
+        type: "boolean",
+        description: "Prefer live LSP results over the index. Ignored unless the LSP plugin is active; when it is active and this is true, results come from live workspaceSymbol queries."
+      }
+    },
+    required: ["query"]
+  },
+  async execute(input, ctx, execOpts) {
+    const state = getIndexState();
+    if (state.lastError) {
+      const circuit = state.circuit;
+      const retryHint = circuit.state === "open" ? `Indexing is paused (circuit open, retry in ${Math.ceil(circuit.cooldownRemainingMs / 1e3)}s); the user can run /codebase-reindex to retry now.` : "Try /codebase-reindex.";
+      return {
+        results: [],
+        total: 0,
+        query: input.query,
+        indexStatus: `Index build failed: ${state.lastError}. ${retryHint}`
+      };
+    }
+    const limit = Math.max(1, Math.min(Math.trunc(input.limit ?? 20), 100));
+    let searched;
+    try {
+      searched = await searchCodebaseIndex(
+        {
+          projectRoot: ctx.projectRoot,
+          indexDir: codebaseIndexDirOverride(ctx),
+          query: input.query,
+          kind: input.kind?.toLowerCase(),
+          lang: input.lang?.toLowerCase(),
+          file: input.file,
+          lspKind: input.lspKind,
+          limit
+        },
+        { signal: execOpts?.signal }
+      );
+    } catch (err) {
+      if (execOpts?.signal?.aborted) throw err;
+      if (err.name === "IndexRefreshInProgressError") {
+        return {
+          results: [],
+          total: 0,
+          query: input.query,
+          indexStatus: `Index refresh in progress (${state.currentFile}/${state.totalFiles} files); this query has no cached answer yet \u2014 retry after the completed generation is published.`
+        };
+      }
+      return {
+        results: [],
+        total: 0,
+        query: input.query,
+        indexStatus: `Index query failed: ${toErrorMessage5(err)}. Fall back to grep/glob for this lookup.`
+      };
+    }
+    const { results, total, stale, indexSummary } = searched;
+    let hasPersistedIndex = state.ready || total > 0;
+    if (!hasPersistedIndex && indexSummary) {
+      hasPersistedIndex = indexSummary.totalFiles > 0 || indexSummary.lastIndexed !== null;
+    }
+    if (!hasPersistedIndex && !indexSummary) {
+      try {
+        const stats = await codebaseIndexStats(
+          { projectRoot: ctx.projectRoot, indexDir: codebaseIndexDirOverride(ctx) },
+          { signal: execOpts?.signal }
+        );
+        hasPersistedIndex = stats.totalFiles > 0 || stats.lastIndexed !== null;
+      } catch {
+      }
+    }
+    return {
+      results,
+      total,
+      query: input.query,
+      ...stale ? {
+        stale: true,
+        indexStatus: `Index refresh in progress (${state.currentFile}/${state.totalFiles} files); results served from the previous generation \u2014 symbols from files being indexed may lag.`
+      } : {},
+      ...hasPersistedIndex ? {} : { indexStatus: "No persisted index data found. Run codebase-index to build it." }
+    };
+  }
+};
+
+// src/codebase-index/codebase-index-tool.ts
+var MAX_REPORTED_ERRORS = 20;
+var codebaseIndexTool = {
+  name: "codebase-index",
+  category: "Project",
+  icon: "index",
+  description: "Build or incrementally update the project-wide symbol index. This powers fast codebase search and understanding. By default it only processes files that have changed since the last indexing run.",
+  usageHint: "CREATE OR REFRESH THE SEARCH INDEX:\n\n- When `codebase-stats` or `codebase-search` reports no persisted index, call this without arguments, then retry the search.\n- Normal and first-time usage: call without arguments for an incremental build.\n- Use `force: true` only for a corrupt/stale index or an explicitly requested clean rebuild.\n- Use `langs` to restrict to specific languages if you only care about certain parts of the project.\nThis tool is relatively expensive \u2014 do not call it on every turn. Use it when the index is stale or before heavy codebase-search sessions.",
+  permission: "confirm",
+  mutating: true,
+  capabilities: ["fs.write.outside-project"],
+  // Must comfortably exceed the index watchdog
+  // (DEFAULT_FULL_INDEX_TIMEOUT_MS = 240s in background-indexer.ts) so the
+  // structured IndexTimeoutError reaches the agent instead of a generic
+  // TOOL_TIMEOUT.  The watchdog is armed inside withMutex, so under
+  // contention from a concurrent incremental batch (60s ceiling) the tool
+  // timeout must also cover the mutex queue wait + 240s watchdog + margin.
+  timeoutMs: 305e3,
+  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", enum: [...INDEXABLE_LANG_IDS] },
+        description: `Limit reindex to specific languages: ${INDEXABLE_LANG_IDS.join(", ")}`
+      }
+    }
+  },
+  async execute(input, ctx, execOpts) {
+    if (input.langs) {
+      const unknown = input.langs.filter(
+        (lang) => !INDEXABLE_LANG_IDS.includes(lang)
+      );
+      if (unknown.length > 0) {
+        throw new ToolValidationError({
+          message: `codebase-index: unknown lang(s) ${unknown.map((l) => `"${l}"`).join(", ")}. Valid ids: ${INDEXABLE_LANG_IDS.join(", ")}.`,
+          field: "langs"
+        });
+      }
+    }
+    if (isIndexing()) {
+      return {
+        filesIndexed: 0,
+        symbolsIndexed: 0,
+        langStats: {},
+        durationMs: 0,
+        errors: [],
+        note: "A full index is already in progress. Retry codebase-index after it completes (check codebase-stats)."
+      };
+    }
+    const circuit = indexCircuitBreaker.snapshot();
+    if (circuit.state === "open" && circuit.cooldownRemainingMs > 0) {
+      return {
+        filesIndexed: 0,
+        symbolsIndexed: 0,
+        langStats: {},
+        durationMs: 0,
+        errors: [],
+        note: `Codebase indexing is paused after repeated failures (last: ${circuit.lastFailure ?? "unknown"}). Auto-retry possible in ${Math.ceil(circuit.cooldownRemainingMs / 1e3)}s; the user can run /codebase-reindex to retry immediately.`
+      };
+    }
+    const result = await runStartupIndex({
+      projectRoot: ctx.projectRoot,
+      force: input.force ?? false,
+      langs: input.langs,
+      indexDir: codebaseIndexDirOverride(ctx),
+      signal: execOpts?.signal
+    });
+    if (result.errors.length > MAX_REPORTED_ERRORS) {
+      const hidden = result.errors.length - MAX_REPORTED_ERRORS;
+      return {
+        ...result,
+        errors: [...result.errors.slice(0, MAX_REPORTED_ERRORS), `+${hidden} more`]
+      };
+    }
+    return result;
+  }
+};
+
+// src/codebase-index/codebase-outgoing-calls-tool.ts
+import { toErrorMessage as toErrorMessage6 } from "@wrongstack/core/utils";
+var codebaseOutgoingCallsTool = {
+  name: "codebase-outgoing-calls",
+  category: "Project",
+  icon: "index",
+  description: "Find all functions/methods/symbols that a given symbol calls or depends on \u2014 its callees. Uses the codebase index ref graph for instant, exact results. Use this to understand a function's dependencies before modifying it.",
+  usageHint: 'USE THIS TO UNDERSTAND A FUNCTION\'S DEPENDENCIES:\n\n- Prefer this over grep when the index is available; fall back to grep when the index is cold/unavailable or for dynamic dispatch the ref graph cannot see.\n- Call codebase-outgoing-calls({ symbol: "funcName" }) to see everything it calls.\n- Returns exact files, line numbers, callee signatures, and call types in milliseconds.\n- Use `file` to disambiguate when multiple symbols share a name.\n- Pair with codebase-incoming-calls for a complete impact picture: incoming = who calls you, outgoing = what you call.\nIf the index is not built, run codebase-index first.',
+  permission: "auto",
+  mutating: false,
+  capabilities: ["fs.read"],
+  timeoutMs: 35e3,
+  inputSchema: {
+    type: "object",
+    properties: {
+      symbol: {
+        type: "string",
+        description: "The function/method/type name to find callees for"
+      },
+      file: {
+        type: "string",
+        description: "Scope to a specific file when multiple symbols share the same name"
+      },
+      limit: {
+        type: "integer",
+        description: "Maximum call sites to return (default 50, max 200)",
+        minimum: 1,
+        maximum: 200
+      },
+      transitive: {
+        type: "boolean",
+        description: "When true, traverse the full transitive dependency chain (callees of callees, to unlimited depth). Default false: return only direct callees. Cycle-safe via SQL recursive CTE.",
+        default: false
+      }
+    },
+    required: ["symbol"]
+  },
+  async execute(input, ctx) {
+    const state = getIndexState();
+    if (state.lastError) {
+      const circuit = state.circuit;
+      const retryHint = circuit.state === "open" ? `Indexing is paused (circuit open, retry in ${Math.ceil(circuit.cooldownRemainingMs / 1e3)}s).` : "Try /codebase-reindex.";
+      return {
+        symbol: input.symbol,
+        calls: [],
+        total: 0,
+        indexStatus: `Index build failed: ${state.lastError}. ${retryHint}`
+      };
+    }
+    const limit = Math.max(1, Math.min(Math.trunc(input.limit ?? 50), 200));
+    const transitive = input.transitive === true;
+    let serviced;
+    try {
+      serviced = await outgoingCallsService({
+        projectRoot: ctx.projectRoot,
+        indexDir: codebaseIndexDirOverride(ctx),
+        symbol: input.symbol,
+        file: input.file,
+        limit,
+        transitive
+      });
+    } catch (err) {
+      if (err.name === "IndexRefreshInProgressError") {
+        return {
+          symbol: input.symbol,
+          calls: [],
+          total: 0,
+          indexStatus: `Index refresh in progress (${state.currentFile}/${state.totalFiles} files); this symbol has no cached answer yet \u2014 retry after the completed generation is published.`
+        };
+      }
+      return {
+        symbol: input.symbol,
+        calls: [],
+        total: 0,
+        indexStatus: `Index query failed: ${toErrorMessage6(err)}. Fall back to grep for this lookup.`
+      };
+    }
+    const { calls, symbolFound, unresolvedCount, totalMatches, stale } = serviced;
+    if (!symbolFound) {
+      let hasPersistedIndex = state.ready;
+      if (!hasPersistedIndex) {
+        try {
+          const stats = await codebaseIndexStats({
+            projectRoot: ctx.projectRoot,
+            indexDir: codebaseIndexDirOverride(ctx)
+          });
+          hasPersistedIndex = stats.totalFiles > 0 || stats.lastIndexed !== null;
+        } catch {
+        }
+      }
+      if (!hasPersistedIndex) {
+        return {
+          symbol: input.symbol,
+          calls: [],
+          total: 0,
+          indexStatus: "No persisted index data found. Run codebase-index to build it."
+        };
+      }
+      return {
+        symbol: input.symbol,
+        calls: [],
+        total: 0,
+        note: `Symbol "${input.symbol}" not found in the index. Use codebase-search to verify the name.`
+      };
+    }
+    const notes = [];
+    if (totalMatches > limit) {
+      notes.push(
+        `Results capped at ${limit} of ${totalMatches} call sites. Increase \`limit\` or use \`file\` to narrow.`
+      );
+    }
+    if (unresolvedCount > 0) {
+      notes.push(
+        `${unresolvedCount} unresolved reference(s) not shown \u2014 their targets could not be resolved during indexing.`
+      );
+    }
+    if (stale) {
+      notes.push(
+        `Index refresh in progress (${state.currentFile}/${state.totalFiles} files); callees served from the previous generation \u2014 call sites in files being indexed may lag.`
+      );
+    }
+    return {
+      symbol: input.symbol,
+      calls,
+      total: calls.length,
+      ...stale ? { stale: true } : {},
+      ...notes.length > 0 ? { note: notes.join(" ") } : {}
+    };
+  }
+};
+
+// src/codebase-index/codebase-repo-map-tool.ts
+import { toErrorMessage as toErrorMessage7 } from "@wrongstack/core/utils";
+
+// src/codebase-index/repo-map.ts
+import * as fs4 from "node:fs/promises";
+import * as path6 from "node:path";
+
+// src/codebase-index/skeleton-extractor.ts
+import * as fs3 from "node:fs/promises";
+import * as path5 from "node:path";
+var tsModule3 = null;
+async function loadTs3() {
+  if (!tsModule3) {
+    const mod = await import("@typescript/typescript6");
+    tsModule3 = mod.default ?? mod;
+  }
+  return tsModule3;
+}
+function applyReplacements(content, replacements) {
+  if (replacements.length === 0) return content;
+  const sorted = [...replacements].sort((a, b) => a.start - b.start);
+  let result = "";
+  let lastIndex = 0;
+  for (const r of sorted) {
+    if (r.start < lastIndex) {
+      continue;
+    }
+    result += content.slice(lastIndex, r.start);
+    result += r.text;
+    lastIndex = r.end;
+  }
+  result += content.slice(lastIndex);
+  return result;
+}
+async function extractTsSkeleton(content, lang, opts) {
+  const ts = await loadTs3();
+  const scriptKind = lang === "tsx" ? ts.ScriptKind.TSX : lang === "jsx" ? ts.ScriptKind.JSX : lang === "js" ? ts.ScriptKind.JS : ts.ScriptKind.TS;
+  const sourceFile = ts.createSourceFile(
+    lang === "tsx" ? "temp.tsx" : "temp.ts",
+    content,
+    ts.ScriptTarget.Latest,
+    true,
+    scriptKind
+  );
+  const replacements = [];
+  const symbolRanges = [];
+  let symbolCount = 0;
+  const includeLineNumbers = opts.includeLineNumbers ?? true;
+  function isExported(node) {
+    if (!ts.canHaveModifiers(node)) return false;
+    const modifiers = ts.getModifiers(node);
+    return modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+  }
+  function visit(node, depth) {
+    if (opts.maxDepth !== void 0 && depth > opts.maxDepth) {
+      return;
+    }
+    if (ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node) || ts.isConstructorDeclaration(node) || ts.isGetAccessor(node) || ts.isSetAccessor(node)) {
+      symbolCount++;
+      if (opts.exportsOnly && depth === 0 && !isExported(node)) {
+        replacements.push({
+          start: node.getStart(sourceFile),
+          end: node.getEnd(),
+          text: ""
+        });
+        return;
+      }
+      const nodeStart = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
+      const nodeEnd = sourceFile.getLineAndCharacterOfPosition(node.getEnd()).line + 1;
+      let bodyStart;
+      let bodyEnd;
+      if (node.body && ts.isBlock(node.body)) {
+        const start = node.body.getStart(sourceFile);
+        const end = node.body.getEnd();
+        bodyStart = sourceFile.getLineAndCharacterOfPosition(start).line + 1;
+        bodyEnd = sourceFile.getLineAndCharacterOfPosition(end).line + 1;
+        const hasLeadingSpace = start > 0 && /\s/.test(content[start - 1] ?? "");
+        const label = includeLineNumbers ? `/* L${bodyStart}-L${bodyEnd} */` : "/* ... */";
+        replacements.push({
+          start,
+          end,
+          text: hasLeadingSpace ? `{ ${label} }` : ` { ${label} }`
+        });
+      }
+      let name;
+      if ("name" in node && node.name && ts.isIdentifier(node.name)) {
+        name = node.name.text;
+      }
+      symbolRanges.push({
+        name,
+        kind: ts.isFunctionDeclaration(node) ? "function" : "method",
+        startLine: nodeStart,
+        endLine: nodeEnd,
+        bodyStartLine: bodyStart,
+        bodyEndLine: bodyEnd
+      });
+      if (node.body && ts.isBlock(node.body)) {
+        return;
+      }
+    } else if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+      if (node.body) {
+        const start = node.body.getStart(sourceFile);
+        const end = node.body.getEnd();
+        const bodyStart = sourceFile.getLineAndCharacterOfPosition(start).line + 1;
+        const bodyEnd = sourceFile.getLineAndCharacterOfPosition(end).line + 1;
+        const label = includeLineNumbers ? `/* L${bodyStart}-L${bodyEnd} */` : "/* ... */";
+        if (ts.isBlock(node.body)) {
+          const hasLeadingSpace = start > 0 && /\s/.test(content[start - 1] ?? "");
+          replacements.push({
+            start,
+            end,
+            text: hasLeadingSpace ? `{ ${label} }` : ` { ${label} }`
+          });
+          return;
+        } else {
+          replacements.push({
+            start,
+            end,
+            text: label
+          });
+          return;
+        }
+      }
+    } else if (ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node)) {
+      symbolCount++;
+      if (opts.exportsOnly && depth === 0 && !isExported(node)) {
+        replacements.push({
+          start: node.getStart(sourceFile),
+          end: node.getEnd(),
+          text: ""
+        });
+        return;
+      }
+      let name;
+      if ("name" in node && node.name && ts.isIdentifier(node.name)) {
+        name = node.name.text;
+      }
+      symbolRanges.push({
+        name,
+        kind: ts.isClassDeclaration(node) ? "class" : ts.isInterfaceDeclaration(node) ? "interface" : ts.isTypeAliasDeclaration(node) ? "type" : "enum",
+        startLine: sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1,
+        endLine: sourceFile.getLineAndCharacterOfPosition(node.getEnd()).line + 1
+      });
+    }
+    ts.forEachChild(node, (child) => visit(child, depth + 1));
+  }
+  ts.forEachChild(sourceFile, (node) => visit(node, 0));
+  let skeleton = applyReplacements(content, replacements);
+  if (opts.collapseImports) {
+    skeleton = collapseTsImports(skeleton);
+  }
+  return { skeleton, symbolCount, symbols: symbolRanges };
+}
+function collapseTsImports(code) {
+  const lines = code.split("\n");
+  const resultLines = [];
+  let inImportGroup = false;
+  let importGroupCount = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const trimmed = line.trim();
+    if (trimmed.startsWith("import ") || trimmed.startsWith("import{")) {
+      inImportGroup = true;
+      importGroupCount++;
+      while (!trimmed.includes(";") && !trimmed.includes("from '") && !trimmed.includes('from "') && i + 1 < lines.length) {
+        i++;
+      }
+    } else {
+      if (inImportGroup) {
+        resultLines.push(`// ... [${importGroupCount} import statements collapsed]`);
+        inImportGroup = false;
+        importGroupCount = 0;
+      }
+      resultLines.push(line);
+    }
+  }
+  if (inImportGroup) {
+    resultLines.push(`// ... [${importGroupCount} import statements collapsed]`);
+  }
+  return resultLines.join("\n");
+}
+async function extractTreeSitterSkeleton(content, lang, opts) {
+  const parsed = await parseTreeSitterAst({ content, lang });
+  if (!parsed) return null;
+  const { tree, parser } = parsed;
+  const replacements = [];
+  const symbolRanges = [];
+  let symbolCount = 0;
+  const includeLineNumbers = opts.includeLineNumbers ?? true;
+  try {
+    let walk2 = function(node) {
+      const type = node.type;
+      if (type === "function_definition" || type === "function_declaration" || type === "method_declaration" || type === "function_item" || type === "method" || type === "singleton_method" || type === "func_literal") {
+        symbolCount++;
+        const nodeStart = node.startPosition.row + 1;
+        const nodeEnd = node.endPosition.row + 1;
+        let bodyStart;
+        let bodyEnd;
+        let bodyNode = node.childForFieldName("body") ?? node.children.find(
+          (c) => [
+            "compound_statement",
+            "statement_block",
+            "block",
+            "function_body",
+            "body_statement",
+            "code_block",
+            "do_block"
+          ].includes(c.type)
+        );
+        if (bodyNode) {
+          bodyStart = bodyNode.startPosition.row + 1;
+          bodyEnd = bodyNode.endPosition.row + 1;
+          const label = includeLineNumbers ? `/* L${bodyStart}-L${bodyEnd} */` : "/* ... */";
+          if (lang === "py") {
+            replacements.push({
+              start: bodyNode.startIndex,
+              end: bodyNode.endIndex,
+              text: includeLineNumbers ? `... # L${bodyStart}-L${bodyEnd}` : "..."
+            });
+          } else if (lang === "ruby") {
+            replacements.push({
+              start: bodyNode.startIndex,
+              end: bodyNode.endIndex,
+              text: includeLineNumbers ? `
+    # L${bodyStart}-L${bodyEnd}` : "\n    # ..."
+            });
+          } else {
+            const hasLeadingSpace = bodyNode.startIndex > 0 && /\s/.test(content[bodyNode.startIndex - 1] ?? "");
+            replacements.push({
+              start: bodyNode.startIndex,
+              end: bodyNode.endIndex,
+              text: hasLeadingSpace ? `{ ${label} }` : ` { ${label} }`
+            });
+          }
+        }
+        let nameNode = node.childForFieldName("name") ?? node.childForFieldName("declarator");
+        let symbolName = nameNode ? nameNode.text : void 0;
+        symbolRanges.push({
+          name: symbolName,
+          kind: type.includes("function") ? "function" : "method",
+          startLine: nodeStart,
+          endLine: nodeEnd,
+          bodyStartLine: bodyStart,
+          bodyEndLine: bodyEnd
+        });
+        if (bodyNode) return;
+      } else if (type === "class_definition" || type === "class_specifier" || type === "class_declaration" || type === "struct_specifier" || type === "interface_declaration" || type === "trait_item") {
+        symbolCount++;
+        let nameNode = node.childForFieldName("name");
+        symbolRanges.push({
+          name: nameNode ? nameNode.text : void 0,
+          kind: type.includes("class") ? "class" : type.includes("struct") ? "struct" : type.includes("interface") ? "interface" : "trait",
+          startLine: node.startPosition.row + 1,
+          endLine: node.endPosition.row + 1
+        });
+      }
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child) walk2(child);
+      }
+    };
+    var walk = walk2;
+    const root = tree.rootNode;
+    walk2(root);
+    const skeleton = applyReplacements(content, replacements);
+    return { skeleton, symbolCount, symbols: symbolRanges };
+  } finally {
+    tree.delete();
+    parser.delete();
+  }
+}
+function extractFallbackSkeleton(content, _lang) {
+  const lines = content.split("\n");
+  const skeletonLines = [];
+  let symbolCount = 0;
+  let inBlock = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("export ") || trimmed.startsWith("function ") || trimmed.startsWith("def ") || trimmed.startsWith("class ") || trimmed.startsWith("interface ") || trimmed.startsWith("type ") || trimmed.startsWith("struct ") || trimmed.startsWith("pub ") || trimmed.startsWith("import ") || trimmed.startsWith("package ") || trimmed.startsWith("#include")) {
+      symbolCount++;
+      if (trimmed.endsWith("{")) {
+        skeletonLines.push(`${line.replace(/\{$/, "")}{ /* ... */ }`);
+        inBlock = true;
+      } else {
+        skeletonLines.push(line);
+      }
+    } else if (trimmed === "}" && inBlock) {
+      inBlock = false;
+    } else if (!inBlock && (trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*"))) {
+      skeletonLines.push(line);
+    }
+  }
+  return {
+    skeleton: skeletonLines.length > 0 ? skeletonLines.join("\n") : content,
+    symbolCount
+  };
+}
+async function extractFileSkeleton(opts) {
+  const detected = detectLang(opts.file);
+  const lang = opts.lang ?? detected ?? "other";
+  const options = opts.options ?? {};
+  const originalLines = opts.content.split("\n").length;
+  let extraction;
+  if (["ts", "tsx", "js", "jsx"].includes(lang)) {
+    extraction = await extractTsSkeleton(opts.content, lang, options);
+  } else {
+    const tsResult = await extractTreeSitterSkeleton(opts.content, lang, options);
+    if (tsResult) {
+      extraction = tsResult;
+    } else {
+      extraction = extractFallbackSkeleton(opts.content, lang);
+    }
+  }
+  const skeletonLines = extraction.skeleton.split("\n").length;
+  const originalChars = opts.content.length;
+  const skeletonChars = extraction.skeleton.length;
+  const savings = originalChars > 0 ? (originalChars - skeletonChars) / originalChars * 100 : 0;
+  return {
+    file: opts.file,
+    lang,
+    skeleton: extraction.skeleton,
+    symbols: extraction.symbols,
+    stats: {
+      originalLines,
+      skeletonLines,
+      tokenSavingsPercent: Math.max(0, Math.round(savings * 10) / 10),
+      symbolCount: extraction.symbolCount
+    }
+  };
+}
+async function extractDirectorySkeleton(opts) {
+  const maxFiles = opts.maxFiles ?? 30;
+  const filePaths = [];
+  async function scan(dir) {
+    if (filePaths.length >= maxFiles) return;
+    let entries;
+    try {
+      entries = await fs3.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (filePaths.length >= maxFiles) break;
+      if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build") {
+        continue;
+      }
+      const fullPath = path5.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await scan(fullPath);
+      } else if (entry.isFile() && isIndexablePath(fullPath)) {
+        filePaths.push(fullPath);
+      }
+    }
+  }
+  await scan(opts.dirPath);
+  const results = [];
+  let totalOrigChars = 0;
+  let totalSkelChars = 0;
+  let totalOrigLines = 0;
+  let totalSkelLines = 0;
+  const combinedParts = [];
+  for (const fp of filePaths) {
+    try {
+      const content = await fs3.readFile(fp, "utf8");
+      const res = await extractFileSkeleton({
+        file: fp,
+        content,
+        options: opts.options ?? {}
+      });
+      results.push(res);
+      totalOrigChars += content.length;
+      totalSkelChars += res.skeleton.length;
+      totalOrigLines += res.stats.originalLines;
+      totalSkelLines += res.stats.skeletonLines;
+      const rel = path5.relative(opts.dirPath, fp).replace(/\\/g, "/");
+      combinedParts.push(
+        `// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550 ${rel} (${res.lang}) \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+${res.skeleton}`
+      );
+    } catch {
+    }
+  }
+  const overallSavings = totalOrigChars > 0 ? (totalOrigChars - totalSkelChars) / totalOrigChars * 100 : 0;
+  return {
+    files: results,
+    combinedSkeleton: combinedParts.join("\n\n"),
+    totalOriginalLines: totalOrigLines,
+    totalSkeletonLines: totalSkelLines,
+    overallSavingsPercent: Math.max(0, Math.round(overallSavings * 10) / 10)
+  };
+}
+
+// src/codebase-index/repo-map.ts
+var ENTRY_POINT_REGEX = /(?:^|[/\\])(?:index|main|app|server|cli|lib|api|types|routes|mod)\.[a-zA-Z0-9]+$/i;
+var TEST_OR_MOCK_REGEX = /(?:test|spec|mock|fixture|bench|example)[s]?[/\\._]/i;
+function getEntryPointBonus(relPath) {
+  if (TEST_OR_MOCK_REGEX.test(relPath)) {
+    return -20;
+  }
+  if (ENTRY_POINT_REGEX.test(relPath)) {
+    return 25;
+  }
+  const depth = relPath.split(/[/\\]/).length;
+  if (depth <= 2) return 10;
+  if (depth <= 3) return 5;
+  return 0;
+}
+async function generateRepoMap(opts) {
+  const projectRoot = opts.projectRoot;
+  const maxTokens = opts.maxTokens ?? 1200;
+  const charBudget = maxTokens * 4;
+  const focusSet = new Set((opts.focusFiles ?? []).map((f) => path6.resolve(projectRoot, f)));
+  const allFiles = [];
+  async function scan(dir) {
+    if (allFiles.length > 500) return;
+    let entries;
+    try {
+      entries = await fs4.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "coverage") {
+        continue;
+      }
+      const fullPath = path6.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await scan(fullPath);
+      } else if (entry.isFile() && isIndexablePath(fullPath)) {
+        allFiles.push(fullPath);
+      }
+    }
+  }
+  await scan(projectRoot);
+  if (allFiles.length === 0) {
+    return {
+      map: "// [Repo map: No indexable source files found]",
+      filesCount: 0,
+      totalFilesScanned: 0,
+      estimatedTokens: 0,
+      rankedFiles: []
+    };
+  }
+  const scoredFiles = [];
+  for (const file of allFiles) {
+    const relPath = path6.relative(projectRoot, file).replace(/\\/g, "/");
+    let score = 10;
+    if (focusSet.has(file)) {
+      score += 100;
+    }
+    score += getEntryPointBonus(relPath);
+    scoredFiles.push({ file, score, relPath });
+  }
+  scoredFiles.sort((a, b) => b.score - a.score);
+  const includedSections = [];
+  const includedFiles = [];
+  let currentChars = 0;
+  for (const candidate of scoredFiles) {
+    if (currentChars >= charBudget) break;
+    try {
+      const content = await fs4.readFile(candidate.file, "utf8");
+      if (content.length === 0) continue;
+      const skeletonResult = await extractFileSkeleton({
+        file: candidate.file,
+        content,
+        options: {
+          exportsOnly: true,
+          collapseImports: true,
+          includeDocs: false,
+          includeLineNumbers: true,
+          ...opts.options ?? {}
+        }
+      });
+      const cleanSkeleton = skeletonResult.skeleton.trim();
+      if (!cleanSkeleton) continue;
+      const section = `${candidate.relPath} (${skeletonResult.lang}):
+${cleanSkeleton.split("\n").map((line) => line.trim() ? `  ${line}` : "").join("\n")}`;
+      const sectionChars = section.length + 2;
+      if (currentChars + sectionChars > charBudget && includedFiles.length > 0) {
+        break;
+      }
+      includedSections.push(section);
+      includedFiles.push(candidate.relPath);
+      currentChars += sectionChars;
+    } catch {
+    }
+  }
+  const map = includedSections.join("\n\n");
+  const estimatedTokens = Math.ceil(map.length / 4);
+  return {
+    map,
+    filesCount: includedFiles.length,
+    totalFilesScanned: allFiles.length,
+    estimatedTokens,
+    rankedFiles: includedFiles
+  };
+}
+
+// src/codebase-index/codebase-repo-map-tool.ts
+var codebaseRepoMapTool = {
+  name: "codebase-repo-map",
+  category: "Project",
+  icon: "index",
+  permission: "auto",
+  mutating: false,
+  capabilities: ["fs.read"],
+  description: "Generate a reference-weighted, token-budgeted Repository Map (Repo Map) of the codebase. Extracts the most architecturally central types, interfaces, classes, and function signatures across the repository into a compact outline (~800-1500 tokens). Use this at the beginning of tasks or when navigating unfamiliar repositories to get a bird-eye view of the architecture.",
+  usageHint: 'USE AT THE START OF COMPLEX OR REPOSITORY-WIDE TASKS:\n\n- Call with default parameters to get a global architecture map within ~1200 tokens.\n- Pass `focusFiles: ["src/auth.ts"]` to ensure candidate files are guaranteed to be mapped alongside related entry-points.\n- Use the returned line numbers (e.g. `/* L32-L45 */`) to navigate or partially read only the functions you need.',
+  inputSchema: {
+    type: "object",
+    properties: {
+      maxTokens: {
+        type: "number",
+        description: "Maximum token budget (approximate) for the map. Defaults to 1200."
+      },
+      focusFiles: {
+        type: "array",
+        items: { type: "string" },
+        description: "File paths to prioritize and ensure inclusion in the map."
+      }
+    },
+    additionalProperties: false
+  },
+  async execute(input, ctx) {
+    try {
+      const projectRoot = ctx.projectRoot;
+      const result = await generateRepoMap({
+        projectRoot,
+        maxTokens: input.maxTokens,
+        focusFiles: input.focusFiles
+      });
+      return {
+        status: "ok",
+        ...result
+      };
+    } catch (err) {
+      return {
+        status: "error",
+        map: "",
+        filesCount: 0,
+        totalFilesScanned: 0,
+        estimatedTokens: 0,
+        rankedFiles: [],
+        error: toErrorMessage7(err)
+      };
+    }
+  }
+};
+
+// src/codebase-index/codebase-skeleton-tool.ts
+import * as fs5 from "node:fs/promises";
+import * as path7 from "node:path";
+import { toErrorMessage as toErrorMessage8 } from "@wrongstack/core/utils";
+var codebaseSkeletonTool = {
+  name: "codebase-skeleton",
+  category: "Project",
+  icon: "index",
+  description: "Extract an AST-based skeleton of a file or directory with implementation bodies stripped. Preserves imports, type definitions, interfaces, docstrings, and function/method signatures while saving ~70-90% tokens. Prefer this before reading full multi-hundred-line files when exploring module structure, contracts, or candidate APIs.",
+  usageHint: "FIRST CHOICE FOR MODULE CONTRACT & OUTLINE UNDERSTANDING:\n\n- Call on large source files to inspect signatures, types, and exports before issuing a full `read`.\n- Call on directories to generate a compact repository or module map.\n- Use `includeDocs: true` (default) to keep API documentation.\n- Use `collapseImports: true` to further compress import-heavy modules.",
+  permission: "auto",
+  mutating: false,
+  capabilities: ["fs.read"],
+  timeoutMs: 3e4,
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Relative or absolute file or directory path to extract skeleton for."
+      },
+      includeDocs: {
+        type: "boolean",
+        description: "Keep JSDoc / docstrings in the output skeleton (defaults to true)."
+      },
+      collapseImports: {
+        type: "boolean",
+        description: "Collapse import blocks into a single summary comment (defaults to false)."
+      },
+      exportsOnly: {
+        type: "boolean",
+        description: "Only include exported/public declarations (defaults to false)."
+      },
+      maxFiles: {
+        type: "number",
+        description: "Max files to include if path is a directory (defaults to 20, max 50)."
+      }
+    },
+    required: ["path"],
+    additionalProperties: false
+  },
+  async execute(input, ctx) {
+    const targetPath = path7.isAbsolute(input.path) ? input.path : path7.resolve(ctx.projectRoot ?? process.cwd(), input.path);
+    let stat3;
+    try {
+      stat3 = await fs5.stat(targetPath);
+    } catch (err) {
+      throw new Error(
+        `codebase-skeleton: file or directory not found at "${input.path}": ${toErrorMessage8(err)}`
+      );
+    }
+    const options = {
+      includeDocs: input.includeDocs ?? true,
+      collapseImports: input.collapseImports ?? false,
+      exportsOnly: input.exportsOnly ?? false
+    };
+    if (stat3.isDirectory()) {
+      const maxFiles = Math.min(Math.max(1, input.maxFiles ?? 20), 50);
+      const dirResult = await extractDirectorySkeleton({
+        dirPath: targetPath,
+        maxFiles,
+        options
+      });
+      let totalSymbols = 0;
+      for (const f of dirResult.files) {
+        totalSymbols += f.stats.symbolCount;
+      }
+      return {
+        path: input.path,
+        isDir: true,
+        skeleton: dirResult.combinedSkeleton,
+        stats: {
+          originalLines: dirResult.totalOriginalLines,
+          skeletonLines: dirResult.totalSkeletonLines,
+          tokenSavingsPercent: dirResult.overallSavingsPercent,
+          symbolCount: totalSymbols,
+          fileCount: dirResult.files.length
+        },
+        files: dirResult.files
+      };
+    }
+    const content = await fs5.readFile(targetPath, "utf8");
+    const fileResult = await extractFileSkeleton({
+      file: targetPath,
+      content,
+      options
+    });
+    return {
+      path: input.path,
+      isDir: false,
+      skeleton: fileResult.skeleton,
+      stats: fileResult.stats
+    };
+  }
+};
+
+// src/codebase-index/codebase-stats-tool.ts
+var codebaseStatsTool = {
+  name: "codebase-stats",
+  category: "Project",
+  icon: "index",
+  description: "Check whether a persisted codebase index exists and report its health and statistics (symbols, files, language/kind breakdown, size, last update).",
+  usageHint: "CHECK ONCE BEFORE BROAD CODE EXPLORATION:\n\n- Call before broad `tree`, `glob`, or `grep` exploration to see whether index-backed search is available.\n- If it reports no persisted data, run `codebase-index`, then use `codebase-search`.\n- No arguments required.\nLightweight and safe to call frequently.",
+  permission: "auto",
+  mutating: false,
+  capabilities: ["fs.read"],
+  // The index host has its own 30s read watchdog. Keep the outer tool budget
+  // longer so the host can return a structured timeout instead of being
+  // pre-empted by the generic tool executor.
+  timeoutMs: 35e3,
+  inputSchema: {
+    type: "object",
+    properties: {},
+    additionalProperties: false
+  },
+  async execute(_input, ctx, execOpts) {
+    const idxState = getIndexState();
+    const indexPath = resolveIndexDir(ctx.projectRoot, codebaseIndexDirOverride(ctx));
+    if (idxState.indexing) {
+      return {
+        totalSymbols: 0,
+        totalFiles: 0,
+        byLang: {},
+        byKind: {},
+        lastIndexed: null,
+        sizeBytes: 0,
+        indexPath,
+        version: SCHEMA_VERSION,
+        statsAvailable: false,
+        indexing: {
+          currentFile: idxState.currentFile,
+          totalFiles: idxState.totalFiles
+        },
+        indexStatus: idxState.ready ? `Index refresh in progress (${idxState.currentFile}/${idxState.totalFiles} files). The persisted snapshot remains available to codebase-search; retry stats after refresh.` : `Startup indexing in progress (${idxState.currentFile}/${idxState.totalFiles} files). Do not start another index; retry stats or codebase-search after completion.`
+      };
+    }
+    let stats;
+    try {
+      stats = await codebaseIndexStats(
+        { projectRoot: ctx.projectRoot, indexDir: codebaseIndexDirOverride(ctx) },
+        { signal: execOpts?.signal }
+      );
+    } catch (err) {
+      if (!(err instanceof IndexTimeoutError) && err?.name !== "IndexTimeoutError") {
+        throw err;
+      }
+      return {
+        totalSymbols: 0,
+        totalFiles: 0,
+        byLang: {},
+        byKind: {},
+        lastIndexed: null,
+        sizeBytes: 0,
+        indexPath,
+        version: SCHEMA_VERSION,
+        statsAvailable: false,
+        indexStatus: "Index statistics timed out. Do not repeatedly retry stats; try codebase-search directly or use the appropriate grep/glob/tree fallback."
+      };
+    }
+    const circuit = idxState.circuit;
+    const hasPersistedIndex = stats.totalFiles > 0 || stats.lastIndexed !== null;
+    let indexStatus;
+    if (circuit.state === "open") {
+      indexStatus = `${hasPersistedIndex ? "Indexing" : "No persisted index data found, and indexing"} is paused after repeated failures (last: ${circuit.lastFailure ?? "unknown"}); auto-retry in ${Math.ceil(circuit.cooldownRemainingMs / 1e3)}s, or run /codebase-reindex. ` + (hasPersistedIndex ? "Stats reflect the last successful build." : "Build the index after recovery.");
+    } else if (!hasPersistedIndex) {
+      indexStatus = "No persisted index data found. Run codebase-index to build it before broad code exploration.";
+    }
+    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,
+      statsAvailable: true,
+      ...indexStatus ? { indexStatus } : {}
+    };
+  }
+};
+
+// src/codebase-index/codebase-targeted-test-tool.ts
+import * as fs6 from "node:fs/promises";
+import * as path8 from "node:path";
+import { toErrorMessage as toErrorMessage9 } from "@wrongstack/core/utils";
+var TEST_FILE_REGEX2 = /(?:test|spec|mock|fixture|bench)[s]?[/\\._]/i;
+async function findConventionTestFiles(projectRoot, sourceRelPath) {
+  const parsed = path8.parse(sourceRelPath);
+  const candidates = [
+    path8.join(parsed.dir, `${parsed.name}.test${parsed.ext}`),
+    path8.join(parsed.dir, `${parsed.name}.spec${parsed.ext}`),
+    path8.join(parsed.dir, `${parsed.name}_test${parsed.ext}`),
+    path8.join(parsed.dir, `test_${parsed.name}${parsed.ext}`),
+    path8.join("tests", `${parsed.name}.test${parsed.ext}`),
+    path8.join("tests", `${parsed.name}.spec${parsed.ext}`),
+    path8.join("test", `${parsed.name}.test${parsed.ext}`),
+    path8.join(parsed.dir, "__tests__", `${parsed.name}.test${parsed.ext}`),
+    path8.join(parsed.dir, "__tests__", `${parsed.name}${parsed.ext}`)
+  ];
+  const found = [];
+  for (const cand of candidates) {
+    const absPath = path8.resolve(projectRoot, cand);
+    try {
+      const st = await fs6.stat(absPath);
+      if (st.isFile()) {
+        found.push(cand.replace(/\\/g, "/"));
+      }
+    } catch {
+    }
+  }
+  return found;
+}
+var codebaseTargetedTestTool = {
+  name: "codebase-targeted-test",
+  category: "Code Quality",
+  icon: "test",
+  permission: "confirm",
+  mutating: false,
+  capabilities: ["shell.restricted", "fs.read"],
+  timeoutMs: 6e4,
+  description: "Smart targeted test runner. Automatically identifies and executes only the test suites that cover a specific symbol or file using Call Graph references and convention mapping. Executes in ~100-500ms rather than waiting minutes for the entire test suite.",
+  usageHint: 'CALL IMMEDIATELY AFTER MUTATING A FUNCTION OR FILE:\n\n- Pass `symbol: "calculateDiscount"` or `file: "src/order-service.ts"`.\n- Discovers covering tests via the call graph and conventions, then executes only those files.\n- Returns instant test feedback and failure logs for self-healing loops.',
+  inputSchema: {
+    type: "object",
+    properties: {
+      symbol: {
+        type: "string",
+        description: "Symbol name whose covering tests should be discovered and run."
+      },
+      file: {
+        type: "string",
+        description: "Source file path whose covering tests should be run."
+      },
+      testFiles: {
+        type: "array",
+        items: { type: "string" },
+        description: "Explicit list of test files to execute."
+      }
+    },
+    additionalProperties: false
+  },
+  async execute(input, ctx) {
+    const projectRoot = ctx.projectRoot;
+    const suitesSet = /* @__PURE__ */ new Set();
+    try {
+      if (input.testFiles) {
+        for (const tf of input.testFiles) suitesSet.add(tf.replace(/\\/g, "/"));
+      }
+      if (input.symbol) {
+        try {
+          const indexDir = codebaseIndexDirOverride(ctx);
+          const serviced = await incomingCallsService({
+            projectRoot,
+            indexDir,
+            symbol: input.symbol,
+            file: input.file,
+            limit: 100,
+            transitive: true
+          });
+          for (const site of serviced.calls) {
+            const relPath = path8.relative(projectRoot, site.symbol.file).replace(/\\/g, "/");
+            if (TEST_FILE_REGEX2.test(relPath)) {
+              suitesSet.add(relPath);
+            }
+          }
+        } catch {
+        }
+      }
+      if (input.file) {
+        const convFiles = await findConventionTestFiles(projectRoot, input.file);
+        for (const cf of convFiles) suitesSet.add(cf);
+      }
+      const discoveredSuites = [...suitesSet];
+      if (discoveredSuites.length === 0) {
+        return {
+          status: "no_tests_found",
+          discoveredSuites: [],
+          testsRun: 0,
+          passed: 0,
+          failed: 0,
+          durationMs: 0,
+          output: "No targeted test suites found for the given symbol or file."
+        };
+      }
+      const start = Date.now();
+      let runnerCmd = "npx";
+      let runnerArgs = ["vitest", "run", ...discoveredSuites];
+      if (discoveredSuites.every((s) => s.endsWith(".py"))) {
+        runnerCmd = "pytest";
+        runnerArgs = discoveredSuites;
+      } else if (discoveredSuites.every((s) => s.endsWith("_test.go"))) {
+        runnerCmd = "go";
+        runnerArgs = ["test", ...discoveredSuites];
+      }
+      const signal = ctx.signal ?? new AbortController().signal;
+      const gen = spawnStream({
+        cmd: runnerCmd,
+        args: runnerArgs,
+        cwd: projectRoot,
+        signal,
+        maxBytes: 1e5
+      });
+      let genResult = await gen.next();
+      while (!genResult.done) {
+        genResult = await gen.next();
+      }
+      const streamRes = genResult.value;
+      const durationMs = Date.now() - start;
+      const combinedOutput = normalizeCommandOutput(
+        `${streamRes.stdout}
+${streamRes.stderr}`.trim(),
+        { maxBytes: 4e3 }
+      );
+      const isPassed = streamRes.exitCode === 0;
+      const passMatch = combinedOutput.match(/(\d+)\s+passed/i);
+      const failMatch = combinedOutput.match(/(\d+)\s+failed/i);
+      const passed = passMatch ? parseInt(passMatch[1] ?? "0", 10) : isPassed ? discoveredSuites.length : 0;
+      const failed = failMatch ? parseInt(failMatch[1] ?? "0", 10) : isPassed ? 0 : 1;
+      const testsRun = passed + failed;
+      return {
+        status: isPassed ? "passed" : "failed",
+        discoveredSuites,
+        testsRun,
+        passed,
+        failed,
+        durationMs,
+        output: combinedOutput
+      };
+    } catch (err) {
+      return {
+        status: "error",
+        discoveredSuites: [...suitesSet],
+        testsRun: 0,
+        passed: 0,
+        failed: 0,
+        durationMs: 0,
+        output: "",
+        error: toErrorMessage9(err)
+      };
+    }
+  }
+};
+
+// src/codebase-index/dead-code-scan.ts
+import * as fs7 from "node:fs";
+import * as path9 from "node:path";
+var deadCodeScanTool = {
+  name: "dead-code-scan",
+  category: "Project",
+  icon: "index",
+  description: "Scan TypeScript/JavaScript source files for exported symbols that appear unused anywhere in the project. Uses the codebase-index reference graph (import/call/type-ref edges) to compute transitive reachability from package.json entry points. Requires a built codebase-index (run `codebase-index` first if you get no results).",
+  usageHint: "SCANS ALL INDEXED FILES UNDER THE PROJECT ROOT:\n\n- `projectRoot` defaults to the current project root; `indexDir` overrides the resolved index location.\n- `entryPoints` is an array of file paths that AUGMENTS the auto-discovered entry points (package.json bin/main/exports/types plus conventional src/index.ts-style files) \u2014 it does not replace them.\n\nThe scan runs against the existing index; results are best-effort (dynamic imports, external consumers, and config-driven registration are invisible).",
+  permission: "auto",
+  mutating: false,
+  capabilities: ["fs.read"],
+  timeoutMs: 6e4,
+  inputSchema: {
+    type: "object",
+    properties: {
+      projectRoot: {
+        type: "string",
+        description: "Project root (defaults to ctx.projectRoot)."
+      },
+      indexDir: {
+        type: "string",
+        description: "Override index directory."
+      },
+      entryPoints: {
+        type: "array",
+        items: { type: "string" },
+        description: "Additional entry-point file paths to seed the scan."
+      }
+    }
+  },
+  async execute(input, ctx, _execOpts) {
+    const startMs = Date.now();
+    const projectRoot = input.projectRoot ?? ctx.projectRoot;
+    const indexDir = input.indexDir ?? codebaseIndexDirOverride(ctx) ?? void 0;
+    const result = runDeadCodeScan(projectRoot, {
+      indexDir,
+      userEntryPoints: input.entryPoints
+    });
+    return {
+      ...result,
+      stats: { ...result.stats, durationMs: Date.now() - startMs }
+    };
+  }
+};
+function tryReadJson(filePath) {
+  try {
+    const raw = fs7.readFileSync(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function resolveAgainst(base, relative7) {
+  if (path9.isAbsolute(relative7)) return relative7;
+  return path9.resolve(base, relative7);
+}
+function discoverEntryPoints(projectRoot, userEntryPoints) {
+  const entries = /* @__PURE__ */ new Set();
+  if (userEntryPoints) {
+    for (const ep of userEntryPoints) {
+      const resolved = resolveAgainst(projectRoot, ep);
+      if (fs7.existsSync(resolved)) entries.add(resolved);
+    }
+  }
+  const rootPkg = tryReadJson(path9.join(projectRoot, "package.json"));
+  if (rootPkg) {
+    addPkgJsonEntryPoints(projectRoot, rootPkg, entries);
+  }
+  let workspaces;
+  if (rootPkg) {
+    workspaces = extractWorkspaceGlobs(rootPkg, projectRoot);
+    if (workspaces.length === 0) {
+      workspaces = extractPnpmWorkspaceDirs(projectRoot);
+    }
+  } else {
+    workspaces = [];
+  }
+  for (const wsDir of workspaces) {
+    const pkgJsonPath = path9.join(wsDir, "package.json");
+    const pkg = tryReadJson(pkgJsonPath);
+    if (pkg) {
+      addPkgJsonEntryPoints(wsDir, pkg, entries);
+      const convention1 = path9.join(wsDir, "src", "index.ts");
+      if (fs7.existsSync(convention1)) entries.add(convention1);
+      const convention2 = path9.join(wsDir, "src", "main.ts");
+      if (fs7.existsSync(convention2)) entries.add(convention2);
+      const convention3 = path9.join(wsDir, "index.ts");
+      if (fs7.existsSync(convention3)) entries.add(convention3);
+    }
+  }
+  if (!rootPkg || !workspaces.length) {
+    for (const name of ["src/index.ts", "src/main.ts", "index.ts"]) {
+      const convention = path9.join(projectRoot, name);
+      if (fs7.existsSync(convention)) entries.add(convention);
+    }
+  }
+  return [...entries];
+}
+var BUILD_OUTPUT_DIRS = ["dist", "out", "build", "release"];
+var BUILD_OUTPUT_DIR_NAMES = BUILD_OUTPUT_DIRS.map((d) => `${path9.sep}${d}${path9.sep}`);
+function trySourceEquivalent(resolved) {
+  resolved = resolved.replace(/[/\\]/g, path9.sep);
+  for (const marker of BUILD_OUTPUT_DIR_NAMES) {
+    const idx = resolved.indexOf(marker);
+    if (idx === -1) continue;
+    const base = resolved.replace(marker, `${path9.sep}src${path9.sep}`);
+    const candidate = base.replace(/\.(js|mjs|cjs)$/, ".ts");
+    if (candidate !== base && fs7.existsSync(candidate)) {
+      return candidate;
+    }
+    const dtsStripped = base.replace(/\.d\.ts$/, "");
+    const candidateDts = dtsStripped + ".ts";
+    if (candidateDts !== base && candidateDts !== candidate && fs7.existsSync(candidateDts)) {
+      return candidateDts;
+    }
+    const candidateNoExt = base + ".ts";
+    if (candidate !== candidateNoExt && candidateNoExt !== candidateDts && fs7.existsSync(candidateNoExt)) {
+      return candidateNoExt;
+    }
+  }
+  return null;
+}
+function tryAddEntryPath(pkgDir, rawPath, entries) {
+  const resolved = resolveAgainst(pkgDir, rawPath);
+  if (fs7.existsSync(resolved)) entries.add(resolved);
+  const tsResolved = resolved.replace(/\.(js|mjs|cjs)$/, ".ts");
+  if (tsResolved !== resolved && fs7.existsSync(tsResolved)) {
+    entries.add(tsResolved);
+  }
+  const srcAlt = trySourceEquivalent(resolved);
+  if (srcAlt) entries.add(srcAlt);
+}
+function addPkgJsonEntryPoints(pkgDir, pkg, entries) {
+  if (typeof pkg.main === "string") {
+    tryAddEntryPath(pkgDir, pkg.main, entries);
+  }
+  const bin = pkg.bin;
+  if (typeof bin === "string") {
+    tryAddEntryPath(pkgDir, bin, entries);
+  } else if (bin && typeof bin === "object") {
+    for (const value of Object.values(bin)) {
+      if (typeof value === "string") {
+        tryAddEntryPath(pkgDir, value, entries);
+      }
+    }
+  }
+  for (const key of ["types", "typings"]) {
+    if (typeof pkg[key] === "string") {
+      tryAddEntryPath(pkgDir, pkg[key], entries);
+    }
+  }
+  const exports_ = pkg.exports;
+  if (exports_ && typeof exports_ === "object") {
+    for (const value of Object.values(exports_)) {
+      if (typeof value === "string") {
+        tryAddEntryPath(pkgDir, value, entries);
+      } else if (value && typeof value === "object") {
+        for (const nested of Object.values(value)) {
+          if (typeof nested === "string") {
+            tryAddEntryPath(pkgDir, nested, entries);
+          }
+        }
+      }
+    }
+  }
+}
+function expandGlobPattern(entry, projectRoot) {
+  const dirs = [];
+  if (entry.includes("*")) {
+    const base = entry.replace(/\/\*+$/, "");
+    const baseDir = path9.resolve(projectRoot, base);
+    try {
+      const children = fs7.readdirSync(baseDir, { withFileTypes: true });
+      for (const child of children) {
+        if (child.isDirectory()) {
+          dirs.push(path9.join(baseDir, child.name));
+        }
+      }
+    } catch {
+    }
+  } else {
+    dirs.push(path9.resolve(projectRoot, entry));
+  }
+  return dirs;
+}
+function extractWorkspaceGlobs(pkg, projectRoot) {
+  const dirs = [];
+  const workspaces = pkg.workspaces;
+  if (Array.isArray(workspaces)) {
+    for (const entry of workspaces) {
+      if (typeof entry === "string") {
+        dirs.push(...expandGlobPattern(entry, projectRoot));
+      }
+    }
+  }
+  return dirs;
+}
+function extractPnpmWorkspaceDirs(projectRoot) {
+  const yamlPath = path9.join(projectRoot, "pnpm-workspace.yaml");
+  if (!fs7.existsSync(yamlPath)) return [];
+  try {
+    const content = fs7.readFileSync(yamlPath, "utf8");
+    const dirs = [];
+    let inPackages = false;
+    const lines = content.split("\n");
+    const itemRe = /^\s+-\s+"([^"]+)"|^\s+-\s+'([^']+)'|^\s+-\s+(\S+)/;
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (/^packages\s*:\s*$/.test(trimmed)) {
+        inPackages = true;
+        continue;
+      }
+      if (inPackages && trimmed.length > 0 && !line.startsWith(" ") && !line.startsWith("	")) {
+        if (!trimmed.startsWith("-")) {
+          inPackages = false;
+          continue;
+        }
+      }
+      if (inPackages) {
+        const m = itemRe.exec(line);
+        if (m) {
+          const entry = m[1] ?? m[2] ?? m[3];
+          if (entry) {
+            dirs.push(...expandGlobPattern(entry, projectRoot));
+          }
+        }
+      }
+    }
+    return dirs;
+  } catch {
+    return [];
+  }
+}
+function resolveModulePath(importerPath, moduleSpecifier, indexedFiles) {
+  if (!moduleSpecifier.startsWith(".")) return [];
+  const dir = path9.dirname(importerPath);
+  const base = path9.resolve(dir, moduleSpecifier);
+  const results = [];
+  const stripped = base.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/, "");
+  const skipBase = stripped !== base && /\.(ts|tsx|js|jsx|mjs|cjs)$/.test(base);
+  const candidates = skipBase ? [stripped] : [base];
+  for (const candidate of candidates) {
+    if (indexedFiles.has(candidate + ".ts")) results.push(candidate + ".ts");
+    if (indexedFiles.has(candidate + ".tsx")) results.push(candidate + ".tsx");
+    if (indexedFiles.has(candidate + ".js")) results.push(candidate + ".js");
+    if (indexedFiles.has(candidate + ".jsx")) results.push(candidate + ".jsx");
+    if (indexedFiles.has(candidate + ".mjs")) results.push(candidate + ".mjs");
+    if (indexedFiles.has(candidate + ".cjs")) results.push(candidate + ".cjs");
+    if (indexedFiles.has(path9.join(candidate, "index.ts")))
+      results.push(path9.join(candidate, "index.ts"));
+    if (indexedFiles.has(path9.join(candidate, "index.tsx")))
+      results.push(path9.join(candidate, "index.tsx"));
+    if (indexedFiles.has(path9.join(candidate, "index.js")))
+      results.push(path9.join(candidate, "index.js"));
+    if (indexedFiles.has(path9.join(candidate, "index.jsx")))
+      results.push(path9.join(candidate, "index.jsx"));
+    if (indexedFiles.has(path9.join(candidate, "index.mjs")))
+      results.push(path9.join(candidate, "index.mjs"));
+    if (indexedFiles.has(path9.join(candidate, "index.cjs")))
+      results.push(path9.join(candidate, "index.cjs"));
+  }
+  return [...new Set(results)];
+}
+function parseNamedExportSymbols(matchText) {
+  const braceStart = matchText.indexOf("{");
+  if (braceStart === -1) return null;
+  const braceEnd = matchText.indexOf("}", braceStart);
+  if (braceEnd === -1) return null;
+  const inner = matchText.slice(braceStart + 1, braceEnd);
+  const symbols = [];
+  for (const part of inner.split(",")) {
+    let s = part.trim();
+    if (!s) continue;
+    s = s.replace(/^type\s+/, "");
+    const asIdx = s.search(/\s+as\s+/);
+    if (asIdx !== -1) {
+      s = s.slice(0, asIdx).trim();
+    }
+    if (s) symbols.push(s);
+  }
+  return symbols;
+}
+function runDeadCodeScan(projectRoot, opts = {}) {
+  const store = opts.store ?? indexStorePool.acquire(projectRoot, { indexDir: opts.indexDir });
+  try {
+    const allSymbols = store.getAllSymbols();
+    const symbolById = /* @__PURE__ */ new Map();
+    for (const s of allSymbols) {
+      symbolById.set(s.id, s);
+    }
+    const discoveredFiles = discoverEntryPoints(projectRoot, opts.userEntryPoints);
+    const entryFileSet = new Set(discoveredFiles.map((f) => path9.resolve(f)));
+    const indexedFiles = /* @__PURE__ */ new Set();
+    for (const s of allSymbols) indexedFiles.add(s.file);
+    for (const fm of store.getAllFileMetas()) indexedFiles.add(fm.file);
+    const seedIds = /* @__PURE__ */ new Set();
+    for (const s of allSymbols) {
+      if (entryFileSet.has(s.file)) {
+        seedIds.add(s.id);
+      }
+    }
+    const fileToSymbolIds = /* @__PURE__ */ new Map();
+    for (const s of allSymbols) {
+      let byFile = fileToSymbolIds.get(s.file);
+      if (!byFile) {
+        byFile = [];
+        fileToSymbolIds.set(s.file, byFile);
+      }
+      byFile.push(s.id);
+    }
+    const scannedBarrels = /* @__PURE__ */ new Set();
+    const barrelWorkList = [...entryFileSet];
+    while (barrelWorkList.length > 0) {
+      const epFile = barrelWorkList.pop();
+      if (scannedBarrels.has(epFile)) continue;
+      scannedBarrels.add(epFile);
+      try {
+        const content = fs7.readFileSync(epFile, "utf8");
+        const strippedContent = content.replace(/\/\*[\s\S]*?\*\//g, (m) => " ".repeat(m.length)).replace(/\/\/[^\n]*/g, (m) => " ".repeat(m.length));
+        const reExportRe = /export\s+(?:(?:type\s+)?\{[\s\S]*?\}\s+from|\*\s+as\s+\w+\s+from|\*\s+from)\s+['"]([^'"]+)['"]/g;
+        for (; ; ) {
+          const match = reExportRe.exec(strippedContent);
+          if (match === null) break;
+          const moduleSpec = match[1];
+          const resolvedFiles = resolveModulePath(epFile, moduleSpec, indexedFiles);
+          for (const rf of resolvedFiles) {
+            const fileSyms = fileToSymbolIds.get(rf);
+            if (fileSyms) {
+              const namedSymbols = parseNamedExportSymbols(match[0]);
+              if (namedSymbols) {
+                const nameSet = new Set(namedSymbols);
+                for (const sid of fileSyms) {
+                  const sym = symbolById.get(sid);
+                  if (sym && nameSet.has(sym.name)) seedIds.add(sid);
+                }
+              } else {
+                for (const sid of fileSyms) seedIds.add(sid);
+              }
+            }
+            if (!scannedBarrels.has(rf)) {
+              barrelWorkList.push(rf);
+            }
+          }
+        }
+      } catch (err) {
+        if (err instanceof Error && err.code !== "ENOENT") {
+          console.warn(
+            JSON.stringify({
+              level: "warn",
+              event: "dead_code_scan_barrel_read_failed",
+              message: err.message,
+              file: epFile,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            })
+          );
+        }
+      }
+    }
+    const alive = store.findReachableSymbolIds([...seedIds]);
+    const dead = [];
+    const symbolsByFile = /* @__PURE__ */ new Map();
+    const usedFiles = /* @__PURE__ */ new Set();
+    for (const s of allSymbols) {
+      if (alive.has(s.id)) {
+        usedFiles.add(s.file);
+        continue;
+      }
+      if (s.kind === "parameter") continue;
+      if (s.kind === "let" || s.kind === "var") {
+        continue;
+      }
+      const reason = "unreferenced";
+      dead.push({
+        name: s.name,
+        kind: s.kind,
+        lang: detectLang(s.file) ?? "ts",
+        file: s.file,
+        line: s.line,
+        reason
+      });
+      let fileSymbols = symbolsByFile.get(s.file);
+      if (!fileSymbols) {
+        fileSymbols = [];
+        symbolsByFile.set(s.file, fileSymbols);
+      }
+      fileSymbols.push(s);
+    }
+    const deadFiles = [];
+    for (const [file, syms] of symbolsByFile) {
+      let anyAlive = false;
+      for (const s of allSymbols) {
+        if (s.file === file && alive.has(s.id)) {
+          anyAlive = true;
+          break;
+        }
+      }
+      if (!anyAlive) {
+        deadFiles.push({
+          file,
+          symbolCount: syms.length,
+          lang: detectLang(file) ?? "ts"
+        });
+      }
+    }
+    const deadPackages = [];
+    const pkgEntries = findPackageEntries(projectRoot);
+    for (const [pkgName, pkgDir] of pkgEntries) {
+      const pkgFiles = allSymbols.filter((s) => s.file.startsWith(pkgDir + path9.sep));
+      if (pkgFiles.length === 0) continue;
+      const pkgUsed = pkgFiles.filter((s) => alive.has(s.id));
+      if (pkgUsed.length === 0) {
+        const uniqueFiles = new Set(pkgFiles.map((s) => s.file));
+        deadPackages.push({
+          package: pkgName,
+          path: pkgDir,
+          fileCount: uniqueFiles.size
+        });
+      }
+    }
+    dead.sort((a, b) => {
+      if (a.reason !== b.reason) return a.reason === "unreferenced-export" ? -1 : 1;
+      return a.file.localeCompare(b.file) || a.line - b.line;
+    });
+    return {
+      deadSymbols: dead,
+      deadFiles,
+      deadPackages,
+      entryPoints: discoveredFiles,
+      stats: {
+        totalSymbols: allSymbols.length,
+        alive: alive.size,
+        dead: dead.length,
+        durationMs: 0
+      }
+    };
+  } finally {
+    if (!opts.store) {
+      indexStorePool.release(store);
+    }
+  }
+}
+function findPackageEntries(projectRoot) {
+  const pkgMap = /* @__PURE__ */ new Map();
+  const rootPkg = tryReadJson(path9.join(projectRoot, "package.json"));
+  if (rootPkg && typeof rootPkg.name === "string") {
+    pkgMap.set(rootPkg.name, projectRoot);
+  }
+  if (rootPkg) {
+    let wsDirs = extractWorkspaceGlobs(rootPkg, projectRoot);
+    if (wsDirs.length === 0) {
+      wsDirs = extractPnpmWorkspaceDirs(projectRoot);
+    }
+    for (const wsDir of wsDirs) {
+      const wsPkg = tryReadJson(path9.join(wsDir, "package.json"));
+      if (wsPkg && typeof wsPkg.name === "string") {
+        pkgMap.set(wsPkg.name, wsDir);
+      }
+    }
+  }
+  return pkgMap;
+}
+
+export {
+  PolyglotInvariantEngine,
+  polyglotInvariantEngine,
+  replaceSymbolInFile,
+  codebaseAstReplaceTool,
+  codebaseInvariantCheckTool,
+  codebaseImpactAnalysisTool,
+  codebaseIncomingCallsTool,
+  codebaseSearchTool,
+  codebaseIndexTool,
+  codebaseOutgoingCallsTool,
+  extractFileSkeleton,
+  extractDirectorySkeleton,
+  generateRepoMap,
+  codebaseRepoMapTool,
+  codebaseSkeletonTool,
+  codebaseStatsTool,
+  codebaseTargetedTestTool,
+  deadCodeScanTool,
+  runDeadCodeScan
+};
+//# sourceMappingURL=chunk-OZC255IC.js.map