cf-memory-mcp 3.54.0 → 3.56.0

package/bin/cf-memory-mcp.js

@@ -4038,6 +4038,12 @@ function parseCliArgs(rest) {
             flags.blockers_only = true;
         } else if (a === '--chain') {
             flags.chain = true;
+        } else if (a === '--include-chain') {
+            const n = parseInt(rest[++i], 10);
+            flags.include_chain = Number.isFinite(n) && n > 0 ? Math.min(n, 10) : 3;
+        } else if (a.startsWith('--include-chain=')) {
+            const n = parseInt(a.slice('--include-chain='.length), 10);
+            flags.include_chain = Number.isFinite(n) && n > 0 ? Math.min(n, 10) : 3;
         } else if (a === '--validate') {
             flags.validate = true;
         } else if (a === '--raw') {
@@ -4474,25 +4480,54 @@ async function runResumeCli() {
 
             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) {
+
+            // Build a structured diff first; render either as JSON or
+            // as the human-readable +/- output.
+            const scalarDiff = {};
+            for (const f of ['goal', 'status', 'branch', 'repo_path']) {
                 if (h[f] !== otherHandoff[f]) {
-                    lines.push(`  ~ ${f}: "${otherHandoff[f] || ''}" → "${h[f] || ''}"`);
+                    scalarDiff[f] = { from: otherHandoff[f] ?? null, to: h[f] ?? null };
                 }
             }
-            // 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);
+            const arrayDiffObj = (a, b, key) => {
+                const A = setOf(a, key); const B = setOf(b, key);
+                return {
+                    added: [...A].filter(x => !B.has(x)),
+                    removed: [...B].filter(x => !A.has(x)),
+                };
+            };
+            const arrayDiffs = {
+                next_steps: arrayDiffObj(h.next_steps, otherHandoff.next_steps),
+                blockers: arrayDiffObj(h.blockers, otherHandoff.blockers),
+                decisions: arrayDiffObj(h.decisions, otherHandoff.decisions),
+                files_touched: arrayDiffObj(h.files_touched, otherHandoff.files_touched, 'path'),
+                code_anchors: arrayDiffObj(h.code_anchors, otherHandoff.code_anchors, 'file_path'),
+            };
+
+            if (flags.json) {
+                // Strip empty arrays from arrayDiffs for compactness.
+                const compactArrays = Object.fromEntries(
+                    Object.entries(arrayDiffs)
+                        .filter(([, v]) => v.added.length > 0 || v.removed.length > 0)
+                );
+                process.stdout.write(JSON.stringify({
+                    this: payload.resume_handoff.session_id,
+                    other: otherPayload.resume_handoff.session_id,
+                    scalars: scalarDiff,
+                    arrays: compactArrays,
+                    unchanged: Object.keys(scalarDiff).length === 0 && Object.keys(compactArrays).length === 0,
+                }, null, 2) + '\n');
+                process.exit(0);
+            }
+
+            const lines = [`Diff: ${aShort} (this) vs ${bShort} (other)`, ''];
+            for (const [f, v] of Object.entries(scalarDiff)) {
+                lines.push(`  ~ ${f}: "${v.from || ''}" → "${v.to || ''}"`);
+            }
+            for (const [label, v] of Object.entries(arrayDiffs)) {
+                if (v.added.length > 0) lines.push(`  + ${label}: ${v.added.join(', ')}`);
+                if (v.removed.length > 0) lines.push(`  - ${label}: ${v.removed.join(', ')}`);
+            }
             if (lines.length === 2) lines.push('  (no differences)');
             process.stdout.write(lines.join('\n') + '\n');
             process.exit(0);
@@ -4585,6 +4620,32 @@ async function runResumeCli() {
             } else {
                 process.stdout.write(JSON.stringify(payload.resume_handoff, null, 2) + '\n');
             }
+            // --include-chain N: walk parent_session_id back N times and
+            // append each parent's resume_prompt inline so the agent sees
+            // the full thread arc in one output.
+            if (flags.include_chain && flags.include_chain > 0) {
+                let cur = payload.resume_handoff;
+                for (let i = 0; i < flags.include_chain; i++) {
+                    const parentId = cur?.handoff?.parent_session_id;
+                    if (!parentId) break;
+                    const parentRes = await server.makeRequest({
+                        jsonrpc: '2.0', id: `cli-include-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;
+                    process.stdout.write(`\n---\n## ↑ Parent ${i + 1}: ${(parentPayload.resume_handoff.session_id||'').slice(0,8)}\n\n`);
+                    if (parentPayload.resume_prompt) {
+                        // Strip the parent's own "## Resume context" header
+                        // to avoid duplicated h2s.
+                        const cleaned = parentPayload.resume_prompt.replace(/^## Resume context from previous session\n+/, '');
+                        process.stdout.write(cleaned + '\n');
+                    }
+                    cur = parentPayload.resume_handoff;
+                }
+            }
             if (Array.isArray(payload.recent_handoffs) && payload.recent_handoffs.length > 1) {
                 process.stdout.write('\n---\nOther recent handoffs:\n');
                 for (const h of payload.recent_handoffs.slice(0, 4)) {
@@ -5362,6 +5423,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.
+    --include-chain N     Inline the last N parent handoffs in the rendered output (default 3, max 10).
     --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).

package/package.json

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