@sdsrs/code-graph 0.158.0 → 0.159.0

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

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

package/claude-plugin/scripts/pre-grep-guide.js

@@ -56,7 +56,7 @@ const {
   runGrepAnswer, runShowAnswer, sanitizeSearchPath, buildGrepArgs, formatCgCommand, shellQuoteArg,
   resolveAnswerBinary,
 } = require('./cg-answer');
-const { emitPreToolRewrite } = require('./hook-emit');
+const { emitPreToolRewrite, emitPreToolContext, MAX_INJECTED_BYTES } = require('./hook-emit');
 
 // --- Pure logic (testable) ---
 
@@ -1177,6 +1177,43 @@ function isAnswerDisabled(env = process.env) {
   return env.CODE_GRAPH_NO_ANSWER_IN_DENY === '1';
 }
 
+// Smallest per-dir share of the context cap worth spending on an overview answer.
+const MIN_FANOUT_ANSWER_BYTES = 400;
+
+/// Byte budget for each overview answer when several dirs fire in one command
+/// (undefined for one dir: the answer keeps its own default). Every hint first
+/// pays for its own lines — an answer's header, footer and separator are about
+/// 175 bytes plus the dir name twice, the one-line advice about 165 plus the
+/// name three times — reserved as 200 plus the name three times, and the
+/// answers share what is left of the cap. A share under MIN_FANOUT_ANSWER_BYTES
+/// returns 0: every dir then gets the one-line advice instead.
+function fanoutAnswerBudget(dirs) {
+  if (dirs.length < 2) return undefined;
+  const reserved = dirs.reduce((sum, d) => sum + 200 + 3 * Buffer.byteLength(d, 'utf8'), 0);
+  const share = Math.floor((MAX_INJECTED_BYTES - reserved) / dirs.length);
+  return share >= MIN_FANOUT_ANSWER_BYTES ? share : 0;
+}
+
+/// The fired dirs' hints as one context text. Every dir was marked delivered,
+/// so each must be named in it: once the next hint would leave no room for a
+/// line naming the dirs still to come, that line replaces the remaining hints.
+function joinFanoutHints(dirs, hints) {
+  const rest = (from) => `[code-graph] 5+ Reads also into ${dirs.slice(from).map((d) => `${d}/`).join(', ')} — \`code-graph-mcp overview <dir>/\` gives each dir's symbols+callers in one call.`;
+  const out = [];
+  let used = 0;
+  for (let i = 0; i < hints.length; i++) {
+    const need = Buffer.byteLength(hints[i], 'utf8') + (out.length ? 2 : 0);
+    const tail = i + 1 < hints.length ? Buffer.byteLength(rest(i + 1), 'utf8') + 2 : 0;
+    if (used + need + tail > MAX_INJECTED_BYTES) {
+      out.push(rest(i));
+      break;
+    }
+    out.push(hints[i]);
+    used += need;
+  }
+  return out.join('\n\n');
+}
+
 function runMain() {
   if (isSilenced()) return;
   // v0.48 — process.cwd() follows the persistent shell; resolve the project
@@ -1198,18 +1235,34 @@ function runMain() {
   // v0.49 — sed-range reads count toward the read-fanout state (the Read hook
   // never sees Bash-side file reads). A fired fanout hint already delivered an
   // overview — skip grep hinting for this command to avoid double output.
+  //
+  // Every dir that fired goes into ONE envelope. Claude Code parses a hook's
+  // stdout as a single JSON value: two envelopes (two dirs crossing in one
+  // compound command) were rejected whole, so the model saw neither hint while
+  // the state recorded both as delivered. The shared context cap is split
+  // between the answers, so a large first overview cannot truncate the second
+  // dir out of the envelope.
+  //
+  // No permission decision: this is a Bash call, and `allow` would skip the
+  // user's prompt for the WHOLE command (`sed -n 1,5p a.js; <anything>`). The
+  // read hook's allow envelope used to leak here because pre-read-guide wrote
+  // it from inside the shared tracker, out of hook-emit.test.js's allowlist view.
   const sedTargets = extractSedReadTargets(rawCmd);
   if (sedTargets.length > 0) {
     const readGuide = require('./pre-read-guide');
-    let fanoutFired = false;
+    const firedDirs = [];
     for (const t of sedTargets) {
       if (!readGuide.isSourceFile(t)) continue;
       const abs = path.isAbsolute(t) ? t : path.resolve(shellCwd, t);
-      if (readGuide.trackReadAndMaybeHint(root, path.relative(root, abs))) {
-        fanoutFired = true;
-      }
+      const dir = readGuide.trackRead(root, path.relative(root, abs));
+      if (dir !== null) firedDirs.push(dir);  // a dir fires once: markHint starts its cooldown
+    }
+    if (firedDirs.length > 0) {
+      const maxBytes = fanoutAnswerBudget(firedDirs);
+      const hints = firedDirs.map((dir) => readGuide.buildFanoutHint(root, dir, { maxBytes }));
+      process.stdout.write(emitPreToolContext(joinFanoutHints(firedDirs, hints)) + '\n');
+      return;
     }
-    if (fanoutFired) return;
   }
 
   // v0.47.1 — match against the root-stripped form so absolute paths under the

package/claude-plugin/scripts/pre-read-guide.js

@@ -157,13 +157,14 @@ function isAnswerDisabled(env = process.env) {
 
 // --- Shared tracking core (also driven by pre-grep-guide's sed-range path) ---
 
-/// Record one read of `rel` (project-root-relative source path) and fire the
-/// fanout hint when the threshold crosses. Emits to stdout + records the
-/// recommendation. Returns true when a hint fired.
-function trackReadAndMaybeHint(root, rel, now = Date.now()) {
-  if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) return false;
+/// Record one read of `rel` (project-root-relative source path). Returns the
+/// dir when this read crossed the fanout threshold (the hint is marked as
+/// delivered), else null. Writes nothing to stdout: a hook's stdout is parsed as
+/// ONE JSON value, so only the entry point may write, and only once.
+function trackRead(root, rel, now = Date.now()) {
+  if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) return null;
   const dir = path.dirname(rel);
-  if (!dir || dir === '.' || dir === '') return false;  // top-level file: not fanout
+  if (!dir || dir === '.' || dir === '') return null;  // top-level file: not fanout
 
   const state = loadState(root, now);
   recordRead(state, dir, now);
@@ -178,12 +179,21 @@ function trackReadAndMaybeHint(root, rel, now = Date.now()) {
     // Record it (best-effort) so `stats` can measure the model's read fan-out —
     // e.g. a read right after cg answered a grep in-place (search-decay).
     recordRecommendation(root, { hook: 'read', action: 'observe' });
-    return false;
+    return null;
   }
+  return dir;
+}
 
+/// The fanout hint text for `dir`, with the overview answer embedded when the
+/// CLI delivers one. `maxBytes` bounds that answer — the pre-grep sed path
+/// splits one envelope's budget between several dirs.
+function buildFanoutHint(root, dir, { maxBytes } = {}) {
   let answer = { status: 'unavailable' };
-  if (!isAnswerDisabled()) {
-    answer = runOverviewAnswer({ cwd: root, dir });
+  if (maxBytes === 0) {
+    // No room left in a shared envelope: the advice line, and no CLI run.
+    answer = { status: 'unavailable', reason: 'budget' };
+  } else if (!isAnswerDisabled()) {
+    answer = runOverviewAnswer({ cwd: root, dir, ...(maxBytes ? { maxBytes } : {}) });
   }
   const answered = answer.status === 'hits';
   recordRecommendation(root, {
@@ -202,14 +212,14 @@ function trackReadAndMaybeHint(root, rel, now = Date.now()) {
     ...(answered ? {} : { reason: answer.status }),
     ...(answered || !answer.reason ? {} : { fallthrough_reason: answer.reason }),
   });
-  // Compound-grep sibling sweep: emit via the PreToolUse allow+additionalContext
-  // envelope (shared hook-emit.js). Bare stdout on a PreToolUse exit-0 lands in
-  // the debug log only and never reaches the model (CC docs v2026-06); the
-  // additionalContext channel is what actually surfaces the fanout hint. Read is
-  // a safe tool, so the allow elevation is negligible.
-  const hintText = answered ? buildHintWithAnswer(dir, answer) : buildHint(dir);
-  process.stdout.write(emitPreToolAllowContext(hintText) + '\n');
-  return true;
+  return answered ? buildHintWithAnswer(dir, answer) : buildHint(dir);
+}
+
+/// trackRead + buildFanoutHint for one read. Returns the hint text when the
+/// hint fired, else null. The caller emits it.
+function trackReadAndMaybeHint(root, rel, now = Date.now()) {
+  const dir = trackRead(root, rel, now);
+  return dir === null ? null : buildFanoutHint(root, dir);
 }
 
 // --- Main execution ---
@@ -237,7 +247,13 @@ function runMain() {
     rel = path.relative(root, filePath);
   } catch { return; }
 
-  trackReadAndMaybeHint(root, rel);
+  const hint = trackReadAndMaybeHint(root, rel);
+  // Emit via the PreToolUse allow+additionalContext envelope (shared
+  // hook-emit.js). Bare stdout on a PreToolUse exit-0 lands in the debug log
+  // only and never reaches the model (CC docs v2026-06); the additionalContext
+  // channel is what actually surfaces the fanout hint. Read is a safe tool, so
+  // the allow elevation is negligible.
+  if (hint) process.stdout.write(emitPreToolAllowContext(hint) + '\n');
 }
 
 if (require.main === module) {
@@ -249,5 +265,6 @@ module.exports = {
   loadState, saveState, recordRead, shouldHint, markHint,
   buildHint, buildHintWithAnswer, isSilenced, isAnswerDisabled,
   trackReadAndMaybeHint,   // v0.49 — shared with pre-grep-guide's sed-range path
+  trackRead, buildFanoutHint,  // the sed path's two halves: one envelope for every dir that fired
   FANOUT_THRESHOLD, COOLDOWN_MS, STATE_TTL_MS, SRC_EXT,
 };

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.158.0 code-graph-mcp snapshot create --out snapshot.db
+          npx -y -p @sdsrs/code-graph@0.159.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.158.0",
+  "version": "0.159.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.158.0",
-    "@sdsrs/code-graph-linux-arm64": "0.158.0",
-    "@sdsrs/code-graph-darwin-x64": "0.158.0",
-    "@sdsrs/code-graph-darwin-arm64": "0.158.0",
-    "@sdsrs/code-graph-win32-x64": "0.158.0"
+    "@sdsrs/code-graph-linux-x64": "0.159.0",
+    "@sdsrs/code-graph-linux-arm64": "0.159.0",
+    "@sdsrs/code-graph-darwin-x64": "0.159.0",
+    "@sdsrs/code-graph-darwin-arm64": "0.159.0",
+    "@sdsrs/code-graph-win32-x64": "0.159.0"
   }
 }