@stitchdb/cli 0.7.4 → 0.9.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.
@@ -515,6 +628,7 @@ async function cmdHook(args) {
         try {
             const stitch = client(cfg);
             const projectTag = (threadName.split('/')[0] || threadName).toLowerCase();
+            const baseUrl = cfg.baseUrl || 'https://db.stitchdb.com';
             const [thread, memHits, workspaces, fileSummaries, aboutMems] = await Promise.all([
                 stitch.thread(threadName).recall({ last: 5 }).catch(() => ({ thread_id: '', recent: [], semantic: [] })),
                 stitch.recall(projectTag, { k: 8 }).catch(() => []),
@@ -522,10 +636,26 @@ async function cmdHook(args) {
                 stitch.list({ limit: 12 }).then((all) => all.filter((m) => m.tags.some((t) => t.startsWith('file:')))).catch(() => []),
                 stitch.list({ tag: 'workspace:about', limit: 1 }).catch(() => []),
             ]);
-            const currentWs = Array.isArray(workspaces) && workspaces.length > 0 ? workspaces[0] : null;
+            // Look up the current workspace using the client's resolved id; fall
+            // back to first if resolveWorkspace failed (shouldn't normally).
+            const currentWsId = await stitch.resolveWorkspace().catch(() => null);
+            const currentWs = (Array.isArray(workspaces) ? workspaces : [])
+                .find((w) => w.id === currentWsId) || (Array.isArray(workspaces) ? workspaces[0] : null);
+            // Cross-project user-level memories from the special `_global` workspace.
+            // Pull top 8 most-recent — these are user preferences / rules that apply
+            // EVERYWHERE, regardless of which project this session is in.
+            let globalMems = [];
+            try {
+                const globalWs = (Array.isArray(workspaces) ? workspaces : []).find((w) => w.name === '_global');
+                if (globalWs) {
+                    const globalClient = new Stitch({ apiKey: cfg.apiKey, baseUrl, workspace: globalWs.id });
+                    globalMems = await globalClient.list({ limit: 8 }).catch(() => []);
+                }
+            }
+            catch { /* ignore */ }
             const lines = [];
             lines.push('<stitch-context>');
-            lines.push(`Project: ${threadName} · Workspace: ${currentWs?.name || '(unknown)'} · Stitch MCP tools: recall, remember, thread_recall, thread_append, workspace_setup, file_summary, file_summary_save.`);
+            lines.push(`Project: ${threadName} · Workspace: ${currentWs?.name || '(unknown)'} · Stitch MCP tools: recall, remember, recall_global, remember_global, thread_recall, thread_append, workspace_setup, file_summary, file_summary_save.`);
             lines.push('');
             // Nudge the AI to set a meaningful workspace name once.
             if (currentWs?.name === 'default') {
@@ -533,6 +663,15 @@ async function cmdHook(args) {
                 lines.push('Call the `workspace_setup` MCP tool with a slug-style name based on this project (e.g. the package.json name or repo dir).');
                 lines.push('');
             }
+            // Global preferences first — they should bias everything else.
+            if (globalMems.length > 0) {
+                lines.push('### User-level rules & preferences (apply across all projects)');
+                for (const m of globalMems) {
+                    const txt = String(m.content || '').replace(/\n+/g, ' ').slice(0, 350);
+                    lines.push(`- **[${m.kind}]** ${txt}`);
+                }
+                lines.push('');
+            }
             if (Array.isArray(aboutMems) && aboutMems.length > 0) {
                 lines.push('### About this workspace');
                 lines.push(String(aboutMems[0].content || '').slice(0, 400));
@@ -566,7 +705,7 @@ async function cmdHook(args) {
                 }
                 lines.push('');
             }
-            lines.push('Call `recall` for deeper search, `thread_recall` for older turns, `file_summary` BEFORE reading any non-trivial file (saves tokens).');
+            lines.push('Call `recall` for project memory, `recall_global` for cross-project user prefs, `thread_recall` for older turns, `file_summary` BEFORE reading any non-trivial file. Save user-level habits/preferences with `remember_global`; project facts with `remember`.');
             lines.push('</stitch-context>');
             process.stdout.write(lines.join('\n'));
         }
@@ -941,7 +1080,6 @@ async function cmdSummarizeFile(args) {
         return;
     try {
         const stitch = client(cfg);
-        const projectTag = (inferThread() || 'default').split('/')[0];
         // Replace any prior summary for this path.
         const prior = await stitch.list({ tag: `file:${rel}`, limit: 50 }).catch(() => []);
         for (const p of prior) {
@@ -950,9 +1088,13 @@ async function cmdSummarizeFile(args) {
             }
             catch { }
         }
+        // No project:* tag — the workspace itself is the project identity now.
+        // Adding a project tag based on inferThread() is the bug that caused
+        // cross-workspace contamination when the workspace pin and the thread
+        // pin disagreed.
         await stitch.remember(summary, {
             kind: 'snippet',
-            tags: [`file:${rel}`, `hash:${hashPrefix}`, 'auto:file-summary', `project:${projectTag}`],
+            tags: [`file:${rel}`, `hash:${hashPrefix}`, 'auto:file-summary'],
         });
     }
     catch { /* silent — never break a session */ }
@@ -1096,12 +1238,12 @@ async function cmdDistill(args) {
         bumpDistillCooldown(thread);
         return;
     }
-    // Push each to Stitch as a memory with auto:true tag.
-    const projectTag = thread.split('/')[0] || thread;
+    // Push each to Stitch as a memory with auto:true tag. No project:* tag —
+    // the workspace itself is the project identity.
     let saved = 0;
     for (const m of memories) {
         try {
-            const tags = ['auto', 'auto:distill', `thread:${thread}`, `project:${projectTag}`, ...(m.tags || [])];
+            const tags = ['auto', 'auto:distill', `thread:${thread}`, ...(m.tags || [])];
             await stitch.remember(m.content, { kind: m.kind, tags });
             saved++;
         }
@@ -1546,39 +1688,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)
@@ -1992,6 +2163,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.4",
+  "version": "0.9.0",
   "description": "Stitch CLI — manage memory + run agents from your terminal",
   "type": "module",
   "bin": {