@mrxkun/mcfast-mcp 4.0.11 → 4.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrxkun/mcfast-mcp",
-  "version": "4.0.11",
+  "version": "4.0.14",
   "description": "Ultra-fast code editing with WASM acceleration, fuzzy patching, multi-layer caching, and 8 unified tools. Optimized for AI code assistants with 80-98% latency reduction. Phase 4: ML Intelligence Layer.",
   "type": "module",
   "bin": {

package/src/index.js

@@ -54,16 +54,69 @@ const VERBOSE = process.env.MCFAST_VERBOSE !== 'false'; // Default: true
 
 // Memory Engine (initialized lazily)
 let memoryEngine = null;
+let memoryEngineInitPromise = null;
+let memoryEngineReady = false;
 
+/**
+ * Start background initialization of memory engine
+ * Call this on server startup to pre-initialize
+ */
+async function backgroundInitializeMemoryEngine() {
+    if (memoryEngineInitPromise) return memoryEngineInitPromise;
+    
+    memoryEngineInitPromise = (async () => {
+        try {
+            memoryEngine = new MemoryEngine({
+                apiKey: TOKEN,
+                enableSync: true
+            });
+            // Use a shorter timeout for initialization
+            const initTimeout = new Promise((_, reject) => {
+                setTimeout(() => reject(new Error('Memory engine init timeout')), 25000);
+            });
+            
+            await Promise.race([
+                memoryEngine.initialize(process.cwd()),
+                initTimeout
+            ]);
+            
+            memoryEngineReady = true;
+            console.error(`${colors.cyan}[Memory]${colors.reset} Engine initialized successfully`);
+        } catch (error) {
+            console.error(`${colors.yellow}[Memory]${colors.reset} Engine initialization failed: ${error.message}`);
+            // Don't throw - allow partial initialization
+            memoryEngineReady = false;
+        }
+    })();
+    
+    return memoryEngineInitPromise;
+}
+
+/**
+ * Get memory engine - waits for initialization with timeout
+ */
 async function getMemoryEngine() {
+    if (memoryEngine && memoryEngineReady) {
+        return memoryEngine;
+    }
+    
+    // Wait for initialization with timeout
+    if (memoryEngineInitPromise) {
+        try {
+            await Promise.race([
+                memoryEngineInitPromise,
+                new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout')), 5000))
+            ]);
+        } catch (error) {
+            console.error(`${colors.yellow}[Memory]${colors.reset} Waiting for engine: ${error.message}`);
+        }
+    }
+    
+    // If still not ready, try to initialize now
     if (!memoryEngine) {
-        memoryEngine = new MemoryEngine({
-            apiKey: TOKEN,
-            enableSync: true
-        });
-        await memoryEngine.initialize(process.cwd());
-        console.error(`${colors.cyan}[Memory]${colors.reset} Engine initialized`);
+        await backgroundInitializeMemoryEngine();
     }
+    
     return memoryEngine;
 }
 
@@ -282,6 +335,28 @@ const TOOL_ALIASES = {
     'list_files_fast': 'list_files',
     'read_file': 'read',
     'goto_definition': 'search', // redirected
+    // VSCode MCP client adds prefixes
+    'mcp--mcfast--edit': 'edit',
+    'mcp--mcfast--search': 'search',
+    'mcp--mcfast--read': 'read',
+    'mcp--mcfast--list_files': 'list_files',
+    'mcp--mcfast--reapply': 'reapply',
+    'mcp--mcfast--memory_search': 'memory_search',
+    'mcp--mcfast--memory_get': 'memory_get',
+    'mcp--mcfast--detect_patterns': 'detect_patterns',
+    'mcp--mcfast--get_suggestions': 'get_suggestions',
+    'mcp--mcfast--select_strategy': 'select_strategy',
+    // Alternative format with double dashes
+    'mcfast_edit': 'edit',
+    'mcfast_search': 'search',
+    'mcfast_read': 'read',
+    'mcfast_list_files': 'list_files',
+    'mcfast_reapply': 'reapply',
+    'mcfast_memory_search': 'memory_search',
+    'mcfast_memory_get': 'memory_get',
+    'mcfast_detect_patterns': 'detect_patterns',
+    'mcfast_get_suggestions': 'get_suggestions',
+    'mcfast_select_strategy': 'select_strategy',
 };
 
 /**
@@ -1107,7 +1182,8 @@ async function handleSearchFilesystem({ query, path: searchPath, isRegex = false
                         lines.forEach((line, idx) => {
                             if (line.includes(query)) {
                                 matches.push({
-                                    line: idx + 1,
+                                    file,
+                                    lineNumber: idx + 1,
                                     content: line.trim()
                                 });
                             }
@@ -1152,7 +1228,7 @@ async function handleSearchFilesystem({ query, path: searchPath, isRegex = false
             contentMatches.slice(0, 10).forEach(({ file, matches }) => {
                 output += `\n${colors.yellow}${file}${colors.reset}\n`;
                 matches.forEach(match => {
-                    output += `  ${colors.dim}${match.line}:${colors.reset} ${match.content}\n`;
+                    output += `  ${colors.dim}${match.lineNumber}:${colors.reset} ${match.content}\n`;
                 });
             });
         }
@@ -1233,6 +1309,22 @@ async function handleReapply({ instruction, files, errorContext = "", attempt =
  */
 async function handleEdit({ instruction, files, code_edit, dryRun = false }) {
     const editStartTime = Date.now();
+    
+    // Validate required parameters
+    if (!instruction) {
+        return {
+            content: [{ type: "text", text: "❌ Error: 'instruction' parameter is required" }],
+            isError: true
+        };
+    }
+    
+    if (!files || Object.keys(files).length === 0) {
+        return {
+            content: [{ type: "text", text: "❌ Error: 'files' parameter is required and must contain at least one file" }],
+            isError: true
+        };
+    }
+    
     const firstFile = Object.keys(files)[0];
     
     // 1. Retrieve memory context for enhanced understanding
@@ -1243,7 +1335,7 @@ async function handleEdit({ instruction, files, code_edit, dryRun = false }) {
             console.error(`${colors.cyan}[MEMORY]${colors.reset} Retrieved context for edit`);
         }
     } catch (error) {
-        console.error(`${colors.yellow}[MEMORY]${colors.reset} Context retrieval failed: ${error.message}`);
+        console.error(`${colors.yellow}[Memory]${colors.reset} Context retrieval failed: ${error.message}`);
     }
     
     // 2. Analyze impact for rename operations
@@ -2489,7 +2581,7 @@ async function handleApplyFast({ instruction, files, dryRun, toolName }) {
     if (!TOKEN) {
         return {
             content: [{ type: "text", text: "❌ Error: MCFAST_TOKEN is missing. Please set it in your MCP config." }],
-            isError: true
+            isError: true,
         };
     }
     try {
@@ -2858,6 +2950,18 @@ async function handleMemorySearch({ query, type = 'all', maxResults = 6, minScor
  */
 async function handleMemoryGet({ type }) {
     const start = Date.now();
+    
+    // Early return if memory engine not ready
+    if (!memoryEngineReady) {
+        return {
+            content: [{ 
+                type: "text", 
+                text: `⏳ Memory engine is still initializing. Please try again in a few seconds.` 
+            }],
+            isError: true
+        };
+    }
+    
     try {
         const engine = await getMemoryEngine();
         let output = '';
@@ -2923,6 +3027,18 @@ async function handleMemoryGet({ type }) {
  */
 async function handleDetectPatterns() {
     const start = Date.now();
+    
+    // Early return if memory engine not ready
+    if (!memoryEngineReady) {
+        return {
+            content: [{ 
+                type: "text", 
+                text: `⏳ Memory engine is still initializing. Please try again in a few seconds.` 
+            }],
+            isError: true
+        };
+    }
+    
     try {
         const engine = await getMemoryEngine();
         const patterns = await engine.detectPatterns();
@@ -2970,6 +3086,18 @@ async function handleDetectPatterns() {
  */
 async function handleGetSuggestions({ currentFile, currentLine }) {
     const start = Date.now();
+    
+    // Early return if memory engine not ready
+    if (!memoryEngineReady) {
+        return {
+            content: [{ 
+                type: "text", 
+                text: `⏳ Memory engine is still initializing. Please try again in a few seconds.` 
+            }],
+            isError: true
+        };
+    }
+    
     try {
         const engine = await getMemoryEngine();
         const suggestions = await engine.getSuggestions({
@@ -3023,6 +3151,18 @@ async function handleGetSuggestions({ currentFile, currentLine }) {
  */
 async function handleSelectStrategy({ instruction, files = [] }) {
     const start = Date.now();
+    
+    // Early return if memory engine not ready
+    if (!memoryEngineReady) {
+        return {
+            content: [{ 
+                type: "text", 
+                text: `⏳ Memory engine is still initializing. Please try again in a few seconds.` 
+            }],
+            isError: true
+        };
+    }
+    
     try {
         const engine = await getMemoryEngine();
         const result = await engine.selectStrategy(instruction, { files });
@@ -3067,5 +3207,11 @@ async function handleSelectStrategy({ instruction, files = [] }) {
  * Start Server
  */
 const transport = new StdioServerTransport();
+
+// Pre-initialize memory engine in background
+backgroundInitializeMemoryEngine().catch(err => {
+    console.error(`${colors.yellow}[Memory]${colors.reset} Background init error: ${err.message}`);
+});
+
 await server.connect(transport);
 console.error("mcfast MCP v1.0.0 running on stdio");

package/src/memory/memory-engine.js

@@ -104,12 +104,47 @@ export class MemoryEngine {
     console.log(`[MemoryEngine] Smart Routing: ${this.smartRoutingEnabled ? 'ENABLED' : 'DISABLED'}`);
     console.log(`[MemoryEngine] Intelligence Layer: ${this.intelligenceEnabled ? 'ENABLED' : 'DISABLED'}`);
     
-    // Load intelligence models
+    // Initialize intelligence engines if enabled
     if (this.intelligenceEnabled) {
-      await this.patternDetector.loadModel?.();
-      await this.suggestionEngine.loadModel?.();
-      await this.strategySelector.loadModel?.();
-      console.log('[MemoryEngine] ✅ Intelligence models loaded');
+      try {
+        const { PatternDetector, SuggestionEngine, StrategySelector } = await import('../intelligence/index.js');
+        this.patternDetector = new PatternDetector({ memoryEngine: this });
+        this.suggestionEngine = new SuggestionEngine({ memoryEngine: this });
+        this.strategySelector = new StrategySelector({ memoryEngine: this });
+        console.log('[MemoryEngine] Intelligence engines initialized');
+      } catch (error) {
+        console.warn('[MemoryEngine] Failed to initialize intelligence engines:', error.message);
+        this.intelligenceEnabled = false;
+      }
+    }
+    
+    // Load intelligence models - run in background to not block initialization
+    if (this.intelligenceEnabled) {
+      // Start model loading in background without awaiting
+      (async () => {
+        try {
+          const loadPromises = [
+            this.patternDetector.loadModel?.(),
+            this.suggestionEngine.loadModel?.(),
+            this.strategySelector.loadModel?.()
+          ].filter(Boolean);
+          
+          // Add timeout to prevent hanging
+          const timeoutPromise = new Promise((_, reject) => 
+            setTimeout(() => reject(new Error('Model loading timeout')), 5000)
+          );
+          
+          await Promise.race([
+            Promise.all(loadPromises),
+            timeoutPromise
+          ]);
+          
+          console.log('[MemoryEngine] ✅ Intelligence models loaded');
+        } catch (error) {
+          console.warn('[MemoryEngine] Model loading failed or timed out:', error.message);
+          // Don't disable intelligence - models are optional
+        }
+      })();
     }
   }
 

package/src/utils/parallel-search.js

@@ -98,7 +98,7 @@ export class ParallelSearch {
       );
       
       results = [...results, ...slowResults];
-      return this.mergeResults(results, maxResults);
+      return this.mergeResults(results, limit);
     }
 
     return merged;