@stitchdb/cli 0.3.2 → 0.4.0

package/dist/cli.js

@@ -557,6 +557,187 @@ function lastAssistantTextFromTranscript(transcriptPath) {
     catch { /* ignore */ }
     return text;
 }
+// ── Sync Claude's local memory dir into Stitch ────────────────────────────
+// Claude Code keeps per-project memory at ~/.claude/projects/<encoded>/memory/
+// Each file is a markdown memory with optional YAML frontmatter (name,
+// description, type). When Stitch is set up, mirror those files as Stitch
+// memories so the same context surfaces via recall + the dashboard.
+const SYNC_STATE_FILE = path.join(CONFIG_DIR, 'sync-state.json');
+function loadSyncState() {
+    try {
+        return JSON.parse(fs.readFileSync(SYNC_STATE_FILE, 'utf8'));
+    }
+    catch {
+        return { files: {} };
+    }
+}
+function saveSyncState(s) {
+    if (!fs.existsSync(CONFIG_DIR))
+        fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    fs.writeFileSync(SYNC_STATE_FILE, JSON.stringify(s, null, 2));
+}
+const KIND_FROM_TYPE = {
+    feedback: 'preference',
+    user: 'fact',
+    project: 'note',
+    reference: 'fact',
+};
+function parseMemoryFile(text) {
+    const fields = {};
+    const m = text.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+    if (!m)
+        return { fields, body: text.trim() };
+    for (const line of m[1].split('\n')) {
+        const kv = line.match(/^([\w-]+):\s*(.+)$/);
+        if (kv)
+            fields[kv[1].toLowerCase()] = kv[2].trim();
+    }
+    return { fields, body: m[2].trim() };
+}
+async function hashContent(s) {
+    const buf = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(s));
+    return [...new Uint8Array(buf)].slice(0, 8).map((b) => b.toString(16).padStart(2, '0')).join('');
+}
+function listMemoryFiles() {
+    const root = path.join(os.homedir(), '.claude', 'projects');
+    if (!fs.existsSync(root))
+        return [];
+    const out = [];
+    for (const dir of fs.readdirSync(root)) {
+        const memDir = path.join(root, dir, 'memory');
+        if (!fs.existsSync(memDir))
+            continue;
+        for (const f of fs.readdirSync(memDir)) {
+            if (!f.endsWith('.md'))
+                continue;
+            if (f === 'MEMORY.md')
+                continue; // index, not content
+            out.push(path.join(memDir, f));
+        }
+    }
+    return out;
+}
+// Convert Claude's encoded path "-Users-x-Desktop-Projects-StitchDB" → "StitchDB" tag.
+function projectTagFromPath(filePath) {
+    const m = filePath.match(/\/projects\/([^/]+)\/memory\//);
+    if (!m)
+        return 'claude';
+    const encoded = m[1];
+    // Last hyphen-separated segment is usually the repo name
+    const parts = encoded.split('-').filter(Boolean);
+    return parts[parts.length - 1] || encoded;
+}
+async function cmdSync(args) {
+    const cfg = loadConfig();
+    const stitch = client(cfg);
+    const watch = hasFlag(args, ['--watch', '-w']);
+    const dryRun = hasFlag(args, ['--dry-run']);
+    const state = loadSyncState();
+    async function syncFile(file) {
+        try {
+            const stat = fs.statSync(file);
+            const text = fs.readFileSync(file, 'utf8');
+            const hash = await hashContent(text);
+            const prev = state.files[file];
+            if (prev && prev.contentHash === hash)
+                return 'unchanged';
+            const { fields, body } = parseMemoryFile(text);
+            const tag = projectTagFromPath(file);
+            const fileTag = path.basename(file, '.md');
+            const kind = KIND_FROM_TYPE[fields.type ?? ''] ?? 'note';
+            // Compose content: prefer the body; if body is empty, use description.
+            const content = body || fields.description || `(${fileTag} memory)`;
+            const tags = [tag, `claude:${fileTag}`].concat(fields.type ? [`claude-type:${fields.type}`] : []);
+            if (dryRun)
+                return prev ? 'updated' : 'created';
+            // We don't have an "update memory" endpoint yet — soft-delete + re-create.
+            if (prev?.memoryId) {
+                try {
+                    await stitch.forget(prev.memoryId);
+                }
+                catch { /* memory may already be gone */ }
+            }
+            const out = await stitch.remember(content, { kind: kind, tags });
+            state.files[file] = { memoryId: out.id, mtimeMs: stat.mtimeMs, contentHash: hash };
+            saveSyncState(state);
+            return prev ? 'updated' : 'created';
+        }
+        catch (e) {
+            console.error(`  ! ${file}: ${e.message || e}`);
+            return 'error';
+        }
+    }
+    async function syncAll() {
+        const files = listMemoryFiles();
+        const counts = { created: 0, updated: 0, unchanged: 0, error: 0 };
+        for (const f of files) {
+            const r = await syncFile(f);
+            counts[r]++;
+            if (r !== 'unchanged')
+                process.stdout.write(`  ${r === 'created' ? '+' : r === 'updated' ? '~' : 'x'} ${path.relative(os.homedir(), f)}\n`);
+        }
+        return counts;
+    }
+    const initial = await syncAll();
+    console.log(`\n${initial.created} created · ${initial.updated} updated · ${initial.unchanged} unchanged${initial.error ? ` · ${initial.error} errors` : ''}`);
+    if (!watch)
+        return;
+    console.log('\nWatching ~/.claude/projects/*/memory/ for changes (Ctrl+C to stop)…');
+    const root = path.join(os.homedir(), '.claude', 'projects');
+    // Walk per-project memory dirs; fs.watch is recursive on macOS but not Linux,
+    // so we attach a watcher per memory dir to keep the behaviour uniform.
+    const watched = new Set();
+    function attachWatcher(memDir) {
+        if (watched.has(memDir))
+            return;
+        watched.add(memDir);
+        try {
+            fs.watch(memDir, { persistent: true }, async (_event, name) => {
+                if (!name || !String(name).endsWith('.md') || name === 'MEMORY.md')
+                    return;
+                const file = path.join(memDir, String(name));
+                if (!fs.existsSync(file)) {
+                    // File deleted — soft-delete from Stitch too.
+                    const prev = state.files[file];
+                    if (prev) {
+                        try {
+                            await stitch.forget(prev.memoryId);
+                        }
+                        catch { /* ignore */ }
+                        delete state.files[file];
+                        saveSyncState(state);
+                        console.log(`  - ${path.relative(os.homedir(), file)}`);
+                    }
+                    return;
+                }
+                const r = await syncFile(file);
+                if (r !== 'unchanged')
+                    console.log(`  ${r === 'created' ? '+' : r === 'updated' ? '~' : 'x'} ${path.relative(os.homedir(), file)}`);
+            });
+        }
+        catch { /* dir likely removed */ }
+    }
+    if (fs.existsSync(root)) {
+        for (const dir of fs.readdirSync(root)) {
+            const memDir = path.join(root, dir, 'memory');
+            if (fs.existsSync(memDir))
+                attachWatcher(memDir);
+        }
+        // Watch the root for new project dirs too.
+        try {
+            fs.watch(root, { persistent: true }, (_event, name) => {
+                if (!name)
+                    return;
+                const memDir = path.join(root, String(name), 'memory');
+                if (fs.existsSync(memDir))
+                    attachWatcher(memDir);
+            });
+        }
+        catch { /* ignore */ }
+    }
+    // Hold open forever.
+    await new Promise(() => { });
+}
 function loadUpdateCache() {
     try {
         return JSON.parse(fs.readFileSync(UPDATE_CACHE, 'utf8'));
@@ -707,11 +888,62 @@ async function cmdInstall(args) {
             fs.writeFileSync(claudeMd, body);
         console.log(`• ${action === 'created' ? 'Wrote' : action === 'appended' ? 'Appended to' : 'Found'} ./CLAUDE.md (${action})`);
     }
+    // 4. One-shot sync of any existing Claude memory files so they show up in
+    //    Stitch immediately. The user can rerun `stitch sync --watch` later.
+    if (!hasFlag(args, ['--no-sync'])) {
+        try {
+            const files = listMemoryFiles();
+            if (files.length > 0) {
+                process.stdout.write(`• Syncing ${files.length} Claude memory file(s) into Stitch… `);
+                const state = loadSyncState();
+                const stitch = client(cfg);
+                let created = 0, updated = 0, errors = 0;
+                for (const file of files) {
+                    try {
+                        const text = fs.readFileSync(file, 'utf8');
+                        const hash = await hashContent(text);
+                        const prev = state.files[file];
+                        if (prev && prev.contentHash === hash)
+                            continue;
+                        const { fields, body } = parseMemoryFile(text);
+                        const tag = projectTagFromPath(file);
+                        const fileTag = path.basename(file, '.md');
+                        const kind = KIND_FROM_TYPE[fields.type ?? ''] ?? 'note';
+                        const content = body || fields.description || `(${fileTag} memory)`;
+                        const tags = [tag, `claude:${fileTag}`].concat(fields.type ? [`claude-type:${fields.type}`] : []);
+                        if (prev?.memoryId) {
+                            try {
+                                await stitch.forget(prev.memoryId);
+                            }
+                            catch { }
+                        }
+                        const out = await stitch.remember(content, { kind: kind, tags });
+                        state.files[file] = { memoryId: out.id, mtimeMs: fs.statSync(file).mtimeMs, contentHash: hash };
+                        if (prev)
+                            updated++;
+                        else
+                            created++;
+                    }
+                    catch {
+                        errors++;
+                    }
+                }
+                saveSyncState(state);
+                console.log(`+${created} ~${updated}${errors ? ` ✗${errors}` : ''}`);
+            }
+        }
+        catch (e) {
+            console.log(`skipped (${e.message})`);
+        }
+    }
     console.log();
     console.log('Done. Open a fresh `claude` session — Stitch is wired.');
     console.log('  • remember/recall tools are available');
     console.log('  • every turn auto-logs to the thread for this repo');
     console.log('  • Claude auto-pulls past context at session start (per CLAUDE.md)');
+    console.log('  • Claude memory files are mirrored to Stitch');
+    console.log();
+    console.log('Run `stitch sync --watch` to keep them in sync as Claude updates them.');
 }
 // The hook calls a single CLI subcommand (`stitch _hook`) that reads the event
 // JSON from stdin, picks the right field (or reads transcript_path for Stop),
@@ -898,6 +1130,11 @@ function help() {
   stitch whoami                               Show the configured key.
   stitch logout
 
+  stitch sync [--watch] [--dry-run]           Mirror ~/.claude/projects/*/memory/
+                                              files into Stitch as memories.
+                                              --watch keeps running; otherwise it's
+                                              a one-shot.
+
   stitch update                               Update to the latest @stitchdb/cli.
   stitch version                              Print the installed version.
 
@@ -939,6 +1176,7 @@ async function main(argv) {
             case 'recall': return cmdRecall(rest);
             case 'thread': return cmdThread(rest);
             case 'install': return cmdInstall(rest);
+            case 'sync': return cmdSync(rest);
             case '_hook': return cmdHook(rest);
             case 'update':
             case 'upgrade': return cmdUpdate(rest);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stitchdb/cli",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "Stitch CLI — manage memory + run agents from your terminal",
   "type": "module",
   "bin": {