@sdsrs/code-graph 0.8.0 → 0.8.2

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

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

package/claude-plugin/scripts/adopt.js

@@ -13,8 +13,11 @@ const INDEX_LINE = '- [code-graph-mcp](plugin_code_graph_mcp.md) — "谁调 X /
 const TEMPLATE_PATH = path.resolve(__dirname, '..', 'templates', 'plugin_code_graph_mcp.md');
 const TARGET_NAME = 'plugin_code_graph_mcp.md';
 
+// Claude Code slug convention: every non-alphanumeric-non-hyphen char → `-`.
+// `/mnt/data_ssd/dev/proj` → `-mnt-data-ssd-dev-proj`
+// `/home/sds/.claude/x`   → `-home-sds--claude-x`  (double-dash from `/.`)
 function memoryDir(cwd = process.cwd(), home = os.homedir()) {
-  const slug = cwd.replace(/\//g, '-');
+  const slug = cwd.replace(/[^a-zA-Z0-9-]/g, '-');
   return path.join(home, '.claude', 'projects', slug, 'memory');
 }
 
@@ -22,7 +25,41 @@ function escapeRegex(s) {
   return s.replace(/[\\/[\]^$.*+?()|{}]/g, '\\$&');
 }
 
+// Strip our sentinel block — well-formed first, then self-heal orphan begin/end.
+// Shared by adopt (so re-adopt rewrites a stale/malformed block) and unadopt.
+function stripSentinelBlock(text) {
+  const wellFormed = new RegExp(
+    `${escapeRegex(SENTINEL_BEGIN)}[\\s\\S]*?${escapeRegex(SENTINEL_END)}\\n?`, 'g'
+  );
+  let out = text.replace(wellFormed, '');
+  // Orphan BEGIN with no matching END (truncation / partial edit).
+  // Strip from BEGIN to the next blank line or EOF — the file is shared with
+  // claude-mem-lite, so we must not eat past a blank-line boundary.
+  if (out.includes(SENTINEL_BEGIN)) {
+    out = out.replace(
+      new RegExp(`${escapeRegex(SENTINEL_BEGIN)}[\\s\\S]*?(?=\\n\\n|$)`, 'g'),
+      ''
+    );
+  }
+  // Orphan END line by itself.
+  if (out.includes(SENTINEL_END)) {
+    out = out.split('\n').filter(l => l.trim() !== SENTINEL_END).join('\n');
+  }
+  // Collapse blank-line runs introduced by stripping mid-paragraph blocks.
+  return out.replace(/\n{3,}/g, '\n\n');
+}
+
+function platformGuard() {
+  if (process.platform === 'win32') {
+    return { ok: false, reason: 'windows-not-supported' };
+  }
+  return null;
+}
+
 function adopt({ cwd, home, templatePath } = {}) {
+  const blocked = platformGuard();
+  if (blocked) return blocked;
+
   const dir = memoryDir(cwd, home);
   if (!fs.existsSync(dir)) {
     return { ok: false, reason: 'no-memory-dir', dir };
@@ -35,18 +72,25 @@ function adopt({ cwd, home, templatePath } = {}) {
   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;
+  const index = fs.existsSync(indexPath) ? fs.readFileSync(indexPath, 'utf8') : '# Memory Index\n';
+  const desiredBlock = `${SENTINEL_BEGIN}\n${INDEX_LINE}\n${SENTINEL_END}`;
+
+  // Already-adopted-and-well-formed: skip the write entirely.
+  if (index.includes(desiredBlock)) {
+    return { ok: true, target, indexPath, indexed: false, healed: false };
   }
-  return { ok: true, target, indexPath, indexed };
+
+  const cleaned = stripSentinelBlock(index);
+  const healed = cleaned !== index;
+  const base = cleaned.endsWith('\n') ? cleaned : cleaned + '\n';
+  fs.writeFileSync(indexPath, base + desiredBlock + '\n');
+  return { ok: true, target, indexPath, indexed: true, healed };
 }
 
 function unadopt({ cwd, home } = {}) {
+  const blocked = platformGuard();
+  if (blocked) return blocked;
+
   const dir = memoryDir(cwd, home);
   const target = path.join(dir, TARGET_NAME);
   const indexPath = path.join(dir, 'MEMORY.md');
@@ -59,8 +103,7 @@ function unadopt({ cwd, home } = {}) {
   }
   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, '');
+    const after = stripSentinelBlock(before);
     if (after !== before) {
       fs.writeFileSync(indexPath, after);
       indexPruned = true;
@@ -70,6 +113,10 @@ function unadopt({ cwd, home } = {}) {
 }
 
 function formatResult(action, result) {
+  if (!result.ok && result.reason === 'windows-not-supported') {
+    return '[code-graph] adopt/unadopt are POSIX-only — claude-mem-lite slug ' +
+           'convention on Windows is unverified. Edit MEMORY.md manually to opt in.';
+  }
   if (action === 'adopt') {
     if (!result.ok) {
       if (result.reason === 'no-memory-dir') {
@@ -82,8 +129,9 @@ function formatResult(action, result) {
       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`);
+    if (result.healed) lines.push(`[code-graph] Healed malformed sentinel block → ${result.indexPath}`);
+    else if (result.indexed) lines.push(`[code-graph] Indexed → ${result.indexPath}`);
+    else lines.push(`[code-graph] Index already up-to-date — no write`);
     lines.push('[code-graph] Activate: set CODE_GRAPH_QUIET_HOOKS=1 in ~/.claude/settings.json env');
     return lines.join('\n');
   }
@@ -105,6 +153,6 @@ if (require.main === module) {
 }
 
 module.exports = {
-  adopt, unadopt, memoryDir, formatResult,
+  adopt, unadopt, memoryDir, formatResult, stripSentinelBlock,
   SENTINEL_BEGIN, SENTINEL_END, INDEX_LINE, TEMPLATE_PATH, TARGET_NAME,
 };

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

@@ -5,7 +5,8 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const {
-  adopt, unadopt, memoryDir, SENTINEL_BEGIN, SENTINEL_END, INDEX_LINE, TEMPLATE_PATH,
+  adopt, unadopt, memoryDir, stripSentinelBlock,
+  SENTINEL_BEGIN, SENTINEL_END, INDEX_LINE, TEMPLATE_PATH,
 } = require('./adopt');
 
 function makeSandbox() {
@@ -25,6 +26,24 @@ test('memoryDir slugifies cwd path', () => {
   assert.strictEqual(dir, '/home/alice/.claude/projects/-home-alice-proj/memory');
 });
 
+test('memoryDir replaces underscores and dots (Claude Code slug convention)', () => {
+  // Real-world bug: /mnt/data_ssd/... needs data-ssd slug, not data_ssd
+  assert.strictEqual(
+    memoryDir('/mnt/data_ssd/dev/projects/code-graph-mcp', '/home/u'),
+    '/home/u/.claude/projects/-mnt-data-ssd-dev-projects-code-graph-mcp/memory'
+  );
+  // Hidden dirs: /home/sds/.claude/x → -home-sds--claude-x (double-dash)
+  assert.strictEqual(
+    memoryDir('/home/sds/.claude/x', '/home/sds'),
+    '/home/sds/.claude/projects/-home-sds--claude-x/memory'
+  );
+  // Preserves case and hyphens
+  assert.strictEqual(
+    memoryDir('/Users/Alice/my-Project_v2.1', '/'),
+    '/.claude/projects/-Users-Alice-my-Project-v2-1/memory'
+  );
+});
+
 test('adopt writes template and appends sentinel block when index absent', () => {
   const sb = makeSandbox();
   try {
@@ -112,3 +131,102 @@ test('template file exists and contains decision table', () => {
   assert.ok(content.includes('impact_analysis'), 'mentions impact_analysis');
   assert.ok(content.includes('CODE_GRAPH_QUIET_HOOKS'), 'mentions env gate');
 });
+
+test('stripSentinelBlock removes well-formed block', () => {
+  const before = `# Index\n${SENTINEL_BEGIN}\n${INDEX_LINE}\n${SENTINEL_END}\n- [x.md](x.md)\n`;
+  const after = stripSentinelBlock(before);
+  assert.ok(!after.includes(SENTINEL_BEGIN));
+  assert.ok(!after.includes(SENTINEL_END));
+  assert.ok(after.includes('- [x.md](x.md)'), 'preserves neighbors');
+});
+
+test('stripSentinelBlock self-heals orphan BEGIN without END', () => {
+  // Truncation / partial edit scenario
+  const before = `# Index\n- [a.md](a.md) — entry\n${SENTINEL_BEGIN}\n${INDEX_LINE}\n\n- [b.md](b.md) — survivor\n`;
+  const after = stripSentinelBlock(before);
+  assert.ok(!after.includes(SENTINEL_BEGIN), 'orphan BEGIN removed');
+  assert.ok(after.includes('survivor'), 'content past blank-line boundary preserved');
+  assert.ok(after.includes('entry'), 'content before BEGIN preserved');
+});
+
+test('stripSentinelBlock self-heals orphan END line', () => {
+  const before = `# Index\n- [a.md](a.md)\n${SENTINEL_END}\n- [b.md](b.md)\n`;
+  const after = stripSentinelBlock(before);
+  assert.ok(!after.includes(SENTINEL_END));
+  assert.ok(after.includes('- [a.md](a.md)') && after.includes('- [b.md](b.md)'));
+});
+
+test('adopt heals malformed sentinel (orphan BEGIN) on re-run', () => {
+  const sb = makeSandbox();
+  try {
+    const indexPath = path.join(sb.dir, 'MEMORY.md');
+    // Simulate truncated prior adopt — BEGIN line + stale entry, no END
+    fs.writeFileSync(
+      indexPath,
+      `# Memory Index\n- [old.md](old.md) — preserved\n${SENTINEL_BEGIN}\n- [stale](stale.md) — wrong entry\n\n- [neighbor.md](neighbor.md) — survives\n`
+    );
+    const res = adopt({ cwd: sb.cwd, home: sb.home });
+    assert.strictEqual(res.ok, true);
+    assert.strictEqual(res.healed, true, 'reports healed');
+    const final = fs.readFileSync(indexPath, 'utf8');
+    // Exactly one well-formed block now
+    const beginCount = (final.match(new RegExp(SENTINEL_BEGIN.replace(/[\\/[\]^$.*+?()|{}]/g, '\\$&'), 'g')) || []).length;
+    const endCount = (final.match(new RegExp(SENTINEL_END.replace(/[\\/[\]^$.*+?()|{}]/g, '\\$&'), 'g')) || []).length;
+    assert.strictEqual(beginCount, 1, 'one BEGIN');
+    assert.strictEqual(endCount, 1, 'one END');
+    assert.ok(final.includes('preserved'), 'preserves pre-BEGIN content');
+    assert.ok(final.includes('neighbor.md'), 'preserves post-malformed-block content');
+    assert.ok(!final.includes('stale.md'), 'old wrong entry purged');
+    assert.ok(final.includes(INDEX_LINE), 'fresh canonical line written');
+  } finally { sb.cleanup(); }
+});
+
+test('adopt is a true no-op when desired block is already present verbatim', () => {
+  const sb = makeSandbox();
+  try {
+    adopt({ cwd: sb.cwd, home: sb.home });
+    const indexPath = path.join(sb.dir, 'MEMORY.md');
+    const before = fs.readFileSync(indexPath, 'utf8');
+    const beforeMtime = fs.statSync(indexPath).mtimeMs;
+    const res2 = adopt({ cwd: sb.cwd, home: sb.home });
+    assert.strictEqual(res2.indexed, false);
+    assert.strictEqual(res2.healed, false);
+    assert.strictEqual(fs.readFileSync(indexPath, 'utf8'), before, 'file content identical');
+    // mtime may equal beforeMtime since we skipped the write
+    assert.strictEqual(fs.statSync(indexPath).mtimeMs, beforeMtime, 'no write occurred');
+  } finally { sb.cleanup(); }
+});
+
+test('unadopt heals malformed sentinel (orphan BEGIN)', () => {
+  const sb = makeSandbox();
+  try {
+    const indexPath = path.join(sb.dir, 'MEMORY.md');
+    fs.writeFileSync(
+      indexPath,
+      `# Index\n${SENTINEL_BEGIN}\n${INDEX_LINE}\n\n- [keep.md](keep.md) — survives\n`
+    );
+    const res = unadopt({ cwd: sb.cwd, home: sb.home });
+    assert.strictEqual(res.indexPruned, true);
+    const final = fs.readFileSync(indexPath, 'utf8');
+    assert.ok(!final.includes(SENTINEL_BEGIN), 'orphan BEGIN purged');
+    assert.ok(final.includes('keep.md'), 'content past blank-line preserved');
+  } finally { sb.cleanup(); }
+});
+
+test('Windows platform is rejected with clear reason', { skip: process.platform === 'win32' }, () => {
+  const orig = process.platform;
+  Object.defineProperty(process, 'platform', { value: 'win32', configurable: true });
+  try {
+    const sb = makeSandbox();
+    try {
+      const adoptRes = adopt({ cwd: sb.cwd, home: sb.home });
+      assert.strictEqual(adoptRes.ok, false);
+      assert.strictEqual(adoptRes.reason, 'windows-not-supported');
+      const unadoptRes = unadopt({ cwd: sb.cwd, home: sb.home });
+      assert.strictEqual(unadoptRes.ok, false);
+      assert.strictEqual(unadoptRes.reason, 'windows-not-supported');
+    } finally { sb.cleanup(); }
+  } finally {
+    Object.defineProperty(process, 'platform', { value: orig, configurable: true });
+  }
+});

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

@@ -465,16 +465,17 @@ test('skills: only expected skills exist', () => {
   assert.deepEqual(files, ['explore.md', 'index.md']);
 });
 
-test('CODE_GRAPH_QUIET_HOOKS=1 short-circuits before reading stdin', () => {
-  const { execFileSync } = require('node:child_process');
+test('CODE_GRAPH_QUIET_HOOKS=1 short-circuits silently on stdout, stderr, exit 0', () => {
+  const { spawnSync } = require('node:child_process');
   const script = path.join(__dirname, 'user-prompt-context.js');
-  const out = execFileSync(process.execPath, [script], {
+  const proc = spawnSync(process.execPath, [script], {
     input: JSON.stringify({ message: 'impact analysis for fn_that_would_trigger_search' }),
     env: { ...process.env, CODE_GRAPH_QUIET_HOOKS: '1' },
     encoding: 'utf8',
-    stdio: ['pipe', 'pipe', 'pipe'],
     timeout: 2000,
   });
-  // Quiet mode must produce no stdout — no [code-graph:*] prefix, nothing.
-  assert.equal(out, '');
+  // Quiet mode must be fully silent — any stderr leaks into Claude's display.
+  assert.equal(proc.stdout, '', 'stdout must be empty');
+  assert.equal(proc.stderr, '', 'stderr must be empty');
+  assert.equal(proc.status, 0, 'must exit 0');
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdsrs/code-graph",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "MCP server that indexes codebases into an AST knowledge graph with semantic search, call graph traversal, and HTTP route tracing",
   "license": "MIT",
   "repository": {
@@ -34,10 +34,10 @@
     "node": ">=16"
   },
   "optionalDependencies": {
-    "@sdsrs/code-graph-linux-x64": "0.8.0",
-    "@sdsrs/code-graph-linux-arm64": "0.8.0",
-    "@sdsrs/code-graph-darwin-x64": "0.8.0",
-    "@sdsrs/code-graph-darwin-arm64": "0.8.0",
-    "@sdsrs/code-graph-win32-x64": "0.8.0"
+    "@sdsrs/code-graph-linux-x64": "0.8.2",
+    "@sdsrs/code-graph-linux-arm64": "0.8.2",
+    "@sdsrs/code-graph-darwin-x64": "0.8.2",
+    "@sdsrs/code-graph-darwin-arm64": "0.8.2",
+    "@sdsrs/code-graph-win32-x64": "0.8.2"
   }
 }