@stitchdb/cli 0.7.3 → 0.8.0

package/dist/cli.js

@@ -84,12 +84,35 @@ function client(cfg) {
         console.error('Not logged in. Run: stitch login');
         process.exit(2);
     }
+    // Per-project workspace pin: .stitch/project.json's workspace_id wins over
+    // the global default. Lets multiple projects share one machine without
+    // their memory pools polluting each other.
+    const projectWorkspace = readProjectWorkspaceId(process.cwd());
     return new Stitch({
         apiKey: cfg.apiKey,
         baseUrl: cfg.baseUrl,
-        workspace: cfg.defaultWorkspace,
+        workspace: projectWorkspace || cfg.defaultWorkspace,
     });
 }
+function readProjectWorkspaceId(cwd) {
+    let cur = cwd;
+    for (let i = 0; i < 8; i++) {
+        const projectFile = path.join(cur, '.stitch', 'project.json');
+        if (fs.existsSync(projectFile)) {
+            try {
+                const pj = JSON.parse(fs.readFileSync(projectFile, 'utf8'));
+                if (typeof pj.workspace_id === 'string' && pj.workspace_id.startsWith('wsp_'))
+                    return pj.workspace_id;
+            }
+            catch { /* fall through */ }
+        }
+        const next = path.dirname(cur);
+        if (next === cur)
+            break;
+        cur = next;
+    }
+    return undefined;
+}
 // ─── Argv helpers ──────────────────────────────────────────────────────────
 function parseFlag(args, names) {
     for (const name of names) {
@@ -222,6 +245,9 @@ async function cmdWorkspace(args) {
         const w = await stitch.workspaces.update(id, { name });
         console.log(`Renamed ${w.id} → ${w.name}`);
     }
+    else if (sub === 'migrate-by-project') {
+        return cmdWorkspaceMigrate(rest);
+    }
     else if (sub === 'delete') {
         const id = positional(rest)[0];
         if (!id) {
@@ -375,6 +401,93 @@ async function cmdAgent(args) {
     console.error('Usage: stitch agent [register|list|run|dispatch|revoke] …');
     process.exit(2);
 }
+// ── Workspace migration: split a pooled workspace into per-project ones ───
+// Reads every memory in the source workspace, groups by `project:*` tag,
+// and copies each group into a workspace named after the project (creating
+// it if missing), then soft-deletes the source rows. Memories with no
+// `project:*` tag stay put. Idempotent re-runs are safe.
+async function cmdWorkspaceMigrate(args) {
+    const cfg = loadConfig();
+    if (!cfg.apiKey) {
+        console.error('Run `stitch login` first.');
+        process.exit(2);
+    }
+    const baseUrl = cfg.baseUrl || 'https://db.stitchdb.com';
+    const dryRun = hasFlag(args, ['--dry-run']);
+    const stitch = new Stitch({ apiKey: cfg.apiKey, baseUrl });
+    const sourceId = parseFlag(args, ['--from']) || (await stitch.workspaces.list())[0]?.id;
+    if (!sourceId) {
+        console.error('No source workspace found.');
+        process.exit(1);
+    }
+    const source = new Stitch({ apiKey: cfg.apiKey, baseUrl, workspace: sourceId });
+    console.log(`Reading memories from ${sourceId}…`);
+    const all = [];
+    let offset = 0;
+    while (true) {
+        const batch = await source.list({ limit: 100, offset });
+        if (batch.length === 0)
+            break;
+        all.push(...batch);
+        if (batch.length < 100)
+            break;
+        offset += batch.length;
+    }
+    console.log(`Found ${all.length} memories.`);
+    const byProject = {};
+    let untagged = 0;
+    for (const m of all) {
+        const tag = m.tags.find((t) => t.startsWith('project:'));
+        if (!tag) {
+            untagged++;
+            continue;
+        }
+        const proj = tag.slice('project:'.length).trim();
+        if (!proj) {
+            untagged++;
+            continue;
+        }
+        const slug = slugify(proj);
+        (byProject[slug] ??= []).push(m);
+    }
+    console.log(`  ${untagged} untagged → staying in source`);
+    for (const [slug, mems] of Object.entries(byProject)) {
+        console.log(`  ${slug.padEnd(30)} ${mems.length} memories`);
+    }
+    if (dryRun) {
+        console.log('Dry run — nothing written.');
+        return;
+    }
+    const allWs = await stitch.workspaces.list();
+    let totalMoved = 0;
+    for (const [slug, mems] of Object.entries(byProject)) {
+        let target = allWs.find((w) => w.name === slug);
+        if (!target) {
+            target = await stitch.workspaces.create(slug);
+            console.log(`  + created workspace "${slug}" (${target.id})`);
+            allWs.push(target);
+        }
+        if (target.id === sourceId) {
+            console.log(`  · ${slug}: target = source — keeping in place`);
+            continue;
+        }
+        const targetClient = new Stitch({ apiKey: cfg.apiKey, baseUrl, workspace: target.id });
+        let moved = 0;
+        for (const m of mems) {
+            try {
+                await targetClient.remember(m.content, { kind: m.kind, tags: m.tags, metadata: m.metadata });
+                await source.forget(m.id);
+                moved++;
+            }
+            catch (e) {
+                console.error(`  ! ${m.id}: ${e?.message || e}`);
+            }
+        }
+        totalMoved += moved;
+        console.log(`  → ${slug}: moved ${moved}/${mems.length}`);
+    }
+    console.log(`Migration complete. ${totalMoved} memories moved across ${Object.keys(byProject).length} workspaces.`);
+}
 // ── Threads — append / recall / current ───────────────────────────────────
 function inferThread() {
     // Single source of truth: `.stitch/project.json` if present, else cwd basename.
@@ -490,9 +603,11 @@ async function cmdHook(args) {
         await handlePreReadHook(cfg, event, cwd || process.cwd()).catch(() => { });
         return;
     }
-    // ── PostToolUse on Read: opportunistically save a fresh summary ───────
-    if (eventName === 'PostToolUse' && event?.tool_name === 'Read') {
-        await handlePostReadHook(cfg, event, cwd || process.cwd()).catch(() => { });
+    // ── PostToolUse on Read/Edit/Write/MultiEdit: keep the file-summary
+    //    cache fresh. After an edit we re-hash the on-disk file and
+    //    re-summarise, so a stale "old version" memory never lingers.
+    if (eventName === 'PostToolUse' && ['Read', 'Edit', 'Write', 'MultiEdit'].includes(String(event?.tool_name))) {
+        await handlePostFileChangeHook(cfg, event, cwd || process.cwd()).catch(() => { });
         return;
     }
     // ── SessionStart: self-heal hook config + inject prior context ─────────
@@ -735,13 +850,14 @@ function lastAssistantTextFromTranscript(transcriptPath) {
 const FILE_SUMMARY_MIN_BYTES = 500; // skip tiny files
 const FILE_SUMMARY_MAX_BYTES = 200_000; // skip absolutely huge files
 const FILE_SUMMARY_COOLDOWN_MS = 5 * 60_000; // per-file: don't re-summarize more than once per 5 min
-const FILE_SUMMARY_PROMPT = `You are summarising a single source file for an AI coding assistant cache.
+const FILE_SUMMARY_PROMPT = `You are summarising a single source file for an AI coding assistant's persistent project cache. Other agents will read this summary before deciding whether to open the file in full, so it must enable a real mental model of the project — not just describe the file in isolation.
 
-Return ONLY a 2-3 sentence summary describing:
-  • What the file does (purpose, the few exported symbols / commands / endpoints worth knowing).
-  • Any important pattern, convention, or non-obvious behaviour another agent would benefit from before reading the file in full.
+Return ONLY a 2-4 sentence summary that covers:
+  1. PURPOSE — what this file does, its key exported symbols / routes / commands / classes worth knowing, any non-obvious invariant or pattern.
+  2. CONNECTIONS — concrete other files/modules this depends on (real import paths, real symbol names) AND who/what typically depends on this. Use real names from the file content; don't generalise.
+  3. WHEN TO OPEN — what kind of task forces an edit here vs a peek. (e.g. "edit this when adding a new auth provider; safe to skip for purely UI changes").
 
-Skip preamble. Skip "this file …". Be specific. No markdown fences. No prose around it.
+Be dense and specific. No preamble. No "this file ...". No markdown fences. No prose around it. Plain text only.
 
 File path: {{PATH}}
 
@@ -820,47 +936,64 @@ async function handlePreReadHook(cfg, event, cwd) {
     const payload = { hookSpecificOutput: { hookEventName: 'PreToolUse', additionalContext: note } };
     process.stdout.write(JSON.stringify(payload));
 }
-// PostToolUse on Read: kick off a background `claude -p` to summarize this
-// file IF we don't already have a summary at the current hash. Fire-and-forget.
-async function handlePostReadHook(cfg, event, cwd) {
+// PostToolUse handler for tools that observe-or-modify a single file
+// (Read, Edit, Write, MultiEdit). Kicks off a background `claude -p` to
+// (re-)summarise this file unless we already have an up-to-date cached
+// summary for this exact hash. Fire-and-forget.
+//
+// Read flow:    file content same as cache → no-op. Different → re-summarise.
+// Edit flow:    file content always different from cache → re-summarise. The
+//               existing summary is replaced by cmdSummarizeFile so no stale
+//               memory persists.
+// Write/MultiEdit: same as Edit.
+//
+// A 30 s "min-interval" floor on top of the hash-keyed cooldown prevents a
+// flurry of edits within seconds from spawning N parallel claude -p calls
+// for the same file.
+async function handlePostFileChangeHook(cfg, event, cwd) {
     const filePath = String(event?.tool_input?.file_path || '');
     if (!filePath)
         return;
     const rel = relPathFor(cwd, filePath);
-    const content = readFileContentFromHookEvent(event);
-    // Fall back to reading from disk if hook payload didn't carry content.
-    let body = content;
-    if (!body) {
-        try {
-            body = fs.readFileSync(filePath, 'utf8');
-        }
-        catch {
-            return;
-        }
+    // After Edit/Write the on-disk content is what we want; the hook payload
+    // may also carry it, but reading from disk is always correct.
+    let body = '';
+    try {
+        body = fs.readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return;
     }
-    if (!body || body.length < FILE_SUMMARY_MIN_BYTES)
+    if (!body)
+        return;
+    // Tiny files: not worth a summary. Huge files: skip; would exhaust context.
+    if (body.length < FILE_SUMMARY_MIN_BYTES)
         return;
     if (body.length > FILE_SUMMARY_MAX_BYTES)
         return;
     const fullHash = await sha256Hex(body);
     const hashPrefix = fullHash.slice(0, 16);
-    // Per-file cooldown so a hot-edited file doesn't re-summarize on every read.
     const state = loadFileSummaryState();
     const last = state.files[rel];
+    // Hash-keyed dedupe: same content as last spawn → nothing to do.
     if (last && last.hash === hashPrefix && Date.now() - last.lastSummarizedAt < FILE_SUMMARY_COOLDOWN_MS)
         return;
+    // Min-interval floor: regardless of hash change, don't spawn more often
+    // than once per 30 s for the same file (catches edit flurries).
+    const MIN_RESPAWN_MS = 30_000;
+    if (last && Date.now() - last.lastSummarizedAt < MIN_RESPAWN_MS)
+        return;
+    // Optimisation: confirm the API view is also stale before spending tokens.
     const stitch = client(cfg);
     const cached = await lookupFileSummary(stitch, rel);
     if (cached && cached.hash === hashPrefix) {
-        // Already summarized this exact version — refresh cooldown and bail.
         state.files[rel] = { hash: hashPrefix, lastSummarizedAt: Date.now() };
         saveFileSummaryState(state);
         return;
     }
-    // Mark BEFORE spawning so a flurry of Read events doesn't fire N spawns.
+    // Mark BEFORE spawning so overlapping events don't fire N spawns.
     state.files[rel] = { hash: hashPrefix, lastSummarizedAt: Date.now() };
     saveFileSummaryState(state);
-    // Spawn detached: stitch _summarize-file <abs-path> <hash> <rel>
     try {
         const cliPath = process.argv[1] || (await import('node:url')).fileURLToPath(import.meta.url);
         const child = spawn(process.argv[0], [cliPath, '_summarize-file', filePath, hashPrefix, rel], {
@@ -1526,39 +1659,68 @@ async function cmdInstall(args) {
         console.error('Run `stitch login` first.');
         process.exit(2);
     }
-    const stitch = client(cfg);
-    const ws = await stitch.resolveWorkspace();
     const baseUrl = cfg.baseUrl || 'https://db.stitchdb.com';
-    const mcpUrl = `${baseUrl}/mcp/v1/${ws}`;
-    // 0. If the workspace is still called "default", upgrade its name to a
-    //    project-derived slug so memories surface under a meaningful identity.
-    //    The AI can later refine it via the workspace_setup MCP tool.
-    if (!hasFlag(args, ['--no-rename-workspace'])) {
-        try {
-            const current = await stitch.workspaces.get(ws);
-            if (current.name === 'default') {
-                const derived = deriveWorkspaceName(process.cwd());
-                if (derived && derived !== 'default') {
-                    process.stdout.write(`• Naming workspace "${derived}" (was "default")… `);
-                    await stitch.workspaces.update(ws, { name: derived });
-                    console.log('ok');
-                }
-            }
+    // Use a "raw" SDK client (no project pin) for the bootstrap so we can list
+    // and create workspaces freely. After this we write .stitch/project.json
+    // and subsequent commands auto-route through the per-project workspace.
+    const rawStitch = new Stitch({ apiKey: cfg.apiKey, baseUrl });
+    // Step 0 — resolve the per-project workspace ─────────────────────────────
+    const projectName = deriveWorkspaceName(process.cwd());
+    process.stdout.write(`• Resolving workspace "${projectName}" for this project… `);
+    let ws;
+    try {
+        const list = await rawStitch.workspaces.list();
+        let target = list.find((w) => w.name === projectName);
+        if (!target) {
+            target = await rawStitch.workspaces.create(projectName);
+            console.log(`created (${target.id})`);
         }
-        catch (e) {
-            // Older deployments may not have the PATCH endpoint yet.
-            console.log(`• Workspace rename skipped (${e?.message || e}).`);
+        else {
+            console.log(`found (${target.id})`);
         }
+        ws = target.id;
     }
+    catch (e) {
+        console.log(`failed (${e?.message || e})`);
+        process.exit(1);
+    }
+    // Step 0.5 — write .stitch/project.json so every CLI invocation in this
+    // tree (incl. hooks) routes to the right workspace automatically.
+    try {
+        const dir = path.join(process.cwd(), '.stitch');
+        fs.mkdirSync(dir, { recursive: true });
+        const file = path.join(dir, 'project.json');
+        let pj = {};
+        try {
+            pj = JSON.parse(fs.readFileSync(file, 'utf8'));
+        }
+        catch { }
+        pj.thread = pj.thread || projectName;
+        pj.workspace_id = ws;
+        pj.workspace_name = projectName;
+        pj.linked_at = pj.linked_at || new Date().toISOString();
+        fs.writeFileSync(file, JSON.stringify(pj, null, 2));
+        console.log(`• Pinned project to workspace "${projectName}" (${file})`);
+    }
+    catch (e) {
+        console.log(`• .stitch/project.json write skipped (${e?.message || e})`);
+    }
+    const mcpUrl = `${baseUrl}/mcp/v1/${ws}`;
     const noMcp = hasFlag(args, ['--no-mcp']);
     const noHooks = hasFlag(args, ['--no-hooks']);
     const noClaudeMd = hasFlag(args, ['--no-claude-md']);
-    // 1. claude mcp add
+    // 1. claude mcp add — LOCAL scope (per-user-per-project) so each project's
+    //    Claude session loads only its own workspace's tools, not every project's.
+    //    If a stale entry exists with a different URL we replace it, since this
+    //    project's workspace_id may have changed (e.g. cloned to a new account).
     if (!noMcp) {
         const claudePath = process.env.STITCH_CLAUDE_BIN || 'claude';
-        process.stdout.write('• Adding Stitch as an MCP server in Claude Code… ');
+        process.stdout.write('• Registering Stitch MCP for this project (local scope)… ');
+        // Best-effort remove of any prior local-scope `stitch` entry; ignore errors
+        // (it's fine if there wasn't one).
+        await runSilent(claudePath, ['mcp', 'remove', '--scope', 'local', 'stitch']).catch(() => { });
         const { exit_code, stderr } = await runSilent(claudePath, [
-            'mcp', 'add', '--transport', 'http', '--scope', 'user', 'stitch', mcpUrl,
+            'mcp', 'add', '--transport', 'http', '--scope', 'local', 'stitch', mcpUrl,
             '-H', `Authorization: Bearer ${cfg.apiKey}`,
         ]);
         if (exit_code === 0)
@@ -1688,13 +1850,17 @@ const STITCH_SESSION_START_HOOK = {
     matcher: '*',
     hooks: [{ type: 'command', command: 'stitch _hook SessionStart' }],
 };
-// File summary cache: only fires for the Read tool, both pre and post.
+// File summary cache:
+//   • PreToolUse fires only on Read (cached summary surfaces before the read).
+//   • PostToolUse fires on Read, Edit, Write, MultiEdit — Edit/Write/MultiEdit
+//     invalidate any prior summary so a stale "old version" memory never
+//     lingers. The matcher is a regex (Claude Code accepts pipe alternation).
 const STITCH_PRE_READ_HOOK = {
     matcher: 'Read',
     hooks: [{ type: 'command', command: 'stitch _hook' }],
 };
 const STITCH_POST_READ_HOOK = {
-    matcher: 'Read',
+    matcher: 'Read|Edit|Write|MultiEdit',
     hooks: [{ type: 'command', command: 'stitch _hook' }],
 };
 function mergeHook(existing, entry) {
@@ -1968,6 +2134,10 @@ function help() {
                                               for the current repo / cwd.
 
   stitch workspace [list | create <name> | use <id> | rename <id> <name> | delete <id> --yes]
+  stitch workspace migrate-by-project [--from <id>] [--dry-run]
+                                              Split memories from one pooled
+                                              workspace into per-project
+                                              workspaces by their project:* tag.
 
   stitch agent register <name>                Create an agent identity (id only).
   stitch agent list

package/package.json

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