@stitchdb/cli 0.3.2 → 0.5.0

package/dist/cli.js

@@ -455,18 +455,61 @@ async function cmdHook(args) {
     catch {
         return;
     }
-    if (!raw)
-        return;
-    let event;
-    try {
-        event = JSON.parse(raw);
-    }
-    catch {
-        return;
+    let event = {};
+    if (raw) {
+        try {
+            event = JSON.parse(raw);
+        }
+        catch { /* keep empty */ }
     }
+    // hook_event_name may be missing for SessionStart on some Claude Code
+    // versions. Allow the caller to pass it as the first positional arg too.
     const eventName = event?.hook_event_name || args[0] || '';
-    const cwd = event?.cwd;
+    // SessionStart's payload doesn't include cwd — fall back to process.cwd()
+    // (which is the directory `claude` was launched from).
+    const cwd = event?.cwd || process.cwd();
     const threadName = inferThreadFor(cwd) || 'default';
+    // ── SessionStart: inject prior context as additional context ──────────
+    if (eventName === 'SessionStart') {
+        try {
+            const stitch = client(cfg);
+            const projectTag = path.basename(cwd || process.cwd());
+            // Pull both: recent dialogue from the per-repo thread + relevant
+            // durable memories tagged with the project.
+            const [thread, memHits] = await Promise.all([
+                stitch.thread(threadName).recall({ last: 20 }).catch(() => ({ thread_id: '', recent: [], semantic: [] })),
+                stitch.recall(projectTag, { k: 5 }).catch(() => []),
+            ]);
+            const lines = [];
+            lines.push('## Stitch — prior memory for this project');
+            lines.push('');
+            lines.push(`Thread: \`${threadName}\` · Workspace recall available via the \`stitch\` MCP server.`);
+            lines.push('');
+            if (thread.recent && thread.recent.length > 0) {
+                lines.push('### Recent conversation (continue from here)');
+                for (const t of thread.recent.slice(-12)) {
+                    const txt = String(t.content || '').replace(/\n+/g, ' ').slice(0, 400);
+                    lines.push(`- **${t.role}**: ${txt}`);
+                }
+                lines.push('');
+            }
+            if (Array.isArray(memHits) && memHits.length > 0) {
+                lines.push('### Durable memories');
+                for (const m of memHits) {
+                    const txt = String(m.content || '').replace(/\n+/g, ' ').slice(0, 320);
+                    lines.push(`- **[${m.kind}]** ${txt}`);
+                }
+                lines.push('');
+            }
+            if (lines.length > 4) {
+                // Plain stdout is auto-injected as additionalContext for SessionStart.
+                process.stdout.write(lines.join('\n'));
+            }
+        }
+        catch { /* silent — never break a session start */ }
+        return;
+    }
+    // ── UserPromptSubmit / Stop: log a turn ───────────────────────────────
     let role = null;
     let content = '';
     if (eventName === 'UserPromptSubmit') {
@@ -557,6 +600,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'));
@@ -665,15 +889,16 @@ async function cmdInstall(args) {
         else
             console.log(`failed (${stderr.trim().slice(0, 120)})`);
     }
-    // 2. Hooks for auto-logging conversations
+    // 2. Hooks: auto-log every turn + auto-inject prior context at session start
     if (!noHooks) {
-        process.stdout.write('• Wiring auto-log hooks (UserPromptSubmit + Stop)… ');
+        process.stdout.write('• Wiring hooks (SessionStart + UserPromptSubmit + Stop)… ');
         try {
             const settingsPath = path.join(os.homedir(), '.claude', 'settings.json');
             const existing = fs.existsSync(settingsPath)
                 ? JSON.parse(fs.readFileSync(settingsPath, 'utf8'))
                 : {};
             existing.hooks = existing.hooks || {};
+            existing.hooks.SessionStart = mergeHook(existing.hooks.SessionStart, STITCH_SESSION_START_HOOK);
             existing.hooks.UserPromptSubmit = mergeHook(existing.hooks.UserPromptSubmit, STITCH_USER_HOOK);
             existing.hooks.Stop = mergeHook(existing.hooks.Stop, STITCH_STOP_HOOK);
             fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
@@ -707,11 +932,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),
@@ -725,6 +1001,10 @@ const STITCH_STOP_HOOK = {
     matcher: '*',
     hooks: [{ type: 'command', command: 'stitch _hook' }],
 };
+const STITCH_SESSION_START_HOOK = {
+    matcher: '*',
+    hooks: [{ type: 'command', command: 'stitch _hook SessionStart' }],
+};
 function mergeHook(existing, entry) {
     const arr = Array.isArray(existing) ? existing.slice() : [];
     // Replace any earlier Stitch entry; identify by the marker.
@@ -898,6 +1178,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 +1224,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.5.0",
   "description": "Stitch CLI — manage memory + run agents from your terminal",
   "type": "module",
   "bin": {