@mrxkun/mcfast-mcp 4.1.10 → 4.1.11

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mrxkun/mcfast-mcp",
-  "version": "4.1.10",
-  "description": "Ultra-fast code editing with WASM acceleration, fuzzy patching, multi-layer caching, and 8 unified tools. v4.1.10: Suppress console output to prevent JSON-RPC stream corruption.",
+  "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

@@ -75,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
@@ -95,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;
@@ -645,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: []
+                }
             }
         ],
     };
@@ -847,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}`);
         }
@@ -3238,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");

package/src/memory/memory-engine.js

@@ -26,6 +26,9 @@ import { CuratedMemory } from './layers/curated-memory.js';
 // Bootstrap
 import { AgentsMdBootstrap } from './bootstrap/agents-md.js';
 
+// Project Analysis (AI-powered)
+import { execute as projectAnalyzeExecute } from '../tools/project_analyze.js';
+
 // Embedders
 import { UltraEnhancedEmbedder } from './utils/ultra-embedder.js';
 import { SmartRouter } from './utils/smart-router.js';
@@ -38,6 +41,7 @@ import { PatternDetector, SuggestionEngine, StrategySelector } from '../intellig
 export class MemoryEngine {
   static instance = null;
   static instancePromise = null;
+  static instancePid = null; // Track which process owns the instance
   
   /**
    * Get singleton instance of MemoryEngine
@@ -45,8 +49,19 @@ export class MemoryEngine {
    * @returns {MemoryEngine} Singleton instance
    */
   static getInstance(options = {}) {
+    const currentPid = process.pid;
+    
+    // Check if instance belongs to current process
+    if (MemoryEngine.instancePid !== currentPid) {
+      // Different process - reset instance
+      MemoryEngine.instance = null;
+      MemoryEngine.instancePromise = null;
+      MemoryEngine.instancePid = null;
+    }
+    
     if (!MemoryEngine.instance) {
       MemoryEngine.instance = new MemoryEngine(options);
+      MemoryEngine.instancePid = currentPid;
     }
     return MemoryEngine.instance;
   }
@@ -58,6 +73,16 @@ export class MemoryEngine {
    * @returns {Promise<MemoryEngine>} Initialized singleton instance
    */
   static async getOrCreate(projectPath, options = {}) {
+    const currentPid = process.pid;
+    
+    // Check if instance belongs to current process
+    if (MemoryEngine.instancePid !== currentPid) {
+      // Different process - reset instance
+      MemoryEngine.instance = null;
+      MemoryEngine.instancePromise = null;
+      MemoryEngine.instancePid = null;
+    }
+    
     if (MemoryEngine.instance && MemoryEngine.instance.isInitialized) {
       return MemoryEngine.instance;
     }
@@ -68,6 +93,7 @@ export class MemoryEngine {
     
     const engine = new MemoryEngine(options);
     MemoryEngine.instance = engine;
+    MemoryEngine.instancePid = currentPid;
     MemoryEngine.instancePromise = engine.initialize(projectPath).then(() => engine);
     
     return MemoryEngine.instancePromise;
@@ -131,6 +157,9 @@ export class MemoryEngine {
     this.suggestionEngine = null;
     this.strategySelector = null;
     
+    // Auto-analyze project on first use
+    this.autoAnalyze = options.autoAnalyze !== false;
+    
     // Search configuration
     this.searchConfig = {
       hybrid: {
@@ -208,7 +237,13 @@ export class MemoryEngine {
         '**/*.log'
       ]
     });
-    await this.watcher.start();
+    
+    try {
+      await this.watcher.start();
+    } catch (watcherError) {
+      console.error('[MemoryEngine] ⚠️ File watcher failed to start (continuing without file watching):', watcherError.message);
+      this.watcher = null;
+    }
     
     // Perform initial scan
     await this.performInitialScan();
@@ -223,6 +258,9 @@ export class MemoryEngine {
     console.error(`[MemoryEngine] Smart Routing: ${this.smartRoutingEnabled ? 'ENABLED' : 'DISABLED'}`);
     console.error(`[MemoryEngine] Intelligence: ${this.intelligenceEnabled ? 'ENABLED' : 'DISABLED'}`);
     
+    // Auto-analyze project if MCFAST_TOKEN is set
+    await this.autoAnalyzeProject();
+    
     // Log initialization to daily logs
     await this.dailyLogs.log('Memory Engine Initialized', `Project: ${projectPath}`, {
       stats: this.getStats()
@@ -264,6 +302,47 @@ export class MemoryEngine {
     }
   }
 
+  /**
+   * Auto-analyze project using AI if MCFAST_TOKEN is set
+   * Runs in background to not block initialization
+   */
+  async autoAnalyzeProject() {
+    if (!this.autoAnalyze) return;
+    
+    const apiKey = process.env.MCFAST_TOKEN;
+    if (!apiKey) {
+      console.error('[MemoryEngine] Skipping auto-analysis (no MCFAST_TOKEN)');
+      return;
+    }
+    
+    // Check if already analyzed (MEMORY.md has Project Context section)
+    try {
+      const memoryContent = await this.curatedMemory.read();
+      if (memoryContent && memoryContent.includes('## Project Context') && 
+          !memoryContent.includes('<!-- Add project context here -->')) {
+        console.error('[MemoryEngine] Project already analyzed, skipping auto-analysis');
+        return;
+      }
+    } catch (e) {
+      // MEMORY.md doesn't exist yet, proceed with analysis
+    }
+    
+    // Run analysis in background
+    console.error('[MemoryEngine] 🔄 Starting auto-analysis in background...');
+    
+    projectAnalyzeExecute({ force: false, updateMemory: true })
+      .then(result => {
+        if (result.metadata?.memoryUpdated) {
+          console.error('[MemoryEngine] ✅ Auto-analysis complete, MEMORY.md updated');
+        } else if (result.isError) {
+          console.error('[MemoryEngine] ⚠️ Auto-analysis failed:', result.content?.[0]?.text?.substring(0, 100));
+        }
+      })
+      .catch(err => {
+        console.error('[MemoryEngine] ⚠️ Auto-analysis error:', err.message);
+      });
+  }
+
   async performInitialScan() {
     if (this.isScanning) return;
     this.isScanning = true;
@@ -470,24 +549,44 @@ export class MemoryEngine {
 
   // ========== Storage Operations ==========
 
-  async storeIndexed(indexed) {
-    this.codebaseDb?.upsertFile?.(indexed.file);
-    this.codebaseDb?.deleteFactsByFile?.(indexed.file.id);
-    this.codebaseDb?.deleteChunksByFile?.(indexed.file.id);
+  async storeIndexed(indexed, maxRetries = 3) {
+    // Retry logic with exponential backoff
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        this.codebaseDb?.upsertFile?.(indexed.file);
+        this.codebaseDb?.deleteFactsByFile?.(indexed.file.id);
+        this.codebaseDb?.deleteChunksByFile?.(indexed.file.id);
 
-    for (const fact of indexed.facts) {
-      this.codebaseDb?.insertFact?.(fact);
-    }
+        for (const fact of indexed.facts) {
+          this.codebaseDb?.insertFact?.(fact);
+        }
 
-    for (const chunk of indexed.chunks) {
-      this.codebaseDb?.insertChunk?.(chunk);
-    }
+        for (const chunk of indexed.chunks) {
+          this.codebaseDb?.insertChunk?.(chunk);
+        }
+
+        for (const embedding of indexed.embeddings) {
+          this.codebaseDb?.insertEmbedding?.(embedding);
+        }
 
-    for (const embedding of indexed.embeddings) {
-      this.codebaseDb?.insertEmbedding?.(embedding);
+        return true; // Success
+      } catch (error) {
+        if (attempt === maxRetries) {
+          console.error(`[MemoryEngine] Failed to store indexed data after ${maxRetries} attempts:`, error.message);
+          this.codebaseDb?.recordFailedIndex?.(indexed.file.path, error.message);
+          return false;
+        }
+        // Exponential backoff: 100ms, 200ms, 400ms
+        await new Promise(resolve => setTimeout(resolve, 100 * Math.pow(2, attempt - 1)));
+      }
     }
   }
 
+  // Record failed indexing for tracking
+  recordFailedIndex(filePath, errorMessage) {
+    console.error(`[MemoryEngine] Indexing failed for ${filePath}: ${errorMessage}`);
+  }
+
   // ========== Search Operations ==========
 
   async searchFacts(query, limit = 20) {
@@ -573,6 +672,80 @@ export class MemoryEngine {
   }
 
   async searchCodebase(query, limit = 20) {
+    const startTime = performance.now();
+
+    // FIX: Get embeddings from both codebaseDb AND memoryDb
+    const [codebaseEmbeddings, memoryEmbeddings] = await Promise.all([
+      this.codebaseDb?.getAllEmbeddings?.() || [],
+      this.memoryDb?.getAllEmbeddings?.() || []
+    ]);
+
+    // Generate query embedding
+    const queryResult = this.embedder.embedCode(query);
+    const queryEmbedding = queryResult.vector;
+
+    // Score and tag results from each source
+    const scoreFn = (item) => {
+      const buf = item.embedding?.buffer || item.embedding;
+      const arr = buf ? new Uint8Array(buf) : new Uint8Array(0);
+      return this.embedder.cosineSimilarity(queryEmbedding, Array.from(arr));
+    };
+
+    const codebaseResults = (codebaseEmbeddings || []).map(item => ({
+      ...item, similarity: scoreFn(item), source: 'codebase', type: 'code'
+    }));
+
+    const memoryResults = (memoryEmbeddings || []).map(item => ({
+      ...item, similarity: scoreFn(item), source: 'memory', type: 'memory'
+    }));
+
+    // Combine results
+    let combined = [...codebaseResults, ...memoryResults];
+
+    // Also get FTS results from both databases
+    const [codebaseFts, memoryFts] = await Promise.all([
+      this.codebaseDb?.searchFTS?.(query, limit * 2) || { results: [] },
+      this.memoryDb?.searchFTS?.(query, limit * 2) || { results: [] }
+    ]);
+
+    // Add FTS results
+    for (const r of codebaseFts.results || []) {
+      combined.push({ ...r, source: 'fts', type: 'code', score: r.score });
+    }
+    for (const r of memoryFts.results || []) {
+      combined.push({ ...r, source: 'fts', type: 'memory', score: r.score });
+    }
+
+    // Deduplicate and sort
+    const seen = new Map();
+    for (const r of combined) {
+      const key = r.chunk_id || r.id;
+      if (!seen.has(key) || (r.similarity || r.score || 0) > (seen.get(key).similarity || seen.get(key).score || 0)) {
+        seen.set(key, r);
+      }
+    }
+
+    const finalResults = Array.from(seen.values())
+      .sort((a, b) => (b.similarity || b.score || 0) - (a.similarity || a.score || 0))
+      .slice(0, limit);
+
+    const duration = performance.now() - startTime;
+
+    return {
+      results: finalResults,
+      metadata: {
+        vectorCandidates: codebaseResults.length + memoryResults.length,
+        ftsCandidates: (codebaseFts.results?.length || 0) + (memoryFts.results?.length || 0),
+        totalCandidates: combined.length,
+        codebaseResults: codebaseResults.length,
+        memoryResults: memoryResults.length,
+        duration: duration.toFixed(2) + 'ms'
+      }
+    };
+  }
+
+  // Legacy search - kept for backward compatibility
+  async _searchCodebaseLegacy(query, limit = 20) {
     // Search codebase using existing methods
     const vectorResults = await this.searchVector(query, limit * 2);
     const ftsResults = this.codebaseDb?.searchFTS?.(query, limit * 2);
@@ -781,6 +954,33 @@ export class MemoryEngine {
     this.isInitialized = false;
     console.error('[MemoryEngine] Shutdown complete');
   }
+
+  async cleanup() {
+    // Alias for shutdown for consistency
+    return this.shutdown();
+  }
+}
+
+// Auto-register cleanup handlers for graceful shutdown
+if (typeof process !== 'undefined') {
+  const cleanupHandler = async (signal) => {
+    console.error(`[MemoryEngine] Received ${signal}, performing cleanup...`);
+    if (MemoryEngine.instance) {
+      try {
+        await MemoryEngine.instance.shutdown();
+      } catch (error) {
+        console.error(`[MemoryEngine] Error during shutdown: ${error.message}`);
+      }
+    }
+  };
+
+  // Register handlers only once
+  if (!process._memoryEngineCleanupRegistered) {
+    process.on('beforeExit', () => cleanupHandler('beforeExit'));
+    process.on('SIGINT', () => cleanupHandler('SIGINT'));
+    process.on('SIGTERM', () => cleanupHandler('SIGTERM'));
+    process._memoryEngineCleanupRegistered = true;
+  }
 }
 
 export default MemoryEngine;