@mrxkun/mcfast-mcp 4.1.9 → 4.1.11

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mrxkun/mcfast-mcp",
-  "version": "4.1.9",
-  "description": "Ultra-fast code editing with WASM acceleration, fuzzy patching, multi-layer caching, and 8 unified tools. v4.1.8: Debug mode - Write logs to .mcfast/mcp-debug.log",
+  "version": "4.1.11",
+  "description": "Ultra-fast code editing with WASM acceleration, fuzzy patching, multi-layer caching, and 8 unified tools. v4.1.11: Suppress console output to prevent JSON-RPC stream corruption.",
   "type": "module",
   "bin": {
     "mcfast-mcp": "src/index.js"

package/src/index.js

@@ -8,47 +8,33 @@
 // CRITICAL: Suppress ALL console output in MCP mode to prevent JSON parsing errors
 // MCP protocol requires stdout to contain ONLY JSON-RPC messages
 
-// Also override console.log - log to file in MCP mode
+// ANSI Color Codes for Terminal Output (MUST be defined before any usage)
+const colors = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    cyan: '\x1b[36m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    gray: '\x1b[90m',
+    white: '\x1b[37m',
+    bgBlack: '\x1b[40m',
+};
+
+// Override console.log - suppress in MCP mode
 const originalConsoleLog = console.log;
 console.log = function(...args) {
-    // Write to log file in project directory
-    try {
-        const logDir = process.cwd() + '/.mcfast';
-        const logFile = logDir + '/mcp-debug.log';
-        const message = `[${new Date().toISOString()}] [LOG] ${args.join(' ')}\n`;
-        
-        // Ensure directory exists
-        require('fs').mkdirSync(logDir, { recursive: true });
-        require('fs').appendFileSync(logFile, message);
-    } catch (e) {
-        // Ignore if can't write
-    }
+    // Suppressed in MCP mode
 };
 
-// Override console.error - log to file in MCP mode  
+// Override console.error - suppress in MCP mode  
 const originalConsoleError = console.error;
 console.error = function(...args) {
-    // Write to log file in project directory
-    try {
-        const logDir = process.cwd() + '/.mcfast';
-        const logFile = logDir + '/mcp-debug.log';
-        const message = `[${new Date().toISOString()}] [ERROR] ${args.join(' ')}\n`;
-        
-        // Ensure directory exists
-        require('fs').mkdirSync(logDir, { recursive: true });
-        require('fs').appendFileSync(logFile, message);
-    } catch (e) {
-        // Ignore if can't write
-    }
+    // Suppressed in MCP mode
 };
 
-// Write startup marker
-try {
-    const logDir = process.cwd() + '/.mcfast';
-    require('fs').mkdirSync(logDir, { recursive: true });
-    require('fs').appendFileSync(logDir + '/mcp-debug.log', `[${new Date().toISOString()}] [START] MCP initializing...\n`);
-} catch (e) {}
-
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { ListToolsRequestSchema, CallToolRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema } from "@modelcontextprotocol/sdk/types.js";
@@ -89,9 +75,87 @@ import { getAuditQueue } from './utils/audit-queue.js';
 import { getIntelligenceCache } from './utils/intelligence-cache.js';
 import { getContextPrefetcher } from './utils/context-prefetcher.js';
 import { parallelMemorySearch } from './utils/parallel-search.js';
+import { execute as projectAnalyzeExecute } from './tools/project_analyze.js';
 
 const execAsync = promisify(exec);
 
+// ============================================================================
+// LOCK FILE MECHANISM - Prevent multiple instances running simultaneously
+// ============================================================================
+const LOCK_FILE_PATH = path.join(process.cwd(), '.mcfast', '.mcp-instance.lock');
+let lockFileHandle = null;
+
+async function acquireLock() {
+  try {
+    const lockDir = path.dirname(LOCK_FILE_PATH);
+    await fs.mkdir(lockDir, { recursive: true });
+    
+    lockFileHandle = await fs.open(LOCK_FILE_PATH, 'wx');
+    
+    // Write current PID
+    await lockFileHandle.write(`${process.pid}\n${Date.now()}\n`, 0);
+    await lockFileHandle.sync();
+    
+    // Cleanup on exit
+    process.on('beforeExit', releaseLock);
+    process.on('SIGINT', releaseLock);
+    process.on('SIGTERM', releaseLock);
+    process.on('uncaughtException', releaseLock);
+    
+    console.error(`${colors.cyan}[Lock]${colors.reset} Acquired lock file: ${LOCK_FILE_PATH}`);
+    return true;
+  } catch (error) {
+    if (error.code === 'EEXIST') {
+      // Lock file exists, check if it's stale
+      try {
+        const lockContent = await fs.readFile(LOCK_FILE_PATH, 'utf-8');
+        const [pid, timestamp] = lockContent.trim().split('\n');
+        const lockAge = Date.now() - parseInt(timestamp);
+        
+        // Check if process is still running (stale lock if > 5 minutes)
+        if (lockAge > 5 * 60 * 1000) {
+          console.error(`${colors.yellow}[Lock]${colors.reset} Stale lock detected (age: ${Math.round(lockAge / 1000)}s), removing...`);
+          await fs.unlink(LOCK_FILE_PATH);
+          return acquireLock(); // Retry
+        }
+        
+        console.error(`${colors.red}[Lock]${colors.reset} Another instance is already running (PID: ${pid})`);
+        console.error(`${colors.yellow}[Lock]${colors.reset} To force start, delete: ${LOCK_FILE_PATH}`);
+        return false;
+      } catch (readError) {
+        console.error(`${colors.red}[Lock]${colors.reset} Failed to read lock file: ${readError.message}`);
+        return false;
+      }
+    }
+    console.error(`${colors.red}[Lock]${colors.reset} Failed to acquire lock: ${error.message}`);
+    return false;
+  }
+}
+
+async function releaseLock() {
+  if (lockFileHandle) {
+    try {
+      await lockFileHandle.close();
+      lockFileHandle = null;
+    } catch (e) {
+      // Ignore close errors
+    }
+  }
+  
+  try {
+    await fs.unlink(LOCK_FILE_PATH);
+    console.error(`${colors.cyan}[Lock]${colors.reset} Released lock file`);
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      console.error(`${colors.yellow}[Lock]${colors.reset} Failed to release lock: ${error.message}`);
+    }
+  }
+}
+
+// ============================================================================
+// END LOCK FILE MECHANISM
+// ============================================================================
+
 const API_URL = "https://mcfast.vercel.app/api/v1";
 const TOKEN = process.env.MCFAST_TOKEN;
 const VERBOSE = process.env.MCFAST_VERBOSE !== 'false'; // Default: true
