@sdsrs/code-graph 0.77.0 → 0.77.2

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

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

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

@@ -71,16 +71,41 @@ function runProvider(command, needsStdin, stdin) {
     // swallowed below, silently dropping the user's original statusline.
     const argv = parts.map(expandTilde);
 
+    // Forward Claude Code's authoritative current dir (from the stdin payload) as
+    // a plugin-scoped env var. The code-graph provider gates on it instead of its
+    // own process.cwd(), which need not track the session's working dir. Harmless
+    // 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;
+
     const out = execFileSync(argv[0], argv.slice(1), {
       timeout: 3000,
       stdio: ['pipe', 'pipe', 'pipe'],
       input: needsStdin ? stdin : '',
+      env,
     }).toString().trim();
 
     return out || null;
   } catch { return null; }
 }
 
+// Extract Claude Code's current working directory from the stdin JSON context.
+// Prefer the top-level `cwd`, then `workspace.current_dir`; both track the
+// session's working dir (after the model runs `cd`). Returns null for empty,
+// non-JSON, or cwd-less payloads (e.g. the stdin-timeout fallback passes '').
+// Only a non-empty STRING is accepted: a malformed `cwd` (number/object) would
+// otherwise be coerced to a bogus env path that resolves nowhere and silently
+// blanks the segment — null keeps the gate on the safe process.cwd() fallback.
+function cwdFromStdin(stdin) {
+  if (!stdin) return null;
+  try {
+    const ctx = JSON.parse(stdin);
+    const v = ctx && (ctx.cwd || (ctx.workspace && ctx.workspace.current_dir));
+    return typeof v === 'string' && v ? v : null;
+  } catch { return null; }
+}
+
 function parseCommand(cmd) {
   // Handle: node "/path/to/script.js"
   const match = cmd.match(/^(\S+)\s+"([^"]+)"(.*)$/);
@@ -109,4 +134,4 @@ function codeGraphCommand() {
   return `node "${path.join(__dirname, 'statusline.js')}"`;
 }
 
-module.exports = { run, runProvider, parseCommand, expandTilde };
+module.exports = { run, runProvider, parseCommand, expandTilde, cwdFromStdin };

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

@@ -0,0 +1,65 @@
+'use strict';
+// The composite is the registered statusLine command: it receives Claude Code's
+// JSON context on stdin and fans out to each provider. This pins the cwd bridge:
+// the code-graph provider keys its gate on process.cwd(), but Claude Code may
+// spawn the statusline from a cwd unrelated to the session. The composite must
+// extract the authoritative cwd from stdin and forward it (CODE_GRAPH_STATUSLINE_CWD)
+// so the provider resolves the right project regardless of the spawn's cwd.
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { cwdFromStdin, runProvider } = require('./statusline-composite');
+
+test('cwdFromStdin reads the top-level cwd field', () => {
+  assert.equal(cwdFromStdin('{"cwd":"/a/b"}'), '/a/b');
+});
+
+test('cwdFromStdin falls back to workspace.current_dir', () => {
+  assert.equal(cwdFromStdin('{"workspace":{"current_dir":"/c/d"}}'), '/c/d');
+});
+
+test('cwdFromStdin prefers top-level cwd over workspace.current_dir', () => {
+  assert.equal(cwdFromStdin('{"cwd":"/a","workspace":{"current_dir":"/c"}}'), '/a');
+});
+
+test('cwdFromStdin returns null for empty / non-JSON / cwd-less payloads', () => {
+  assert.equal(cwdFromStdin(''), null);
+  assert.equal(cwdFromStdin('not json'), null);
+  assert.equal(cwdFromStdin('{}'), null);
+  assert.equal(cwdFromStdin('{"workspace":{}}'), null);
+});
+
+test('cwdFromStdin returns null for a non-string cwd (no bogus env path)', () => {
+  // A malformed payload must not coerce a number/object into an env path that
+  // resolves to nowhere and silently blanks the segment. Only a real string wins.
+  assert.equal(cwdFromStdin('{"cwd":123}'), null);
+  assert.equal(cwdFromStdin('{"cwd":{"x":1}}'), null);
+  assert.equal(cwdFromStdin('{"cwd":""}'), null);
+  assert.equal(cwdFromStdin('{"workspace":{"current_dir":42}}'), null);
+});
+
+test('runProvider forwards the stdin cwd to the provider as CODE_GRAPH_STATUSLINE_CWD', (t) => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-composite-'));
+  t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
+  const fixture = path.join(dir, 'echo-cwd.js');
+  fs.writeFileSync(fixture, "process.stdout.write('CWD='+(process.env.CODE_GRAPH_STATUSLINE_CWD||'NONE'));");
+  const out = runProvider(`node ${JSON.stringify(fixture)}`, false, '{"cwd":"/x/y"}');
+  assert.equal(out, 'CWD=/x/y');
+});
+
+test('runProvider leaves CODE_GRAPH_STATUSLINE_CWD unset when stdin carries no cwd', (t) => {
+  // Hermetic against an ambient var: with no stdin cwd, runProvider passes
+  // process.env through unchanged, so a value inherited by the test runner would
+  // leak into the child. Clear it for this case, restore after.
+  const saved = process.env.CODE_GRAPH_STATUSLINE_CWD;
+  delete process.env.CODE_GRAPH_STATUSLINE_CWD;
+  t.after(() => { if (saved !== undefined) process.env.CODE_GRAPH_STATUSLINE_CWD = saved; });
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-composite-'));
+  t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
+  const fixture = path.join(dir, 'echo-cwd.js');
+  fs.writeFileSync(fixture, "process.stdout.write('CWD='+(process.env.CODE_GRAPH_STATUSLINE_CWD||'NONE'));");
+  const out = runProvider(`node ${JSON.stringify(fixture)}`, false, '');
+  assert.equal(out, 'CWD=NONE');
+});

