@misterhuydo/cairn-mcp 1.7.5 → 1.8.1

package/bin/cairn-cli.js

@@ -14,91 +14,148 @@ const MINIFY_LANGS = new Set(['java', 'typescript', 'javascript', 'vue', 'python
 
 // Memory sync scripts deployed to ~/.claude/scripts/ during global install.
 // Using forward slashes in hook commands — bash on Windows handles them fine.
-const SYNC_FORWARD_SCRIPT = `\
-"""
-Forward sync: Claude Code auto-memory -> .cairn/memory/auto-memory/
-Triggered as a PostToolUse hook on Write.
-Only fires when the written file is inside Claude's projects memory dir
-and the current project has a .cairn/ folder.
-"""
-import sys, json, os, shutil
-
-data = json.load(sys.stdin)
-fp = data.get('tool_input', {}).get('file_path', '')
-
-user_home = os.path.expanduser('~')
-claude_projects = os.path.normpath(os.path.join(user_home, '.claude', 'projects'))
-
-fp_norm = os.path.normpath(fp)
-if not fp_norm.startswith(claude_projects) or 'memory' not in fp_norm:
-    sys.exit(0)
-
-cwd = os.getcwd()
-if not os.path.exists(os.path.join(cwd, '.cairn')):
-    sys.exit(0)
-
-memory_dir = os.path.dirname(fp_norm)
-dest = os.path.join(cwd, '.cairn', 'memory', 'auto-memory')
-os.makedirs(dest, exist_ok=True)
-
-for f in os.listdir(memory_dir):
-    src = os.path.join(memory_dir, f)
-    if os.path.isfile(src):
-        shutil.copy2(src, dest)
+const SYNC_FORWARD_SCRIPT = `#!/usr/bin/env node
+// Forward sync: Claude Code auto-memory -> .cairn/memory/auto-memory/
+// Triggered as a PostToolUse hook on Write.
+// Only fires when the written file is inside Claude's projects memory dir
+// and the current project has a .cairn/ folder.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+let stdinData = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', c => { stdinData += c; });
+process.stdin.on('end', () => {
+  let fp;
+  try { fp = JSON.parse(stdinData)?.tool_input?.file_path || ''; } catch { process.exit(0); }
+  if (!fp) process.exit(0);
+
+  const claudeProjects = path.normalize(path.join(os.homedir(), '.claude', 'projects'));
+  const fpNorm = path.normalize(fp);
+  if (!fpNorm.startsWith(claudeProjects) || !fpNorm.includes('memory')) process.exit(0);
+
+  const cwd = process.cwd();
+  if (!fs.existsSync(path.join(cwd, '.cairn'))) process.exit(0);
+
+  const memoryDir = path.dirname(fpNorm);
+  const cairnMemory = path.join(cwd, '.cairn', 'memory');
+  const dest = path.join(cairnMemory, 'auto-memory');
+  fs.mkdirSync(dest, { recursive: true });
+
+  for (const f of fs.readdirSync(memoryDir)) {
+    // Skip files that exist in canonical top-level — those are mirrored from cairn_memo,
+    // not out-of-band auto-memory writes, so backing them up would duplicate canonical content.
+    if (fs.existsSync(path.join(cairnMemory, f))) continue;
+    const src = path.join(memoryDir, f);
+    let st;
+    try { st = fs.statSync(src); } catch { continue; }
+    if (!st.isFile()) continue;
+    const dst = path.join(dest, f);
+    fs.copyFileSync(src, dst);
+    try { fs.utimesSync(dst, st.atime, st.mtime); } catch {}
+  }
+});
 `;
 
-const SYNC_RESTORE_SCRIPT = `\
-"""
-Restore sync: .cairn/memory/ -> Claude Code memory dir for current location.
-Triggered as a UserPromptSubmit hook on each new session prompt.
-Two passes:
-  1. New-machine restore: copy .cairn/memory/auto-memory/ -> Claude memory dir
-     (only when target is empty/missing, preserves Claude-native memory on new drive)
-  2. Always: sync .cairn/memory/ (top-level files only) -> Claude memory dir
-     using mtime comparison so cairn_memo writes are always reflected.
-Path encoding: H:\\\\Projects\\\\Cairn -> H--Projects-Cairn
-  (both ':' and '\\\\' map to '-', so ':' + '\\\\' = '--')
-"""
-import sys, os, shutil
-
-cwd = os.getcwd()
-cairn_memory = os.path.join(cwd, '.cairn', 'memory')
-
-if not os.path.exists(cairn_memory):
-    sys.exit(0)
-
-encoded = cwd.replace(':', '-').replace('\\\\', '-').replace('/', '-').lstrip('-')
-user_home = os.path.expanduser('~')
-memory_dir = os.path.join(user_home, '.claude', 'projects', encoded, 'memory')
-os.makedirs(memory_dir, exist_ok=True)
-
-# Pass 1: new-machine restore from auto-memory backup
-cairn_auto_memory = os.path.join(cairn_memory, 'auto-memory')
-if os.path.exists(cairn_auto_memory):
-    target_empty = not any(f.endswith('.md') for f in os.listdir(memory_dir))
-    if target_empty:
-        restored = 0
-        for f in os.listdir(cairn_auto_memory):
-            src = os.path.join(cairn_auto_memory, f)
-            if os.path.isfile(src):
-                shutil.copy2(src, memory_dir)
-                restored += 1
-        if restored > 0:
-            print(f"[cairn] Restored {restored} memory files from .cairn/memory/auto-memory/ (new project location detected)")
-
-# Pass 2: always sync top-level .cairn/memory/ files (cairn_memo writes) -> Claude memory dir
-synced = 0
-for f in os.listdir(cairn_memory):
-    src = os.path.join(cairn_memory, f)
-    if not os.path.isfile(src):
-        continue  # skip subdirs like auto-memory/
-    dst = os.path.join(memory_dir, f)
-    if not os.path.exists(dst) or os.path.getmtime(src) > os.path.getmtime(dst):
-        shutil.copy2(src, dst)
-        synced += 1
-
-if synced > 0:
-    print(f"[cairn] Synced {synced} memory file(s) from .cairn/memory/ to Claude memory dir")
+const SYNC_RESTORE_SCRIPT = `#!/usr/bin/env node
+// Restore sync: .cairn/memory/ -> Claude Code memory dir for current location.
+// Triggered as a UserPromptSubmit hook on each new session prompt.
+// Three passes:
+//   0. Bootstrap: capture any auto-memory files newer/missing in .cairn/memory/auto-memory/
+//      (catches files pre-dating the forward-sync hook install).
+//   1. New-machine restore: copy .cairn/memory/auto-memory/ -> Claude memory dir
+//      (only when target is empty, preserves Claude-native memory on new drive)
+//   2. Always: mtime-mirror .cairn/memory/*.md -> Claude memory dir
+//      (so cairn_memo writes are reflected)
+// Path encoding: H:\\Projects\\Cairn -> H--Projects-Cairn
+//   (':', '\\', '/' all map to '-')
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const cwd = process.cwd();
+const cairnMemory = path.join(cwd, '.cairn', 'memory');
+if (!fs.existsSync(cairnMemory)) process.exit(0);
+
+const encoded = cwd.replace(/[:/\\\\]/g, '-').replace(/^-+/, '');
+const memoryDir = path.join(os.homedir(), '.claude', 'projects', encoded, 'memory');
+fs.mkdirSync(memoryDir, { recursive: true });
+
+const cairnAutoMemory = path.join(cairnMemory, 'auto-memory');
+
+function copyWithMtime(src, dst, srcStat) {
+  fs.copyFileSync(src, dst);
+  try { fs.utimesSync(dst, srcStat.atime, srcStat.mtime); } catch {}
+}
+
+// Pass 0: bootstrap — capture auto-memory files missing/newer in .cairn/memory/auto-memory/
+// (catches files that pre-date the forward-sync hook install)
+// Skip files present in canonical top-level: they are mirrored from cairn_memo, not auto-memory.
+const claudeFiles = fs.readdirSync(memoryDir);
+let bootstrapped = 0;
+if (claudeFiles.length > 0) {
+  fs.mkdirSync(cairnAutoMemory, { recursive: true });
+  for (const f of claudeFiles) {
+    if (fs.existsSync(path.join(cairnMemory, f))) continue;
+    const src = path.join(memoryDir, f);
+    let srcStat;
+    try { srcStat = fs.statSync(src); } catch { continue; }
+    if (!srcStat.isFile()) continue;
+    const dst = path.join(cairnAutoMemory, f);
+    let needCopy = !fs.existsSync(dst);
+    if (!needCopy) {
+      try { needCopy = srcStat.mtimeMs > fs.statSync(dst).mtimeMs; } catch { needCopy = true; }
+    }
+    if (needCopy) {
+      copyWithMtime(src, dst, srcStat);
+      bootstrapped++;
+    }
+  }
+}
+if (bootstrapped > 0) {
+  process.stdout.write(\`[cairn] Bootstrapped \${bootstrapped} auto-memory file(s) into .cairn/memory/auto-memory/\\n\`);
+}
+
+// Pass 1: new-machine restore from auto-memory backup (only when target empty)
+if (fs.existsSync(cairnAutoMemory)) {
+  const targetEmpty = !fs.readdirSync(memoryDir).some(f => f.endsWith('.md'));
+  if (targetEmpty) {
+    let restored = 0;
+    for (const f of fs.readdirSync(cairnAutoMemory)) {
+      const src = path.join(cairnAutoMemory, f);
+      let srcStat;
+      try { srcStat = fs.statSync(src); } catch { continue; }
+      if (!srcStat.isFile()) continue;
+      copyWithMtime(src, path.join(memoryDir, f), srcStat);
+      restored++;
+    }
+    if (restored > 0) {
+      process.stdout.write(\`[cairn] Restored \${restored} memory files from .cairn/memory/auto-memory/ (new project location detected)\\n\`);
+    }
+  }
+}
+
+// Pass 2: mtime-mirror top-level .cairn/memory/*.md -> Claude memory dir
+let synced = 0;
+for (const f of fs.readdirSync(cairnMemory)) {
+  const src = path.join(cairnMemory, f);
+  let srcStat;
+  try { srcStat = fs.statSync(src); } catch { continue; }
+  if (!srcStat.isFile()) continue;  // skip subdirs like auto-memory/
+  const dst = path.join(memoryDir, f);
+  let needCopy = !fs.existsSync(dst);
+  if (!needCopy) {
+    try { needCopy = srcStat.mtimeMs > fs.statSync(dst).mtimeMs; } catch { needCopy = true; }
+  }
+  if (needCopy) {
+    copyWithMtime(src, dst, srcStat);
+    synced++;
+  }
+}
+if (synced > 0) {
+  process.stdout.write(\`[cairn] Synced \${synced} memory file(s) from .cairn/memory/ to Claude memory dir\\n\`);
+}
 `;
 
 process.on('uncaughtException', (e) => {
@@ -509,10 +566,10 @@ if (subcommand === '--version' || subcommand === '-v') {
   console.log('  PreToolUse[Read]     -> cairn minify                   (compress source files for reading)');
   console.log('  PreToolUse[Edit]     -> cairn edit-guard               (block Edit until re-read with full content)')
   console.log('  PreToolUse[Write]    -> cairn edit-guard               (clear minify state before full file overwrite)');
-  console.log('  PostToolUse[Write]   -> sync-memory-forward.py         (sync ~/.claude/memory -> .cairn/memory/auto-memory/)');
+  console.log('  PostToolUse[Write]   -> sync-memory-forward.mjs        (sync ~/.claude/memory -> .cairn/memory/auto-memory/)');
   console.log('  Stop                 -> cairn checkpoint --auto         (auto-save session)');
   console.log('  UserPromptSubmit     -> cairn resume-hint               (remind Claude of prior session)');
-  console.log('  UserPromptSubmit     -> sync-memory-restore.py          (sync .cairn/memory/ -> ~/.claude/memory, mtime-based)');
+  console.log('  UserPromptSubmit     -> sync-memory-restore.mjs         (sync .cairn/memory/ -> ~/.claude/memory, mtime-based)');
   console.log('');
   console.log('Restart Claude Code to activate the MCP server, then open any project and start working.');
   console.log('Upgrade any time with: npm install -g @misterhuydo/cairn-mcp');
@@ -532,12 +589,12 @@ if (subcommand === '--version' || subcommand === '-v') {
   console.log('  PreToolUse[Edit]     -> cairn edit-guard               (block Edit until re-read with full content)')
   console.log('  PreToolUse[Write]    -> cairn edit-guard               (clear minify state before full file overwrite)');
   if (isGlobal) {
-    console.log('  PostToolUse[Write]   -> sync-memory-forward.py         (sync ~/.claude/memory -> .cairn/memory/auto-memory/)');
+    console.log('  PostToolUse[Write]   -> sync-memory-forward.mjs        (sync ~/.claude/memory -> .cairn/memory/auto-memory/)');
   }
   console.log('  Stop                 -> cairn checkpoint --auto         (auto-save session)');
   console.log('  UserPromptSubmit     -> cairn resume-hint               (remind Claude of prior session)');
   if (isGlobal) {
-    console.log('  UserPromptSubmit     -> sync-memory-restore.py          (sync .cairn/memory/ -> ~/.claude/memory, mtime-based)');
+    console.log('  UserPromptSubmit     -> sync-memory-restore.mjs         (sync .cairn/memory/ -> ~/.claude/memory, mtime-based)');
   }
   process.exit(0);
 
@@ -579,32 +636,50 @@ function applyHooks(settingsDir, isGlobal) {
   }
 
   // UserPromptSubmit: cairn resume-hint
-  const submitHooks = settings.hooks.UserPromptSubmit || [];
+  let submitHooks = settings.hooks.UserPromptSubmit || [];
   if (!submitHooks.some(h => h.hooks?.some(hh => hh.command === 'cairn resume-hint'))) {
     submitHooks.push({ hooks: [{ type: 'command', command: 'cairn resume-hint' }] });
   }
 
   if (isGlobal) {
-    // Deploy memory sync scripts to ~/.claude/scripts/
+    // Deploy memory sync scripts to ~/.claude/scripts/ (Node — cross-platform, no python3 required)
     const scriptsDir = path.join(settingsDir, 'scripts');
     fs.mkdirSync(scriptsDir, { recursive: true });
-    const forwardScript = path.join(scriptsDir, 'sync-memory-forward.py');
-    const restoreScript = path.join(scriptsDir, 'sync-memory-restore.py');
+    const forwardScript = path.join(scriptsDir, 'sync-memory-forward.mjs');
+    const restoreScript = path.join(scriptsDir, 'sync-memory-restore.mjs');
     fs.writeFileSync(forwardScript, SYNC_FORWARD_SCRIPT, 'utf8');
     fs.writeFileSync(restoreScript, SYNC_RESTORE_SCRIPT, 'utf8');
 
+    // Clean up legacy Python scripts from prior installs
+    for (const legacy of ['sync-memory-forward.py', 'sync-memory-restore.py']) {
+      const p = path.join(scriptsDir, legacy);
+      if (fs.existsSync(p)) { try { fs.unlinkSync(p); } catch {} }
+    }
+
     // Use forward slashes in hook commands — works across bash on Windows and Unix
-    const fwdCmd = `python3 "${scriptsDir.replace(/\\/g, '/')}/sync-memory-forward.py"`;
-    const rstCmd = `python3 "${scriptsDir.replace(/\\/g, '/')}/sync-memory-restore.py"`;
+    const scriptsDirFwd = scriptsDir.replace(/\\/g, '/');
+    const fwdCmd = `node "${scriptsDirFwd}/sync-memory-forward.mjs"`;
+    const rstCmd = `node "${scriptsDirFwd}/sync-memory-restore.mjs"`;
+
+    // Strip stale python3 .py references from prior installs (avoids duplicate hooks firing)
+    const isLegacyPyCmd = (cmd) => typeof cmd === 'string' &&
+      /python3?\s+.*sync-memory-(forward|restore)\.py/.test(cmd);
+    const stripLegacy = (entries) => entries
+      .map(entry => ({
+        ...entry,
+        hooks: (entry.hooks || []).filter(h => !isLegacyPyCmd(h.command)),
+      }))
+      .filter(entry => entry.hooks.length > 0);
 
     // PostToolUse[Write]: forward sync Claude memory -> .cairn/memory/auto-memory/
-    const postHooks = settings.hooks.PostToolUse || [];
+    let postHooks = stripLegacy(settings.hooks.PostToolUse || []);
     if (!postHooks.some(h => h.matcher === 'Write' && h.hooks?.some(hh => hh.command === fwdCmd))) {
       postHooks.push({ matcher: 'Write', hooks: [{ type: 'command', command: fwdCmd }] });
     }
     settings.hooks.PostToolUse = postHooks;
 
     // UserPromptSubmit: sync .cairn/memory/ -> Claude memory dir (always, mtime-based)
+    submitHooks = stripLegacy(submitHooks);
     if (!submitHooks.some(h => h.hooks?.some(hh => hh.command === rstCmd))) {
       submitHooks.push({ hooks: [{ type: 'command', command: rstCmd }] });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@misterhuydo/cairn-mcp",
-  "version": "1.7.5",
+  "version": "1.8.1",
   "description": "MCP server that gives Claude Code persistent memory across sessions. Index your codebase once, search symbols, bundle source, scan for vulnerabilities, and checkpoint/resume work — across Java, TypeScript, Vue, Python, SQL and more.",
   "type": "module",
   "main": "index.js",

package/src/tools/checkpoint.js

@@ -47,14 +47,19 @@ export function checkpoint(_db, { message, active_files = [], notes = [] }) {
   const sessionPath = path.join(cairnDir, 'session.json');
   const dateStr = new Date().toISOString().slice(0, 10);
 
-  // Snapshot mtimes of active files
+  // Snapshot mtimes of all indexed files so resume can detect changes accurately.
+  // Without a full snapshot, resume labels every non-active file as "new" and
+  // triggers a full reindex on every call.
   const mtimeSnapshot = {};
-  for (const filePath of active_files) {
-    try {
-      mtimeSnapshot[filePath] = fs.statSync(filePath).mtimeMs;
-    } catch {
-      // File may not exist yet
+  try {
+    const rows = _db.prepare('SELECT path FROM main.files').all();
+    for (const { path: filePath } of rows) {
+      try { mtimeSnapshot[filePath] = fs.statSync(filePath).mtimeMs; } catch { }
     }
+  } catch { /* DB may not exist on first run */ }
+  // Also include active_files in case they are not yet indexed
+  for (const filePath of active_files) {
+    try { mtimeSnapshot[filePath] = fs.statSync(filePath).mtimeMs; } catch { }
   }
 
   // Process all notes: long strings get filed, short ones stay inline, refs pass through

package/src/tools/resume.js

@@ -1,6 +1,8 @@
 import fs from 'fs';
 import path from 'path';
-import { execSync } from 'child_process';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
 import { getCairnDir, getProjectRoot, getMemoryDir } from '../graph/cwd.js';
 import { walkRepo } from '../indexer/fileWalker.js';
 import { getAttachedSchemas } from '../graph/db.js';
@@ -172,28 +174,26 @@ export async function resume(db) {
     result.migrated = `Removed ${gitSnapshotNotes.length} legacy git-snapshot note(s). Original session backed up to session.bak.json.`;
   }
 
-  // Git state — lets Claude determine what's resolved vs still in-flight,
-  // regardless of checkpoint staleness.
+  // Git state — run all three queries in parallel to avoid sequential git startup overhead.
   const gitRoot = getProjectRoot();
-  try {
-    const since = new Date(session.checkpoint_at).toISOString();
-    const raw = execSync(`git log --oneline --after="${since}"`, {
-      cwd: gitRoot, encoding: 'utf8', timeout: 5000,
-    }).trim();
+  const since = new Date(session.checkpoint_at).toISOString();
+  const [logResult, diffResult, statusResult] = await Promise.allSettled([
+    execAsync(`git log --oneline --after="${since}"`, { cwd: gitRoot, timeout: 5000 }),
+    execAsync('git diff --name-only HEAD', { cwd: gitRoot, timeout: 5000 }),
+    execAsync('git status --short', { cwd: gitRoot, timeout: 5000 }),
+  ]);
+  if (logResult.status === 'fulfilled') {
+    const raw = logResult.value.stdout.trim();
     if (raw) result.commits_since_checkpoint = raw.split('\n');
-  } catch { }
-  try {
-    const raw = execSync('git diff --name-only HEAD', {
-      cwd: gitRoot, encoding: 'utf8', timeout: 5000,
-    }).trim();
+  }
+  if (diffResult.status === 'fulfilled') {
+    const raw = diffResult.value.stdout.trim();
     if (raw) result.uncommitted_changes = raw.split('\n');
-  } catch { }
-  try {
-    const raw = execSync('git status --short', {
-      cwd: gitRoot, encoding: 'utf8', timeout: 5000,
-    }).trim();
+  }
+  if (statusResult.status === 'fulfilled') {
+    const raw = statusResult.value.stdout.trim();
     if (raw) result.git_status = raw;
-  } catch { }
+  }
 
   if (relocation) result.relocated = relocation;
   if (preferences.length > 0) {