@mrxkun/mcfast-mcp 4.0.6 → 4.0.11

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

package/src/utils/streaming-api.js

@@ -0,0 +1,168 @@
+/**
+ * Streaming API Client
+ * Handles Server-Sent Events (SSE) for real-time updates
+ */
+
+import { colors } from './colors.js';
+
+export class StreamingAPIClient {
+  constructor(options = {}) {
+    this.baseUrl = options.baseUrl || 'https://mcfast.vercel.app/api/v1';
+    this.token = options.token || process.env.MCFAST_TOKEN;
+    this.verbose = options.verbose || false;
+  }
+
+  /**
+   * Stream edit with real-time progress
+   */
+  async *streamEdit({ instruction, files, onProgress }) {
+    const url = `${this.baseUrl}/edit/stream`;
+    
+    try {
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.token}`
+        },
+        body: JSON.stringify({
+          instruction,
+          files,
+          stream: true
+        })
+      });
+
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+      }
+
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = '';
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          if (line.trim()) {
+            const event = this.parseSSE(line);
+            if (event) {
+              if (onProgress) onProgress(event);
+              yield event;
+            }
+          }
+        }
+      }
+
+    } catch (error) {
+      console.error(`${colors.red}[Streaming]${colors.reset} Error:`, error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Batch audit with streaming acknowledgments
+   */
+  async *streamBatchAudit(logs, onAck) {
+    const url = `${this.baseUrl}/logs/batch`;
+    
+    try {
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.token}`
+        },
+        body: JSON.stringify({ logs, stream: true })
+      });
+
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+      }
+
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = '';
+      const acks = [];
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          if (line.trim()) {
+            const event = this.parseSSE(line);
+            if (event) {
+              if (event.event === 'ack' && onAck) {
+                onAck(event.data);
+              }
+              acks.push(event.data);
+              yield event;
+            }
+          }
+        }
+      }
+
+      return acks;
+
+    } catch (error) {
+      console.error(`${colors.red}[Streaming]${colors.reset} Batch audit error:`, error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Parse SSE format
+   */
+  parseSSE(raw) {
+    const lines = raw.split('\n');
+    const event = {};
+
+    for (const line of lines) {
+      if (line.startsWith('event: ')) {
+        event.event = line.substring(7);
+      } else if (line.startsWith('data: ')) {
+        try {
+          event.data = JSON.parse(line.substring(6));
+        } catch {
+          event.data = line.substring(6);
+        }
+      } else if (line.startsWith('id: ')) {
+        event.id = line.substring(4);
+      }
+    }
+
+    return event.event ? event : null;
+  }
+
+  /**
+   * Non-streaming batch audit (fallback)
+   */
+  async batchAudit(logs) {
+    const url = `${this.baseUrl}/logs/batch`;
+    
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.token}`
+      },
+      body: JSON.stringify({ logs, stream: false })
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+    }
+
+    return response.json();
+  }
+}