@sdsrs/code-graph 0.74.7 → 0.75.0

package/claude-plugin/.claude-plugin/plugin.json

@@ -4,7 +4,7 @@
   "author": {
     "name": "sdsrs"
   },
-  "version": "0.74.7",
+  "version": "0.75.0",
   "keywords": [
     "code-graph",
     "ast",

package/claude-plugin/scripts/cg-answer.js

@@ -243,6 +243,67 @@ function runOverviewAnswer(opts = {}) {
   }
 }
 
+/**
+ * v0.75 — Run `code-graph-mcp callgraph <symbol>` for the cross-file caller/callee
+ * tree. This is the ONE thing a raw grep CANNOT return: a symbol-targeted grep
+ * hands the model the definition + same-file usages it already scoped to, but NOT
+ * "who calls this across the repo". The 2026-06-26 inject audit (13 events, 0
+ * CONSUMED) found the grep-echo payload redundant precisely because it re-stated
+ * the model's own hits; the caller tree is the marginal signal grep can't give.
+ *
+ * "hits" requires an actual EDGE line (`← called by` / `→ calls`) — a bare symbol
+ * header with no edges (leaf symbol, or name not in the graph) carries no marginal
+ * value over the grep the model already ran, so it degrades to `no-hits` and the
+ * caller falls back to the grep/show echo. Same bounded/best-effort posture as the
+ * sibling runners; any failure → `unavailable` / `no-binary`, never a new failure.
+ * @returns {{status: 'hits', text: string, truncated: boolean}
+ *         | {status: 'no-hits'}
+ *         | {status: 'no-binary'}
+ *         | {status: 'unavailable'}}
+ */
+function runCallgraphAnswer(opts = {}) {
+  const {
+    cwd,
+    symbol,
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+    maxBytes = DEFAULT_MAX_BYTES,
+  } = opts;
+  try {
+    if (typeof symbol !== 'string' || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(symbol)) {
+      return { status: 'unavailable' };
+    }
+    let binary = opts.binary;
+    if (binary === undefined) {
+      binary = process.env._CG_ANSWER_BINARY || require('./find-binary').findBinary();
+    }
+    if (!binary) return { status: 'no-binary' };
+
+    const res = spawnSync(binary, ['callgraph', symbol], {
+      cwd,
+      timeout: timeoutMs,
+      encoding: 'utf8',
+      maxBuffer: 4 * 1024 * 1024,
+      stdio: ['ignore', 'pipe', 'ignore'],
+      env: { ...process.env, CODE_GRAPH_INTERNAL: '1' },
+    });
+    if (res.error || res.signal) return { status: 'unavailable' };
+    // grep-parity exit codes: 1 = symbol not found (no graph node).
+    if (res.status === 1) return { status: 'no-hits' };
+    if (res.status !== 0) return { status: 'unavailable' };
+    const out = (res.stdout || '').trim();
+    // Only an edge-bearing tree is marginal over the grep the model already ran.
+    if (!out || out.startsWith(NO_MATCH_PREFIX) ||
+        !(out.includes('← called by') || out.includes('→ calls'))) {
+      return { status: 'no-hits' };
+    }
+    const { text, truncated } = truncateAtLine(out, maxBytes);
+    return { status: 'hits', text, truncated };
+  } catch {
+    return { status: 'unavailable' };
+  }
+}
+
 module.exports = {
-  runGrepAnswer, runShowAnswer, runOverviewAnswer, truncateAtLine, sanitizeSearchPath,
+  runGrepAnswer, runShowAnswer, runOverviewAnswer, runCallgraphAnswer,
+  truncateAtLine, sanitizeSearchPath,
 };

package/claude-plugin/scripts/cg-answer.test.js

@@ -4,7 +4,7 @@ const assert = require('node:assert/strict');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
-const { runGrepAnswer, runShowAnswer, runOverviewAnswer, truncateAtLine } = require('./cg-answer');
+const { runGrepAnswer, runShowAnswer, runOverviewAnswer, runCallgraphAnswer, truncateAtLine } = require('./cg-answer');
 
 // Stub "binary": a node script that reacts to its first real arg so one stub
 // covers hits / no-hits / error / timeout cases.
@@ -24,6 +24,15 @@ else if (pattern === 'NothingHere') {
 } else if (pattern === 'NothingHereExit1') {
   // v0.50 grep-parity binary: no match → empty stdout + exit 1
   process.exit(1);
+} else if (pattern === 'HasCallers') {
+  // callgraph with real edges → runCallgraphAnswer 'hits'
+  process.stdout.write(
+    'HasCallers (src/a.rs)\\n' +
+    '  \\u2190 called by: alpha (src/b.rs)\\n' +
+    '  \\u2192 calls: beta (src/c.rs)\\n');
+} else if (pattern === 'LeafSymbol') {
+  // callgraph with a bare header, no edge lines → 'no-hits' (no marginal value)
+  process.stdout.write('LeafSymbol (src/a.rs)\\n');
 } else {
   process.stdout.write(
     'src/storage/db.rs:42  fn ' + pattern + '() {\\n' +
@@ -251,3 +260,50 @@ test('runOverviewAnswer: empty/oversized dir → unavailable (never spawns)', ()
     runOverviewAnswer({ cwd: stubDir, dir: 'a'.repeat(301), binary: stubBinary() }).status,
     'unavailable');
 });
