@mrxkun/mcfast-mcp 4.0.6 → 4.0.12

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'
+};

package/src/utils/context-prefetcher.js

@@ -0,0 +1,170 @@
+/**
+ * Context Prefetcher
+ * Predictively fetches context based on user activity
+ */
+
+import { colors } from './colors.js';
+
+export class ContextPrefetcher {
+  constructor(options = {}) {
+    this.cache = new Map();
+    this.cacheTtl = options.cacheTtl || 2 * 60 * 1000; // 2 minutes
+    this.prefetchDelay = options.prefetchDelay || 500; // 500ms debounce
+    this.maxCacheSize = options.maxCacheSize || 50;
+    this.pendingPrefetch = null;
+    this.verbose = options.verbose || false;
+    
+    // Track recent files for relationship analysis
+    this.recentFiles = [];
+    this.maxRecentFiles = 10;
+  }
+
+  onUserTyping(filePath, currentLine, searchContextFn) {
+    // Update recent files
+    this.addToRecentFiles(filePath);
+    
+    // Debounce prefetch
+    clearTimeout(this.pendingPrefetch);
+    this.pendingPrefetch = setTimeout(() => {
+      this.prefetch(filePath, currentLine, searchContextFn);
+    }, this.prefetchDelay);
+  }
+
+  onFileOpened(filePath, searchContextFn) {
+    this.addToRecentFiles(filePath);
+    // Prefetch immediately on file open
+    this.prefetch(filePath, null, searchContextFn);
+  }
+
+  addToRecentFiles(filePath) {
+    // Remove if already exists
+    this.recentFiles = this.recentFiles.filter(f => f !== filePath);
+    // Add to front
+    this.recentFiles.unshift(filePath);
+    // Keep only max
+    this.recentFiles = this.recentFiles.slice(0, this.maxRecentFiles);
+  }
+
+  async prefetch(filePath, currentLine, searchContextFn) {
+    if (!searchContextFn) return;
+    
+    try {
+      // Prefetch current file context
+      const cacheKey = `file:${filePath}`;
+      if (!this.cache.has(cacheKey)) {
+        if (this.verbose) {
+          console.error(`${colors.dim}[Prefetch] Fetching context for ${filePath}${colors.reset}`);
+        }
+        
+        const context = await searchContextFn(`file:${filePath}`, 10);
+        this.setCache(cacheKey, context);
+      }
+      
+      // Prefetch related files
+      await this.prefetchRelatedFiles(filePath, searchContextFn);
+      
+    } catch (error) {
+      if (this.verbose) {
+        console.error(`${colors.yellow}[Prefetch] Error: ${error.message}${colors.reset}`);
+      }
+    }
+  }
+
+  async prefetchRelatedFiles(currentFilePath, searchContextFn) {
+    // Find files that are often accessed together
+    const relatedFiles = this.findRelatedFiles(currentFilePath);
+    
+    for (const filePath of relatedFiles) {
+      const cacheKey = `file:${filePath}`;
+      if (!this.cache.has(cacheKey)) {
+        try {
+          const context = await searchContextFn(`file:${filePath}`, 5);
+          this.setCache(cacheKey, context);
+        } catch (e) {
+          // Ignore prefetch errors
+        }
+      }
+    }
+  }
+
+  findRelatedFiles(currentFilePath) {
+    // Simple heuristic: files accessed recently with similar names
+    const currentBase = currentFilePath.replace(/\.(js|ts|jsx|tsx)$/, '');
+    const related = [];
+    
+    for (const file of this.recentFiles) {
+      if (file === currentFilePath) continue;
+      
+      const fileBase = file.replace(/\.(js|ts|jsx|tsx)$/, '');
+      
+      // Check for common patterns
+      if (currentBase.includes(fileBase) || fileBase.includes(currentBase)) {
+        related.push(file);
+      }
+    }
+    
+    return related.slice(0, 3); // Max 3 related files
+  }
+
+  getCachedContext(filePath) {
+    const cacheKey = `file:${filePath}`;
+    const item = this.cache.get(cacheKey);
+    
+    if (!item) return null;
+    
+    // Check TTL
+    if (Date.now() - item.timestamp > this.cacheTtl) {
+      this.cache.delete(cacheKey);
+      return null;
+    }
+    
+    return item.data;
+  }
+
+  setCache(key, data) {
+    // Evict oldest if needed
+    if (this.cache.size >= this.maxCacheSize) {
+      const firstKey = this.cache.keys().next().value;
+      this.cache.delete(firstKey);
+    }
+    
+    this.cache.set(key, {
+      data,
+      timestamp: Date.now()
+    });
+  }
+
+  getStats() {
+    return {
+      cacheSize: this.cache.size,
+      maxCacheSize: this.maxCacheSize,
+      recentFiles: this.recentFiles.length
+    };
+  }
+
+  invalidate(filePath) {
+    this.cache.delete(`file:${filePath}`);
+  }
+
+  invalidateAll() {
+    this.cache.clear();
+    this.recentFiles = [];
+  }
+}
+
+// Singleton instance
+let prefetcher = null;
+
+export function getContextPrefetcher(options = {}) {
+  if (!prefetcher) {
+    prefetcher = new ContextPrefetcher(options);
+  }
+  return prefetcher;
+}
+
+export function resetContextPrefetcher() {
+  if (prefetcher) {
+    prefetcher.invalidateAll();
+    prefetcher = null;
+  }
+}

