cf-memory-mcp 3.10.1 → 3.12.0

package/bin/cf-memory-mcp.js

@@ -792,6 +792,11 @@ class CFMemoryMCP {
                 await this.maybeAttachResumeMetadata(message);
             }
 
+            // Record which files the agent is touching so end_session can
+            // auto-populate handoff.files_read. Cheap (in-memory Map), safe
+            // (try/catch'd), and the agent's hand-written list always wins.
+            this.trackToolActivity(message);
+
             let response = await this.makeRequest(message);
             _mcpTrace('DISPATCH_DONE', `id=${message.id} method=${message.method} elapsed=${Date.now()-_t0}ms`);
 
@@ -801,6 +806,9 @@ class CFMemoryMCP {
             // acting on stale indexed content as if it were current.
             if (message.method === 'tools/call' &&
                 message.params && message.params.name === 'retrieve_context') {
+                // Track which files the response surfaced — these are what
+                // the agent will read next, and they belong in handoff.files_read.
+                this.trackRetrieveContextResponse(response);
                 this.maybeAnnotateStaleness(response, message.params.arguments);
 
                 // Auto-refresh path: when CF_MEMORY_AUTO_REFRESH=true OR the
@@ -818,6 +826,20 @@ class CFMemoryMCP {
                 }
             }
 
+            // After end_session without keep_open, drop the implicit-session
+            // cache so a subsequent end_session creates a fresh session.
+            if (message.method === 'tools/call' && message.params?.name === 'end_session') {
+                this.clearImplicitSessionIfFinalized(message, response);
+            }
+
+            // After explicit start_session, cache the returned session_id as
+            // the implicit session for this cwd. Lets a subsequent
+            // end_session({handoff:{...}}) without session_id resolve to
+            // the just-created one.
+            if (message.method === 'tools/call' && message.params?.name === 'start_session') {
+                this.cacheImplicitSessionFromResponse(response);
+            }
+
             // Send response to stdout
             process.stdout.write(JSON.stringify(response) + '\n');
 
@@ -2111,17 +2133,35 @@ class CFMemoryMCP {
                 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;
+            if (toolName === 'end_session') {
+                // session_id auto-fill: if the caller didn't pass one, use
+                // the implicit session for this cwd. Lets agents call
+                // end_session({handoff:{...}}) without threading session_id
+                // through every checkpoint.
+                if (!args.session_id) {
+                    const implicit = await this.getOrCreateImplicitSession();
+                    if (implicit) {
+                        args.session_id = implicit;
+                        _mcpTrace('IMPLICIT_SESSION', `end_session using implicit session=${implicit}`);
                     }
                 }
+                if (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;
+                        }
+                    }
+                    // Auto-fill files_read from observed retrieve_context /
+                    // get_file_content / get_file_outline calls during this
+                    // bridge session, if the agent didn't supply them. The
+                    // agent's hand-written files_touched stays authoritative.
+                    this.autoFillHandoffFilesRead(args.handoff);
+                }
                 return;
             }
         } catch (err) {
@@ -2129,6 +2169,208 @@ class CFMemoryMCP {
         }
     }
 
