dsh-code-index 0.4.0 → 0.6.1

package/dist/index.js

@@ -162,6 +162,66 @@ var IMPORT_QUERIES = {
     (preproc_include) @import
   `
 };
+var CALL_QUERIES = {
+  typescript: `
+    (call_expression function: (identifier) @call)
+    (call_expression function: (member_expression property: (property_identifier) @call))
+    (new_expression constructor: (identifier) @call)
+  `,
+  javascript: `
+    (call_expression function: (identifier) @call)
+    (call_expression function: (member_expression property: (property_identifier) @call))
+    (new_expression constructor: (identifier) @call)
+  `,
+  python: `
+    (call function: (identifier) @call)
+    (call function: (attribute attribute: (identifier) @call))
+  `,
+  go: `
+    (call_expression function: (identifier) @call)
+    (call_expression function: (selector_expression field: (field_identifier) @call))
+  `,
+  rust: `
+    (call_expression function: (identifier) @call)
+    (call_expression function: (field_expression field: (field_identifier) @call))
+    (call_expression function: (scoped_identifier name: (identifier) @call))
+  `,
+  java: `
+    (method_invocation name: (identifier) @call)
+    (object_creation_expression type: (type_identifier) @call)
+  `,
+  cpp: `
+    (call_expression function: (identifier) @call)
+    (call_expression function: (field_expression field: (field_identifier) @call))
+    (call_expression function: (qualified_identifier name: (identifier) @call))
+  `,
+  c: `
+    (call_expression function: (identifier) @call)
+    (call_expression function: (field_expression field: (field_identifier) @call))
+  `
+};
+var CALLABLE_NODES = {
+  typescript: /* @__PURE__ */ new Set([
+    "function_declaration",
+    "generator_function_declaration",
+    "method_definition",
+    "function_expression",
+    "arrow_function"
+  ]),
+  javascript: /* @__PURE__ */ new Set([
+    "function_declaration",
+    "generator_function_declaration",
+    "method_definition",
+    "function_expression",
+    "arrow_function"
+  ]),
+  python: /* @__PURE__ */ new Set(["function_definition"]),
+  go: /* @__PURE__ */ new Set(["function_declaration", "method_declaration", "func_literal"]),
+  rust: /* @__PURE__ */ new Set(["function_item", "function_signature_item"]),
+  java: /* @__PURE__ */ new Set(["method_declaration", "constructor_declaration"]),
+  cpp: /* @__PURE__ */ new Set(["function_definition", "lambda_expression"]),
+  c: /* @__PURE__ */ new Set(["function_definition"])
+};
 var parserPromise = null;
 async function getParser() {
   if (!parserPromise) {
@@ -184,20 +244,27 @@ function getLanguage(id) {
       const lang = await Language.load(bytes);
       new Query(lang, QUERIES[id]).delete();
       new Query(lang, IMPORT_QUERIES[id]).delete();
+      new Query(lang, CALL_QUERIES[id]).delete();
       return lang;
     });
     languageCache.set(id, entry);
   }
   return entry;
 }
-async function extractAll(code, id) {
+function encodeSymbolComponent(value) {
+  return encodeURIComponent(value).replace(
+    /[!'()*~]/g,
+    (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`
+  );
+}
+async function extractAll(code, id, file = "") {
   const lang = await getLanguage(id);
   const parser = await getParser();
   parser.setLanguage(lang);
   const tree = parser.parse(code);
   if (!tree) throw new Error(`tree-sitter parse returned null for a ${id} source`);
   try {
-    const symbols = [];
+    const drafts = [];
     const symbolQuery = new Query(lang, QUERIES[id]);
     try {
       const captures = symbolQuery.captures(tree.rootNode);
@@ -208,43 +275,297 @@ async function extractAll(code, id) {
         if (def.kind === "variable" && !isModuleLevelVariable(id, node)) continue;
         const name2 = nameOf(id, node);
         if (!name2) continue;
-        symbols.push({
-          name: name2,
-          kind: kindFor(id, node, def.kind),
-          file: "",
-          // set by the caller (extractor is file-agnostic)
-          line: node.startPosition.row + 1,
-          endLine: node.endPosition.row + 1,
-          exported: isExported(id, node),
-          signature: signatureFor(id, node)
+        drafts.push({
+          symbol: {
+            name: name2,
+            kind: kindFor(id, node, def.kind),
+            line: node.startPosition.row + 1,
+            endLine: node.endPosition.row + 1,
+            exported: isExported(id, node),
+            signature: signatureFor(id, node)
+          },
+          node
         });
       }
     } finally {
       symbolQuery.delete();
     }
-    const imports = [];
+    const dedupedDrafts = dedupeDrafts(drafts);
+    const symbols = assignSymbolIds(file, dedupedDrafts, id);
+    const symbolByNodeId = /* @__PURE__ */ new Map();
+    dedupedDrafts.forEach((draft, index) => symbolByNodeId.set(draft.node.id, symbols[index]));
+    const importDetails = [];
     const importQuery = new Query(lang, IMPORT_QUERIES[id]);
     try {
       for (const cap of importQuery.captures(tree.rootNode)) {
-        const spec = specifierOf(id, cap.node);
-        if (spec) imports.push(spec);
+        for (const info of importInfoFor(id, cap.node)) importDetails.push(info);
       }
     } finally {
       importQuery.delete();
     }
-    symbols.sort((a, b) => a.line - b.line);
-    const seen = /* @__PURE__ */ new Set();
-    const deduped = symbols.filter((s) => {
-      const key = `${s.kind}|${s.name}|${s.line}`;
-      if (seen.has(key)) return false;
-      seen.add(key);
-      return true;
-    });
-    return { symbols: deduped, imports };
+    const imports = importDetails.map((info) => info.specifier);
+    const calls = [];
+    const callQuery = new Query(lang, CALL_QUERIES[id]);
+    try {
+      const seen = /* @__PURE__ */ new Set();
+      for (const cap of callQuery.captures(tree.rootNode)) {
+        const name2 = cap.node.text.trim();
+        if (!name2) continue;
+        const line = cap.node.startPosition.row + 1;
+        const callable = enclosingCallableNode(id, cap.node);
+        const from = callable ? callableNameOf(id, callable) : "";
+        const fromId = callable ? nearestDraftId(callable, symbolByNodeId) : null;
+        const key = `${from}|${name2}|${line}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        calls.push({ name: name2, line, from, fromId, qualifier: qualifierOf(cap.node) });
+      }
+    } finally {
+      callQuery.delete();
+    }
+    calls.sort((a, b) => a.line - b.line || a.name.localeCompare(b.name));
+    symbols.sort(
+      (a, b) => a.line - b.line || a.endLine - b.endLine || a.kind.localeCompare(b.kind) || a.name.localeCompare(b.name)
+    );
+    return { symbols, imports, importDetails, calls };
   } finally {
     tree.delete();
   }
 }
+function dedupeDrafts(drafts) {
+  const sorted = [...drafts].sort(
+    (a, b) => a.symbol.line - b.symbol.line || a.node.startIndex - b.node.startIndex
+  );
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const draft of sorted) {
+    if (seen.has(draft.node.id)) continue;
+    seen.add(draft.node.id);
+    out.push(draft);
+  }
+  return out;
+}
+var MATCHABLE_OWNER_KINDS = /* @__PURE__ */ new Set([
+  "class",
+  "interface",
+  "trait",
+  "module",
+  "namespace",
+  "impl"
+]);
+function scopeKindOf(language, kind) {
+  switch (kind) {
+    case "class":
+      return "class";
+    case "interface":
+      return language === "rust" ? "trait" : "interface";
+    case "function":
+      return "function";
+    case "method":
+      return "method";
+    case "module":
+      return language === "cpp" ? "namespace" : "module";
+    default:
+      return "owner";
+  }
+}
+function segmentOf(entry) {
+  return `${entry.kind}:${encodeSymbolComponent(entry.name)}@${entry.ordinal}`;
+}
+function assignSymbolIds(file, drafts, language) {
+  const entries = drafts.map((draft, index) => ({
+    kind: scopeKindOf(language, draft.symbol.kind),
+    name: draft.symbol.name,
+    startIndex: draft.node.startIndex,
+    endIndex: draft.node.endIndex,
+    parent: -1,
+    ordinal: 1,
+    scopeKey: "",
+    draftIndex: index
+  }));
+  const entryByNodeId = /* @__PURE__ */ new Map();
+  drafts.forEach((draft, index) => entryByNodeId.set(draft.node.id, index));
+  const entriesByName = /* @__PURE__ */ new Map();
+  entries.forEach((entry, index) => {
+    const list = entriesByName.get(entry.name);
+    if (list) list.push(index);
+    else entriesByName.set(entry.name, [index]);
+  });
+  const syntheticByKey = /* @__PURE__ */ new Map();
+  const resolveOwner = (desc, parent, selfIndex) => {
+    const matches = entriesByName.get(desc.name);
+    const typed = matches?.find((index2) => {
+      if (index2 === selfIndex) return false;
+      const entry = entries[index2];
+      if (!MATCHABLE_OWNER_KINDS.has(entry.kind)) return false;
+      if (entry.parent !== parent) return false;
+      return desc.kind === "owner" || entry.kind === desc.kind;
+    });
+    if (typed !== void 0) return typed;
+    const key = `${parent}\0${desc.kind}\0${desc.name}`;
+    const existing = syntheticByKey.get(key);
+    if (existing !== void 0) return existing;
+    const index = entries.length;
+    entries.push({
+      kind: desc.kind,
+      name: desc.name,
+      startIndex: Number.MAX_SAFE_INTEGER,
+      endIndex: Number.MAX_SAFE_INTEGER,
+      parent,
+      ordinal: 1,
+      scopeKey: "",
+      draftIndex: -1
+    });
+    syntheticByKey.set(key, index);
+    return index;
+  };
+  drafts.forEach((draft, index) => {
+    let parent = -1;
+    for (let node = draft.node.parent; node; node = node.parent) {
+      const owner = entryByNodeId.get(node.id);
+      if (owner !== void 0) {
+        parent = owner;
+        break;
+      }
+    }
+    for (const desc of ownerScopeOf(language, draft.node)) {
+      parent = resolveOwner(desc, parent, index);
+    }
+    entries[index].parent = parent;
+  });
+  assignOrdinals(entries);
+  return drafts.map((draft, index) => {
+    const entry = entries[index];
+    const chain = [];
+    for (let node = entries[entry.parent]; node; node = entries[node.parent]) {
+      chain.push(node);
+    }
+    chain.reverse();
+    const scope = chain.map((node) => ({
+      kind: node.kind,
+      name: node.name,
+      ordinal: node.ordinal
+    }));
+    const segments = [...chain.map(segmentOf), segmentOf(entry)];
+    return {
+      ...draft.symbol,
+      file,
+      id: `sym:v1:${encodeSymbolComponent(file)}#${segments.join("/")}`,
+      scope,
+      ordinal: entry.ordinal
+    };
+  });
+}
+function assignOrdinals(entries) {
+  const depthCache = /* @__PURE__ */ new Map();
+  const depthOf = (index) => {
+    const cached = depthCache.get(index);
+    if (cached !== void 0) return cached;
+    const parent = entries[index].parent;
+    const value = parent >= 0 ? depthOf(parent) + 1 : 0;
+    depthCache.set(index, value);
+    return value;
+  };
+  const byDepth = /* @__PURE__ */ new Map();
+  let maxDepth = 0;
+  for (let index = 0; index < entries.length; index++) {
+    const depth = depthOf(index);
+    maxDepth = Math.max(maxDepth, depth);
+    const list = byDepth.get(depth);
+    if (list) list.push(index);
+    else byDepth.set(depth, [index]);
+  }
+  for (let depth = 0; depth <= maxDepth; depth++) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const index of byDepth.get(depth) ?? []) {
+      const entry = entries[index];
+      const parentKey = entry.parent >= 0 ? entries[entry.parent].scopeKey : "";
+      const key = `${parentKey}\0${entry.kind}\0${entry.name}`;
+      const list = groups.get(key);
+      if (list) list.push(index);
+      else groups.set(key, [index]);
+    }
+    for (const group of groups.values()) {
+      group.sort((a, b) => {
+        const left = entries[a];
+        const right = entries[b];
+        return left.startIndex - right.startIndex || left.endIndex - right.endIndex || left.kind.localeCompare(right.kind) || left.name.localeCompare(right.name);
+      });
+      group.forEach((index, position) => {
+        const entry = entries[index];
+        entry.ordinal = position + 1;
+        const segment = segmentOf(entry);
+        entry.scopeKey = entry.parent >= 0 ? `${entries[entry.parent].scopeKey}/${segment}` : segment;
+      });
+    }
+  }
+}
+function ownerScopeOf(language, node) {
+  if (language === "go") return goReceiverOwners(node);
+  if (language === "rust") return rustImplOwners(node);
+  if (language === "cpp" || language === "c") return cppQualifiedOwners(node);
+  return [];
+}
+function goReceiverOwners(node) {
+  if (node.type !== "method_declaration") return [];
+  const receiver = node.childForFieldName("receiver");
+  const type = receiver ? findDescendant(receiver, "type_identifier") : null;
+  return type ? [{ kind: "class", name: type.text.trim() }] : [];
+}
+function rustImplOwners(node) {
+  if (node.type !== "function_item" && node.type !== "function_signature_item") return [];
+  let impl = null;
+  for (let parent = node.parent; parent; parent = parent.parent) {
+    if (parent.type === "impl_item") {
+      impl = parent;
+      break;
+    }
+    if (parent.type === "trait_item" || CALLABLE_NODES.rust.has(parent.type)) return [];
+  }
+  if (!impl) return [];
+  const type = impl.childForFieldName("type");
+  const targetName = type ? findDescendant(type, "type_identifier")?.text.trim() : void 0;
+  const traitName = impl.childForFieldName("trait")?.text.trim();
+  const name2 = targetName && traitName ? `${traitName} for ${targetName}` : targetName ?? traitName;
+  return name2 ? [{ kind: "impl", name: name2 }] : [];
+}
+function cppQualifiedOwners(node) {
+  const declarator = cppDeclaratorQid(node);
+  if (!declarator) return [];
+  return cppQualifiedSegments(declarator).slice(0, -1).map((name2) => ({ kind: "owner", name: name2 }));
+}
+function cppDeclaratorQid(node) {
+  let current = node.childForFieldName?.("declarator");
+  while (current) {
+    if (current.type === "qualified_identifier") return current;
+    if (!current.type.includes("declarator")) return null;
+    current = current.childForFieldName?.("declarator") ?? current.namedChildren[0] ?? null;
+  }
+  return null;
+}
+function cppQualifiedSegments(qualified) {
+  const scope = qualified.childForFieldName("scope");
+  const name2 = qualified.childForFieldName("name");
+  const head = scope ? [scope.text.trim()] : [];
+  const tail = name2?.type === "qualified_identifier" ? cppQualifiedSegments(name2) : [name2?.text.trim() ?? ""];
+  return [...head, ...tail].filter(Boolean);
+}
+function findDescendant(node, type) {
+  if (node.type === type) return node;
+  for (const child of node.namedChildren) {
+    if (!child) continue;
+    const nested = findDescendant(child, type);
+    if (nested) return nested;
+  }
+  return null;
+}
+function nearestDraftId(node, symbols) {
+  for (let current = node; current; current = current.parent) {
+    const symbol = symbols.get(current.id);
+    if (symbol) return symbol.id;
+  }
+  return null;
+}
 async function extractSymbols(code, id) {
   return (await extractAll(code, id)).symbols;
 }
