dsh-code-index 0.3.1 → 0.5.0

package/dist/index.js

@@ -15,7 +15,9 @@ var GRAMMAR_NAMES = {
   python: "tree-sitter-python",
   go: "tree-sitter-go",
   rust: "tree-sitter-rust",
-  java: "tree-sitter-java"
+  java: "tree-sitter-java",
+  cpp: "tree-sitter-cpp",
+  c: "tree-sitter-c"
 };
 var EXT_TO_LANG = {
   ".ts": "typescript",
@@ -30,7 +32,19 @@ var EXT_TO_LANG = {
   ".pyi": "python",
   ".go": "go",
   ".rs": "rust",
-  ".java": "java"
+  ".java": "java",
+  ".cpp": "cpp",
+  ".cc": "cpp",
+  ".cxx": "cpp",
+  ".c++": "cpp",
+  ".hpp": "cpp",
+  ".hxx": "cpp",
+  ".hh": "cpp",
+  ".h": "cpp",
+  ".ipp": "cpp",
+  ".tpp": "cpp",
+  ".inl": "cpp",
+  ".c": "c"
 };
 function languageForFile(filePath) {
   const ext = path.extname(filePath).toLowerCase();
@@ -79,6 +93,31 @@ var QUERIES = {
     (enum_declaration) @enum
     (method_declaration) @method
     (constructor_declaration) @method
+  `,
+  // C++ grammar (superset of C — also serves .h headers). function names
+  // live inside the declarator chain, so patterns stay broad and names,
+  // kinds and signatures are resolved in code (cppNameOf / kindFor /
+  // signatureFor). Top-level `declaration` covers prototypes, constructors
+  // and globals; field_declaration covers class-body members.
+  cpp: `
+    (function_definition) @function
+    (class_specifier body: (_)) @class
+    (struct_specifier body: (_)) @class
+    (enum_specifier body: (_)) @enum
+    (type_definition) @type
+    (alias_declaration) @type
+    (namespace_definition) @module
+    (field_declaration) @field
+    (declaration) @variable
+  `,
+  // Plain C: same core nodes minus C++-only namespace/alias forms.
+  c: `
+    (function_definition) @function
+    (struct_specifier body: (_)) @class
+    (enum_specifier body: (_)) @enum
+    (type_definition) @type
+    (field_declaration) @field
+    (declaration) @variable
   `
 };
 var CAPTURE_KINDS = {
@@ -89,7 +128,8 @@ var CAPTURE_KINDS = {
   type: { kind: "type" },
   enum: { kind: "enum" },
   variable: { kind: "variable" },
-  field: { kind: "field" }
+  field: { kind: "field" },
+  module: { kind: "module" }
 };
 var IMPORT_QUERIES = {
   typescript: `
@@ -112,8 +152,76 @@ var IMPORT_QUERIES = {
   `,
   java: `
     (import_declaration) @import
+  `,
+  // C/C++: #include "local.hpp" — quoted form resolves in-repo; <system>
+  // captures too but yields null and is dropped by the extractor.
+  cpp: `
+    (preproc_include) @import
+  `,
+  c: `
+    (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) {
@@ -136,6 +244,7 @@ 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);
@@ -157,8 +266,8 @@ async function extractAll(code, id) {
         const def = CAPTURE_KINDS[cap.name];
         if (!def) continue;
         const node = cap.node;
-        if (def.kind === "variable" && !isModuleLevelVariable(node)) continue;
-        const name2 = nameOf(node);
+        if (def.kind === "variable" && !isModuleLevelVariable(id, node)) continue;
+        const name2 = nameOf(id, node);
         if (!name2) continue;
         symbols.push({
           name: name2,
@@ -168,7 +277,7 @@ async function extractAll(code, id) {
           line: node.startPosition.row + 1,
           endLine: node.endPosition.row + 1,
           exported: isExported(id, node),
-          signature: signatureFor(node)
+          signature: signatureFor(id, node)
         });
       }
     } finally {
@@ -184,8 +293,33 @@ async function extractAll(code, id) {
     } finally {
       importQuery.delete();
     }
+    const calls = [];
+    const callQuery = new Query(lang, CALL_QUERIES[id]);
+    try {
+      const seen2 = /* @__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 from = enclosingCallable(id, cap.node);
+        const key = `${from}|${name2}|${line}`;
+        if (seen2.has(key)) continue;
+        seen2.add(key);
+        calls.push({ name: name2, line, from });
+      }
+    } finally {
+      callQuery.delete();
+    }
+    calls.sort((a, b) => a.line - b.line || a.name.localeCompare(b.name));
     symbols.sort((a, b) => a.line - b.line);
-    return { symbols, imports };
+    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, calls };
   } finally {
     tree.delete();
   }
@@ -193,11 +327,53 @@ async function extractAll(code, id) {
 async function extractSymbols(code, id) {
   return (await extractAll(code, id)).symbols;
 }
-function nameOf(node) {
+function nameOf(id, node) {
+  if (id === "cpp" || id === "c") return cppNameOf(node);
   const field = node.childForFieldName?.("name");
   if (field) return field.text.trim();
   return "";
 }
+function cppNameOf(node) {
+  const nameField = node.childForFieldName?.("name");
+  if (nameField) return nameField.text.trim();
+  if (node.type === "type_definition") {
+    return node.childForFieldName?.("declarator")?.text.trim() ?? "";
+  }
+  let declarator = node.childForFieldName?.("declarator");
+  if (declarator?.type === "init_declarator") {
+    declarator = declarator.childForFieldName?.("declarator");
+  }
+  if (declarator) {
+    let current = declarator;
+    while (current) {
+      if (current.type === "function_declarator" || current.type === "pointer_declarator" || current.type === "array_declarator" || current.type === "reference_declarator" || current.type === "parenthesized_declarator" || current.type === "init_declarator") {
+        current = current.childForFieldName?.("declarator") ?? current.namedChildren[0] ?? null;
+        continue;
+      }
+      if (current.type === "qualified_identifier") {
+        return current.childForFieldName?.("name")?.text.trim() ?? current.text.trim();
+      }
+      if (current.type === "identifier" || current.type === "field_identifier" || current.type === "type_identifier") {
+        return current.text.trim();
+      }
+      break;
+    }
+  }
+  return "";
+}
+function enclosingCallable(id, node) {
+  const callable = CALLABLE_NODES[id];
+  for (let parent = node.parent; parent; parent = parent.parent) {
+    if (!callable.has(parent.type)) continue;
+    const named = nameOf(id, parent);
+    if (named) return named;
+    const declaration = parent.parent;
+    const field = declaration?.type === "variable_declarator" ? "name" : null;
+    if (field) return declaration?.childForFieldName?.(field)?.text.trim() ?? "";
+    return "";
+  }
+  return "";
+}
 function specifierOf(id, node) {
   switch (node.type) {
     case "import_statement":
@@ -216,6 +392,8 @@ function specifierOf(id, node) {
       return rustUsePath(node.childForFieldName("argument")?.text);
     case "import_declaration":
       return dottedToPath(node.namedChildren[0]?.text);
+    case "preproc_include":
+      return stripQuotes(node.childForFieldName("path")?.text);
     default:
       return null;
   }
@@ -247,21 +425,43 @@ function pythonRelative(raw) {
   const prefix = dots === 1 ? "./" : "../".repeat(dots - 1);
   return prefix + rest;
 }
-function signatureFor(node) {
-  const name2 = nameOf(node);
+function signatureFor(id, node) {
+  const sig = rawSignature(id, node);
+  return sig.length > 80 ? `${sig.slice(0, 77)}...` : sig;
+}
+function rawSignature(id, node) {
+  const name2 = nameOf(id, node);
   const params = node.childForFieldName?.("parameters") ?? node.namedChildren.find(
     (c) => c?.type === "formal_parameters" || c?.type === "method_parameters" || c?.type === "parameters" || c?.type === "parameter_list"
   );
   if (params) {
     return `${name2}${collapseSpace(params.text)}`;
   }
+  if (id === "cpp" || id === "c") {
+    let current = node.childForFieldName?.("declarator");
+    while (current) {
+      if (current.type === "function_declarator") {
+        const list = current.childForFieldName?.("parameters");
+        return list ? `${name2}${collapseSpace(list.text)}` : name2;
+      }
+      current = current.childForFieldName?.("declarator") ?? current.namedChildren[0] ?? null;
+      if (current && !current.type.includes("declarator") && current.type !== "identifier" && current.type !== "qualified_identifier" && current.type !== "field_identifier") break;
+    }
+  }
   const first = node.namedChildren[0];
   return first ? collapseSpace(first.text) : name2;
 }
 function collapseSpace(text) {
   return text.replace(/\s+/g, " ").replace(/\( /g, "(").replace(/ \)/g, ")").replace(/ ,/g, ",").replace(/,\)/g, ")").trim();
 }
-function isModuleLevelVariable(node) {
+function isModuleLevelVariable(id, node) {
+  if (id === "cpp" || id === "c") {
+    for (let parent = node.parent; parent; parent = parent.parent) {
+      if (parent.type === "function_definition" || parent.type === "compound_statement") return false;
+      if (parent.type === "translation_unit" || parent.type === "declaration_list" || parent.type === "field_declaration_list") return true;
+    }
+    return false;
+  }
   const declaration = node.parent;
   const container = declaration?.parent;
   return container?.type === "program" || container?.type === "export_statement";
@@ -271,7 +471,7 @@ function isExported(id, node) {
     return node.parent?.type === "module";
   }
   if (id === "go") {
-    const name2 = nameOf(node);
+    const name2 = nameOf(id, node);
     return !!name2 && /^[A-Z]/.test(name2);
   }
   if (id === "rust") {
@@ -283,6 +483,9 @@ function isExported(id, node) {
     if (node.parent?.type === "interface_body") return true;
     return node.namedChildren.some((c) => c?.type === "modifiers" && /\bpublic\b/.test(c?.text ?? ""));
   }
+  if (id === "cpp" || id === "c") {
+    return cppIsExported(node);
+  }
   for (let parent = node.parent; parent; parent = parent.parent) {
     if (parent.type === "export_statement") return true;
     if (parent.type === "statement_block" || parent.type === "class_body") return false;
@@ -290,6 +493,31 @@ function isExported(id, node) {
   }
   return false;
 }
+function cppIsExported(node) {
+  const isStatic = node.namedChildren.some(
+    (c) => c?.type === "storage_class_specifier" && c.text === "static"
+  );
+  for (let parent = node.parent; parent; parent = parent.parent) {
+    if (parent.type === "field_declaration_list") {
+      const body = parent;
+      const structKind = body.parent?.type === "struct_specifier" ? "struct" : "class";
+      let current = structKind === "struct" ? "public" : "private";
+      for (let up = node; up && up.id !== body.id; up = up.parent) {
+        const next = up.parent;
+        if (next?.type === "field_declaration_list") {
+          const siblingIndex = next.namedChildren.findIndex((c) => c?.id === up.id);
+          const accessBefore = next.namedChildren.slice(0, siblingIndex).filter((c) => c?.type === "access_specifier");
+          if (accessBefore.length > 0) {
+            current = accessBefore.at(-1).text.replace(":", "").trim();
+          }
+        }
+      }
+      return current === "public" && !isStatic;
+    }
+    if (parent.type === "translation_unit") return !isStatic;
+  }
+  return !isStatic;
+}
 function kindFor(id, node, kind) {
   if (id === "python" && kind === "function") {
     const inClassBody = node.parent?.type === "block" && node.parent?.parent?.type === "class_definition";
@@ -305,6 +533,19 @@ function kindFor(id, node, kind) {
     const inImpl = node.parent?.type === "declaration_list" && node.parent?.parent?.type === "impl_item";
     if (inImpl) return "method";
   }
+  if ((id === "cpp" || id === "c") && (kind === "variable" || kind === "field")) {
+    let current = node.childForFieldName?.("declarator");
+    while (current) {
+      if (current.type === "function_declarator") {
+        return node.parent?.type === "field_declaration_list" ? "method" : "function";
+      }
+      current = current.childForFieldName?.("declarator") ?? current.namedChildren[0] ?? null;
+    }
+    return node.type === "field_declaration" ? "field" : "variable";
+  }
+  if ((id === "cpp" || id === "c") && node.type === "function_definition") {
+    if (node.parent?.type === "field_declaration_list") return "method";
+  }
   return kind;
 }
 async function parseFileToSymbols(filePath, repoRoot, code) {
@@ -348,7 +589,19 @@ var SUPPORTED_EXTS = /* @__PURE__ */ new Set([
   ".pyi",
   ".go",
   ".rs",
-  ".java"
+  ".java",
+  ".cpp",
+  ".cc",
+  ".cxx",
+  ".c++",
+  ".hpp",
+  ".hxx",
+  ".hh",
+  ".h",
+  ".ipp",
+  ".tpp",
+  ".inl",
+  ".c"
 ]);
 async function scanRepo(root, options = {}) {
   const excluded = /* @__PURE__ */ new Set([...DEFAULT_EXCLUDED_DIRS, ...options.excludeDirs ?? []]);
@@ -456,13 +709,14 @@ async function buildIndex(root, options = {}, previous = null) {
         } catch {
           return null;
         }
-        const { symbols, imports } = await extractAll(code, lang);
+        const { symbols, imports, calls } = await extractAll(code, lang);
         return {
           path: f.rel,
           lang,
           mtimeMs: f.mtimeMs,
           symbols: symbols.map((s) => ({ ...s, file: f.rel })),
-          imports
+          imports,
+          calls
         };
       })
     );
@@ -508,12 +762,22 @@ function indexesEqual(left, right) {
       return false;
     }
     if (file.symbols.length !== other.symbols.length) return false;
+    if (!callsEqual(file.calls, other.calls)) 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;
     });
   });
 }
