@sdsrs/code-graph 0.58.0 → 0.60.0

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

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

package/claude-plugin/scripts/adopt.js

@@ -24,6 +24,23 @@ function readAdoptedBy(filePath) {
     return m ? m[1] : null;
   } catch { return null; }
 }
+// Atomic write (tmp in same dir → rename) so a crash mid-write can't leave a
+// half-written MEMORY.md / detail file — the dir is shared with claude-mem-lite,
+// which reads MEMORY.md on every keyword match. Mirrors lifecycle.js
+// writeJsonAtomic / auto-update.js binary promote; accepts a string or Buffer.
+function writeFileAtomic(filePath, data) {
+  const tmp = filePath + '.tmp.' + process.pid;
+  fs.writeFileSync(tmp, data);
+  try {
+    fs.renameSync(tmp, filePath);
+  } catch (e) {
+    // rename can fail (ENOSPC / EACCES / EROFS on the dir). Don't orphan the
+    // temp in the shared memory dir — mirror auto-update.js's binary promote,
+    // which cleans its tmp on failure. Best-effort unlink, then rethrow original.
+    try { fs.unlinkSync(tmp); } catch { /* already gone */ }
+    throw e;
+  }
+}
 // One-liner per MEMORY.md spec ("each entry should be one line"). All routing
 // triggers from prior multi-line block preserved verbatim — collapsing to single
 // line is a structural fix, not a signal change. Decision table lives in the
@@ -354,7 +371,7 @@ function adopt({ cwd, home, templatePath } = {}) {
   // ADOPTED_BY_RE strip below).
   const tplBody = fs.readFileSync(tpl);
   const marker = Buffer.from(`<!-- adopted-by: ${effectiveCwd} -->\n`);
-  fs.writeFileSync(target, Buffer.concat([marker, tplBody]));
+  writeFileAtomic(target, Buffer.concat([marker, tplBody]));
 
   const indexPath = path.join(dir, 'MEMORY.md');
   const index = fs.existsSync(indexPath) ? fs.readFileSync(indexPath, 'utf8') : '# Memory Index\n';
@@ -372,7 +389,7 @@ function adopt({ cwd, home, templatePath } = {}) {
   const cleaned = stripSentinelBlock(index);
   const healed = cleaned !== index;
   const base = cleaned.endsWith('\n') ? cleaned : cleaned + '\n';
-  fs.writeFileSync(indexPath, base + desiredBlock + '\n');
+  writeFileAtomic(indexPath, base + desiredBlock + '\n');
   return { ok: true, target, indexPath, indexed: true, healed, collisionWith };
 }
 
@@ -479,7 +496,7 @@ function unadopt({ cwd, home } = {}) {
     const before = fs.readFileSync(indexPath, 'utf8');
     const after = stripSentinelBlock(before);
     if (after !== before) {
-      fs.writeFileSync(indexPath, after);
+      writeFileAtomic(indexPath, after);
       indexPruned = true;
     }
   }

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

@@ -90,6 +90,39 @@ test('adopt preserves existing MEMORY.md content and appends', () => {
   } finally { sb.cleanup(); }
 });
 
+test('adopt + unadopt write atomically — no .tmp residue in the memory dir', () => {
+  // The memory dir is shared with claude-mem-lite, which reads MEMORY.md on
+  // every keyword match; a non-atomic write crashing mid-flight would corrupt
+  // it. adopt/unadopt now go through writeFileAtomic (tmp + rename). Proof the
+  // rename completed cleanly across all three write sites (detail file + adopt
+  // index + unadopt prune): no leftover `*.tmp.<pid>` entries.
+  const sb = makeSandbox();
+  try {
+    adopt({ cwd: sb.cwd, home: sb.home });
+    unadopt({ cwd: sb.cwd, home: sb.home });
+    const residue = fs.readdirSync(sb.dir).filter((f) => f.includes('.tmp.'));
+    assert.deepStrictEqual(residue, [], `no atomic-write tmp residue; found: ${residue}`);
+  } finally { sb.cleanup(); }
+});
+
+test('writeFileAtomic cleans its temp file when rename fails (no orphaned .tmp)', () => {
+  // The success path leaves no residue (above). This pins the FAILURE path: if
+  // renameSync throws (ENOSPC/EACCES/EROFS on the shared memory dir) the temp must
+  // be unlinked, not orphaned. Force every rename to fail and assert no `.tmp.<pid>`
+  // survives the (failed) adopt.
+  const sb = makeSandbox();
+  const realRename = fs.renameSync;
+  try {
+    fs.renameSync = () => { const e = new Error('EROFS: simulated read-only fs'); e.code = 'EROFS'; throw e; };
+    try { adopt({ cwd: sb.cwd, home: sb.home }); } catch { /* expected — rename failed */ }
+    const residue = fs.readdirSync(sb.dir).filter((f) => f.includes('.tmp.'));
+    assert.deepStrictEqual(residue, [], `failed rename must not orphan a temp; found: ${residue}`);
+  } finally {
+    fs.renameSync = realRename;
+    sb.cleanup();
+  }
+});
+
 test('adopt refuses a non-project cwd even when the memory dir already exists (regression: /tmp adoption)', () => {
   // Bug: the isProjectRoot guard was nested inside `if (!fs.existsSync(dir))`,
   // so when Claude Code had already created ~/.claude/projects/<slug>/memory

package/package.json

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