cf-memory-mcp 3.3.1 → 3.4.0

package/bin/cf-memory-mcp.js

@@ -229,81 +229,89 @@ class CFMemoryMCP {
     }
 
     /**
-     * Handle local project indexing
+     * Handle local project indexing - scans local files and sends them via MCP
      */
     async handleIndexProject(message) {
-        const { project_path, project_name } = message.params.arguments;
+        const { project_path, project_name, include_patterns, exclude_patterns } = 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
+            // 1. Scan Local Files
             this.logDebug(`Scanning files in ${resolvedPath}...`);
-            const files = this.scanDirectory(resolvedPath);
+            const files = this.scanDirectory(resolvedPath, '', include_patterns, exclude_patterns);
             this.logDebug(`Found ${files.length} files to index.`);
 
-            // 3. Batch Upload
-            let indexed = 0;
-            const BATCH_SIZE = 10;
+            if (files.length === 0) {
+                const response = {
+                    jsonrpc: '2.0',
+                    id: message.id,
+                    result: {
+                        content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                project_id: null,
+                                project_name: name,
+                                files_found: 0,
+                                files_indexed: 0,
+                                chunks_created: 0,
+                                status: 'complete',
+                                message: 'No matching files found in directory'
+                            }, null, 2)
+                        }]
+                    }
+                };
+                process.stdout.write(JSON.stringify(response) + '\n');
+                return;
+            }
+
+            // 2. Send files directly via MCP tool call (batched to avoid timeouts)
+            const BATCH_SIZE = 20; // Process 20 files at a time
+            let totalIndexed = 0;
+            let totalChunks = 0;
+            let projectId = null;
 
             for (let i = 0; i < files.length; i += BATCH_SIZE) {
                 const batch = files.slice(i, i + BATCH_SIZE);
+                this.logDebug(`Processing batch ${Math.floor(i/BATCH_SIZE) + 1}/${Math.ceil(files.length/BATCH_SIZE)} (${batch.length} files)`);
+
+                const projectResult = await this.makeRequest({
+                    jsonrpc: '2.0',
+                    id: `index-batch-${Date.now()}-${i}`,
+                    method: 'tools/call',
+                    params: {
+                        name: 'index_project',
+                        arguments: {
+                            project_path: resolvedPath,
+                            project_name: name,
+                            files: batch.map(f => ({
+                                path: f.relativePath,
+                                content: f.content
+                            })),
+                            include_patterns,
+                            exclude_patterns
+                        }
+                    }
+                });
+
+                if (projectResult.error) {
+                    this.logError(`Batch ${i} failed:`, projectResult.error);
+                    continue;
+                }
+
                 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);
+                    const content = JSON.parse(projectResult.result.content[0].text);
+                    projectId = content.project_id;
+                    totalIndexed += content.files_indexed || 0;
+                    totalChunks += content.chunks_created || 0;
+                } catch (e) {
+                    this.logError('Could not parse batch result:', e);
                 }
             }
 
-            // 4. Return success
+            // 3. Return aggregated success
             const response = {
                 jsonrpc: '2.0',
                 id: message.id,
@@ -312,9 +320,11 @@ class CFMemoryMCP {
                         type: 'text',
                         text: JSON.stringify({
                             project_id: projectId,
+                            project_name: name,
                             files_found: files.length,
-                            files_indexed: indexed,
-                            status: 'completed'
+                            files_indexed: totalIndexed,
+                            chunks_created: totalChunks,
+                            status: 'complete'
                         }, null, 2)
                     }]
                 }
@@ -336,12 +346,35 @@ class CFMemoryMCP {
     }
 
     /**
-     * Recursive scan
+     * Recursive directory scan with filtering
      */
