cf-memory-mcp 3.48.0 → 3.50.0

package/bin/cf-memory-mcp.js

@@ -4061,6 +4061,10 @@ function parseCliArgs(rest) {
             flags.fields = rest[++i];
         } else if (a.startsWith('--fields=')) {
             flags.fields = a.slice('--fields='.length);
+        } else if (a === '--diff') {
+            flags.diff = rest[++i];
+        } else if (a.startsWith('--diff=')) {
+            flags.diff = a.slice('--diff='.length);
         } else if (a === '--older-than') {
             // Accept "7d" / "30d" / "12h" / raw number (days).
             const raw = rest[++i] || '';
@@ -4392,6 +4396,78 @@ async function runResumeCli() {
             process.exit(0);
         }
 
+        // --diff <other-id>: compare two handoffs. Shows added/removed
+        // next_steps, branch shift, status change, files diff. Useful
+        // for "what changed between yesterday's session and today's?".
+        // Special value "--parent" diffs against the chain parent.
+        if (flags.diff) {
+            if (!found) {
+                process.stderr.write('No source handoff available to diff against.\n');
+                process.exit(3);
+            }
+            let diffTarget = flags.diff;
+            // --diff --parent: resolve to the parent_session_id from the
+            // current handoff so users can do "what's new since the
+            // last checkpoint" without typing the parent's id.
+            if (diffTarget === '--parent' || diffTarget === 'parent') {
+                const parentId = payload.resume_handoff.handoff?.parent_session_id;
+                if (!parentId) {
+                    process.stderr.write('This handoff has no parent_session_id to diff against.\n');
+                    process.exit(3);
+                }
+                diffTarget = parentId;
+            }
+            const otherRes = await server.makeRequest({
+                jsonrpc: '2.0', id: `cli-diff-${Date.now()}`,
+                method: 'tools/call',
+                params: { name: 'get_context_bootstrap', arguments: { resume: true, session_id_hint: diffTarget } },
+            });
+            const otherText = otherRes?.result?.content?.[0]?.text;
+            const otherPayload = JSON.parse(otherText || '{}');
+            const otherHandoff = otherPayload.resume_handoff?.handoff;
+            if (!otherHandoff) {
+                process.stderr.write(`Could not fetch handoff "${diffTarget}" to diff against.\n`);
+                process.exit(3);
+            }
+            const h = payload.resume_handoff.handoff;
+            const setOf = (arr, key) =>
+                new Set((arr || []).map(x => typeof x === 'string' ? x : x[key]).filter(Boolean));
+            const diffArr = (label, a, b, key) => {
+                const A = setOf(a, key); const B = setOf(b, key);
+                const added = [...A].filter(x => !B.has(x));
+                const removed = [...B].filter(x => !A.has(x));
+                const lines = [];
+                if (added.length) lines.push(`  + ${label}: ${added.join(', ')}`);
+                if (removed.length) lines.push(`  - ${label}: ${removed.join(', ')}`);
+                return lines.join('\n');
+            };
+
+            const aShort = (payload.resume_handoff.session_id || '').slice(0, 8);
+            const bShort = (otherPayload.resume_handoff.session_id || '').slice(0, 8);
+            const lines = [`Diff: ${aShort} (this) vs ${bShort} (other)`, ''];
+            // Scalar fields
+            const scalars = ['goal', 'status', 'branch', 'repo_path'];
+            for (const f of scalars) {
+                if (h[f] !== otherHandoff[f]) {
+                    lines.push(`  ~ ${f}: "${otherHandoff[f] || ''}" → "${h[f] || ''}"`);
+                }
+            }
+            // Array fields
+            const arrDiff = diffArr('next_steps', h.next_steps, otherHandoff.next_steps);
+            if (arrDiff) lines.push(arrDiff);
+            const blockerDiff = diffArr('blockers', h.blockers, otherHandoff.blockers);
+            if (blockerDiff) lines.push(blockerDiff);
+            const decisionDiff = diffArr('decisions', h.decisions, otherHandoff.decisions);
+            if (decisionDiff) lines.push(decisionDiff);
+            const fileDiff = diffArr('files_touched', h.files_touched, otherHandoff.files_touched, 'path');
+            if (fileDiff) lines.push(fileDiff);
+            const anchorDiff = diffArr('code_anchors', h.code_anchors, otherHandoff.code_anchors, 'file_path');
+            if (anchorDiff) lines.push(anchorDiff);
+            if (lines.length === 2) lines.push('  (no differences)');
+            process.stdout.write(lines.join('\n') + '\n');
+            process.exit(0);
+        }
+
         // --validate: verify the handoff's file references still exist
         // on disk. Resolves each path relative to the handoff's repo_path
         // (or cwd). Reports per-path status. Useful before resuming to
@@ -5098,6 +5174,7 @@ const PER_COMMAND_HELP = {
     --decisions-only      decisions, one per line.
     --blockers-only       open blockers, one per line.
     --chain               Walk parent_session_id back; show the thread history.
+    --diff <other-id>     Compare this handoff against another (added/removed/changed fields).
     --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).
@@ -5295,8 +5372,25 @@ async function runDoctorCli() {
         }
     }
 