package/claude-plugin/scripts/statusline.js

@@ -33,7 +33,15 @@ if (disabledCleanup.cleaned) process.exit(0);
 // "oscillating" between root/backend/frontend node counts) or, in a clean subdir
 // with no local index, showed nothing at all. The resolver skips stray nested
 // indexes, so the statusline tracks one DB — the project root — from any subdir.
-const root = resolveProjectRoot(process.cwd());
+//
+// Start from Claude Code's AUTHORITATIVE current dir (CODE_GRAPH_STATUSLINE_CWD,
+// forwarded by the composite from its stdin payload) rather than process.cwd().
+// The spawned statusline's process.cwd() is an implementation detail of how
+// Claude Code launches the command and need not track the session's working dir;
+// the stdin `cwd` always does. Fall back to process.cwd() when unset (direct
+// invocation, tests).
+const startDir = process.env.CODE_GRAPH_STATUSLINE_CWD || process.cwd();
+const root = resolveProjectRoot(startDir);
 if (!root) {
   process.exit(0);
 }

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

@@ -69,6 +69,17 @@ function runStatusline(home, projectDir) {
   }).trim();
 }
 
+// Run statusline.js from an arbitrary process.cwd() with extra env vars. Used to
+// prove the gate keys on Claude Code's authoritative cwd (CODE_GRAPH_STATUSLINE_CWD,
+// forwarded by the composite from the stdin payload), NOT the spawn's cwd.
+function runStatuslineIn(home, processCwd, extraEnv) {
+  return execFileSync('node', [STATUSLINE], {
+    cwd: processCwd,
+    env: { ...process.env, HOME: home, ...extraEnv },
+    encoding: 'utf8',
+  }).trim();
+}
+
 function mkProject(home) {
   const dir = path.join(home, 'project');
   const cg = path.join(dir, '.code-graph');
@@ -164,3 +175,36 @@ test('version-stale index shows rebuilding marker', (t) => {
   });
   assert.equal(runStatusline(home, project), 'code-graph: ✓ 14119 nodes | 922 files | ↻ rebuilding');
 });
+
+// CODE_GRAPH_STATUSLINE_CWD is Claude Code's authoritative current dir, forwarded by
+// the composite from its stdin payload. The gate must trust it over process.cwd():
+// Claude Code may spawn the statusline from a cwd unrelated to the session (the
+// classic regression — the segment vanished when the shell sat in a subdir whose
+// process.cwd() didn't resolve to the project root).
+test('CODE_GRAPH_STATUSLINE_CWD overrides process.cwd() for the gate', (t) => {
+  const home = mkHome(t);
+  const project = mkProject(home);
+  installStubBinary(home, {
+    report: { healthy: true, nodes: 3145, files: 205 },
+    exitCode: 0,
+  });
+  // process.cwd() = home (no .code-graph → resolves null → would be blank), but
+  // the authoritative cwd points at the project → must render the health line.
+  const out = runStatuslineIn(home, home, { CODE_GRAPH_STATUSLINE_CWD: project });
+  assert.equal(out, 'code-graph: ✓ 3145 nodes | 205 files');
+});
+
+test('CODE_GRAPH_STATUSLINE_CWD in a subdir walks up to the project root', (t) => {
+  const home = mkHome(t);
+  const project = mkProject(home);
+  const subdir = path.join(project, 'claude-plugin', 'scripts');
+  fs.mkdirSync(subdir, { recursive: true });
+  installStubBinary(home, {
+    report: { healthy: true, nodes: 3145, files: 205 },
+    exitCode: 0,
+  });
+  // The reported symptom: shell in <root>/claude-plugin/scripts. The subdir has
+  // no .code-graph of its own; resolveProjectRoot must walk up to <root>.
+  const out = runStatuslineIn(home, home, { CODE_GRAPH_STATUSLINE_CWD: subdir });
+  assert.equal(out, 'code-graph: ✓ 3145 nodes | 205 files');
+});

package/package.json

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