@sdsrs/code-graph 0.5.27 → 0.5.29

package/claude-plugin/scripts/find-binary.js

@@ -6,25 +6,43 @@ const fs = require('fs');
 const os = require('os');
 
 const PLATFORM = os.platform();
+const ARCH = os.arch();
 const CACHE_FILE = path.join(os.homedir(), '.cache', 'code-graph', 'binary-path');
+const BINARY_NAME = PLATFORM === 'win32' ? 'code-graph-mcp.exe' : 'code-graph-mcp';
+
+function isNativeBinary(candidate) {
+  if (!candidate) return false;
+  try {
+    if (!fs.existsSync(candidate)) return false;
+    const realPath = fs.realpathSync(candidate);
+    return path.basename(realPath) === BINARY_NAME;
+  } catch {
+    return false;
+  }
+}
 
 /**
  * Locate the code-graph-mcp binary using multiple strategies.
  * Results are cached to disk so repeated calls (e.g. per-hook) are fast.
- * Priority: cache > PATH > local dev build > cargo install > npm platform pkg > npx cache
+ *
+ * Priority:
+ *   cache (if valid) → dev-mode (target/release) → auto-update cache
+ *   → platform npm pkg → bundled (bin/) → cargo install → PATH → npx cache
+ *
  * Returns the absolute path or null if not found.
  */
 function findBinary() {
   // Try disk cache first (avoids spawning `which` on hot paths)
   try {
     const cached = fs.readFileSync(CACHE_FILE, 'utf8').trim();
-    if (cached && fs.existsSync(cached)) return cached;
+    if (isNativeBinary(cached)) return cached;
+    if (cached) clearCache();
   } catch { /* no cache or stale */ }
 
   const result = findBinaryUncached();
 
   // Write cache for subsequent calls
-  if (result) {
+  if (isNativeBinary(result)) {
     try {
       fs.mkdirSync(path.dirname(CACHE_FILE), { recursive: true });
       fs.writeFileSync(CACHE_FILE, result);
@@ -34,50 +52,95 @@ function findBinary() {
   return result;
 }
 
+/**
+ * Detect if we're running from the source repo (e.g. npm link).
+ * Checks relative to a given root directory for Cargo.toml.
+ */
+function isDevRepo(rootDir) {
+  return fs.existsSync(path.join(rootDir, 'Cargo.toml'));
+}
+
 function findBinaryUncached() {
-  const name = PLATFORM === 'win32' ? 'code-graph-mcp.exe' : 'code-graph-mcp';
+  // --- Dev mode: always prefer cargo build output when running from source repo ---
+  // This covers: npm link, direct invocation from repo, CLAUDE_PROJECT_DIR set to repo
+  const possibleRoots = new Set();
 
-  // 1. PATH lookup (user has intentionally installed it)
-  try {
-    const which = PLATFORM === 'win32' ? 'where' : 'which';
-    const found = execFileSync(which, [name], { stdio: ['pipe', 'pipe', 'pipe'] })
-      .toString().trim().split('\n')[0];
-    if (found && fs.existsSync(found)) return found;
-  } catch { /* not in PATH */ }
+  // From plugin scripts context (claude-plugin/scripts/ → repo root is ../..)
+  possibleRoots.add(path.resolve(__dirname, '..', '..'));
+  // From bin/ context (cli.js sets FIND_BINARY_ROOT)
+  if (process.env._FIND_BINARY_ROOT) {
+    possibleRoots.add(path.resolve(process.env._FIND_BINARY_ROOT));
+  }
+  // From CLAUDE_PROJECT_DIR
+  if (process.env.CLAUDE_PROJECT_DIR) {
+    possibleRoots.add(path.resolve(process.env.CLAUDE_PROJECT_DIR));
+  }
 
-  // 2. Local dev build (target/release in project directory)
-  const projectRoot = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-  const devBin = path.join(projectRoot, 'target', 'release', name);
-  if (fs.existsSync(devBin)) return devBin;
+  for (const root of possibleRoots) {
+    if (isDevRepo(root)) {
+      const devBin = path.join(root, 'target', 'release', BINARY_NAME);
+      if (isNativeBinary(devBin)) return devBin;
+    }
+  }
 
-  // 3. Cargo install (~/.cargo/bin)
-  const cargoBin = path.join(os.homedir(), '.cargo', 'bin', name);
-  if (fs.existsSync(cargoBin)) return cargoBin;
+  // --- Auto-update cache (binary downloaded directly from GitHub release) ---
+  const autoUpdateBin = path.join(os.homedir(), '.cache', 'code-graph', 'bin', BINARY_NAME);
+  if (isNativeBinary(autoUpdateBin)) return autoUpdateBin;
 
-  // 4. npm platform package (installed via @sdsrs/code-graph)
-  const platformPkg = `@sdsrs/code-graph-${PLATFORM}-${os.arch()}`;
+  // --- Platform-specific npm package (@sdsrs/code-graph-{os}-{arch}) ---
+  const platformPkg = `@sdsrs/code-graph-${PLATFORM}-${ARCH}`;
   try {
     const pkgPath = require.resolve(`${platformPkg}/package.json`);
-    const bin = path.join(path.dirname(pkgPath), name);
-    if (fs.existsSync(bin)) return bin;
+    const bin = path.join(path.dirname(pkgPath), BINARY_NAME);
+    if (isNativeBinary(bin)) return bin;
   } catch { /* not installed via npm */ }
 
-  // 5. npx cache (last resort — may be outdated)
+  // --- Bundled binary (in same directory as cli.js or plugin scripts) ---
+  // Check bin/ directory of the npm package
+  const binDirs = new Set();
+  if (process.env._FIND_BINARY_ROOT) {
+    binDirs.add(path.join(process.env._FIND_BINARY_ROOT, 'bin'));
+  }
+  binDirs.add(path.resolve(__dirname, '..', '..', 'bin'));
+  for (const dir of binDirs) {
+    const bundled = path.join(dir, BINARY_NAME);
+    if (isNativeBinary(bundled)) return bundled;
+  }
+
+  // --- Cargo install (~/.cargo/bin) ---
+  const cargoBin = path.join(os.homedir(), '.cargo', 'bin', BINARY_NAME);
+  if (isNativeBinary(cargoBin)) return cargoBin;
+
+  // --- PATH lookup (last resort for intentionally installed binaries) ---
+  try {
+    const which = PLATFORM === 'win32' ? 'where' : 'which';
+    const found = execFileSync(which, [BINARY_NAME], { stdio: ['pipe', 'pipe', 'pipe'] })
+      .toString().trim().split('\n')[0];
+    if (isNativeBinary(found)) return found;
+  } catch { /* not in PATH */ }
+
+  // --- npx cache (very last resort — may be outdated) ---
   const npxDir = path.join(os.homedir(), '.npm', '_npx');
   try {
     for (const entry of fs.readdirSync(npxDir)) {
-      const pkgJsonPath = path.join(npxDir, entry, 'node_modules', '@sdsrs', 'code-graph', 'package.json');
-      if (!fs.existsSync(pkgJsonPath)) continue;
-      const platDir = path.join(npxDir, entry, 'node_modules', '@sdsrs', `code-graph-${PLATFORM}-${os.arch()}`);
-      const platBin = path.join(platDir, name);
-      if (fs.existsSync(platBin)) return platBin;
+      const platDir = path.join(npxDir, entry, 'node_modules', '@sdsrs', `code-graph-${PLATFORM}-${ARCH}`);
+      const platBin = path.join(platDir, BINARY_NAME);
+      if (isNativeBinary(platBin)) return platBin;
     }
   } catch { /* no npx cache */ }
 
   return null;
 }
 
-module.exports = { findBinary };
+/**
+ * Clear the disk cache. Call this after binary updates so the next
+ * findBinary() picks up the new location.
+ */
+function clearCache() {
+  try { fs.unlinkSync(CACHE_FILE); } catch { /* ok */ }
+}
+
+module.exports = { findBinary, findBinaryUncached, clearCache, CACHE_FILE, BINARY_NAME };
 
 // Allow direct invocation for testing
 if (require.main === module) {

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

@@ -0,0 +1,91 @@
+'use strict';
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const repoRoot = path.resolve(__dirname, '..', '..');
+const pluginRoot = path.resolve(__dirname, '..');
+const lifecycleCli = path.join(__dirname, 'lifecycle.js');
+const compositeCli = path.join(__dirname, 'statusline-composite.js');
+const currentVersion = JSON.parse(fs.readFileSync(path.join(repoRoot, 'package.json'), 'utf8')).version;
+
+function mkHome() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'code-graph-e2e-'));
+}
+
+function writeJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(value, null, 2) + '\n');
+}
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function runScript(homeDir, scriptPath, args = [], options = {}) {
+  return execFileSync(process.execPath, [scriptPath, ...args], {
+    cwd: options.cwd || repoRoot,
+    env: { ...process.env, HOME: homeDir, CLAUDE_PLUGIN_ROOT: pluginRoot },
+    input: options.input,
+    stdio: ['pipe', 'pipe', 'pipe'],
+  }).toString();
+}
+
+test('lifecycle CLI handles install, disable self-heal, re-enable, and uninstall', () => {
+  const homeDir = mkHome();
+  const settingsPath = path.join(homeDir, '.claude', 'settings.json');
+  const installedPath = path.join(homeDir, '.claude', 'plugins', 'installed_plugins.json');
+  const registryPath = path.join(homeDir, '.cache', 'code-graph', 'statusline-registry.json');
+  const manifestPath = path.join(homeDir, '.cache', 'code-graph', 'install-manifest.json');
+  const cacheDir = path.join(homeDir, '.cache', 'code-graph');
+
+  writeJson(settingsPath, {
+    statusLine: { type: 'command', command: 'echo previous-status' },
+    enabledPlugins: { 'code-graph-mcp@code-graph-mcp': true },
+  });
+  writeJson(installedPath, {
+    plugins: {
+      'code-graph-mcp@code-graph-mcp': [{
+        installPath: pluginRoot,
+        version: currentVersion,
+        scope: 'user',
+      }],
+    },
+  });
+
+  runScript(homeDir, lifecycleCli, ['install']);
+  let settings = readJson(settingsPath);
+  let registry = readJson(registryPath);
+  let manifest = readJson(manifestPath);
+  assert.match(settings.statusLine.command, /statusline-composite\.js/);
+  assert.equal(registry[0].id, '_previous');
+  assert.equal(registry[1].id, 'code-graph');
+  assert.equal(manifest.version, currentVersion);
+
+  settings.enabledPlugins['code-graph-mcp@code-graph-mcp'] = false;
+  writeJson(settingsPath, settings);
+  runScript(homeDir, compositeCli, [], { input: '{}' });
+  settings = readJson(settingsPath);
+  assert.equal(settings.statusLine.command, 'echo previous-status');
+  assert.equal(fs.existsSync(registryPath), false);
+
+  settings.enabledPlugins['code-graph-mcp@code-graph-mcp'] = true;
+  writeJson(settingsPath, settings);
+  runScript(homeDir, lifecycleCli, ['install']);
+  settings = readJson(settingsPath);
+  registry = readJson(registryPath);
+  assert.match(settings.statusLine.command, /statusline-composite\.js/);
+  assert.equal(registry.length, 2);
+
+  runScript(homeDir, lifecycleCli, ['uninstall']);
+  settings = readJson(settingsPath);
+  const installed = readJson(installedPath);
+  assert.equal(settings.statusLine.command, 'echo previous-status');
+  assert.deepEqual(settings.enabledPlugins, {});
+  assert.deepEqual(installed.plugins, {});
+  assert.equal(fs.existsSync(cacheDir), false);
+});
+