+    /**
+     * Return the implicit session_id for the current cwd, creating one via
+     * start_session when no session is active. Lets agents skip explicit
+     * session management — they can go straight to end_session({handoff})
+     * for checkpoint or finalization.
+     *
+     * The cache is keyed by cwd so multiple bridge processes for different
+     * repos don't share state. Sessions finalized via end_session WITHOUT
+     * keep_open clear the implicit cache so the next call starts fresh.
+     */
+    async getOrCreateImplicitSession() {
+        try {
+            const cwd = process.env.CF_MEMORY_WATCH_PATH || process.cwd();
+            if (!this._implicitSessionByCwd) this._implicitSessionByCwd = new Map();
+            const cached = this._implicitSessionByCwd.get(cwd);
+            if (cached) return cached;
+
+            // Lazily start a session, tagged with the same repo metadata as
+            // start_session would auto-attach if called explicitly.
+            const meta = this.getRepoMetadata();
+            const startArgs = { context: 'main' };
+            if (meta.repo_path) startArgs.repo_path = meta.repo_path;
+            if (meta.branch) startArgs.branch = meta.branch;
+            const fake = { params: { name: 'retrieve_context', arguments: {} } };
+            await this.maybeFillProjectId(fake);
+            if (fake.params.arguments.project_id) startArgs.project_id = fake.params.arguments.project_id;
+
+            const response = await this.makeRequest({
+                jsonrpc: '2.0',
+                id: `auto-session-${Date.now()}`,
+                method: 'tools/call',
+                params: { name: 'start_session', arguments: startArgs },
+            });
+            let sessionId = null;
+            try {
+                const payload = JSON.parse(response.result.content[0].text);
+                sessionId = payload.session_id;
+            } catch (_) { /* malformed response */ }
+            if (sessionId) {
+                this._implicitSessionByCwd.set(cwd, sessionId);
+                _mcpTrace('IMPLICIT_SESSION', `created implicit session=${sessionId} for cwd=${cwd}`);
+            }
+            return sessionId;
+        } catch (err) {
+            this.logDebug(`getOrCreateImplicitSession failed: ${err && err.message}`);
+            return null;
+        }
+    }
+
+    /**
+     * After an explicit start_session response, cache the returned session_id
+     * as the implicit session for the current cwd. This way the next
+     * end_session call without a session_id picks up the right one
+     * automatically.
+     */
+    cacheImplicitSessionFromResponse(response) {
+        try {
+            const text = response?.result?.content?.[0]?.text;
+            if (!text) return;
+            let parsed;
+            try { parsed = JSON.parse(text); } catch (_) { return; }
+            const sessionId = parsed?.session_id;
+            if (!sessionId) return;
+            const cwd = process.env.CF_MEMORY_WATCH_PATH || process.cwd();
+            if (!this._implicitSessionByCwd) this._implicitSessionByCwd = new Map();
+            this._implicitSessionByCwd.set(cwd, sessionId);
+            _mcpTrace('IMPLICIT_SESSION', `cached implicit session=${sessionId} for cwd=${cwd}`);
+        } catch (err) {
+            this.logDebug(`cacheImplicitSessionFromResponse failed: ${err && err.message}`);
+        }
+    }
+
+    /**
+     * Clear the implicit session for the current cwd after a non-keep_open
+     * end_session call. Lets a subsequent checkpoint create a fresh
+     * session instead of reusing a finalized one.
+     */
+    clearImplicitSessionIfFinalized(originalMessage, response) {
+        try {
+            if (originalMessage?.params?.name !== 'end_session') return;
+            const args = originalMessage.params.arguments || {};
+            if (args.keep_open) return; // checkpoint — keep cache
+            // Parse the response to confirm the session was actually ended
+            // (vs. an error). Don't clear if the server errored.
+            const text = response?.result?.content?.[0]?.text;
+            if (!text) return;
+            try {
+                const parsed = JSON.parse(text);
+                if (parsed?.error || parsed?.kept_open) return;
+            } catch (_) { return; }
+
+            const cwd = process.env.CF_MEMORY_WATCH_PATH || process.cwd();
+            if (this._implicitSessionByCwd?.has(cwd)) {
+                this._implicitSessionByCwd.delete(cwd);
+                _mcpTrace('IMPLICIT_SESSION', `cleared implicit session for cwd=${cwd}`);
+            }
+        } catch (err) {
+            this.logDebug(`clearImplicitSessionIfFinalized failed: ${err && err.message}`);
+        }
+    }
+
+    /**
+     * Record file paths the agent touched via retrieve_context, get_file_content,
+     * get_file_outline, and refresh_files. Used to seed end_session.handoff.files_read
+     * when the agent didn't bother listing them. The set is bounded so a chatty
+     * session can't blow up memory.
+     */
+    trackToolActivity(message) {
+        try {
+            if (message?.method !== 'tools/call' || !message.params) return;
+            const toolName = message.params.name;
+            const args = message.params.arguments || {};
+            if (!this._activityFiles) this._activityFiles = new Map();
+
+            const noteFile = (file_path, source) => {
+                if (typeof file_path !== 'string' || !file_path) return;
+                // Bound to 50 entries — past that we drop oldest.
+                if (this._activityFiles.size >= 50 && !this._activityFiles.has(file_path)) {
+                    const firstKey = this._activityFiles.keys().next().value;
+                    this._activityFiles.delete(firstKey);
+                }
+                const existing = this._activityFiles.get(file_path) || { sources: new Set(), count: 0 };
+                existing.sources.add(source);
+                existing.count += 1;
+                existing.last_seen = Date.now();
+                this._activityFiles.set(file_path, existing);
+            };
+
+            if (toolName === 'get_file_content' || toolName === 'get_file_outline') {
+                noteFile(args.file_path, toolName);
+            } else if (toolName === 'refresh_files' && Array.isArray(args.file_paths)) {
+                for (const p of args.file_paths) noteFile(p, 'refresh_files');
+            }
+        } catch (err) {
+            this.logDebug(`trackToolActivity failed: ${err && err.message}`);
+        }
+    }
+
+    /**
+     * Record file paths from a retrieve_context response. Called after the
+     * server responds so we capture what was actually returned (not just
+     * what was queried for).
+     */
+    trackRetrieveContextResponse(response) {
+        try {
+            if (!this._activityFiles) this._activityFiles = new Map();
+            const text = response?.result?.content?.[0]?.text;
+            if (!text) return;
+            let parsed;
+            try { parsed = JSON.parse(text); } catch (_) { return; }
+            const results = Array.isArray(parsed?.results) ? parsed.results : [];
+            for (const r of results.slice(0, 20)) {
+                if (typeof r?.file_path !== 'string') continue;
+                if (this._activityFiles.size >= 50 && !this._activityFiles.has(r.file_path)) {
+                    const firstKey = this._activityFiles.keys().next().value;
+                    this._activityFiles.delete(firstKey);
+                }
+                const existing = this._activityFiles.get(r.file_path) || { sources: new Set(), count: 0 };
+                existing.sources.add('retrieve_context');
+                existing.count += 1;
+                existing.last_seen = Date.now();
+                this._activityFiles.set(r.file_path, existing);
+            }
+        } catch (err) {
+            this.logDebug(`trackRetrieveContextResponse failed: ${err && err.message}`);
+        }
+    }
+
+    /**
+     * Populate handoff.files_read from observed tool activity, but only
+     * when the agent did not already list any. Hand-written entries always
+     * win — the bridge is a fallback, not a replacement.
+     */
+    autoFillHandoffFilesRead(handoff) {
+        try {
+            if (!handoff || typeof handoff !== 'object') return;
+            if (Array.isArray(handoff.files_read) && handoff.files_read.length > 0) return;
+            if (!this._activityFiles || this._activityFiles.size === 0) return;
+
+            // Exclude files the agent already listed as touched — those
+            // outrank "read". Then take the top 20 by access count.
+            const touchedPaths = new Set(
+                Array.isArray(handoff.files_touched)
+                    ? handoff.files_touched.map(f => f.path).filter(Boolean)
+                    : []
+            );
+            const entries = Array.from(this._activityFiles.entries())
+                .filter(([p]) => !touchedPaths.has(p))
+                .sort((a, b) => b[1].count - a[1].count)
+                .slice(0, 20);
+            if (entries.length === 0) return;
+
+            handoff.files_read = entries.map(([path, info]) => ({
+                path,
+                why: `Observed via ${Array.from(info.sources).join(', ')} (${info.count}x)`,
+            }));
+            _mcpTrace('HANDOFF_AUTOFILL', `files_read=${entries.length}`);
+        } catch (err) {
+            this.logDebug(`autoFillHandoffFilesRead 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.10.1",
+	"version": "3.12.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": {