@@ -109,28 +173,49 @@ 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;
+        const maxRetries = 2;
+        let lastError = null;
+        
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                memoryEngine = new MemoryEngine({
+                    apiKey: TOKEN,
+                    enableSync: true
+                });
+                
+                // Use 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`);
+                return memoryEngine;
+                
+            } catch (error) {
+                lastError = error;
+                console.error(`${colors.yellow}[Memory]${colors.reset} Initialization attempt ${attempt}/${maxRetries} failed: ${error.message}`);
+                
+                if (attempt < maxRetries) {
+                    // Exponential backoff before retry
+                    const backoffMs = 1000 * Math.pow(2, attempt - 1);
+                    console.error(`${colors.yellow}[Memory]${colors.reset} Retrying in ${backoffMs}ms...`);
+                    await new Promise(resolve => setTimeout(resolve, backoffMs));
+                }
+            }
         }
+        
+        // All retries failed - graceful degradation
+        console.error(`${colors.yellow}[Memory]${colors.reset} All initialization attempts failed. Running in degraded mode.`);
+        console.error(`${colors.yellow}[Memory]${colors.reset} Error: ${lastError?.message || 'Unknown error'}`);
+        console.error(`${colors.yellow}[Memory]${colors.reset} Tools requiring memory will be unavailable.`);
+        memoryEngineReady = false;
+        return null;
     })();
     
     return memoryEngineInitPromise;
