@sdsrs/code-graph 0.169.0 → 0.170.0

package/README.md

@@ -201,7 +201,7 @@ What you get:
 - **Skills** — `explore` (structure-first navigation before reading files) and `index` (health-check / re-index / full rebuild); see [Plugin Skills](#plugin-skills)
 - **Code Explorer Agent** — Deep code understanding expert via `code-explorer`
 - **Auto-indexing Hook** — Incremental index on every file edit (PostToolUse)
-- **StatusLine** — Real-time health display (nodes, files, watch status) — compatible with other plugins' StatusLine via composite multiplexer
+- **StatusLine** — Real-time health display (nodes, files, watch status) and what code-graph did in this session (`5 answers · 2 calls`: answers its grep, edit, read, subagent and Stop hooks delivered to Claude, code-graph queries Claude ran) — compatible with other plugins' StatusLine via composite multiplexer
 - **Auto-update** — Checks for a new version at session start (throttled to at most one check every 2 minutes). Between forced checks the re-check interval is 30 minutes after an "up to date" answer and 6 hours while an update is already pending. Updates install silently.
 
 #### Manual Update
@@ -552,6 +552,7 @@ defaults are what you get by doing nothing.
 | `CODE_GRAPH_VERBOSE_HOOKS=1` | The opposite: opt into the noisy form. |
 | `CODE_GRAPH_NO_BLOCK_GREP=1` | Never turn a `grep` hint into a block — prefix a single command with it to get past one. |
 | `CODE_GRAPH_NO_INJECT=1` | No post-tool AST context injection. |
+| `CODE_GRAPH_STATUSLINE_COUNTS=0` | Drop the session counts (`5 answers · 2 calls`) from the statusline. |
 | `CODE_GRAPH_HOOK_INDEX=on\|off` | Force the incremental-index hook on or off instead of letting it decide. |
 | `CODE_GRAPH_MODEL_DIR=<dir>` | Load the embedding model from here (air-gapped installs). |
 | `CODE_GRAPH_DISABLE_MODEL_DOWNLOAD=1` | Never fetch the model; fail instead. |
@@ -609,6 +610,7 @@ plugins' entries. An installer that reads exit codes must not treat it as
 | Variable | Set by | Purpose |
 |---|---|---|
 | `CODE_GRAPH_STATUSLINE_CWD` | statusline-composite | Forwards Claude Code's authoritative cwd to each statusline provider. |
+| `CODE_GRAPH_STATUSLINE_SESSION` | statusline-composite | Forwards the stdin `session_id` (UUID-shaped only), so the code-graph segment counts this session's answers and calls. |
 | `CODE_GRAPH_STATUSLINE_DEBUG` | test suite | Makes statusline-composite print why it dropped a provider instead of swallowing the error. Off by default so a broken third-party provider stays silent in a real statusline. |
 | `CODE_GRAPH_INSTALL_LOCK_HELD` | launcher | Tells a child that the parent already holds the install lock, so it does not deadlock. |
 | `CODE_GRAPH_AUTO_UPDATE_SILENT` | session-init | Runs the update check without console output. |

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

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

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

@@ -559,8 +559,69 @@ function runCallgraphAnswer(opts = {}) {
   }
 }
 
