@sdsrs/code-graph 0.74.2 → 0.74.4

package/bin/cli.js

@@ -36,6 +36,36 @@ if (sub === "adopt" || sub === "unadopt") {
   process.exit(result.ok === false ? 1 : 0);
 }
 
+// Intercept `uninstall` — full local teardown (restore prior statusline, strip
+// code-graph hooks from settings.json, delete ~/.cache/code-graph, and unadopt the
+// CURRENT project). Node-only; no Rust counterpart. CC's `/plugin uninstall` fires
+// no uninstall hook, so this is the user's one-shot CLI teardown. Guard `--help`
+// before the destructive work (same discipline as adopt/unadopt above).
+if (sub === "uninstall") {
+  if (process.argv.slice(3).some((a) => a === "--help" || a === "-h")) {
+    process.stdout.write(
+      "code-graph-mcp uninstall — remove code-graph config + cache from this machine\n\n" +
+      "USAGE:\n    code-graph-mcp uninstall\n\n" +
+      "Restores your prior statusline, strips code-graph hooks from settings.json,\n" +
+      "deletes ~/.cache/code-graph, and removes this project's CLAUDE.md adoption\n" +
+      "block. Also run `/plugin uninstall code-graph-mcp` in Claude Code to sync its\n" +
+      "UI, and `code-graph-mcp unadopt` in any OTHER adopted project.\n");
+    process.exit(0);
+  }
+  const lifecycle = require("../claude-plugin/scripts/lifecycle");
+  const { unadopt } = require("../claude-plugin/scripts/adopt");
+  const r = lifecycle.uninstall();
+  let ua = { ok: false };
+  try { ua = unadopt(); } catch { /* best-effort — settings/cache already cleaned */ }
+  const projectUnadopted = !!(ua && (ua.blockPruned || ua.fileRemoved || ua.claudeMdRemoved));
+  process.stdout.write(
+    `Uninstalled code-graph-mcp | settings cleaned=${r.settingsChanged}` +
+    ` | this project unadopted=${projectUnadopted}\n` +
+    "  Also run `/plugin uninstall code-graph-mcp` in Claude Code, and\n" +
+    "  `code-graph-mcp unadopt` in any other adopted project.\n");
+  process.exit(0);
+}
+
 const { findBinary, unsupportedPlatformHint } = require("../claude-plugin/scripts/find-binary");
 
 const binary = findBinary();

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

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

package/claude-plugin/scripts/lifecycle.js

@@ -871,9 +871,31 @@ function healthCheck() {
   };
 }
 
