cf-memory-mcp 3.8.11 → 3.9.0

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
@@ -1639,6 +1654,93 @@ class CFMemoryMCP {
         }
     }
 
+    /**
+     * If the just-returned retrieve_context response had stale files,
+     * refresh them via refresh_files, 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.
+     */
+    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`);
+
+            // Build a refresh_files message and invoke it via our own handler
+            const refreshMessage = {
+                jsonrpc: '2.0',
+                id: `auto-refresh-${Date.now()}`,
+                method: 'tools/call',
+                params: {
+                    name: 'refresh_files',
+                    arguments: {
+                        project_id: projectId,
+                        file_paths: stalePaths,
+                    },
+                },
+            };
+            // handleRefreshFiles writes to stdout itself; we need its work
+            // done but the output suppressed. Capture stdout for this call.
+            const origWrite = process.stdout.write.bind(process.stdout);
+            let captured = '';
+            process.stdout.write = (chunk) => {
+                captured += String(chunk);
+                return true;
+            };
+            try {
+                await this.handleRefreshFiles(refreshMessage);
+            } finally {
+                process.stdout.write = origWrite;
+            }
+            _mcpTrace('AUTO_REFRESH_DONE', `refreshed ${stalePaths.length} files; captured=${captured.length}b`);
+
+            // 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: 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;
@@ -1991,6 +2093,45 @@ if (process.argv.includes('--diagnose')) {
             console.log(`FAIL: ${err.message}`);
         }
 
+        // 5. Deep health (D1 + Vectorize + AI bindings)
+        process.stdout.write('5. Deep health (D1/Vectorize/AI)... ');
+        const deepStart = Date.now();
+        try {
+            const url = new URL(BASE_URL + '/health/deep');
+            const result = await new Promise((resolve, reject) => {
+                const req = https.request({
+                    hostname: url.hostname,
+                    port: url.port || 443,
+                    path: url.pathname,
+                    method: 'GET',
+                    headers: { 'X-API-Key': API_KEY },
+                    timeout: 15000,
+                }, (res) => {
+                    let body = '';
+                    res.on('data', (c) => body += c);
+                    res.on('end', () => resolve({ status: res.statusCode, body }));
+                });
+                req.on('error', reject);
+                req.on('timeout', () => reject(new Error('timeout')));
+                req.end();
+            });
+            const elapsed = Date.now() - deepStart;
+            const parsed = JSON.parse(result.body);
+            const checks = parsed.checks || {};
+            const summary = ['d1', 'vectorize', 'ai']
+                .map(k => `${k}=${checks[k]?.ok ? 'ok' : 'FAIL'}`)
+                .join(' ');
+            console.log(`${parsed.status} (${elapsed}ms, ${summary})`);
+            // Surface any sub-check errors
+            for (const [k, v] of Object.entries(checks)) {
+                if (v && typeof v === 'object' && 'ok' in v && !v.ok && v.error) {
+                    console.log(`     ${k}: ${v.error}`);
+                }
+            }
+        } catch (err) {
+            console.log(`FAIL: ${err.message}`);
+        }
+
         console.log('\nDiagnostics complete.');
         process.exit(0);
     })().catch(err => {

package/package.json

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