dsh-code-index 0.4.0 → 0.5.0

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,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);
@@ -232,6 +293,24 @@ 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);
     const seen = /* @__PURE__ */ new Set();
     const deduped = symbols.filter((s) => {
@@ -240,7 +319,7 @@ async function extractAll(code, id) {
       seen.add(key);
       return true;
     });
-    return { symbols: deduped, imports };
+    return { symbols: deduped, imports, calls };
   } finally {
     tree.delete();
   }
@@ -282,6 +361,19 @@ function cppNameOf(node) {
   }
   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":
@@ -617,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
         };
       })
     );
@@ -669,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++) {
@@ -695,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();
@@ -727,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);
@@ -888,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";
@@ -898,7 +1122,8 @@ var DEFAULTS = {
   mapTopFiles: 24,
   mapMaxChars: 3200,
   mapTtlMs: 6e4,
-  autoInject: true
+  autoInject: true,
+  codeHealth: false
 };
 var state = { current: { ...DEFAULTS } };
 function applyConfig(partial) {
@@ -987,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",
@@ -1059,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);
@@ -1095,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);
@@ -1132,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"];
@@ -1144,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}`);
     }
@@ -1210,9 +1625,14 @@ export {
   apply,
   buildIndex,
   buildIndexWithCache,
+  buildModuleGraph,
+  buildSymbolTable,
+  callerCounts,
   defaultCachePath,
   extractAll,
   extractSymbols,
+  findCycles,
+  findOrphanModules,
   findRepoRoot,
   inject,
   languageForFile,
@@ -1227,6 +1647,7 @@ export {
   scoreFile,
   searchSymbols,
   symbolCount,
+  symbolRefs,
   tools
 };
 //# sourceMappingURL=index.js.map