cf-memory-mcp 3.3.0 → 3.3.1

package/bin/cf-memory-mcp.js

@@ -17,12 +17,15 @@ const https = require('https');
 const { URL } = require('url');
 const os = require('os');
 const process = require('process');
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
 
 // Configuration
-const STREAMABLE_HTTP_URL = 'https://cf-memory-mcp.johnlam90.workers.dev/mcp';
-const LEGACY_SERVER_URL = 'https://cf-memory-mcp.johnlam90.workers.dev/mcp/message';
+const STREAMABLE_HTTP_URL = 'https://cf-memory-mcp-simplified.johnlam90.workers.dev/mcp/message';
+const LEGACY_SERVER_URL = 'https://cf-memory-mcp-simplified.johnlam90.workers.dev/mcp/message';
 const PACKAGE_VERSION = require('../package.json').version;
-const TIMEOUT_MS = 30000;
+const TIMEOUT_MS = 60000; // Increased timeout for batch operations
 const CONNECT_TIMEOUT_MS = 10000;
 
 // Get API key from environment variable (will be checked later)
@@ -56,7 +59,7 @@ class CFMemoryMCP {
         this.logDebug(`Legacy Server URL: ${this.legacyServerUrl}`);
         this.logDebug(`User Agent: ${this.userAgent}`);
     }
-    
+
     /**
      * Log debug messages to stderr (won't interfere with MCP communication)
      */
@@ -65,7 +68,7 @@ class CFMemoryMCP {
             process.stderr.write(`[DEBUG] ${new Date().toISOString()} ${message}\n`);
         }
     }
-    
+
     /**
      * Log error messages to stderr
      */
@@ -76,7 +79,7 @@ class CFMemoryMCP {
             process.stderr.write(`[ERROR] ${timestamp} ${error.stack}\n`);
         }
     }
-    
+
     /**
      * Start listening for MCP messages on stdin
      */
@@ -90,7 +93,7 @@ class CFMemoryMCP {
             process.exit(1);
         }
     }
-    
+
     /**
      * Test connectivity to the Cloudflare Worker
      */
@@ -133,37 +136,37 @@ class CFMemoryMCP {
             }
         }
     }
-    
+
     /**
      * Process stdio input/output for MCP communication
      */
     async processStdio() {
         let buffer = '';
-        
+
         // Handle stdin data
         for await (const chunk of process.stdin) {
             buffer += chunk;
-            
+
             // Process complete JSON-RPC messages (one per line)
             let newlineIndex;
             while ((newlineIndex = buffer.indexOf('\n')) !== -1) {
                 const line = buffer.slice(0, newlineIndex).trim();
                 buffer = buffer.slice(newlineIndex + 1);
-                
+
                 if (line) {
                     await this.handleMessage(line);
                 }
             }
         }
-        
+
         // Process any remaining buffer content
         if (buffer.trim()) {
             await this.handleMessage(buffer.trim());
         }
-        
+
         this.logDebug('Stdin closed, shutting down...');
     }
-    
+
     /**
      * Handle a single MCP message
      */
