@sdsrs/code-graph 0.7.16 → 0.8.0

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

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

package/claude-plugin/hooks/hooks.json

@@ -1,16 +1,5 @@
 {
-  "hooks": {
-    "SessionStart": [
-      {
-        "matcher": "startup|clear|compact",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/session-init.js\"",
-            "timeout": 5
-          }
-        ]
-      }
-    ]
-  }
+  "description": "code-graph-mcp hooks",
+  "_note": "Hooks are registered to ~/.claude/settings.json by scripts/lifecycle.js. This file is intentionally empty to prevent double-firing — Claude Code would otherwise load hooks from both the plugin cache copy AND settings.json, causing each hook to run twice per event.",
+  "hooks": {}
 }

package/claude-plugin/scripts/adopt.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+'use strict';
+// adopt / unadopt — writes plugin_code_graph_mcp.md into this project's
+// claude-mem memory dir and maintains a sentinel-bracketed index entry in
+// MEMORY.md. Idempotent. Used by invited-memory pattern with CODE_GRAPH_QUIET_HOOKS=1.
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const SENTINEL_BEGIN = '<!-- code-graph-mcp:begin v1 -->';
+const SENTINEL_END = '<!-- code-graph-mcp:end -->';
+const INDEX_LINE = '- [code-graph-mcp](plugin_code_graph_mcp.md) — "谁调 X / 改 X 炸啥 / 模块结构" → `get_call_graph` / `impact_analysis` / `module_overview`，替代多步 Grep/Read';
+const TEMPLATE_PATH = path.resolve(__dirname, '..', 'templates', 'plugin_code_graph_mcp.md');
+const TARGET_NAME = 'plugin_code_graph_mcp.md';
+
+function memoryDir(cwd = process.cwd(), home = os.homedir()) {
+  const slug = cwd.replace(/\//g, '-');
+  return path.join(home, '.claude', 'projects', slug, 'memory');
+}
+
+function escapeRegex(s) {
+  return s.replace(/[\\/[\]^$.*+?()|{}]/g, '\\$&');
+}
+
+function adopt({ cwd, home, templatePath } = {}) {
+  const dir = memoryDir(cwd, home);
+  if (!fs.existsSync(dir)) {
+    return { ok: false, reason: 'no-memory-dir', dir };
+  }
+  const target = path.join(dir, TARGET_NAME);
+  const tpl = templatePath || TEMPLATE_PATH;
+  if (!fs.existsSync(tpl)) {
+    return { ok: false, reason: 'no-template', template: tpl };
+  }
+  fs.copyFileSync(tpl, target);
+
+  const indexPath = path.join(dir, 'MEMORY.md');
+  let index = fs.existsSync(indexPath) ? fs.readFileSync(indexPath, 'utf8') : '# Memory Index\n';
+  let indexed = false;
+  if (!index.includes(SENTINEL_BEGIN)) {
+    if (!index.endsWith('\n')) index += '\n';
+    index += `${SENTINEL_BEGIN}\n${INDEX_LINE}\n${SENTINEL_END}\n`;
+    fs.writeFileSync(indexPath, index);
+    indexed = true;
+  }
+  return { ok: true, target, indexPath, indexed };
+}
+
+function unadopt({ cwd, home } = {}) {
+  const dir = memoryDir(cwd, home);
+  const target = path.join(dir, TARGET_NAME);
+  const indexPath = path.join(dir, 'MEMORY.md');
+  let fileRemoved = false;
+  let indexPruned = false;
+
+  if (fs.existsSync(target)) {
+    fs.unlinkSync(target);
+    fileRemoved = true;
+  }
+  if (fs.existsSync(indexPath)) {
+    const before = fs.readFileSync(indexPath, 'utf8');
+    const re = new RegExp(`${escapeRegex(SENTINEL_BEGIN)}[\\s\\S]*?${escapeRegex(SENTINEL_END)}\\n?`, 'g');
+    const after = before.replace(re, '');
+    if (after !== before) {
+      fs.writeFileSync(indexPath, after);
+      indexPruned = true;
+    }
+  }
+  return { ok: true, fileRemoved, indexPruned, target, indexPath };
+}
+
+function formatResult(action, result) {
+  if (action === 'adopt') {
+    if (!result.ok) {
+      if (result.reason === 'no-memory-dir') {
+        return `[code-graph] Memory dir not found: ${result.dir}\n` +
+               '  Run \`claude\` at least once in this project to create it.';
+      }
+      if (result.reason === 'no-template') {
+        return `[code-graph] Template missing: ${result.template}`;
+      }
+      return `[code-graph] adopt failed: ${result.reason || 'unknown'}`;
+    }
+    const lines = [`[code-graph] Adopted → ${result.target}`];
+    if (result.indexed) lines.push(`[code-graph] Indexed → ${result.indexPath}`);
+    else lines.push(`[code-graph] Index already contains sentinel — left as-is`);
+    lines.push('[code-graph] Activate: set CODE_GRAPH_QUIET_HOOKS=1 in ~/.claude/settings.json env');
+    return lines.join('\n');
+  }
+  if (action === 'unadopt') {
+    const lines = [];
+    if (result.fileRemoved) lines.push(`[code-graph] Removed → ${result.target}`);
+    if (result.indexPruned) lines.push(`[code-graph] De-indexed → ${result.indexPath}`);
+    if (!result.fileRemoved && !result.indexPruned) lines.push('[code-graph] Nothing to unadopt');
+    return lines.join('\n');
+  }
+  return '';
+}
+
+if (require.main === module) {
+  const action = process.argv[2] === 'unadopt' ? 'unadopt' : 'adopt';
+  const result = action === 'unadopt' ? unadopt() : adopt();
+  process.stdout.write(formatResult(action, result) + '\n');
+  process.exit(result.ok === false ? 1 : 0);
+}
+
+module.exports = {
+  adopt, unadopt, memoryDir, formatResult,
+  SENTINEL_BEGIN, SENTINEL_END, INDEX_LINE, TEMPLATE_PATH, TARGET_NAME,
+};

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

@@ -0,0 +1,114 @@
+'use strict';
+const test = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const {
+  adopt, unadopt, memoryDir, SENTINEL_BEGIN, SENTINEL_END, INDEX_LINE, TEMPLATE_PATH,
+} = require('./adopt');
+
+function makeSandbox() {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-adopt-home-'));
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-adopt-cwd-'));
+  // Pre-create the memory dir (claude-mem convention — we don't create it).
+  const dir = memoryDir(cwd, home);
+  fs.mkdirSync(dir, { recursive: true });
+  return { home, cwd, dir, cleanup: () => {
+    fs.rmSync(home, { recursive: true, force: true });
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }};
+}
+
+test('memoryDir slugifies cwd path', () => {
+  const dir = memoryDir('/home/alice/proj', '/home/alice');
+  assert.strictEqual(dir, '/home/alice/.claude/projects/-home-alice-proj/memory');
+});
+
+test('adopt writes template and appends sentinel block when index absent', () => {
+  const sb = makeSandbox();
+  try {
+    const res = adopt({ cwd: sb.cwd, home: sb.home });
+    assert.strictEqual(res.ok, true);
+    assert.strictEqual(res.indexed, true);
+    assert.ok(fs.existsSync(res.target), 'plugin file written');
+    const index = fs.readFileSync(res.indexPath, 'utf8');
+    assert.match(index, /^# Memory Index/);
+    assert.ok(index.includes(SENTINEL_BEGIN));
+    assert.ok(index.includes(SENTINEL_END));
+    assert.ok(index.includes(INDEX_LINE));
+  } finally { sb.cleanup(); }
+});
+
+test('adopt is idempotent — no duplicate sentinel on re-run', () => {
+  const sb = makeSandbox();
+  try {
+    adopt({ cwd: sb.cwd, home: sb.home });
+    const res2 = adopt({ cwd: sb.cwd, home: sb.home });
+    assert.strictEqual(res2.indexed, false, 'second run leaves index alone');
+    const index = fs.readFileSync(res2.indexPath, 'utf8');
+    const matches = index.match(new RegExp(SENTINEL_BEGIN.replace(/[\\/[\]^$.*+?()|{}]/g, '\\$&'), 'g'));
+    assert.strictEqual(matches.length, 1, 'sentinel appears exactly once');
+  } finally { sb.cleanup(); }
+});
+
+test('adopt preserves existing MEMORY.md content and appends', () => {
+  const sb = makeSandbox();
+  try {
+    const indexPath = path.join(sb.dir, 'MEMORY.md');
+    fs.writeFileSync(indexPath, '# Memory Index\n\n- [foo.md](foo.md) — existing entry\n');
+    adopt({ cwd: sb.cwd, home: sb.home });
+    const index = fs.readFileSync(indexPath, 'utf8');
+    assert.ok(index.includes('existing entry'), 'preserves prior entries');
+    assert.ok(index.includes(SENTINEL_BEGIN), 'appends sentinel');
+  } finally { sb.cleanup(); }
+});
+
+test('adopt fails gracefully when memory dir missing', () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-adopt-home-'));
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-adopt-cwd-'));
+  try {
+    const res = adopt({ cwd, home });
+    assert.strictEqual(res.ok, false);
+    assert.strictEqual(res.reason, 'no-memory-dir');
+  } finally {
+    fs.rmSync(home, { recursive: true, force: true });
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('unadopt removes file and sentinel block, preserves other entries', () => {
+  const sb = makeSandbox();
+  try {
+    adopt({ cwd: sb.cwd, home: sb.home });
+    // add a neighboring entry
+    const indexPath = path.join(sb.dir, 'MEMORY.md');
+    const withNeighbor = fs.readFileSync(indexPath, 'utf8') + '- [bar.md](bar.md) — neighbor\n';
+    fs.writeFileSync(indexPath, withNeighbor);
+
+    const res = unadopt({ cwd: sb.cwd, home: sb.home });
+    assert.strictEqual(res.fileRemoved, true);
+    assert.strictEqual(res.indexPruned, true);
+    assert.ok(!fs.existsSync(res.target), 'plugin file gone');
+    const final = fs.readFileSync(indexPath, 'utf8');
+    assert.ok(!final.includes(SENTINEL_BEGIN), 'sentinel removed');
+    assert.ok(final.includes('neighbor'), 'neighbor preserved');
+  } finally { sb.cleanup(); }
+});
+
+test('unadopt is a no-op when never adopted', () => {
+  const sb = makeSandbox();
+  try {
+    const res = unadopt({ cwd: sb.cwd, home: sb.home });
+    assert.strictEqual(res.fileRemoved, false);
+    assert.strictEqual(res.indexPruned, false);
+  } finally { sb.cleanup(); }
+});
+
+test('template file exists and contains decision table', () => {
+  assert.ok(fs.existsSync(TEMPLATE_PATH), `template at ${TEMPLATE_PATH}`);
+  const content = fs.readFileSync(TEMPLATE_PATH, 'utf8');
+  assert.ok(content.includes('get_call_graph'), 'mentions get_call_graph');
+  assert.ok(content.includes('impact_analysis'), 'mentions impact_analysis');
+  assert.ok(content.includes('CODE_GRAPH_QUIET_HOOKS'), 'mentions env gate');
+});

package/claude-plugin/scripts/auto-update.js

@@ -7,6 +7,7 @@ const path = require('path');
 const os = require('os');
 const { CACHE_DIR, PLUGIN_ID, MARKETPLACE_NAME, readManifest, readJson, writeJsonAtomic } = require('./lifecycle');
 const { clearCache: clearBinaryCache } = require('./find-binary');
+const { readBinaryVersion, isDevMode } = require('./version-utils');
 
 // ── Environment Checks ────────────────────────────────────
 
@@ -32,7 +33,6 @@ const BINARY_CACHE_DIR = path.join(CACHE_DIR, 'bin');
 const CHECK_INTERVAL_MS = 6 * 60 * 60 * 1000;        // 6h
 const RATE_LIMIT_INTERVAL_MS = 24 * 60 * 60 * 1000;  // 24h if rate-limited
 const FETCH_TIMEOUT_MS = 3000;
-const VERSION_OUTPUT_RE = /^code-graph-mcp\s+(\d+\.\d+\.\d+)$/;
 
 function isSilentMode(argv = process.argv.slice(2), env = process.env) {
   return argv.includes('--silent') || env.CODE_GRAPH_AUTO_UPDATE_SILENT === '1';
@@ -65,18 +65,6 @@ function saveState(state) {
   } catch { /* ok */ }
 }
 
-// ── Dev Mode Detection ─────────────────────────────────────
-
-function isDevMode() {
-  // Always derive from __dirname — CLAUDE_PLUGIN_ROOT can leak from other plugins
-  const pluginRoot = path.resolve(__dirname, '..');
-  // Dev mode: running from source repo (has Cargo.toml nearby)
-  if (fs.existsSync(path.join(pluginRoot, '..', 'Cargo.toml'))) return true;
-  // Dev mode: plugin root is a symlink
-  try { if (fs.lstatSync(pluginRoot).isSymbolicLink()) return true; } catch { /* ok */ }
-  return false;
-}
-
 // ── Throttle ───────────────────────────────────────────────
 
 function shouldCheck(state) {
@@ -184,19 +172,6 @@ function getExtractedPluginVersion(pluginSrc) {
   return manifest && typeof manifest.version === 'string' ? manifest.version : null;
 }
 
-function readBinaryVersion(binaryPath) {
-  try {
-    const out = execFileSync(binaryPath, ['--version'], {
-      timeout: 2000,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    }).toString().trim();
-    const match = out.match(VERSION_OUTPUT_RE);
-    return match ? match[1] : null;
-  } catch {
-    return null;
-  }
-}
-
 function promoteVerifiedBinary(binaryTmp, binaryDst, expectedVersion) {
   try {
     const stat = fs.statSync(binaryTmp);