+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;
+  });
+}
 async function findRepoRoot(startDir, maxLevels = 12) {
   let dir = path4.resolve(startDir);
   for (let level = 0; level < maxLevels; level++) {
@@ -534,6 +798,56 @@ function symbolCount(index) {
   return index.files.reduce((n, f) => n + f.symbols.length, 0);
 }
 
+// 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]);
+    }
+  }
+  for (const list of table.values()) {
+    list.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
+  }
+  return table;
+}
+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;
+}
+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 });
+      }
+      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 {
+    defs,
+    callers: callers.slice(0, limit),
+    callees: callees.slice(0, limit)
+  };
+}
+
 // src/search.ts
 function matchScore(name2, query) {
   const q = query.toLowerCase();
@@ -566,8 +880,9 @@ function searchSymbols(index, filter, limit = 50) {
       hits.push({ ...sym, score });
     }
   }
+  const refs = callerCounts(index);
   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);
+    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);
@@ -697,6 +1012,7 @@ function resolveImport(spec, fromPath, fileSet) {
   return null;
 }
 function candidateFor(base, fileSet) {
+  if (fileSet.has(base)) return base;
   for (const ext of SUPPORTED_EXTS) {
     if (fileSet.has(`${base}${ext}`)) return `${base}${ext}`;
   }
@@ -726,6 +1042,76 @@ function renderRepoMap(entries, options = {}) {
   return totalSymbols > 0 ? text : "";
 }
 
+// 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(
+    (path7) => withSymbols.has(path7) && (incoming.get(path7) ?? 0) === 0 && (edges.get(path7)?.size ?? 0) === 0 && !ENTRY_RE.test(path7) && !TEST_RE.test(path7)
+  );
+}
+
 // src/tools.ts
 import { defineTool } from "@deepseek-ai/dsh-tools";
 import path6 from "path";
