cf-memory-mcp 3.9.1 → 3.9.3

package/bin/cf-memory-mcp.js

@@ -286,7 +286,7 @@ const TOOLS_LIST = [
     },
     {
         name: 'get_file_content',
-        description: 'Reassemble and return the full content of an indexed file from its stored chunks. Use when retrieve_context returned a fragment and you need the whole file context, or when working remotely without local filesystem access. Returns indexed_at + file_hash for staleness checks.',
+        description: 'Return the full content of a file. When the bridge can resolve the file under the project root locally, it reads byte-exact source from disk and returns source:"local" — suitable for code review and patch planning. When local read fails (remote/CI environments, missing project root), falls back to server-side reassembly from indexed chunks and returns reconstructed_from_chunks:true + reconstruction_warning + missing_line_ranges (approximate, suitable for orientation only). Always returns indexed_at + file_hash for staleness checks.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -731,6 +731,17 @@ class CFMemoryMCP {
                 return;
             }
 
+            // Intercept get_file_content: prefer byte-exact local file read
+            // over server-side chunk reconstruction when the file is
+            // resolvable locally. Codex review flagged the reconstruction
+            // path as "useful for orientation only, not exact review or
+            // patch planning". Local read closes that gap.
+            if (message.method === 'tools/call' && message.params && message.params.name === 'get_file_content') {
+                const handled = await this.maybeServeLocalFileContent(message);
+                if (handled) return;
+                // Fall through to server-side reconstruction if local read failed.
+            }
+
             _mcpTrace('DISPATCH', `id=${message.id} method=${message.method} -> network`);
             // If this is a retrieve_context call with no project_id and no
             // all_projects, try to auto-fill project_id from the current
@@ -1694,6 +1705,21 @@ class CFMemoryMCP {
             });
             _mcpTrace('AUTO_REFRESH_DONE', `refreshed=${refreshResult.files_refreshed || 0}`);
 
+            // If refresh itself errored or refreshed 0 files, return the
+            // original response with a clear note rather than re-querying
+            // and pretending the refresh succeeded.
+            if (refreshResult.error || (refreshResult.files_refreshed || 0) === 0) {
+                try {
+                    parsed.auto_refresh_failed = {
+                        attempted: stalePaths.length,
+                        error: refreshResult.error || 'refresh ran but indexed 0 files (paths may be unreadable or project_root mismatched)',
+                        skipped: refreshResult.skipped,
+                    };
+                    response.result.content[0].text = JSON.stringify(parsed);
+                } catch (_) { /* best-effort tag */ }
+                return response;
+            }
+
             // Re-run the original retrieve_context (without auto_refresh
             // to prevent loops). Server cache invalidates on write so the
             // re-query sees fresh data.
