cf-memory-mcp 3.8.12 → 3.9.1

package/bin/cf-memory-mcp.js

@@ -155,7 +155,8 @@ const TOOLS_LIST = [
                 file_filter: { type: 'array', items: { type: 'string' }, description: 'Limit to files matching path substrings' },
                 all_projects: { type: 'boolean', description: 'Search across ALL your indexed projects (overrides project_id). Useful for "find X in any of my repos".' },
                 expand_context: { type: 'boolean', description: 'Include file_imports (the file\'s module/imports chunk) with each result. Default: true.' },
-                exclude_docs: { type: 'boolean', description: 'Filter out markdown/docs from code queries. Default: true (auto-disabled if query mentions docs/readme/tutorial). Response includes docs_filtered_count when chunks were dropped — flip to false to surface them.' }
+                exclude_docs: { type: 'boolean', description: 'Filter out markdown/docs from code queries. Default: true (auto-disabled if query mentions docs/readme/tutorial). Response includes docs_filtered_count when chunks were dropped — flip to false to surface them.' },
+                auto_refresh: { type: 'boolean', description: 'When true, if results contain stale chunks the bridge transparently calls refresh_files + re-runs the query before returning. Removes the manual find_stale_files → refresh → re-query loop. Adds ~5-10s to the request when stale files exist. Set globally via CF_MEMORY_AUTO_REFRESH=true.' }
             },
             required: ['query']
         }
@@ -740,7 +741,7 @@ class CFMemoryMCP {
                 await this.maybeFillProjectId(message);
             }
 
-            const response = await this.makeRequest(message);
+            let response = await this.makeRequest(message);
             _mcpTrace('DISPATCH_DONE', `id=${message.id} method=${message.method} elapsed=${Date.now()-_t0}ms`);
 
             // Annotate retrieve_context results with local staleness when