+    // Optional: handoff stats summary at the bottom (visibility into
+    // how much resume context is captured for the current user).
+    let handoffStats = null;
+    if (API_KEY) {
+        try {
+            const statsRes = await server.makeRequestOnce({
+                jsonrpc: '2.0', id: `doctor-stats-${Date.now()}`,
+                method: 'tools/call', params: { name: 'get_stats', arguments: {} },
+            });
+            const statsText = statsRes?.result?.content?.[0]?.text;
+            if (statsText) {
+                const statsPayload = JSON.parse(statsText);
+                if (statsPayload?.handoffs) handoffStats = statsPayload.handoffs;
+            }
+        } catch (_) { /* skip on failure */ }
+    }
+
     if (flags.json) {
-        process.stdout.write(JSON.stringify({ checks }, null, 2) + '\n');
+        process.stdout.write(JSON.stringify({ checks, ...(handoffStats ? { handoffs: handoffStats } : {}) }, null, 2) + '\n');
         process.exit(checks.every(c => c.ok) ? 0 : 1);
     }
     process.stdout.write(`cf-memory-mcp v${PACKAGE_VERSION} — doctor\n\n`);
@@ -5309,6 +5403,23 @@ async function runDoctorCli() {
             process.stdout.write(`      → ${c.fix}\n`);
         }
     }
+    if (handoffStats) {
+        process.stdout.write('\nHandoff stats:\n');
+        process.stdout.write(`  total:              ${handoffStats.total}\n`);
+        if (handoffStats.by_status) {
+            const byStatus = Object.entries(handoffStats.by_status)
+                .map(([s, n]) => `${s}=${n}`).join(', ');
+            process.stdout.write(`  by_status:          ${byStatus}\n`);
+        }
+        if (handoffStats.oldest_in_progress) {
+            const o = handoffStats.oldest_in_progress;
+            const shortId = (o.session_id || '').slice(0, 8);
+            process.stdout.write(`  oldest in_progress: ${shortId} (${o.age_minutes}m ago)\n`);
+        }
+        if (handoffStats.by_repo && handoffStats.by_repo.length > 0) {
+            process.stdout.write(`  top repos:          ${handoffStats.by_repo.slice(0, 3).map(r => `${r.repo_path.split('/').pop()}=${r.count}`).join(', ')}\n`);
+        }
+    }
     process.stdout.write('\n');
     process.stdout.write(anyFailed ? 'Some checks failed. See suggestions above.\n' : 'All checks passed.\n');
     process.exit(anyFailed ? 1 : 0);

package/package.json

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