cf-memory-mcp 3.9.12 → 3.10.0

package/README.md

@@ -14,6 +14,7 @@ Cloudflare-hosted MCP server for semantic code indexing, retrieval, and assistan
 - **Self-healing freshness** - Results auto-flag stale chunks with a copy-pasteable `refresh_files` call; `refresh_stale` rebuilds the changed files in seconds; cache invalidates on write
 - **Self-debugging errors** - `retrieve_context` includes `empty_hint` on 0-result queries; `get_file_content` / `get_file_outline` return `{error, hint}` pointing to the next call instead of bare null; calling bridge-only tools server-side returns `bridge_required` install instructions
 - **Smart defaults** - Bridge auto-detects project_id from cwd, returns chunks pre-enriched with file imports + citation + source classification
+- **Cross-chat resume** - `end_session({handoff:{goal, status, next_steps, code_anchors, ...}})` persists a structured ~600-1500 token resume packet; next chat calls `get_context_bootstrap({resume:true})` to pick up where the previous chat left off, with `match_confidence`, branch-mismatch downgrades, and stale-anchor markers + refresh hints. Bridge auto-fills `repo_path`/`branch`/`project_id` from cwd + git.
 - **Contextual embeddings** - Qwen3 8K-context model with Anthropic-style chunk headers
 
 The active runtime is at [src-simplified/index.ts](src-simplified/index.ts). It exposes direct MCP over HTTP and a local stdio bridge for clients that want `npx cf-memory-mcp`.

package/bin/cf-memory-mcp.js

@@ -779,6 +779,19 @@ class CFMemoryMCP {
                 await this.maybeFillProjectId(message);
             }
 
+            // For resume-context tools, auto-attach repo_path/branch/project_id
+            // from cwd + git when the caller didn't supply them. Makes
+            // get_context_bootstrap({resume:true}) zero-config and lets
+            // end_session({handoff:{goal,status,next_steps}}) work without
+            // the agent having to dig up the repo metadata itself.
+            if (message.method === 'tools/call' && message.params && (
+                message.params.name === 'get_context_bootstrap' ||
+                message.params.name === 'start_session' ||
+                message.params.name === 'end_session'
+            )) {
+                await this.maybeAttachResumeMetadata(message);
+            }
+
             let response = await this.makeRequest(message);
             _mcpTrace('DISPATCH_DONE', `id=${message.id} method=${message.method} elapsed=${Date.now()-_t0}ms`);
 
@@ -2024,6 +2037,98 @@ class CFMemoryMCP {
         }
     }
 
+    /**
+     * Detect the current repo path and git branch once per process. Used by
+     * the resume-context plumbing on start_session / end_session /
+     * get_context_bootstrap so callers don't need to pass them manually.
+     * Returns { repo_path, branch } where either may be undefined when
+     * detection fails.
+     */
+    getRepoMetadata() {
+        if (this._repoMetaCache) return this._repoMetaCache;
+        const result = {};
+        try {
+            const root = process.env.CF_MEMORY_WATCH_PATH || process.cwd();
+            if (root && fs.existsSync(root)) {
+                result.repo_path = path.resolve(root);
+            }
+        } catch (_) { /* leave repo_path undefined */ }
+        try {
+            const { execSync } = require('child_process');
+            // symbolic-ref works on empty repos (no commits yet) where
+            // rev-parse --abbrev-ref HEAD fails. Detached HEAD still throws,
+            // which is the right behavior — we want the branch name, not "HEAD".
+            const branch = execSync('git symbolic-ref --short HEAD', {
+                cwd: result.repo_path || process.cwd(),
+                encoding: 'utf8',
+                stdio: ['ignore', 'pipe', 'ignore'],
+                timeout: 500,
+            }).trim();
+            if (branch) result.branch = branch;
+        } catch (_) { /* not a git repo, detached HEAD, or no branch — leave undefined */ }
+        this._repoMetaCache = result;
+        _mcpTrace('REPO_META', `repo_path=${result.repo_path||'?'} branch=${result.branch||'?'}`);
+        return result;
+    }
+
+    /**
+     * Attach repo_path / project_id / branch to start_session,
+     * end_session.handoff and get_context_bootstrap calls when the caller
+     * left them blank. This makes resume work zero-config: just call
+     * get_context_bootstrap({resume:true}) and the bridge fills in the rest.
+     *
+     * The server still treats these as optional, so any of the auto-fill
+     * lookups failing (no git, no indexed project) is safe — the call
+     * proceeds with whatever metadata was already present.
+     */
+    async maybeAttachResumeMetadata(message) {
+        try {
+            if (message.method !== 'tools/call' || !message.params) return;
+            const toolName = message.params.name;
+            const args = message.params.arguments || (message.params.arguments = {});
+
+            // get_context_bootstrap with resume:true wants repo_path + branch
+            // for matching. We do not force resume:true — that's a caller
+            // choice — but we fill the metadata so resume becomes useful
+            // when the caller does opt in.
+            if (toolName === 'get_context_bootstrap') {
+                const meta = this.getRepoMetadata();
+                if (!args.repo_path && meta.repo_path) args.repo_path = meta.repo_path;
+                if (!args.branch && meta.branch) args.branch = meta.branch;
+                if (!args.project_id) {
+                    await this.maybeFillProjectId({ params: { name: 'retrieve_context', arguments: args } });
+                }
+                return;
+            }
+
+            if (toolName === 'start_session') {
+                const meta = this.getRepoMetadata();
+                if (!args.repo_path && meta.repo_path) args.repo_path = meta.repo_path;
+                if (!args.branch && meta.branch) args.branch = meta.branch;
+                if (!args.project_id) {
+                    await this.maybeFillProjectId({ params: { name: 'retrieve_context', arguments: args } });
+                }
+                return;
+            }
+
+            if (toolName === 'end_session' && args.handoff && typeof args.handoff === 'object') {
+                const meta = this.getRepoMetadata();
+                if (!args.handoff.repo_path && meta.repo_path) args.handoff.repo_path = meta.repo_path;
+                if (!args.handoff.branch && meta.branch) args.handoff.branch = meta.branch;
+                if (!args.handoff.project_id) {
+                    const fake = { params: { name: 'retrieve_context', arguments: {} } };
+                    await this.maybeFillProjectId(fake);
+                    if (fake.params.arguments.project_id) {
+                        args.handoff.project_id = fake.params.arguments.project_id;
+                    }
+                }
+                return;
+            }
+        } catch (err) {
+            this.logDebug(`maybeAttachResumeMetadata failed: ${err && err.message}`);
+        }
+    }
+
     /**
      * If the just-returned retrieve_context response had stale files,
      * refresh them via refreshFilesCore, re-run the original query, and

package/package.json

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