@@ -272,7 +593,7 @@ function cppNameOf(node) {
         continue;
       }
       if (current.type === "qualified_identifier") {
-        return current.childForFieldName?.("name")?.text.trim() ?? current.text.trim();
+        return cppQualifiedSegments(current).at(-1) ?? "";
       }
       if (current.type === "identifier" || current.type === "field_identifier" || current.type === "type_identifier") {
         return current.text.trim();
@@ -282,29 +603,251 @@ function cppNameOf(node) {
   }
   return "";
 }
-function specifierOf(id, node) {
+function enclosingCallableNode(id, node) {
+  const callable = CALLABLE_NODES[id];
+  for (let parent = node.parent; parent; parent = parent.parent) {
+    if (callable.has(parent.type)) return parent;
+  }
+  return null;
+}
+function callableNameOf(id, callable) {
+  const named = nameOf(id, callable);
+  if (named) return named;
+  const declaration = callable.parent;
+  if (declaration?.type === "variable_declarator") {
+    return declaration.childForFieldName?.("name")?.text.trim() ?? "";
+  }
+  return "";
+}
+function qualifierOf(node) {
+  const parent = node.parent;
+  if (!parent) return null;
+  let receiver;
+  switch (parent.type) {
+    case "member_expression":
+    case "method_invocation":
+    case "attribute":
+      receiver = parent.childForFieldName("object");
+      break;
+    case "selector_expression":
+      receiver = parent.childForFieldName("operand");
+      break;
+    case "field_expression":
+      receiver = parent.childForFieldName("value") ?? parent.childForFieldName("argument");
+      break;
+    case "qualified_identifier":
+    case "scoped_identifier":
+      receiver = parent.childForFieldName("scope") ?? parent.childForFieldName("path");
+      break;
+    default:
+      return null;
+  }
+  const text = receiver?.text.replace(/\s+/g, " ").trim();
+  return text ? text : null;
+}
+function importInfoFor(id, node) {
+  const line = node.startPosition.row + 1;
   switch (node.type) {
     case "import_statement":
-      if (id === "python") return dottedToPath(node.childForFieldName("name")?.text);
-      return stripQuotes(node.childForFieldName("source")?.text);
+      return id === "python" ? pythonModuleImports(node, line) : tsJsImports(node, line);
     case "export_statement":
-      return stripQuotes(node.childForFieldName("source")?.text);
-    case "import_from_statement": {
-      const raw = node.childForFieldName("module_name")?.text;
-      if (raw == null) return null;
-      return raw.startsWith(".") ? pythonRelative(raw) : dottedToPath(raw);
-    }
+      return tsJsReexport(node, line);
+    case "import_from_statement":
+      return pythonFromImport(node, line);
     case "import_spec":
-      return stripQuotes(node.childForFieldName("path")?.text);
+      return goImport(node, line);
     case "use_declaration":
-      return rustUsePath(node.childForFieldName("argument")?.text);
+      return rustUse(node, line);
     case "import_declaration":
-      return dottedToPath(node.namedChildren[0]?.text);
-    case "preproc_include":
-      return stripQuotes(node.childForFieldName("path")?.text);
+      return javaImport(node, line);
+    case "preproc_include": {
+      const specifier = stripQuotes(node.childForFieldName("path")?.text);
+      return specifier ? [{ specifier, line, kind: "include", bindings: [] }] : [];
+    }
     default:
-      return null;
+      return [];
+  }
+}
+function tsJsImports(node, line) {
+  const specifier = stripQuotes(node.childForFieldName("source")?.text);
+  if (!specifier) return [];
+  return [{ specifier, line, kind: "import", bindings: importClauseBindings(node) }];
+}
+function importClauseBindings(node) {
+  const bindings = [];
+  const clause = node.namedChildren.find((child) => child?.type === "import_clause");
+  if (!clause) return bindings;
+  for (const child of clause.namedChildren) {
+    if (!child) continue;
+    if (child.type === "identifier") {
+      bindings.push({ imported: "default", local: child.text.trim(), kind: "default" });
+    } else if (child.type === "namespace_import") {
+      const local = child.namedChildren.find((c) => c?.type === "identifier")?.text.trim();
+      if (local) bindings.push({ imported: "*", local, kind: "namespace" });
+    } else if (child.type === "named_imports") {
+      for (const spec of child.namedChildren) {
+        if (spec?.type !== "import_specifier") continue;
+        const imported = spec.childForFieldName("name")?.text.trim();
+        if (!imported) continue;
+        const alias = spec.childForFieldName("alias")?.text.trim();
+        bindings.push({ imported, local: alias ?? imported, kind: "named" });
+      }
+    }
   }
+  return bindings;
+}
+function tsJsReexport(node, line) {
+  const specifier = stripQuotes(node.childForFieldName("source")?.text);
+  if (!specifier) return [];
+  const bindings = [];
+  const clause = node.namedChildren.find((child) => child?.type === "export_clause");
+  for (const spec of clause?.namedChildren ?? []) {
+    if (spec?.type !== "export_specifier") continue;
+    const imported = spec.childForFieldName("name")?.text.trim();
+    if (!imported) continue;
+    const alias = spec.childForFieldName("alias")?.text.trim();
+    bindings.push({ imported, local: alias ?? imported, kind: "named" });
+  }
+  const namespaceExport = node.namedChildren.find((child) => child?.type === "namespace_export");
+  const local = namespaceExport?.namedChildren.find((c) => c?.type === "identifier")?.text.trim();
+  if (local) bindings.push({ imported: "*", local, kind: "namespace" });
+  return [{ specifier, line, kind: "reexport", bindings }];
+}
+function pythonModuleImports(node, line) {
+  const out = [];
+  for (const nameNode of node.childrenForFieldName("name")) {
+    if (!nameNode) continue;
+    if (nameNode.type === "aliased_import") {
+      const moduleName = nameNode.childForFieldName("name")?.text.trim();
+      const specifier = dottedToPath(moduleName);
+      if (!specifier) continue;
+      const alias = nameNode.childForFieldName("alias")?.text.trim();
+      out.push({
+        specifier,
+        line,
+        kind: "import",
+        bindings: [
+          { imported: moduleName ?? null, local: alias ?? moduleName ?? "", kind: "namespace" }
+        ]
+      });
+    } else if (nameNode.type === "dotted_name") {
+      const moduleName = nameNode.text.trim();
+      const specifier = dottedToPath(moduleName);
+      if (!specifier) continue;
+      out.push({
+        specifier,
+        line,
+        kind: "import",
+        bindings: [{ imported: null, local: moduleName.split(".")[0] ?? moduleName, kind: "package" }]
+      });
+    }
+  }
+  return out;
+}
+function pythonFromImport(node, line) {
+  const raw = node.childForFieldName("module_name")?.text;
+  if (raw == null) return [];
+  const specifier = raw.startsWith(".") ? pythonRelative(raw) : dottedToPath(raw);
+  if (!specifier) return [];
+  const moduleNode = node.childForFieldName("module_name");
+  const bindings = [];
+  for (const nameNode of node.namedChildren) {
+    if (!nameNode || nameNode.id === moduleNode?.id) continue;
+    if (nameNode.type === "aliased_import") {
+      const imported = nameNode.childForFieldName("name")?.text.trim();
+      if (!imported) continue;
+      const alias = nameNode.childForFieldName("alias")?.text.trim();
+      bindings.push({ imported, local: alias ?? lastDotSegment(imported), kind: "named" });
+    } else if (nameNode.type === "dotted_name") {
+      const imported = nameNode.text.trim();
+      bindings.push({ imported, local: lastDotSegment(imported), kind: "named" });
+    } else if (nameNode.type === "wildcard_import") {
+      bindings.push({ imported: "*", local: "*", kind: "glob" });
+    }
+  }
+  return [{ specifier, line, kind: "import", bindings }];
+}
+function goImport(node, line) {
+  const specifier = stripQuotes(node.childForFieldName("path")?.text);
+  if (!specifier) return [];
+  const nameNode = node.childForFieldName("name");
+  let binding;
+  if (!nameNode) {
+    binding = { imported: null, local: lastSlashSegment(specifier), kind: "package" };
+  } else if (nameNode.type === "dot") {
+    binding = { imported: "*", local: ".", kind: "glob" };
+  } else {
+    binding = { imported: null, local: nameNode.text.trim(), kind: "package" };
+  }
+  return [{ specifier, line, kind: "import", bindings: [binding] }];
+}
+function rustUse(node, line) {
+  const argument = node.childForFieldName("argument");
+  if (!argument) return [];
+  const base = argument.type === "use_as_clause" ? argument.childForFieldName("path") : argument;
+  const specifier = rustUsePath(base?.text ?? argument.text);
+  if (!specifier) return [];
+  return [{ specifier, line, kind: "use", bindings: rustBindings(argument) }];
+}
+function rustBindings(node) {
+  switch (node.type) {
+    case "scoped_identifier": {
+      const imported = node.childForFieldName("name")?.text.trim();
+      return imported ? [{ imported, local: imported, kind: "named" }] : [];
+    }
+    case "identifier": {
+      const name2 = node.text.trim();
+      return name2 ? [{ imported: name2, local: name2, kind: "named" }] : [];
+    }
+    case "use_as_clause": {
+      const path9 = node.childForFieldName("path");
+      const alias = node.childForFieldName("alias")?.text.trim();
+      const imported = path9 ? rustLeafName(path9) : null;
+      return imported && alias ? [{ imported, local: alias, kind: "named" }] : [];
+    }
+    case "scoped_use_list": {
+      const bindings = [];
+      for (const item of node.childForFieldName("list")?.namedChildren ?? []) {
+        if (item) bindings.push(...rustBindings(item));
+      }
+      return bindings;
+    }
+    case "use_wildcard":
+      return [{ imported: "*", local: "*", kind: "glob" }];
+    default:
+      return [];
+  }
+}
+function rustLeafName(node) {
+  if (node.type === "identifier") return node.text.trim();
+  return node.childForFieldName("name")?.text.trim() ?? null;
+}
+function javaImport(node, line) {
+  const path9 = node.namedChildren.find((child) => child?.type === "scoped_identifier");
+  const specifier = dottedToPath(path9?.text);
+  if (!specifier) return [];
+  const wildcard = node.namedChildren.some((child) => child?.type === "asterisk");
+  if (wildcard) {
+    return [
+      { specifier, line, kind: "import", bindings: [{ imported: "*", local: "*", kind: "glob" }] }
+    ];
+  }
+  const imported = path9?.childForFieldName("name")?.text.trim() ?? lastSlashSegment(specifier);
+  const isStatic = /^import\s+static\b/.test(node.text);
+  return [
+    {
+      specifier,
+      line,
+      kind: "import",
+      bindings: [{ imported, local: imported, kind: isStatic ? "static" : "named" }]
+    }
+  ];
+}
+function lastDotSegment(value) {
+  return value.split(".").pop() ?? value;
+}
+function lastSlashSegment(value) {
+  return value.split("/").pop() ?? value;
 }
 function rustUsePath(text) {
   if (!text) return null;
@@ -460,9 +1003,9 @@ async function parseFileToSymbols(filePath, repoRoot, code) {
   const lang = languageForFile(filePath);
   if (!lang) return [];
   const text = code ?? await readFile(filePath, "utf8");
-  const rows = await extractSymbols(text, lang);
   const rel = path.relative(repoRoot, filePath).split(path.sep).join("/");
-  return rows.map((r) => ({ ...r, file: rel }));
+  const { symbols } = await extractAll(text, lang, rel);
+  return symbols;
 }
 
 // src/scan.ts
@@ -546,6 +1089,14 @@ async function scanRepo(root, options = {}) {
 import { mkdir, readFile as readFile2, rename, rm, writeFile } from "fs/promises";
 import path3 from "path";
 import { createHash, randomUUID } from "crypto";
+
+// src/types.ts
+var REPO_INDEX_SCHEMA_VERSION = 2;
+function symbolCount(index) {
+  return index.files.reduce((n, f) => n + f.symbols.length, 0);
+}
+
+// src/store.ts
 var CACHE_DIR_NAME = ".dsh-code-index";
 function cacheKeyForRoot(root) {
   const resolved = path3.resolve(root);
@@ -566,6 +1117,7 @@ async function loadIndex(cachePath) {
     const raw = await readFile2(cachePath, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed.root !== "string" || !Array.isArray(parsed.files)) return null;
+    if (parsed.schemaVersion !== REPO_INDEX_SCHEMA_VERSION) return null;
     return healSymbolFiles(parsed);
   } catch {
     return null;
@@ -617,13 +1169,15 @@ async function buildIndex(root, options = {}, previous = null) {
         } catch {
           return null;
         }
-        const { symbols, imports } = await extractAll(code, lang);
+        const { symbols, imports, importDetails, calls } = await extractAll(code, lang, f.rel);
         return {
           path: f.rel,
           lang,
           mtimeMs: f.mtimeMs,
           symbols: symbols.map((s) => ({ ...s, file: f.rel })),
-          imports
+          imports,
+          importDetails,
+          calls
         };
       })
     );
@@ -632,6 +1186,7 @@ async function buildIndex(root, options = {}, previous = null) {
     }
   }
   return {
+    schemaVersion: REPO_INDEX_SCHEMA_VERSION,
     root,
     generatedAt: Date.now(),
     files,
@@ -659,6 +1214,7 @@ async function buildIndexWithCache(root, options = {}, cacheDir) {
   return fresh;
 }
 function indexesEqual(left, right) {
+  if (left.schemaVersion !== right.schemaVersion) return false;
   if (cacheKeyForRoot(left.root) !== cacheKeyForRoot(right.root)) return false;
   if (left.files.length !== right.files.length) return false;
   if (left.excludedDirs.length !== right.excludedDirs.length) return false;
@@ -669,12 +1225,45 @@ function indexesEqual(left, right) {
       return false;
     }
     if (file.symbols.length !== other.symbols.length) return false;
+    if (!callsEqual(file.calls, other.calls)) return false;
+    if (!importsEqual(file.importDetails, other.importDetails)) return false;
     return file.symbols.every((symbol, symbolIndex) => {
       const candidate = other.symbols[symbolIndex];
-      return candidate !== void 0 && symbol.name === candidate.name && symbol.kind === candidate.kind && symbol.file === candidate.file && symbol.line === candidate.line && symbol.endLine === candidate.endLine && symbol.exported === candidate.exported && symbol.signature === candidate.signature;
+      return candidate !== void 0 && symbol.id === candidate.id && symbol.name === candidate.name && symbol.kind === candidate.kind && symbol.file === candidate.file && symbol.line === candidate.line && symbol.endLine === candidate.endLine && symbol.exported === candidate.exported && symbol.signature === candidate.signature && symbol.ordinal === candidate.ordinal && scopesEqual(symbol.scope, candidate.scope);
+    });
+  });
+}
+function scopesEqual(left, right) {
+  if (left.length !== right.length) return false;
+  return left.every((part, index) => {
+    const other = right[index];
+    return other !== void 0 && part.kind === other.kind && part.name === other.name && part.ordinal === other.ordinal;
+  });
+}
+function importsEqual(left, right) {
+  const a = left ?? [];
+  const b = right ?? [];
+  if (a.length !== b.length) return false;
+  return a.every((info, index) => {
+    const other = b[index];
+    if (!other || info.specifier !== other.specifier || info.line !== other.line || info.kind !== other.kind || info.bindings.length !== other.bindings.length) {
+      return false;
+    }
+    return info.bindings.every((binding, bindingIndex) => {
+      const candidate = other.bindings[bindingIndex];
+      return candidate !== void 0 && binding.imported === candidate.imported && binding.local === candidate.local && binding.kind === candidate.kind;
     });
   });
 }