@@ -331,21 +416,6 @@ async function analyzeRenameImpact(symbolName, currentFile = null) {
     }
 }
 
-// ANSI Color Codes for Terminal Output
-const colors = {
-    reset: '\x1b[0m',
-    bold: '\x1b[1m',
-    dim: '\x1b[2m',
-    cyan: '\x1b[36m',
-    green: '\x1b[32m',
-    yellow: '\x1b[33m',
-    blue: '\x1b[34m',
-    magenta: '\x1b[35m',
-    gray: '\x1b[90m',
-    white: '\x1b[37m',
-    bgBlack: '\x1b[40m',
-};
-
 // Tool icons (v2.0 - 4 core tools)
 const toolIcons = {
     edit: '✏️',
@@ -630,11 +700,11 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             // MEMORY TOOL 2: memory_get
             {
                 name: "memory_get",
-                description: "📚 Get stored memories: today's log, curated memories, or intelligence stats. Use to review recent changes or long-term knowledge.",
+                description: "📚 Get stored memories: today's log, curated memories, stats, or trigger re-index. Use to review recent changes or long-term knowledge.",
                 inputSchema: {
                     type: "object",
                     properties: {
-                        type: { type: "string", enum: ["today_log", "curated", "stats", "intelligence"], description: "Type of memory to retrieve" }
+                        type: { type: "string", enum: ["today_log", "curated", "stats", "intelligence", "reindex"], description: "Type of memory to retrieve or 'reindex' to trigger codebase re-indexing" }
                     },
                     required: ["type"]
                 }
@@ -674,6 +744,19 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     },
                     required: ["instruction"]
                 }
+            },
+            // PROJECT ANALYSIS TOOL
+            {
+                name: "project_analyze",
+                description: "🔍 Analyze project structure using AI (Mercury). Returns: Project Overview, Technologies, API Endpoints, Main Features. Auto-updates MEMORY.md. Requires MCFAST_TOKEN.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        force: { type: "boolean", description: "Force re-analysis (ignore cache)" },
+                        updateMemory: { type: "boolean", description: "Update MEMORY.md with results (default: true)" }
+                    },
+                    required: []
+                }
             }
         ],
     };
@@ -876,6 +959,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             result = await handleSelectStrategy(args);
             summary = 'Strategy selected';
         }
+        // PROJECT ANALYSIS TOOL
+        else if (name === "project_analyze") {
+            result = await projectAnalyzeExecute(args);
+            summary = 'Project analyzed';
+        }
         else {
             throw new Error(`Tool not found: ${name}`);
         }
