@mrxkun/mcfast-mcp 4.1.13 → 4.1.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrxkun/mcfast-mcp",
-  "version": "4.1.13",
+  "version": "4.1.15",
   "description": "Ultra-fast code editing with WASM acceleration, fuzzy patching, multi-layer caching, and 8 unified tools. v4.1.12: Implement proper MCP stdio transport lifecycle and cleanup to prevent zombie processes.",
   "type": "module",
   "bin": {

package/src/index.js

@@ -8,7 +8,10 @@
 // CRITICAL: Suppress ALL console output in MCP mode to prevent JSON parsing errors
 // MCP protocol requires stdout to contain ONLY JSON-RPC messages
 
-// ANSI Color Codes for Terminal Output (MUST be defined before any usage)
+import os from 'os';
+import crypto from 'crypto';
+
+// ANSI Color Codes for Terminal Output
 const colors = {
     reset: '\x1b[0m',
     bold: '\x1b[1m',
@@ -29,11 +32,11 @@ console.log = function (...args) {
     // Suppressed in MCP mode
 };
 
-// Override console.error - suppress in MCP mode  
-const originalConsoleError = console.error;
-console.error = function (...args) {
-    // Suppressed in MCP mode
-};
+// Keep console.error enabled for debugging and MCP logging
+// const originalConsoleError = console.error;
+// console.error = function(...args) {
+//     // Suppressed in MCP mode
+// };
 
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -81,8 +84,11 @@ const execAsync = promisify(exec);
 
 // ============================================================================
 // LOCK FILE MECHANISM - Prevent multiple instances running simultaneously
+// Use home directory to avoid permission issues in project root or systems where CWD is /
 // ============================================================================
-const LOCK_FILE_PATH = path.join(process.cwd(), '.mcfast', '.mcp-instance.lock');
+const LOCK_DIR = path.join(os.homedir(), '.mcfast', 'locks');
+const projectHash = crypto.createHash('md5').update(process.cwd()).digest('hex');
+const LOCK_FILE_PATH = path.join(LOCK_DIR, `${projectHash}.lock`);
 let lockFileHandle = null;
 
 async function acquireLock() {
@@ -112,9 +118,21 @@ async function acquireLock() {
                 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...`);
+                // Robust stale check: stale if > 5 mins OR timestamp is in the future (prevent stuck lock)
+                // OR check if PID is actually running
+                let isStale = lockAge > 5 * 60 * 1000 || lockAge < -60 * 1000;
+
+                if (!isStale && pid) {
+                    try {
+                        process.kill(parseInt(pid), 0);
+                    } catch (e) {
+                        // PID not running
+                        isStale = true;
+                    }
+                }
+
+                if (isStale) {
+                    console.error(`${colors.yellow}[Lock]${colors.reset} Stale or invalid lock detected, removing...`);
                     await fs.unlink(LOCK_FILE_PATH);
                     return acquireLock(); // Retry
                 }

package/src/memory/memory-engine.js

@@ -42,7 +42,7 @@ export class MemoryEngine {
   static instance = null;
   static instancePromise = null;
   static instancePid = null; // Track which process owns the instance
-  
+
   /**
    * Get singleton instance of MemoryEngine
    * @param {Object} options - Configuration options
@@ -50,7 +50,7 @@ export class MemoryEngine {
    */
   static getInstance(options = {}) {
     const currentPid = process.pid;
-    
+
     // Check if instance belongs to current process
     if (MemoryEngine.instancePid !== currentPid) {
       // Different process - reset instance
@@ -58,14 +58,14 @@ export class MemoryEngine {
       MemoryEngine.instancePromise = null;
       MemoryEngine.instancePid = null;
     }
-    
+
     if (!MemoryEngine.instance) {
       MemoryEngine.instance = new MemoryEngine(options);
       MemoryEngine.instancePid = currentPid;
     }
     return MemoryEngine.instance;
   }
-  
+
   /**
    * Get or create singleton instance with async initialization
    * @param {string} projectPath - Project path
@@ -74,7 +74,7 @@ export class MemoryEngine {
    */
   static async getOrCreate(projectPath, options = {}) {
     const currentPid = process.pid;
-    
+
     // Check if instance belongs to current process
     if (MemoryEngine.instancePid !== currentPid) {
       // Different process - reset instance
@@ -82,47 +82,47 @@ export class MemoryEngine {
       MemoryEngine.instancePromise = null;
       MemoryEngine.instancePid = null;
     }
-    
+
     if (MemoryEngine.instance && MemoryEngine.instance.isInitialized) {
       return MemoryEngine.instance;
     }
-    
+
     if (MemoryEngine.instancePromise) {
       return MemoryEngine.instancePromise;
     }
-    
+
     const engine = new MemoryEngine(options);
     MemoryEngine.instance = engine;
     MemoryEngine.instancePid = currentPid;
     MemoryEngine.instancePromise = engine.initialize(projectPath).then(() => engine);
-    
+
     return MemoryEngine.instancePromise;
   }
 
   constructor(options = {}) {
     this.projectPath = null;
     this.isInitialized = false;
-    
+
     // Paths
     this.memoryPath = options.memoryPath || null;
     this.indexPath = options.indexPath || null;
-    
+
     // Databases (separate concerns)
     this.memoryDb = null;      // For notes/memory (Markdown source)
     this.codebaseDb = null;    // For code indexing
-    
+
     // Two-tier memory
     this.dailyLogs = null;
     this.curatedMemory = null;
-    
+
     // Bootstrap
     this.agentsBootstrap = null;
-    
+
     // Indexing
     this.indexer = new CodeIndexer(options.indexer);
     this.watcher = null;
     this.isScanning = false;
-    
+
     // Sync Engine
     this.syncEngine = null;
     this.syncEngineOptions = {
@@ -130,14 +130,14 @@ export class MemoryEngine {
       baseUrl: options.baseUrl || process.env.MCFAST_DASHBOARD_URL || 'https://mcfast.vercel.app',
       syncInterval: options.syncInterval || 5 * 60 * 1000
     };
-    
+
     // Embedder
     this.embedder = new UltraEnhancedEmbedder({
       dimension: options.dimension || 1024,
       cacheSize: options.cacheSize || 2000,
       useMercury: options.useMercury || false
     });
-    
+
     // Smart routing
     this.dashboardClient = options.dashboardClient || new DashboardClient({
       apiKey: process.env.MCFAST_TOKEN
@@ -145,21 +145,21 @@ export class MemoryEngine {
     this.smartRouter = new SmartRouter({
       dashboardClient: this.dashboardClient
     });
-    
+
     // Configuration
     this.useUltraHybrid = options.useUltraHybrid !== false;
     this.targetAccuracy = options.targetAccuracy || 90;
     this.smartRoutingEnabled = options.smartRoutingEnabled !== false;
-    
+
     // Intelligence
     this.intelligenceEnabled = options.intelligenceEnabled !== false;
     this.patternDetector = null;
     this.suggestionEngine = null;
     this.strategySelector = null;
-    
+
     // Auto-analyze project on first use
     this.autoAnalyze = options.autoAnalyze !== false;
-    
+
     // Search configuration
     this.searchConfig = {
       hybrid: {
@@ -178,7 +178,7 @@ export class MemoryEngine {
     if (this.isInitialized) return;
 
     this.projectPath = projectPath;
-    
+
     // Setup paths
     if (!this.memoryPath) {
       this.memoryPath = path.join(projectPath, '.mcfast');
@@ -186,19 +186,19 @@ export class MemoryEngine {
     if (!this.indexPath) {
       this.indexPath = path.join(this.memoryPath, 'index');
     }
-    
+
     // Create directories
     await fs.mkdir(this.memoryPath, { recursive: true });
     await fs.mkdir(this.indexPath, { recursive: true });
-    
+
     console.error(`[MemoryEngine] Initializing...`);
     console.error(`[MemoryEngine] Project: ${projectPath}`);
     console.error(`[MemoryEngine] Memory path: ${this.memoryPath}`);
-    
+
     // Initialize bootstrap (AGENTS.md)
     this.agentsBootstrap = new AgentsMdBootstrap({ projectPath });
     await this.agentsBootstrap.bootstrap();
-    
+
     // Initialize databases
     this.memoryDb = new MemoryDatabase(
       path.join(this.indexPath, 'memory.sqlite')
@@ -206,15 +206,15 @@ export class MemoryEngine {
     this.codebaseDb = new CodebaseDatabase(
       path.join(this.indexPath, 'codebase.sqlite')
     );
-    
+
     await this.memoryDb.initialize();
     await this.codebaseDb.initialize();
-    
+
     // Initialize two-tier memory
     this.dailyLogs = new DailyLogs({ memoryPath: this.memoryPath });
     this.curatedMemory = new CuratedMemory({ memoryPath: this.memoryPath });
     await this.curatedMemory.ensureFile(); // Create MEMORY.md if not exists
-    
+
     // Initialize sync engine
     if (this.syncEngineOptions.apiKey && this.syncEngineOptions.enableSync !== false) {
       this.syncEngine = new SyncEngine({
@@ -224,10 +224,10 @@ export class MemoryEngine {
         syncInterval: this.syncEngineOptions.syncInterval
       });
     }
-    
+
     // Initialize file watcher (configurable via MCFAST_FILE_WATCHER env)
     const ENABLE_FILE_WATCHER = process.env.MCFAST_FILE_WATCHER !== 'false';
-    
+
     if (ENABLE_FILE_WATCHER) {
       this.watcher = new FileWatcher(projectPath, this, {
         debounceMs: 1500,
@@ -240,7 +240,7 @@ export class MemoryEngine {
           '**/*.log'
         ]
       });
-      
+
       try {
         await this.watcher.start();
       } catch (watcherError) {
@@ -251,23 +251,25 @@ export class MemoryEngine {
       console.error('[MemoryEngine] File watcher disabled (MCFAST_FILE_WATCHER=false)');
       this.watcher = null;
     }
-    
-    // Perform initial scan
-    await this.performInitialScan();
-    
+
+    // Start initial scan in background (don't block initialize)
+    this.performInitialScan().catch(error => {
+      console.error('[MemoryEngine] Background scan error:', error);
+    });
+
     // Initialize intelligence
     await this.initializeIntelligence();
-    
+
     this.isInitialized = true;
-    
+
     console.error(`[MemoryEngine] ✅ Initialized successfully`);
     console.error(`[MemoryEngine] Hybrid Search: ${this.searchConfig.hybrid.enabled ? 'ENABLED' : 'DISABLED'}`);
     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()
@@ -276,14 +278,14 @@ export class MemoryEngine {
 
   async initializeIntelligence() {
     if (!this.intelligenceEnabled) return;
-    
+
     try {
       this.patternDetector = new PatternDetector({ memoryEngine: this });
       this.suggestionEngine = new SuggestionEngine({ memoryEngine: this });
       this.strategySelector = new StrategySelector({ memoryEngine: this });
-      
+
       console.error('[MemoryEngine] Intelligence engines initialized');
-      
+
       // Load models in background
       (async () => {
         try {
@@ -292,11 +294,11 @@ export class MemoryEngine {
             this.suggestionEngine.loadModel?.(),
             this.strategySelector.loadModel?.()
           ].filter(Boolean);
-          
-          const timeoutPromise = new Promise((_, reject) => 
+
+          const timeoutPromise = new Promise((_, reject) =>
             setTimeout(() => reject(new Error('Model loading timeout')), 5000)
           );
-          
+
           await Promise.race([Promise.all(loadPromises), timeoutPromise]);
           console.error('[MemoryEngine] ✅ Intelligence models loaded');
         } catch (error) {
@@ -315,28 +317,28 @@ export class MemoryEngine {
    */
   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 -->')) {
+      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) {
@@ -353,22 +355,22 @@ export class MemoryEngine {
   async performInitialScan() {
     if (this.isScanning) return;
     this.isScanning = true;
-    
+
     console.error('[MemoryEngine] 🔍 Performing initial codebase scan...');
-    
+
     try {
       // Scan memory files first
       await this.scanMemoryFiles();
-      
+
       // Scan codebase
       await this.scanCodebase();
-      
+
       // Update indexing progress
       this.codebaseDb?.completeIndexing?.();
-      
+
       console.error('[MemoryEngine] ✅ Initial scan complete');
       console.error(`[MemoryEngine] Stats:`, this.getStats());
-      
+
     } catch (error) {
       console.error('[MemoryEngine] Error during initial scan:', error);
     } finally {
@@ -378,14 +380,14 @@ export class MemoryEngine {
 
   async scanMemoryFiles() {
     console.error('[MemoryEngine] Scanning memory files...');
-    
+
     try {
       // Index MEMORY.md
       const memoryFile = path.join(this.memoryPath, 'MEMORY.md');
       if (await this.fileExists(memoryFile)) {
         await this.indexMarkdownFile(memoryFile);
       }
-      
+
       // Index daily logs
       const memoryDir = path.join(this.memoryPath, 'memory');
       if (await this.fileExists(memoryDir)) {
@@ -394,7 +396,7 @@ export class MemoryEngine {
           await this.indexMarkdownFile(path.join(memoryDir, file));
         }
       }
-      
+
       console.error('[MemoryEngine] Memory files indexed');
     } catch (error) {
       console.error('[MemoryEngine] Error scanning memory files:', error);
@@ -403,37 +405,37 @@ export class MemoryEngine {
 
   async scanCodebase() {
     console.error('[MemoryEngine] Scanning codebase...');
-    
+
     const extensions = ['.js', '.jsx', '.ts', '.tsx', '.py', '.java', '.go', '.rs', '.cpp', '.c', '.h'];
     const files = await this.findFiles(this.projectPath, extensions);
-    
+
     if (files.length === 0) {
       console.error('[MemoryEngine] No code files found to index');
       return;
     }
-    
+
     console.error(`[MemoryEngine] Found ${files.length} files to index`);
-    
+
     // Start indexing progress
     this.codebaseDb?.startIndexing?.(files.length);
-    
+
     let indexed = 0;
     let failed = 0;
-    
+
     for (const filePath of files) {
       try {
         const content = await fs.readFile(filePath, 'utf-8');
         const contentHash = crypto.createHash('md5').update(content).digest('hex');
-        
+
         // Skip if already indexed
         if (this.codebaseDb?.isFileIndexed?.(filePath, contentHash)) {
           continue;
         }
-        
+
         // Index file
         const indexedData = await this.indexer.indexFile(filePath, content);
         await this.storeIndexed(indexedData);
-        
+
         indexed++;
         if (indexed % 10 === 0) {
           console.error(`[MemoryEngine] Indexed ${indexed}/${files.length} files...`);
@@ -443,7 +445,7 @@ export class MemoryEngine {
         failed++;
       }
     }
-    
+
     console.error(`[MemoryEngine] Codebase scan complete: ${indexed} indexed, ${failed} failed`);
   }
 
@@ -453,40 +455,40 @@ export class MemoryEngine {
       const contentHash = crypto.createHash('md5').update(content).digest('hex');
       const stats = await fs.stat(filePath);
       const relativePath = path.relative(this.projectPath, filePath);
-      
+
       // Skip if unchanged
       if (this.memoryDb?.isFileIndexed?.(relativePath, contentHash)) {
         return;
       }
-      
+
       // Import chunker dynamically
       const { MarkdownChunker } = await import('./utils/markdown-chunker.js');
       const chunker = new MarkdownChunker({
         chunkSize: this.searchConfig.chunkSize * 4, // chars
         overlap: this.searchConfig.chunkOverlap * 4
       });
-      
+
       const chunks = chunker.chunk(content, relativePath);
-      
+
       // Track file
       this.memoryDb?.upsertFile?.(relativePath, contentHash, stats.mtimeMs, stats.size);
-      
+
       // Delete old chunks
       this.memoryDb?.deleteChunksByFile?.(relativePath);
-      
+
       // Process chunks
       for (const chunk of chunks) {
         // Check embedding cache
         let embedding = null;
         const cached = this.memoryDb?.getCachedEmbedding?.(chunk.contentHash);
-        
+
         if (cached) {
           embedding = new Float32Array(cached.embedding.buffer, cached.embedding.byteOffset, cached.dimensions);
         } else {
           // Generate embedding
           const result = this.embedder.embedCode(chunk.content);
           embedding = result.vector;
-          
+
           // Cache it
           this.memoryDb?.cacheEmbedding?.(
             chunk.contentHash,
@@ -495,7 +497,7 @@ export class MemoryEngine {
             embedding.length
           );
         }
-        
+
         // Insert chunk
         this.memoryDb?.insertChunk?.({
           id: chunk.id,
@@ -506,7 +508,7 @@ export class MemoryEngine {
           content_hash: chunk.contentHash,
           chunk_type: chunk.chunkType
         });
-        
+
         // Insert embedding
         this.memoryDb?.insertEmbedding?.({
           chunk_id: chunk.id,
@@ -515,7 +517,7 @@ export class MemoryEngine {
           dimensions: embedding.length
         });
       }
-      
+
     } catch (error) {
       console.warn(`[MemoryEngine] Failed to index markdown ${filePath}:`, error.message);
     }
@@ -524,13 +526,13 @@ export class MemoryEngine {
   async findFiles(dir, extensions) {
     const files = [];
     const ignored = ['node_modules', '.git', 'dist', 'build', '.mcfast'];
-    
+
     try {
       const entries = await fs.readdir(dir, { withFileTypes: true });
-      
+
       for (const entry of entries) {
         const fullPath = path.join(dir, entry.name);
-        
+
         if (entry.isDirectory() && !ignored.includes(entry.name)) {
           const subFiles = await this.findFiles(fullPath, extensions);
           files.push(...subFiles);
@@ -541,7 +543,7 @@ export class MemoryEngine {
     } catch (error) {
       // Permission denied or other error, skip
     }
-    
+
     return files;
   }
 
@@ -602,26 +604,26 @@ export class MemoryEngine {
 
   async searchVector(query, limit = 20) {
     const startTime = performance.now();
-    
+
     const queryResult = this.embedder.embedCode(query);
     const queryEmbedding = queryResult.vector;
-    
+
     const allEmbeddings = this.codebaseDb?.getAllEmbeddings?.() || [];
-    
+
     const scored = allEmbeddings.map(item => {
       const vector = Array.from(new Float32Array(item.embedding.buffer, item.embedding.byteOffset, item.embedding.byteLength / 4));
       const similarity = this.embedder.cosineSimilarity(queryEmbedding, vector);
-      return { 
-        ...item, 
+      return {
+        ...item,
         similarity,
         queryEmbedding: queryResult.metadata
       };
     });
-    
+
     scored.sort((a, b) => b.similarity - a.similarity);
-    
+
     const duration = performance.now() - startTime;
-    
+
     return {
       results: scored.slice(0, limit),
       metadata: {
@@ -640,15 +642,15 @@ export class MemoryEngine {
   async searchHybrid(query, options = {}) {
     const startTime = performance.now();
     const limit = options.limit || 10;
-    
+
     console.error(`[MemoryEngine] 🔍 Hybrid search: "${query}"`);
-    
+
     // Get vector results first
     const vectorResult = await this.searchVector(query, limit * 4);
-    
+
     // Use database hybrid search
     const dbResults = this.memoryDb?.searchHybrid?.(query, vectorResult.results, limit);
-    
+
     if (dbResults) {
       const totalDuration = performance.now() - startTime;
       return {
@@ -659,7 +661,7 @@ export class MemoryEngine {
         }
       };
     }
-    
+
     // Fallback to vector-only if hybrid fails
     return vectorResult;
   }
@@ -670,11 +672,11 @@ export class MemoryEngine {
       useHybrid = this.searchConfig.hybrid.enabled,
       minScore = this.searchConfig.hybrid.minScore
     } = options;
-    
+
     if (useHybrid) {
       return this.searchHybrid(query, { limit, minScore });
     }
-    
+
     return this.searchVector(query, limit);
   }
 
@@ -756,18 +758,18 @@ export class MemoryEngine {
     // Search codebase using existing methods
     const vectorResults = await this.searchVector(query, limit * 2);
     const ftsResults = this.codebaseDb?.searchFTS?.(query, limit * 2);
-    
+
     // Combine and deduplicate
     const seen = new Set();
     const combined = [];
-    
+
     for (const r of vectorResults.results) {
       if (!seen.has(r.chunk_id)) {
         seen.add(r.chunk_id);
         combined.push({ ...r, source: 'vector' });
       }
     }
-    
+
     if (ftsResults?.results) {
       for (const r of ftsResults.results) {
         if (!seen.has(r.chunk_id)) {
@@ -776,10 +778,10 @@ export class MemoryEngine {
         }
       }
     }
-    
+
     // Sort by score and limit
     combined.sort((a, b) => (b.similarity || b.score) - (a.similarity || a.score));
-    
+
     return {
       results: combined.slice(0, limit),
       metadata: {
@@ -845,7 +847,7 @@ export class MemoryEngine {
   async logEdit(edit) {
     // Log to daily
     await this.dailyLogs?.logEdit?.(edit);
-    
+
     // Record to database
     this.codebaseDb?.recordEdit?.({
       id: Math.random().toString(36).substring(2, 15),
@@ -876,7 +878,7 @@ export class MemoryEngine {
     if (!this.intelligenceEnabled || !this.patternDetector) {
       throw new Error('Intelligence layer not enabled');
     }
-    
+
     const editHistory = this.codebaseDb?.getRecentEdits?.(100) || [];
     return this.patternDetector.analyze(editHistory);
   }
@@ -885,7 +887,7 @@ export class MemoryEngine {
     if (!this.intelligenceEnabled || !this.suggestionEngine) {
       throw new Error('Intelligence layer not enabled');
     }
-    
+
     return this.suggestionEngine.getSuggestions(context);
   }
 
@@ -893,21 +895,21 @@ export class MemoryEngine {
     if (!this.intelligenceEnabled || !this.strategySelector) {
       return this.fallbackStrategySelection(instruction, context);
     }
-    
+
     return this.strategySelector.selectStrategy(instruction, context);
   }
 
   fallbackStrategySelection(instruction, context) {
     const lower = instruction.toLowerCase();
-    
+
     if (lower.includes('replace') || lower.includes('change line') || lower.includes('exact')) {
       return { strategy: 'deterministic', confidence: 0.8, reason: 'Simple replacement detected' };
     }
-    
+
     if (lower.includes('refactor') || lower.includes('improve') || lower.includes('multiple')) {
       return { strategy: 'llm', confidence: 0.8, reason: 'Complex operation detected' };
     }
-    
+
     return { strategy: 'cached', confidence: 0.6, reason: 'Default selection' };
   }
 
@@ -947,17 +949,17 @@ export class MemoryEngine {
 
   async shutdown() {
     console.error('[MemoryEngine] Shutting down...');
-    
+
     if (this.intelligenceEnabled) {
       await this.strategySelector?.saveModel?.();
     }
-    
+
     await this.watcher?.stop?.();
     this.syncEngine?.shutdown?.();
-    
+
     this.memoryDb?.close?.();
     this.codebaseDb?.close?.();
-    
+
     this.isInitialized = false;
     console.error('[MemoryEngine] Shutdown complete');
   }