+function callsEqual(left, right) {
+  const a = left ?? [];
+  const b = right ?? [];
+  if (a.length !== b.length) return false;
+  return a.every((call, index) => {
+    const other = b[index];
+    return other !== void 0 && call.name === other.name && call.line === other.line && call.from === other.from && call.fromId === other.fromId && call.qualifier === other.qualifier;
+  });
+}
 async function findRepoRoot(startDir, maxLevels = 12) {
   let dir = path4.resolve(startDir);
   for (let level = 0; level < maxLevels; level++) {
@@ -690,56 +1279,6 @@ async function findRepoRoot(startDir, maxLevels = 12) {
   return null;
 }
 
-// src/types.ts
-function symbolCount(index) {
-  return index.files.reduce((n, f) => n + f.symbols.length, 0);
-}
-
-// src/search.ts
-function matchScore(name2, query) {
-  const q = query.toLowerCase();
-  const n = name2.toLowerCase();
-  if (n === q) return 1;
-  if (n.startsWith(q)) return 0.8;
-  if (n.includes(q)) return 0.5;
-  if (q.length >= 3 && isSubsequence(q, n)) return 0.3;
-  return 0;
-}
-function isSubsequence(query, name2) {
-  let i = 0;
-  for (const ch of name2) {
-    if (ch === query[i]) i++;
-    if (i === query.length) return true;
-  }
-  return false;
-}
-function searchSymbols(index, filter, limit = 50) {
-  const q = (filter.query ?? "").trim();
-  const filePat = filter.file?.trim().toLowerCase();
-  const hits = [];
-  for (const file of index.files) {
-    if (filePat && !file.path.toLowerCase().includes(filePat)) continue;
-    for (const sym of file.symbols) {
-      if (filter.kind && sym.kind !== filter.kind) continue;
-      if (filter.exportedOnly && !sym.exported) continue;
-      const score = q ? matchScore(sym.name, q) : 0.4;
-      if (q && score === 0) continue;
-      hits.push({ ...sym, score });
-    }
-  }
-  hits.sort((a, b) => {
-    const ab = Number(b.exported) - Number(a.exported) || b.score - a.score || a.name.localeCompare(b.name) || a.file.localeCompare(b.file);
-    return ab;
-  });
-  return hits.slice(0, limit);
-}
-function renderHit(hit) {
-  const exportMark = hit.exported ? "export " : "";
-  const sig = hit.signature || hit.name;
-  const score = hit.score < 1 ? ` [${hit.score.toFixed(2)}]` : "";
-  return `${exportMark}${hit.kind} ${sig}${score} \u2014 ${hit.file}:${hit.line}`;
-}
-
 // src/repomap.ts
 import path5 from "path";
 var KIND_WEIGHT = {
@@ -844,30 +1383,45 @@ function referencePageRank(files, density) {
   for (let i = 0; i < n; i++) result.set(nodes[i], rank[i]);
   return result;
 }
-function resolveImport(spec, fromPath, fileSet) {
-  if (!spec) return null;
+function resolveImportDetailed(spec, fromPath, fileSet) {
+  if (!spec) return { target: null, suffixSkipped: false };
   if (spec.startsWith("./") || spec.startsWith("../")) {
     const base = path5.posix.normalize(path5.posix.join(path5.posix.dirname(fromPath), spec));
-    return candidateFor(base, fileSet);
+    return { target: candidateFor(base, fileSet), suffixSkipped: false };
   }
   const segments = spec.split("/").filter(Boolean);
   for (let skip = 0; skip < segments.length; skip++) {
     const hit = candidateFor(segments.slice(skip).join("/"), fileSet);
-    if (hit) return hit;
+    if (hit) return { target: hit, suffixSkipped: skip > 0 };
   }
-  return null;
+  return { target: null, suffixSkipped: false };
+}
+function resolveImport(spec, fromPath, fileSet) {
+  return resolveImportDetailed(spec, fromPath, fileSet).target;
 }
 function candidateFor(base, fileSet) {
   if (fileSet.has(base)) return base;
   for (const ext of SUPPORTED_EXTS) {
     if (fileSet.has(`${base}${ext}`)) return `${base}${ext}`;
   }
+  const aliased = tsSourceForJsSpecifier(base, fileSet);
+  if (aliased) return aliased;
   for (const ext of SUPPORTED_EXTS) {
     if (fileSet.has(`${base}/index${ext}`)) return `${base}/index${ext}`;
     if (fileSet.has(`${base}/__init__${ext}`)) return `${base}/__init__${ext}`;
   }
   return null;
 }
+function tsSourceForJsSpecifier(base, fileSet) {
+  const match = /\.(js|jsx|mjs|cjs)$/.exec(base);
+  if (!match) return null;
+  const stem = base.slice(0, base.length - match[0].length);
+  const candidates = match[1] === "jsx" ? [".tsx", ".ts"] : match[1] === "mjs" ? [".mts", ".ts"] : match[1] === "cjs" ? [".cts", ".ts"] : [".ts", ".tsx"];
+  for (const ext of candidates) {
+    if (fileSet.has(`${stem}${ext}`)) return `${stem}${ext}`;
+  }
+  return null;
+}
 function renderRepoMap(entries, options = {}) {
   const maxChars = options.maxChars ?? 3200;
   const lines = ["# repo map"];
@@ -888,67 +1442,1341 @@ function renderRepoMap(entries, options = {}) {
   return totalSymbols > 0 ? text : "";
 }
 
-// src/tools.ts
-import { defineTool } from "@deepseek-ai/dsh-tools";
-import path6 from "path";
-
-// src/config.ts
-var DEFAULTS = {
-  excludeDirs: [],
-  mapTopFiles: 24,
-  mapMaxChars: 3200,
-  mapTtlMs: 6e4,
-  autoInject: true
-};
-var state = { current: { ...DEFAULTS } };
-function applyConfig(partial) {
-  state.current = {
-    ...DEFAULTS,
-    ...partial ?? {},
-    excludeDirs: [...DEFAULTS.excludeDirs, ...partial?.excludeDirs ?? []]
-  };
-  if (!Number.isFinite(state.current.mapTopFiles) || state.current.mapTopFiles < 1) {
-    state.current.mapTopFiles = DEFAULTS.mapTopFiles;
-  }
-  if (!Number.isFinite(state.current.mapMaxChars) || state.current.mapMaxChars < 200) {
-    state.current.mapMaxChars = DEFAULTS.mapMaxChars;
+// src/refgraph.ts
+function buildSymbolTable(index) {
+  const table = /* @__PURE__ */ new Map();
+  for (const file of index.files) {
+    for (const symbol of file.symbols) {
+      const list = table.get(symbol.name);
+      if (list) list.push(symbol);
+      else table.set(symbol.name, [symbol]);
+    }
   }
-  if (!Number.isFinite(state.current.mapTtlMs) || state.current.mapTtlMs < 1e3) {
-    state.current.mapTtlMs = DEFAULTS.mapTtlMs;
+  for (const list of table.values()) {
+    list.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
   }
+  return table;
 }
-function getConfig() {
-  return state.current;
-}
-function indexOptions() {
-  return { excludeDirs: state.current.excludeDirs };
+function callerCounts(index) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const file of index.files) {
+    for (const call of file.calls ?? []) {
+      counts.set(call.name, (counts.get(call.name) ?? 0) + 1);
+    }
+  }
+  return counts;
 }
-
-// src/tools.ts
-function createIndexCache(load, ttlMs = 6e4, now = Date.now) {
-  const completed = /* @__PURE__ */ new Map();
-  const inFlight = /* @__PURE__ */ new Map();
-  let epoch = 0;
-  function startLoad(key, root, previous) {
-    const loadEpoch = epoch;
-    const begin = previous ? previous.catch(() => void 0).then(() => load(root)) : load(root);
-    const promise = begin.then((index) => {
-      if (loadEpoch === epoch) {
-        completed.delete(key);
-        completed.set(key, { index, at: now(), epoch: loadEpoch });
-        while (completed.size > 16) completed.delete(completed.keys().next().value);
+function symbolRefs(index, symbol, limit = 200) {
+  const table = buildSymbolTable(index);
+  const defs = table.get(symbol) ?? [];
+  const callers = [];
+  const calleeFirstLine = /* @__PURE__ */ new Map();
+  for (const file of index.files) {
+    for (const call of file.calls ?? []) {
+      if (call.name === symbol) {
+        callers.push({ file: file.path, line: call.line, from: call.from });
       }
-      return index;
-    }).finally(() => {
-      if (inFlight.get(key)?.promise === promise) inFlight.delete(key);
-    });
-    inFlight.set(key, { promise, epoch: loadEpoch });
-    return promise;
+      if (call.from === symbol && !calleeFirstLine.has(call.name)) {
+        calleeFirstLine.set(call.name, call.line);
+      }
+    }
   }
+  callers.sort(
+    (a, b) => a.file.localeCompare(b.file) || a.line - b.line || a.from.localeCompare(b.from)
+  );
+  const callees = [...calleeFirstLine.entries()].map(([name2, line]) => ({ name: name2, line, targets: table.get(name2) ?? [] })).sort((a, b) => a.line - b.line || a.name.localeCompare(b.name));
   return {
-    get(root, force = false) {
-      const resolvedRoot = path6.resolve(root);
-      const key = cacheKeyForRoot(resolvedRoot);
+    defs,
+    callers: callers.slice(0, limit),
+    callees: callees.slice(0, limit)
+  };
+}
+var DEFAULT_MAX_CANDIDATES = 8;
+function buildReferenceGraph(index, options = {}) {
+  const maxCandidates = options.maxCandidatesPerCall ?? DEFAULT_MAX_CANDIDATES;
+  const symbolsById = /* @__PURE__ */ new Map();
+  const symbolsByFile = /* @__PURE__ */ new Map();
+  for (const file of index.files) {
+    for (const symbol of file.symbols) symbolsById.set(symbol.id, symbol);
+    symbolsByFile.set(file.path, file.symbols);
+  }
+  const symbolsByName = buildSymbolTable(index);
+  const fileSet = new Set(index.files.map((file) => file.path));
+  const outgoing = /* @__PURE__ */ new Map();
+  const incoming = /* @__PURE__ */ new Map();
+  const moduleLevelEdges = [];
+  for (const file of index.files) {
+    for (const call of file.calls ?? []) {
+      const edges = resolveCallTargetsFor(
+        fileSet,
+        file,
+        call,
+        symbolsByName,
+        symbolsByFile,
+        maxCandidates
+      );
+      if (edges.length === 0) continue;
+      if (call.fromId) {
+        appendEdges(outgoing, call.fromId, edges);
+      } else {
+        moduleLevelEdges.push(...edges);
+      }
+      for (const edge of edges) appendEdges(incoming, edge.targetId, [edge]);
+    }
+  }
+  return { symbolsById, outgoing, incoming, moduleLevelEdges };
+}
+function resolveCallTargetsFor(fileSet, file, call, symbolsByName, symbolsByFile, maxCandidates) {
+  const named = symbolsByName.get(call.name) ?? [];
+  const qualified = call.qualifier !== null;
+  const imports = (file.importDetails ?? []).filter((info) => info.kind !== "reexport");
+  if (!qualified) {
+    const locals = named.filter((s) => s.file === file.path && lexicallyVisible(s, call));
+    if (locals.length > 0) {
+      const unique = locals.length === 1;
+      const owned = unique && isStructuralOwner(call, locals[0]);
+      const provenance = owned && call.fromId !== null ? "structural-owner" : "local-unique";
+      return toEdges(locals, call, file.path, provenance, owned ? "exact" : "name-only", maxCandidates);
+    }
+    const bound = [];
+    let directBinding = true;
+    let defaultBinding = false;
+    for (const info of imports) {
+      for (const binding of info.bindings) {
+        if (binding.local !== call.name) continue;
+        const isDefault = binding.kind === "default" || binding.imported === "default";
+        if (!isDefault && !isExplicitBinding(binding)) continue;
+        const resolved = resolveImportDetailed(info.specifier, file.path, fileSet);
+        const target = resolved.target;
+        if (!target) continue;
+        if (resolved.suffixSkipped) directBinding = false;
+        if (isDefault) {
+          defaultBinding = true;
+          const moduleSymbols = symbolsByFile.get(target) ?? [];
+          const nameMatches = moduleSymbols.filter((s) => s.name === binding.local);
+          bound.push(
+            ...nameMatches.length > 0 ? nameMatches : moduleSymbols.filter((s) => s.exported)
+          );
+          continue;
+        }
+        if (!isExplicitBinding(binding)) continue;
+        for (const def of symbolsByName.get(binding.imported) ?? []) {
+          if (def.file === target) bound.push(def);
+        }
+      }
+    }
+    if (bound.length > 0) {
+      const label = bound.length === 1 && directBinding && !defaultBinding ? "exact" : "import-scoped";
+      return toEdges(bound, call, file.path, "explicit-import-binding", label, maxCandidates);
+    }
+    const resolvedModules = /* @__PURE__ */ new Set();
+    for (const info of imports) {
+      const target = resolveImport(info.specifier, file.path, fileSet);
+      if (target && target !== file.path) resolvedModules.add(target);
+    }
+    const imported = named.filter((s) => resolvedModules.has(s.file));
+    if (imported.length > 0) {
+      return toEdges(
+        imported,
+        call,
+        file.path,
+        "resolved-import-module",
+        "import-scoped",
+        maxCandidates
+      );
+    }
+  }
+  if (qualified) {
+    const qualifier = call.qualifier;
+    const modules = /* @__PURE__ */ new Set();
+    for (const info of imports) {
+      const namespaceBound = info.bindings.some(
+        (b) => (b.kind === "namespace" || b.kind === "package") && b.local === qualifier
+      );
+      if (!namespaceBound) {
+        if (info.bindings.length > 0) continue;
+        if (specifierLastSegment(info.specifier) !== qualifier) continue;
+      }
+      const target = resolveImport(info.specifier, file.path, fileSet);
+      if (target && target !== file.path) modules.add(target);
+    }
+    const qualifiedTargets = named.filter((s) => modules.has(s.file));
+    if (qualifiedTargets.length > 0) {
+      return toEdges(
+        qualifiedTargets,
+        call,
+        file.path,
+        "namespace-import",
+        "import-scoped",
+        maxCandidates
+      );
+    }
+  }
+  if (named.length > 0) {
+    return toEdges(named, call, file.path, "global-name", "name-only", maxCandidates);
+  }
+  return [];
+}
+function toEdges(candidates, call, filePath, provenance, resolution, maxCandidates) {
+  const unique = dedupeSymbols(candidates);
+  const count = unique.length;
+  const cap = maxCandidates > 0 ? Math.floor(maxCandidates) : 0;
+  return unique.slice(0, cap).map((target) => ({
+    sourceId: call.fromId,
+    targetId: target.id,
+    callSite: { file: filePath, line: call.line },
+    name: call.name,
+    provenance,
+    resolution,
+    candidateCount: count
+  }));
+}
+function appendEdges(map, key, edges) {
+  const list = map.get(key);
+  if (list) list.push(...edges);
+  else map.set(key, [...edges]);
+}
+function dedupeSymbols(candidates) {
+  const sorted = [...candidates].sort(compareSymbols);
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const symbol of sorted) {
+    if (seen.has(symbol.id)) continue;
+    seen.add(symbol.id);
+    out.push(symbol);
+  }
+  return out;
+}
+function compareSymbols(a, b) {
+  return a.file.localeCompare(b.file) || a.line - b.line || a.kind.localeCompare(b.kind) || a.name.localeCompare(b.name) || a.id.localeCompare(b.id);
+}
+function lexicallyVisible(candidate, call) {
+  if (call.fromId) {
+    const ownerPath = pathAfterHash(call.fromId);
+    const scopePath = containerPath(candidate.id);
+    if (scopePath === "") return true;
+    return ownerPath === scopePath || ownerPath.startsWith(`${scopePath}/`);
+  }
+  if (candidate.scope.length === 0) return true;
+  return candidate.line <= call.line && call.line <= candidate.endLine;
+}
+function isStructuralOwner(call, target) {
+  if (!call.fromId) return containerPath(target.id) === "";
+  if (target.id === call.fromId) return true;
+  return containerPath(target.id) === pathAfterHash(call.fromId);
+}
+function pathAfterHash(id) {
+  const hash = id.indexOf("#");
+  return hash >= 0 ? id.slice(hash + 1) : id;
+}
+function containerPath(id) {
+  const full = pathAfterHash(id);
+  const slash = full.lastIndexOf("/");
+  return slash >= 0 ? full.slice(0, slash) : "";
+}
+function isExplicitBinding(binding) {
+  return binding.imported != null && binding.imported !== "*" && binding.imported !== "default";
+}
+function specifierLastSegment(specifier) {
+  const clean = specifier.split(/[?#]/)[0] ?? specifier;
+  const segment = clean.split("/").filter(Boolean).pop() ?? clean;
+  return segment.replace(/\.[A-Za-z0-9]+$/, "");
+}
+
+// src/search.ts
+function matchScore(name2, query) {
+  const q = query.toLowerCase();
+  const n = name2.toLowerCase();
+  if (n === q) return 1;
+  if (n.startsWith(q)) return 0.8;
+  if (n.includes(q)) return 0.5;
+  if (q.length >= 3 && isSubsequence(q, n)) return 0.3;
+  return 0;
+}
+function isSubsequence(query, name2) {
+  let i = 0;
+  for (const ch of name2) {
+    if (ch === query[i]) i++;
+    if (i === query.length) return true;
+  }
+  return false;
+}
+function searchSymbols(index, filter, limit = 50) {
+  const q = (filter.query ?? "").trim();
+  const filePat = filter.file?.trim().toLowerCase();
+  const hits = [];
+  for (const file of index.files) {
+    if (filePat && !file.path.toLowerCase().includes(filePat)) continue;
+    for (const sym of file.symbols) {
+      if (filter.kind && sym.kind !== filter.kind) continue;
+      if (filter.exportedOnly && !sym.exported) continue;
+      const score = q ? matchScore(sym.name, q) : 0.4;
+      if (q && score === 0) continue;
+      hits.push({ ...sym, score });
+    }
+  }
+  const refs = callerCounts(index);
+  hits.sort((a, b) => {
+    const ab = Number(b.exported) - Number(a.exported) || b.score - a.score || (refs.get(b.name) ?? 0) - (refs.get(a.name) ?? 0) || a.name.localeCompare(b.name) || a.file.localeCompare(b.file);
+    return ab;
+  });
+  return hits.slice(0, limit);
+}
+function renderHit(hit) {
+  const exportMark = hit.exported ? "export " : "";
+  const sig = hit.signature || hit.name;
+  const score = hit.score < 1 ? ` [${hit.score.toFixed(2)}]` : "";
+  return `${exportMark}${hit.kind} ${sig}${score} \u2014 ${hit.file}:${hit.line}`;
+}
+
+// src/health.ts
+function buildModuleGraph(index) {
+  const nodes = index.files.map((file) => file.path).sort((a, b) => a.localeCompare(b));
+  const fileSet = new Set(nodes);
+  const edges = /* @__PURE__ */ new Map();
+  for (const file of index.files) {
+    const targets = /* @__PURE__ */ new Set();
+    for (const spec of file.imports ?? []) {
+      const target = resolveImport(spec, file.path, fileSet);
+      if (target && target !== file.path) targets.add(target);
+    }
+    edges.set(file.path, targets);
+  }
+  return { nodes, edges };
+}
+function findCycles(index) {
+  const { nodes, edges } = buildModuleGraph(index);
+  const discovery = /* @__PURE__ */ new Map();
+  const low = /* @__PURE__ */ new Map();
+  const onStack = /* @__PURE__ */ new Set();
+  const stack = [];
+  const components = [];
+  let counter = 0;
+  const visit = (node) => {
+    discovery.set(node, counter);
+    low.set(node, counter);
+    counter++;
+    stack.push(node);
+    onStack.add(node);
+    for (const next of edges.get(node) ?? []) {
+      if (!discovery.has(next)) {
+        visit(next);
+        low.set(node, Math.min(low.get(node), low.get(next)));
+      } else if (onStack.has(next)) {
+        low.set(node, Math.min(low.get(node), discovery.get(next)));
+      }
+    }
+    if (low.get(node) === discovery.get(node)) {
+      const component = [];
+      for (; ; ) {
+        const member = stack.pop();
+        onStack.delete(member);
+        component.push(member);
+        if (member === node) break;
+      }
+      if (component.length > 1) components.push(component.sort());
+    }
+  };
+  for (const node of nodes) {
+    if (!discovery.has(node)) visit(node);
+  }
+  components.sort((a, b) => a[0].localeCompare(b[0]));
+  return components;
+}
+var ENTRY_RE = /(^|\/)(index|main|cli|app|server|mod|lib|__init__)\.[A-Za-z0-9]+$|(^|\/)(bin|cmd|scripts)\/|\.config\.[A-Za-z0-9]+$/;
+var TEST_RE = /(^|\/)(tests?|__tests__)(\/|$)|\.(?:spec|test)\.[cm]?[jt]sx?$|(^|\/)(?:test_[^/]+\.py|[^/]+_test\.(?:py|go))$/;
+function findOrphanModules(index) {
+  const { nodes, edges } = buildModuleGraph(index);
+  const incoming = /* @__PURE__ */ new Map();
+  for (const targets of edges.values()) {
+    for (const target of targets) incoming.set(target, (incoming.get(target) ?? 0) + 1);
+  }
+  const withSymbols = new Set(
+    index.files.filter((file) => file.symbols.length > 0).map((file) => file.path)
+  );
+  return nodes.filter(
+    (path9) => withSymbols.has(path9) && (incoming.get(path9) ?? 0) === 0 && (edges.get(path9)?.size ?? 0) === 0 && !ENTRY_RE.test(path9) && !TEST_RE.test(path9)
+  );
+}
+
+// src/git-diff.ts
+import { execFile } from "child_process";
+import { readFile as readFile4 } from "fs/promises";
+import path6 from "path";
+var HUNK_RE = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+var HEADER_PATH_PREFIX_RE = /^[ab]\//;
+var MAX_BUFFER = 64 * 1024 * 1024;
+function newDraft() {
+  return {
+    oldPath: null,
+    newPath: null,
+    gitOldPath: null,
+    gitNewPath: null,
+    sawOldHeader: false,
+    sawNewHeader: false,
+    renameFrom: null,
+    renameTo: null,
+    newFile: false,
+    deletedFile: false,
+    hunks: [],
+    sawHunk: false
+  };
+}
+function parseUnifiedDiff(text) {
+  const changes = [];
+  let draft = null;
+  for (const line of text.split("\n")) {
+    if (line.startsWith("diff --git ")) {
+      if (draft) changes.push(finalize(draft));
+      draft = newDraft();
+      const [rawOld, rawNew] = splitDiffGitPaths(line.slice("diff --git ".length));
+      draft.gitOldPath = rawOld === null ? null : parseHeaderPath(rawOld);
+      draft.gitNewPath = rawNew === null ? null : parseHeaderPath(rawNew);
+      continue;
+    }
+    if (!draft) {
+      if (!isFileLine(line)) continue;
+      draft = newDraft();
+    }
+    if (line.startsWith("new file mode ")) {
+      draft.newFile = true;
+    } else if (line.startsWith("deleted file mode ")) {
+      draft.deletedFile = true;
+    } else if (line.startsWith("rename from ")) {
+      draft.renameFrom = parseRawPath(line.slice("rename from ".length));
+    } else if (line.startsWith("rename to ")) {
+      draft.renameTo = parseRawPath(line.slice("rename to ".length));
+    } else if (!draft.sawHunk && line.startsWith("--- ")) {
+      draft.oldPath = parseHeaderPath(line.slice(4));
+      draft.sawOldHeader = true;
+    } else if (!draft.sawHunk && line.startsWith("+++ ")) {
+      draft.newPath = parseHeaderPath(line.slice(4));
+      draft.sawNewHeader = true;
+    } else if (line.startsWith("@@ ")) {
+      const hunk = parseHunk(line);
+      if (hunk) {
+        draft.hunks.push(hunk);
+        draft.sawHunk = true;
+      }
+    }
+  }
+  if (draft) changes.push(finalize(draft));
+  return changes;
+}
+function isFileLine(line) {
+  return line.startsWith("--- ") || line.startsWith("+++ ") || line.startsWith("@@ ") || line.startsWith("new file mode ") || line.startsWith("deleted file mode ") || line.startsWith("rename from ") || line.startsWith("rename to ");
+}
+function finalize(draft) {
+  let oldPath = draft.renameFrom ?? (draft.sawOldHeader ? draft.oldPath : draft.gitOldPath);
+  let newPath = draft.renameTo ?? (draft.sawNewHeader ? draft.newPath : draft.gitNewPath);
+  if (draft.newFile) oldPath = null;
+  if (draft.deletedFile) newPath = null;
+  let status = "modified";
+  if (draft.newFile || oldPath === null && newPath !== null && draft.renameFrom === null) {
+    status = "added";
+  } else if (draft.deletedFile || newPath === null && oldPath !== null && draft.renameTo === null) {
+    status = "deleted";
+  } else if (draft.renameFrom !== null || draft.renameTo !== null) {
+    status = "renamed";
+  }
+  return { oldPath, newPath, status, hunks: draft.hunks };
+}
+function splitDiffGitPaths(rest) {
+  const tokens = [];
+  let index = 0;
+  while (index < rest.length && tokens.length < 2) {
+    while (index < rest.length && rest[index] === " ") index++;
+    if (index >= rest.length) break;
+    const start = index;
+    if (rest[index] === '"') {
+      index++;
+      while (index < rest.length) {
+        if (rest[index] === "\\") index += 2;
+        else if (rest[index] === '"') {
+          index++;
+          break;
+        } else index++;
+      }
+    } else {
+      while (index < rest.length && rest[index] !== " ") index++;
+    }
+    tokens.push(rest.slice(start, index));
+  }
+  return [tokens[0] ?? null, tokens[1] ?? null];
+}
+function parseHunk(line) {
+  const match = HUNK_RE.exec(line);
+  if (!match) return null;
+  const oldCount = match[2];
+  const newCount = match[4];
+  return {
+    oldStart: Number(match[1]),
+    oldLines: oldCount === void 0 ? 1 : Number(oldCount),
+    newStart: Number(match[3]),
+    newLines: newCount === void 0 ? 1 : Number(newCount)
+  };
+}
+function parseHeaderPath(raw) {
+  let value = raw;
+  const tab = value.indexOf("	");
+  if (tab >= 0) value = value.slice(0, tab);
+  value = value.trim();
+  if (value === "/dev/null") return null;
+  if (value.startsWith('"')) value = unquoteGitPath(value);
+  value = value.replace(HEADER_PATH_PREFIX_RE, "");
+  return value.length > 0 ? value : null;
+}
+function parseRawPath(raw) {
+  let value = raw.trim();
+  if (value.startsWith('"')) value = unquoteGitPath(value);
+  return value.length > 0 ? value : null;
+}
+function unquoteGitPath(value) {
+  const inner = value.slice(1, -1);
+  const bytes = [];
+  for (let i = 0; i < inner.length; i++) {
+    const ch = inner[i];
+    if (ch !== "\\") {
+      bytes.push(...Buffer.from(ch, "utf8"));
+      continue;
+    }
+    i++;
+    const esc = inner[i];
+    if (esc === void 0) break;
+    if (esc >= "0" && esc <= "7") {
+      let octal = esc;
+      let next = inner[i + 1];
+      while (octal.length < 3 && next !== void 0 && next >= "0" && next <= "7") {
+        octal += next;
+        i++;
+        next = inner[i + 1];
+      }
+      bytes.push(parseInt(octal, 8));
+      continue;
+    }
+    switch (esc) {
+      case "n":
+        bytes.push(10);
+        break;
+      case "t":
+        bytes.push(9);
+        break;
+      case "r":
+        bytes.push(13);
+        break;
+      case "f":
+        bytes.push(12);
+        break;
+      case "v":
+        bytes.push(11);
+        break;
+      case "b":
+        bytes.push(8);
+        break;
+      case "a":
+        bytes.push(7);
+        break;
+      case '"':
+        bytes.push(34);
+        break;
+      case "\\":
+        bytes.push(92);
+        break;
+      default:
+        bytes.push(...Buffer.from(esc, "utf8"));
+    }
+  }
+  return Buffer.from(bytes).toString("utf8");
+}
+function requireSafeRef(ref, label) {
+  if (ref.length === 0) throw new Error(`${label} must not be empty`);
+  if (ref.startsWith("-")) throw new Error(`${label} must not start with '-': ${ref}`);
+}
+function runGit(args, cwd) {
+  return new Promise((resolve, reject) => {
+    execFile("git", args, { cwd, encoding: "utf8", maxBuffer: MAX_BUFFER }, (error, stdout) => {
+      if (error) reject(error);
+      else resolve(stdout);
+    });
+  });
+}
+async function readWorkingTreeDiff(root, baseRef) {
+  requireSafeRef(baseRef, "baseRef");
+  const tracked = await runGit(
+    ["diff", "--no-ext-diff", "--find-renames", "--unified=0", baseRef, "--", "."],
+    root
+  );
+  const untracked = await runGit(["ls-files", "--others", "--exclude-standard", "-z", "--"], root);
+  const changes = parseUnifiedDiff(tracked);
+  const untrackedFiles = [];
+  for (const rawPath of untracked.split("\0")) {
+    if (rawPath.length === 0) continue;
+    const normalized = rawPath.replace(/\\/g, "/");
+    if (normalized === ".dsh-code-index" || normalized.startsWith(".dsh-code-index/")) continue;
+    try {
+      const content = await readFile4(path6.resolve(root, normalized), "utf8");
+      const lines = content.length === 0 ? 0 : content.split(/\r?\n/).length - (content.endsWith("\n") ? 1 : 0);
+      untrackedFiles.push({ path: normalized, content, lines });
+    } catch {
+    }
+  }
+  const paired = /* @__PURE__ */ new Set();
+  for (const change of changes) {
+    if (change.status !== "deleted" || change.oldPath === null) continue;
+    let oldContent;
+    try {
+      oldContent = await runGit(["show", `${baseRef}:${change.oldPath}`], root);
+    } catch {
+      continue;
+    }
+    const match = untrackedFiles.find((file) => !paired.has(file.path) && file.content === oldContent);
+    if (!match) continue;
+    change.newPath = match.path;
+    change.status = "renamed";
+    change.hunks = [];
+    paired.add(match.path);
+  }
+  for (const file of untrackedFiles) {
+    if (paired.has(file.path)) continue;
+    changes.push({
+      oldPath: null,
+      newPath: file.path,
+      status: "added",
+      hunks: file.lines > 0 ? [{ oldStart: 0, oldLines: 0, newStart: 1, newLines: file.lines }] : []
+    });
+  }
+  return renderNormalizedDiff(changes);
+}
+function renderNormalizedDiff(changes) {
+  return changes.map((change) => {
+    const oldPath = change.oldPath ?? change.newPath;
+    const newPath = change.newPath ?? change.oldPath;
+    const lines = [`diff --git ${diffToken(`a/${oldPath}`)} ${diffToken(`b/${newPath}`)}`];
+    if (change.status === "added") lines.push("new file mode 100644");
+    if (change.status === "deleted") lines.push("deleted file mode 100644");
+    if (change.status === "renamed") {
+      lines.push("similarity index 100%", `rename from ${diffToken(change.oldPath)}`, `rename to ${diffToken(change.newPath)}`);
+    } else {
+      lines.push(`--- ${change.oldPath === null ? "/dev/null" : diffToken(`a/${change.oldPath}`)}`);
+      lines.push(`+++ ${change.newPath === null ? "/dev/null" : diffToken(`b/${change.newPath}`)}`);
+    }
+    for (const hunk of change.hunks) {
+      const oldCount = hunk.oldLines === 1 ? "" : `,${hunk.oldLines}`;
+      const newCount = hunk.newLines === 1 ? "" : `,${hunk.newLines}`;
+      lines.push(`@@ -${hunk.oldStart}${oldCount} +${hunk.newStart}${newCount} @@`);
+    }
+    return `${lines.join("\n")}
+`;
+  }).join("");
+}
+function diffToken(value) {
+  return /[\s"]/.test(value) ? `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"` : value;
+}
+async function readGitFileAtRef(root, ref, repoRelativePath) {
+  requireSafeRef(ref, "ref");
+  try {
+    return await runGit(["show", `${ref}:${repoRelativePath}`], root);
+  } catch {
+    return null;
+  }
+}
+
+// src/change-context.ts
+import path7 from "path";
+var LABEL_STRENGTH = {
+  exact: 3,
+  "import-scoped": 2,
+  "name-only": 1
+};
+var ENTRY_KINDS = /* @__PURE__ */ new Set(["function", "method", "class"]);
+var ENTRY_FILE_RE = /(^|\/)(main|index|cli|server|app)\.[^./]+$/;
+var TEST_RE2 = /(^|\/)(tests?|__tests__)(\/|$)|\.(?:spec|test)\.[cm]?[jt]sx?$|(^|\/)(?:test_[^/]+\.py|[^/]+_test\.(?:py|go))$/;
+function changeContextInputFromArgs(args, root) {
+  const hasDiff = typeof args.diff === "string" && args.diff.trim().length > 0;
+  const hasFiles = Array.isArray(args.files) && args.files.length > 0;
+  const hasSymbols = Array.isArray(args.symbols) && args.symbols.length > 0;
+  if ([hasDiff, hasFiles, hasSymbols].filter(Boolean).length > 1) {
+    throw new Error("pass only one of diff, files, symbols");
+  }
+  const suppliedBaseRef = typeof args.baseRef === "string" && args.baseRef.length > 0 ? args.baseRef : void 0;
+  if (hasDiff) {
+    return suppliedBaseRef === void 0 ? { kind: "diff", root, text: args.diff } : { kind: "diff", root, text: args.diff, baseRef: suppliedBaseRef };
+  }
+  if (hasFiles) return { kind: "files", files: args.files.map(requireSafePath) };
+  if (hasSymbols) return { kind: "symbols", symbolIds: [...args.symbols] };
+  return { kind: "git", root, baseRef: suppliedBaseRef ?? "HEAD" };
+}
+function requireSafePath(raw) {
+  const value = raw.replace(/\\/g, "/").trim();
+  if (value.length === 0) throw new Error("file path must not be empty");
+  if (value.startsWith("/") || /^[A-Za-z]:\//.test(value)) {
+    throw new Error(`absolute file path not allowed: ${raw}`);
+  }
+  if (/(^|\/)\.\.(\/|$)/.test(value)) throw new Error(`path must stay inside the repo: ${raw}`);
+  return value.replace(/^\.\//, "");
+}
+function clamp(value, lo, hi, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  return Math.min(hi, Math.max(lo, Math.floor(value)));
+}
+function weakest(labels) {
+  let out = "exact";
+  for (const label of labels) {
+    if (LABEL_STRENGTH[label] < LABEL_STRENGTH[out]) out = label;
+  }
+  return out;
+}
+function symbolLabel(symbol) {
+  return `${symbol.kind} ${symbol.signature || symbol.name}`;
+}
+async function buildChangeContext(index, input, options = {}) {
+  const maxDepth = clamp(options.maxDepth, 1, 6, 3);
+  const maxImpact = clamp(options.maxImpact, 1, 200, 40);
+  const maxPaths = clamp(options.maxPaths, 1, 50, 10);
+  const maxTests = clamp(options.maxTests, 1, 100, 20);
+  const graph = buildReferenceGraph(index);
+  const moduleGraph = buildModuleGraph(index);
+  const filesByPath = new Map(index.files.map((file) => [file.path, file]));
+  const fileSet = new Set(filesByPath.keys());
+  const incomingCount = /* @__PURE__ */ new Map();
+  for (const [id, edges] of graph.incoming) incomingCount.set(id, edges.length);
+  const warnings = [];
+  const changedByKey = /* @__PURE__ */ new Map();
+  const unmapped = [];
+  const changedFiles = /* @__PURE__ */ new Set();
+  const commandRoot = input.kind === "git" || input.kind === "diff" ? input.root : index.root;
+  if (path7.resolve(commandRoot) !== path7.resolve(index.root)) {
+    warnings.push(
+      `command root ${path7.resolve(commandRoot)} differs from indexed root ${index.root}; using the cached index`
+    );
+  }
+  const addChanged = (symbol, change, side) => {
+    const key = `${side}:${symbol.id}`;
+    if (!changedByKey.has(key)) changedByKey.set(key, { symbol, change, side, resolution: "exact" });
+  };
+  const addUnmapped = (file, side, ranges, reason) => {
+    if (ranges.length > 0) unmapped.push({ file, side, ranges, reason });
+  };
+  let baseRef;
+  if (input.kind === "files") {
+    for (const filePath of input.files) {
+      const file = filesByPath.get(filePath);
+      if (!file) {
+        warnings.push(`file not in index: ${filePath}`);
+        continue;
+      }
+      changedFiles.add(file.path);
+      for (const symbol of file.symbols) addChanged(symbol, "modified", "current");
+      if (file.symbols.length === 0) warnings.push(`no indexed symbols in changed file: ${filePath}`);
+    }
+  } else if (input.kind === "symbols") {
+    for (const id of input.symbolIds) {
+      const symbol = graph.symbolsById.get(id);
+      if (!symbol) {
+        warnings.push(`symbol not in index: ${id}`);
+        continue;
+      }
+      changedFiles.add(symbol.file);
+      addChanged(symbol, "modified", "current");
+    }
+  } else {
+    let text;
+    if (input.kind === "git") {
+      baseRef = input.baseRef;
+      text = await readWorkingTreeDiff(input.root, input.baseRef);
+    } else {
+      text = input.text;
+      baseRef = input.baseRef;
+    }
+    const changes = parseUnifiedDiff(text).map((change) => ({
+      ...change,
+      oldPath: change.oldPath === null ? null : requireSafePath(change.oldPath),
+      newPath: change.newPath === null ? null : requireSafePath(change.newPath)
+    }));
+    if (changes.length === 0) warnings.push("no changes found in the diff");
+    const baseSymbolsCache = /* @__PURE__ */ new Map();
+    const readBaseSymbols = (filePath) => {
+      const cached = baseSymbolsCache.get(filePath);
+      if (cached) return cached;
+      const pending = (async () => {
+        if (baseRef === void 0) return null;
+        const content = await readGitFileAtRef(commandRoot, baseRef, filePath);
+        if (content === null) return null;
+        const lang = languageForFile(filePath);
+        if (!lang) return null;
+        const extracted = await extractAll(content, lang, filePath);
+        return extracted.symbols;
+      })();
+      baseSymbolsCache.set(filePath, pending);
+      return pending;
+    };
+    const symbolsByPath = new Map(index.files.map((file) => [file.path, file.symbols]));
+    await mapDiffChanges(
+      changes,
+      symbolsByPath,
+      addChanged,
+      addUnmapped,
+      changedFiles,
+      readBaseSymbols,
+      warnings
+    );
+  }
+  const changedSymbols = [...changedByKey.values()].sort(compareChanged);
+  const callerById = /* @__PURE__ */ new Map();
+  for (const changed of changedSymbols) {
+    for (const edge of graph.incoming.get(changed.symbol.id) ?? []) {
+      if (edge.sourceId === null) continue;
+      const caller = graph.symbolsById.get(edge.sourceId);
+      if (!caller) continue;
+      const row = {
+        symbol: caller,
+        depth: 1,
+        via: hopOf(edge),
+        resolution: edge.resolution
+      };
+      const existing = callerById.get(caller.id);
+      if (!existing || LABEL_STRENGTH[row.resolution] > LABEL_STRENGTH[existing.resolution]) {
+        callerById.set(caller.id, row);
+      }
+    }
+  }
+  const allCallers = [...callerById.values()].sort(compareBySymbol);
+  const changedIds = new Set(changedSymbols.map((changed) => changed.symbol.id));
+  const impactById = /* @__PURE__ */ new Map();
+  {
+    const depthById = /* @__PURE__ */ new Map();
+    const strengthById = /* @__PURE__ */ new Map();
+    for (const id of changedIds) {
+      depthById.set(id, 0);
+      strengthById.set(id, "exact");
+    }
+    let frontier = [...changedIds];
+    for (let depth = 0; depth < maxDepth; depth++) {
+      const next = [];
+      for (const id of frontier) {
+        const pathStrength = strengthById.get(id) ?? "exact";
+        for (const edge of graph.incoming.get(id) ?? []) {
+          if (edge.sourceId === null || changedIds.has(edge.sourceId)) continue;
+          const caller = graph.symbolsById.get(edge.sourceId);
+          if (!caller) continue;
+          const cumulative = weakest([pathStrength, edge.resolution]);
+          const row = {
+            symbol: caller,
+            depth: depth + 1,
+            via: hopOf(edge),
+            resolution: cumulative
+          };
+          const seen = depthById.get(edge.sourceId);
+          if (seen === void 0) {
+            depthById.set(edge.sourceId, depth + 1);
+            strengthById.set(edge.sourceId, cumulative);
+            next.push(edge.sourceId);
+            if (depth + 1 >= 2) impactById.set(edge.sourceId, row);
+          } else if (seen === depth + 1) {
+            const previous = strengthById.get(edge.sourceId) ?? "exact";
+            if (LABEL_STRENGTH[cumulative] > LABEL_STRENGTH[previous]) {
+              strengthById.set(edge.sourceId, cumulative);
+              if (depth + 1 >= 2) impactById.set(edge.sourceId, row);
+            }
+          }
+        }
+      }
+      frontier = next;
+    }
+  }
+  const allImpact = [...impactById.values()].sort(compareByDepthThenSymbol);
+  const allPaths = [];
+  const pathKey = /* @__PURE__ */ new Set();
+  for (const changed of changedSymbols) {
+    for (const found of pathsToEntryPoints(changed.symbol, graph, incomingCount, maxDepth)) {
+      const key = `${found.entry.id}\0${found.changed.id}`;
+      if (pathKey.has(key)) continue;
+      pathKey.add(key);
+      allPaths.push(found);
+    }
+  }
+  allPaths.sort(comparePaths);
+  const importDependents = collectImportDependents(index, moduleGraph, fileSet, changedFiles);
+  const allTests = collectAffectedTests(
+    index,
+    moduleGraph,
+    changedFiles,
+    changedSymbols,
+    [...allCallers, ...allImpact]
+  );
+  const truncated = {
+    callers: allCallers.length > maxImpact,
+    dependents: importDependents.length > maxImpact,
+    paths: allPaths.length > maxPaths,
+    impact: allImpact.length > maxImpact,
+    tests: allTests.length > maxTests
+  };
+  return {
+    root: index.root,
+    source: input.kind,
+    ...baseRef !== void 0 ? { baseRef } : {},
+    changed: changedSymbols,
+    unmapped: unmapped.sort(compareUnmapped),
+    directCallers: allCallers.slice(0, maxImpact),
+    importDependents: importDependents.slice(0, maxImpact),
+    paths: allPaths.slice(0, maxPaths),
+    impact: allImpact.slice(0, maxImpact),
+    tests: allTests.slice(0, maxTests),
+    warnings,
+    truncated
+  };
+}
+function hopOf(edge) {
+  return {
+    fromId: edge.sourceId,
+    toId: edge.targetId,
+    callSite: edge.callSite,
+    resolution: edge.resolution,
+    reason: edge.provenance
+  };
+}
+async function mapDiffChanges(changes, symbolsByPath, addChanged, addUnmapped, changedFiles, readBaseSymbols, warnings) {
+  for (const change of changes) {
+    const { oldPath, newPath, hunks } = change;
+    if (newPath) changedFiles.add(newPath);
+    if (oldPath) changedFiles.add(oldPath);
+    const currentSymbols = newPath !== null && change.status !== "deleted" ? symbolsByPath.get(newPath) : void 0;
+    if (newPath !== null && change.status !== "deleted") {
+      const currentRanges = hunks.filter((hunk) => hunk.newLines > 0).map((hunk) => ({
+        startLine: hunk.newStart,
+        endLine: hunk.newStart + Math.max(hunk.newLines, 1) - 1
+      }));
+      if (currentRanges.length > 0 && currentSymbols) {
+        for (const range of currentRanges) {
+          for (const symbol of currentSymbols) {
+            if (intersects(symbol, range)) addChanged(symbol, change.status, "current");
+          }
+        }
+        const missed = currentRanges.filter(
+          (range) => !currentSymbols.some((symbol) => intersects(symbol, range))
+        );
+        addUnmapped(newPath, "current", missed, "outside-symbol");
+      } else if (currentRanges.length > 0) {
+        addUnmapped(newPath, "current", currentRanges, "outside-symbol");
+      }
+      if (change.status === "renamed" && hunks.length === 0) {
+        for (const symbol of currentSymbols ?? []) addChanged(symbol, "renamed", "current");
+        if (oldPath !== null) {
+          const oldSymbols = await readBaseSymbols(oldPath);
+          if (oldSymbols === null) {
+            warnings.push(`rename baseline unavailable: ${oldPath}`);
+          } else {
+            for (const symbol of oldSymbols) addChanged(symbol, "renamed", "base");
+          }
+        }
+      }
+    }
+    const deletionHunks = hunks.filter((hunk) => hunk.newLines === 0);
+    if (deletionHunks.length > 0 && oldPath !== null) {
+      const oldRanges = deletionHunks.map((hunk) => ({
+        startLine: hunk.oldStart,
+        endLine: hunk.oldStart + Math.max(hunk.oldLines, 1) - 1
+      }));
+      const oldSymbols = await readBaseSymbols(oldPath);
+      if (oldSymbols === null) {
+        addUnmapped(oldPath, "base", oldRanges, "base-content-unavailable");
+      } else {
+        const baseChange = change.status === "deleted" ? "deleted" : "modified";
+        for (const range of oldRanges) {
+          for (const symbol of oldSymbols) {
+            if (intersects(symbol, range)) addChanged(symbol, baseChange, "base");
+          }
+        }
+        const missed = oldRanges.filter(
+          (range) => !oldSymbols.some((symbol) => intersects(symbol, range))
+        );
+        addUnmapped(oldPath, "base", missed, "outside-symbol");
+      }
+    }
+    if (change.status === "renamed" && hunks.length === 0) {
+      warnings.push(`renamed with no content change: ${oldPath} -> ${newPath}`);
+    }
+  }
+}
+function intersects(symbol, range) {
+  return symbol.line <= range.endLine && symbol.endLine >= range.startLine;
+}
+function pathsToEntryPoints(changed, graph, incomingCount, maxDepth) {
+  const isEntry = (symbol) => {
+    if (ENTRY_FILE_RE.test(symbol.file)) return true;
+    if (!symbol.exported) return false;
+    if (symbol.kind === "variable") {
+      return symbol.scope.length === 0 || (incomingCount.get(symbol.id) ?? 0) === 0;
+    }
+    if (ENTRY_KINDS.has(symbol.kind)) return true;
+    return (incomingCount.get(symbol.id) ?? 0) === 0;
+  };
+  const found = [];
+  const depthById = /* @__PURE__ */ new Map([[changed.id, 0]]);
+  const strengthById = /* @__PURE__ */ new Map([[changed.id, "exact"]]);
+  const nextEdge = /* @__PURE__ */ new Map();
+  const entryIds = /* @__PURE__ */ new Set();
+  const queue = [changed.id];
+  while (queue.length > 0) {
+    const node = queue.shift();
+    const nodeDepth = depthById.get(node) ?? 0;
+    if (nodeDepth >= maxDepth) continue;
+    const nodeStrength = strengthById.get(node) ?? "exact";
+    for (const edge of graph.incoming.get(node) ?? []) {
+      if (edge.sourceId === null) continue;
+      const candidateDepth = nodeDepth + 1;
+      const cumulative = weakest([nodeStrength, edge.resolution]);
+      const existingDepth = depthById.get(edge.sourceId);
+      if (existingDepth === void 0) {
+        depthById.set(edge.sourceId, candidateDepth);
+        strengthById.set(edge.sourceId, cumulative);
+        nextEdge.set(edge.sourceId, hopOf(edge));
+        queue.push(edge.sourceId);
+      } else if (existingDepth === candidateDepth) {
+        const existingStrength = strengthById.get(edge.sourceId) ?? "exact";
+        if (LABEL_STRENGTH[cumulative] > LABEL_STRENGTH[existingStrength]) {
+          strengthById.set(edge.sourceId, cumulative);
+          nextEdge.set(edge.sourceId, hopOf(edge));
+          queue.push(edge.sourceId);
+        }
+      }
+      const entry = graph.symbolsById.get(edge.sourceId);
+      if (entry && isEntry(entry)) entryIds.add(edge.sourceId);
+    }
+  }
+  for (const entryId of entryIds) {
+    const entry = graph.symbolsById.get(entryId);
+    if (!entry) continue;
+    const hops = [];
+    let cursor = entryId;
+    const guard = /* @__PURE__ */ new Set();
+    while (cursor !== changed.id && !guard.has(cursor)) {
+      guard.add(cursor);
+      const hop = nextEdge.get(cursor);
+      if (!hop) break;
+      hops.push(hop);
+      cursor = hop.toId;
+    }
+    if (cursor === changed.id && hops.length > 0) {
+      found.push({
+        entry,
+        changed,
+        hops,
+        resolution: weakest(hops.map((hop) => hop.resolution))
+      });
+    }
+  }
+  return found;
+}
+function collectImportDependents(index, moduleGraph, fileSet, changedFiles) {
+  const filesByPath = new Map(index.files.map((file) => [file.path, file]));
+  const reverse = /* @__PURE__ */ new Map();
+  for (const [from, targets] of moduleGraph.edges) {
+    for (const target of targets) {
+      const importers = reverse.get(target) ?? /* @__PURE__ */ new Set();
+      importers.add(from);
+      reverse.set(target, importers);
+    }
+  }
+  const augmented = /* @__PURE__ */ new Set([...fileSet, ...changedFiles]);
+  let reverseImports = null;
+  const reverseImportIndex = () => {
+    if (reverseImports) return reverseImports;
+    const map = /* @__PURE__ */ new Map();
+    for (const file of index.files) {
+      for (const info of file.importDetails ?? []) {
+        const target = resolveImport(info.specifier, file.path, augmented);
+        if (target === null) continue;
+        const importers = map.get(target) ?? /* @__PURE__ */ new Set();
+        importers.add(file.path);
+        map.set(target, importers);
+      }
+    }
+    reverseImports = map;
+    return map;
+  };
+  const dependents = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const changedFile of [...changedFiles].sort((a, b) => a.localeCompare(b))) {
+    const importers = new Set(reverse.get(changedFile) ?? []);
+    let resolutionSet = fileSet;
+    if (!fileSet.has(changedFile)) {
+      resolutionSet = augmented;
+      for (const importerPath of reverseImportIndex().get(changedFile) ?? []) {
+        importers.add(importerPath);
+      }
+    }
+    for (const importerPath of [...importers].sort((a, b) => a.localeCompare(b))) {
+      const importer = filesByPath.get(importerPath);
+      if (!importer) continue;
+      const specifier = specifierFor(importer, changedFile, resolutionSet);
+      if (specifier === null) continue;
+      const key = `${importerPath}\0${changedFile}\0${specifier}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      dependents.push({
+        file: importerPath,
+        changedFile,
+        specifier,
+        resolution: "import-scoped"
+      });
+    }
+  }
+  return dependents.sort(
+    (a, b) => a.file.localeCompare(b.file) || a.changedFile.localeCompare(b.changedFile) || a.specifier.localeCompare(b.specifier)
+  );
+}
+function specifierFor(file, target, fileSet) {
+  for (const info of file.importDetails ?? []) {
+    if (resolveImport(info.specifier, file.path, fileSet) === target) return info.specifier;
+  }
+  for (const spec of file.imports ?? []) {
+    if (resolveImport(spec, file.path, fileSet) === target) return spec;
+  }
+  return null;
+}
+var TEST_RANK = {
+  "changed-test": 0,
+  "imports-changed-file": 1,
+  "imports-impact-file": 2,
+  "references-symbol-name": 3,
+  "path-convention": 4
+};
+function collectAffectedTests(index, moduleGraph, changedFiles, changedSymbols, impactRows) {
+  const changedNames = new Set(changedSymbols.map((changed) => changed.symbol.name));
+  const impactFileDepth = /* @__PURE__ */ new Map();
+  for (const row of impactRows) {
+    const previous = impactFileDepth.get(row.symbol.file);
+    if (previous === void 0 || row.depth < previous) {
+      impactFileDepth.set(row.symbol.file, row.depth);
+    }
+  }
+  const changedStems = new Set([...changedFiles].map(pathStem));
+  const tests = [];
+  for (const file of index.files) {
+    if (!TEST_RE2.test(file.path)) continue;
+    const imports = moduleGraph.edges.get(file.path) ?? /* @__PURE__ */ new Set();
+    if (changedFiles.has(file.path)) {
+      tests.push({ file: file.path, resolution: "exact", reason: "changed-test", distance: 0 });
+      continue;
+    }
+    const changedImport = [...imports].find(
+      (target) => changedFiles.has(target) && target !== file.path
+    );
+    if (changedImport !== void 0) {
+      tests.push({
+        file: file.path,
+        resolution: "import-scoped",
+        reason: "imports-changed-file",
+        distance: 1
+      });
+      continue;
+    }
+    const impactImports = [...imports].filter((target) => impactFileDepth.has(target)).sort((a, b) => (impactFileDepth.get(a) ?? 0) - (impactFileDepth.get(b) ?? 0));
+    if (impactImports.length > 0) {
+      tests.push({
+        file: file.path,
+        resolution: "import-scoped",
+        reason: "imports-impact-file",
+        distance: impactFileDepth.get(impactImports[0]) ?? 2
+      });
+      continue;
+    }
+    if ((file.calls ?? []).some((call) => changedNames.has(call.name))) {
+      tests.push({
+        file: file.path,
+        resolution: "name-only",
+        reason: "references-symbol-name",
+        distance: 1
+      });
+      continue;
+    }
+    if (changedStems.has(pathStem(file.path))) {
+      tests.push({ file: file.path, resolution: "name-only", reason: "path-convention" });
+    }
+  }
+  return tests.sort(
+    (a, b) => TEST_RANK[a.reason] - TEST_RANK[b.reason] || (a.distance ?? Number.MAX_SAFE_INTEGER) - (b.distance ?? Number.MAX_SAFE_INTEGER) || a.file.localeCompare(b.file)
+  );
+}
+function pathStem(filePath) {
+  const base = filePath.split("/").pop() ?? filePath;
+  return base.replace(/\.[A-Za-z0-9]+$/, "").replace(/\.(?:test|spec)$/, "").replace(/^test_/, "").replace(/_test$/, "");
+}
+function compareChanged(a, b) {
+  return a.side.localeCompare(b.side) || a.symbol.file.localeCompare(b.symbol.file) || a.symbol.line - b.symbol.line || a.symbol.id.localeCompare(b.symbol.id);
+}
+function compareBySymbol(a, b) {
+  return a.symbol.file.localeCompare(b.symbol.file) || a.symbol.line - b.symbol.line || a.symbol.id.localeCompare(b.symbol.id);
+}
+function compareByDepthThenSymbol(a, b) {
+  return a.depth - b.depth || LABEL_STRENGTH[b.resolution] - LABEL_STRENGTH[a.resolution] || compareBySymbol(a, b);
+}
+function comparePaths(a, b) {
+  return a.entry.file.localeCompare(b.entry.file) || a.entry.line - b.entry.line || a.changed.file.localeCompare(b.changed.file) || a.changed.line - b.changed.line || a.entry.id.localeCompare(b.entry.id);
+}
+function compareUnmapped(a, b) {
+  return a.file.localeCompare(b.file) || a.side.localeCompare(b.side);
+}
+function renderChangeContext(result, maxChars = 12e3) {
+  const sections = [
+    {
+      title: "CHANGED",
+      rows: result.changed.map(
+        (changed) => `${changed.change} ${changed.side === "base" ? "base " : ""}${symbolLabel(changed.symbol)} ${changed.symbol.file}:${changed.symbol.line} [${changed.resolution}]`
+      )
+    },
+    {
+      title: "DIRECT CALLERS",
+      rows: result.directCallers.map(
+        (row) => `${symbolLabel(row.symbol)} ${row.symbol.file}:${row.symbol.line} (called at ${row.via.callSite.file}:${row.via.callSite.line}) [${row.resolution}]`
+      )
+    },
+    {
+      title: "IMPORT DEPENDENTS",
+      rows: result.importDependents.map(
+        (dependent) => `${dependent.file} imports ${dependent.changedFile} ('${dependent.specifier}') [${dependent.resolution}]`
+      )
+    },
+    {
+      title: "SHORTEST PATHS TO ENTRY POINTS",
+      rows: result.paths.map(
+        (symbolPath) => `${symbolPath.entry.file}:${symbolPath.entry.line} ${symbolLabel(symbolPath.entry)} \u2192 ${symbolPath.changed.file}:${symbolPath.changed.line} ${symbolLabel(symbolPath.changed)} (${symbolPath.hops.length} hop(s)) [${symbolPath.resolution}]`
+      )
+    },
+    {
+      title: "TRANSITIVE IMPACT",
+      rows: result.impact.map(
+        (row) => `depth ${row.depth}: ${symbolLabel(row.symbol)} ${row.symbol.file}:${row.symbol.line} (reached via ${row.via.callSite.file}:${row.via.callSite.line}) [${row.resolution}]`
+      )
+    },
+    {
+      title: "LIKELY AFFECTED TESTS",
+      rows: result.tests.map(
+        (test) => `${test.file} (${test.reason}${test.distance !== void 0 ? `, distance ${test.distance}` : ""}) [${test.resolution}]`
+      )
+    },
+    {
+      title: "UNMAPPED",
+      rows: result.unmapped.map(
+        (entry) => `${entry.file} ${entry.side} lines ${entry.ranges.map((range) => `${range.startLine}-${range.endLine}`).join(", ")} (${entry.reason})`
+      )
+    }
+  ];
+  const summary = `change context \u2014 source: ${result.source}${result.baseRef !== void 0 ? ` (base ${result.baseRef})` : ""}: ${result.changed.length} changed symbol(s)`;
+  const warningLines = result.warnings.map((warning) => `- ${warning}`);
+  const render = (kept) => {
+    const lines = [summary];
+    sections.forEach((section, index) => {
+      if (section.rows.length === 0) {
+        lines.push(`${section.title}: (none)`);
+        return;
+      }
+      lines.push(`${section.title}:`);
+      const take = kept[index] ?? 0;
+      for (let row = 0; row < take; row++) lines.push(`  ${section.rows[row]}`);
+      if (take < section.rows.length) lines.push(`  \u2026 (${section.rows.length - take} more)`);
+    });
+    lines.push("WARNINGS:");
+    if (warningLines.length === 0) lines.push("  (none)");
+    else for (const warning of warningLines) lines.push(`  ${warning}`);
+    return lines.join("\n");
+  };
+  const flattened = [];
+  sections.forEach((section, index) => {
+    section.rows.forEach((text) => flattened.push({ section: index, text }));
+  });
+  const countsFor = (count) => {
+    const kept = sections.map(() => 0);
+    for (let index = 0; index < count; index++) kept[flattened[index].section]++;
+    return kept;
+  };
+  const total = flattened.length;
+  const full = render(sections.map((section) => section.rows.length));
+  if (full.length <= maxChars) return full;
+  const truncationNote = "\n\u2026 truncated rows to fit the character cap (raise maxChars or narrow the change)";
+  const headerOnly = render(countsFor(0));
+  if (headerOnly.length > maxChars) {
+    throw new Error(
+      `maxChars ${maxChars} is below the renderer minimum ${headerOnly.length} (section headers and warnings cannot be kept)`
+    );
+  }
+  if (headerOnly.length + truncationNote.length > maxChars) return headerOnly;
+  const fits = (count) => render(countsFor(count)).length + truncationNote.length <= maxChars;
+  let lo = 0;
+  let hi = total;
+  while (lo < hi) {
+    const mid = Math.ceil((lo + hi) / 2);
+    if (fits(mid)) lo = mid;
+    else hi = mid - 1;
+  }
+  let out = render(countsFor(lo));
+  if (lo < total) out += truncationNote;
+  return out;
+}
+
+// src/tools.ts
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import path8 from "path";
+
+// src/config.ts
+var DEFAULTS = {
+  excludeDirs: [],
+  mapTopFiles: 24,
+  mapMaxChars: 3200,
+  mapTtlMs: 6e4,
+  autoInject: true,
+  codeHealth: false
+};
+var state = { current: { ...DEFAULTS } };
+function applyConfig(partial) {
+  state.current = {
+    ...DEFAULTS,
+    ...partial ?? {},
+    excludeDirs: [...DEFAULTS.excludeDirs, ...partial?.excludeDirs ?? []]
+  };
+  if (!Number.isFinite(state.current.mapTopFiles) || state.current.mapTopFiles < 1) {
+    state.current.mapTopFiles = DEFAULTS.mapTopFiles;
+  }
+  if (!Number.isFinite(state.current.mapMaxChars) || state.current.mapMaxChars < 200) {
+    state.current.mapMaxChars = DEFAULTS.mapMaxChars;
+  }
+  if (!Number.isFinite(state.current.mapTtlMs) || state.current.mapTtlMs < 1e3) {
+    state.current.mapTtlMs = DEFAULTS.mapTtlMs;
+  }
+}
+function getConfig() {
+  return state.current;
+}
+function indexOptions() {
+  return { excludeDirs: state.current.excludeDirs };
+}
+
+// src/tools.ts
+function createIndexCache(load, ttlMs = 6e4, now = Date.now) {
+  const completed = /* @__PURE__ */ new Map();
+  const inFlight = /* @__PURE__ */ new Map();
+  let epoch = 0;
+  function startLoad(key, root, previous) {
+    const loadEpoch = epoch;
+    const begin = previous ? previous.catch(() => void 0).then(() => load(root)) : load(root);
+    const promise = begin.then((index) => {
+      if (loadEpoch === epoch) {
+        completed.delete(key);
+        completed.set(key, { index, at: now(), epoch: loadEpoch });
+        while (completed.size > 16) completed.delete(completed.keys().next().value);
+      }
+      return index;
+    }).finally(() => {
+      if (inFlight.get(key)?.promise === promise) inFlight.delete(key);
+    });
+    inFlight.set(key, { promise, epoch: loadEpoch });
+    return promise;
+  }
+  return {
+    get(root, force = false) {
+      const resolvedRoot = path8.resolve(root);
+      const key = cacheKeyForRoot(resolvedRoot);
       const running = inFlight.get(key);
       if (running) {
         if (running.epoch === epoch && !force) return running.promise;
@@ -984,13 +2812,45 @@ async function resolveRoot(arg, exec) {
   const cwd = exec.agent?.session?.header?.cwd;
   const base = arg ?? cwd ?? process.cwd();
   const root = await findRepoRoot(base);
-  if (!root) throw new Error(`no git repository found from ${path6.resolve(base)}`);
+  if (!root) throw new Error(`no git repository found from ${path8.resolve(base)}`);
   return root;
 }
+function hitsToSearchMeta(hits) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const raw of hits) {
+    const hit = raw;
+    if (!hit.file || typeof hit.line !== "number") continue;
+    const label = `${hit.kind ?? ""} ${hit.signature || hit.name || ""}`.trim();
+    const list = byFile.get(hit.file) ?? [];
+    list.push({ lineNumber: hit.line, line: label });
+    byFile.set(hit.file, list);
+  }
+  return {
+    shape: "matches",
+    files: [...byFile.entries()].map(([path9, matches]) => ({ path: path9, matches })),
+    truncated: false,
+    total: hits.length
+  };
+}
+function searchCardFromMeta(meta) {
+  if (!meta || typeof meta !== "object" || Array.isArray(meta)) return void 0;
+  const record = meta;
+  if (record.shape !== "matches" || !Array.isArray(record.files)) return void 0;
+  const files = record.files.filter(
+    (entry) => typeof entry === "object" && entry !== null && !Array.isArray(entry)
+  );
+  return {
+    card: "search",
+    shape: "matches",
+    files,
+    truncated: record.truncated === true,
+    total: typeof record.total === "number" ? record.total : 0
+  };
+}
 var tools = [
   defineTool({
     name: "code_index",
-    description: "Manage the semantic repo index: status or (re)build it for the current workspace. Auto-builds the first time it is queried. Returns file/symbol counts and the index location.",
+    description: "Manage the code index: status or (re)build it for the current workspace. Auto-builds the first time it is queried. Returns file/symbol counts and the index location.",
     parameters: {
       action: {
         type: "string",
@@ -1059,8 +2919,16 @@ var tools = [
       render: (_args, value) => value.map((v) => ({
         type: "text",
         text: renderHit(v)
-      }))
+      })),
+      presentationMeta: (_args, value) => hitsToSearchMeta(value)
     },
+    presentCall: (args) => ({
+      card: "generic",
+      title: args.kind ? `List ${args.kind} symbols` : "List symbols",
+      kind: "search",
+      rawInput: { query: args.query, file: args.file, kind: args.kind }
+    }),
+    presentResult: (_args, result) => searchCardFromMeta(result.meta),
     async execute(args, exec) {
       const root = await resolveRoot(args.repoRoot, exec);
       const index = await getIndex(root);
@@ -1095,8 +2963,16 @@ var tools = [
       render: (_args, value) => value.map((v) => ({
         type: "text",
         text: renderHit(v)
-      }))
+      })),
+      presentationMeta: (_args, value) => hitsToSearchMeta(value)
     },
+    presentCall: (args) => ({
+      card: "generic",
+      title: `Search "${args.query}"`,
+      kind: "search",
+      rawInput: { query: args.query }
+    }),
+    presentResult: (_args, result) => searchCardFromMeta(result.meta),
     async execute(args, exec) {
       const root = await resolveRoot(args.repoRoot, exec);
       const index = await getIndex(root);
@@ -1132,9 +3008,216 @@ var tools = [
         return `code_index: ${error.message ?? String(error)}`;
       }
     }
+  }),
+  defineTool({
+    name: "code_refs",
+    description: "Trace a symbol through the call graph: who calls it (callers) and what it calls (callees), resolved to in-repo definitions with file:line. Complements code_search \u2014 search finds a definition, code_refs shows how it is used. Resolution is name-based, so like-named symbols are reported as candidate definitions.",
+    parameters: {
+      symbol: {
+        type: "string",
+        required: true,
+        description: "Symbol name to trace (case-sensitive)."
+      },
+      direction: {
+        type: "string",
+        enum: ["callers", "callees", "both"],
+        description: 'Which side of the call graph to return (default "both").'
+      },
+      limit: {
+        type: "number",
+        description: "Max rows per side (default 50)."
+      },
+      repoRoot: {
+        type: "string",
+        description: "Optional absolute repo path; defaults to the session workspace root."
+      }
+    },
+    output: {
+      schema: { type: "string" },
+      render: (_args, value) => [{ type: "text", text: value }]
+    },
+    presentCall: (args) => ({
+      card: "generic",
+      title: `Refs ${args.symbol}`,
+      kind: "search",
+      rawInput: { symbol: args.symbol, direction: args.direction }
+    }),
+    async execute(args, exec) {
+      try {
+        const root = await resolveRoot(args.repoRoot, exec);
+        const index = await getIndex(root);
+        const refs = symbolRefs(index, args.symbol, args.limit ?? 50);
+        const direction = args.direction ?? "both";
+        const lines = [];
+        if (refs.defs.length > 0) {
+          lines.push("definitions:");
+          for (const def of refs.defs) {
+            lines.push(`  ${def.kind} ${def.signature || def.name} \u2014 ${def.file}:${def.line}`);
+          }
+        } else {
+          lines.push(`no definition of "${args.symbol}" in this repo`);
+        }
+        if (direction === "callers" || direction === "both") {
+          lines.push("", `callers (${refs.callers.length}):`);
+          if (refs.callers.length === 0) lines.push("  (none)");
+          for (const caller of refs.callers) {
+            lines.push(`  ${caller.file}:${caller.line}${caller.from ? ` in ${caller.from}` : ""}`);
+          }
+        }
+        if (direction === "callees" || direction === "both") {
+          lines.push("", `callees (${refs.callees.length}):`);
+          if (refs.callees.length === 0) lines.push("  (none)");
+          for (const callee of refs.callees) {
+            const target = callee.targets[0];
+            lines.push(
+              `  ${callee.name} :${callee.line}${target ? ` \u2192 ${target.file}:${target.line}` : " (external)"}`
+            );
+          }
+        }
+        return lines.join("\n");
+      } catch (error) {
+        return `code_refs: ${error.message ?? String(error)}`;
+      }
+    }
+  }),
+  defineTool({
+    name: "code_change_context",
+    description: "Return the smallest change-aware context for the current diff: changed symbols, direct callers, import dependents, shortest paths to entry points, transitive impact, and likely affected tests. Every relation is labeled exact / import-scoped / name-only, so confidence is explicit. Select the change with an explicit diff, a list of files, a list of symbol ids, or (default) the working tree against baseRef.",
+    parameters: {
+      repoRoot: {
+        type: "string",
+        description: "Optional absolute repo path; defaults to the session workspace root."
+      },
+      diff: {
+        type: "string",
+        description: "Caller-supplied unified diff text; when present no git command runs."
+      },
+      baseRef: {
+        type: "string",
+        description: 'Git ref to diff against (default "HEAD"); also the baseline read for deletions.'
+      },
+      files: {
+        type: "array",
+        items: { type: "string" },
+        description: "Repo-relative files to treat as wholly changed (mutually exclusive with diff/symbols)."
+      },
+      symbols: {
+        type: "array",
+        items: { type: "string" },
+        description: "SymbolInfo ids to treat as changed (mutually exclusive with diff/files)."
+      },
+      maxDepth: {
+        type: "number",
+        description: "Transitive caller depth, 1..6 (default 3)."
+      },
+      maxImpact: {
+        type: "number",
+        description: "Max direct-caller / impact / dependent rows, 1..200 (default 40)."
+      },
+      maxPaths: {
+        type: "number",
+        description: "Max entry-point paths, 1..50 (default 10)."
+      },
+      maxTests: {
+        type: "number",
+        description: "Max affected-test rows, 1..100 (default 20)."
+      }
+    },
+    output: {
+      schema: { type: "string" },
+      render: (_args, value) => [{ type: "text", text: value }]
+    },
+    presentCall: (args) => ({
+      card: "generic",
+      title: "Change context",
+      kind: "search",
+      rawInput: {
+        baseRef: args.baseRef,
+        files: args.files,
+        symbols: args.symbols,
+        diff: args.diff !== void 0 ? "(inline diff)" : void 0
+      }
+    }),
+    async execute(args, exec) {
+      try {
+        const root = await resolveRoot(args.repoRoot, exec);
+        const index = await getIndex(root);
+        const input = changeContextInputFromArgs(args, root);
+        const result = await buildChangeContext(index, input, {
+          maxDepth: args.maxDepth,
+          maxImpact: args.maxImpact,
+          maxPaths: args.maxPaths,
+          maxTests: args.maxTests
+        });
+        return renderChangeContext(result);
+      } catch (error) {
+        return `code_change_context: ${error.message ?? String(error)}`;
+      }
+    }
+  }),
+  defineTool({
+    name: "code_health",
+    description: "Report structural health from the import graph: circular dependencies (import cycles) and orphan modules (symbol-bearing files that nothing imports and that import nothing, excluding entry points and tests).",
+    parameters: {
+      limit: {
+        type: "number",
+        description: "Max cycles and orphan rows to list (default 50)."
+      },
+      repoRoot: {
+        type: "string",
+        description: "Optional absolute repo path; defaults to the session workspace root."
+      }
+    },
+    output: {
+      schema: { type: "string" },
+      render: (_args, value) => [{ type: "text", text: value }]
+    },
+    presentCall: () => ({ card: "generic", title: "Code health", kind: "read" }),
+    async execute(args, exec) {
+      try {
+        const root = await resolveRoot(args.repoRoot, exec);
+        const index = await getIndex(root);
+        const limit = args.limit ?? 50;
+        const cycles = findCycles(index);
+        const orphans = findOrphanModules(index);
+        const lines = [`repo health \u2014 ${index.files.length} files`];
+        lines.push("", `circular dependencies (${cycles.length}):`);
+        if (cycles.length === 0) lines.push("  (none)");
+        for (const cycle of cycles.slice(0, limit)) lines.push(`  ${cycle.join(" \u2192 ")}`);
+        lines.push("", `orphan modules (${orphans.length}):`);
+        if (orphans.length === 0) lines.push("  (none)");
+        for (const orphan of orphans.slice(0, limit)) lines.push(`  ${orphan}`);
+        return lines.join("\n");
+      } catch (error) {
+        return `code_health: ${error.message ?? String(error)}`;
+      }
+    }
   })
 ];
 
+// src/settings.ts
+import Schema from "@deepseek-ai/schemastery";
+var SETTINGS_NAMESPACE = "code-index";
+var settingsSchema = Schema.object({
+  excludeDirs: Schema.array(Schema.string()).default([]),
+  mapTopFiles: Schema.number().default(24),
+  mapMaxChars: Schema.number().default(3200),
+  mapTtlMs: Schema.number().default(6e4),
+  autoInject: Schema.boolean().default(true),
+  codeHealth: Schema.boolean().default(false)
+});
+function registerSettings(getService, pluginConfig, onResolved) {
+  const service = getService("settings");
+  if (!service) return;
+  const scope = service.register(SETTINGS_NAMESPACE, settingsSchema, {
+    base: pluginConfig ?? {}
+  });
+  onResolved(scope.get());
+  scope.watch((next) => {
+    onResolved(next);
+  });
+}
+
 // src/index.ts
 var name = "dsh-code-index";
 var inject = ["tools", "systemPrompt"];
@@ -1144,7 +3227,17 @@ function apply(ctx, pluginConfig) {
   ctx.effect(() => {
     const disposers = [];
     console.log("[dsh-code-index] plugin loaded");
+    if (ctx.inject) {
+      ctx.inject(["settings"], (settingsCtx) => {
+        registerSettings(
+          (name2) => settingsCtx.get(name2),
+          pluginConfig,
+          (resolved) => applyConfig(resolved)
+        );
+      });
+    }
     for (const tool of tools) {
+      if (tool.name === "code_health" && !getConfig().codeHealth) continue;
       disposers.push(ctx.tools.register(tool));
       console.log(`[dsh-code-index] registered tool: ${tool.name}`);
     }
@@ -1208,18 +3301,29 @@ export {
   DEFAULT_EXCLUDED_DIRS,
   SUPPORTED_EXTS,
   apply,
+  buildChangeContext,
   buildIndex,
   buildIndexWithCache,
+  buildModuleGraph,
+  buildSymbolTable,
+  callerCounts,
+  changeContextInputFromArgs,
   defaultCachePath,
   extractAll,
   extractSymbols,
+  findCycles,
+  findOrphanModules,
   findRepoRoot,
   inject,
   languageForFile,
   loadIndex,
   name,
   parseFileToSymbols,
+  parseUnifiedDiff,
   rankRepoMap,
+  readGitFileAtRef,
+  readWorkingTreeDiff,
+  renderChangeContext,
   renderHit,
   renderRepoMap,
   saveIndex,
@@ -1227,6 +3331,7 @@ export {
   scoreFile,
   searchSymbols,
   symbolCount,
+  symbolRefs,
   tools
 };
 //# sourceMappingURL=index.js.map