+// A definition label longer than this is cut (a C++ or Go qualified name can
+// keep text from its declaration).
+const DEFINITION_LABEL_MAX = 160;
+
+/**
+ * Where exactly `symbol` is defined in `file`: `show <symbol> --file <file>
+ * --json`, kept only when ONE row in that file carries the name (`X`, a
+ * qualified `Cls.X` or `mod::X`). The outside-path grep inject names this in
+ * place of a command to run (tasks/specs/outside-path-definition-answer.md):
+ * the model's next step after that pointer was a read of the definition, not
+ * a code-graph call (0 of 45 such pointers was followed by a code-graph call
+ * within 10 tool calls; 23 by a Read of the defining file or a Bash/Grep call
+ * naming it).
+ *
+ * `label` is `<type> <name>` on one line, whitespace collapsed, at most
+ * DEFINITION_LABEL_MAX characters (`…` when cut). No signature: each
+ * extractor writes its own shape, and the lines are what the next read needs.
+ * @returns {{status: 'hits', start: number, end: number, label: string}
+ *         | {status: 'several'} | {status: 'no-hits'}
+ *         | {status: 'no-binary'} | {status: 'unavailable', reason?: 'budget'}}
+ */
+function runDefinitionAnswer(opts = {}) {
+  const { cwd, symbol, file, timeoutMs = DEFAULT_TIMEOUT_MS } = opts;
+  try {
+    if (typeof symbol !== 'string' || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(symbol)
+        || typeof file !== 'string' || !file) {
+      return { status: 'unavailable' };
+    }
+    const binary = resolveAnswerBinary(opts);
+    if (!binary) return { status: 'no-binary' };
+    // --compact: the rows without `code_content` (a whole class body otherwise).
+    const res = runCg(binary, ['show', symbol, '--file', file, '--json', '--compact'], { cwd, timeoutMs });
+    const verdict = classifyRun(res, { exitOneIsNoHits: true });
+    if (verdict !== 'ok') {
+      return { status: verdict, ...(res.budgetExhausted ? { reason: 'budget' } : {}) };
+    }
+    let rows;
+    try {
+      rows = JSON.parse(res.stdout || '');
+    } catch {
+      return { status: 'unavailable' };
+    }
+    if (!Array.isArray(rows)) return { status: 'unavailable' };
+    const named = rows.filter((r) => r && r.file_path === file && typeof r.name === 'string'
+      && (r.name === symbol || r.name.endsWith(`.${symbol}`) || r.name.endsWith(`::${symbol}`)));
+    if (named.length === 0) return { status: 'no-hits' };
+    if (named.length > 1) return { status: 'several' };
+    const r = named[0];
+    if (!Number.isInteger(r.start_line) || !Number.isInteger(r.end_line)) return { status: 'unavailable' };
+    let label = `${r.type || 'symbol'} ${r.name}`
+      // U+0085 and U+001C-1E too: JS `\s` lacks them, and a reader splitting
+      // lines (Python's splitlines) breaks on them.
+      .replace(/[\s\u0085\u001c-\u001e]+/g, ' ').trim();
+    const chars = [...label];
+    if (chars.length > DEFINITION_LABEL_MAX) label = chars.slice(0, DEFINITION_LABEL_MAX - 1).join('') + '…';
+    return { status: 'hits', start: r.start_line, end: r.end_line, label };
+  } catch {
+    return { status: 'unavailable' };
+  }
+}
+
 module.exports = {
-  runGrepAnswer, runShowAnswer, runOverviewAnswer, runCallgraphAnswer,
+  runGrepAnswer, runShowAnswer, runOverviewAnswer, runCallgraphAnswer, runDefinitionAnswer,
   truncateAtLine, sanitizeSearchPath,
   // The one argv builder + its renderer, so the deny copy and the child process
   // cannot describe different commands.

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

@@ -36,7 +36,9 @@ const { recordRecommendation } = require('./recommendation-log');
 // `sanitizeSearchPath` is deliberately NOT imported any more: this hook passes
 // the RAW path so buildGrepArgs can split a glob into scope + `-g` instead of
 // widening it away. Leaving the require behind would read as "still used".
-const { runGrepAnswer, runShowAnswer, runCallgraphAnswer, shellQuoteArg, formatCgCommand } = require('./cg-answer');
+const {
+  runGrepAnswer, runShowAnswer, runCallgraphAnswer, runDefinitionAnswer, shellQuoteArg,
+} = require('./cg-answer');
 const { emitPostToolContext } = require('./hook-emit');
 const {
   splitTopLevelSegments,
@@ -214,7 +216,10 @@ const CALLGRAPH_HEADER =
 // is looking; a same-named symbol's 4 KB call tree from elsewhere is not about
 // that place (a grep in tests/cli_e2e.rs got `indexed_project`'s tree from
 // src/indexer/resync.rs). Its location was the useful part, so that is what it
-// gets: one pointer line.
+// gets: one line. It used to end in the `callgraph` command for the tree; no
+// session ran it (0 of 45, 0.164.0 to 2026-10-16) and the next step was a read
+// of the definition, so the line carries the definition's lines, type and name
+// instead when `show` names exactly one (tasks/specs/outside-path-definition-answer.md).
 
 /** The file on a `callgraph` answer's root line (`name (path)`), or null. */
 function definitionFile(text) {
@@ -236,9 +241,14 @@ function searchCovers(searchPath, file) {
   return file === p || file.startsWith(p + '/');
 }
 
-function buildPointerText(symbol, file, searchPath) {
-  return `[code-graph] ${symbol} is defined in ${shellQuoteArg(file)}, outside the path your grep ` +
-    `searched (${shellQuoteArg(searchPath)}). Its callers and callees: ${formatCgCommand(['callgraph', symbol])}`;
+/** @param {object} [def] a runDefinitionAnswer result; only `hits` adds lines, type and name. */
+function buildPointerText(symbol, file, searchPath, def) {
+  const where = `${symbol} is defined in ${shellQuoteArg(file)}`;
+  const outside = `outside the path your grep searched (${shellQuoteArg(searchPath)})`;
+  if (def && def.status === 'hits') {
+    return `[code-graph] ${where}:${def.start}-${def.end}, ${outside}: ${def.label}`;
+  }
+  return `[code-graph] ${where}, ${outside}.`;
 }
 
 function buildInjectText(answer, mode) {
@@ -520,7 +530,8 @@ function runMain() {
     ...(outside ? { scope: 'outside' } : {}),
   });
   const text = outside
-    ? buildPointerText(answeredSymbol, rootFile, searchPath)
+    ? buildPointerText(answeredSymbol, rootFile, searchPath,
+      runDefinitionAnswer({ cwd: root, symbol: answeredSymbol, file: rootFile }))
     : buildInjectText(answer, answeredMode);
   process.stdout.write(emitPostToolContext(text) + '\n');
 }

package/claude-plugin/scripts/recommendation-log.js

@@ -158,6 +158,16 @@ function rotateIfNeeded(file) {
   }
 }
 
+// The first 8 hex digits, lowercased, of a UUID-shaped Claude Code session id
+// (CLAUDE_CODE_SESSION_ID, which Claude Code sets for every hook and tool
+// child), else null. Rust `cli::session_tag` is the twin for the CLI's `use`
+// rows, so one session's rows from both writers share a tag; the statusline
+// counts this session's answers and calls by it.
+const SESSION_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function sessionTag(raw) {
+  return typeof raw === 'string' && SESSION_ID.test(raw) ? raw.slice(0, 8).toLowerCase() : null;
+}
+
 /**
  * Append one recommendation event to <cwd>/.code-graph/recommendations.jsonl.
  * @param {string} cwd        project root (the hook's process.cwd())
@@ -187,7 +197,9 @@ function recordRecommendation(cwd, event = {}) {
     const file = path.join(dir, REC_FILE);
     if (!isOwnedPath(file, 'file')) return false;
     rotateIfNeeded(file); // rotate-before-append so the file never exceeds ~max + one line
-    const line = JSON.stringify({ ts: new Date().toISOString(), ...event }) + '\n';
+    const { session: _ignored, ...fields } = event;
+    const session = sessionTag(process.env.CLAUDE_CODE_SESSION_ID);
+    const line = JSON.stringify({ ts: new Date().toISOString(), ...fields, ...(session ? { session } : {}) }) + '\n';
     const fd = openOwned(
       file,
       fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_APPEND
@@ -204,4 +216,4 @@ function recordRecommendation(cwd, event = {}) {
   }
 }
 
-module.exports = { recordRecommendation, REC_FILE, isOwnedPath, openOwned };
+module.exports = { recordRecommendation, REC_FILE, isOwnedPath, openOwned, sessionTag };

package/claude-plugin/scripts/statusline-composite.js

@@ -127,7 +127,16 @@ function runProvider(command, needsStdin, stdin, id) {
     // to `_previous`/third-party providers, which ignore the unknown var. The
     // CODE_GRAPH_ prefix (not CLAUDE_) keeps it out of Claude Code's own namespace.
     const cwd = cwdFromStdin(stdin);
-    const env = cwd ? { ...process.env, CODE_GRAPH_STATUSLINE_CWD: cwd } : process.env;
+    // Likewise the session id: the code-graph segment counts this session's
+    // answers and calls by it. Only a UUID-shaped id is forwarded.
+    const session = sessionFromStdin(stdin);
+    const env = (cwd || session)
+      ? {
+        ...process.env,
+        ...(cwd ? { CODE_GRAPH_STATUSLINE_CWD: cwd } : {}),
+        ...(session ? { CODE_GRAPH_STATUSLINE_SESSION: session } : {}),
+      }
+      : process.env;
 
     const out = execFileSync(argv[0], argv.slice(1), hidden({
       timeout: 3000,
@@ -217,6 +226,18 @@ function cwdFromStdin(stdin) {
   } catch { return null; }
 }
 
+// Claude Code's session id from the stdin JSON context, when UUID-shaped
+// (the only shape both session-tag rules accept); null otherwise.
+const SESSION_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function sessionFromStdin(stdin) {
+  if (!stdin) return null;
+  try {
+    const v = JSON.parse(stdin);
+    const id = v && v.session_id;
+    return typeof id === 'string' && SESSION_ID.test(id) ? id : null;
+  } catch { return null; }
+}
+
 /// Shell constructs a direct `execFileSync` cannot honour at all: pipelines,
 /// redirection, sequencing, command substitution, backgrounding.
 ///

package/claude-plugin/scripts/statusline.js

@@ -214,4 +214,70 @@ try {
   errText = [(e && e.stderr) || '', (e && e.stdout) || ''].map(String).join('\n');
 }
 
-process.stdout.write(report ? renderHealth(report) : statusUnavailable(errText));
+// This session's code-graph activity (tasks/specs/statusline-session-counts.md):
+// answers a hook delivered to the model, and code-graph commands the model ran
+// itself. Without it the user cannot see code-graph working at all — every
+// answer reaches the model silently. Rows are matched by the `session` tag
+// both recorders stamp; the id comes from the composite's stdin payload.
+// Kinds that delivered code-graph content (an unanswered hint or deny carried
+// only advice; observe/bypass/follow-up rows delivered nothing).
+const ANSWER_KINDS = [
+  ['grep', 'deny', true], ['grep', 'inject', true], ['edit', 'hint', true], ['read', 'hint', true],
+  ['subagent', 'subagent_context', null], ['stop', 'stop_check', null],
+];
+// Read no more than the rotation's keep size: the log is ~1 MB at most, and a
+// render runs on every frame.
+const COUNTS_TAIL_BYTES = 524288;
+
+function sessionCounts(dir, tag) {
+  const { isOwnedPath, openOwned, REC_FILE } = require('./recommendation-log');
+  const what = 'statusline';
+  let dirStat;
+  try { dirStat = fs.lstatSync(dir); } catch { return null; }
+  if (!isOwnedPath(dir, 'dir', dirStat, what)) return null;
+  const file = path.join(dir, REC_FILE);
+  if (!isOwnedPath(file, 'file', undefined, what)) return null;
+  let fd;
+  try {
+    // O_NONBLOCK: a FIFO planted in the repo must not hold the render.
+    fd = openOwned(file, fs.constants.O_RDONLY | (fs.constants.O_NONBLOCK || 0), what);
+  } catch { return null; }
+  if (fd === null) return null;
+  let text;
+  try {
+    const size = fs.fstatSync(fd).size;
+    const len = Math.min(size, COUNTS_TAIL_BYTES);
+    const buf = Buffer.alloc(len);
+    fs.readSync(fd, buf, 0, len, size - len);
+    text = buf.toString('utf8');
+  } catch { return null; } finally { fs.closeSync(fd); }
+  let answers = 0;
+  let calls = 0;
+  for (const line of text.split('\n')) {
+    // Cheap prefilter on the tag alone; the parsed field decides.
+    if (!line.includes(tag)) continue;
+    let r;
+    try { r = JSON.parse(line); } catch { continue; }
+    if (!r || r.session !== tag) continue;
+    if (r.hook === 'cli' && r.action === 'use') calls++;
+    else if (ANSWER_KINDS.some(([h, a, ans]) => r.hook === h && r.action === a && (ans === null || r.answered === ans))) answers++;
+  }
+  return { answers, calls };
+}
+
+function renderSessionCounts() {
+  if (process.env.CODE_GRAPH_STATUSLINE_COUNTS === '0') return '';
+  try {
+    const { sessionTag } = require('./recommendation-log');
+    const tag = sessionTag(process.env.CODE_GRAPH_STATUSLINE_SESSION);
+    if (!tag) return '';
+    const c = sessionCounts(codeGraphDir, tag);
+    if (!c) return '';
+    const parts = [];
+    if (c.answers) parts.push(`${c.answers} answer${c.answers === 1 ? '' : 's'}`);
+    if (c.calls) parts.push(`${c.calls} call${c.calls === 1 ? '' : 's'}`);
+    return parts.length ? ` | ${parts.join(' · ')}` : '';
+  } catch { return ''; }
+}
+
+process.stdout.write(report ? renderHealth(report) + renderSessionCounts() : statusUnavailable(errText));

package/claude-plugin/templates/code-graph-snapshot.yml

@@ -35,7 +35,7 @@ jobs:
           node-version: '20'
       - name: Build snapshot
         run: |
-          npx -y -p @sdsrs/code-graph@0.169.0 code-graph-mcp snapshot create --out snapshot.db
+          npx -y -p @sdsrs/code-graph@0.170.0 code-graph-mcp snapshot create --out snapshot.db
           zstd -9 snapshot.db -o snapshot.db.zst
           mv snapshot.db.zst "code-graph-snapshot-${GITHUB_SHA:0:7}.db.zst"
       - name: Upload to release

package/package.json

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