@sdsrs/code-graph 0.98.1 → 0.99.0

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

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

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

@@ -8,12 +8,34 @@
 // relative-path matching) fails silently for the rest of the session (daagu
 // 2026-06-11: 38/40 head-greps dark; the read hook never recorded AT ALL).
 // Walk up to the nearest ancestor holding `.code-graph/index.db`; stop at
-// $HOME (checked, not crossed) and fs root.
+// $HOME and at `.git` boundaries (neither is crossed, and home's own index is
+// never adopted from below).
 
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
 
+// A linked git worktree's `.git` is a FILE containing
+// `gitdir: <main>/.git/worktrees/<name>` — resolve it to the main checkout so
+// worktree sessions (Claude Code's EnterWorktree puts them under
+// <main>/.claude/worktrees/<slug>) reuse the main index instead of going dark.
+// A submodule's `.git` file points at `.git/modules/…` and stays a hard
+// boundary: its content is a DIFFERENT codebase, not a branch copy of the
+// parent. Returns null for a regular `.git` directory (EISDIR), a missing
+// `.git` (ENOENT), or any gitdir not under `.git/worktrees/`.
+function worktreeMainRoot(dir) {
+  let raw;
+  try { raw = fs.readFileSync(path.join(dir, '.git'), 'utf8'); }
+  catch { return null; }
+  const m = /^gitdir:\s*(.+?)\s*$/m.exec(raw);
+  if (!m) return null;
+  const gitdir = path.resolve(dir, m[1]);
+  const marker = `${path.sep}.git${path.sep}worktrees${path.sep}`;
+  const at = gitdir.lastIndexOf(marker);
+  if (at < 0) return null;
+  return gitdir.slice(0, at) || null;
+}
+
 // 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
@@ -22,8 +44,17 @@ const path = require('path');
 // `✗ 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.
