cf-memory-mcp 3.41.0 → 3.43.0

package/bin/cf-memory-mcp.js

@@ -3843,7 +3843,7 @@ if (process.argv.includes('--version') || process.argv.includes('-v')) {
 
 // Global --help only when no subcommand is present. With a subcommand, fall
 // through to the per-command help dispatch below.
-const SUBCOMMANDS = new Set(['resume', 'list', 'checkpoint', 'status', 'clean', 'export', 'import', 'doctor', 'completion', 'delete', 'env', 'history']);
+const SUBCOMMANDS = new Set(['resume', 'list', 'checkpoint', 'status', 'clean', 'export', 'import', 'doctor', 'completion', 'delete', 'env', 'history', 'link']);
 const hasSubcommand = process.argv[2] && SUBCOMMANDS.has(process.argv[2]);
 
 if (!hasSubcommand && (process.argv.includes('--help') || process.argv.includes('-h'))) {
@@ -3858,6 +3858,7 @@ Usage:
   npx cf-memory-mcp list            List recent handoffs for cwd (status-ranked)
   npx cf-memory-mcp history         List all handoffs for cwd, chronological
   npx cf-memory-mcp checkpoint ["<goal>"]  Snapshot current state (keep_open)
+  npx cf-memory-mcp link <child> --parent <id>  Retroactively link a child session to a parent
   npx cf-memory-mcp status          Show bridge state + server resume availability
   npx cf-memory-mcp clean           Delete local disk cache for current cwd
   npx cf-memory-mcp clean --all     Delete ALL local disk caches
@@ -3890,6 +3891,42 @@ For more information, visit: https://github.com/johnlam90/cf-memory-mcp
     process.exit(0);
 }
 
+/**
+ * Pipe a string to the platform clipboard. Returns true on success.
+ * Detects the right command per platform; falls back gracefully when
+ * none are installed. Bounded by a 2s timeout so a hung clipboard
+ * helper can't lock the CLI.
+ */
+function copyToClipboard(text) {
+    const { spawnSync } = require('child_process');
+    let cmd, args;
+    if (process.platform === 'darwin') {
+        cmd = 'pbcopy'; args = [];
+    } else if (process.platform === 'win32') {
+        cmd = 'clip'; args = [];
+    } else {
+        // Linux: try xclip first, then wl-copy (Wayland).
+        const which = spawnSync('which', ['xclip']);
+        if (which.status === 0) {
+            cmd = 'xclip'; args = ['-selection', 'clipboard'];
+        } else {
+            const which2 = spawnSync('which', ['wl-copy']);
+            if (which2.status === 0) {
+                cmd = 'wl-copy'; args = [];
+            } else {
+                return { ok: false, error: 'install xclip or wl-copy to use --copy' };
+            }
+        }
+    }
+    try {
+        const res = spawnSync(cmd, args, { input: text, timeout: 2000 });
+        if (res.status === 0) return { ok: true };
+        return { ok: false, error: `${cmd} exited ${res.status}: ${res.stderr?.toString().slice(0, 200) || ''}` };
+    } catch (err) {
+        return { ok: false, error: `${cmd} failed: ${err.message}` };
+    }
+}
+
 // Parse positional + flag args for CLI subcommands. Returns
 // { positional: string[], flags: { json, limit, md_path, older_than_days, status, repo_path, yes } }.
 function parseCliArgs(rest) {
@@ -3926,6 +3963,10 @@ function parseCliArgs(rest) {
             flags.validate = true;
         } else if (a === '--raw') {
             flags.raw = true;
+        } else if (a === '--copy') {
+            flags.copy = true;
+        } else if (a === '--card') {
+            flags.card = true;
         } else if (a === '--older-than') {
             // Accept "7d" / "30d" / "12h" / raw number (days).
             const raw = rest[++i] || '';
@@ -4088,6 +4129,24 @@ async function runResumeCli() {
             process.exit(0);
         }
 
+        // --card: compact 2-3 line summary card for status widgets.
+        // Format: [status · age · q=score] goal / → next_step
+        if (flags.card) {
+            const envelope = payload.resume_handoff;
+            if (!envelope) process.exit(3);
+            const h = envelope.handoff || {};
+            const ageMin = envelope.handoff_age_minutes;
+            const fmtAge = (m) => m == null ? '?' : m < 60 ? `${m}m` : m < 1440 ? `${Math.round(m/60)}h` : `${Math.round(m/1440)}d`;
+            const status = h.status || '?';
+            const q = typeof envelope.quality_score === 'number' ? ` · q=${envelope.quality_score}` : '';
+            const staleMarker = envelope.stale ? ' · STALE' : '';
+            process.stdout.write(`[${status} · ${fmtAge(ageMin)} ago${q}${staleMarker}]\n`);
+            process.stdout.write(`${h.goal || '(no goal)'}\n`);
+            const next = h.next_steps?.[0];
+            if (next) process.stdout.write(`→ ${next}\n`);
+            process.exit(0);
+        }
+
         // --chain: walk parent_session_id back through the thread history.
         // Bounded at 20 iterations to avoid an infinite loop on malformed
         // data. Prints each handoff as "<id> [age] status — goal".
@@ -4205,6 +4264,19 @@ async function runResumeCli() {
             }
         }
 
+        // --copy: pipe rendered markdown to platform clipboard. Quick
+        // paste into another chat client or doc tool.
+        if (found && flags.copy && payload.resume_prompt) {
+            const result = copyToClipboard(payload.resume_prompt);
+            if (result.ok) {
+                process.stdout.write(`Copied ${payload.resume_prompt.length} chars to clipboard.\n`);
+                process.exit(0);
+            } else {
+                process.stderr.write(`Failed to copy to clipboard: ${result.error}\n`);
+                process.exit(1);
+            }
+        }
+
         if (flags.json) {
             process.stdout.write(JSON.stringify(payload, null, 2) + '\n');
             process.exit(found ? 0 : 3);
@@ -4332,6 +4404,95 @@ async function runListCli() {
     }
 }
 
+async function runLinkCli() {
+    if (!API_KEY) {
+        console.error('Error: CF_MEMORY_API_KEY environment variable is required');
+        process.exit(1);
+    }
+    const { positional, flags } = parseCliArgs(process.argv.slice(3));
+    const childArg = positional[0];
+    // --parent <id> is parsed positionally too; grab it from process.argv.
+    let parentId = null;
+    const parentIdx = process.argv.indexOf('--parent');
+    if (parentIdx !== -1 && process.argv[parentIdx + 1]) parentId = process.argv[parentIdx + 1];
+    for (const a of process.argv) {
+        if (a.startsWith('--parent=')) parentId = a.slice('--parent='.length);
+    }
+    if (!childArg || !parentId) {
+        console.error('Usage: cf-memory-mcp link <child-id-or-prefix> --parent <parent-id-or-prefix>');
+        process.exit(1);
+    }
+    const server = new CFMemoryMCP();
+    server.logDebug = () => {};
+    try {
+        // Resolve child + parent prefixes to full UUIDs via get_context_bootstrap.
+        const resolveId = async (idHint) => {
+            if (idHint.length >= 36) return idHint;
+            const r = await server.makeRequest({
+                jsonrpc: '2.0', id: `cli-link-resolve-${Date.now()}`,
+                method: 'tools/call',
+                params: { name: 'get_context_bootstrap', arguments: { resume: true, session_id_hint: idHint } },
+            });
+            const t = r?.result?.content?.[0]?.text;
+            const p = JSON.parse(t || '{}');
+            return p.resume_handoff?.session_id || null;
+        };
+        const fullChild = await resolveId(childArg);
+        const fullParent = await resolveId(parentId);
+        if (!fullChild) {
+            process.stderr.write(`Could not resolve child "${childArg}" to a session.\n`);
+            process.exit(3);
+        }
+        if (!fullParent) {
+            process.stderr.write(`Could not resolve parent "${parentId}" to a session.\n`);
+            process.exit(3);
+        }
+        // Fetch current child handoff, set parent_session_id, write back via end_session keep_open.
+        const childRes = await server.makeRequest({
+            jsonrpc: '2.0', id: `cli-link-fetch-${Date.now()}`,
+            method: 'tools/call',
+            params: { name: 'get_context_bootstrap', arguments: { resume: true, session_id_hint: fullChild } },
+        });
+        const childText = childRes?.result?.content?.[0]?.text;
+        const childPayload = JSON.parse(childText || '{}');
+        const handoff = childPayload.resume_handoff?.handoff;
+        if (!handoff) {
+            process.stderr.write(`Child session has no handoff stored; cannot link.\n`);
+            process.exit(3);
+        }
+        // Update with parent_session_id.
+        const updated = { ...handoff, parent_session_id: fullParent };
+        const updateRes = await server.makeRequest({
+            jsonrpc: '2.0', id: `cli-link-update-${Date.now()}`,
+            method: 'tools/call',
+            params: { name: 'end_session', arguments: {
+                session_id: fullChild,
+                keep_open: true, // don't accidentally finalize
+                handoff: updated,
+            } },
+        });
+        const updateText = updateRes?.result?.content?.[0]?.text;
+        const updatePayload = JSON.parse(updateText || '{}');
+        if (flags.json) {
+            process.stdout.write(JSON.stringify({
+                child: fullChild,
+                parent: fullParent,
+                handoff_stored: !!updatePayload.handoff_stored,
+            }, null, 2) + '\n');
+            process.exit(updatePayload.handoff_stored ? 0 : 2);
+        }
+        if (updatePayload.handoff_stored) {
+            process.stdout.write(`Linked ${fullChild.slice(0,8)} → parent ${fullParent.slice(0,8)}\n`);
+            process.exit(0);
+        }
+        process.stderr.write(`Update failed: ${updateText}\n`);
+        process.exit(2);
+    } catch (err) {
+        console.error('link command failed:', err.message);
+        process.exit(1);
+    }
+}
+
 async function runHistoryCli() {
     if (!API_KEY) {
         console.error('Error: CF_MEMORY_API_KEY environment variable is required');
@@ -4589,7 +4750,7 @@ function runEnvCli() {
 
 function runCompletionCli() {
     const shell = process.argv[3] || 'bash';
-    const commands = ['resume', 'list', 'history', 'checkpoint', 'status', 'clean', 'export', 'import', 'delete', 'doctor', 'env', 'completion'];
+    const commands = ['resume', 'list', 'history', 'checkpoint', 'link', 'status', 'clean', 'export', 'import', 'delete', 'doctor', 'env', 'completion'];
     const flags = ['--json', '-j', '--limit', '-n', '--md', '--all', '--force', '-f', '--version', '-v', '--help', '-h', '--diagnose'];
     if (shell === 'bash') {
         process.stdout.write(`# cf-memory-mcp bash completion
@@ -4679,6 +4840,8 @@ const PER_COMMAND_HELP = {
   Print the prior resume handoff (markdown by default).
     <session-id-prefix>   Optional: pick a specific session (>=8 char prefix or full UUID).
     --md <path>           Write the markdown to a file instead of stdout.
+    --copy                Pipe the markdown to the platform clipboard (pbcopy/xclip/wl-copy/clip).
+    --card                Compact 2-3 line status card (for terminal status widgets).
   Extract flags (pick one; each exits 3 if the section is empty):
     --next-only           First next_step only (for shell prompts).
     --next-steps          All next_steps, numbered.
@@ -4754,6 +4917,11 @@ const PER_COMMAND_HELP = {
     --repo PATH           Override the cwd's repo.
     --since ISO           Lower bound on handoff timestamp.
     --json, -j            Emit JSON.`,
+    link: `cf-memory-mcp link <child-id-or-prefix> --parent <parent-id-or-prefix> [--json]
+  Retroactively set parent_session_id on a child session, linking it to
+  a parent in the chain. Useful when you forgot --force on checkpoint
+  or want to manually chain sessions across repos.
+    --json, -j            Emit a JSON status object.`,
 };
 
 function printPerCommandHelp(cmd) {
@@ -5362,6 +5530,11 @@ if (process.argv[2] === 'history') {
     return;
 }
 
+if (process.argv[2] === 'link') {
+    runLinkCli();
+    return;
+}
+
 if (process.argv.includes('--diagnose')) {
     (async () => {
         console.log(`CF Memory MCP v${PACKAGE_VERSION} - Diagnostics`);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cf-memory-mcp",
-	"version": "3.41.0",
+	"version": "3.43.0",
 	"description": "Cloudflare-hosted MCP server for code indexing, retrieval, and assistant memory with a direct remote MCP endpoint and local stdio bridge.",
 	"main": "bin/cf-memory-mcp.js",
 	"bin": {