+// True when the plugin has been UNINSTALLED (removed from installed_plugins.json),
+// as opposed to merely toggled OFF (isPluginExplicitlyDisabled — the user may
+// re-enable). The distinction matters because the uninstall teardown below is
+// destructive (deletes the cached binary, unwinds project adoption); doing that
+// on a temporary disable would force a re-download + re-adopt on re-enable.
+function isPluginUninstalled(settings = readJson(settingsPath()) || {}) {
+  if (isPluginExplicitlyDisabled(settings)) return false;
+  return isPluginInactive(settings);
+}
+
+// Remove the ~/.cache/code-graph residue (the ~40MB binary, update-state,
+// statusline-registry, install-manifest). The settings-only self-heal
+// (cleanupDisabledStatusline) leaves this behind; the SessionStart teardown calls
+// this so a CC `/plugin uninstall` (which fires no uninstall hook) still reclaims
+// the disk. Idempotent: rm is force, so repeat SessionStarts are no-ops. Does NOT
+// touch the plugin-cache script dirs — those are CC-managed and may be executing.
+function removeCacheResidue() {
+  try { fs.rmSync(CACHE_DIR, { recursive: true, force: true }); return true; }
+  catch { return false; }
+}
+
 module.exports = {
   install, uninstall, update, healthCheck, scanForBrokenPaths, checkScopeConflict,
-  isPluginExplicitlyDisabled, isPluginInactive, cleanupDisabledStatusline,
+  isPluginExplicitlyDisabled, isPluginInactive, isPluginUninstalled, removeCacheResidue,
+  cleanupDisabledStatusline,
   readManifest, readJson, writeJsonAtomic,
   readRegistry, writeRegistry,
   getPluginVersion, cleanupOldCacheVersions,
@@ -898,7 +920,8 @@ if (require.main === module) {
   } else if (cmd === 'uninstall') {
     const r = uninstall();
     console.log(`Uninstalled | settings cleaned=${r.settingsChanged}`);
-    console.log('  Note: also run `/plugin uninstall code-graph-mcp` inside Claude Code to sync its UI state.');
+    console.log('  Note: also run `/plugin uninstall code-graph-mcp` inside Claude Code to sync its UI state,');
+    console.log('  and `code-graph-mcp unadopt` in each adopted project to remove its CLAUDE.md block.');
   } else if (cmd === 'update') {
     const r = update();
     console.log(`Updated ${r.oldVersion} → ${r.version} | settings=${r.settingsChanged}`);

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

@@ -99,6 +99,39 @@ test('cleanupDisabledStatusline also heals orphaned statusline after uninstall',
   assert.equal(fs.existsSync(registryPath), false);
 });
 
+test('isPluginUninstalled distinguishes a genuine uninstall from a temporary disable', (t) => {
+  // Orphaned composite (installed_plugins exists, no code-graph record) = uninstalled.
+  const uninstalledHome = mkHome(t);
+  seedOrphanedComposite(uninstalledHome);
+  // enabledPlugins[id]=false = user toggled it off; may re-enable → NOT uninstalled.
+  const disabledHome = mkHome(t);
+  seedDisabledComposite(disabledHome);
+
+  const probe = (home) => JSON.parse(execFileSync(process.execPath, ['-e', `
+    const { isPluginUninstalled } = require(${JSON.stringify(lifecyclePath)});
+    process.stdout.write(JSON.stringify(isPluginUninstalled()));
+  `], { env: { ...process.env, HOME: home } }).toString());
+
+  assert.equal(probe(uninstalledHome), true, 'orphaned/no-record → uninstalled');
+  assert.equal(probe(disabledHome), false, 'explicit disable → not uninstalled (re-enable safe)');
+});
+
+test('removeCacheResidue deletes ~/.cache/code-graph and is idempotent', (t) => {
+  const homeDir = mkHome(t);
+  const cacheDir = path.join(homeDir, '.cache', 'code-graph');
+  writeJson(path.join(cacheDir, 'bin', 'marker.json'), { v: 1 });
+  fs.writeFileSync(path.join(cacheDir, 'update-state.json'), '{}');
+
+  const run = () => execFileSync(process.execPath, ['-e', `
+    const { removeCacheResidue } = require(${JSON.stringify(lifecyclePath)});
+    process.stdout.write(JSON.stringify(removeCacheResidue()));
+  `], { env: { ...process.env, HOME: homeDir } }).toString();
+
+  assert.equal(run(), 'true');
+  assert.equal(fs.existsSync(cacheDir), false, 'cache dir removed');
+  assert.equal(run(), 'true', 'second call is a no-op success (idempotent force-rm)');
+});
+
 function legacyHooksFromPlugin() {
   return {
     SessionStart: [{

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

@@ -5,11 +5,11 @@ const path = require('path');
 const fs = require('fs');
 const {
   install, update, readManifest, getPluginVersion, checkScopeConflict,
-  cleanupDisabledStatusline, isPluginInactive, readJson, CACHE_DIR,
-  settingsPath, isStaleRelicContext,
+  cleanupDisabledStatusline, isPluginInactive, isPluginUninstalled, removeCacheResidue,
+  readJson, CACHE_DIR, settingsPath, isStaleRelicContext,
 } = require('./lifecycle');
 const { readBinaryVersion, isDevMode, getNewestMtime } = require('./version-utils');
-const { maybeAutoAdopt, isAdopted } = require('./adopt');
+const { maybeAutoAdopt, isAdopted, unadopt } = require('./adopt');
 const { isNonProjectCwd } = require('./project-detect');
 
 // v0.17.0 — quietHooks: unconditional quiet 默认。
@@ -420,8 +420,31 @@ function consistencyCheck(binary) {
 
 function runSessionInit({ source } = {}) {
   if (isPluginInactive()) {
+    // Capture the uninstalled-vs-disabled verdict BEFORE cleanupDisabledStatusline()
+    // runs — it removes our composite + registry entry, which are the very signals
+    // isPluginUninstalled()/isPluginInactive() read, so calling it afterwards would
+    // always see "no composite/registry" and report not-uninstalled (teardown skipped).
+    const uninstalled = isPluginUninstalled();
     cleanupDisabledStatusline();
-    return { inactive: true, lifecycle: 'noop', autoUpdateLaunched: false };
+    // Genuine uninstall (not a temporary disable) leaves residue the settings-only
+    // self-heal can't reach: ~/.cache/code-graph (the ~40MB binary + state) and the
+    // current project's CLAUDE.md adoption block. CC fires no uninstall hook, so this
+    // SessionStart is the only automated teardown — symmetric to install's auto-adopt.
+    // Per-project: only the cwd we're in; other adopted projects self-clean when next
+    // opened, or via `code-graph-mcp unadopt`.
+    let teardown = null;
+    if (uninstalled) {
+      const cacheRemoved = removeCacheResidue();
+      let unadopted = false;
+      try {
+        if (!isNonProjectCwd(process.cwd())) {
+          const r = unadopt({ cwd: process.cwd() });
+          unadopted = !!(r && (r.blockPruned || r.fileRemoved || r.claudeMdRemoved));
+        }
+      } catch { /* best-effort — never let teardown break SessionStart */ }
+      teardown = { cacheRemoved, unadopted };
+    }
+    return { inactive: true, lifecycle: 'noop', autoUpdateLaunched: false, teardown };
   }
 
   // Non-project cwd (no .git/manifest — e.g. /tmp, where claude-mem-lite

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

@@ -99,6 +99,53 @@ test('runSessionInit no-ops (nonProject) in a non-project cwd', (t) => {
   }
 });
 
+test('runSessionInit tears down cache + adoption on a genuine uninstall (order regression)', (t) => {
+  // Subprocess isolation: lifecycle.js evaluates CACHE_DIR from os.homedir() at
+  // MODULE LOAD, so HOME/CLAUDE_CONFIG_DIR must be set before require — only a
+  // fresh child honors them. This locks the order bug: isPluginUninstalled() MUST be
+  // read BEFORE cleanupDisabledStatusline() wipes the composite/registry signals it
+  // depends on — otherwise teardown is skipped (was null pre-fix).
+  const os = require('os');
+  const { execFileSync } = require('child_process');
+  const sb = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-si-teardown-'));
+  t.after(() => fs.rmSync(sb, { recursive: true, force: true }));
+  const home = sb, cfg = path.join(sb, '.claude'), proj = path.join(sb, 'proj');
+  fs.mkdirSync(path.join(cfg, 'plugins'), { recursive: true });
+  fs.mkdirSync(proj, { recursive: true });
+  fs.writeFileSync(path.join(proj, 'package.json'), '{"name":"p","version":"1.0.0"}');
+  fs.writeFileSync(path.join(proj, 'CLAUDE.md'), '# P\n\nKEEP THIS USER LINE.\n');
+  fs.writeFileSync(path.join(cfg, 'settings.json'), '{"statusLine":{"type":"command","command":"/bin/prior.sh"}}');
+  const env = { ...process.env, HOME: home, CLAUDE_CONFIG_DIR: cfg };
+  const lc = path.join(__dirname, 'lifecycle.js'), ad = path.join(__dirname, 'adopt.js');
+  const si = path.join(__dirname, 'session-init.js');
+
+  // install + adopt, then simulate a downloaded binary + a post-/plugin-uninstall
+  // installed_plugins.json (record for some OTHER plugin, none for code-graph).
+  execFileSync(process.execPath, [lc, 'install'], { env, cwd: proj, stdio: 'ignore' });
+  execFileSync(process.execPath, ['-e',
+    `require(${JSON.stringify(ad)}).adopt({cwd:process.cwd()})`], { env, cwd: proj, stdio: 'ignore' });
+  fs.mkdirSync(path.join(home, '.cache', 'code-graph', 'bin'), { recursive: true });
+  fs.writeFileSync(path.join(home, '.cache', 'code-graph', 'bin', 'code-graph-mcp'), 'x');
+  fs.writeFileSync(path.join(cfg, 'plugins', 'installed_plugins.json'),
+    JSON.stringify({ plugins: { 'other@mkt': [{ version: '1.0.0', installPath: '/x' }] } }));
+  assert.ok(fs.readFileSync(path.join(proj, 'CLAUDE.md'), 'utf8').includes('code-graph'), 'adopt injected block');
+
+  const res = JSON.parse(execFileSync(process.execPath, ['-e',
+    `process.stdout.write(JSON.stringify(require(${JSON.stringify(si)}).runSessionInit({source:'startup'})))`],
+    { env, cwd: proj }).toString());
+
+  assert.equal(res.inactive, true);
+  assert.ok(res.teardown, 'teardown ran (null pre-fix = order bug)');
+  assert.equal(res.teardown.cacheRemoved, true);
+  assert.equal(res.teardown.unadopted, true);
+  assert.equal(fs.existsSync(path.join(home, '.cache', 'code-graph')), false, 'cache residue gone');
+  const md = fs.readFileSync(path.join(proj, 'CLAUDE.md'), 'utf8');
+  assert.ok(!md.includes('code-graph'), 'adopt block removed');
+  assert.ok(md.includes('KEEP THIS USER LINE'), 'user content preserved');
+  const settings = JSON.parse(fs.readFileSync(path.join(cfg, 'settings.json'), 'utf8'));
+  assert.equal(settings.statusLine.command, '/bin/prior.sh', 'prior statusline restored');
+});
+
 test('consistencyCheck returns empty array when binary version matches plugin', () => {
   const result = consistencyCheck('/tmp/nonexistent-binary');
   assert.ok(Array.isArray(result));

package/claude-plugin/scripts/statusline.js

@@ -2,11 +2,25 @@
 'use strict';
 const { execFileSync } = require('child_process');
 const fs = require('fs');
+const os = require('os');
 const path = require('path');
 const { findBinary } = require('./find-binary');
 const lifecycle = require('./lifecycle');
 const cleanupDisabledStatusline = lifecycle.cleanupDisabledStatusline || (() => ({ cleaned: false }));
 
+// True when auto-update has a newer release queued or in flight (the background
+// downloader in session-init.js hasn't promoted the new binary yet). Used to show
+// a transient "updating" state instead of the alarming "offline" during that window.
+function updatePending() {
+  try {
+    const st = JSON.parse(fs.readFileSync(
+      path.join(os.homedir(), '.cache', 'code-graph', 'update-state.json'), 'utf8'));
+    if (st.updateAvailable) return true;
+    if (st.latestVersion && st.installedVersion && st.latestVersion !== st.installedVersion) return true;
+  } catch { /* no state file or unreadable — treat as no pending update */ }
+  return false;
+}
+
 const disabledCleanup = cleanupDisabledStatusline();
 if (disabledCleanup.cleaned) process.exit(0);
 
@@ -38,7 +52,9 @@ if (!fs.existsSync(path.join(codeGraphDir, 'index.db'))) {
 
 const bin = findBinary();
 if (!bin) {
-  process.stdout.write('code-graph: offline');
+  // No usable binary yet. If an update is queued, the background downloader is
+  // still fetching it \u2014 that is "updating", not a broken "offline" state.
+  process.stdout.write(updatePending() ? 'code-graph: \u21bb updating' : 'code-graph: offline');
   process.exit(0);
 }
 
@@ -53,6 +69,13 @@ try {
     `code-graph: ${icon} ${s.nodes} nodes | ${s.files} files` +
     (s.watching ? ' | watching' : '')
   );
-} catch {
-  process.stdout.write('code-graph: offline');
+} catch (e) {
+  // A schema-too-new error means the resolved binary is OLDER than the index it
+  // is reading \u2014 the classic post-update window where the new binary is still
+  // downloading. That, or any pending update, is transient: show "updating" so
+  // the user knows it self-heals, rather than the misleading "offline".
+  const errOut = ((e && (e.stderr || e.stdout)) || '').toString();
+  const binaryOutdated = /schema version/i.test(errOut);
+  process.stdout.write(
+    (binaryOutdated || updatePending()) ? 'code-graph: \u21bb updating' : 'code-graph: offline');
 }

package/package.json

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