@mrxkun/mcfast-mcp 4.1.1 → 4.1.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mrxkun/mcfast-mcp",
-  "version": "4.1.1",
-  "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 5: Memory v4.1.0 - Markdown source, Hybrid Search, Two-tier memory.",
+  "version": "4.1.3",
+  "description": "Ultra-fast code editing with WASM acceleration, fuzzy patching, multi-layer caching, and 8 unified tools. v4.1.3: Fixed MCP stream issues (console.log->stderr), Singleton pattern, Duplicate log prevention.",
   "type": "module",
   "bin": {
     "mcfast-mcp": "src/index.js"

package/src/memory/layers/daily-logs.js

@@ -11,6 +11,15 @@ export class DailyLogs {
   constructor(options = {}) {
     this.memoryPath = options.memoryPath || '.mcfast';
     this.logsDir = path.join(this.memoryPath, 'memory');
+    
+    // Track recently logged entries to avoid duplicates
+    this.recentLogs = new Map();
+    this.dedupWindowMs = 5000; // 5 seconds
+    
+    // Create directory immediately on construction
+    this.ensureDirectory().catch(() => {
+      // Silent fail - will retry when logging
+    });
   }
 
   /**
@@ -52,6 +61,24 @@ export class DailyLogs {
    * @param {Object} metadata - Optional metadata
    */
   async log(title, content, metadata = {}) {
+    // Check for duplicate within dedup window
+    const logKey = `${title}:${content.substring(0, 50)}`;
+    const now = Date.now();
+    const lastLog = this.recentLogs.get(logKey);
+    
+    if (lastLog && (now - lastLog) < this.dedupWindowMs) {
+      console.error(`[DailyLogs] Skipping duplicate log: "${title}"`);
+      return null;
+    }
+    
+    // Track this log
+    this.recentLogs.set(logKey, now);
+    
+    // Cleanup old entries periodically
+    if (this.recentLogs.size > 100) {
+      this.cleanupRecentLogs();
+    }
+
     await this.ensureDirectory();
 
     const logPath = this.getTodayLogPath();
@@ -85,7 +112,7 @@ export class DailyLogs {
     // Append entry
     await fs.writeFile(logPath, fileContent + entry);
     
-    console.log(`[DailyLogs] Logged: "${title}" to ${logPath}`);
+    console.error(`[DailyLogs] Logged: "${title}" to ${logPath}`);
     return logPath;
   }
 
@@ -231,6 +258,18 @@ export class DailyLogs {
       return false;
     }
   }
+
+  /**
+   * Cleanup old recent log entries
+   */
+  cleanupRecentLogs() {
+    const now = Date.now();
+    for (const [key, timestamp] of this.recentLogs.entries()) {
+      if (now - timestamp > this.dedupWindowMs) {
+        this.recentLogs.delete(key);
+      }
+    }
+  }
 }
 
 export default DailyLogs;

package/src/memory/memory-engine.js

@@ -36,6 +36,43 @@ import { SyncEngine } from './utils/sync-engine.js';
 import { PatternDetector, SuggestionEngine, StrategySelector } from '../intelligence/index.js';
 
 export class MemoryEngine {
+  static instance = null;
+  static instancePromise = null;
+  
+  /**
+   * Get singleton instance of MemoryEngine
+   * @param {Object} options - Configuration options
+   * @returns {MemoryEngine} Singleton instance
+   */
+  static getInstance(options = {}) {
+    if (!MemoryEngine.instance) {
+      MemoryEngine.instance = new MemoryEngine(options);
+    }
+    return MemoryEngine.instance;
+  }
+  
+  /**
+   * Get or create singleton instance with async initialization
+   * @param {string} projectPath - Project path
+   * @param {Object} options - Configuration options
+   * @returns {Promise<MemoryEngine>} Initialized singleton instance
+   */
+  static async getOrCreate(projectPath, options = {}) {
+    if (MemoryEngine.instance && MemoryEngine.instance.isInitialized) {
+      return MemoryEngine.instance;
+    }
+    
+    if (MemoryEngine.instancePromise) {
+      return MemoryEngine.instancePromise;
+    }
+    
+    const engine = new MemoryEngine(options);
+    MemoryEngine.instance = engine;
+    MemoryEngine.instancePromise = engine.initialize(projectPath).then(() => engine);
+    
+    return MemoryEngine.instancePromise;
+  }
+
   constructor(options = {}) {
     this.projectPath = null;
     this.isInitialized = false;
@@ -125,9 +162,9 @@ export class MemoryEngine {
     await fs.mkdir(this.memoryPath, { recursive: true });
     await fs.mkdir(this.indexPath, { recursive: true });
     
-    console.log(`[MemoryEngine] Initializing...`);
-    console.log(`[MemoryEngine] Project: ${projectPath}`);
-    console.log(`[MemoryEngine] Memory path: ${this.memoryPath}`);
+    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 });
@@ -181,10 +218,10 @@ export class MemoryEngine {
     
     this.isInitialized = true;
     
-    console.log(`[MemoryEngine] ✅ Initialized successfully`);
-    console.log(`[MemoryEngine] Hybrid Search: ${this.searchConfig.hybrid.enabled ? 'ENABLED' : 'DISABLED'}`);
-    console.log(`[MemoryEngine] Smart Routing: ${this.smartRoutingEnabled ? 'ENABLED' : 'DISABLED'}`);
-    console.log(`[MemoryEngine] Intelligence: ${this.intelligenceEnabled ? 'ENABLED' : 'DISABLED'}`);
+    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'}`);
     
     // Log initialization to daily logs
     await this.dailyLogs.log('Memory Engine Initialized', `Project: ${projectPath}`, {
@@ -200,7 +237,7 @@ export class MemoryEngine {
       this.suggestionEngine = new SuggestionEngine({ memoryEngine: this });
       this.strategySelector = new StrategySelector({ memoryEngine: this });
       
-      console.log('[MemoryEngine] Intelligence engines initialized');
+      console.error('[MemoryEngine] Intelligence engines initialized');
       
       // Load models in background
       (async () => {
@@ -216,7 +253,7 @@ export class MemoryEngine {
           );
           
           await Promise.race([Promise.all(loadPromises), timeoutPromise]);
-          console.log('[MemoryEngine] ✅ Intelligence models loaded');
+          console.error('[MemoryEngine] ✅ Intelligence models loaded');
         } catch (error) {
           console.warn('[MemoryEngine] Model loading failed or timed out:', error.message);
         }
@@ -231,7 +268,7 @@ export class MemoryEngine {
     if (this.isScanning) return;
     this.isScanning = true;
     
-    console.log('[MemoryEngine] 🔍 Performing initial codebase scan...');
+    console.error('[MemoryEngine] 🔍 Performing initial codebase scan...');
     
     try {
       // Scan memory files first
@@ -243,8 +280,8 @@ export class MemoryEngine {
       // Update indexing progress
       this.codebaseDb?.completeIndexing?.();
       
-      console.log('[MemoryEngine] ✅ Initial scan complete');
-      console.log(`[MemoryEngine] Stats:`, this.getStats());
+      console.error('[MemoryEngine] ✅ Initial scan complete');
+      console.error(`[MemoryEngine] Stats:`, this.getStats());
       
     } catch (error) {
       console.error('[MemoryEngine] Error during initial scan:', error);
@@ -254,7 +291,7 @@ export class MemoryEngine {
   }
 
   async scanMemoryFiles() {
-    console.log('[MemoryEngine] Scanning memory files...');
+    console.error('[MemoryEngine] Scanning memory files...');
     
     try {
       // Index MEMORY.md
@@ -272,24 +309,24 @@ export class MemoryEngine {
         }
       }
       
-      console.log('[MemoryEngine] Memory files indexed');
+      console.error('[MemoryEngine] Memory files indexed');
     } catch (error) {
       console.error('[MemoryEngine] Error scanning memory files:', error);
     }
   }
 
   async scanCodebase() {
-    console.log('[MemoryEngine] Scanning codebase...');
+    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.log('[MemoryEngine] No code files found to index');
+      console.error('[MemoryEngine] No code files found to index');
       return;
     }
     
-    console.log(`[MemoryEngine] Found ${files.length} files to index`);
+    console.error(`[MemoryEngine] Found ${files.length} files to index`);
     
     // Start indexing progress
     this.codebaseDb?.startIndexing?.(files.length);
@@ -313,7 +350,7 @@ export class MemoryEngine {
         
         indexed++;
         if (indexed % 10 === 0) {
-          console.log(`[MemoryEngine] Indexed ${indexed}/${files.length} files...`);
+          console.error(`[MemoryEngine] Indexed ${indexed}/${files.length} files...`);
         }
       } catch (error) {
         console.warn(`[MemoryEngine] Failed to index ${filePath}:`, error.message);
@@ -321,7 +358,7 @@ export class MemoryEngine {
       }
     }
     
-    console.log(`[MemoryEngine] Codebase scan complete: ${indexed} indexed, ${failed} failed`);
+    console.error(`[MemoryEngine] Codebase scan complete: ${indexed} indexed, ${failed} failed`);
   }
 
   async indexMarkdownFile(filePath) {
@@ -498,7 +535,7 @@ export class MemoryEngine {
     const startTime = performance.now();
     const limit = options.limit || 10;
     
-    console.log(`[MemoryEngine] 🔍 Hybrid search: "${query}"`);
+    console.error(`[MemoryEngine] 🔍 Hybrid search: "${query}"`);
     
     // Get vector results first
     const vectorResult = await this.searchVector(query, limit * 4);
@@ -710,7 +747,7 @@ export class MemoryEngine {
   // ========== Lifecycle ==========
 
   async shutdown() {
-    console.log('[MemoryEngine] Shutting down...');
+    console.error('[MemoryEngine] Shutting down...');
     
     if (this.intelligenceEnabled) {
       await this.strategySelector?.saveModel?.();
@@ -723,7 +760,7 @@ export class MemoryEngine {
     this.codebaseDb?.close?.();
     
     this.isInitialized = false;
-    console.log('[MemoryEngine] Shutdown complete');
+    console.error('[MemoryEngine] Shutdown complete');
   }
 }
 

package/src/memory/utils/context-analyzer.js

@@ -0,0 +1,494 @@
+/**
+ * Context Analyzer
+ * Phân tích changes và tự động cập nhật MEMORY.md sử dụng mcfast API (Mercury qua API)
+ * 
+ * Flow:
+ * 1. Detect file changes
+ * 2. Send to mcfast API /analyze endpoint
+ * 3. Get structured summary
+ * 4. Auto-update MEMORY.md if important
+ * 5. Return results immediately
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+
+const API_URL = process.env.MCFAST_API_URL || "https://mcfast.vercel.app/api/v1";
+
+export class ContextAnalyzer {
+  constructor(options = {}) {
+    this.apiKey = options.apiKey || process.env.MCFAST_TOKEN;
+    this.projectPath = options.projectPath || process.cwd();
+    this.memoryPath = options.memoryPath || path.join(this.projectPath, '.mcfast');
+    
+    // Analysis cache to avoid re-analyzing same changes
+    this.analysisCache = new Map();
+    this.cacheMaxSize = 100;
+    
+    // Session tracking
+    this.currentSession = {
+      startTime: Date.now(),
+      changes: [],
+      filesAffected: new Set(),
+      patterns: []
+    };
+    
+    console.log('[ContextAnalyzer] Initialized with mcfast API');
+  }
+
+  /**
+   * Call mcfast API for analysis
+   * Sử dụng endpoint /apply để phân tích changes
+   */
+  async callMcfastAPI(instruction, files = {}) {
+    try {
+      const response = await fetch(`${API_URL}/apply`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.apiKey}`,
+        },
+        body: JSON.stringify({
+          instruction,
+          files,
+          toolName: 'context_analyze',
+          options: {
+            mode: 'analyze_only',
+            return_analysis: true
+          }
+        }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`API Error (${response.status}): ${errorText}`);
+      }
+
+      return await response.json();
+    } catch (error) {
+      console.error('[ContextAnalyzer] API call failed:', error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Phân tích changes và trả về kết quả nhanh
+   * @param {Object} changeInfo - Thông tin về changes
+   * @returns {Promise<Object>} Analysis result
+   */
+  async analyze(changeInfo) {
+    const startTime = performance.now();
+    
+    try {
+      // Build analysis prompt
+      const prompt = this.buildAnalysisPrompt(changeInfo);
+      
+      // Call mcfast API (sử dụng Mercury thông qua API)
+      const result = await this.callMcfastAPI(prompt, {
+        'analysis.txt': changeInfo.diff || ''
+      });
+      
+      // Parse API response
+      const analysis = this.parseAnalysis(result.content || result.analysis || '');
+      
+      // Update session tracking
+      this.trackSessionChange(changeInfo, analysis);
+      
+      // Auto-update MEMORY.md if important
+      if (analysis.importance >= 7) {
+        await this.autoUpdateMemory(analysis);
+      }
+      
+      const duration = performance.now() - startTime;
+      
+      return {
+        success: true,
+        analysis: analysis,
+        duration: Math.round(duration),
+        session: this.getSessionSummary(),
+        metadata: {
+          importance: analysis.importance,
+          shouldUpdateMemory: analysis.importance >= 7,
+          filesAffected: Array.from(this.currentSession.filesAffected),
+          apiLatency: result.latency_ms || 0
+        }
+      };
+      
+    } catch (error) {
+      console.error('[ContextAnalyzer] Analysis failed:', error.message);
+      return {
+        success: false,
+        error: error.message,
+        duration: Math.round(performance.now() - startTime)
+      };
+    }
+  }
+
+  /**
+   * Build analysis prompt for mcfast API
+   */
+  buildAnalysisPrompt(changeInfo) {
+    const { 
+      filePath, 
+      changeType, // 'add', 'modify', 'delete'
+      oldContent = '',
+      newContent = '',
+      diff = '',
+      instruction = '' // Original user instruction if available
+    } = changeInfo;
+
+    return `Analyze this code change and provide a structured summary.
+
+**File:** ${filePath}
+**Change Type:** ${changeType}
+${instruction ? `**User Instruction:** ${instruction}` : ''}
+
+**Diff/Changes:**
+${diff || `Old: ${oldContent.substring(0, 500)}...\nNew: ${newContent.substring(0, 500)}...`}
+
+**Analyze and return JSON format:**
+{
+  "summary": "Brief summary of what was changed (1-2 sentences)",
+  "type": "Type of change: feature|bugfix|refactor|docs|test|config",
+  "importance": "Number 1-10: How important is this change?",
+  "impact": "Impact level: low|medium|high",
+  "keyChanges": ["List of specific changes made"],
+  "decisions": ["Any architectural or design decisions implied"],
+  "patterns": ["Code patterns or conventions used"],
+  "risks": ["Potential risks or concerns"],
+  "suggestions": ["Suggestions for improvement"],
+  "shouldRemember": "Boolean: Should this be remembered in long-term memory?",
+  "memorySection": "Which MEMORY.md section to update: User Preferences|Important Decisions|Key Contacts|Project Context|Lessons Learned"
+}
+
+Return ONLY valid JSON, no markdown formatting.`;
+  }
+
+  /**
+   * Parse mcfast API response
+   */
+  parseAnalysis(content) {
+    try {
+      // Try to extract JSON from response
+      const jsonMatch = content.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        const analysis = JSON.parse(jsonMatch[0]);
+        
+        // Ensure all fields exist with defaults
+        return {
+          summary: analysis.summary || 'Change analyzed',
+          type: analysis.type || 'unknown',
+          importance: parseInt(analysis.importance) || 5,
+          impact: analysis.impact || 'medium',
+          keyChanges: analysis.keyChanges || [],
+          decisions: analysis.decisions || [],
+          patterns: analysis.patterns || [],
+          risks: analysis.risks || [],
+          suggestions: analysis.suggestions || [],
+          shouldRemember: analysis.shouldRemember || false,
+          memorySection: analysis.memorySection || 'Project Context'
+        };
+      }
+    } catch (error) {
+      console.warn('[ContextAnalyzer] Failed to parse JSON, using fallback');
+    }
+    
+    // Fallback: treat entire content as summary
+    return {
+      summary: content.substring(0, 200),
+      type: 'unknown',
+      importance: 5,
+      impact: 'medium',
+      keyChanges: [],
+      decisions: [],
+      patterns: [],
+      risks: [],
+      suggestions: [],
+      shouldRemember: false,
+      memorySection: 'Project Context'
+    };
+  }
+
+  /**
+   * Track changes in current session
+   */
+  trackSessionChange(changeInfo, analysis) {
+    this.currentSession.changes.push({
+      timestamp: Date.now(),
+      file: changeInfo.filePath,
+      type: changeInfo.changeType,
+      analysis: analysis
+    });
+    
+    this.currentSession.filesAffected.add(changeInfo.filePath);
+    
+    // Track patterns
+    if (analysis.patterns) {
+      analysis.patterns.forEach(pattern => {
+        if (!this.currentSession.patterns.includes(pattern)) {
+          this.currentSession.patterns.push(pattern);
+        }
+      });
+    }
+  }
+
+  /**
+   * Get current session summary
+   */
+  getSessionSummary() {
+    const duration = Date.now() - this.currentSession.startTime;
+    const changeCount = this.currentSession.changes.length;
+    
+    // Calculate importance distribution
+    const importanceSum = this.currentSession.changes.reduce(
+      (sum, c) => sum + (c.analysis.importance || 5), 
+      0
+    );
+    const avgImportance = changeCount > 0 ? (importanceSum / changeCount).toFixed(1) : 0;
+    
+    return {
+      duration: Math.round(duration / 1000), // seconds
+      changeCount,
+      filesAffected: Array.from(this.currentSession.filesAffected),
+      patterns: this.currentSession.patterns,
+      avgImportance,
+      highImpactChanges: this.currentSession.changes.filter(
+        c => c.analysis.importance >= 8
+      ).length
+    };
+  }
+
+  /**
+   * Auto-update MEMORY.md with important information
+   */
+  async autoUpdateMemory(analysis) {
+    try {
+      const memoryPath = path.join(this.memoryPath, 'MEMORY.md');
+      
+      // Check if file exists
+      let content = '';
+      try {
+        content = await fs.readFile(memoryPath, 'utf-8');
+      } catch (error) {
+        // File doesn't exist, will be created
+        content = this.getDefaultMemoryTemplate();
+      }
+      
+      // Determine what to add based on analysis
+      let update = '';
+      const timestamp = new Date().toISOString().split('T')[0];
+      
+      if (analysis.decisions && analysis.decisions.length > 0) {
+        // Add to Important Decisions
+        update = `\n- **${timestamp}:** ${analysis.summary}`;
+        if (analysis.decisions[0]) {
+          update += `\n  - Decision: ${analysis.decisions[0]}`;
+        }
+        content = this.addToSection(content, 'Important Decisions', update);
+      }
+      
+      if (analysis.patterns && analysis.patterns.length > 0 && analysis.importance >= 8) {
+        // Add to Project Context if high importance
+        update = `\n- **${timestamp}:** Using ${analysis.patterns.join(', ')}`;
+        content = this.addToSection(content, 'Project Context', update);
+      }
+      
+      if (analysis.type === 'bugfix' && analysis.importance >= 7) {
+        // Add to Lessons Learned
+        update = `\n- **${timestamp}:** Fixed issue - ${analysis.summary}`;
+        if (analysis.risks[0]) {
+          update += `\n  - Lesson: ${analysis.risks[0]}`;
+        }
+        content = this.addToSection(content, 'Lessons Learned', update);
+      }
+      
+      // Update timestamp
+      content = content.replace(
+        /\*Last updated:.*\*/,
+        `*Last updated: ${new Date().toISOString()}*`
+      );
+      
+      await fs.writeFile(memoryPath, content);
+      console.log(`[ContextAnalyzer] Updated MEMORY.md: ${analysis.memorySection}`);
+      
+    } catch (error) {
+      console.error('[ContextAnalyzer] Failed to update MEMORY.md:', error.message);
+    }
+  }
+
+  /**
+   * Add content to a specific section in MEMORY.md
+   */
+  addToSection(content, sectionName, newContent) {
+    const sectionRegex = new RegExp(`(## ${sectionName}.*?)(?=\n## |$)`, 's');
+    const match = content.match(sectionRegex);
+    
+    if (match) {
+      // Insert after section header
+      const section = match[1];
+      const updatedSection = section + newContent;
+      return content.replace(section, updatedSection);
+    }
+    
+    return content;
+  }
+
+  /**
+   * Get default MEMORY.md template
+   */
+  getDefaultMemoryTemplate() {
+    return `# Long-term Memory
+
+This file contains curated, persistent knowledge.
+
+## User Preferences
+<!-- Add user preferences here -->
+
+## Important Decisions
+<!-- Add important decisions here -->
+
+## Key Contacts
+<!-- Add key contacts here -->
+
+## Project Context
+<!-- Add project context here -->
+
+## Lessons Learned
+<!-- Add lessons learned here -->
+
+---
+*Last updated: ${new Date().toISOString()}*
+`;
+  }
+
+  /**
+   * Generate session summary at end of work
+   */
+  async generateSessionSummary() {
+    const session = this.getSessionSummary();
+    
+    if (session.changeCount === 0) {
+      return { summary: 'No changes made in this session' };
+    }
+    
+    // Build summary for Mercury
+    const changesList = this.currentSession.changes
+      .map(c => `- ${c.file}: ${c.analysis.summary} (importance: ${c.analysis.importance})`)
+      .join('\n');
+    
+    const prompt = `Summarize this coding session in 2-3 sentences.
+
+**Session Stats:**
+- Duration: ${Math.round(session.duration / 60)} minutes
+- Files changed: ${session.filesAffected.length}
+- Total changes: ${session.changeCount}
+- High impact changes: ${session.highImpactChanges}
+
+**Changes made:**
+${changesList}
+
+**Summary:**`;
+
+    try {
+      const result = await this.callMcfastAPI(prompt, {});
+      
+      return {
+        summary: result.content.trim(),
+        session: session,
+        timestamp: Date.now()
+      };
+    } catch (error) {
+      return {
+        summary: `Session with ${session.changeCount} changes across ${session.filesAffected.length} files`,
+        session: session,
+        timestamp: Date.now()
+      };
+    }
+  }
+
+  /**
+   * End current session and generate summary
+   */
+  async endSession() {
+    const summary = await this.generateSessionSummary();
+    
+    // Log to daily logs
+    const dailyLogs = this.memory.dailyLogs;
+    if (dailyLogs) {
+      await dailyLogs.log('Session Summary', summary.summary, {
+        filesChanged: summary.session.filesAffected.length,
+        duration: summary.session.duration,
+        avgImportance: summary.session.avgImportance
+      });
+    }
+    
+    // Reset session
+    this.currentSession = {
+      startTime: Date.now(),
+      changes: [],
+      filesAffected: new Set(),
+      patterns: []
+    };
+    
+    return summary;
+  }
+
+  /**
+   * Quick analysis - returns immediately with cached result if available
+   */
+  async quickAnalyze(filePath, changeType, diff = '') {
+    const cacheKey = this.getCacheKey(filePath, diff);
+    
+    // Check cache
+    if (this.analysisCache.has(cacheKey)) {
+      return {
+        success: true,
+        cached: true,
+        analysis: this.analysisCache.get(cacheKey),
+        duration: 0
+      };
+    }
+    
+    // Perform analysis
+    const result = await this.analyze({
+      filePath,
+      changeType,
+      diff
+    });
+    
+    // Cache result
+    if (result.success) {
+      this.cacheResult(cacheKey, result.analysis);
+    }
+    
+    return result;
+  }
+
+  getCacheKey(filePath, diff) {
+    return `${filePath}:${diff.substring(0, 100)}`;
+  }
+
+  cacheResult(key, analysis) {
+    if (this.analysisCache.size >= this.cacheMaxSize) {
+      // Remove oldest entry
+      const firstKey = this.analysisCache.keys().next().value;
+      this.analysisCache.delete(firstKey);
+    }
+    this.analysisCache.set(key, analysis);
+  }
+
+  /**
+   * Get analysis statistics
+   */
+  getStats() {
+    return {
+      sessionDuration: Math.round((Date.now() - this.currentSession.startTime) / 1000),
+      changesInSession: this.currentSession.changes.length,
+      filesAffected: this.currentSession.filesAffected.size,
+      cacheSize: this.analysisCache.size,
+      patternsDetected: this.currentSession.patterns.length
+    };
+  }
+}
+
+export default ContextAnalyzer;

package/src/memory/watchers/file-watcher.js

@@ -51,8 +51,8 @@ export class FileWatcher {
   }
 
   async start() {
-    console.log(`[FileWatcher] Starting watcher for: ${this.projectPath}`);
-    console.log(`[FileWatcher] Debounce: ${this.debounceMs}ms`);
+    console.error(`[FileWatcher] Starting watcher for: ${this.projectPath}`);
+    console.error(`[FileWatcher] Debounce: ${this.debounceMs}ms`);
     
     this.watcher = chokidar.watch(this.projectPath, {
       ignored: this.ignored,
@@ -79,11 +79,11 @@ export class FileWatcher {
       this.watcher.once('error', reject);
     });
     
-    console.log(`[FileWatcher] Ready and watching`);
+    console.error(`[FileWatcher] Ready and watching`);
   }
 
   handleAdd(filePath) {
-    console.log(`[FileWatcher] File added: ${filePath}`);
+    console.error(`[FileWatcher] File added: ${filePath}`);
     this.pendingUpdates.set(filePath, {
       path: filePath,
       type: 'add',
@@ -93,7 +93,7 @@ export class FileWatcher {
   }
 
   handleChange(filePath) {
-    console.log(`[FileWatcher] File changed: ${filePath}`);
+    console.error(`[FileWatcher] File changed: ${filePath}`);
     this.pendingUpdates.set(filePath, {
       path: filePath,
       type: 'change',
@@ -103,7 +103,7 @@ export class FileWatcher {
   }
 
   handleDelete(filePath) {
-    console.log(`[FileWatcher] File deleted: ${filePath}`);
+    console.error(`[FileWatcher] File deleted: ${filePath}`);
     this.pendingUpdates.set(filePath, {
       path: filePath,
       type: 'delete',
@@ -131,7 +131,7 @@ export class FileWatcher {
       
       if (updates.length === 0) return;
       
-      console.log(`[FileWatcher] Processing ${updates.length} updates...`);
+      console.error(`[FileWatcher] Processing ${updates.length} updates...`);
       
       // Group by type for efficiency
       const adds = updates.filter(u => u.type === 'add' || u.type === 'change');
@@ -147,7 +147,7 @@ export class FileWatcher {
         await this.processFile(update);
       }
       
-      console.log(`[FileWatcher] Processed ${updates.length} updates`);
+      console.error(`[FileWatcher] Processed ${updates.length} updates`);
       
     } catch (error) {
       console.error(`[FileWatcher] Error processing queue:`, error);
@@ -167,7 +167,7 @@ export class FileWatcher {
       
       // Skip large files (> 1MB)
       if (stats.size > 1024 * 1024) {
-        console.log(`[FileWatcher] Skipping large file: ${filePath} (${Math.round(stats.size / 1024)}KB)`);
+        console.error(`[FileWatcher] Skipping large file: ${filePath} (${Math.round(stats.size / 1024)}KB)`);
         return;
       }
       
@@ -177,7 +177,7 @@ export class FileWatcher {
       
       // Check if already indexed with same hash
       if (this.memory.codebaseDb?.isFileIndexed?.(filePath, contentHash)) {
-        console.log(`[FileWatcher] File unchanged: ${filePath}`);
+        console.error(`[FileWatcher] File unchanged: ${filePath}`);
         return;
       }
       
@@ -208,7 +208,7 @@ export class FileWatcher {
       const file = this.memory.codebaseDb?.getFileByPath?.(filePath);
       if (file) {
         this.memory.codebaseDb.deleteFile(file.id);
-        console.log(`[FileWatcher] Deleted from index: ${filePath}`);
+        console.error(`[FileWatcher] Deleted from index: ${filePath}`);
       }
       
       this.stats.filesDeleted++;
@@ -220,7 +220,7 @@ export class FileWatcher {
   }
 
   async indexMarkdownFile(filePath, content, contentHash, stats) {
-    console.log(`[FileWatcher] Indexing Markdown: ${filePath}`);
+    console.error(`[FileWatcher] Indexing Markdown: ${filePath}`);
     
     // Delete old chunks if updating
     const relativePath = path.relative(this.projectPath, filePath);
@@ -279,18 +279,18 @@ export class FileWatcher {
       }
     }
     
-    console.log(`[FileWatcher] Indexed ${chunks.length} chunks from ${filePath}`);
+    console.error(`[FileWatcher] Indexed ${chunks.length} chunks from ${filePath}`);
   }
 
   async indexCodeFile(filePath, content, contentHash, stats) {
-    console.log(`[FileWatcher] Indexing code: ${filePath}`);
+    console.error(`[FileWatcher] Indexing code: ${filePath}`);
     
     // Use the existing indexer
     if (this.memory.indexer) {
       try {
         const indexed = await this.memory.indexer.indexFile(filePath, content);
         await this.memory.storeIndexed(indexed);
-        console.log(`[FileWatcher] Indexed ${indexed.facts.length} facts, ${indexed.chunks.length} chunks from ${filePath}`);
+        console.error(`[FileWatcher] Indexed ${indexed.facts.length} facts, ${indexed.chunks.length} chunks from ${filePath}`);
       } catch (error) {
         console.error(`[FileWatcher] Failed to index ${filePath}:`, error.message);
       }
@@ -319,7 +319,7 @@ export class FileWatcher {
       
       await this.watcher.close();
       this.watcher = null;
-      console.log(`[FileWatcher] Stopped`);
+      console.error(`[FileWatcher] Stopped`);
     }
   }
 }

package/src/tools/memory_get.js

@@ -8,24 +8,15 @@ import fs from 'fs/promises';
 import path from 'path';
 import { MemoryEngine } from '../memory/index.js';
 
-// Memory engine instance (initialized lazily)
-let memoryEngine = null;
-let enginePromise = null;
-
+/**
+ * Get MemoryEngine singleton instance
+ * Uses static getOrCreate to ensure single instance
+ */
 async function getMemoryEngine() {
-    if (memoryEngine) return memoryEngine;
-    if (enginePromise) return enginePromise;
-    
-    enginePromise = (async () => {
-        memoryEngine = new MemoryEngine({
-            apiKey: process.env.MCFAST_TOKEN,
-            enableSync: true
-        });
-        await memoryEngine.initialize(process.cwd());
-        return memoryEngine;
-    })();
-    
-    return enginePromise;
+    return MemoryEngine.getOrCreate(process.cwd(), {
+        apiKey: process.env.MCFAST_TOKEN,
+        enableSync: true
+    });
 }
 
 /**

package/src/tools/memory_search.js

@@ -6,24 +6,15 @@
 
 import { MemoryEngine } from '../memory/index.js';
 
-// Memory engine instance (initialized lazily)
-let memoryEngine = null;
-let enginePromise = null;
-
+/**
+ * Get MemoryEngine singleton instance
+ * Uses static getOrCreate to ensure single instance
+ */
 async function getMemoryEngine() {
-    if (memoryEngine) return memoryEngine;
-    if (enginePromise) return enginePromise;
-    
-    enginePromise = (async () => {
-        memoryEngine = new MemoryEngine({
-            apiKey: process.env.MCFAST_TOKEN,
-            enableSync: true
-        });
-        await memoryEngine.initialize(process.cwd());
-        return memoryEngine;
-    })();
-    
-    return enginePromise;
+    return MemoryEngine.getOrCreate(process.cwd(), {
+        apiKey: process.env.MCFAST_TOKEN,
+        enableSync: true
+    });
 }
 
 /**