@@ -736,7 +1122,8 @@ var DEFAULTS = {
   mapTopFiles: 24,
   mapMaxChars: 3200,
   mapTtlMs: 6e4,
-  autoInject: true
+  autoInject: true,
+  codeHealth: false
 };
 var state = { current: { ...DEFAULTS } };
 function applyConfig(partial) {
@@ -825,6 +1212,38 @@ async function resolveRoot(arg, exec) {
   if (!root) throw new Error(`no git repository found from ${path6.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(([path7, matches]) => ({ path: path7, 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",
@@ -897,8 +1316,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);
@@ -933,8 +1360,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);
@@ -970,9 +1405,141 @@ 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_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"];
@@ -982,7 +1549,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}`);
     }
@@ -1048,9 +1625,14 @@ export {
   apply,
   buildIndex,
   buildIndexWithCache,
+  buildModuleGraph,
+  buildSymbolTable,
+  callerCounts,
   defaultCachePath,
   extractAll,
   extractSymbols,
+  findCycles,
+  findOrphanModules,
   findRepoRoot,
   inject,
   languageForFile,
@@ -1065,6 +1647,7 @@ export {
   scoreFile,
   searchSymbols,
   symbolCount,
+  symbolRefs,
   tools
 };
 //# sourceMappingURL=index.js.map