package/claude-plugin/scripts/lifecycle.js

@@ -53,6 +53,15 @@ function codeGraphStatuslineCommand() {
   return `node ${JSON.stringify(path.join(PLUGIN_ROOT, 'scripts', 'statusline.js'))}`;
 }
 
+function hasOwn(obj, key) {
+  return !!obj && Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+function hasInstalledPluginRecord() {
+  const installed = readJson(INSTALLED_PLUGINS_PATH);
+  return !!(installed && installed.plugins && Array.isArray(installed.plugins[PLUGIN_ID]) && installed.plugins[PLUGIN_ID].length > 0);
+}
+
 function isOurComposite(settings) {
   return settings.statusLine &&
     settings.statusLine.command &&
@@ -67,6 +76,10 @@ function readRegistry() {
 }
 
 function writeRegistry(registry) {
+  if (!registry || registry.length === 0) {
+    try { fs.unlinkSync(REGISTRY_FILE); } catch { /* ok */ }
+    return;
+  }
   writeJsonAtomic(REGISTRY_FILE, registry);
 }
 
@@ -93,6 +106,58 @@ function unregisterStatuslineProvider(id) {
   return true;
 }
 
+function isPluginExplicitlyDisabled(settings = readJson(SETTINGS_PATH) || {}) {
+  return hasOwn(settings.enabledPlugins, PLUGIN_ID) && settings.enabledPlugins[PLUGIN_ID] === false;
+}
+
+function isPluginInactive(settings = readJson(SETTINGS_PATH) || {}) {
+  if (isPluginExplicitlyDisabled(settings)) return true;
+
+  const hasComposite = isOurComposite(settings);
+  const hasCodeGraphRegistry = readRegistry().some((provider) => provider.id === 'code-graph');
+  if (!hasComposite && !hasCodeGraphRegistry) return false;
+
+  const installed = readJson(INSTALLED_PLUGINS_PATH);
+  if (!installed || !installed.plugins) return false;
+  return !hasInstalledPluginRecord();
+}
+
+function detachStatuslineIntegration(settings) {
+  let settingsChanged = false;
+
+  unregisterStatuslineProvider('code-graph');
+  const previous = readRegistry().find(p => p.id === '_previous' && p.command);
+
+  // If our composite is still configured while the plugin is disabled/uninstalled,
+  // prefer restoring the prior statusline (or removing ours entirely) so the plugin
+  // truly stops affecting Claude Code.
+  if (isOurComposite(settings)) {
+    if (previous) {
+      settings.statusLine = { type: 'command', command: previous.command };
+    } else {
+      delete settings.statusLine;
+    }
+    settingsChanged = true;
+  }
+
+  unregisterStatuslineProvider('_previous');
+  return settingsChanged;
+}
+
+function cleanupDisabledStatusline() {
+  const settings = readJson(SETTINGS_PATH);
+  if (!settings || !isPluginInactive(settings)) {
+    return { cleaned: false, settingsChanged: false };
+  }
+
+  const settingsChanged = detachStatuslineIntegration(settings);
+  if (settingsChanged) {
+    writeJsonAtomic(SETTINGS_PATH, settings);
+  }
+
+  return { cleaned: true, settingsChanged };
+}
+
 // --- Scope Conflict Detection ---
 
 function checkScopeConflict() {
@@ -207,22 +272,9 @@ function uninstall() {
   let settingsChanged = false;
 
   if (settings) {
-    // 1. StatusLine: remove code-graph from registry
-    unregisterStatuslineProvider('code-graph');
-    const remaining = readRegistry();
-
-    if (isOurComposite(settings)) {
-      if (remaining.length === 1 && remaining[0].id === '_previous') {
-        // Only the previous provider remains — restore it directly
-        settings.statusLine = { type: 'command', command: remaining[0].command };
-        unregisterStatuslineProvider('_previous');
-        settingsChanged = true;
-      } else if (remaining.length === 0) {
-        // No providers left — remove statusLine entirely
-        delete settings.statusLine;
-        settingsChanged = true;
-      }
-      // else: other providers still using composite — leave it
+    // 1. StatusLine: remove code-graph integration and restore prior statusline.
+    if (detachStatuslineIntegration(settings)) {
+      settingsChanged = true;
     }
 
     // 2. Remove all known IDs from enabledPlugins
@@ -317,6 +369,7 @@ function update() {
 
 module.exports = {
   install, uninstall, update, checkScopeConflict,
+  isPluginExplicitlyDisabled, isPluginInactive, cleanupDisabledStatusline,
   readManifest, readJson, writeJsonAtomic,
   readRegistry, writeRegistry,
   getPluginVersion,

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

@@ -0,0 +1,97 @@
+'use strict';
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const lifecyclePath = path.join(__dirname, 'lifecycle.js');
+const statuslinePath = path.join(__dirname, 'statusline.js');
+
+function mkHome() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'code-graph-home-'));
+}
+
+function writeJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(value, null, 2) + '\n');
+}
+
+function seedDisabledComposite(homeDir) {
+  const settingsPath = path.join(homeDir, '.claude', 'settings.json');
+  const registryPath = path.join(homeDir, '.cache', 'code-graph', 'statusline-registry.json');
+  writeJson(settingsPath, {
+    statusLine: { type: 'command', command: 'node "/plugin/statusline-composite.js"' },
+    enabledPlugins: { 'code-graph-mcp@code-graph-mcp': false },
+  });
+  writeJson(registryPath, [
+    { id: '_previous', command: 'echo previous-status', needsStdin: true },
+    { id: 'code-graph', command: 'node "/plugin/statusline.js"', needsStdin: false },
+  ]);
+  return { settingsPath, registryPath };
+}
+
+function seedOrphanedComposite(homeDir) {
+  const settingsPath = path.join(homeDir, '.claude', 'settings.json');
+  const registryPath = path.join(homeDir, '.cache', 'code-graph', 'statusline-registry.json');
+  const installedPath = path.join(homeDir, '.claude', 'plugins', 'installed_plugins.json');
+  writeJson(settingsPath, {
+    statusLine: { type: 'command', command: 'node "/plugin/statusline-composite.js"' },
+    enabledPlugins: {},
+  });
+  writeJson(installedPath, { plugins: {} });
+  writeJson(registryPath, [
+    { id: '_previous', command: 'echo previous-status', needsStdin: true },
+    { id: 'code-graph', command: 'node "/plugin/statusline.js"', needsStdin: false },
+  ]);
+  return { settingsPath, registryPath };
+}
+
+test('cleanupDisabledStatusline restores previous statusline and removes registry', () => {
+  const homeDir = mkHome();
+  const { settingsPath, registryPath } = seedDisabledComposite(homeDir);
+
+  const out = execFileSync(process.execPath, ['-e', `
+    const { cleanupDisabledStatusline } = require(${JSON.stringify(lifecyclePath)});
+    process.stdout.write(JSON.stringify(cleanupDisabledStatusline()));
+  `], { env: { ...process.env, HOME: homeDir } }).toString();
+
+  assert.deepEqual(JSON.parse(out), { cleaned: true, settingsChanged: true });
+  const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+  assert.equal(settings.statusLine.command, 'echo previous-status');
+  assert.equal(fs.existsSync(registryPath), false);
+});
+
+test('statusline exits cleanly and self-heals when plugin is disabled', () => {
+  const homeDir = mkHome();
+  const { settingsPath, registryPath } = seedDisabledComposite(homeDir);
+  const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'code-graph-project-'));
+  fs.mkdirSync(path.join(projectDir, '.code-graph'), { recursive: true });
+  fs.writeFileSync(path.join(projectDir, '.code-graph', 'index.db'), '');
+
+  const stdout = execFileSync(process.execPath, [statuslinePath], {
+    env: { ...process.env, HOME: homeDir },
+    cwd: projectDir,
+  }).toString();
+
+  assert.equal(stdout, '');
+  const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+  assert.equal(settings.statusLine.command, 'echo previous-status');
+  assert.equal(fs.existsSync(registryPath), false);
+});
+
+test('cleanupDisabledStatusline also heals orphaned statusline after uninstall', () => {
+  const homeDir = mkHome();
+  const { settingsPath, registryPath } = seedOrphanedComposite(homeDir);
+
+  const out = execFileSync(process.execPath, ['-e', `
+    const { cleanupDisabledStatusline } = require(${JSON.stringify(lifecyclePath)});
+    process.stdout.write(JSON.stringify(cleanupDisabledStatusline()));
+  `], { env: { ...process.env, HOME: homeDir } }).toString();
+
+  assert.deepEqual(JSON.parse(out), { cleaned: true, settingsChanged: true });
+  const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+  assert.equal(settings.statusLine.command, 'echo previous-status');
+  assert.equal(fs.existsSync(registryPath), false);
+});