@@ -2075,10 +2163,6 @@ async function handleReadFileInternal({ path: filePath, start_line, end_line, ma
 
         if (startLine < 1) startLine = 1;
         if (endLine < 1 || endLine > totalLines) endLine = totalLines;
-        if (startLine > endLine) {
-            throw new Error(`Invalid line range: start_line (${startLine}) > end_line (${endLine})`);
-        }
-
         if (start_line || end_line) {
             outputContent = lines.slice(startLine - 1, endLine).join('\n');
         } else if (max_lines && lines.length > max_lines) {
@@ -2930,7 +3014,7 @@ async function handleMemorySearch({ query, type = 'all', maxResults = 6, minScor
                 score: fact.confidence || 0.8
             }));
         } else if (type === 'code') {
-            const searchResult = await engine.ultraSearch(query, { limit: maxResults });
+            const searchResult = await engine.intelligentSearch(query, { limit: maxResults });
             results = searchResult.results.map(result => ({
                 type: 'chunk',
                 content: result.code || result.content,
@@ -3022,10 +3106,31 @@ async function handleMemoryGet({ type }) {
         } else if (type === 'stats') {
             const stats = await engine.getStats();
             output = `📊 Memory Stats\n\n`;
-            output += `Total chunks: ${stats.totalChunks || 0}\n`;
-            output += `Total facts: ${stats.totalFacts || 0}\n`;
-            output += `Index size: ${stats.indexSize || 0}\n`;
-            output += `Last indexed: ${stats.lastIndexed || 'Never'}`;
+            output += `📝 Memory Index\n`;
+            output += `  Files: ${stats.memory?.files || 0}\n`;
+            output += `  Chunks: ${stats.memory?.chunks || 0}\n`;
+            output += `  Embeddings: ${stats.memory?.embeddings || 0}\n\n`;
+            output += `💻 Codebase Index\n`;
+            output += `  Files: ${stats.codebase?.files || 0}\n`;
+            output += `  Facts: ${stats.codebase?.facts || 0}\n`;
+            output += `  Chunks: ${stats.codebase?.chunks || 0}\n`;
+            output += `  Embeddings: ${stats.codebase?.embeddings || 0}\n`;
+            output += `  Edits: ${stats.codebase?.edits || 0}\n\n`;
+            output += `🔄 Indexing\n`;
+            output += `  Complete: ${stats.indexing?.is_complete ? '✅' : '⏳'}\n`;
+            output += `  Indexed: ${stats.indexing?.indexed_files || 0}/${stats.indexing?.total_files || 0}\n`;
+            output += `  Failed: ${stats.indexing?.failed_files || 0}\n`;
+        } else if (type === 'reindex') {
+            output = `🔄 Re-indexing Codebase\n\n`;
+            output += `Starting re-index in background...\n`;
+            
+            // Trigger re-index in background
+            engine.performInitialScan().catch(err => {
+                console.error('[Reindex] Error:', err.message);
+            });
+            
+            output += `✅ Re-index started. Check stats in a few seconds.\n`;
+            output += `Use 'memory_get stats' to check progress.`;
         } else if (type === 'intelligence') {
             const intelStats = engine.getIntelligenceStats();
             output = `🧠 Intelligence Stats\n\n`;
@@ -3250,12 +3355,50 @@ async function handleSelectStrategy({ instruction, files = [] }) {
 /**
  * Start Server
  */
+
+// Acquire lock before starting - prevents multiple instances
+const lockAcquired = await acquireLock();
+if (!lockAcquired) {
+  console.error(`${colors.red}[ERROR]${colors.reset} Failed to acquire lock. Another mcfast-mcp instance may be running.`);
+  console.error(`${colors.yellow}[HINT]${colors.reset} Delete ${LOCK_FILE_PATH} if you're sure no other instance is running.`);
+  process.exit(1);
+}
+
 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}`);
+    // Don't exit - continue without memory
 });
 
+// Graceful shutdown handler
+async function gracefulShutdown(signal) {
+  console.error(`${colors.yellow}[Shutdown]${colors.reset} Received ${signal}, cleaning up...`);
+  
+  try {
+    // Stop memory engine
+    if (memoryEngine && memoryEngineReady) {
+      await memoryEngine.cleanup();
+    }
+    
+    // Flush audit queue
+    const auditQ = getAuditQueue();
+    await auditQ.destroy();
+    
+    // Release lock
+    await releaseLock();
+    
+    console.error(`${colors.green}[Shutdown]${colors.reset} Cleanup complete`);
+  } catch (error) {
+    console.error(`${colors.red}[Shutdown]${colors.reset} Error during cleanup: ${error.message}`);
+  }
+  
+  process.exit(0);
+}
+
+process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+
 await server.connect(transport);
 console.error("mcfast MCP v1.0.0 running on stdio");