+
+// ── runCallgraphAnswer (v0.75) — cross-file caller/callee tree ────────
+
+test('runCallgraphAnswer: edge-bearing tree → hits with caller/callee lines', () => {
+  const r = runCallgraphAnswer({ cwd: stubDir, symbol: 'HasCallers', binary: stubBinary() });
+  assert.equal(r.status, 'hits');
+  assert.match(r.text, /called by: alpha/);
+  assert.match(r.text, /calls: beta/);
+});
+
+test('runCallgraphAnswer: passes callgraph subcommand + symbol as argv', () => {
+  // 'HasCallers' is the only stub branch that emits edges; assert it reached it.
+  const r = runCallgraphAnswer({ cwd: stubDir, symbol: 'HasCallers', binary: stubBinary() });
+  assert.equal(r.status, 'hits');
+  assert.match(r.text, /← called by/);
+});
+
+test('runCallgraphAnswer: bare header with no edges → no-hits (no marginal value)', () => {
+  const r = runCallgraphAnswer({ cwd: stubDir, symbol: 'LeafSymbol', binary: stubBinary() });
+  assert.equal(r.status, 'no-hits');
+});
+
+test('runCallgraphAnswer: symbol not in graph (exit 1) → no-hits', () => {
+  const r = runCallgraphAnswer({ cwd: stubDir, symbol: 'NothingHereExit1', binary: stubBinary() });
+  assert.equal(r.status, 'no-hits');
+});
+
+test('runCallgraphAnswer: failing binary → unavailable', () => {
+  const r = runCallgraphAnswer({ cwd: stubDir, symbol: 'ExplodePlease', binary: stubBinary() });
+  assert.equal(r.status, 'unavailable');
+});
+
+test('runCallgraphAnswer: missing binary → no-binary (distinct from runtime unavailable)', () => {
+  const r = runCallgraphAnswer({ cwd: stubDir, symbol: 'HasCallers', binary: null });
+  assert.equal(r.status, 'no-binary');
+});
+
+test('runCallgraphAnswer: non-identifier symbol → unavailable (never spawns)', () => {
+  assert.equal(runCallgraphAnswer({ cwd: stubDir, symbol: 'a|b', binary: stubBinary() }).status, 'unavailable');
+  assert.equal(runCallgraphAnswer({ cwd: stubDir, symbol: '', binary: stubBinary() }).status, 'unavailable');
+  assert.equal(runCallgraphAnswer({ cwd: stubDir, symbol: 'def foo', binary: stubBinary() }).status, 'unavailable');
+});
+
+test('runCallgraphAnswer: timeout → unavailable', () => {
+  const r = runCallgraphAnswer({ cwd: stubDir, symbol: 'HangForever', binary: stubBinary(), timeoutMs: 300 });
+  assert.equal(r.status, 'unavailable');
+});

package/claude-plugin/scripts/post-grep-inject.js

@@ -25,7 +25,7 @@ const path = require('path');
 const crypto = require('crypto');
 const { cgTmpDir } = require('./tmp-dir');
 const { recordRecommendation } = require('./recommendation-log');
