cf-memory-mcp 3.43.0 → 3.45.0

package/bin/cf-memory-mcp.js

@@ -3967,6 +3967,12 @@ function parseCliArgs(rest) {
             flags.copy = true;
         } else if (a === '--card') {
             flags.card = true;
+        } else if (a === '--short') {
+            flags.short = true;
+        } else if (a === '--age') {
+            flags.age = true;
+        } else if (a === '--quality') {
+            flags.quality = true;
         } else if (a === '--older-than') {
             // Accept "7d" / "30d" / "12h" / raw number (days).
             const raw = rest[++i] || '';
@@ -4129,6 +4135,35 @@ async function runResumeCli() {
             process.exit(0);
         }
 
+        // --age: print just handoff_age_minutes (single integer).
+        if (flags.age) {
+            const ageMin = payload.resume_handoff?.handoff_age_minutes;
+            if (typeof ageMin !== 'number') process.exit(3);
+            process.stdout.write(String(ageMin) + '\n');
+            process.exit(0);
+        }
+
+        // --quality: print just quality_score (single float).
+        if (flags.quality) {
+            const q = payload.resume_handoff?.quality_score;
+            if (typeof q !== 'number') process.exit(3);
+            process.stdout.write(String(q) + '\n');
+            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) {
@@ -4750,10 +4785,41 @@ function runEnvCli() {
 
 function runCompletionCli() {
     const shell = process.argv[3] || 'bash';
+    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() {
@@ -4775,7 +4841,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
@@ -4796,7 +4862,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 {
@@ -4816,7 +4882,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')}
@@ -4831,6 +4897,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);
 }
 
@@ -4852,6 +4943,8 @@ const PER_COMMAND_HELP = {
     --chain               Walk parent_session_id back; show the thread history.
     --validate            Check that files_touched + code_anchors still exist locally.
     --raw                 Print just the raw handoff JSON (no envelope metadata).
+    --age                 Print handoff_age_minutes (single integer).
+    --quality             Print quality_score (single float, 0-1).
     --json, -j            Full bootstrap payload as JSON.
   Exit codes: 0 = found, 3 = no handoff / no data, 4 = --validate found missing files.`,
     list: `cf-memory-mcp list [--status S] [--since ISO] [--repo PATH] [--limit N] [--json]
@@ -4879,10 +4972,13 @@ const PER_COMMAND_HELP = {
     --all                 Delete ALL cf-memory disk caches.
     --json, -j            Emit a JSON list of removed paths.`,
     export: `cf-memory-mcp export <session-id-or-prefix> [--md path]
+  cf-memory-mcp export --all
   Print a handoff as a JSON bundle to stdout (or write to file). For
-  backup or cross-machine sync.
+  backup or cross-machine sync. With --all, streams ALL handoffs as
+  NDJSON (one bundle per line) suitable for piping to a file.
     <session-id>          Full UUID or short prefix (>=8 chars).
-    --md <path>           Write the JSON to a file.`,
+    --md <path>           Write the JSON to a file (single-handoff mode).
+    --all                 Stream all handoffs as NDJSON.`,
     import: `cf-memory-mcp import [<file>|-] [--json]
   Restore a handoff bundle into a NEW session (keep_open). Cross-machine
   sync. Use "-" to read from stdin.
@@ -5060,12 +5156,91 @@ async function runExportCli() {
     }
     const { positional, flags } = parseCliArgs(process.argv.slice(3));
     const sessionArg = positional[0];
-    if (!sessionArg) {
-        console.error('Usage: cf-memory-mcp export <session-id-or-prefix> [--md path]');
+    const exportAll = process.argv.includes('--all');
+    if (!sessionArg && !exportAll) {
+        console.error('Usage:');
+        console.error('  cf-memory-mcp export <session-id-or-prefix>  # single handoff bundle');
+        console.error('  cf-memory-mcp export --all                   # all handoffs as NDJSON');
         process.exit(1);
     }
     const server = new CFMemoryMCP();
     server.logDebug = () => {};
+
+    // --all: stream every handoff as NDJSON (one bundle per line).
+    if (exportAll) {
+        // EPIPE handler: when piping to `head` etc., downstream closes
+        // stdout while we're still writing. Exit cleanly instead of
+        // dumping a Node stack trace.
+        process.stdout.on('error', (err) => {
+            if (err.code === 'EPIPE') process.exit(0);
+            throw err;
+        });
+        try {
+            // Page through all the user's handoffs via get_context_bootstrap
+            // with recent_handoff_limit=50, sorted by recency. Use `since`
+            // to walk back in time without dupes — query for entries before
+            // the oldest one in the previous batch.
+            const seen = new Set();
+            let cursor = null; // ISO timestamp; entries with ended_at|started_at >= cursor are returned
+            let totalEmitted = 0;
+            for (let page = 0; page < 100; page++) {
+                const args = { resume: true, recent_handoff_limit: 50 };
+                const meta = server.getRepoMetadata();
+                if (meta.repo_path) args.repo_path = meta.repo_path;
+                if (cursor) args.since = cursor;
+                const res = await server.makeRequest({
+                    jsonrpc: '2.0', id: `cli-export-all-${page}-${Date.now()}`,
+                    method: 'tools/call',
+                    params: { name: 'get_context_bootstrap', arguments: args },
+                });
+                const text = res?.result?.content?.[0]?.text;
+                const payload = JSON.parse(text || '{}');
+                const handoffs = payload.recent_handoffs || [];
+                if (handoffs.length === 0) break;
+                let newCount = 0;
+                let oldestSeen = null;
+                for (const h of handoffs) {
+                    if (seen.has(h.session_id)) continue;
+                    seen.add(h.session_id);
+                    // Fetch the full handoff (not just the summary).
+                    const fullRes = await server.makeRequest({
+                        jsonrpc: '2.0', id: `cli-export-all-detail-${Date.now()}`,
+                        method: 'tools/call',
+                        params: { name: 'get_context_bootstrap', arguments: { resume: true, session_id_hint: h.session_id } },
+                    });
+                    const fullText = fullRes?.result?.content?.[0]?.text;
+                    const fullPayload = JSON.parse(fullText || '{}');
+                    const envelope = fullPayload.resume_handoff;
+                    if (!envelope) continue;
+                    const bundle = {
+                        kind: 'cf-memory-handoff',
+                        version: 1,
+                        exported_at: new Date().toISOString(),
+                        session_id: envelope.session_id,
+                        started_at: envelope.started_at,
+                        ended_at: envelope.ended_at,
+                        handoff: envelope.handoff,
+                    };
+                    process.stdout.write(JSON.stringify(bundle) + '\n');
+                    totalEmitted++;
+                    newCount++;
+                    const t = envelope.ended_at || envelope.started_at;
+                    if (!oldestSeen || t > oldestSeen) oldestSeen = t;
+                }
+                // No new entries → we've exhausted the timeline.
+                if (newCount === 0) break;
+                // Step the cursor forward (next page returns entries from
+                // after the oldest we saw).
+                cursor = oldestSeen;
+            }
+            process.stderr.write(`Exported ${totalEmitted} handoffs.\n`);
+            process.exit(totalEmitted === 0 ? 3 : 0);
+        } catch (err) {
+            console.error('export --all failed:', err.message);
+            process.exit(1);
+        }
+        return;
+    }
     try {
         const args = { resume: true, session_id_hint: sessionArg };
         const response = await server.makeRequest({

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cf-memory-mcp",
-	"version": "3.43.0",
+	"version": "3.45.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": {