@mrxkun/mcfast-mcp 4.0.1 → 4.0.3

package/src/intelligence/suggestion-engine.js

@@ -0,0 +1,489 @@
+/**
+ * Suggestion Engine
+ * Provides intelligent code suggestions based on context and patterns
+ * Phase 4: Intelligence Layer
+ * Version: 4.0.2
+ */
+
+import { PatternDetector } from './pattern-detector.js';
+
+export class SuggestionEngine {
+  constructor(options = {}) {
+    this.db = options.db || null;
+    this.detector = new PatternDetector(options);
+    this.memoryEngine = options.memoryEngine || null;
+    this.minConfidence = options.minConfidence || 0.70;
+    this.suggestionCache = new Map();
+    this.cacheTTL = 5 * 60 * 1000; // 5 minutes
+  }
+
+  /**
+   * Get intelligent suggestions based on current context
+   * @param {Object} context - Current editing context
+   * @returns {Array} Suggestions with confidence scores
+   */
+  async getSuggestions(context) {
+    const suggestions = [];
+
+    // 1. Naming inconsistency suggestions
+    const namingSuggestions = await this.suggestNamingFixes(context);
+    suggestions.push(...namingSuggestions);
+
+    // 2. Long function detection
+    const functionSuggestions = await this.suggestFunctionRefactoring(context);
+    suggestions.push(...functionSuggestions);
+
+    // 3. Test coverage suggestions
+    const testSuggestions = await this.suggestTestAdditions(context);
+    suggestions.push(...testSuggestions);
+
+    // 4. Import/organization suggestions
+    const importSuggestions = await this.suggestImportOrganization(context);
+    suggestions.push(...importSuggestions);
+
+    // 5. Duplicate code detection
+    const duplicateSuggestions = await this.suggestDuplicateCodeElimination(context);
+    suggestions.push(...duplicateSuggestions);
+
+    // 6. Performance optimization suggestions
+    const perfSuggestions = await this.suggestPerformanceImprovements(context);
+    suggestions.push(...perfSuggestions);
+
+    // Filter by confidence and sort
+    return suggestions
+      .filter(s => s.confidence >= this.minConfidence)
+      .sort((a, b) => b.confidence - a.confidence)
+      .slice(0, 10); // Max 10 suggestions
+  }
+
+  /**
+   * Suggest naming convention fixes
+   */
+  async suggestNamingFixes(context) {
+    const suggestions = [];
+    const editHistory = await this.getEditHistory();
+
+    // Find inconsistent naming patterns
+    const namingPatterns = this.analyzeNamingPatterns(editHistory);
+    
+    for (const pattern of namingPatterns) {
+      if (pattern.inconsistency > 0.3) { // More than 30% inconsistency
+        suggestions.push({
+          type: 'rename',
+          category: 'naming',
+          description: `Inconsistent naming: "${pattern.current}" doesn't match convention "${pattern.convention}"`,
+          current: pattern.current,
+          suggested: pattern.suggested,
+          files: pattern.files,
+          confidence: pattern.confidence,
+          autoApply: false,
+          reason: `Found ${pattern.count} similar names using "${pattern.convention}" convention`,
+          action: {
+            type: 'refactor',
+            operation: 'rename_symbol',
+            symbol: pattern.current,
+            newName: pattern.suggested
+          }
+        });
+      }
+    }
+
+    return suggestions;
+  }
+
+  /**
+   * Suggest function extraction for long functions
+   */
+  async suggestFunctionRefactoring(context) {
+    const suggestions = [];
+    
+    if (!context || !context.currentFile) return suggestions;
+
+    // Get facts about current file
+    const facts = await this.memoryEngine?.searchFacts(context.currentFile, 50);
+    if (!facts) return suggestions;
+
+    for (const fact of facts) {
+      if (fact.type === 'function' || fact.type === 'method') {
+        const lineCount = (fact.line_end || 0) - (fact.line_start || 0);
+        
+        if (lineCount > 50) {
+          suggestions.push({
+            type: 'extract_function',
+            category: 'refactoring',
+            description: `Function "${fact.name}" is ${lineCount} lines long. Consider extracting parts into smaller functions.`,
+            target: fact.name,
+            file: context.currentFile,
+            lineCount,
+            confidence: Math.min(0.75 + (lineCount - 50) / 100, 0.95),
+            autoApply: false,
+            reason: `Functions longer than 50 lines are harder to maintain and test`,
+            action: {
+              type: 'refactor',
+              operation: 'extract_function',
+              function: fact.name,
+              file: context.currentFile,
+              lines: [fact.line_start, fact.line_end]
+            }
+          });
+        }
+      }
+    }
+
+    return suggestions;
+  }
+
+  /**
+   * Suggest adding tests for uncovered code
+   */
+  async suggestTestAdditions(context) {
+    const suggestions = [];
+    
+    // Get recently modified files
+    const recentEdits = await this.getRecentEdits(20);
+    const filesToCheck = new Set();
+    
+    for (const edit of recentEdits) {
+      if (edit.files) {
+        edit.files.forEach(f => {
+          if (!f.includes('.test.') && !f.includes('.spec.') && !f.includes('__tests__')) {
+            filesToCheck.add(f);
+          }
+        });
+      }
+    }
+
+    // Check for test files
+    for (const file of filesToCheck) {
+      const hasTest = await this.checkHasTestFile(file);
+      
+      if (!hasTest) {
+        suggestions.push({
+          type: 'add_tests',
+          category: 'testing',
+          description: `No tests found for "${file}". Consider adding test coverage.`,
+          target: file,
+          confidence: 0.80,
+          autoApply: false,
+          reason: 'Recently modified file without test coverage',
+          action: {
+            type: 'create',
+            operation: 'generate_tests',
+            target: file
+          }
+        });
+      }
+    }
+
+    return suggestions;
+  }
+
+  /**
+   * Suggest import organization
+   */
+  async suggestImportOrganization(context) {
+    const suggestions = [];
+    
+    if (!context || !context.currentFile) return suggestions;
+
+    // Check for unused imports by looking at facts
+    const facts = await this.memoryEngine?.searchFacts(context.currentFile, 100);
+    if (!facts) return suggestions;
+
+    const imports = facts.filter(f => f.type === 'import');
+    const exports = facts.filter(f => f.type === 'export' || f.type === 'function' || f.type === 'class');
+
+    for (const imp of imports) {
+      // Check if import is used in exports
+      const isUsed = exports.some(exp => 
+        exp.name === imp.name || 
+        exp.content?.includes(imp.name)
+      );
+
+      if (!isUsed) {
+        suggestions.push({
+          type: 'remove_unused_import',
+          category: 'organization',
+          description: `Import "${imp.name}" appears unused in "${context.currentFile}"`,
+          target: imp.name,
+          file: context.currentFile,
+          confidence: 0.85,
+          autoApply: false,
+          reason: 'Import is not referenced in any exports or function bodies',
+          action: {
+            type: 'remove',
+            operation: 'remove_import',
+            import: imp.name,
+            file: context.currentFile
+          }
+        });
+      }
+    }
+
+    return suggestions;
+  }
+
+  /**
+   * Suggest eliminating duplicate code
+   */
+  async suggestDuplicateCodeElimination(context) {
+    const suggestions = [];
+    
+    // Get recent code chunks
+    const chunks = await this.memoryEngine?.getRecentChunks(100);
+    if (!chunks || chunks.length < 2) return suggestions;
+
+    // Find similar chunks (simple similarity check)
+    const duplicates = this.findDuplicateChunks(chunks);
+
+    for (const dup of duplicates) {
+      suggestions.push({
+        type: 'extract_duplicate',
+        category: 'refactoring',
+        description: `Duplicate code detected: Similar code found in ${dup.files.length} locations`,
+        files: dup.files,
+        similarity: dup.similarity,
+        confidence: dup.similarity,
+        autoApply: false,
+        reason: `Code similarity: ${(dup.similarity * 100).toFixed(0)}%`,
+        action: {
+          type: 'refactor',
+          operation: 'extract_common',
+          files: dup.files,
+          similarity: dup.similarity
+        }
+      });
+    }
+
+    return suggestions;
+  }
+
+  /**
+   * Suggest performance improvements
+   */
+  async suggestPerformanceImprovements(context) {
+    const suggestions = [];
+    
+    if (!context || !context.currentFile) return suggestions;
+
+    // Check for known anti-patterns
+    const facts = await this.memoryEngine?.searchFacts(context.currentFile, 50);
+    if (!facts) return suggestions;
+
+    for (const fact of facts) {
+      // Check for console.log in production code
+      if (fact.content?.includes('console.log')) {
+        suggestions.push({
+          type: 'remove_debug_code',
+          category: 'performance',
+          description: `console.log found in "${fact.name}". Consider removing for production.`,
+          target: fact.name,
+          file: context.currentFile,
+          confidence: 0.75,
+          autoApply: false,
+          reason: 'Debug code should not be in production',
+          action: {
+            type: 'remove',
+            operation: 'remove_console_logs',
+            file: context.currentFile
+          }
+        });
+      }
+
+      // Check for nested loops (potential O(n²))
+      if (fact.content?.includes('for') && fact.content?.split('for').length > 2) {
+        suggestions.push({
+          type: 'optimize_complexity',
+          category: 'performance',
+          description: `Nested loops detected in "${fact.name}". Consider optimizing algorithm.`,
+          target: fact.name,
+          file: context.currentFile,
+          confidence: 0.70,
+          autoApply: false,
+          reason: 'Nested loops may cause performance issues with large datasets',
+          action: {
+            type: 'refactor',
+            operation: 'optimize_loops',
+            function: fact.name,
+            file: context.currentFile
+          }
+        });
+      }
+    }
+
+    return suggestions;
+  }
+
+  /**
+   * Analyze naming patterns from edit history
+   */
+  analyzeNamingPatterns(editHistory) {
+    const patterns = [];
+    const namingConventions = {
+      camelCase: /^[a-z][a-zA-Z0-9]*$/,
+      PascalCase: /^[A-Z][a-zA-Z0-9]*$/,
+      snake_case: /^[a-z][a-z0-9_]*$/,
+      SCREAMING_SNAKE: /^[A-Z][A-Z0-9_]*$/
+    };
+
+    // Collect all identifiers
+    const identifiers = [];
+    for (const edit of editHistory) {
+      if (edit.instruction) {
+        const words = edit.instruction.match(/\b[a-zA-Z_][a-zA-Z0-9_]*\b/g) || [];
+        identifiers.push(...words);
+      }
+    }
+
+    // Count by convention
+    const conventionCounts = {};
+    for (const id of identifiers) {
+      for (const [name, regex] of Object.entries(namingConventions)) {
+        if (regex.test(id)) {
+          conventionCounts[name] = (conventionCounts[name] || 0) + 1;
+          break;
+        }
+      }
+    }
+
+    // Find dominant convention
+    const dominant = Object.entries(conventionCounts)
+      .sort((a, b) => b[1] - a[1])[0];
+
+    if (dominant) {
+      // Find violations
+      for (const id of identifiers) {
+        const matchesDominant = namingConventions[dominant[0]].test(id);
+        if (!matchesDominant) {
+          const currentConvention = Object.entries(namingConventions)
+            .find(([_, regex]) => regex.test(id))?.[0] || 'unknown';
+          
+          patterns.push({
+            current: id,
+            convention: dominant[0],
+            currentConvention,
+            suggested: this.convertNaming(id, dominant[0]),
+            count: dominant[1],
+            inconsistency: 1 - (conventionCounts[currentConvention] || 0) / identifiers.length,
+            confidence: Math.min(0.70 + dominant[1] / 100, 0.95)
+          });
+        }
+      }
+    }
+
+    return patterns;
+  }
+
+  /**
+   * Convert naming convention
+   */
+  convertNaming(name, targetConvention) {
+    // Simple conversion logic
+    switch (targetConvention) {
+      case 'camelCase':
+        return name.toLowerCase().replace(/[_-](.)/g, (_, c) => c.toUpperCase());
+      case 'PascalCase':
+        return name.charAt(0).toUpperCase() + name.slice(1).toLowerCase().replace(/[_-](.)/g, (_, c) => c.toUpperCase());
+      case 'snake_case':
+        return name.replace(/[A-Z]/g, c => '_' + c.toLowerCase()).replace(/^_/, '');
+      default:
+        return name;
+    }
+  }
+
+  /**
+   * Find duplicate code chunks
+   */
+  findDuplicateChunks(chunks) {
+    const duplicates = [];
+    const seen = new Map();
+
+    for (const chunk of chunks) {
+      const normalized = this.normalizeCode(chunk.content);
+      
+      if (seen.has(normalized)) {
+        const existing = seen.get(normalized);
+        existing.files.push(chunk.file_id);
+        existing.count++;
+      } else {
+        seen.set(normalized, {
+          content: chunk.content,
+          files: [chunk.file_id],
+          count: 1
+        });
+      }
+    }
+
+    for (const [_, data] of seen) {
+      if (data.count >= 2) {
+        duplicates.push({
+          files: data.files,
+          similarity: 1.0, // Exact match for now
+          count: data.count
+        });
+      }
+    }
+
+    return duplicates;
+  }
+
+  /**
+   * Normalize code for comparison
+   */
+  normalizeCode(code) {
+    return code
+      .replace(/\s+/g, ' ')
+      .replace(/\n/g, ' ')
+      .replace(/\/\/.*$/gm, '')
+      .replace(/\/\*[\s\S]*?\*\//g, '')
+      .trim()
+      .toLowerCase();
+  }
+
+  /**
+   * Check if file has corresponding test file
+   */
+  async checkHasTestFile(file) {
+    const testPatterns = [
+      file.replace(/\.(js|ts|jsx|tsx)$/, '.test.$1'),
+      file.replace(/\.(js|ts|jsx|tsx)$/, '.spec.$1'),
+      file.replace(/\/([^/]+)\.(js|ts|jsx|tsx)$/, '/__tests__/$1.test.$2')
+    ];
+
+    for (const pattern of testPatterns) {
+      // Check in memory database
+      const exists = await this.memoryEngine?.db?.getFileByPath(pattern);
+      if (exists) return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Get edit history from database
+   */
+  async getEditHistory(limit = 100) {
+    if (!this.memoryEngine?.db) return [];
+    return this.memoryEngine.db.getRecentEdits(limit);
+  }
+
+  /**
+   * Get recent edits
+   */
+  async getRecentEdits(limit = 20) {
+    return this.getEditHistory(limit);
+  }
+
+  /**
+   * Get engine stats
+   */
+  getStats() {
+    return {
+      minConfidence: this.minConfidence,
+      cacheSize: this.suggestionCache.size,
+      detectorStats: this.detector.getStats()
+    };
+  }
+}
+
+export default SuggestionEngine;

package/src/memory/index.js

@@ -12,3 +12,6 @@ export { DailyLogs } from './utils/daily-logs.js';
 export { SyncEngine } from './utils/sync-engine.js';
 export { MemoryEngine } from './memory-engine.js';
 export { MemoryEngine as default } from './memory-engine.js';
+
+// Phase 4: Intelligence Layer
+export { PatternDetector, SuggestionEngine, StrategySelector } from '../intelligence/index.js';

package/src/memory/memory-engine.js

@@ -11,6 +11,7 @@ import { SmartRouter } from './utils/smart-router.js';
 import { DashboardClient } from './utils/dashboard-client.js';
 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';
 
@@ -30,13 +31,14 @@ export class MemoryEngine {
       memoryPath: this.memoryPath
     });
     
-    // Sync Engine - local ↔ cloud (optional)
+    // Sync Engine - local ↔ cloud (optional, auto-detect from MCFAST_TOKEN)
     this.syncEngine = null;
-    if (options.cloudEndpoint && options.apiKey) {
+    const hasToken = options.apiKey || process.env.MCFAST_TOKEN;
+    if (hasToken && options.enableSync !== false) {
       this.syncEngine = new SyncEngine({
         memoryPath: this.memoryPath,
-        cloudEndpoint: options.cloudEndpoint,
-        apiKey: options.apiKey,
+        apiKey: hasToken,
+        baseUrl: options.baseUrl || process.env.MCFAST_DASHBOARD_URL || 'https://mcfast.vercel.app',
         syncInterval: options.syncInterval || 5 * 60 * 1000
       });
     }
@@ -61,6 +63,21 @@ export class MemoryEngine {
     this.useUltraHybrid = options.useUltraHybrid !== false;
     this.targetAccuracy = options.targetAccuracy || 90;
     this.smartRoutingEnabled = options.smartRoutingEnabled !== false;
+    
+    // Phase 4: Intelligence Layer
+    this.intelligenceEnabled = options.intelligenceEnabled !== false;
+    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) {
@@ -95,6 +112,15 @@ export class MemoryEngine {
     this.isInitialized = true;
     console.log(`[MemoryEngine] Initialized for: ${projectPath}`);
     console.log(`[MemoryEngine] Smart Routing: ${this.smartRoutingEnabled ? 'ENABLED' : 'DISABLED'}`);
+    console.log(`[MemoryEngine] Intelligence Layer: ${this.intelligenceEnabled ? 'ENABLED' : 'DISABLED'}`);
+    
+    // Load intelligence models
+    if (this.intelligenceEnabled) {
+      await this.patternDetector.loadModel?.();
+      await this.suggestionEngine.loadModel?.();
+      await this.strategySelector.loadModel?.();
+      console.log('[MemoryEngine] ✅ Intelligence models loaded');
+    }
   }
 
   async indexFile(filePath, content) {
@@ -517,9 +543,129 @@ export class MemoryEngine {
     }
   }
 
+  // ==================== INTELLIGENCE LAYER (Phase 4) ====================
+
+  /**
+   * Detect patterns from edit history
+   * @returns {Array} Detected patterns with confidence scores
+   */
+  async detectPatterns() {
+    if (!this.intelligenceEnabled || !this.patternDetector) {
+      throw new Error('Intelligence layer not enabled');
+    }
+
+    console.log('[MemoryEngine] 🔍 Detecting patterns...');
+    
+    const editHistory = await this.db.getRecentEdits(100);
+    const patterns = await this.patternDetector.analyze(editHistory);
+    
+    console.log(`[MemoryEngine] ✅ Found ${patterns.length} patterns`);
+    return patterns;
+  }
+
+  /**
+   * Get intelligent suggestions based on current context
+   * @param {Object} context - Current editing context
+   * @returns {Array} Suggestions with confidence scores
+   */
+  async getSuggestions(context = {}) {
+    if (!this.intelligenceEnabled || !this.suggestionEngine) {
+      throw new Error('Intelligence layer not enabled');
+    }
+
+    console.log('[MemoryEngine] 💡 Generating suggestions...');
+    
+    const suggestions = await this.suggestionEngine.getSuggestions(context);
+    
+    console.log(`[MemoryEngine] ✅ Generated ${suggestions.length} suggestions`);
+    return suggestions;
+  }
+
+  /**
+   * Select best strategy for edit operation
+   * @param {string} instruction - Edit instruction
+   * @param {Object} context - Edit context
+   * @returns {Object} Selected strategy with confidence
+   */
+  async selectStrategy(instruction, context = {}) {
+    if (!this.intelligenceEnabled || !this.strategySelector) {
+      // Fallback: use simple heuristics
+      return this.fallbackStrategySelection(instruction, context);
+    }
+
+    console.log('[MemoryEngine] 🎯 Selecting strategy...');
+    
+    const result = await this.strategySelector.selectStrategy(instruction, context);
+    
+    console.log(`[MemoryEngine] ✅ Selected: ${result.strategy} (confidence: ${(result.confidence * 100).toFixed(1)}%)`);
+    return result;
+  }
+
+  /**
+   * Learn from edit result (improve future selections)
+   * @param {Object} edit - Edit data
+   * @param {Object} result - Edit result
+   */
+  async learnFromEdit(edit, result) {
+    if (!this.intelligenceEnabled || !this.strategySelector) {
+      return;
+    }
+
+    await this.strategySelector.learn(edit, result);
+    console.log('[MemoryEngine] 🧠 Learned from edit result');
+  }
+
+  /**
+   * Get intelligence layer statistics
+   */
+  getIntelligenceStats() {
+    if (!this.intelligenceEnabled) {
+      return { enabled: false };
+    }
+
+    return {
+      enabled: true,
+      patternDetector: this.patternDetector?.getStats() || null,
+      suggestionEngine: this.suggestionEngine?.getStats() || null,
+      strategySelector: this.strategySelector?.getStats() || null
+    };
+  }
+
+  /**
+   * Enable/disable intelligence layer
+   */
+  setIntelligenceEnabled(enabled) {
+    this.intelligenceEnabled = enabled;
+    console.log(`[MemoryEngine] Intelligence layer ${enabled ? 'ENABLED' : 'DISABLED'}`);
+  }
+
+  /**
+   * Fallback strategy selection when ML is disabled
+   */
+  fallbackStrategySelection(instruction, context) {
+    const lower = instruction.toLowerCase();
+    
+    // Simple keyword-based selection
+    if (lower.includes('replace') || lower.includes('change line') || lower.includes('exact')) {
+      return { strategy: 'deterministic', confidence: 0.8, reason: 'Simple replacement detected' };
+    }
+    
+    if (lower.includes('refactor') || lower.includes('improve') || lower.includes('multiple')) {
+      return { strategy: 'llm', confidence: 0.8, reason: 'Complex operation detected' };
+    }
+    
+    return { strategy: 'cached', confidence: 0.6, reason: 'Default selection' };
+  }
+
   // ==================== LIFECYCLE ====================
 
   async shutdown() {
+    // Save intelligence models
+    if (this.intelligenceEnabled) {
+      await this.strategySelector?.saveModel?.();
+      console.log('[MemoryEngine] 💾 Intelligence models saved');
+    }
+    
     if (this.watcher) await this.watcher.stop();
     if (this.syncEngine) this.syncEngine.shutdown();
     this.db.close();

package/src/memory/utils/chunker.js

@@ -69,10 +69,13 @@ export class Chunker {
   createChunk(lines, startLine, endLine, metadata) {
     const content = lines.join('\n');
     const tokens = this.estimateTokens(content);
+    
+    // Handle both string (filePath) and object metadata
+    const filePath = typeof metadata === 'string' ? metadata : (metadata.filePath || '');
 
     return {
-      id: this.generateChunkId(metadata.filePath, startLine),
-      file_id: this.generateFileId(metadata.filePath),
+      id: this.generateChunkId(filePath, startLine),
+      file_id: this.generateFileId(filePath),
       content: content,
       start_line: startLine,
       end_line: endLine,