@@ -750,6 +751,20 @@ class CFMemoryMCP {
             if (message.method === 'tools/call' &&
                 message.params && message.params.name === 'retrieve_context') {
                 this.maybeAnnotateStaleness(response, message.params.arguments);
+
+                // Auto-refresh path: when CF_MEMORY_AUTO_REFRESH=true OR the
+                // caller passes auto_refresh:true in arguments, and the
+                // response had stale chunks, transparently refresh those
+                // files and re-run the query. Removes the find-stale →
+                // refresh → re-query loop the codex review flagged as
+                // operationally brittle. Capped to avoid pathological cases.
+                const args = message.params.arguments || {};
+                const autoRefreshOptIn = args.auto_refresh === true ||
+                    process.env.CF_MEMORY_AUTO_REFRESH === '1' ||
+                    process.env.CF_MEMORY_AUTO_REFRESH === 'true';
+                if (autoRefreshOptIn) {
+                    response = await this.maybeAutoRefreshAndRequery(response, message);
+                }
             }
 
             // Send response to stdout
@@ -794,25 +809,31 @@ class CFMemoryMCP {
      * a full re-index, just refresh the affected files.
      */
     async handleRefreshFiles(message) {
-        const args = (message.params && message.params.arguments) || {};
+        const payload = await this.refreshFilesCore(message.params?.arguments || {});
+        process.stdout.write(JSON.stringify({
+            jsonrpc: '2.0',
+            id: message.id,
+            result: { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] },
+        }) + '\n');
+    }
+
+    /**
+     * Core refresh-files logic: reads local files, uploads them, returns a
+     * payload. Extracted so the auto-refresh path can call it without
+     * needing to capture stdout (the previous approach of swapping
+     * process.stdout.write was racy against other concurrent messages).
+     */
+    async refreshFilesCore(args) {
         const projectIdOrName = args.project_id;
         const filePaths = Array.isArray(args.file_paths) ? args.file_paths : [];
         const projectRoot = args.project_root ? path.resolve(args.project_root)
             : (process.env.CF_MEMORY_WATCH_PATH || process.cwd());
 
-        const respond = (payload) => {
-            process.stdout.write(JSON.stringify({
-                jsonrpc: '2.0',
-                id: message.id,
-                result: { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] },
-            }) + '\n');
-        };
-
         if (!projectIdOrName) {
-            return respond({ error: 'project_id is required' });
+            return { error: 'project_id is required' };
         }
         if (filePaths.length === 0) {
-            return respond({ error: 'file_paths (string[]) is required' });
+            return { error: 'file_paths (string[]) is required' };
         }
 
         // Resolve to project ID via list_projects if a name was given.
@@ -857,26 +878,26 @@ class CFMemoryMCP {
         }
 
         if (files.length === 0) {
-            return respond({
+            return {
                 project_id: projectId,
                 files_refreshed: 0,
                 skipped,
                 hint: `All ${filePaths.length} file path(s) failed to read. Check that paths are relative to project_root (${projectRoot}). If the project was indexed from a different directory, pass project_root=<that directory>.`,
-            });
+            };
         }
 
         const uploadResult = await this.uploadFileBatch(projectId, files);
         const refreshed = (uploadResult && typeof uploadResult.files_indexed === 'number') ? uploadResult.files_indexed : 0;
         const chunks = (uploadResult && typeof uploadResult.chunks_created === 'number') ? uploadResult.chunks_created : 0;
 
-        return respond({
+        return {
             project_id: projectId,
             files_attempted: files.length,
             files_refreshed: refreshed,
             chunks_created: chunks,
             skipped,
             errors: uploadResult && Array.isArray(uploadResult.errors) ? uploadResult.errors : undefined,
-        });
+        };
     }
 
     /**
@@ -1639,6 +1660,77 @@ class CFMemoryMCP {
         }
     }
 
+    /**
+     * If the just-returned retrieve_context response had stale files,
+     * refresh them via refreshFilesCore, re-run the original query, and
+     * return the fresh response. Opt-in via CF_MEMORY_AUTO_REFRESH or
+     * per-call `auto_refresh:true`. Guards against infinite loops by
+     * stripping auto_refresh from the re-query.
+     *
+     * Uses refreshFilesCore (returns data directly) rather than
+     * handleRefreshFiles (writes to stdout). Avoids globally overriding
+     * process.stdout.write, which was racy against any other MCP message
+     * being handled concurrently in the same isolate.
+     */
+    async maybeAutoRefreshAndRequery(response, originalMessage) {
+        try {
+            const text = response?.result?.content?.[0]?.text;
+            if (!text) return response;
+            let parsed;
+            try { parsed = JSON.parse(text); } catch (_) { return response; }
+            const hint = parsed?.stale_refresh_hint;
+            const stalePaths = hint?.arguments?.file_paths;
+            const projectId = hint?.arguments?.project_id;
+            if (!stalePaths || stalePaths.length === 0 || !projectId) {
+                return response; // Nothing stale, return as-is
+            }
+
+            _mcpTrace('AUTO_REFRESH', `${stalePaths.length} stale files; refreshing then re-querying`);
+
+            // Call core directly — no stdout override needed.
+            const refreshResult = await this.refreshFilesCore({
+                project_id: projectId,
+                file_paths: stalePaths,
+            });
+            _mcpTrace('AUTO_REFRESH_DONE', `refreshed=${refreshResult.files_refreshed || 0}`);
+
+            // Re-run the original retrieve_context (without auto_refresh
+            // to prevent loops). Server cache invalidates on write so the
+            // re-query sees fresh data.
+            const requeryArgs = { ...(originalMessage.params.arguments || {}) };
+            delete requeryArgs.auto_refresh;
+            const requery = {
+                ...originalMessage,
+                id: `${originalMessage.id}-refreshed`,
+                params: { ...originalMessage.params, arguments: requeryArgs },
+            };
+            const fresh = await this.makeRequest(requery);
+
+            // Tag the fresh response so callers can see auto-refresh fired
+            try {
+                const freshText = fresh?.result?.content?.[0]?.text;
+                if (freshText) {
+                    const freshParsed = JSON.parse(freshText);
+                    freshParsed.auto_refreshed = {
+                        files_refreshed: refreshResult.files_refreshed || stalePaths.length,
+                        file_paths: stalePaths,
+                    };
+                    fresh.result.content[0].text = JSON.stringify(freshParsed);
+                }
+            } catch (_) { /* best-effort tag only */ }
+
+            // Re-annotate so the fresh response carries the staleness check
+            // result (should now be empty)
+            this.maybeAnnotateStaleness(fresh, requeryArgs);
+            // Restore the original message id so the MCP client correlates correctly
+            fresh.id = originalMessage.id;
+            return fresh;
+        } catch (err) {
+            this.logDebug(`maybeAutoRefreshAndRequery failed: ${err && err.message}`);
+            return response;
+        }
+    }
+
     maybeAnnotateStaleness(response, args) {
         try {
             const text = response?.result?.content?.[0]?.text;

package/package.json

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