@sdsrs/code-graph 0.51.1 → 0.53.0

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

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

package/claude-plugin/scripts/pr-impact-comment.js

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+'use strict';
+// PR impact review (v0.53.0). Renders a code-graph `affected` analysis of a
+// pull request's changed files into a sticky PR comment: which test files to
+// re-run, the blast radius, and changed production files that have NO covering
+// test ("test gaps").
+//
+// Posture: this is a productization of the already-shipped `affected` command
+// (reverse-dependency closure over imports∪calls∪references∪implements∪inherits).
+// It introduces no new graph logic — it only shells out to the built binary and
+// formats the result. The render path is pure (unit-tested with fixtures); the
+// gh upsert + binary calls live in `computeReview` / `upsertComment` / `main`.
+//
+// Funnel-safe: every binary invocation carries CODE_GRAPH_INTERNAL=1 so CI
+// analysis runs never inflate the deny→use conversion metrics (mirrors
+// cg-answer.js).
+
+const { spawnSync } = require('child_process');
+
+const MARKER = '<!-- code-graph-impact-review -->';
+const SPAWN_TIMEOUT_MS = 60_000;
+const TOP_AFFECTED = 15;
+
+/// File-level test classifier — mirrors `domain::is_test_path` (Rust). Kept in
+/// sync deliberately; see feedback_test_classifier_dual_sources.md.
+function isTestPath(p) {
+  return (
+    p.startsWith('tests/') || p.startsWith('test/') ||
+    p.startsWith('benches/') || p.startsWith('bench/') ||
+    p.includes('__tests__/') ||
+    p.endsWith('/tests.rs') ||
+    p.endsWith('_test.go') || p.endsWith('_test.rs') ||
+    p.endsWith('.test.ts') || p.endsWith('.test.js') ||
+    p.endsWith('.test.tsx') || p.endsWith('.test.jsx') ||
+    p.endsWith('.spec.ts') || p.endsWith('.spec.js') ||
+    p.endsWith('.spec.tsx') || p.endsWith('.spec.jsx')
+  );
+}
+
+function resolveBinary() {
+  if (process.env._CG_REVIEW_BINARY) return process.env._CG_REVIEW_BINARY;
+  try {
+    return require('./find-binary').findBinary();
+  } catch {
+    return null;
+  }
+}
+
+function runAffected(binary, args, cwd, stdin) {
+  const res = spawnSync(binary, args, {
+    cwd,
+    input: stdin,
+    timeout: SPAWN_TIMEOUT_MS,
+    encoding: 'utf8',
+    maxBuffer: 16 * 1024 * 1024,
+    stdio: ['pipe', 'pipe', 'ignore'],
+    env: { ...process.env, CODE_GRAPH_INTERNAL: '1' },
+  });
+  if (res.error || res.signal || res.status !== 0) return null;
+  try {
+    return JSON.parse((res.stdout || '').trim());
+  } catch {
+    return null;
+  }
+}
+
+/// Build the review object by running `affected` over the changed files.
+/// `changedFiles` is the raw list (newline-split, pre-filtered to non-empty).
+/// Returns null only when the binary itself is unavailable — an empty diff still
+/// yields a valid (empty) review so the comment path always has data.
+function computeReview(binary, changedFiles, cwd) {
+  const aggregate = runAffected(
+    binary, ['affected', '--stdin', '--json'], cwd, changedFiles.join('\n') + '\n'
+  );
+  if (!aggregate) return null;
+
+  const changed = aggregate.changed || [];
+  const tests = aggregate.tests || [];
+  const affectedFiles = aggregate.affected_files || [];
+  const notIndexed = aggregate.not_indexed || [];
+
+  // Per-file test-gap: a changed PRODUCTION (non-test) file is "uncovered" when
+  // running `affected` on it alone surfaces zero test files. Run per-file so the
+  // signal is attributable (the aggregate union can't be split back per file).
+  const uncovered = [];
+  for (const f of changed) {
+    if (isTestPath(f)) continue;
+    const single = runAffected(binary, ['affected', f, '--json'], cwd, '');
+    if (single && (single.tests || []).length === 0) {
+      uncovered.push(f);
+    }
+  }
+
+  const topAffected = affectedFiles
+    .slice()
+    .sort((a, b) => (a.depth - b.depth) || a.path.localeCompare(b.path))
+    .slice(0, TOP_AFFECTED);
+
+  return {
+    changed,
+    not_indexed: notIndexed,
+    tests: tests.slice().sort(),
+    blast_radius: affectedFiles.length,
+    top_affected: topAffected,
+    uncovered: uncovered.sort(),
+  };
+}
+
+/// Pure: render a review object to sticky-comment markdown. Always begins with
+/// MARKER so the upsert can find and replace it.
+function renderMarkdown(review) {
+  const lines = [MARKER, '## 🔎 Code Graph impact review', ''];
+
+  if (review.changed.length === 0) {
+    lines.push(
+      review.not_indexed.length > 0
+        ? `No **indexed** code changed (${review.not_indexed.length} changed file(s) not in the graph — new/non-code files).`
+        : 'No code changes detected in this PR.'
+    );
+    lines.push('', '<sub>code-graph-mcp `affected`</sub>');
+    return lines.join('\n');
+  }
+
+  lines.push(
+    `**${review.changed.length}** changed indexed file(s) · ` +
+    `blast radius **${review.blast_radius}** file(s) · ` +
+    `**${review.tests.length}** test file(s) to re-run`,
+    ''
+  );
+
+  if (review.uncovered.length > 0) {
+    lines.push(`### ⚠️ Test gaps (${review.uncovered.length})`);
+    lines.push('Changed production files with no test in their reverse-dependency closure:');
+    for (const p of review.uncovered) lines.push(`- \`${p}\``);
+    lines.push('');
+  }
+
+  if (review.tests.length > 0) {
+    lines.push('<details><summary>Tests to re-run</summary>', '');
+    for (const t of review.tests) lines.push(`- \`${t}\``);
+    lines.push('', '</details>', '');
+  }
+
+  if (review.top_affected.length > 0) {
+    const more = review.blast_radius - review.top_affected.length;
+    const cap = more > 0 ? ` (top ${review.top_affected.length} of ${review.blast_radius})` : '';
+    lines.push(`<details><summary>Blast radius${cap}</summary>`, '');
+    for (const a of review.top_affected) lines.push(`- \`${a.path}\` (depth ${a.depth})`);
+    if (more > 0) lines.push(`- …and ${more} more`);
+    lines.push('', '</details>', '');
+  }
+
+  if (review.not_indexed.length > 0) {
+    lines.push(`<sub>${review.not_indexed.length} changed file(s) not in index (new/non-code) — not analyzed.</sub>`);
+  }
+  lines.push('<sub>code-graph-mcp `affected` · reverse-dependency closure over imports∪calls∪references∪implements∪inherits</sub>');
+  return lines.join('\n');
+}
+
+/// Upsert a sticky comment: find an existing comment containing MARKER and PATCH
+/// it, else POST a new one. Uses `gh api` (preinstalled on GitHub runners).
+function upsertComment(repo, prNumber, body) {
+  const gh = (args, input) => spawnSync('gh', args, {
+    encoding: 'utf8', input, timeout: SPAWN_TIMEOUT_MS,
+    env: { ...process.env },
+  });
+
+  const list = gh(['api', '--paginate', `repos/${repo}/issues/${prNumber}/comments`]);
+  let existingId = null;
+  if (list.status === 0) {
+    try {
+      const comments = JSON.parse(list.stdout || '[]');
+      const hit = comments.find((c) => (c.body || '').includes(MARKER));
+      if (hit) existingId = hit.id;
+    } catch { /* fall through to create */ }
+  }
+
+  if (existingId) {
+    const res = gh(
+      ['api', '--method', 'PATCH', `repos/${repo}/issues/comments/${existingId}`, '-F', 'body=@-'],
+      body
+    );
+    return res.status === 0;
+  }
+  const res = gh(
+    ['api', '--method', 'POST', `repos/${repo}/issues/${prNumber}/comments`, '-F', 'body=@-'],
+    body
+  );
+  return res.status === 0;
+}
+
+function main(argv) {
+  // argv: [changedFilesPath]. Env: GH_REPO, PR_NUMBER, CODE_GRAPH_FAIL_ON_RISK.
+  const fs = require('fs');
+  const changedPath = argv[0];
+  if (!changedPath) {
+    console.error('usage: pr-impact-comment.js <changed-files.txt>');
+    process.exit(2);
+  }
+  const binary = resolveBinary();
+  if (!binary) {
+    console.error('[pr-impact] code-graph-mcp binary not found; skipping review.');
+    return; // best-effort: never fail the PR over a missing analyzer
+  }
+
+  const changedFiles = fs.readFileSync(changedPath, 'utf8')
+    .split('\n').map((s) => s.trim()).filter(Boolean);
+
+  const review = computeReview(binary, changedFiles, process.cwd());
+  if (!review) {
+    console.error('[pr-impact] affected analysis failed; skipping comment.');
+    return;
+  }
+
+  const body = renderMarkdown(review);
+  const repo = process.env.GH_REPO;
+  const prNumber = process.env.PR_NUMBER;
+  if (repo && prNumber) {
+    const ok = upsertComment(repo, prNumber, body);
+    if (!ok) console.error('[pr-impact] failed to upsert PR comment.');
+  } else {
+    // No PR context (e.g. local run) — print to stdout for inspection.
+    process.stdout.write(body + '\n');
+  }
+
+  const failOnRisk = /^(1|true|yes)$/i.test(process.env.CODE_GRAPH_FAIL_ON_RISK || '');
+  if (failOnRisk && review.uncovered.length > 0) {
+    console.error(`[pr-impact] fail-on-risk: ${review.uncovered.length} changed file(s) have no covering test.`);
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  main(process.argv.slice(2));
+}
+
+module.exports = { isTestPath, renderMarkdown, computeReview, upsertComment, MARKER };

package/claude-plugin/scripts/pr-impact-comment.test.js

@@ -0,0 +1,110 @@
+'use strict';
+const { test } = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { isTestPath, renderMarkdown, computeReview, MARKER } = require('./pr-impact-comment');
+
+test('isTestPath mirrors domain::is_test_path patterns', () => {
+  for (const p of [
+    'tests/integration.rs', 'test/foo.js', 'benches/indexing.rs', 'bench/x.rs',
+    'src/__tests__/a.ts', 'src/foo/tests.rs', 'pkg/x_test.go', 'src/y_test.rs',
+    'a.test.ts', 'a.test.js', 'a.test.tsx', 'a.test.jsx',
+    'a.spec.ts', 'a.spec.js', 'a.spec.tsx', 'a.spec.jsx',
+  ]) {
+    assert.ok(isTestPath(p), `${p} should be a test path`);
+  }
+  for (const p of ['src/lib.rs', 'src/graph/centrality.rs', 'README.md', 'src/testing.rs']) {
+    assert.ok(!isTestPath(p), `${p} should NOT be a test path`);
+  }
+});
+
+test('renderMarkdown: empty diff', () => {
+  const md = renderMarkdown({ changed: [], not_indexed: [], tests: [], blast_radius: 0, top_affected: [], uncovered: [] });
+  assert.ok(md.startsWith(MARKER), 'must start with marker');
+  assert.match(md, /No code changes detected/);
+});
+
+test('renderMarkdown: only non-indexed changes', () => {
+  const md = renderMarkdown({ changed: [], not_indexed: ['docs/x.md', 'new.rs'], tests: [], blast_radius: 0, top_affected: [], uncovered: [] });
+  assert.match(md, /No \*\*indexed\*\* code changed \(2 changed file/);
+});
+
+test('renderMarkdown: full review with test gaps', () => {
+  const md = renderMarkdown({
+    changed: ['src/a.rs', 'src/b.rs'],
+    not_indexed: ['NEW.md'],
+    tests: ['tests/a_test.rs'],
+    blast_radius: 20,
+    top_affected: [{ path: 'src/c.rs', depth: 1 }, { path: 'src/d.rs', depth: 2 }],
+    uncovered: ['src/b.rs'],
+  });
+  assert.ok(md.startsWith(MARKER));
+  assert.match(md, /2\*\* changed indexed file/);
+  assert.match(md, /blast radius \*\*20\*\*/);
+  assert.match(md, /Test gaps \(1\)/);
+  assert.match(md, /- `src\/b\.rs`/);
+  assert.match(md, /Tests to re-run/);
+  assert.match(md, /- `tests\/a_test\.rs`/);
+  // 20 blast radius but only 2 shown → "top 2 of 20" + "…and 18 more"
+  assert.match(md, /top 2 of 20/);
+  assert.match(md, /…and 18 more/);
+  assert.match(md, /1 changed file\(s\) not in index/);
+});
+
+// Stub binary: a node script that emulates `code-graph-mcp affected`.
+// `affected --stdin --json` → aggregate; `affected <file> --json` → per-file.
+function writeStubBinary(dir) {
+  const stub = path.join(dir, 'stub-cg.js');
+  fs.writeFileSync(stub, `#!/usr/bin/env node
+'use strict';
+const args = process.argv.slice(2);
+// args[0] === 'affected'
+if (args.includes('--stdin')) {
+  process.stdout.write(JSON.stringify({
+    changed: ['src/a.rs', 'src/b.rs', 'tests/a_test.rs'],
+    tests: ['tests/a_test.rs'],
+    affected_files: [{path:'tests/a_test.rs',depth:1,is_test:true},{path:'src/x.rs',depth:1,is_test:false}],
+    not_indexed: ['NEW.md'],
+  }));
+  process.exit(0);
+}
+const file = args[1];
+// src/a.rs is covered (has a test); src/b.rs is uncovered (no tests).
+if (file === 'src/a.rs') {
+  process.stdout.write(JSON.stringify({ changed:[file], tests:['tests/a_test.rs'], affected_files:[], not_indexed:[] }));
+} else {
+  process.stdout.write(JSON.stringify({ changed:[file], tests:[], affected_files:[], not_indexed:[] }));
+}
+process.exit(0);
+`);
+  fs.chmodSync(stub, 0o755);
+  // Wrap so it's executable as a single binary path: use `node stub.js` via a shell shim.
+  const shim = path.join(dir, 'cg');
+  fs.writeFileSync(shim, `#!/usr/bin/env bash\nexec node "${stub}" "$@"\n`);
+  fs.chmodSync(shim, 0o755);
+  return shim;
+}
+
+test('computeReview: aggregate + per-file test-gap detection', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-prreview-'));
+  try {
+    const binary = writeStubBinary(dir);
+    const review = computeReview(binary, ['src/a.rs', 'src/b.rs', 'tests/a_test.rs', 'NEW.md'], dir);
+    assert.ok(review, 'review computed');
+    assert.deepStrictEqual(review.tests, ['tests/a_test.rs']);
+    assert.strictEqual(review.blast_radius, 2);
+    assert.deepStrictEqual(review.not_indexed, ['NEW.md']);
+    // src/b.rs has no covering test → uncovered; src/a.rs covered; test file skipped.
+    assert.deepStrictEqual(review.uncovered, ['src/b.rs']);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('computeReview: returns null when binary unavailable', () => {
+  const review = computeReview('/nonexistent/cg-binary-xyz', ['src/a.rs'], os.tmpdir());
+  assert.strictEqual(review, null);
+});

package/package.json

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