-const { runGrepAnswer, runShowAnswer, sanitizeSearchPath } = require('./cg-answer');
+const { runGrepAnswer, runShowAnswer, runCallgraphAnswer, sanitizeSearchPath } = require('./cg-answer');
 const { emitPostToolContext } = require('./hook-emit');
 const {
   splitTopLevelSegments,
@@ -65,8 +65,21 @@ function findFoldableGrepSegment(cmd) {
 // Short header so the model recognizes this as cg's parallel structural view of
 // the grep it just ran (the grep already executed; this is additive context).
 const INJECT_HEADER = '[code-graph] AST-aware view of your grep (ran alongside):';
+// callgraph mode carries the cross-file caller/callee tree — the marginal signal
+// the grep CANNOT return (2026-06-26 audit: the grep-echo above was redundant
+// with the model's own hits; the caller tree is what moves behavior).
+const CALLGRAPH_HEADER =
+  '[code-graph] Cross-file call graph for the symbol you grepped (grep can\'t show this):';
 
 function buildInjectText(answer, mode) {
+  if (mode === 'callgraph') {
+    const lines = [CALLGRAPH_HEADER, answer.text];
+    if (answer.truncated) {
+      lines.push('(truncated — run `code-graph-mcp callgraph <symbol>` yourself for the full tree)');
+    }
+    lines.push('`← called by` = callers, `→ calls` = callees, across all files — use these directly.');
+    return lines.join('\n');
+  }
   const lines = [INJECT_HEADER, answer.text];
   if (answer.truncated) {
     lines.push(mode === 'show'
@@ -142,18 +155,39 @@ function runMain() {
 
   const { segment, block } = found;
   // Run the answer exactly like the deny path.
-  const pattern = translateBreToRg(segment, pickBlockPattern(segment));
+  const rawPattern = pickBlockPattern(segment);
+  const pattern = translateBreToRg(segment, rawPattern);
   const searchPath = sanitizeSearchPath(extractSearchPath(segment));
   let answer = { status: 'unavailable' };
   let answeredMode = block.mode;
-  if (block.mode === 'show') {
-    answer = runShowAnswer({ cwd: root, symbols: block.symbols });
-    if (answer.status !== 'hits' && pattern) {
+
+  // PREFER the cross-file caller/callee tree when the grep targets a single clean
+  // identifier — that is the marginal signal a raw grep can't return (2026-06-26
+  // inject audit: 13 events / 0 CONSUMED because the grep-echo just re-stated the
+  // model's own hits). runCallgraphAnswer returns `hits` ONLY when the symbol has
+  // real edges; a leaf/absent symbol degrades to the show/grep echo below.
+  const symbol = (typeof rawPattern === 'string' && /^[A-Za-z_][A-Za-z0-9_]*$/.test(rawPattern))
+    ? rawPattern : null;
+  if (symbol) {
+    const cg = runCallgraphAnswer({ cwd: root, symbol });
+    if (cg.status === 'hits') {
+      answer = cg;
+      answeredMode = 'callgraph';
+    }
+  }
+
+  if (answer.status !== 'hits') {
+    if (block.mode === 'show') {
+      answeredMode = 'show';
+      answer = runShowAnswer({ cwd: root, symbols: block.symbols });
+      if (answer.status !== 'hits' && pattern) {
+        answeredMode = 'grep';
+        answer = runGrepAnswer({ cwd: root, pattern, searchPath });
+      }
+    } else if (pattern) {
       answeredMode = 'grep';
       answer = runGrepAnswer({ cwd: root, pattern, searchPath });
     }
-  } else if (pattern) {
-    answer = runGrepAnswer({ cwd: root, pattern, searchPath });
   }
 
   // Only inject on hits — no-hits / unavailable / no-binary stay silent (the grep

package/claude-plugin/scripts/post-grep-inject.test.js

@@ -95,6 +95,19 @@ test('buildInjectText: no truncation note when not truncated', () => {
   assert.doesNotMatch(out, /truncated/);
 });
 
+test('buildInjectText: callgraph mode uses the cross-file header (not the grep-echo header)', () => {
+  const out = buildInjectText({ text: '  ← called by: alpha (src/b.rs)', truncated: false }, 'callgraph');
+  assert.match(out, /Cross-file call graph/);
+  assert.match(out, /grep can't show this/);
+  assert.doesNotMatch(out, /AST-aware view of your grep/);
+  assert.match(out, /← called by` = callers/);
+});
+
+test('buildInjectText: callgraph truncation note points at the callgraph command', () => {
+  const out = buildInjectText({ text: 'tree', truncated: true }, 'callgraph');
+  assert.match(out, /code-graph-mcp callgraph <symbol>/);
+});
+
 // ── opt-out / kill switch ───────────────────────────────────────────
 
 test('isSilenced: CODE_GRAPH_QUIET_HOOKS=1 → silenced; default not', () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdsrs/code-graph",
-  "version": "0.74.7",
+  "version": "0.75.0",
   "description": "MCP server that indexes codebases into an AST knowledge graph with semantic search, call graph traversal, and HTTP route tracing",
   "license": "MIT",
   "repository": {
@@ -35,10 +35,10 @@
     "node": ">=16"
   },
   "optionalDependencies": {
-    "@sdsrs/code-graph-linux-x64": "0.74.7",
-    "@sdsrs/code-graph-linux-arm64": "0.74.7",
-    "@sdsrs/code-graph-darwin-x64": "0.74.7",
-    "@sdsrs/code-graph-darwin-arm64": "0.74.7",
-    "@sdsrs/code-graph-win32-x64": "0.74.7"
+    "@sdsrs/code-graph-linux-x64": "0.75.0",
+    "@sdsrs/code-graph-linux-arm64": "0.75.0",
+    "@sdsrs/code-graph-darwin-x64": "0.75.0",
+    "@sdsrs/code-graph-darwin-arm64": "0.75.0",
+    "@sdsrs/code-graph-win32-x64": "0.75.0"
   }
 }