cf-memory-mcp 3.16.0 → 3.17.0

package/bin/cf-memory-mcp.js

@@ -932,6 +932,7 @@ class CFMemoryMCP {
                 message.params.arguments?.resume) {
                 const cached = this.maybeServePrewarmedResume(message);
                 if (cached) {
+                    this.injectRepoDiffIntoResume(cached);
                     _mcpTrace('RESUME_PREWARM', `served get_context_bootstrap id=${message.id} from cache`);
                     process.stdout.write(JSON.stringify(cached) + '\n');
                     return;
@@ -986,6 +987,16 @@ class CFMemoryMCP {
                 this.cacheImplicitSessionFromResponse(response);
             }
 
+            // Inject bridge-side git diff into resume responses. Lets the
+            // agent see what's changed in the repo since the handoff was
+            // written — files modified, commits added, branch moves —
+            // without having to call git themselves.
+            if (message.method === 'tools/call' &&
+                message.params?.name === 'get_context_bootstrap' &&
+                message.params.arguments?.resume) {
+                this.injectRepoDiffIntoResume(response);
+            }
+
             // Send response to stdout
             process.stdout.write(JSON.stringify(response) + '\n');
 
@@ -2502,6 +2513,97 @@ class CFMemoryMCP {
         }
     }
 
+    /**
+     * Mutates a get_context_bootstrap response to attach a `repo_diff`
+     * field describing what's changed in the local repo since the
+     * handoff. Bridge-only — server has no git access. Best-effort, silent
+     * on failure.
+     *
+     * Opt out via CF_MEMORY_RESUME_DIFF=off.
+     */
+    injectRepoDiffIntoResume(response) {
+        try {
+            const opt = process.env.CF_MEMORY_RESUME_DIFF;
+            if (opt === '0' || opt === 'false' || opt === 'off') return;
+            const text = response?.result?.content?.[0]?.text;
+            if (!text) return;
+            let parsed;
+            try { parsed = JSON.parse(text); } catch (_) { return; }
+            const envelope = parsed?.resume_handoff;
+            if (!envelope) return;
+
+            const meta = this.getRepoMetadata();
+            const repoRoot = meta.repo_path;
+            if (!repoRoot) return;
+            // Reference point: prefer ended_at, fall back to started_at.
+            const since = envelope.ended_at || envelope.started_at;
+            if (!since) return;
+
+            const diff = this.computeRepoDiff(repoRoot, since, envelope.handoff?.branch || meta.branch);
+            if (diff) {
+                envelope.repo_diff = diff;
+                // Re-serialize the modified envelope back into the response.
+                response.result.content[0].text = JSON.stringify(parsed);
+            }
+        } catch (err) {
+            this.logDebug(`injectRepoDiffIntoResume failed: ${err && err.message}`);
+        }
+    }
+
+    /**
+     * Run a bounded git query in the repo root to summarize changes since
+     * the handoff was written. Returns { commits, files_changed,
+     * branch_now, branch_at_handoff } or null if git isn't available.
+     */
+    computeRepoDiff(repoRoot, sinceIso, handoffBranch) {
+        try {
+            const { execSync } = require('child_process');
+            const run = (cmd) => execSync(cmd, {
+                cwd: repoRoot,
+                encoding: 'utf8',
+                stdio: ['ignore', 'pipe', 'ignore'],
+                timeout: 1000,
+            });
+            // Git accepts ISO timestamps via --since
+            const commitsOut = run(`git log --since='${sinceIso}' --pretty=format:'%h %s' -n 25`);
+            const commits = commitsOut.split('\n').filter(Boolean).map(line => {
+                const [hash, ...rest] = line.split(' ');
+                return { hash, subject: rest.join(' ').slice(0, 120) };
+            });
+
+            // Files changed since the handoff. Compare HEAD against the
+            // commit closest to the handoff time. If no commits since,
+            // diff vs. HEAD~0 returns nothing.
+            let filesChanged = [];
+            try {
+                const namesOut = run(`git log --since='${sinceIso}' --name-only --pretty=format:''`);
+                const names = new Set(namesOut.split('\n').map(s => s.trim()).filter(Boolean));
+                filesChanged = Array.from(names).slice(0, 50);
+            } catch (_) { /* empty diff is fine */ }
+
+            // Branch information.
+            let branchNow = null;
+            try {
+                branchNow = run('git symbolic-ref --short HEAD').trim();
+            } catch (_) { /* detached HEAD */ }
+
+            const diff = {
+                commits_since_handoff: commits,
+                files_changed_count: filesChanged.length,
+                files_changed: filesChanged,
+            };
+            if (branchNow) diff.branch_now = branchNow;
+            if (handoffBranch) diff.branch_at_handoff = handoffBranch;
+            if (handoffBranch && branchNow && handoffBranch !== branchNow) {
+                diff.branch_changed = true;
+            }
+            return diff;
+        } catch (err) {
+            this.logDebug(`computeRepoDiff failed: ${err && err.message}`);
+            return null;
+        }
+    }
+
     /**
      * Build a minimal handoff packet from observed bridge activity. Used by
      * end_session auto-synthesis, the periodic auto-checkpoint, and the

package/package.json

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