cf-memory-mcp 3.36.0 → 3.38.0

package/bin/cf-memory-mcp.js

@@ -66,6 +66,32 @@ const STREAMABLE_HTTP_URL = `${BASE_URL}/mcp`;
 const LEGACY_SERVER_URL = `${BASE_URL}/mcp/message`;
 const PROGRESS_SSE_URL = `${BASE_URL}/api/indexing/progress`;
 const PACKAGE_VERSION = require('../package.json').version;
+
+/**
+ * Fetch the latest version of cf-memory-mcp from the npm registry.
+ * Returns the latest version string, or null on timeout/error.
+ * Used by `doctor` to flag outdated installs. Bounded by timeoutMs
+ * so an unreachable registry doesn't hang the doctor command.
+ */
+function checkLatestNpmVersion(currentVersion, timeoutMs = 1500) {
+    return new Promise((resolve) => {
+        const req = https.get('https://registry.npmjs.org/cf-memory-mcp/latest', {
+            timeout: timeoutMs,
+            headers: { 'Accept': 'application/json', 'User-Agent': `cf-memory-mcp/${currentVersion}` },
+        }, (res) => {
+            let body = '';
+            res.on('data', (chunk) => { body += chunk; });
+            res.on('end', () => {
+                try {
+                    const parsed = JSON.parse(body);
+                    resolve(parsed.version || null);
+                } catch (_) { resolve(null); }
+            });
+        });
+        req.on('error', () => resolve(null));
+        req.on('timeout', () => { req.destroy(); resolve(null); });
+    });
+}
 // Default per-request timeout. Batch uploads use BATCH_TIMEOUT_MS below.
 const TIMEOUT_MS = 60000;
 // Batch uploads can take longer because the worker processes each file
@@ -217,7 +243,8 @@ const TOOLS_LIST = [
                 max_age_minutes: { type: 'number', description: 'Hard cutoff: hide handoffs older than this many minutes. Without it, older handoffs surface with reduced confidence.' },
                 goal_contains: { type: 'string', description: 'Substring filter on handoff content (goal/notes/decisions). Case-insensitive. Lets agents find a specific thread by what it was about.' },
                 since: { type: 'string', description: 'Lower bound on handoff timestamp (ISO 8601). Scope resume to a time window.' },
-                status_filter: { description: 'Restrict matches to handoffs with this status. Single string or array of strings (e.g., ["in_progress","blocked"]).' }
+                status_filter: { description: 'Restrict matches to handoffs with this status. Single string or array of strings (e.g., ["in_progress","blocked"]).' },
+                recent_handoff_limit: { type: 'number', description: 'Override the default recent_handoffs cap (5). Range 1-50.' }
             }
         }
     },
