cf-memory-mcp 3.16.0 → 3.18.0

package/bin/cf-memory-mcp.js

@@ -213,8 +213,9 @@ const TOOLS_LIST = [
                 repo_path: { type: 'string', description: 'Absolute project root path. Bridge auto-fills from cwd if omitted.' },
                 project_id: { type: 'string', description: 'Canonical project id (proj_...). Used before repo_path when set.' },
                 branch: { type: 'string', description: 'Current git branch. Mismatch downgrades match_confidence but does not hide. Bridge auto-fills from git.' },
-                session_id_hint: { type: 'string', description: 'Resume a specific session by id (overrides repo/branch matching). Useful after seeing recent_handoffs.' },
-                max_age_minutes: { type: 'number', description: 'Hard cutoff: hide handoffs older than this many minutes. Without it, older handoffs surface with reduced confidence.' }
+                session_id_hint: { type: 'string', description: 'Resume a specific session by id (overrides repo/branch matching). Full UUID or short prefix (>=8 chars). Useful after seeing recent_handoffs.' },
+                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.' }
             }
         }
     },
@@ -932,6 +933,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 +988,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 +2514,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
@@ -2535,10 +2638,63 @@ class CFMemoryMCP {
         // sees the recent trajectory ("what was I doing").
         const timelineNote = this.formatActivityTimeline();
         const baseNote = `Auto-synthesized by cf-memory-mcp bridge. Agent did not provide a handoff. Tool calls observed: ${this._toolCallCount || 0}. Set CF_MEMORY_AUTO_HANDOFF=off to disable.`;
-        handoff.notes = timelineNote ? `${baseNote}\n\nRecent activity:\n${timelineNote}` : baseNote;
+
+        // Workspace state: uncommitted changes + recent commits give the
+        // next chat real signal about what's been happening in the repo,
+        // not just what tools the agent called.
+        const workspaceState = this.getGitWorkspaceState();
+        const sections = [baseNote];
+        if (timelineNote) sections.push(`Recent activity:\n${timelineNote}`);
+        if (workspaceState) sections.push(`Workspace state:\n${workspaceState}`);
+        handoff.notes = sections.join('\n\n');
         return handoff;
     }
 
+    /**
+     * Snapshot the local git workspace: uncommitted file count, top
+     * changed files, last 3 commit messages. Used by auto-synthesized
+     * handoffs so the next chat sees real workspace state, not just
+     * tool-call activity. Best-effort: returns "" when git unavailable.
+     */
+    getGitWorkspaceState() {
+        try {
+            const meta = this.getRepoMetadata();
+            if (!meta.repo_path) return '';
+            const { execSync } = require('child_process');
+            const run = (cmd) => execSync(cmd, {
+                cwd: meta.repo_path,
+                encoding: 'utf8',
+                stdio: ['ignore', 'pipe', 'ignore'],
+                timeout: 500,
+            });
+            const lines = [];
+            // Uncommitted: `git status --porcelain` is one line per changed file.
+            try {
+                const status = run('git status --porcelain').trim();
+                if (status) {
+                    const files = status.split('\n').slice(0, 8);
+                    const more = status.split('\n').length > 8 ? ` (+ ${status.split('\n').length - 8} more)` : '';
+                    lines.push(`  Uncommitted changes:${more}`);
+                    files.forEach(f => lines.push(`    ${f}`));
+                } else {
+                    lines.push('  Working tree clean.');
+                }
+            } catch (_) { /* git status failed */ }
+            // Last 3 commits — short hash + subject only.
+            try {
+                const log = run('git log -3 --pretty=format:%h\\ %s').trim();
+                if (log) {
+                    lines.push('  Recent commits:');
+                    log.split('\n').forEach(c => lines.push(`    ${c}`));
+                }
+            } catch (_) { /* git log failed */ }
+            return lines.join('\n');
+        } catch (err) {
+            this.logDebug(`getGitWorkspaceState failed: ${err && err.message}`);
+            return '';
+        }
+    }
+
     /**
      * Condense an MCP tool call into a single-line summary. Used for the
      * activity timeline so the synthesized handoff includes "what was I

package/package.json

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