package/src/utils/intelligence-cache.js

@@ -0,0 +1,114 @@
+/**
+ * Intelligence Cache with TTL
+ * Caches intelligence results to reduce computation overhead
+ */
+
+export class IntelligenceCache {
+  constructor(options = {}) {
+    this.cache = new Map();
+    this.ttl = options.ttl || 5 * 60 * 1000; // 5 minutes default
+    this.maxSize = options.maxSize || 1000;
+    this.hitCount = 0;
+    this.missCount = 0;
+  }
+
+  generateKey(type, params) {
+    // Generate unique key from type and params
+    const paramsStr = JSON.stringify(params);
+    return `${type}:${paramsStr}`;
+  }
+
+  get(type, params) {
+    const key = this.generateKey(type, params);
+    const item = this.cache.get(key);
+    
+    if (!item) {
+      this.missCount++;
+      return null;
+    }
+    
+    // Check TTL
+    if (Date.now() - item.timestamp > this.ttl) {
+      this.cache.delete(key);
+      this.missCount++;
+      return null;
+    }
+    
+    this.hitCount++;
+    return item.data;
+  }
+
+  set(type, params, data) {
+    const key = this.generateKey(type, params);
+    
+    // Evict oldest if at capacity
+    if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      this.cache.delete(firstKey);
+    }
+    
+    this.cache.set(key, {
+      data,
+      timestamp: Date.now()
+    });
+  }
+
+  invalidate(type) {
+    // Invalidate all keys of a certain type
+    for (const key of this.cache.keys()) {
+      if (key.startsWith(`${type}:`)) {
+        this.cache.delete(key);
+      }
+    }
+  }
+
+  invalidateAll() {
+    this.cache.clear();
+    this.hitCount = 0;
+    this.missCount = 0;
+  }
+
+  getStats() {
+    const total = this.hitCount + this.missCount;
+    return {
+      size: this.cache.size,
+      maxSize: this.maxSize,
+      hitRate: total > 0 ? (this.hitCount / total * 100).toFixed(2) + '%' : 'N/A',
+      hits: this.hitCount,
+      misses: this.missCount,
+      ttl: this.ttl
+    };
+  }
+
+  // Pre-warm cache with common queries
+  async prewarm(queries, fetchFn) {
+    for (const query of queries) {
+      const cached = this.get('search', query);
+      if (!cached) {
+        try {
+          const result = await fetchFn(query);
+          this.set('search', query, result);
+        } catch (e) {
+          // Ignore prewarm errors
+        }
+      }
+    }
+  }
+}
+
+// Singleton instance
+let intelligenceCache = null;
+
+export function getIntelligenceCache(options = {}) {
+  if (!intelligenceCache) {
+    intelligenceCache = new IntelligenceCache(options);
+  }
+  return intelligenceCache;
+}
+
+export function resetIntelligenceCache() {
+  if (intelligenceCache) {
+    intelligenceCache.invalidateAll();
+    intelligenceCache = null;
+  }
+}

