@mrxkun/mcfast-mcp 4.0.12 → 4.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrxkun/mcfast-mcp",
-  "version": "4.0.12",
+  "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;
 }
 
@@ -1256,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
@@ -1266,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
@@ -2512,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 {
@@ -2881,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 = '';
@@ -2946,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();
@@ -2993,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({
@@ -3046,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 });
@@ -3090,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

@@ -118,12 +118,33 @@ export class MemoryEngine {
       }
     }
     
-    // Load intelligence models
+    // Load intelligence models - run in background to not block initialization
     if (this.intelligenceEnabled) {
-      await this.patternDetector.loadModel?.();
-      await this.suggestionEngine.loadModel?.();
-      await this.strategySelector.loadModel?.();
-      console.log('[MemoryEngine] ✅ Intelligence models loaded');
+      // 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;