+// prefer the project root: the nearest indexed `.git` root, else the nearest
+// indexed ancestor INSIDE the boundary (git root if any, home otherwise — the
+// walk stops at both, so a nested repo never adopts the outer project's index
+// and a stray `~/.code-graph` never leaks into un-indexed dirs under home).
+// `null` when nothing on start→…→boundary is indexed.
+//
+// Rust parity note (cli::resolve_project_root_from): the Rust resolver is the
+// WRITE side — in a worktree it returns the worktree itself and builds a local
+// index there. This reader prefers such a local index when present (own-index
+// rule), falling back to the main checkout's index only while the worktree has
+// none. Divergence is intentional; keep it documented on both sides.
 function resolveProjectRoot(startDir, opts = {}) {
   const home = opts.home !== undefined ? opts.home : os.homedir();
   const exists = opts.exists || fs.existsSync;
@@ -32,17 +63,28 @@ function resolveProjectRoot(startDir, opts = {}) {
   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;
+  // repo): use its index if present. With none, a linked WORKTREE falls back to
+  // its main checkout's index (a worktree is a branch copy of that codebase);
+  // anything 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)) {
+    if (hasIndex(start)) return start;
+    const main = worktreeMainRoot(start);
+    return main && hasIndex(main) ? main : null;
+  }
+
+  // start IS home: own-index rule only (deliberately indexed home dirs keep
+  // working from home itself), and never scan ancestors ABOVE home — without
+  // this, the strict-ancestor walk below starts past the home bound entirely.
+  if (start === home) 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 gitRoot = null;
   let ancestorIndexed = false;
   let dir = start;
   for (;;) {
@@ -53,23 +95,33 @@ function resolveProjectRoot(startDir, opts = {}) {
     if (parent === dir || parent === home) break;
     dir = parent;
     if (hasIndex(dir)) ancestorIndexed = true;
-    if (hasGit(dir)) { if (hasIndex(dir)) gitRootIndexed = dir; break; }
+    if (hasGit(dir)) { gitRoot = 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.
+  if (gitRoot && hasIndex(gitRoot)) return gitRoot;
+
+  // Nearest indexed ancestor strictly INSIDE the boundary (git root / home are
+  // stops, never candidates — see header). Covers the legit shape where only a
+  // sub-project of an unindexed repo was indexed (repo/packages/foo).
   let d = hasIndex(start) ? path.dirname(start) : start;
   for (;;) {
+    if (d === home || d === gitRoot) break;
     if (hasIndex(d)) return d;
-    if (d === home) return null;
     const parent = path.dirname(d);
-    if (parent === d) return null;
+    if (parent === d) break;
     d = parent;
   }
+
+  // Nothing indexed inside the boundary. If that boundary is a linked worktree
+  // root, subdirs resolve like the root itself does: to the main checkout.
+  if (gitRoot) {
+    const main = worktreeMainRoot(gitRoot);
+    if (main && hasIndex(main)) return main;
+  }
+  return null;
 }
 
 module.exports = { resolveProjectRoot };

package/claude-plugin/scripts/session-init.js

@@ -316,7 +316,12 @@ function ensureIndexFresh() {
   const bin = findBinary();
   if (!bin) return 'skipped';
 
-  const cwd = process.cwd();
+  // Canonical index root, not the bare session cwd: a session launched in a
+  // linked worktree (resolves to the main checkout) or a subdir otherwise
+  // gate-fails here and freshness never runs (sibling of the statusline/hook
+  // subdir-cwd dark class).
+  const { resolveProjectRoot } = require('./project-root');
+  const cwd = resolveProjectRoot(process.cwd()) || process.cwd();
   const dbPath = path.join(cwd, '.code-graph', 'index.db');
   if (!fs.existsSync(dbPath)) return 'skipped';
 
@@ -592,7 +597,8 @@ function runSessionInit({ source } = {}) {
  */
 function injectProjectMap() {
   try {
-    const cwd = process.cwd();
+    const { resolveProjectRoot } = require('./project-root');
+    const cwd = resolveProjectRoot(process.cwd()) || process.cwd();
     const dbPath = path.join(cwd, '.code-graph', 'index.db');
     if (!fs.existsSync(dbPath)) return false;
 
@@ -636,7 +642,14 @@ function injectProjectMap() {
  */
 function injectRecentImpact({ source } = {}) {
   try {
-    const cwd = process.cwd();
+    // Index + telemetry live at the canonical root (worktree → main checkout,
+    // subdir → project root); git WIP detection stays in the SESSION dir — the
+    // worktree's branch state is what this session edits. Repo-relative git
+    // paths translate 1:1 to root-relative index paths (a worktree mirrors the
+    // checkout layout).
+    const { resolveProjectRoot } = require('./project-root');
+    const sessionDir = process.cwd();
+    const cwd = resolveProjectRoot(sessionDir) || sessionDir;
     const dbPath = path.join(cwd, '.code-graph', 'index.db');
     if (!fs.existsSync(dbPath)) return false;
 
@@ -646,7 +659,7 @@ function injectRecentImpact({ source } = {}) {
     // last commit. Timeouts tightened (finding #1): worst-case cap sum is now
     // status(1s) + HEAD~1(1s) + affected(1.5s) = 3.5s, comfortably under the 5s
     // SessionStart hook budget; the old 2+2+3=7s could get the whole hook killed.
-    const gitOpts = { cwd, timeout: 1000, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] };
+    const gitOpts = { cwd: sessionDir, timeout: 1000, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] };
     let changed = [];
     let isWip = false;
     try {

package/claude-plugin/scripts/user-prompt-context.js

@@ -431,8 +431,11 @@ function runMain() {
   // Chinese chars are ~3 bytes but 1 char; "看看 fts5_search" is only 16 chars
   if (!message || message.length < 8) return;
 
-  // --- Check index ---
-  const cwd = process.cwd();
+  // --- Check index --- (canonical root: worktree → main checkout, subdir →
+  // project root — the bare cwd gate left this hook dark there, sibling of the
+  // pre-*-guide subdir-cwd class)
+  const { resolveProjectRoot } = require('./project-root');
+  const cwd = resolveProjectRoot(process.cwd()) || process.cwd();
   const dbPath = path.join(cwd, '.code-graph', 'index.db');
   if (!fs.existsSync(dbPath)) return;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdsrs/code-graph",
-  "version": "0.98.1",
+  "version": "0.99.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": {
@@ -36,10 +36,10 @@
     "node": ">=16"
   },
   "optionalDependencies": {
-    "@sdsrs/code-graph-linux-x64": "0.98.1",
-    "@sdsrs/code-graph-linux-arm64": "0.98.1",
-    "@sdsrs/code-graph-darwin-x64": "0.98.1",
-    "@sdsrs/code-graph-darwin-arm64": "0.98.1",
-    "@sdsrs/code-graph-win32-x64": "0.98.1"
+    "@sdsrs/code-graph-linux-x64": "0.99.0",
+    "@sdsrs/code-graph-linux-arm64": "0.99.0",
+    "@sdsrs/code-graph-darwin-x64": "0.99.0",
+    "@sdsrs/code-graph-darwin-arm64": "0.99.0",
+    "@sdsrs/code-graph-win32-x64": "0.99.0"
   }
 }