@stitchdb/cli 0.7.4 → 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.
@@ -1546,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)
@@ -1992,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.4",
+  "version": "0.8.0",
   "description": "Stitch CLI — manage memory + run agents from your terminal",
   "type": "module",
   "bin": {