@sdsrs/code-graph 0.81.1 → 0.82.1

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

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

package/claude-plugin/scripts/doctor.js

@@ -285,7 +285,7 @@ function runDiagnostics() {
 
 const STATUS_ICONS = { ok: '\u2705', warn: '\u26a0\ufe0f', error: '\u274c', skip: '\u2796' };
 
-function formatReport(results) {
+function formatReport(results, { checkOnly = false } = {}) {
   const pluginVersion = getPluginVersion();
   const lines = [`\ud83d\udd0d code-graph doctor v${pluginVersion}`, ''];
 
@@ -302,7 +302,15 @@ function formatReport(results) {
     lines.push('  All checks passed.');
   } else {
     const fixable = issues.filter(r => r.fixId);
-    lines.push(`  ${issues.length} issue(s) found.${fixable.length > 0 ? ' Fixing...' : ''}`);
+    // `--check-only` is read-only (it never reaches runRepairs), so it must not
+    // claim "Fixing..." — that contradicts the documented contract and alarms
+    // the user into thinking their settings.json/MEMORY.md was just rewritten.
+    const suffix = fixable.length === 0
+      ? ''
+      : checkOnly
+        ? ' Run without --check-only to fix.'
+        : ' Fixing...';
+    lines.push(`  ${issues.length} issue(s) found.${suffix}`);
   }
 
   return lines.join('\n');
@@ -526,7 +534,7 @@ function runRepairs(results) {
 
 function runDoctor(opts = {}) {
   const results = runDiagnostics();
-  console.log(formatReport(results));
+  console.log(formatReport(results, { checkOnly: opts.checkOnly }));
 
   const issues = results.filter(r => r.status === 'warn' || r.status === 'error');
 

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

@@ -48,6 +48,22 @@ test('formatReport shows issue count when problems exist', () => {
   assert.ok(output.includes('issue'));
 });
 
+test('formatReport: --check-only never says "Fixing..." (it does not repair)', () => {
+  const results = [
+    { name: 'Hook coverage', status: 'warn', detail: 'missing', fixId: 'hooks' },
+  ];
+  // Default (repair mode) announces the fix.
+  assert.ok(formatReport(results).includes('Fixing...'),
+    'repair mode should announce Fixing...');
+  // --check-only is read-only: it must NOT claim to fix, and should point the
+  // user at the repair command instead.
+  const checkOnly = formatReport(results, { checkOnly: true });
+  assert.ok(!checkOnly.includes('Fixing...'),
+    `--check-only must not say "Fixing..."; got: ${checkOnly}`);
+  assert.ok(checkOnly.includes('--check-only'),
+    `--check-only should hint how to fix; got: ${checkOnly}`);
+});
+
 test('formatReport shows all-clear when no problems', () => {
   const results = [
     { name: 'Binary version', status: 'ok', detail: 'v0.7.16' },

package/claude-plugin/scripts/lifecycle.js

@@ -756,10 +756,13 @@ function update() {
   manifest.updatedAt = new Date().toISOString();
   writeManifest(manifest);
 
-  // 7. Clean up old cached versions (keep latest 3). Claude Code only fires
-  //    hooks from the active version (per installed_plugins.json), so older
-  //    cache dirs are inert disk clutter, not correctness risks.
-  cleanupOldCacheVersions(3);
+  // 7. Clean up old cached versions (keep the newest few). NOTE: older cache
+  //    dirs are NOT always inert — a running MCP server's launcher path
+  //    (<version>/scripts/mcp-launcher.js) is resolved + cached by Claude Code
+  //    for the whole session, so pruning the version a live process is bound to
+  //    breaks `/mcp` reconnect with -32000 (MODULE_NOT_FOUND). cleanupOldCacheVersions
+  //    therefore skips any version still referenced by a live process cmdline.
+  cleanupOldCacheVersions(5);
 
   return { oldVersion, version, settingsChanged, hooksRegistered };
 }
@@ -768,8 +771,16 @@ function update() {
  * Remove old plugin cache versions, keeping the N most recent.
  * Cache layout: ~/.claude/plugins/cache/<marketplace>/<plugin>/<version>/
  */
-function cleanupOldCacheVersions(keep = 3) {
-  const cacheParent = path.join(pluginsCacheDir(), MARKETPLACE_NAME);
+function cleanupOldCacheVersions(
+  keep = 5,
+  getActiveCmdlines = readActiveProcessCmdlines,
+  cacheParent = path.join(pluginsCacheDir(), MARKETPLACE_NAME),
+) {
+  // Command lines of all live processes — used by the in-use guard below to
+  // avoid deleting a version a running MCP server is still bound to. Failure to
+  // enumerate ⇒ [] ⇒ pruning falls back to recency-only (pre-guard behavior).
+  let cmdlines;
+  try { cmdlines = getActiveCmdlines() || []; } catch { cmdlines = []; }
   try {
     // List all subdirectories under the marketplace cache
     const entries = fs.readdirSync(cacheParent, { withFileTypes: true });
@@ -788,17 +799,51 @@ function cleanupOldCacheVersions(keep = 3) {
 
         if (versions.length <= keep) continue;
 
-        const toRemove = versions.slice(keep);
-        for (const v of toRemove) {
+        for (const v of versions.slice(keep)) {
+          // In-use guard: never delete a version dir a live process is running
+          // from. Claude Code caches the resolved launcher path
+          // (<version>/scripts/mcp-launcher.js) for the session; deleting that
+          // dir breaks `/mcp` reconnect with -32000. Trailing separator stops
+          // `0.8` from matching `0.80.x`.
+          if (cmdlines.some(c => c.includes(v.path + path.sep))) continue;
           try {
             fs.rmSync(v.path, { recursive: true, force: true });
-          } catch { /* permission error or in-use — skip */ }
+          } catch { /* permission error — skip */ }
         }
       } catch { /* can't read plugin dir — skip */ }
     }
   } catch { /* cache dir doesn't exist — nothing to clean */ }
 }
 
+/**
+ * Best-effort list of running process command lines, for cleanupOldCacheVersions'
+ * in-use guard. Linux reads /proc/<pid>/cmdline; macOS/BSD shells out to `ps`;
+ * any other platform or failure returns [] (pruning then falls back to
+ * recency-only — the same behavior as before the guard existed).
+ */
+function readActiveProcessCmdlines() {
+  try {
+    if (process.platform === 'linux' && fs.existsSync('/proc')) {
+      const out = [];
+      for (const pid of fs.readdirSync('/proc')) {
+        if (!/^\d+$/.test(pid)) continue;
+        try {
+          const raw = fs.readFileSync(path.join('/proc', pid, 'cmdline'), 'utf8');
+          if (raw) out.push(raw.replace(/\0/g, ' '));
+        } catch { /* pid exited or unreadable — skip */ }
+      }
+      return out;
+    }
+  } catch { /* fall through to ps */ }
+  try {
+    const { execFileSync } = require('child_process');
+    return execFileSync('ps', ['-axww', '-o', 'command='], {
+      encoding: 'utf8', maxBuffer: 8 * 1024 * 1024,
+    }).split('\n').filter(Boolean);
+  } catch { /* unsupported platform — caller falls back to recency-only */ }
+  return [];
+}
+
 // --- Health Check ---
 // Validates all registered paths in settings.json point to existing scripts.
 // Returns { healthy, issues, repaired, remaining }.

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

@@ -733,3 +733,54 @@ test('isStaleRelicContext: relic in plugins cache defers to a different active i
     existsSync: () => false,
   }), false);
 });
+
+test('cleanupOldCacheVersions keeps an in-use version even beyond the keep window', (t) => {
+  const { cleanupOldCacheVersions } = require('./lifecycle.js');
+  const cacheParent = fs.mkdtempSync(path.join(os.tmpdir(), 'code-graph-cache-'));
+  t.after(() => fs.rmSync(cacheParent, { recursive: true, force: true }));
+  const pluginDir = path.join(cacheParent, 'code-graph-mcp');
+  // Seven versions, oldest -> newest by mtime.
+  const vers = ['0.78.0', '0.80.2', '0.80.3', '0.81.0', '0.81.1', '0.81.2', '0.81.3'];
+  vers.forEach((v, i) => {
+    const scripts = path.join(pluginDir, v, 'scripts');
+    fs.mkdirSync(scripts, { recursive: true });
+    fs.writeFileSync(path.join(scripts, 'mcp-launcher.js'), '// stub');
+    const ts = (i + 1) * 3600; // distinct, increasing mtimes
+    fs.utimesSync(path.join(pluginDir, v), ts, ts);
+  });
+  // A live MCP server is running from the OLDEST version (beyond keep=5) — this
+  // is the v0.80.2 reconnect-(-32000) scenario.
+  const inUse = path.join(pluginDir, '0.78.0');
+  const fakeCmdlines = [`node ${path.join(inUse, 'scripts', 'mcp-launcher.js')} `];
+
+  cleanupOldCacheVersions(5, () => fakeCmdlines, cacheParent);
+
+  assert.equal(fs.existsSync(inUse), true,
+    'in-use version must survive prune even when it is the oldest');
+  assert.equal(fs.existsSync(path.join(pluginDir, '0.80.2')), false,
+    'a non-in-use version beyond the keep window is still pruned');
+  assert.equal(fs.existsSync(path.join(pluginDir, '0.81.3')), true,
+    'newest version (within keep window) is kept');
+});
+
+test('cleanupOldCacheVersions prunes beyond keep when nothing is in use', (t) => {
+  const { cleanupOldCacheVersions } = require('./lifecycle.js');
+  const cacheParent = fs.mkdtempSync(path.join(os.tmpdir(), 'code-graph-cache-'));
+  t.after(() => fs.rmSync(cacheParent, { recursive: true, force: true }));
+  const pluginDir = path.join(cacheParent, 'code-graph-mcp');
+  const vers = ['0.78.0', '0.80.2', '0.80.3', '0.81.0', '0.81.1', '0.81.2', '0.81.3'];
+  vers.forEach((v, i) => {
+    fs.mkdirSync(path.join(pluginDir, v), { recursive: true });
+    const ts = (i + 1) * 3600;
+    fs.utimesSync(path.join(pluginDir, v), ts, ts);
+  });
+  // No live process references any version → recency-only pruning (pre-guard).
+  cleanupOldCacheVersions(5, () => [], cacheParent);
+
+  assert.equal(fs.existsSync(path.join(pluginDir, '0.78.0')), false, 'oldest pruned');
+  assert.equal(fs.existsSync(path.join(pluginDir, '0.80.2')), false, '2nd-oldest pruned');
+  assert.equal(fs.existsSync(path.join(pluginDir, '0.80.3')), true, 'within keep window kept');
+  assert.equal(
+    fs.readdirSync(pluginDir).filter(n => fs.statSync(path.join(pluginDir, n)).isDirectory()).length,
+    5, 'exactly keep=5 versions remain');
+});

package/package.json

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