@sdsrs/code-graph 0.157.0 → 0.159.0

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

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

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

@@ -46,6 +46,8 @@ const {
   extractCgFlags,
   cgFlagSet,
   extractSearchPath,
+  bareSourceTarget,
+  firstShellClause,
   normalizeCommandPaths,
   rebaseRelativePaths,
   resolveProjectRoot,
@@ -263,6 +265,14 @@ function runMain() {
   markCooldown(rawCmd, root);
 
   const { segment, block } = found;
+  // D#73 — a bare dir names `<shell cwd>/src`. From a subdirectory shell (same
+  // guard as pre-grep-guide's runMain), or after anything earlier in the same
+  // command, that is not provably the root's src: round 2 found `cd x && grep`,
+  // round 3 reproduced 19 more forms that move the shell (`builtin cd`, `if cd`,
+  // `{ cd …; }`, `\cd`, `popd`, `eval`, a function). A denylist of those never
+  // closes, so a bare dir is answered only when the grep is the FIRST segment.
+  if (bareSourceTarget(firstShellClause(segment))
+      && (relPrefix || splitTopLevelSegments(cmd)[0] !== segment)) return;
   // Run the answer exactly like the deny path.
   const rawPattern = pickBlockPattern(segment);
   // Grep-response gate (2026-07-03 audit: 18/18 injects were 0 CONSUMED because they

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) ---
 
@@ -89,6 +89,30 @@ const SRC_PREFIXES =
 const SRC_PATH = new RegExp(`(?:^|\\s|["'])(${SRC_PREFIXES})/`);
 // Anchored variant for whole-token matching in extractSearchPath.
 const SRC_PATH_TOKEN = new RegExp(`^(?:\\./)?(${SRC_PREFIXES})/`);
+// A path operand the rewrite grammar proved: a bare prefix word (`src`), or a
+// `./`-rooted one with any subpath (`./src`, `./src/x/`), which SRC_PATH's
+// lookbehind never matched.
+const SRC_BARE_TOKEN = new RegExp(`^(?:(?:${SRC_PREFIXES})|\\./(?:${SRC_PREFIXES})(?:/.*)?)$`);
+
+// D#73 — a source dir written as a bare word (`grep -rn X src`, `rg X tests`,
+// `./src`): the shape models write when a prompt says "under src/", and it
+// matched nothing before. Recognized ONLY where rewritePlan's grammar proves the
+// word is the command's path operand. A regex over the text cannot tell: these
+// prefixes are English words (`server`, `tasks`) and import-path fragments
+// inside patterns, flag values (`rg -t cmd`, `ag --ignore tests`), halves of a
+// two-path or `$(…)` search, or the pattern itself (`grep -n tasks f.py`) —
+// pre-ship review round 1 reproduced each as a wrong hint or inject. Callers
+// in a subdirectory shell must not use it on an un-rebased word: there a bare
+// `src` is `<cwd>/src`, not the root's (see runMain). `.` and no path at all
+// stay out: they reach non-source files, and grep -r ignores .gitignore where
+// cg does not.
+function bareSourceTarget(clause) {
+  const plan = rewritePlan(clause);
+  return plan && plan.target !== undefined && SRC_BARE_TOKEN.test(plan.target) ? plan.target : null;
+}
+function namesSourcePath(clause) {
+  return SRC_PATH.test(clause) || bareSourceTarget(clause) !== null;
+}
 const PIPE_INTO_GREP = new RegExp(`\\|\\s*(?:${GREP_VERB})\\b`);
 const CG_INVOKED = /\bcode-graph-mcp\b/;
 // File argument(s) that end in a config/lockfile/data extension. If, after removing
@@ -184,11 +208,11 @@ function shouldHint(cmd) {
   // v0.96 — the source-path gate must see ONLY the grep's own args, not a path in
   // a non-grep tail (`grep X skills/a.py; wc scripts/b` must not fire on scripts/b).
   const clause = firstShellClause(cmd);
-  if (!SRC_PATH.test(clause)) return false;         // not against indexed source tree
+  if (!namesSourcePath(clause)) return false;       // not against indexed source tree
   // If a config file appears AND no source path remains after stripping it, skip.
   if (CONFIG_TARGET_ONLY.test(clause)) {
     const stripped = clause.replace(CONFIG_TARGET_STRIP, ' ');
-    if (!SRC_PATH.test(stripped)) return false;
+    if (!namesSourcePath(stripped)) return false;
   }
   return true;
 }
@@ -679,6 +703,13 @@ function extractSearchPath(cmd) {
   // v0.96 — scope to the grep's own clause so the answer is never scoped to a
   // path in a non-grep tail (the file the user actually grepped is the only one
   // the "already ran for you" answer may claim to have searched).
+  // D#73 — when the grammar proves a bare/`./` source operand, it is the scope.
+  // It must win over the text scan below, which takes the first path-shaped
+  // token and so can take a PATTERN (`grep -rn "./src/x" tests`) or cut a
+  // quoted operand at its space (pre-ship review round 2 B1, B2). The grammar
+  // rejects `..`, so no traversal reaches this return.
+  const bare = bareSourceTarget(firstShellClause(cmd));
+  if (bare) return bare;
   for (const raw of firstShellClause(cmd).split(/\s+/)) {
     const token = raw.replace(/^["']|["']$/g, '');
     if (!token || token.startsWith('-')) continue;
@@ -711,6 +742,11 @@ function countNamedPaths(cmd, patterns) {
     if (pats.has(tok)) continue;                    // the search pattern, not a path
     if (tok.includes('/') || /\.[A-Za-z0-9]{1,6}$/.test(tok)) n++;  // dir-sep or file extension
   }
+  // D#73 — the grammar's bare-dir operand is a named path too, counted like
+  // its `src/` spelling (whose loop pass counts it). The grammar admits one
+  // path operand, so this adds at most one.
+  const bare = bareSourceTarget(firstShellClause(cmd));
+  if (bare && !bare.includes('/') && !/\.[A-Za-z0-9]{1,6}$/.test(bare)) n++;
   return n;
 }
 
@@ -1141,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
@@ -1162,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
@@ -1183,6 +1272,9 @@ function runMain() {
   let cmd = normalizeCommandPaths(rawCmd, root);
   const relPrefix = path.relative(root, shellCwd);
   if (relPrefix) cmd = rebaseRelativePaths(cmd, relPrefix, root);
+  // D#73 — from a subdirectory, a bare dir the rebase left alone is `<cwd>/src`,
+  // which the root-relative answer would not search (pre-ship review round 1 H1).
+  if (relPrefix && bareSourceTarget(firstShellClause(cmd))) return;
   if (!shouldHint(cmd)) return;
 
   // v0.64 — fingerprint the grep's pattern once, shared by the emit points below.
@@ -1393,6 +1485,7 @@ module.exports = {
   extractUnansweredTail, // v0.50 — compound-tail honesty in answered denies
   extractPatterns,    // v0.32.1 — exposed for tests
   countNamedPaths,    // v0.70 — multi-path deny→hint downgrade
+  bareSourceTarget,      // D#73 — a bare source dir the rewrite grammar proves is the path operand
   isRevisionScopedGitGrep, // v0.71 — git grep --cached/treeish exclusion
   extractSearchPath,  // v0.47.0 — deny-with-answer
   normalizeCommandPaths, // v0.47.1 — abs-path matcher fix

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.157.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.157.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.157.0",
-    "@sdsrs/code-graph-linux-arm64": "0.157.0",
-    "@sdsrs/code-graph-darwin-x64": "0.157.0",
-    "@sdsrs/code-graph-darwin-arm64": "0.157.0",
-    "@sdsrs/code-graph-win32-x64": "0.157.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"
   }
 }