cf-memory-mcp 3.42.0 → 3.44.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
@@ -3964,6 +3965,10 @@ function parseCliArgs(rest) {
             flags.raw = true;
         } else if (a === '--copy') {
             flags.copy = true;
+        } else if (a === '--card') {
+            flags.card = true;
+        } else if (a === '--short') {
+            flags.short = true;
         } else if (a === '--older-than') {
             // Accept "7d" / "30d" / "12h" / raw number (days).
             const raw = rest[++i] || '';
@@ -4126,6 +4131,37 @@ async function runResumeCli() {
             process.exit(0);
         }
 
+        // --short: single line for tmux/status bars. "goal · status"
+        // truncated to terminal-friendly length.
+        if (flags.short) {
+            const envelope = payload.resume_handoff;
+            if (!envelope) process.exit(3);
+            const h = envelope.handoff || {};
+            const goal = (h.goal || '(no goal)').slice(0, 60);
+            const status = h.status || '?';
+            const stale = envelope.stale ? ' [STALE]' : '';
+            process.stdout.write(`${goal} · ${status}${stale}\n`);
+            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".
@@ -4383,6 +4419,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');
@@ -4640,10 +4765,41 @@ 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 install = process.argv.includes('--install');
+    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'];
+
+    // Determine the install target for each shell. Use user-local paths
+    // only (no sudo). Caller can override via stdout-redirect when
+    // --install isn't used.
+    const installTarget = (() => {
+        const home = os.homedir();
+        if (shell === 'bash') {
+            // Prefer ~/.bash_completion.d/ if it exists; fall back to ~/.bash_completion.
+            const dir = path.join(home, '.bash_completion.d');
+            return fs.existsSync(dir) ? path.join(dir, 'cf-memory-mcp') : path.join(home, '.bash_completion');
+        }
+        if (shell === 'zsh') {
+            // Honor $ZSH_CUSTOM/plugins or ~/.zsh/completions/
+            const zdir = process.env.ZSH_CUSTOM
+                ? path.join(process.env.ZSH_CUSTOM, 'plugins', 'cf-memory-mcp')
+                : path.join(home, '.zsh', 'completions');
+            return path.join(zdir, '_cf-memory-mcp');
+        }
+        if (shell === 'fish') {
+            return path.join(home, '.config', 'fish', 'completions', 'cf-memory-mcp.fish');
+        }
+        if (shell === 'powershell' || shell === 'pwsh') {
+            return path.join(home, '.config', 'powershell', 'cf-memory-mcp.ps1');
+        }
+        return null;
+    })();
+    // Buffer the output so we can either print or write-to-disk.
+    let output = '';
+    const emit = (chunk) => { output += chunk; };
+
     if (shell === 'bash') {
-        process.stdout.write(`# cf-memory-mcp bash completion
+        emit(`# cf-memory-mcp bash completion
 # Install: cf-memory-mcp completion bash > /usr/local/etc/bash_completion.d/cf-memory-mcp
 # Or for the current shell: source <(cf-memory-mcp completion bash)
 _cf_memory_mcp_complete() {
@@ -4665,7 +4821,7 @@ complete -F _cf_memory_mcp_complete cf-memory-mcp
 complete -F _cf_memory_mcp_complete cfm
 `);
     } else if (shell === 'zsh') {
-        process.stdout.write(`# cf-memory-mcp zsh completion
+        emit(`# cf-memory-mcp zsh completion
 # Install: cf-memory-mcp completion zsh > "\${fpath[1]}/_cf-memory-mcp" && compinit
 # Or for the current shell: source <(cf-memory-mcp completion zsh)
 #compdef cf-memory-mcp cfm
@@ -4686,7 +4842,7 @@ _cf_memory_mcp() {
 _cf_memory_mcp "\$@"
 `);
     } else if (shell === 'powershell' || shell === 'pwsh') {
-        process.stdout.write(`# cf-memory-mcp PowerShell completion
+        emit(`# cf-memory-mcp PowerShell completion
 # Install: cf-memory-mcp completion powershell | Out-String | Invoke-Expression
 # To persist: add the above to your $PROFILE
 Register-ArgumentCompleter -Native -CommandName cf-memory-mcp,cfm -ScriptBlock {
@@ -4706,7 +4862,7 @@ Register-ArgumentCompleter -Native -CommandName cf-memory-mcp,cfm -ScriptBlock {
 }
 `);
     } else if (shell === 'fish') {
-        process.stdout.write(`# cf-memory-mcp fish completion
+        emit(`# cf-memory-mcp fish completion
 # Install: cf-memory-mcp completion fish > ~/.config/fish/completions/cf-memory-mcp.fish
 ${commands.map(c => `complete -c cf-memory-mcp -n '__fish_use_subcommand' -a '${c}' -d '${c} command'`).join('\n')}
 ${commands.map(c => `complete -c cfm -n '__fish_use_subcommand' -a '${c}' -d '${c} command'`).join('\n')}
@@ -4721,6 +4877,31 @@ complete -c cf-memory-mcp -l version -s v -d 'Show version'
         process.stderr.write(`Unknown shell "${shell}". Supported: bash, zsh, fish, powershell.\n`);
         process.exit(1);
     }
+
+    // Either install to a user-local path or print to stdout.
+    if (install) {
+        if (!installTarget) {
+            process.stderr.write(`No install target for shell ${shell}.\n`);
+            process.exit(1);
+        }
+        try {
+            const dir = path.dirname(installTarget);
+            if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+            fs.writeFileSync(installTarget, output);
+            process.stderr.write(`Installed ${shell} completion to ${installTarget}\n`);
+            if (shell === 'bash') {
+                process.stderr.write(`Add to ~/.bashrc to autoload: source ${installTarget}\n`);
+            } else if (shell === 'zsh') {
+                const dirToFpath = path.dirname(installTarget);
+                process.stderr.write(`Add to ~/.zshrc:\n  fpath=(${dirToFpath} $fpath)\n  autoload -Uz compinit && compinit\n`);
+            }
+        } catch (err) {
+            process.stderr.write(`Failed to install: ${err.message}\n`);
+            process.exit(1);
+        }
+    } else {
+        process.stdout.write(output);
+    }
     process.exit(0);
 }
 
@@ -4731,6 +4912,7 @@ const PER_COMMAND_HELP = {
     <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.
@@ -4806,6 +4988,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) {
@@ -5414,6 +5601,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.42.0",
+	"version": "3.44.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": {