@sdsrs/code-graph 0.160.0 → 0.161.0

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

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

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

@@ -347,10 +347,45 @@ function runGrepAnswer(opts = {}) {
  *   `no-binary` distinguishes a missing/unlocatable binary from a runtime
  *   `unavailable`, so the deny funnel can see a dark flagship answer-in-deny.
  */
+/**
+ * The files of the definitions a `show` printed: each definition opens with an
+ * unindented header `<kind> <name>  <path>:<start>-<end>  <signature>`, its body
+ * indented below. null when an unindented line is not such a header, so a
+ * caller that must account for every definition can refuse.
+ */
+function showDefinitionFiles(out) {
+  const defs = [];
+  for (const line of out.split('\n')) {
+    if (line === '' || /^\s/.test(line)) continue;
+    const m = /^(\S+) \S+ {2}(\S+):\d+-\d+(?: |$)/.exec(line);
+    if (!m) return null;
+    defs.push({ kind: m[1], file: m[2] });
+  }
+  return defs.length ? defs : null;
+}
+
+/** Whether a root-relative file lies under a grep path ('' = the whole root). */
+function pathWithin(file, within) {
+  const w = within.replace(/^(\.\/)+/, '').replace(/\/+$/, '');
+  return w === '' || w === '.' || file === w || file.startsWith(w + '/');
+}
+
 function runShowAnswer(opts = {}) {
   const {
     cwd,
     symbols,
+    // A grep path the answer must stay inside (D#125 #2): `show` prints every
+    // same-named definition in the project. With `within`, a symbol is answered
+    // only when EVERY definition `show` prints lies inside the path and is one
+    // the grep's declaration keyword matches (`kinds`: symbol → the label and
+    // file-extension shapes it matches); a symbol with no definition inside is
+    // skipped (the grep finds none either), and any other mix refuses the whole
+    // answer. Narrowing with `show --file` was tried and removed: the label is
+    // coarser than the keyword, so a narrowed answer dropped real matches, and
+    // the inject printed the unnarrowed text (review of D#125, round 2).
+    // undefined: unscoped, as before.
+    within,
+    kinds,
     timeoutMs = DEFAULT_TIMEOUT_MS,
     maxBytes = DEFAULT_MAX_BYTES,
   } = opts;
@@ -365,6 +400,8 @@ function runShowAnswer(opts = {}) {
     // Which symbols actually resolved — the rewrite re-runs exactly these, so a
     // symbol that printed nothing here cannot turn into an exit-1 in the Bash call.
     const resolved = [];
+    // The argv that re-runs each resolved symbol, scoped when `within` is set.
+    const argvs = [];
     for (const sym of symbols.slice(0, 3)) {
       if (typeof sym !== 'string' || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(sym)) continue;
       const res = runCg(binary, ['show', sym], { cwd, timeoutMs });
@@ -383,12 +420,24 @@ function runShowAnswer(opts = {}) {
       if (classifyRun(res, { exitOneIsNoHits: false }) !== 'ok') continue;
       const out = (res.stdout || '').trim();
       if (isEmptyAnswer(out)) continue;
-      parts.push(`$ code-graph-mcp show ${sym}\n${out}`);
+      const argv = ['show', sym];
+      if (within !== undefined) {
+        const defs = showDefinitionFiles(out);
+        if (!defs) return { status: 'unavailable', reason: 'scope' };
+        if (!defs.some((d) => pathWithin(d.file, within))) continue;
+        const shapes = (kinds && kinds[sym]) || [];
+        const ext = (f) => (f.match(/\.([A-Za-z0-9]+)$/) || [])[1];
+        const matches = (d) => pathWithin(d.file, within)
+          && shapes.some((k) => k.labels.includes(d.kind) && k.exts.includes(ext(d.file)));
+        if (!defs.every(matches)) return { status: 'unavailable', reason: 'scope' };
+      }
+      parts.push(`$ code-graph-mcp ${argv.join(' ')}\n${out}`);
       resolved.push(sym);
+      argvs.push(argv);
     }
     if (parts.length === 0) return { status: 'no-hits' };
     const { text, truncated } = truncateAtLine(parts.join('\n\n'), maxBytes);
-    return { status: 'hits', text, truncated, symbols: resolved };
+    return { status: 'hits', text, truncated, symbols: resolved, argvs };
   } catch {
     return { status: 'unavailable' };
   }

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

@@ -52,6 +52,11 @@ const {
   operandMatches,
   firstShellClause,
   normalizeCommandPaths,
+  rootOnlyInSearchPath,
+  grepSearchesNoDirectory,
+  isDirectory,
+  declKindsBySymbol,
+  extractPatterns,
   rebaseRelativePaths,
   resolveProjectRoot,
 } = require('./pre-grep-guide');
@@ -288,6 +293,11 @@ function runMain() {
   if (segCwd === null) return;
   if ((segCwd !== root || relPrefix)
       && !operandMatches(firstShellClause(rawSegs[idx]), extractSearchPath(segment), root, segCwd)) return;
+  // D#125 #1 — the root strip rewrote a pattern that held the root.
+  if (!rootOnlyInSearchPath(rawSegs[idx], root, extractSearchPath(segment))) return;
+  // D#125 #3 — a plain grep without -r searched no directory.
+  if (grepSearchesNoDirectory(firstShellClause(segment), extractSearchPath(segment),
+    (t) => isDirectory(path.resolve(root, t)))) 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
@@ -382,7 +392,14 @@ function runMain() {
   if (answer.status !== 'hits') {
     if (block.mode === 'show') {
       answeredMode = 'show';
-      answer = runShowAnswer({ cwd: root, symbols: block.symbols });
+      // Scoped like the rewrite: the grep's path and declaration kinds; a grep
+      // with a file filter gets the grep answer, which honors it.
+      answer = flags.includes('-g') || flags.includes('-t')
+        ? { status: 'unavailable' }
+        : runShowAnswer({
+          cwd: root, symbols: block.symbols, within: searchPath ?? '',
+          kinds: declKindsBySymbol(extractPatterns(segment)),
+        });
       if (answer.status !== 'hits' && pattern) {
         answeredMode = 'grep';
         answer = runGrepAnswer({ cwd: root, pattern, searchPath, flags });

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

@@ -376,6 +376,38 @@ function clauseWords(s) {
 // name the exact symbols the model wants to READ — extract them for `show`.
 const DECL_SYMBOL = /(?:fn|def|class|function|struct|impl|trait)\s+([A-Za-z_][A-Za-z0-9_]*)/g;
 
+// What a `show` definition must be for the grep's declaration keyword to match
+// its line: the kind label `show` prints (src/cli/symbols.rs
+// format_node_compact) AND a file of a language that spells the declaration
+// with that keyword. The label alone is coarser than the keyword — `fn` is also
+// a Python `def` and a TS method, and a Swift `struct` is labelled `class`
+// (review of D#125, round 2). `impl` names no definition of its own.
+const DECL_KEYWORD_SHAPES = {
+  fn: { labels: ['fn'], exts: ['rs'] },
+  def: { labels: ['fn'], exts: ['py', 'rb'] },
+  function: { labels: ['fn'], exts: ['js', 'mjs', 'cjs', 'jsx', 'ts', 'tsx', 'php', 'sh', 'bash'] },
+  class: {
+    labels: ['class'],
+    exts: ['py', 'js', 'mjs', 'cjs', 'jsx', 'ts', 'tsx', 'java', 'kt', 'cs', 'php', 'rb', 'dart',
+      'cpp', 'cc', 'hpp', 'h', 'scala'],
+  },
+  struct: { labels: ['struct'], exts: ['rs', 'go', 'c', 'h', 'cpp', 'cc', 'hpp', 'cs'] },
+  trait: { labels: ['trait', 'iface'], exts: ['rs', 'php', 'scala'] },
+  impl: { labels: [], exts: [] },
+};
+
+// Symbol → the (label, extension) shapes its declaration keywords match
+// (`fn foo\|def foo` → foo: Rust fn, Python/Ruby def).
+function declKindsBySymbol(patterns) {
+  const out = {};
+  for (const p of patterns) {
+    for (const m of p.matchAll(/\b(fn|def|class|function|struct|impl|trait)\s+([A-Za-z_][A-Za-z0-9_]*)/g)) {
+      (out[m[2]] = out[m[2]] || []).push(DECL_KEYWORD_SHAPES[m[1]]);
+    }
+  }
+  return out;
+}
+
 function extractDeclSymbols(patterns) {
   const out = [];
   for (const p of patterns) {
@@ -656,6 +688,30 @@ function normalizeCommandPaths(cmd, cwd) {
   return cmd.split(cwd.endsWith('/') ? cwd : cwd + '/').join('');
 }
 
+// D#125 #1 — the strip above cannot tell a path operand from a PATTERN, and
+// strips both: `grep -rn "<root>/Foo" src/` searches the literal text
+// `<root>/Foo`, but was answered for `Foo`. Re-picking the pattern with the
+// root marked was tried first and missed shapes where the mark changes which
+// word is picked (`"<root>/def foo"`, `"abc_<root>/def"`: review of D#125). The
+// narrow form: every shell word that holds `<root>/` must BE the search path
+// the answer scopes to; anything else runs as typed.
+function rootOnlyInSearchPath(cmd, cwd, target) {
+  if (!cmd || typeof cmd !== 'string') return true;
+  if (!cwd || typeof cwd !== 'string' || cwd === '/') return true;
+  const prefix = cwd.endsWith('/') ? cwd : cwd + '/';
+  if (!cmd.includes(prefix)) return true;
+  // Round 2: counting words was not enough — a lone root-holding PATTERN whose
+  // stripped text equals the path (`grep -rn "<root>/src/x" src/x`) passed. The
+  // rewrite grammar names which word is the path operand: accept only a command
+  // it reads, with the root once, in that operand, and nowhere in the pattern.
+  if (cmd.split(prefix).length !== 2) return false;
+  const plan = rewritePlan(firstShellClause(cmd), { isDir: () => true });
+  if (!plan || plan.target === undefined || plan.pattern.includes(prefix)) return false;
+  if (!plan.target.startsWith(prefix)) return false;
+  const norm = (p) => p.replace(/^(?:\.\/)+/, '').replace(/\/+$/, '');
+  return target !== undefined && norm(plan.target.slice(prefix.length)) === norm(target);
+}
+
 // v0.48 — subdir-cwd fix; v0.49 — extracted to project-root.js so the read
 // hook shares it. Re-exported below for test/back-compat.
 const { resolveProjectRoot } = require('./project-root');
@@ -1245,6 +1301,7 @@ function rewritePlan(cmd, { isDir = looksLikeDir } = {}) {
   let context = false;
   let endOfFlags = false;
   let include = false;
+  let recursive = false;
   for (; i < words.length; i++) {
     const w = words[i];
     if (!w.anyQuoted && (w.text === '2>&1' || w.text === '2>/dev/null')) continue;
@@ -1267,6 +1324,7 @@ function rewritePlan(cmd, { isDir = looksLikeDir } = {}) {
       const name = w.text.slice(2, eq === -1 ? undefined : eq);
       if (!ALLOWED_LONG[verb].has(name)) return null;
       if (name === 'include') include = true;
+      if (name === 'recursive') recursive = true;
       if (VALUE_LONG.has(name) && eq === -1) {
         const v = words[++i];
         if (!valueWordOk(v, false) || (name === 'include' && /^!|\{/.test(v.text))) return null;
@@ -1290,6 +1348,7 @@ function rewritePlan(cmd, { isDir = looksLikeDir } = {}) {
       }
       if (!allowed.includes(ch)) return null;
       if (ch === 'i' || ch === 's') caseFlag = true;
+      if (ch === 'r' || ch === 'R') recursive = true;
     }
   }
   if (operands.length === 0 || operands.length > 2) return null;
@@ -1307,12 +1366,38 @@ function rewritePlan(cmd, { isDir = looksLikeDir } = {}) {
   // `grep --include='*.py' X src/a.rs` finds nothing; rg — and so cg — searches
   // a named file whatever its -g says (D#78). Equivalent only for a directory.
   if (include && target && !isDir(target.text)) return null;
+  // Plain grep without -r reads no directory ("Is a directory") and, with no
+  // path, reads stdin; the answer would search the tree (D#125 #3). rg and ag
+  // recurse by default, and git grep searches the tracked tree.
+  if (verb === 'grep' && !recursive && (!target || isDir(target.text))) return null;
   // ag is smart-case by default: an all-lowercase pattern matches any case,
   // and cg's search is case-sensitive, so the answer would find less.
   if (verb === 'ag' && !caseFlag && !/[A-Z]/.test(pattern.text)) return null;
   return { pattern: pattern.text, target: target ? target.text : undefined, context };
 }
 
+// D#125 #3 for the PostToolUse side, which has no rewrite grammar: a plain
+// `grep` with no recursion flag searches no directory ("Is a directory" under
+// GNU grep) and, with no path, reads its input.
+function grepSearchesNoDirectory(clause, target, isDir) {
+  const words = shellWords(clause || '');
+  if (!words || words.length === 0 || words[0].anyQuoted || words[0].text !== 'grep') return false;
+  for (let k = 1; k < words.length; k++) {
+    const w = words[k];
+    if (w.op || w.startsQuoted) continue;
+    if (w.text === '--') break;
+    if (/^--(?:recursive|dereference-recursive|directories=recurse)$/.test(w.text)) return false;
+    if (w.text === '-d' && words[k + 1] && words[k + 1].text === 'recurse') return false;
+    if (/^-[^-]/.test(w.text)) {
+      for (const ch of w.text.slice(1)) {
+        if (ch === 'r' || ch === 'R') return false;
+        if ('ABCefmdDg'.includes(ch)) break;  // the rest is that flag's value
+      }
+    }
+  }
+  return target === undefined || isDir(target);
+}
+
 // Does `rootTarget`, run from the root, name the path the grep clause's own
 // operand names from `cwd` — the directory the clause ran in? The raw clause is
 // parsed with the rewrite grammar; an absolute operand resolves the same from
@@ -1401,6 +1486,10 @@ function rewriteMatchesBlock(plan, block, cmd, rawPattern) {
   if (block.mode === 'show') {
     const f = cgFlagSet(extractCgFlags(cmd));
     if (f.has('-l') || f.has('-c')) return false;
+    // `show` has no file filter: `--include`/`-g`/`-t` excluded definitions it
+    // would print (review of D#125).
+    const all = extractCgFlags(cmd);
+    if (all.includes('-g') || all.includes('-t')) return false;
     // show answers at most three symbols; a fourth would silently vanish.
     if (extractDeclSymbols(extractPatterns(cmd)).length > 3) return false;
   }
@@ -1456,18 +1545,37 @@ const BRE_SWAPPED = '(){}+?|';
 const BRE_SAME_ESCAPE = 'wWsSbB<>.*[]^$\\/';
 const POSIX_CLASSES = new Set(['alpha', 'digit', 'alnum', 'upper', 'lower', 'space',
   'punct', 'xdigit', 'blank', 'cntrl', 'graph', 'print']);
+// An unescaped `^` is an anchor only where an alternative starts (the pattern's
+// start, after `\(` or `\|`), and `$` only where one ends (the pattern's end,
+// before `\)` or `\|`); elsewhere BRE reads them as literals and rust regex as
+// anchors — `getUser\|$user_id` searched the text `$user_id` (D#125 #6). No
+// translation: the grep runs.
 function breToRustRegex(pattern) {
   let out = '';
+  let altStart = true;
+  let anchor = false;
   for (let i = 0; i < pattern.length; i++) {
     const c = pattern[i];
+    const wasAltStart = altStart;
+    const wasAnchor = anchor;
+    altStart = false;
+    anchor = c === '^' && wasAltStart;
     if (c === '\\' && i + 1 < pattern.length) {
       const n = pattern[++i];
       if (n === '(' && pattern.startsWith('\\)', i + 1)) return null;
       if (BRE_SWAPPED.includes(n)) out += n;
       else if (BRE_SAME_ESCAPE.includes(n)) out += c + n;
       else return null;
+      altStart = n === '(' || n === '|';
       continue;
     }
+    if (c === '^' && !wasAltStart) return null;
+    // A `*` where an alternative starts, or right after its `^`, repeats
+    // nothing: BRE reads it as a literal, rust regex as an error or a repeat of
+    // the anchor (review of D#125).
+    if (c === '*' && (wasAltStart || (wasAnchor && out.endsWith('^')))) return null;
+    if (c === '$' && i + 1 < pattern.length
+      && !pattern.startsWith('\\)', i + 1) && !pattern.startsWith('\\|', i + 1)) return null;
     if (BRE_SWAPPED.includes(c)) { out += '\\' + c; continue; }
     if (c !== '[') { out += c; continue; }
     // `]` right after `[` or `[^` is a member, not the end.
@@ -1650,6 +1758,7 @@ function runMain() {
   // forwarding `-F` without this guard would make it search the wrong text.
   const cgFlags = extractCgFlags(cmd);
   const rawGrepPattern = pickBlockPattern(cmd);
+  if (!rootOnlyInSearchPath(rawCmd, root, extractSearchPath(cmd))) return;
   const grepPattern = cgFlagSet(cgFlags).has('-F')
     ? rawGrepPattern
     : translateBreToRg(cmd, rawGrepPattern);
@@ -1728,7 +1837,12 @@ function runMain() {
         // No fallback to a grep answer: a context grep (`-A5`) asked for the
         // body, and the grep rewrite would drop the context silently (pre-ship
         // review round 2). A show miss lets the raw grep run.
-        answer = runShowAnswer({ cwd: root, symbols: block.symbols });
+        // Scoped to the grep's path: `show` alone answers the whole project
+        // (D#125 #2 — `grep -A3 "fn f" lib/` was answered from src/).
+        answer = runShowAnswer({
+          cwd: root, symbols: block.symbols, within: searchPath ?? '',
+          kinds: declKindsBySymbol(extractPatterns(cmd)),
+        });
       } else if (pattern) {
         answer = runGrepAnswer({ cwd: root, pattern, searchPath, flags });
       }
@@ -1800,7 +1914,7 @@ function runMain() {
     // stderr; the grep being replaced has no cap (round 3 M4). Only here, not
     // in the in-hook answer, which is a has-hits probe.
     const argvList = answeredMode === 'show'
-      ? answer.symbols.map((sym) => ['show', sym])
+      ? answer.argvs
       : [[...args.slice(0, 1), '-m', '0', ...args.slice(1)]];
     const command = buildRewriteCommand(argvList, {
       invocation: shellQuoteArg(resolveAnswerBinary({})),
@@ -1861,6 +1975,10 @@ module.exports = {
   isRevisionScopedGitGrep, // v0.71 — git grep --cached/treeish exclusion
   extractSearchPath,  // v0.47.0 — deny-with-answer
   normalizeCommandPaths, // v0.47.1 — abs-path matcher fix
+  rootOnlyInSearchPath, // D#125 #1
+  isDirectory,
+  grepSearchesNoDirectory, // D#125 #3
+  declKindsBySymbol, // D#125 #2 review
   resolveProjectRoot,    // v0.48 — subdir-cwd dark fix
   rebaseRelativePaths,   // v0.48 — subdir-cwd dark fix
   commandHasBypass,      // v0.48 — bypass funnel visibility

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