@@ -3806,7 +3833,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']);
+const SUBCOMMANDS = new Set(['resume', 'list', 'checkpoint', 'status', 'clean', 'export', 'import', 'doctor', 'completion', 'delete', 'env', 'history']);
 const hasSubcommand = process.argv[2] && SUBCOMMANDS.has(process.argv[2]);
 
 if (!hasSubcommand && (process.argv.includes('--help') || process.argv.includes('-h'))) {
@@ -3818,7 +3845,8 @@ A portable MCP (Model Context Protocol) server for AI memory storage using Cloud
 Usage:
   npx cf-memory-mcp                 Start the MCP server
   npx cf-memory-mcp resume [id]     Print the prior resume handoff (markdown)
-  npx cf-memory-mcp list            List recent handoffs for cwd
+  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 status          Show bridge state + server resume availability
   npx cf-memory-mcp clean           Delete local disk cache for current cwd
@@ -3882,6 +3910,8 @@ function parseCliArgs(rest) {
             flags.decisions_only = true;
         } else if (a === '--blockers-only') {
             flags.blockers_only = true;
+        } else if (a === '--chain') {
+            flags.chain = true;
         } else if (a === '--older-than') {
             // Accept "7d" / "30d" / "12h" / raw number (days).
             const raw = rest[++i] || '';
@@ -4035,6 +4065,59 @@ async function runResumeCli() {
             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".
+        if (flags.chain) {
+            if (!found) {
+                process.stderr.write('No resume handoff available to walk back from.\n');
+                process.exit(3);
+            }
+            const fmtAge = (iso) => {
+                if (!iso) return '?';
+                const min = Math.round((Date.now() - new Date(iso).getTime()) / 60000);
+                if (min < 60) return `${min}m`;
+                if (min < 1440) return `${Math.round(min/60)}h`;
+                return `${Math.round(min/1440)}d`;
+            };
+            const chain = [];
+            let cur = payload.resume_handoff;
+            chain.push(cur);
+            for (let i = 0; i < 20; i++) {
+                const parentId = cur?.handoff?.parent_session_id;
+                if (!parentId) break;
+                // Fetch parent
+                const parentRes = await server.makeRequest({
+                    jsonrpc: '2.0', id: `cli-chain-${i}-${Date.now()}`,
+                    method: 'tools/call',
+                    params: { name: 'get_context_bootstrap', arguments: { resume: true, session_id_hint: parentId } },
+                });
+                const parentText = parentRes?.result?.content?.[0]?.text;
+                const parentPayload = JSON.parse(parentText || '{}');
+                if (!parentPayload.resume_handoff) break;
+                chain.push(parentPayload.resume_handoff);
+                cur = parentPayload.resume_handoff;
+            }
+            if (flags.json) {
+                process.stdout.write(JSON.stringify({ chain }, null, 2) + '\n');
+                process.exit(0);
+            }
+            process.stdout.write(`Thread chain (newest first, ${chain.length} session${chain.length === 1 ? '' : 's'}):\n\n`);
+            for (let i = 0; i < chain.length; i++) {
+                const e = chain[i];
+                const shortId = (e.session_id || '').slice(0, 8);
+                const age = fmtAge(e.ended_at || e.started_at);
+                const status = e.handoff?.status || '?';
+                const goal = e.handoff?.goal || '(no goal)';
+                const prefix = i === 0 ? '→' : ' ';
+                process.stdout.write(`${prefix} ${shortId}  ${status.padEnd(11)}  ${age.padStart(4)} ago  ${goal}\n`);
+            }
+            if (chain[chain.length-1]?.handoff?.parent_session_id) {
+                process.stdout.write(`\n(chain truncated at 20 — increase with multiple --chain calls)\n`);
+            }
+            process.exit(0);
+        }
+
         // --md <path>: write the rendered markdown to a file instead of
         // (or in addition to) stdout. Useful for piping to a markdown
         // viewer or saving to the project.
@@ -4175,6 +4258,71 @@ async function runListCli() {
     }
 }
 
+async function runHistoryCli() {
+    if (!API_KEY) {
+        console.error('Error: CF_MEMORY_API_KEY environment variable is required');
+        process.exit(1);
+    }
+    const { flags } = parseCliArgs(process.argv.slice(3));
+    const limit = flags.limit || 25;
+    const server = new CFMemoryMCP();
+    server.logDebug = () => {};
+    try {
+        const meta = server.getRepoMetadata();
+        const args = { resume: true, recent_handoff_limit: limit };
+        if (meta.repo_path) args.repo_path = meta.repo_path;
+        if (meta.branch) args.branch = meta.branch;
+        if (flags.repo_path) args.repo_path = flags.repo_path;
+        if (flags.since) args.since = flags.since;
+        if (!flags.repo_path) {
+            const fake = { params: { name: 'retrieve_context', arguments: {} } };
+            await server.maybeFillProjectId(fake);
+            if (fake.params.arguments.project_id) args.project_id = fake.params.arguments.project_id;
+        }
+
+        const response = await server.makeRequest({
+            jsonrpc: '2.0',
+            id: `cli-history-${Date.now()}`,
+            method: 'tools/call',
+            params: { name: 'get_context_bootstrap', arguments: args },
+        });
+        const text = response?.result?.content?.[0]?.text;
+        const payload = JSON.parse(text || '{}');
+        const all = (payload.recent_handoffs || []).slice();
+        // Chronological order (oldest first).
+        all.sort((a, b) => {
+            const ta = new Date(a.ended_at || a.started_at).getTime();
+            const tb = new Date(b.ended_at || b.started_at).getTime();
+            return ta - tb;
+        });
+        if (flags.json) {
+            process.stdout.write(JSON.stringify({
+                repo_path: args.repo_path,
+                count: all.length,
+                handoffs: all,
+            }, null, 2) + '\n');
+            process.exit(all.length === 0 ? 3 : 0);
+        }
+        if (all.length === 0) {
+            process.stderr.write((payload.empty_hint || 'No handoffs for this context.') + '\n');
+            process.exit(3);
+        }
+        const fmtDate = (iso) => iso ? new Date(iso).toISOString().slice(0, 16).replace('T', ' ') : '?';
+        process.stdout.write(`History for ${args.repo_path || 'this cwd'} (${all.length} handoff${all.length === 1 ? '' : 's'}, oldest first):\n\n`);
+        for (const h of all) {
+            const shortId = (h.session_id || '').slice(0, 8);
+            const when = fmtDate(h.ended_at || h.started_at);
+            const status = (h.status || 'unknown').padEnd(11);
+            const goal = (h.goal || '(no goal)').slice(0, 70);
+            process.stdout.write(`  ${when}  ${shortId}  ${status}  ${goal}\n`);
+        }
+        process.exit(0);
+    } catch (err) {
+        console.error('history command failed:', err.message);
+        process.exit(1);
+    }
+}
+
 async function runDeleteCli() {
     if (!API_KEY) {
         console.error('Error: CF_MEMORY_API_KEY environment variable is required');
@@ -4367,7 +4515,7 @@ function runEnvCli() {
 
 function runCompletionCli() {
     const shell = process.argv[3] || 'bash';
-    const commands = ['resume', 'list', 'checkpoint', 'status', 'clean', 'export', 'import', 'delete', 'doctor', 'env', 'completion'];
+    const commands = ['resume', 'list', 'history', 'checkpoint', '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
@@ -4501,6 +4649,14 @@ const PER_COMMAND_HELP = {
   Print all CF_MEMORY_* env vars the bridge reads, with their current
   values + descriptions. Useful for discovering knobs.
     --json, -j            Emit JSON for scripts.`,
+    history: `cf-memory-mcp history [--limit N] [--repo PATH] [--since ISO] [--json]
+  Print all handoffs for the current cwd in chronological order (oldest
+  first). Unlike 'list' (status-ranked, default 5), this is a flat
+  timeline view.
+    --limit N             Max number of handoffs (default 25, max 50).
+    --repo PATH           Override the cwd's repo.
+    --since ISO           Lower bound on handoff timestamp.
+    --json, -j            Emit JSON.`,
 };
 
 function printPerCommandHelp(cmd) {
@@ -4518,6 +4674,20 @@ async function runDoctorCli() {
     const checks = [];
     const add = (label, ok, detail, fix) => checks.push({ label, ok, detail, ...(fix && !ok ? { fix } : {}) });
 
+    // 0. Installed vs latest npm version. Best-effort: skipped on
+    // network failure or when registry is unreachable. Doesn't add to
+    // exit-code failures so doctor still passes if you're just behind.
+    try {
+        const latest = await checkLatestNpmVersion(PACKAGE_VERSION, 1500);
+        if (latest && latest !== PACKAGE_VERSION) {
+            add(`npm version current`, false,
+                `installed v${PACKAGE_VERSION}, latest v${latest}`,
+                `npm install -g cf-memory-mcp@latest  # or: npx cf-memory-mcp@${latest}`);
+        } else if (latest) {
+            add(`npm version current`, true, `v${PACKAGE_VERSION} (latest)`);
+        }
+    } catch (_) { /* network failure or registry timeout — skip */ }
+
     // 1. API key set?
     add('CF_MEMORY_API_KEY set', !!API_KEY,
         API_KEY ? '(redacted)' : 'unset — most commands will fail',
@@ -5090,6 +5260,11 @@ if (process.argv[2] === 'env') {
     return;
 }
 
+if (process.argv[2] === 'history') {
+    runHistoryCli();
+    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.36.0",
+	"version": "3.38.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": {