@@ -171,15 +174,46 @@ class CFMemoryMCP {
         try {
             const message = JSON.parse(messageStr);
             this.logDebug(`Processing message: ${message.method} (id: ${message.id})`);
-            
+
+            // Handle lifecycle methods locally
+            if (message.method === 'initialize') {
+                const response = {
+                    jsonrpc: '2.0',
+                    id: message.id,
+                    result: {
+                        protocolVersion: '2025-03-26',
+                        capabilities: {
+                            tools: {}
+                        },
+                        serverInfo: {
+                            name: 'cf-memory-mcp',
+                            version: PACKAGE_VERSION
+                        }
+                    }
+                };
+                process.stdout.write(JSON.stringify(response) + '\n');
+                return;
+            }
+
+            if (message.method === 'notifications/initialized') {
+                this.logDebug('MCP handshake completed');
+                return;
+            }
+
+            // Intercept index_project tool call to perform local scanning
+            if (message.method === 'tools/call' && message.params && message.params.name === 'index_project') {
+                await this.handleIndexProject(message);
+                return;
+            }
+
             const response = await this.makeRequest(message);
-            
+
             // Send response to stdout
             process.stdout.write(JSON.stringify(response) + '\n');
-            
+
         } catch (error) {
             this.logError('Error handling message:', error);
-            
+
             // Send error response
             const errorResponse = {
                 jsonrpc: '2.0',
@@ -193,16 +227,196 @@ class CFMemoryMCP {
             process.stdout.write(JSON.stringify(errorResponse) + '\n');
         }
     }
-    
+
     /**
-     * Make HTTP request to the Cloudflare Worker
+     * Handle local project indexing
+     */
+    async handleIndexProject(message) {
+        const { project_path, project_name } = message.params.arguments;
+        const resolvedPath = path.resolve(project_path);
+        const name = project_name || path.basename(resolvedPath);
+
+        this.logDebug(`Intercepted index_project for: ${resolvedPath} (${name})`);
+
+        try {
+            // 1. Check/Create Project remotely
+            const projectResult = await this.makeRequest({
+                jsonrpc: '2.0',
+                id: `create-proj-${Date.now()}`,
+                method: 'tools/call',
+                params: {
+                    name: 'index_project',
+                    arguments: {
+                        project_path: resolvedPath,
+                        project_name: name
+                    }
+                }
+            });
+
+            if (projectResult.error) {
+                throw new Error(`Remote project creation failed: ${projectResult.error.message}`);
+            }
+
+            // Parse the result to get project ID
+            let projectId;
+            try {
+                const content = JSON.parse(projectResult.result.content[0].text);
+                projectId = content.project_id;
+            } catch (e) {
+                // Fallback: try to find existing project if creation didn't return generic ID
+                this.logDebug('Could not parse create result, listing projects...');
+                const listResp = await this.makeAuthenticatedRequest('/api/projects', 'GET');
+                const existing = listResp.projects?.find(p => p.name === name);
+                if (existing) {
+                    projectId = existing.id;
+                } else {
+                    throw new Error('Could not determine project ID');
+                }
+            }
+
+            // 2. Scan Local Files
+            this.logDebug(`Scanning files in ${resolvedPath}...`);
+            const files = this.scanDirectory(resolvedPath);
+            this.logDebug(`Found ${files.length} files to index.`);
+
+            // 3. Batch Upload
+            let indexed = 0;
+            const BATCH_SIZE = 10;
+
+            for (let i = 0; i < files.length; i += BATCH_SIZE) {
+                const batch = files.slice(i, i + BATCH_SIZE);
+                try {
+                    const payload = {
+                        files: batch.map(f => ({
+                            path: f.relativePath,
+                            content: f.content
+                        }))
+                    };
+
+                    await this.makeAuthenticatedRequest(`/api/projects/${projectId}/files/batch`, 'POST', payload);
+                    indexed += batch.length;
+
+                    // Optional: Send progress notification to client (if supported)
+                    // this.logDebug(`Indexed ${indexed}/${files.length}`);
+                } catch (err) {
+                    this.logError(`Batch upload failed at index ${i}`, err);
+                }
+            }
+
+            // 4. Return success
+            const response = {
+                jsonrpc: '2.0',
+                id: message.id,
+                result: {
+                    content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            project_id: projectId,
+                            files_found: files.length,
+                            files_indexed: indexed,
+                            status: 'completed'
+                        }, null, 2)
+                    }]
+                }
+            };
+            process.stdout.write(JSON.stringify(response) + '\n');
+
+        } catch (error) {
+            this.logError('Index project failed:', error);
+            const response = {
+                jsonrpc: '2.0',
+                id: message.id,
+                error: {
+                    code: -32000,
+                    message: `Indexing failed: ${error.message}`
+                }
+            };
+            process.stdout.write(JSON.stringify(response) + '\n');
+        }
+    }
+
+    /**
+     * Recursive scan
+     */
+    scanDirectory(dir, basePath = '') {
+        let files = [];
+        const EXCLUDE_DIRS = ['node_modules', '.git', 'dist', 'build', '.wrangler', 'coverage'];
+        const INCLUDE_EXTS = ['.ts', '.tsx', '.js', '.jsx', '.py', '.md', '.sql', '.css', '.html'];
+
+        try {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                const relPath = path.join(basePath, entry.name);
+
+                if (entry.isDirectory()) {
+                    if (!EXCLUDE_DIRS.includes(entry.name)) {
+                        files = files.concat(this.scanDirectory(fullPath, relPath));
+                    }
+                } else if (entry.isFile()) {
+                    if (INCLUDE_EXTS.includes(path.extname(entry.name).toLowerCase())) {
+                        try {
+                            const content = fs.readFileSync(fullPath, 'utf8');
+                            // Skip huge files > 1MB
+                            if (content.length < 1024 * 1024) {
+                                files.push({
+                                    relativePath: relPath,
+                                    content: content
+                                });
+                            }
+                        } catch (e) { /* ignore read errors */ }
+                    }
+                }
+            }
+        } catch (e) {
+            this.logError(`Scan failed for ${dir}:`, e);
+        }
+        return files;
+    }
+
+    /**
+     * Helper for Direct API calls (non-JSON-RPC)
+     */
+    async makeAuthenticatedRequest(endpoint, method, body) {
+        return new Promise((resolve, reject) => {
+            const serverUrl = 'https://cf-memory-mcp-simplified.johnlam90.workers.dev' + endpoint; // Hardcoded base for simplicity in this helper
+            const url = new URL(serverUrl);
+            const postData = body ? JSON.stringify(body) : '';
+
+            const options = {
+                hostname: url.hostname,
+                port: 443,
+                path: url.pathname,
+                method: method,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-API-Key': process.env.CF_MEMORY_API_KEY || API_KEY
+                }
+            };
+
+            const req = https.request(options, (res) => {
+                let data = '';
+                res.on('data', c => data += c);
+                res.on('end', () => {
+                    try { resolve(JSON.parse(data)); } catch (e) { resolve({}); }
+                });
+            });
+            req.on('error', reject);
+            if (postData) req.write(postData);
+            req.end();
+        });
+    }
+
+    /**
+     * Make HTTP request to the Cloudflare Worker (Standard MCP)
      */
     async makeRequest(message) {
         return new Promise((resolve) => {
             const serverUrl = this.useStreamableHttp ? this.streamableHttpUrl : this.legacyServerUrl;
             const url = new URL(serverUrl);
             const postData = JSON.stringify(message);
-            
+
             const options = {
                 hostname: url.hostname,
                 port: url.port || 443,
@@ -218,7 +432,7 @@ class CFMemoryMCP {
                 },
                 timeout: TIMEOUT_MS
             };
-            
+
             const req = https.request(options, (res) => {
                 let body = '';
 
@@ -243,7 +457,7 @@ class CFMemoryMCP {
                     }
                 });
             });
-            
+
             req.on('error', (error) => {
                 resolve({
                     jsonrpc: '2.0',
@@ -255,7 +469,7 @@ class CFMemoryMCP {
                     }
                 });
             });
-            
+
             req.on('timeout', () => {
                 req.destroy();
                 resolve({
@@ -268,12 +482,12 @@ class CFMemoryMCP {
                     }
                 });
             });
-            
+
             req.write(postData);
             req.end();
         });
     }
-    
+
     /**
      * Graceful shutdown
      */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cf-memory-mcp",
-	"version": "3.3.0",
+	"version": "3.3.1",
 	"description": "Best-in-class MCP (Model Context Protocol) server for AI memory storage with MIRIX-Inspired Specialized Memory Types (Core, Episodic, Semantic, Procedural, Resource, Knowledge Vault), Progressive Disclosure, AI-Powered Summaries, Context Window Optimization, Summary Memory Feature (TL;DR), Enhanced JSON Processing, Temporal Relationship Tracking, AI-Enhanced Context-Aware + Temporal Intelligence, Smart Tool Recommendation Engine, Memory Intelligence Engine, autonomous optimization, A/B testing, self-improving algorithms, intelligent search, smart auto-features, memory collections, project onboarding workflows, advanced lifecycle management, Project Intelligence for seamless agent handoff, and Unified Project Intelligence Tool with 57% performance improvement",
 	"main": "bin/cf-memory-mcp.js",
 	"bin": {
@@ -131,4 +131,4 @@
 		"typescript": "^5.7.3",
 		"wrangler": "^4.21.2"
 	}
-}
+}