@mrxkun/mcfast-mcp 4.0.6 → 4.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrxkun/mcfast-mcp",
-  "version": "4.0.6",
+  "version": "4.0.11",
   "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
  */
@@ -728,6 +788,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 +816,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) => {
@@ -1631,6 +1683,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 +1922,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 +2213,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 +2227,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 +2802,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);

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;
   }
 
   /**

package/src/utils/audit-queue.js

@@ -0,0 +1,127 @@
+/**
+ * Audit Queue with Batching
+ * Buffers audit logs and sends them in batches to reduce HTTP overhead
+ */
+
+import { colors } from './colors.js';
+
+export class AuditQueue {
+  constructor(options = {}) {
+    this.queue = [];
+    this.batchSize = options.batchSize || 5;
+    this.flushInterval = options.flushInterval || 5000; // 5 seconds
+    this.apiUrl = options.apiUrl || 'https://mcfast.vercel.app/api/v1/logs/batch';
+    this.token = options.token || process.env.MCFAST_TOKEN;
+    this.verbose = options.verbose || false;
+    
+    // Start flush timer
+    this.flushTimer = setInterval(() => this.flush(), this.flushInterval);
+    
+    // Flush on process exit
+    process.on('beforeExit', () => this.flushSync());
+    process.on('SIGINT', () => this.flushSync());
+    process.on('SIGTERM', () => this.flushSync());
+  }
+
+  add(data) {
+    // Add timestamp if not present
+    const auditData = {
+      timestamp: new Date().toISOString(),
+      ...data
+    };
+    
+    this.queue.push(auditData);
+    
+    if (this.verbose) {
+      console.error(`${colors.dim}[AuditQueue] Added to queue. Size: ${this.queue.length}${colors.reset}`);
+    }
+    
+    // Flush immediately if batch size reached
+    if (this.queue.length >= this.batchSize) {
+      this.flush();
+    }
+  }
+
+  async flush() {
+    if (this.queue.length === 0) return;
+    if (!this.token) return; // Skip if no token
+    
+    // Take batch from queue
+    const batch = this.queue.splice(0, this.batchSize);
+    
+    try {
+      if (this.verbose) {
+        console.error(`${colors.dim}[AuditQueue] Flushing ${batch.length} logs...${colors.reset}`);
+      }
+      
+      // Send batch using the batch API
+      const response = await fetch(this.apiUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.token}`
+        },
+        body: JSON.stringify({ logs: batch, stream: false })
+      });
+      
+      if (!response.ok) {
+        // Put back in queue if failed (will retry next flush)
+        this.queue.unshift(...batch);
+        if (this.verbose) {
+          console.error(`${colors.yellow}[AuditQueue] Flush failed, will retry${colors.reset}`);
+        }
+      } else {
+        const result = await response.json();
+        if (this.verbose) {
+          console.error(`${colors.green}[AuditQueue] Flushed ${result.stored || batch.length} logs ✓${colors.reset}`);
+        }
+      }
+    } catch (error) {
+      // Put back in queue if failed
+      this.queue.unshift(...batch);
+      if (this.verbose) {
+        console.error(`${colors.yellow}[AuditQueue] Network error, will retry: ${error.message}${colors.reset}`);
+      }
+    }
+  }
+
+  flushSync() {
+    // Synchronous flush for process exit
+    if (this.queue.length === 0) return;
+    
+    // In real implementation, you might want to use sync HTTP or write to file
+    if (this.verbose) {
+      console.error(`${colors.dim}[AuditQueue] ${this.queue.length} logs remaining on exit${colors.reset}`);
+    }
+  }
+
+  getStats() {
+    return {
+      queued: this.queue.length,
+      batchSize: this.batchSize,
+      flushInterval: this.flushInterval
+    };
+  }
+
+  destroy() {
+    clearInterval(this.flushTimer);
+    return this.flush();
+  }
+}
+
+// Singleton instance
+let auditQueue = null;
+
+export function getAuditQueue(options = {}) {
+  if (!auditQueue) {
+    auditQueue = new AuditQueue(options);
+  }
+  return auditQueue;
+}
+
+export function resetAuditQueue() {
+  if (auditQueue) {
+    auditQueue.destroy();
+    auditQueue = null;
+  }
+}

package/src/utils/colors.js

@@ -0,0 +1,31 @@
+/**
+ * Color utilities for terminal output
+ */
+
+export const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  underscore: '\x1b[4m',
+  blink: '\x1b[5m',
+  reverse: '\x1b[7m',
+  hidden: '\x1b[8m',
+
+  black: '\x1b[30m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+
+  bgBlack: '\x1b[40m',
+  bgRed: '\x1b[41m',
+  bgGreen: '\x1b[42m',
+  bgYellow: '\x1b[43m',
+  bgBlue: '\x1b[44m',
+  bgMagenta: '\x1b[45m',
+  bgCyan: '\x1b[46m',
+  bgWhite: '\x1b[47m'
+};