@@ -1712,7 +1738,8 @@ class CFMemoryMCP {
                 if (freshText) {
                     const freshParsed = JSON.parse(freshText);
                     freshParsed.auto_refreshed = {
-                        files_refreshed: refreshResult.files_refreshed || stalePaths.length,
+                        files_refreshed: refreshResult.files_refreshed,
+                        chunks_created: refreshResult.chunks_created || 0,
                         file_paths: stalePaths,
                     };
                     fresh.result.content[0].text = JSON.stringify(freshParsed);
@@ -1731,6 +1758,112 @@ class CFMemoryMCP {
         }
     }
 
+    /**
+     * Read the requested file from the local filesystem if we can resolve
+     * it via the project's root_path or the bridge's cwd. Returns the
+     * byte-exact source plus a `source: "local"` flag so callers know it's
+     * not a chunk reconstruction. Falls back (returns false) when:
+     * - We can't resolve a project root locally
+     * - The file doesn't exist at the resolved path
+     * - The local read errors for any reason
+     *
+     * When fallthrough happens, the message flows on to the server which
+     * returns the chunk-reconstructed approximation with reconstruction_warning.
+     */
+    async maybeServeLocalFileContent(message) {
+        try {
+            const args = message.params?.arguments || {};
+            const filePath = args.file_path;
+            const projectIdOrName = args.project_id;
+            const maxChars = Math.min(100000, Math.max(1000, Number(args.max_chars) || 50000));
+            if (!filePath) return false;
+
+            // Resolve project root: prefer explicit project_root arg, then
+            // look up the project's stored root_path on the server, then
+            // fall back to CF_MEMORY_WATCH_PATH / cwd.
+            let projectRoot = args.project_root ? path.resolve(args.project_root) : null;
+            if (!projectRoot && projectIdOrName) {
+                try {
+                    const list = await this.makeRequest({
+                        jsonrpc: '2.0',
+                        id: `gfc-list-${Date.now()}`,
+                        method: 'tools/call',
+                        params: { name: 'list_projects', arguments: {} },
+                    });
+                    const projects = JSON.parse(list.result.content[0].text);
+                    const match = Array.isArray(projects)
+                        ? projects.find(p => p.id === projectIdOrName || p.name === projectIdOrName)
+                        : null;
+                    if (match?.root_path) projectRoot = match.root_path;
+                } catch (_) { /* ignore lookup failure, fall through */ }
+            }
+            if (!projectRoot) {
+                projectRoot = process.env.CF_MEMORY_WATCH_PATH || process.cwd();
+            }
+
+            // Try exact path first, then walk up substring matches under root
+            const candidates = [
+                path.resolve(projectRoot, filePath),
+                path.resolve(filePath),
+            ];
+            let resolvedFull = null;
+            for (const c of candidates) {
+                try {
+                    const stat = fs.statSync(c);
+                    if (stat.isFile()) {
+                        resolvedFull = c;
+                        break;
+                    }
+                } catch (_) { /* try next */ }
+            }
+            if (!resolvedFull) return false;
+
+            const fullContent = fs.readFileSync(resolvedFull, 'utf8');
+            const stat = fs.statSync(resolvedFull);
+            const truncated = fullContent.length > maxChars;
+            const content = truncated ? fullContent.slice(0, maxChars) + '\n... [truncated]' : fullContent;
+            const totalLines = fullContent.split('\n').length;
+            const localHash = crypto.createHash('sha256').update(fullContent, 'utf8').digest('hex');
+
+            // Detect language from extension (mirror the server's mapping)
+            const ext = path.extname(resolvedFull).toLowerCase();
+            const extToLang = {
+                '.ts': 'typescript', '.tsx': 'typescript', '.js': 'javascript', '.jsx': 'javascript',
+                '.mjs': 'javascript', '.cjs': 'javascript', '.py': 'python', '.go': 'go',
+                '.rs': 'rust', '.java': 'java', '.kt': 'kotlin', '.scala': 'scala',
+                '.cs': 'csharp', '.cpp': 'cpp', '.c': 'c', '.h': 'c', '.hpp': 'cpp',
+                '.rb': 'ruby', '.php': 'php', '.swift': 'swift', '.md': 'markdown',
+                '.sql': 'sql', '.sh': 'bash', '.json': 'json', '.yaml': 'yaml', '.yml': 'yaml',
+                '.toml': 'toml',
+            };
+            const language = extToLang[ext] || null;
+
+            const payload = {
+                file_path: path.relative(projectRoot, resolvedFull) || path.basename(resolvedFull),
+                language,
+                total_lines: totalLines,
+                size_bytes: stat.size,
+                indexed_at: stat.mtime.toISOString(),
+                file_hash: localHash,
+                content,
+                truncated,
+                source: 'local',
+                local_path: resolvedFull,
+            };
+
+            process.stdout.write(JSON.stringify({
+                jsonrpc: '2.0',
+                id: message.id,
+                result: { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] },
+            }) + '\n');
+            _mcpTrace('GFC_LOCAL', `served ${resolvedFull} (${stat.size}b, lang=${language})`);
+            return true;
+        } catch (err) {
+            this.logDebug(`maybeServeLocalFileContent failed: ${err && err.message}`);
+            return false;
+        }
+    }
+
     maybeAnnotateStaleness(response, args) {
         try {
             const text = response?.result?.content?.[0]?.text;

package/package.json

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