@stitchdb/cli 0.3.1 → 0.4.0

package/dist/cli.js

@@ -440,6 +440,304 @@ function readStdinAll() {
         process.stdin.on('end', () => resolve(data.trim()));
     });
 }
+// ── Claude Code hook handler ──────────────────────────────────────────────
+// Reads hook event JSON from stdin, figures out what to log, posts to Stitch.
+// Designed to never fail loudly — Claude Code shouldn't be interrupted because
+// our memory layer hiccupped.
+async function cmdHook(args) {
+    const cfg = loadConfig();
+    if (!cfg.apiKey)
+        return; // not logged in, silently skip
+    let raw = '';
+    try {
+        raw = await readStdinAll();
+    }
+    catch {
+        return;
+    }
+    if (!raw)
+        return;
+    let event;
+    try {
+        event = JSON.parse(raw);
+    }
+    catch {
+        return;
+    }
+    const eventName = event?.hook_event_name || args[0] || '';
+    const cwd = event?.cwd;
+    const threadName = inferThreadFor(cwd) || 'default';
+    let role = null;
+    let content = '';
+    if (eventName === 'UserPromptSubmit') {
+        role = 'user';
+        content = String(event?.prompt || '');
+    }
+    else if (eventName === 'Stop') {
+        role = 'assistant';
+        content = lastAssistantTextFromTranscript(event?.transcript_path);
+    }
+    else {
+        return;
+    }
+    content = content.trim();
+    if (!content)
+        return;
+    try {
+        const stitch = client(cfg);
+        await stitch.thread(threadName).append({ role, content });
+    }
+    catch {
+        /* silent */
+    }
+}
+function inferThreadFor(cwd) {
+    const dir = cwd && fs.existsSync(cwd) ? cwd : process.cwd();
+    let cur = dir;
+    for (let i = 0; i < 8; i++) {
+        if (fs.existsSync(path.join(cur, '.git'))) {
+            const repoName = path.basename(cur);
+            let branch = 'main';
+            try {
+                const head = fs.readFileSync(path.join(cur, '.git', 'HEAD'), 'utf8').trim();
+                const m = head.match(/^ref:\s+refs\/heads\/(.+)$/);
+                if (m)
+                    branch = m[1];
+            }
+            catch { /* detached */ }
+            return `${repoName}/${branch}`;
+        }
+        const next = path.dirname(cur);
+        if (next === cur)
+            break;
+        cur = next;
+    }
+    return path.basename(dir);
+}
+function lastAssistantTextFromTranscript(transcriptPath) {
+    if (!transcriptPath || !fs.existsSync(transcriptPath))
+        return '';
+    let text = '';
+    try {
+        const raw = fs.readFileSync(transcriptPath, 'utf8');
+        const lines = raw.split('\n').filter((l) => l.trim());
+        // Walk from the end, find the last entry whose role is 'assistant'.
+        for (let i = lines.length - 1; i >= 0; i--) {
+            let entry;
+            try {
+                entry = JSON.parse(lines[i]);
+            }
+            catch {
+                continue;
+            }
+            const msg = entry?.message ?? entry;
+            const role = msg?.role ?? entry?.role ?? entry?.type;
+            if (role !== 'assistant')
+                continue;
+            const content = msg?.content ?? msg?.text ?? entry?.content;
+            if (typeof content === 'string') {
+                text = content;
+            }
+            else if (Array.isArray(content)) {
+                const parts = [];
+                for (const c of content) {
+                    if (typeof c === 'string')
+                        parts.push(c);
+                    else if (c?.type === 'text' && typeof c.text === 'string')
+                        parts.push(c.text);
+                    else if (typeof c?.text === 'string')
+                        parts.push(c.text);
+                }
+                text = parts.join('\n').trim();
+            }
+            if (text)
+                break;
+        }
+    }
+    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'));
@@ -590,28 +888,79 @@ 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),
+// and posts to the right per-repo thread. Keeps user settings.json minimal and
+// lets us evolve the parsing without touching their config later.
 const STITCH_USER_HOOK = {
     matcher: '*',
-    hooks: [
-        { type: 'command', command: `bash -c 'jq -r .prompt | stitch thread append --role user --thread "$(stitch thread current)" 2>/dev/null || true'` },
-    ],
+    hooks: [{ type: 'command', command: 'stitch _hook' }],
 };
 const STITCH_STOP_HOOK = {
     matcher: '*',
-    hooks: [
-        { type: 'command', command: `bash -c 'jq -r .response.text 2>/dev/null | stitch thread append --role assistant --thread "$(stitch thread current)" 2>/dev/null || true'` },
-    ],
+    hooks: [{ type: 'command', command: 'stitch _hook' }],
 };
 function mergeHook(existing, entry) {
     const arr = Array.isArray(existing) ? existing.slice() : [];
-    // Replace any earlier Stitch entry; identify by marker substring.
-    const isStitch = (h) => JSON.stringify(h).includes('stitch thread append');
+    // Replace any earlier Stitch entry; identify by the marker.
+    const isStitch = (h) => JSON.stringify(h).includes('stitch _hook') || JSON.stringify(h).includes('stitch thread append');
     const filtered = arr.filter((h) => !isStitch(h));
     filtered.push(entry);
     return filtered;
@@ -781,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.
 
@@ -822,6 +1176,8 @@ 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);
             case 'version':

package/package.json

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