package/src/utils/parallel-search.js

@@ -0,0 +1,130 @@
+/**
+ * Parallel Search Executor
+ * Executes multiple search strategies in parallel for better performance
+ */
+
+export class ParallelSearch {
+  constructor(options = {}) {
+    this.timeout = options.timeout || 5000; // 5 second timeout per search
+  }
+
+  /**
+   * Execute multiple searches in parallel
+   * Returns results as soon as all complete (or timeout)
+   */
+  async searchAll(searchFns, query, limit) {
+    const searchPromises = searchFns.map(fn => 
+      this.executeWithTimeout(fn, query, limit)
+    );
+
+    const results = await Promise.allSettled(searchPromises);
+    
+    return results.map((result, index) => ({
+      strategy: searchFns[index].name || `search-${index}`,
+      status: result.status,
+      data: result.status === 'fulfilled' ? result.value : null,
+      error: result.status === 'rejected' ? result.reason : null
+    }));
+  }
+
+  /**
+   * Execute search with timeout
+   */
+  async executeWithTimeout(fn, query, limit) {
+    return Promise.race([
+      fn(query, limit),
+      new Promise((_, reject) => 
+        setTimeout(() => reject(new Error('Search timeout')), this.timeout)
+      )
+    ]);
+  }
+
+  /**
+   * Merge and rank results from multiple strategies
+   */
+  mergeResults(results, maxResults = 10) {
+    const allItems = [];
+    
+    for (const result of results) {
+      if (result.status === 'fulfilled' && result.data) {
+        const items = Array.isArray(result.data) ? result.data : [result.data];
+        allItems.push(...items.map(item => ({
+          ...item,
+          _source: result.strategy,
+          _score: item.score || item.similarity || item.confidence || 0.5
+        })));
+      }
+    }
+
+    // Remove duplicates (by id or content)
+    const seen = new Set();
+    const unique = allItems.filter(item => {
+      const key = item.id || item.name || item.content || JSON.stringify(item);
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+
+    // Sort by score
+    unique.sort((a, b) => b._score - a._score);
+
+    return unique.slice(0, maxResults);
+  }
+
+  /**
+   * Smart parallel search with fallbacks
+   * Tries fast strategies first, then slower ones if needed
+   */
+  async smartSearch(strategies, query, limit, minResults = 5) {
+    // Group strategies by speed
+    const fastStrategies = strategies.filter(s => s.fast);
+    const slowStrategies = strategies.filter(s => !s.fast);
+
+    // Try fast strategies first
+    let results = await this.searchAll(
+      fastStrategies.map(s => s.fn),
+      query,
+      limit
+    );
+
+    const merged = this.mergeResults(results);
+
+    // If not enough results, try slow strategies
+    if (merged.length < minResults && slowStrategies.length > 0) {
+      const slowResults = await this.searchAll(
+        slowStrategies.map(s => s.fn),
+        query,
+        limit
+      );
+      
+      results = [...results, ...slowResults];
+      return this.mergeResults(results, maxResults);
+    }
+
+    return merged;
+  }
+}
+
+// Helper for MemoryEngine parallel search
+export async function parallelMemorySearch(engine, query, limit) {
+  const parallel = new ParallelSearch();
+  
+  const strategies = [
+    { fn: (q, l) => engine.searchFacts(q, l), name: 'facts', fast: true },
+    { fn: (q, l) => engine.searchFTS(q, l), name: 'fts', fast: true },
+    { fn: (q, l) => engine.searchVector(q, l), name: 'vector', fast: false }
+  ];
+
+  const startTime = performance.now();
+  const results = await parallel.smartSearch(strategies, query, limit, 5);
+  const duration = performance.now() - startTime;
+
+  return {
+    results,
+    metadata: {
+      duration: duration.toFixed(2) + 'ms',
+      strategies: strategies.length,
+      resultCount: results.length
+    }
+  };
+}