-    scanDirectory(dir, basePath = '') {
+    scanDirectory(dir, basePath = '', includePatterns = null, excludePatterns = null) {
         let files = [];
-        const EXCLUDE_DIRS = ['node_modules', '.git', 'dist', 'build', '.wrangler', 'coverage'];
-        const INCLUDE_EXTS = ['.ts', '.tsx', '.js', '.jsx', '.py', '.md', '.sql', '.css', '.html'];
+
+        // Default exclusions (always excluded)
+        const DEFAULT_EXCLUDE_DIRS = [
+            'node_modules', '.git', '.svn', '.hg',
+            'dist', 'build', 'out', '.next', '.nuxt',
+            '__pycache__', '.pytest_cache', 'venv', '.venv',
+            'coverage', '.coverage', '.nyc_output',
+            '.wrangler', '.turbo', '.cache'
+        ];
+
+        // Default file extensions to include
+        const DEFAULT_INCLUDE_EXTS = [
+            '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+            '.py', '.rb', '.go', '.rs', '.java', '.kt', '.scala',
+            '.cs', '.cpp', '.c', '.h', '.hpp', '.swift', '.php',
+            '.sql', '.sh', '.bash',
+            '.json', '.yaml', '.yml', '.toml',
+            '.html', '.css', '.scss', '.vue', '.svelte',
+            '.md', '.mdx'
+        ];
+
+        // Merge custom exclude patterns
+        const effectiveExcludes = excludePatterns
+            ? [...DEFAULT_EXCLUDE_DIRS, ...excludePatterns]
+            : DEFAULT_EXCLUDE_DIRS;
 
         try {
             const entries = fs.readdirSync(dir, { withFileTypes: true });
@@ -351,21 +384,61 @@ class CFMemoryMCP {
                 const relPath = path.join(basePath, entry.name);
 
                 if (entry.isDirectory()) {
-                    if (!EXCLUDE_DIRS.includes(entry.name)) {
-                        files = files.concat(this.scanDirectory(fullPath, relPath));
+                    // Check if directory should be excluded
+                    const shouldExclude = effectiveExcludes.some(pattern => {
+                        if (pattern.includes('*')) {
+                            // Simple glob matching
+                            const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+                            return regex.test(entry.name);
+                        }
+                        return entry.name === pattern;
+                    });
+
+                    if (!shouldExclude) {
+                        files = files.concat(this.scanDirectory(fullPath, relPath, includePatterns, excludePatterns));
                     }
                 } else if (entry.isFile()) {
-                    if (INCLUDE_EXTS.includes(path.extname(entry.name).toLowerCase())) {
+                    const ext = path.extname(entry.name).toLowerCase();
+
+                    // Check if file should be excluded
+                    const fileExcluded = effectiveExcludes.some(pattern => {
+                        if (pattern.startsWith('*.')) {
+                            return ext === pattern.substring(1);
+                        }
+                        return entry.name === pattern || relPath.includes(pattern);
+                    });
+
+                    if (fileExcluded) continue;
+
+                    // Check if file matches include patterns
+                    let shouldInclude = false;
+                    if (includePatterns && includePatterns.length > 0) {
+                        shouldInclude = includePatterns.some(pattern => {
+                            if (pattern.startsWith('*.')) {
+                                return ext === pattern.substring(1);
+                            }
+                            return entry.name.includes(pattern) || relPath.includes(pattern);
+                        });
+                    } else {
+                        // Use default extensions
+                        shouldInclude = DEFAULT_INCLUDE_EXTS.includes(ext);
+                    }
+
+                    if (shouldInclude) {
                         try {
                             const content = fs.readFileSync(fullPath, 'utf8');
-                            // Skip huge files > 1MB
-                            if (content.length < 1024 * 1024) {
+                            // Skip huge files > 500KB
+                            if (content.length < 512 * 1024) {
                                 files.push({
                                     relativePath: relPath,
                                     content: content
                                 });
+                            } else {
+                                this.logDebug(`Skipping large file (${Math.round(content.length/1024)}KB): ${relPath}`);
                             }
-                        } catch (e) { /* ignore read errors */ }
+                        } catch (e) {
+                            this.logDebug(`Could not read file: ${relPath}`);
+                        }
                     }
                 }
             }
@@ -376,40 +449,7 @@ class CFMemoryMCP {
     }
 
     /**
-     * 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)
+     * Make HTTP request to the Cloudflare Worker (MCP JSON-RPC)
      */
     async makeRequest(message) {
         return new Promise((resolve) => {
@@ -427,7 +467,8 @@ class CFMemoryMCP {
                     'Accept': 'application/json',
                     'Accept-Encoding': 'identity',
                     'User-Agent': this.userAgent,
-                    'X-API-Key': API_KEY,
+                    'Authorization': `Bearer ${API_KEY}`,
+                    'X-API-Key': API_KEY, // Also include for backwards compatibility
                     'Content-Length': Buffer.byteLength(postData)
                 },
                 timeout: TIMEOUT_MS

package/package.json

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