@sdsrs/code-graph 0.75.0 → 0.75.2

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

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

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

@@ -1359,6 +1359,63 @@ test('resolveProjectRoot: no index up to $HOME → null (home itself still check
   } finally { fsE2e.rmSync(base, { recursive: true, force: true }); }
 });
 
+test('resolveProjectRoot: skips a STRAY nested subdir index, prefers the .git root', () => {
+  // monorepo (daagu shape): root has .git + index; a subdir carries a stray
+  // index relic but no .git. Resolving from the subdir must climb to the root,
+  // not pin the stray nested index (the statusline "oscillation" root cause).
+  const base = fsE2e.mkdtempSync(pathE2e.join(osE2e.tmpdir(), 'cg-root-'));
+  try {
+    const proj = pathE2e.join(base, 'proj');
+    fsE2e.mkdirSync(pathE2e.join(proj, '.git'), { recursive: true });
+    fsE2e.mkdirSync(pathE2e.join(proj, '.code-graph'), { recursive: true });
+    fsE2e.writeFileSync(pathE2e.join(proj, '.code-graph', 'index.db'), '');
+    const sub = pathE2e.join(proj, 'backend');
+    fsE2e.mkdirSync(pathE2e.join(sub, '.code-graph'), { recursive: true });
+    fsE2e.writeFileSync(pathE2e.join(sub, '.code-graph', 'index.db'), '');
+    assert.equal(resolveProjectRoot(sub, { home: base }), proj);
+  } finally { fsE2e.rmSync(base, { recursive: true, force: true }); }
+});
+
+test('resolveProjectRoot: a nested index with its OWN .git (submodule) still wins', () => {
+  const base = fsE2e.mkdtempSync(pathE2e.join(osE2e.tmpdir(), 'cg-root-'));
+  try {
+    const proj = pathE2e.join(base, 'proj');
+    fsE2e.mkdirSync(pathE2e.join(proj, '.git'), { recursive: true });
+    fsE2e.mkdirSync(pathE2e.join(proj, '.code-graph'), { recursive: true });
+    fsE2e.writeFileSync(pathE2e.join(proj, '.code-graph', 'index.db'), '');
+    const sub = pathE2e.join(proj, 'vendored');
+    fsE2e.mkdirSync(pathE2e.join(sub, '.git'), { recursive: true });
+    fsE2e.mkdirSync(pathE2e.join(sub, '.code-graph'), { recursive: true });
+    fsE2e.writeFileSync(pathE2e.join(sub, '.code-graph', 'index.db'), '');
+    assert.equal(resolveProjectRoot(sub, { home: base }), sub);
+  } finally { fsE2e.rmSync(base, { recursive: true, force: true }); }
+});
+
+test('resolveProjectRoot: start with its OWN .git but no index → null (boundary, no escape)', () => {
+  const base = fsE2e.mkdtempSync(pathE2e.join(osE2e.tmpdir(), 'cg-root-'));
+  try {
+    const proj = pathE2e.join(base, 'proj'); // indexed parent
+    fsE2e.mkdirSync(pathE2e.join(proj, '.code-graph'), { recursive: true });
+    fsE2e.writeFileSync(pathE2e.join(proj, '.code-graph', 'index.db'), '');
+    const sub = pathE2e.join(proj, 'sub'); // own .git, no index
+    fsE2e.mkdirSync(pathE2e.join(sub, '.git'), { recursive: true });
+    assert.equal(resolveProjectRoot(sub, { home: base }), null);
+  } finally { fsE2e.rmSync(base, { recursive: true, force: true }); }
+});
+
+test('resolveProjectRoot: non-git monorepo — stray subdir index resolves to indexed ancestor', () => {
+  const base = fsE2e.mkdtempSync(pathE2e.join(osE2e.tmpdir(), 'cg-root-'));
+  try {
+    const root = pathE2e.join(base, 'mono'); // indexed, NO .git
+    fsE2e.mkdirSync(pathE2e.join(root, '.code-graph'), { recursive: true });
+    fsE2e.writeFileSync(pathE2e.join(root, '.code-graph', 'index.db'), '');
+    const sub = pathE2e.join(root, 'backend'); // stray index, no .git
+    fsE2e.mkdirSync(pathE2e.join(sub, '.code-graph'), { recursive: true });
+    fsE2e.writeFileSync(pathE2e.join(sub, '.code-graph', 'index.db'), '');
+    assert.equal(resolveProjectRoot(sub, { home: base }), root);
+  } finally { fsE2e.rmSync(base, { recursive: true, force: true }); }
+});
+
 test('rebaseRelativePaths: daagu shape — bare `app` from backend/ cwd', () => {
   const exists = (p) => p.endsWith(pathE2e.join('backend', 'app'));
   const cmd = 'grep -rn "rr_source\\|max_retries" app --include=*.py';

package/claude-plugin/scripts/project-root.js

@@ -14,16 +14,61 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 
+// Resolves to the project's CANONICAL index dir, skipping STRAY nested indexes.
+// A monorepo subdir (`daagu/backend`, `daagu/frontend`) can carry its own
+// `.code-graph/index.db` — a relic an older binary created — nested under the
+// real root's index. Returning the nearest such index made every consumer
+// (statusline gate, hooks) read a different DB per cwd (statusline "oscillation",
+// `✗ 0 nodes` in an empty subdir index). Mirror the Rust resolver: the start's
+// own index wins only if it is NOT a stray nested index (no indexed ancestor) OR
+// start is itself a project boundary (`.git`, i.e. a real submodule). Otherwise
+// prefer the project root: the nearest indexed `.git` root, else the outermost
+// indexed dir on the chain. `null` when nothing on start→…→home is indexed.
 function resolveProjectRoot(startDir, opts = {}) {
   const home = opts.home !== undefined ? opts.home : os.homedir();
   const exists = opts.exists || fs.existsSync;
-  let dir = path.resolve(startDir || '.');
+  const hasIndex = (d) => exists(path.join(d, '.code-graph', 'index.db'));
+  const hasGit = (d) => exists(path.join(d, '.git'));
+  const start = path.resolve(startDir || '.');
+
+  // start's own `.git` is a hard project boundary (a real submodule / distinct
+  // repo): use its index if present, else `null` — never escape to an ancestor's
+  // index. Mirrors the Rust resolver's rule 1 (which returns cwd even without an
+  // index because it CREATES one; the JS reader has nothing to read → null).
+  if (hasGit(start)) return hasIndex(start) ? start : null;
+
+  // Detect whether `start` is a STRAY nested index: walk STRICT ancestors up to
+  // the nearest `.git` root (project boundary), bounded at home. An indexed
+  // ancestor within that boundary means start's own index is a monorepo-subdir
+  // relic. Stop AT the git root — an index above it (e.g. `~/.code-graph`) is an
+  // unrelated outer project and must not poison this one.
+  let gitRootIndexed = null;
+  let ancestorIndexed = false;
+  let dir = start;
   for (;;) {
-    if (exists(path.join(dir, '.code-graph', 'index.db'))) return dir;
-    if (dir === home) return null;
     const parent = path.dirname(dir);
-    if (parent === dir) return null;
+    // Stop BEFORE home (and fs root): an index at/above home (e.g. ~/.code-graph
+    // from indexing a home dir) is an unrelated outer project, never a parent
+    // that makes `start` stray.
+    if (parent === dir || parent === home) break;
     dir = parent;
+    if (hasIndex(dir)) ancestorIndexed = true;
+    if (hasGit(dir)) { if (hasIndex(dir)) gitRootIndexed = dir; break; }
+  }
+
+  // start's own index wins unless it is stray (an indexed ancestor within the
+  // git boundary). start's own `.git` was already handled above.
+  if (hasIndex(start) && !ancestorIndexed) return start;
+  if (gitRootIndexed) return gitRootIndexed;
+  // Otherwise the nearest indexed ancestor (skipping a stray start), bounded at
+  // home; null if nothing on the chain is indexed. Mirrors the original walk.
+  let d = hasIndex(start) ? path.dirname(start) : start;
+  for (;;) {
+    if (hasIndex(d)) return d;
+    if (d === home) return null;
+    const parent = path.dirname(d);
+    if (parent === d) return null;
+    d = parent;
   }
 }
 

package/claude-plugin/scripts/statusline.js

@@ -5,6 +5,7 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { findBinary } = require('./find-binary');
+const { resolveProjectRoot } = require('./project-root');
 const lifecycle = require('./lifecycle');
 const cleanupDisabledStatusline = lifecycle.cleanupDisabledStatusline || (() => ({ cleaned: false }));
 
@@ -24,14 +25,19 @@ function updatePending() {
 const disabledCleanup = cleanupDisabledStatusline();
 if (disabledCleanup.cleaned) process.exit(0);
 
-// Only show status in projects that have a code-graph directory.
-// The statusLine config is global, so we must exit silently for
-// directories that aren't code-graph projects.
-const cwd = process.cwd();
-const codeGraphDir = path.join(cwd, '.code-graph');
-if (!fs.existsSync(codeGraphDir)) {
+// Only show status in projects that have a code-graph directory. The statusLine
+// config is global, so we must exit silently for non-code-graph directories.
+// Walk UP to the canonical project root (resolveProjectRoot) rather than keying
+// on the bare process.cwd(): when the shell sits in a subdir, the bare-cwd gate
+// either showed a STRAY nested subdir index (monorepo relic — the statusline
+// "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());
+if (!root) {
   process.exit(0);
 }
+const codeGraphDir = path.join(root, '.code-graph');
 
 // Check for background indexing progress file first
 const progressFile = path.join(codeGraphDir, 'indexing-status.json');
@@ -108,7 +114,11 @@ let errText = '';
 try {
   report = parseReport(execFileSync(bin, ['health-check', '--format', 'json'], {
     timeout: 3000,
-    stdio: ['pipe', 'pipe', 'pipe']
+    stdio: ['pipe', 'pipe', 'pipe'],
+    // Run the binary FROM the resolved root so its own project-root resolution
+    // lands on the same DB the gate above picked (a subdir cwd would otherwise
+    // re-resolve to a stray nested index inside the binary).
+    cwd: root
   }).toString());
 } catch (e) {
   // health-check exits NON-ZERO on an unhealthy/empty index but still writes the

package/package.json

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