@sdsrs/code-graph 0.74.8 → 0.75.1

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

@@ -4,7 +4,7 @@
   "author": {
     "name": "sdsrs"
   },
-  "version": "0.74.8",
+  "version": "0.75.1",
   "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/claude-plugin/scripts/pre-grep-guide.test.js

@@ -1359,6 +1359,38 @@ test('resolveProjectRoot: no index up to $HOME → null (home itself still check
   } finally { fsE2e.rmSync(base, { recursive: true, force: true }); }
 });
 
+test('resolveProjectRoot: skips a STRAY nested subdir index, prefers the .git root', () => {
+  // monorepo (daagu shape): root has .git + index; a subdir carries a stray
+  // index relic but no .git. Resolving from the subdir must climb to the root,
+  // not pin the stray nested index (the statusline "oscillation" root cause).
+  const base = fsE2e.mkdtempSync(pathE2e.join(osE2e.tmpdir(), 'cg-root-'));
+  try {
+    const proj = pathE2e.join(base, 'proj');
+    fsE2e.mkdirSync(pathE2e.join(proj, '.git'), { recursive: true });
+    fsE2e.mkdirSync(pathE2e.join(proj, '.code-graph'), { recursive: true });
+    fsE2e.writeFileSync(pathE2e.join(proj, '.code-graph', 'index.db'), '');
+    const sub = pathE2e.join(proj, 'backend');
+    fsE2e.mkdirSync(pathE2e.join(sub, '.code-graph'), { recursive: true });
+    fsE2e.writeFileSync(pathE2e.join(sub, '.code-graph', 'index.db'), '');
+    assert.equal(resolveProjectRoot(sub, { home: base }), proj);
+  } finally { fsE2e.rmSync(base, { recursive: true, force: true }); }
+});
+
+test('resolveProjectRoot: a nested index with its OWN .git (submodule) still wins', () => {
+  const base = fsE2e.mkdtempSync(pathE2e.join(osE2e.tmpdir(), 'cg-root-'));
+  try {
+    const proj = pathE2e.join(base, 'proj');
+    fsE2e.mkdirSync(pathE2e.join(proj, '.git'), { recursive: true });
+    fsE2e.mkdirSync(pathE2e.join(proj, '.code-graph'), { recursive: true });
+    fsE2e.writeFileSync(pathE2e.join(proj, '.code-graph', 'index.db'), '');
+    const sub = pathE2e.join(proj, 'vendored');
+    fsE2e.mkdirSync(pathE2e.join(sub, '.git'), { recursive: true });
+    fsE2e.mkdirSync(pathE2e.join(sub, '.code-graph'), { recursive: true });
+    fsE2e.writeFileSync(pathE2e.join(sub, '.code-graph', 'index.db'), '');
+    assert.equal(resolveProjectRoot(sub, { home: base }), sub);
+  } finally { fsE2e.rmSync(base, { recursive: true, force: true }); }
+});
+
 test('rebaseRelativePaths: daagu shape — bare `app` from backend/ cwd', () => {
   const exists = (p) => p.endsWith(pathE2e.join('backend', 'app'));
   const cmd = 'grep -rn "rr_source\\|max_retries" app --include=*.py';

package/claude-plugin/scripts/project-root.js

@@ -14,16 +14,55 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 
+// Resolves to the project's CANONICAL index dir, skipping STRAY nested indexes.
+// A monorepo subdir (`daagu/backend`, `daagu/frontend`) can carry its own
+// `.code-graph/index.db` — a relic an older binary created — nested under the
+// real root's index. Returning the nearest such index made every consumer
+// (statusline gate, hooks) read a different DB per cwd (statusline "oscillation",
+// `✗ 0 nodes` in an empty subdir index). Mirror the Rust resolver: the start's
+// own index wins only if it is NOT a stray nested index (no indexed ancestor) OR
+// start is itself a project boundary (`.git`, i.e. a real submodule). Otherwise
+// prefer the project root: the nearest indexed `.git` root, else the outermost
+// indexed dir on the chain. `null` when nothing on start→…→home is indexed.
 function resolveProjectRoot(startDir, opts = {}) {
   const home = opts.home !== undefined ? opts.home : os.homedir();
   const exists = opts.exists || fs.existsSync;
-  let dir = path.resolve(startDir || '.');
+  const hasIndex = (d) => exists(path.join(d, '.code-graph', 'index.db'));
+  const hasGit = (d) => exists(path.join(d, '.git'));
+  const start = path.resolve(startDir || '.');
+
+  // Detect whether `start` is a STRAY nested index: walk STRICT ancestors up to
+  // the nearest `.git` root (project boundary), bounded at home. An indexed
+  // ancestor within that boundary means start's own index is a monorepo-subdir
+  // relic. Stop AT the git root — an index above it (e.g. `~/.code-graph`) is an
+  // unrelated outer project and must not poison this one.
+  let gitRootIndexed = null;
+  let ancestorIndexed = false;
+  let dir = start;
   for (;;) {
-    if (exists(path.join(dir, '.code-graph', 'index.db'))) return dir;
-    if (dir === home) return null;
     const parent = path.dirname(dir);
-    if (parent === dir) return null;
+    // Stop BEFORE home (and fs root): an index at/above home (e.g. ~/.code-graph
+    // from indexing a home dir) is an unrelated outer project, never a parent
+    // that makes `start` stray.
+    if (parent === dir || parent === home) break;
     dir = parent;
+    if (hasIndex(dir)) ancestorIndexed = true;
+    if (hasGit(dir)) { if (hasIndex(dir)) gitRootIndexed = dir; break; }
+  }
+
+  // start's own index wins unless it is stray (indexed ancestor within the git
+  // boundary) and start is not itself a boundary (`.git`, a real submodule).
+  if (hasIndex(start) && (!ancestorIndexed || hasGit(start))) return start;
+  if (gitRootIndexed) return gitRootIndexed;
+  // Otherwise the nearest indexed ancestor (skipping a stray start), bounded at
+  // home; null if nothing on the chain is indexed. Mirrors the original walk.
+  let d = hasIndex(start) ? path.dirname(start) : start;
+  for (;;) {
+    if (hasIndex(d)) return d;
+    if (d === home) return null;
+    const parent = path.dirname(d);
+    if (parent === d) return null;
+    d = parent;
   }
 }
 

package/claude-plugin/scripts/statusline.js

@@ -5,6 +5,7 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { findBinary } = require('./find-binary');
+const { resolveProjectRoot } = require('./project-root');
 const lifecycle = require('./lifecycle');
 const cleanupDisabledStatusline = lifecycle.cleanupDisabledStatusline || (() => ({ cleaned: false }));
 
@@ -24,14 +25,19 @@ function updatePending() {
 const disabledCleanup = cleanupDisabledStatusline();
 if (disabledCleanup.cleaned) process.exit(0);
 
-// Only show status in projects that have a code-graph directory.
-// The statusLine config is global, so we must exit silently for
-// directories that aren't code-graph projects.
-const cwd = process.cwd();
-const codeGraphDir = path.join(cwd, '.code-graph');
-if (!fs.existsSync(codeGraphDir)) {
+// Only show status in projects that have a code-graph directory. The statusLine
+// config is global, so we must exit silently for non-code-graph directories.
+// Walk UP to the canonical project root (resolveProjectRoot) rather than keying
+// on the bare process.cwd(): when the shell sits in a subdir, the bare-cwd gate
+// either showed a STRAY nested subdir index (monorepo relic — the statusline
+// "oscillating" between root/backend/frontend node counts) or, in a clean subdir
+// with no local index, showed nothing at all. The resolver skips stray nested
+// indexes, so the statusline tracks one DB — the project root — from any subdir.
+const root = resolveProjectRoot(process.cwd());
+if (!root) {
   process.exit(0);
 }
+const codeGraphDir = path.join(root, '.code-graph');
 
 // Check for background indexing progress file first
 const progressFile = path.join(codeGraphDir, 'indexing-status.json');
@@ -108,7 +114,11 @@ let errText = '';
 try {
   report = parseReport(execFileSync(bin, ['health-check', '--format', 'json'], {
     timeout: 3000,
-    stdio: ['pipe', 'pipe', 'pipe']
+    stdio: ['pipe', 'pipe', 'pipe'],
+    // Run the binary FROM the resolved root so its own project-root resolution
+    // lands on the same DB the gate above picked (a subdir cwd would otherwise
+    // re-resolve to a stray nested index inside the binary).
+    cwd: root
   }).toString());
 } catch (e) {
   // health-check exits NON-ZERO on an unhealthy/empty index but still writes the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdsrs/code-graph",
-  "version": "0.74.8",
+  "version": "0.75.1",
   "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.8",
-    "@sdsrs/code-graph-linux-arm64": "0.74.8",
-    "@sdsrs/code-graph-darwin-x64": "0.74.8",
-    "@sdsrs/code-graph-darwin-arm64": "0.74.8",
-    "@sdsrs/code-graph-win32-x64": "0.74.8"
+    "@sdsrs/code-graph-linux-x64": "0.75.1",
+    "@sdsrs/code-graph-linux-arm64": "0.75.1",
+    "@sdsrs/code-graph-darwin-x64": "0.75.1",
+    "@sdsrs/code-graph-darwin-arm64": "0.75.1",
+    "@sdsrs/code-graph-win32-x64": "0.75.1"
   }
 }