@mrxkun/mcfast-mcp 4.0.6 → 4.0.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrxkun/mcfast-mcp",
-  "version": "4.0.6",
+  "version": "4.0.12",
   "description": "Ultra-fast code editing with WASM acceleration, fuzzy patching, multi-layer caching, and 8 unified tools. Optimized for AI code assistants with 80-98% latency reduction. Phase 4: ML Intelligence Layer.",
   "type": "module",
   "bin": {

package/src/index.js

@@ -41,6 +41,10 @@ import {
 import { safeEdit } from './utils/backup.js';
 import { formatError } from './utils/error-formatter.js';
 import { MemoryEngine } from './memory/index.js';
+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';
 
 const execAsync = promisify(exec);
 
@@ -108,6 +112,62 @@ async function searchMemoryContext(instruction, maxResults = 5) {
     }
 }
 
+/**
+ * Auto-trigger intelligence tools after successful edit
+ * Runs async in background to not block user
+ */
+async function autoTriggerIntelligence(filePath, instruction) {
+    try {
+        // Only trigger if intelligence is enabled
+        if (process.env.MCFAST_INTELLIGENCE_AUTO !== 'true') {
+            return;
+        }
+        
+        const engine = await getMemoryEngine();
+        const cache = getIntelligenceCache();
+        
+        // 1. Detect patterns (cached for 5 minutes)
+        const patternCacheKey = { file: filePath, type: 'patterns' };
+        let patterns = cache.get('patterns', patternCacheKey);
+        
+        if (!patterns) {
+            patterns = await engine.detectPatterns();
+            if (patterns && patterns.length > 0) {
+                cache.set('patterns', patternCacheKey, patterns);
+                console.error(`${colors.cyan}[Intelligence]${colors.reset} 💡 Detected ${patterns.length} patterns`);
+                
+                // Log high-confidence patterns
+                patterns.filter(p => p.confidence > 0.8).forEach(p => {
+                    console.error(`${colors.yellow}[Pattern]${colors.reset} ${p.type}: ${p.message}`);
+                });
+            }
+        }
+        
+        // 2. Get suggestions (cached for 5 minutes)
+        const suggestionCacheKey = { file: filePath, type: 'suggestions' };
+        let suggestions = cache.get('suggestions', suggestionCacheKey);
+        
+        if (!suggestions) {
+            suggestions = await engine.getSuggestions({ currentFile: filePath });
+            if (suggestions && suggestions.length > 0) {
+                cache.set('suggestions', suggestionCacheKey, suggestions);
+                console.error(`${colors.cyan}[Intelligence]${colors.reset} 💡 ${suggestions.length} suggestions available`);
+                
+                // Show top suggestions
+                suggestions.slice(0, 3).forEach(s => {
+                    console.error(`${colors.yellow}[Suggestion]${colors.reset} ${s.type}: ${s.message}`);
+                });
+            }
+        }
+        
+    } catch (error) {
+        // Silent fail - intelligence should not break the tool
+        if (VERBOSE) {
+            console.error(`${colors.yellow}[Intelligence]${colors.reset} Auto-trigger failed: ${error.message}`);
+        }
+    }
+}
+
 /**
  * Log edit to memory after successful edit
  */
@@ -222,6 +282,28 @@ const TOOL_ALIASES = {
     'list_files_fast': 'list_files',
     'read_file': 'read',
     'goto_definition': 'search', // redirected
+    // VSCode MCP client adds prefixes
+    'mcp--mcfast--edit': 'edit',
+    'mcp--mcfast--search': 'search',
+    'mcp--mcfast--read': 'read',
+    'mcp--mcfast--list_files': 'list_files',
+    'mcp--mcfast--reapply': 'reapply',
+    'mcp--mcfast--memory_search': 'memory_search',
+    'mcp--mcfast--memory_get': 'memory_get',
+    'mcp--mcfast--detect_patterns': 'detect_patterns',
+    'mcp--mcfast--get_suggestions': 'get_suggestions',
+    'mcp--mcfast--select_strategy': 'select_strategy',
+    // Alternative format with double dashes
+    'mcfast_edit': 'edit',
+    'mcfast_search': 'search',
+    'mcfast_read': 'read',
+    'mcfast_list_files': 'list_files',
+    'mcfast_reapply': 'reapply',
+    'mcfast_memory_search': 'memory_search',
+    'mcfast_memory_get': 'memory_get',
+    'mcfast_detect_patterns': 'detect_patterns',
+    'mcfast_get_suggestions': 'get_suggestions',
+    'mcfast_select_strategy': 'select_strategy',
 };
 
 /**
@@ -728,6 +810,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 /**
  * Report audit log to Dashboard
  * Sends operation logs to mcfast Dashboard for monitoring
+ * Now uses AuditQueue for batching to reduce HTTP overhead
  */
 async function reportAudit(data) {
     try {
@@ -755,42 +838,33 @@ async function reportAudit(data) {
             latency_ms: data.latency_ms || 0,
             instruction: data.instruction || '',
             files_count: data.files_count || 0,
+            diff_size: data.diff_size || 0,  // ✅ Thêm diff_size
             input_tokens: data.input_tokens || 0,
             output_tokens: data.output_tokens || 0,
             strategy: data.strategy || null,
             error: data.error || null,
+            error_message: data.error || null,  // ✅ Thêm error_message cho server
+            result_summary: data.result_summary || null,  // ✅ Thêm result_summary
             metadata: data.metadata || {}
         };
 
-        // Send to dashboard API
-        const DASHBOARD_API_URL = process.env.MCFAST_DASHBOARD_URL || 'https://mcfast.vercel.app/api/v1/logs/audit';
+        // Use AuditQueue for batching instead of immediate send
+        const queue = getAuditQueue({
+            token: TOKEN,
+            apiUrl: process.env.MCFAST_DASHBOARD_URL || 'https://mcfast.vercel.app/api/v1/logs/audit',
+            batchSize: 5,
+            flushInterval: 5000,
+            verbose: VERBOSE
+        });
         
-        if (VERBOSE) {
-            console.error(`${colors.dim}[Audit] Sending to: ${DASHBOARD_API_URL}${colors.reset}`);
-            console.error(`${colors.dim}[Audit] Tool: ${auditData.tool}, Status: ${auditData.status}${colors.reset}`);
-        }
+        queue.add(auditData);
         
-        const response = await fetch(DASHBOARD_API_URL, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${TOKEN}`
-            },
-            body: JSON.stringify(auditData)
-        });
-
-        if (!response.ok) {
-            const errorText = await response.text().catch(() => 'Unknown error');
-            if (VERBOSE) {
-                console.error(`${colors.yellow}[Audit] Failed - HTTP ${response.status}: ${errorText}${colors.reset}`);
-            }
-        } else {
-            if (VERBOSE) {
-                console.error(`${colors.green}[Audit] Logged successfully ✓${colors.reset}`);
-            }
+        if (VERBOSE) {
+            const stats = queue.getStats();
+            console.error(`${colors.dim}[Audit] Queued for batching. Queue size: ${stats.queued}${colors.reset}`);
         }
 
-        // Also log to local file if configured
+        // Also log to local file if configured (immediate)
         if (process.env.MCFAST_AUDIT_FILE) {
             const logLine = JSON.stringify(auditData) + '\n';
             await fs.appendFile(process.env.MCFAST_AUDIT_FILE, logLine).catch((err) => {
@@ -1055,7 +1129,8 @@ async function handleSearchFilesystem({ query, path: searchPath, isRegex = false
                         lines.forEach((line, idx) => {
                             if (line.includes(query)) {
                                 matches.push({
-                                    line: idx + 1,
+                                    file,
+                                    lineNumber: idx + 1,
                                     content: line.trim()
                                 });
                             }
@@ -1100,7 +1175,7 @@ async function handleSearchFilesystem({ query, path: searchPath, isRegex = false
             contentMatches.slice(0, 10).forEach(({ file, matches }) => {
                 output += `\n${colors.yellow}${file}${colors.reset}\n`;
                 matches.forEach(match => {
-                    output += `  ${colors.dim}${match.line}:${colors.reset} ${match.content}\n`;
+                    output += `  ${colors.dim}${match.lineNumber}:${colors.reset} ${match.content}\n`;
                 });
             });
         }
@@ -1631,6 +1706,12 @@ async function handleEdit({ instruction, files, code_edit, dryRun = false }) {
         durationMs: Date.now() - editStartTime
     });
     
+    // Auto-trigger intelligence tools in background (non-blocking)
+    if (!result.isError) {
+        const firstFile = Object.keys(files)[0];
+        autoTriggerIntelligence(firstFile, instruction).catch(() => {});
+    }
+    
     return result;
 }
 
@@ -1864,7 +1945,7 @@ async function handleReadFileInternal({ path: filePath, start_line, end_line, ma
             } else if (startLine && currentLine >= startLine) {
                 lines.push(line);
                 if (max_lines && lines.length >= max_lines) break;
-            } else if (lines.length < (max_lines || 2000)) {
+            } else if (max_lines && lines.length < max_lines) {
                 lines.push(line);
             } else {
                 break;
@@ -2155,7 +2236,7 @@ async function handleSearchCode({ query, files, regex = false, caseSensitive = f
         });
         return {
             content: [{ type: "text", text: `❌ Search error: ${error.message}` }],
-            isError: true
+            isError: true,
         };
     }
 }
@@ -2169,7 +2250,7 @@ async function handleSearchCodeAI({ query, files, contextLines = 2 }) {
     if (!TOKEN) {
         return {
             content: [{ type: "text", text: "❌ Error: MCFAST_TOKEN is missing. Please set it in your MCP config." }],
-            isError: true
+            isError: true,
         };
     }
     try {
@@ -2744,13 +2825,14 @@ async function handleMemorySearch({ query, type = 'all', maxResults = 6, minScor
                 score: result.finalScore || result.score
             }));
         } else {
-            const searchResult = await engine.intelligentSearch(query, { limit: maxResults });
-            results = searchResult.results.map(result => ({
+            // Use parallel search for 'all' type - faster!
+            const parallelResult = await parallelMemorySearch(engine, query, maxResults);
+            results = parallelResult.results.map(result => ({
                 type: 'chunk',
-                content: result.code || result.content,
-                file: result.filePath || result.path,
-                score: result.finalScore || result.score,
-                method: searchResult.metadata?.method
+                content: result.content || result.code,
+                file: result.file || result.filePath || result.path,
+                score: result._score || result.score || 0.5,
+                method: result._source
             }));
         }
 

package/src/memory/memory-engine.js

@@ -13,7 +13,6 @@ import { DailyLogs } from './utils/daily-logs.js';
 import { SyncEngine } from './utils/sync-engine.js';
 import { PatternDetector, SuggestionEngine, StrategySelector } from '../intelligence/index.js';
 import path from 'path';
-import os from 'os';
 
 export class MemoryEngine {
   constructor(options = {}) {
@@ -23,25 +22,19 @@ export class MemoryEngine {
     this.projectPath = null;
     this.isInitialized = false;
     
-    // Memory path for logs
-    this.memoryPath = options.memoryPath || path.join(os.homedir(), '.mcfast', 'memory');
+    // Memory path - now stored in project directory
+    this.memoryPath = options.memoryPath || null; // Will be set on initialize
     
     // Daily Logs - auto-generated markdown notes
-    this.dailyLogs = new DailyLogs({
-      memoryPath: this.memoryPath
-    });
+    this.dailyLogs = null; // Will be initialized on initialize
     
     // Sync Engine - local ↔ cloud (optional, auto-detect from MCFAST_TOKEN)
     this.syncEngine = null;
-    const hasToken = options.apiKey || process.env.MCFAST_TOKEN;
-    if (hasToken && options.enableSync !== false) {
-      this.syncEngine = new SyncEngine({
-        memoryPath: this.memoryPath,
-        apiKey: hasToken,
-        baseUrl: options.baseUrl || process.env.MCFAST_DASHBOARD_URL || 'https://mcfast.vercel.app',
-        syncInterval: options.syncInterval || 5 * 60 * 1000
-      });
-    }
+    this.syncEngineOptions = {
+      apiKey: options.apiKey || process.env.MCFAST_TOKEN,
+      baseUrl: options.baseUrl || process.env.MCFAST_DASHBOARD_URL || 'https://mcfast.vercel.app',
+      syncInterval: options.syncInterval || 5 * 60 * 1000
+    };
     
     // Sử dụng UltraEnhancedEmbedder cho 90% accuracy
     this.embedder = new UltraEnhancedEmbedder({
@@ -69,41 +62,38 @@ export class MemoryEngine {
     this.patternDetector = null;
     this.suggestionEngine = null;
     this.strategySelector = null;
-    
-    if (this.intelligenceEnabled) {
-      this.patternDetector = new PatternDetector({ db: this.db });
-      this.suggestionEngine = new SuggestionEngine({ 
-        db: this.db,
-        memoryEngine: this 
-      });
-      this.strategySelector = new StrategySelector({ db: this.db });
-    }
   }
 
   async initialize(projectPath) {
     if (this.isInitialized) return;
 
     this.projectPath = projectPath;
-    await this.db.initialize();
     
-    // Load smart router config from dashboard
-    if (this.smartRoutingEnabled) {
-      await this.smartRouter.loadConfig();
-      console.log('[MemoryEngine] Smart router config loaded');
+    // Set memory path to project directory
+    if (!this.memoryPath) {
+      this.memoryPath = path.join(projectPath, '.mcfast', 'memory');
     }
     
-    // Test dashboard connection
-    const connectionStatus = await this.dashboardClient.testConnection();
-    if (connectionStatus.connected) {
-      console.log('[MemoryEngine] ✅ Connected to Dashboard');
-    } else {
-      console.log('[MemoryEngine] ⚠️ Dashboard connection failed, using offline mode');
+    // Update database path if not explicitly set
+    if (!this.db.dbPath) {
+      this.db.dbPath = path.join(this.memoryPath, 'index.db');
     }
     
+    await this.db.initialize();
+    
+    // Initialize Daily Logs with project-specific path
+    this.dailyLogs = new DailyLogs({
+      memoryPath: this.memoryPath
+    });
+    
     // Initialize Sync Engine if configured
-    if (this.syncEngine) {
-      await this.syncEngine.initialize();
-      console.log('[MemoryEngine] ✅ Sync Engine initialized');
+    if (this.syncEngineOptions.apiKey && this.syncEngineOptions.enableSync !== false) {
+      this.syncEngine = new SyncEngine({
+        memoryPath: this.memoryPath,
+        apiKey: this.syncEngineOptions.apiKey,
+        baseUrl: this.syncEngineOptions.baseUrl,
+        syncInterval: this.syncEngineOptions.syncInterval
+      });
     }
     
     this.watcher = new FileWatcher(projectPath, this);
@@ -114,6 +104,20 @@ export class MemoryEngine {
     console.log(`[MemoryEngine] Smart Routing: ${this.smartRoutingEnabled ? 'ENABLED' : 'DISABLED'}`);
     console.log(`[MemoryEngine] Intelligence Layer: ${this.intelligenceEnabled ? 'ENABLED' : 'DISABLED'}`);
     
+    // Initialize intelligence engines if enabled
+    if (this.intelligenceEnabled) {
+      try {
+        const { PatternDetector, SuggestionEngine, StrategySelector } = await import('../intelligence/index.js');
+        this.patternDetector = new PatternDetector({ memoryEngine: this });
+        this.suggestionEngine = new SuggestionEngine({ memoryEngine: this });
+        this.strategySelector = new StrategySelector({ memoryEngine: this });
+        console.log('[MemoryEngine] Intelligence engines initialized');
+      } catch (error) {
+        console.warn('[MemoryEngine] Failed to initialize intelligence engines:', error.message);
+        this.intelligenceEnabled = false;
+      }
+    }
+    
     // Load intelligence models
     if (this.intelligenceEnabled) {
       await this.patternDetector.loadModel?.();

package/src/memory/stores/database.js

@@ -1,15 +1,19 @@
 import Database from 'better-sqlite3';
 import path from 'path';
-import os from 'os';
 import fs from 'fs/promises';
 
 export class MemoryDatabase {
-  constructor(dbPath = path.join(os.homedir(), '.mcfast', 'memory', 'index.db')) {
+  constructor(dbPath = null) {
     this.dbPath = dbPath;
     this.db = null;
   }
 
   async initialize() {
+    // If dbPath not set, create in current directory
+    if (!this.dbPath) {
+      this.dbPath = path.join(process.cwd(), '.mcfast', 'memory', 'index.db');
+    }
+    
     await fs.mkdir(path.dirname(this.dbPath), { recursive: true });
     this.db = new Database(this.dbPath);
     this.db.pragma('journal_mode = WAL');

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

@@ -5,15 +5,15 @@
 
 import fs from 'fs';
 import path from 'path';
-import os from 'os';
 
 export class DailyLogs {
   constructor(options = {}) {
-    this.memoryPath = options.memoryPath || path.join(os.homedir(), '.mcfast', 'memory');
-    this.dateFormat = options.dateFormat || 'yyyy-MM-dd';
-  }
-
-  ensureMemoryDir() {
+    this.memoryPath = options.memoryPath;
+    if (!this.memoryPath) {
+      throw new Error('memoryPath is required for DailyLogs');
+    }
+    
+    // Ensure directory exists
     if (!fs.existsSync(this.memoryPath)) {
       fs.mkdirSync(this.memoryPath, { recursive: true });
     }
@@ -47,8 +47,6 @@ export class DailyLogs {
    * Log a file creation event
    */
   logFileCreated(filePath, facts = []) {
-    this.ensureMemoryDir();
-    
     const content = [
       `## ${this.formatTime()} - File Created`,
       `**File:** \`${filePath}\``,
@@ -63,8 +61,6 @@ export class DailyLogs {
    * Log a file modification event
    */
   logFileModified(filePath, changes = {}) {
-    this.ensureMemoryDir();
-    
     const parts = [`**File:** \`${filePath}\``];
     
     if (changes.added && changes.added.length > 0) {
@@ -92,8 +88,6 @@ export class DailyLogs {
    * Log a file deletion event
    */
   logFileDeleted(filePath) {
-    this.ensureMemoryDir();
-    
     const content = [
       `## ${this.formatTime()} - File Deleted`,
       `**File:** \`${filePath}\``,
@@ -107,8 +101,6 @@ export class DailyLogs {
    * Log an edit session
    */
   logEdit(edit) {
-    this.ensureMemoryDir();
-    
     const {
       instruction,
       files = [],
@@ -139,8 +131,6 @@ export class DailyLogs {
    * Log a search query
    */
   logSearch(query, resultsCount, duration) {
-    this.ensureMemoryDir();
-    
     const content = [
       `## ${this.formatTime()} - Search`,
       `**Query:** "${query}"`,
@@ -156,8 +146,6 @@ export class DailyLogs {
    * Add a curated memory entry to MEMORY.md
    */
   addCuratedMemory(title, content, tags = []) {
-    this.ensureMemoryDir();
-    
     const memoryPath = this.getMemoryFilePath();
     const timestamp = new Date().toISOString();
     
@@ -219,8 +207,6 @@ export class DailyLogs {
    * Get logs for a date range
    */
   getLogsInRange(startDate, endDate) {
-    this.ensureMemoryDir();
-    
     const logs = [];
     const files = fs.readdirSync(this.memoryPath)
       .filter(f => f.match(/^\d{4}-\d{2}-\d{2}\.md$/))
@@ -241,8 +227,6 @@ export class DailyLogs {
    * Clean up old logs (keep last N days)
    */
   cleanupOldLogs(keepDays = 30) {
-    this.ensureMemoryDir();
-    
     const cutoffDate = new Date();
     cutoffDate.setDate(cutoffDate.getDate() - keepDays);
     const cutoffStr = cutoffDate.toISOString().split('T')[0].replace(/-/g, '');

package/src/memory/utils/indexer.js

@@ -7,6 +7,7 @@ import { parse } from '../../strategies/tree-sitter/index.js';
 import { detectLanguage } from '../../strategies/syntax-validator.js';
 import { Chunker } from './chunker.js';
 import { Embedder } from './embedder.js';
+import { getQuery } from '../../strategies/tree-sitter/languages.js';
 import crypto from 'crypto';
 
 export class CodeIndexer {
@@ -58,14 +59,14 @@ export class CodeIndexer {
     const fileId = this.generateFileId(filePath);
 
     try {
-      const { QUERIES } = await import('../../strategies/tree-sitter/queries.js');
-      const queries = QUERIES[language];
+      // Use getQuery to compile the query properly
+      const query = await getQuery(language, 'definitions');
       
-      if (queries?.definitions) {
-        const captures = queries.definitions.captures(ast.rootNode);
+      if (query) {
+        const captures = query.captures(ast.rootNode);
         
         for (const capture of captures) {
-          if (capture.name === 'name') {
+          if (capture.name === 'name' || capture.name === 'function') {
             facts.push({
               id: this.generateFactId(fileId, capture.node.text, 'function'),
               file_id: fileId,

package/src/memory/utils/sync-engine.js

@@ -6,30 +6,19 @@
 
 import fs from 'fs';
 import path from 'path';
-import os from 'os';
 import crypto from 'crypto';
 
 export class SyncEngine {
   constructor(options = {}) {
-    this.memoryPath = options.memoryPath || path.join(os.homedir(), '.mcfast', 'memory');
-    
-    // Use Dashboard URL for sync (same as DashboardClient)
-    this.baseUrl = options.baseUrl || process.env.MCFAST_DASHBOARD_URL || 'https://mcfast.vercel.app';
-    this.apiKey = options.apiKey || process.env.MCFAST_TOKEN;
+    this.memoryPath = options.memoryPath;
+    if (!this.memoryPath) {
+      throw new Error('memoryPath is required for SyncEngine');
+    }
     
+    this.apiKey = options.apiKey;
+    this.baseUrl = options.baseUrl || 'https://mcfast.vercel.app';
     this.syncInterval = options.syncInterval || 5 * 60 * 1000; // 5 minutes
-    this.lastSyncTime = null;
-    this.syncQueue = [];
-    this.isOnline = true;
-    this.isSyncing = false;
-    this.listeners = new Set();
-
-    // Check online status
-    if (typeof window !== 'undefined') {
-      this.isOnline = navigator.onLine;
-      window.addEventListener('online', () => this.handleOnline());
-      window.addEventListener('offline', () => this.handleOffline());
-    }
+    this.syncTimer = null;
   }
 
   /**