@vibecheckai/cli 3.5.0 → 3.5.1

package/bin/runners/lib/agent-firewall/learning/learning-engine.js

@@ -1,849 +0,0 @@
-/**
- * Learning Firewall Engine
- * 
- * ═══════════════════════════════════════════════════════════════════════════════
- * COMPETITIVE MOAT FEATURE - Self-Improving Violation Detection
- * ═══════════════════════════════════════════════════════════════════════════════
- * 
- * This engine learns from user feedback to improve detection accuracy over time.
- * It tracks:
- * - False positives that users dismiss
- * - True positives that users fix
- * - Patterns that lead to violations
- * - Context that causes false detections
- * 
- * The learning system:
- * 1. Adjusts confidence scores based on historical accuracy
- * 2. Learns code patterns that are commonly dismissed
- * 3. Adapts to team/project-specific conventions
- * 4. Shares anonymized learnings across the ecosystem (opt-in)
- */
-
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const crypto = require("crypto");
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// LEARNING DATABASE SCHEMA
-// ═══════════════════════════════════════════════════════════════════════════════
-
-const DEFAULT_LEARNING_DB = {
-  version: "1.0.0",
-  created: new Date().toISOString(),
-  updated: new Date().toISOString(),
-  
-  // Feedback on individual violations
-  feedback: [],
-  
-  // Aggregated pattern statistics
-  patterns: {
-    // Pattern hash -> { occurrences, dismissed, fixed, confidence_adjustment }
-  },
-  
-  // Rule-level statistics
-  rules: {
-    // Rule ID -> { total, false_positives, true_positives, accuracy }
-  },
-  
-  // File path pattern statistics
-  pathPatterns: {
-    // Pattern -> { violations, dismissals, fixes }
-  },
-  
-  // Team-specific conventions learned
-  conventions: {
-    // Convention hash -> { pattern, context, approved, reason }
-  },
-  
-  // Model performance tracking
-  performance: {
-    totalPredictions: 0,
-    correctPredictions: 0,
-    falsePositives: 0,
-    falseNegatives: 0,
-    accuracy: 0,
-    precision: 0,
-    recall: 0,
-    f1Score: 0
-  }
-};
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// FEEDBACK TYPES
-// ═══════════════════════════════════════════════════════════════════════════════
-
-const FEEDBACK_TYPE = {
-  DISMISS: "dismiss",           // User dismissed as false positive
-  FIX: "fix",                   // User fixed the violation
-  OVERRIDE: "override",         // User approved despite violation
-  BLOCK_CORRECT: "block_ok",    // User confirms block was correct
-  ALLOW_INCORRECT: "allow_bad"  // User reports missed violation
-};
-
-const FEEDBACK_WEIGHT = {
-  [FEEDBACK_TYPE.DISMISS]: -0.1,      // Reduce confidence
-  [FEEDBACK_TYPE.FIX]: 0.05,          // Slightly increase (was correct)
-  [FEEDBACK_TYPE.OVERRIDE]: -0.15,    // Stronger reduction
-  [FEEDBACK_TYPE.BLOCK_CORRECT]: 0.1, // Increase confidence
-  [FEEDBACK_TYPE.ALLOW_INCORRECT]: 0.2 // Should have blocked
-};
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// LEARNING ENGINE CLASS
-// ═══════════════════════════════════════════════════════════════════════════════
-
-class LearningEngine {
-  constructor(options = {}) {
-    this.projectRoot = options.projectRoot || process.cwd();
-    this.dbPath = options.dbPath || path.join(this.projectRoot, ".vibecheck", "learning", "firewall-learning.json");
-    this.enableCloudSync = options.enableCloudSync || false;
-    this.minSamplesForAdjustment = options.minSamplesForAdjustment || 5;
-    this.maxConfidenceAdjustment = options.maxConfidenceAdjustment || 0.3;
-    this.decayFactor = options.decayFactor || 0.95; // Older feedback matters less
-    
-    this.db = this.loadDatabase();
-  }
-
-  /**
-   * Load or initialize the learning database
-   */
-  loadDatabase() {
-    try {
-      if (fs.existsSync(this.dbPath)) {
-        const data = JSON.parse(fs.readFileSync(this.dbPath, "utf8"));
-        return this.migrateDatabase(data);
-      }
-    } catch (error) {
-      // Log but don't crash - start fresh
-    }
-    return { ...DEFAULT_LEARNING_DB };
-  }
-
-  /**
-   * Migrate database to latest version
-   */
-  migrateDatabase(data) {
-    // Add any missing fields from newer versions
-    return {
-      ...DEFAULT_LEARNING_DB,
-      ...data,
-      patterns: { ...DEFAULT_LEARNING_DB.patterns, ...data.patterns },
-      rules: { ...DEFAULT_LEARNING_DB.rules, ...data.rules },
-      pathPatterns: { ...DEFAULT_LEARNING_DB.pathPatterns, ...data.pathPatterns },
-      conventions: { ...DEFAULT_LEARNING_DB.conventions, ...data.conventions },
-      performance: { ...DEFAULT_LEARNING_DB.performance, ...data.performance }
-    };
-  }
-
-  /**
-   * Save the learning database
-   */
-  saveDatabase() {
-    try {
-      const dir = path.dirname(this.dbPath);
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-      }
-      
-      this.db.updated = new Date().toISOString();
-      fs.writeFileSync(this.dbPath, JSON.stringify(this.db, null, 2), "utf8");
-    } catch (error) {
-      // Log but don't crash
-    }
-  }
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // FEEDBACK RECORDING
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  /**
-   * Record feedback for a violation
-   */
-  recordFeedback({
-    violationId,
-    ruleId,
-    feedbackType,
-    filePath,
-    codePattern,
-    context,
-    reason,
-    userId
-  }) {
-    const feedback = {
-      id: this.generateId(),
-      violationId,
-      ruleId,
-      feedbackType,
-      filePath,
-      codePattern: this.normalizePattern(codePattern),
-      patternHash: this.hashPattern(codePattern),
-      context,
-      reason,
-      userId: userId ? this.hashUserId(userId) : null,
-      timestamp: new Date().toISOString()
-    };
-
-    // Store feedback
-    this.db.feedback.push(feedback);
-
-    // Update pattern statistics
-    this.updatePatternStats(feedback);
-
-    // Update rule statistics
-    this.updateRuleStats(feedback);
-
-    // Update path pattern statistics
-    this.updatePathStats(feedback);
-
-    // Recalculate performance metrics
-    this.updatePerformanceMetrics(feedback);
-
-    // Check if this creates a new convention
-    this.detectConvention(feedback);
-
-    // Persist changes
-    this.saveDatabase();
-
-    // Optionally sync to cloud
-    if (this.enableCloudSync) {
-      this.syncToCloud(feedback);
-    }
-
-    return feedback;
-  }
-
-  /**
-   * Update pattern-level statistics
-   */
-  updatePatternStats(feedback) {
-    const { patternHash, feedbackType } = feedback;
-    
-    if (!this.db.patterns[patternHash]) {
-      this.db.patterns[patternHash] = {
-        pattern: feedback.codePattern,
-        occurrences: 0,
-        dismissed: 0,
-        fixed: 0,
-        overridden: 0,
-        confidenceAdjustment: 0,
-        firstSeen: feedback.timestamp,
-        lastSeen: feedback.timestamp
-      };
-    }
-
-    const stats = this.db.patterns[patternHash];
-    stats.occurrences++;
-    stats.lastSeen = feedback.timestamp;
-
-    switch (feedbackType) {
-      case FEEDBACK_TYPE.DISMISS:
-        stats.dismissed++;
-        break;
-      case FEEDBACK_TYPE.FIX:
-        stats.fixed++;
-        break;
-      case FEEDBACK_TYPE.OVERRIDE:
-        stats.overridden++;
-        break;
-    }
-
-    // Calculate confidence adjustment
-    stats.confidenceAdjustment = this.calculateConfidenceAdjustment(stats);
-  }
-
-  /**
-   * Update rule-level statistics
-   */
-  updateRuleStats(feedback) {
-    const { ruleId, feedbackType } = feedback;
-    
-    if (!this.db.rules[ruleId]) {
-      this.db.rules[ruleId] = {
-        total: 0,
-        truePositives: 0,
-        falsePositives: 0,
-        accuracy: 1.0,
-        confidenceMultiplier: 1.0
-      };
-    }
-
-    const stats = this.db.rules[ruleId];
-    stats.total++;
-
-    switch (feedbackType) {
-      case FEEDBACK_TYPE.FIX:
-      case FEEDBACK_TYPE.BLOCK_CORRECT:
-        stats.truePositives++;
-        break;
-      case FEEDBACK_TYPE.DISMISS:
-      case FEEDBACK_TYPE.OVERRIDE:
-        stats.falsePositives++;
-        break;
-    }
-
-    // Calculate accuracy
-    if (stats.total >= this.minSamplesForAdjustment) {
-      stats.accuracy = stats.truePositives / stats.total;
-      stats.confidenceMultiplier = 0.5 + (stats.accuracy * 0.5); // Range: 0.5 to 1.0
-    }
-  }
-
-  /**
-   * Update path pattern statistics
-   */
-  updatePathStats(feedback) {
-    const pathPattern = this.extractPathPattern(feedback.filePath);
-    
-    if (!this.db.pathPatterns[pathPattern]) {
-      this.db.pathPatterns[pathPattern] = {
-        violations: 0,
-        dismissals: 0,
-        fixes: 0,
-        shouldSkip: false
-      };
-    }
-
-    const stats = this.db.pathPatterns[pathPattern];
-    stats.violations++;
-
-    switch (feedback.feedbackType) {
-      case FEEDBACK_TYPE.DISMISS:
-      case FEEDBACK_TYPE.OVERRIDE:
-        stats.dismissals++;
-        break;
-      case FEEDBACK_TYPE.FIX:
-        stats.fixes++;
-        break;
-    }
-
-    // If dismissal rate is very high, mark as should skip
-    if (stats.violations >= this.minSamplesForAdjustment) {
-      stats.shouldSkip = (stats.dismissals / stats.violations) > 0.8;
-    }
-  }
-
-  /**
-   * Calculate confidence adjustment for a pattern
-   */
-  calculateConfidenceAdjustment(stats) {
-    if (stats.occurrences < this.minSamplesForAdjustment) {
-      return 0; // Not enough data
-    }
-
-    // Calculate dismissal rate
-    const dismissalRate = (stats.dismissed + stats.overridden) / stats.occurrences;
-    const fixRate = stats.fixed / stats.occurrences;
-
-    // Adjust confidence based on historical accuracy
-    // High dismissal rate = lower confidence
-    // High fix rate = higher confidence
-    let adjustment = (fixRate - dismissalRate) * 0.2;
-
-    // Clamp to max adjustment
-    adjustment = Math.max(-this.maxConfidenceAdjustment, 
-                         Math.min(this.maxConfidenceAdjustment, adjustment));
-
-    return adjustment;
-  }
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // CONFIDENCE ADJUSTMENT API
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  /**
-   * Get adjusted confidence for a violation
-   */
-  getAdjustedConfidence(originalConfidence, {
-    ruleId,
-    codePattern,
-    filePath
-  }) {
-    let adjustment = 0;
-
-    // Apply pattern-based adjustment
-    const patternHash = this.hashPattern(codePattern);
-    if (this.db.patterns[patternHash]) {
-      adjustment += this.db.patterns[patternHash].confidenceAdjustment;
-    }
-
-    // Apply rule-based multiplier
-    if (this.db.rules[ruleId]) {
-      const ruleStats = this.db.rules[ruleId];
-      if (ruleStats.total >= this.minSamplesForAdjustment) {
-        adjustment += (ruleStats.confidenceMultiplier - 1) * 0.2;
-      }
-    }
-
-    // Apply path-based adjustment
-    const pathPattern = this.extractPathPattern(filePath);
-    if (this.db.pathPatterns[pathPattern]?.shouldSkip) {
-      adjustment -= 0.3; // Significantly reduce for commonly dismissed paths
-    }
-
-    // Calculate final confidence
-    let finalConfidence = originalConfidence + adjustment;
-    
-    // Clamp to valid range
-    finalConfidence = Math.max(0, Math.min(1, finalConfidence));
-
-    return {
-      original: originalConfidence,
-      adjusted: finalConfidence,
-      adjustment,
-      factors: {
-        pattern: this.db.patterns[patternHash]?.confidenceAdjustment || 0,
-        rule: this.db.rules[ruleId]?.confidenceMultiplier || 1,
-        path: this.db.pathPatterns[pathPattern]?.shouldSkip ? -0.3 : 0
-      }
-    };
-  }
-
-  /**
-   * Check if a violation should be auto-dismissed
-   */
-  shouldAutoDismiss({
-    ruleId,
-    codePattern,
-    filePath,
-    confidenceThreshold = 0.4
-  }) {
-    const patternHash = this.hashPattern(codePattern);
-    const patternStats = this.db.patterns[patternHash];
-    const ruleStats = this.db.rules[ruleId];
-    const pathStats = this.db.pathPatterns[this.extractPathPattern(filePath)];
-
-    // Auto-dismiss if pattern is almost always dismissed
-    if (patternStats && patternStats.occurrences >= 10) {
-      const dismissRate = (patternStats.dismissed + patternStats.overridden) / patternStats.occurrences;
-      if (dismissRate > 0.9) {
-        return {
-          dismiss: true,
-          reason: `Pattern dismissed ${Math.round(dismissRate * 100)}% of the time (${patternStats.occurrences} occurrences)`,
-          confidence: 1 - dismissRate
-        };
-      }
-    }
-
-    // Auto-dismiss if rule has very high false positive rate
-    if (ruleStats && ruleStats.total >= 20 && ruleStats.accuracy < 0.3) {
-      return {
-        dismiss: true,
-        reason: `Rule ${ruleId} has only ${Math.round(ruleStats.accuracy * 100)}% accuracy`,
-        confidence: ruleStats.accuracy
-      };
-    }
-
-    // Auto-dismiss if path pattern is commonly dismissed
-    if (pathStats?.shouldSkip) {
-      return {
-        dismiss: true,
-        reason: `Files matching this pattern are commonly dismissed`,
-        confidence: 0.2
-      };
-    }
-
-    return { dismiss: false };
-  }
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // CONVENTION LEARNING
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  /**
-   * Detect if feedback creates a new team convention
-   */
-  detectConvention(feedback) {
-    // Check if this pattern is consistently overridden with a reason
-    if (feedback.feedbackType === FEEDBACK_TYPE.OVERRIDE && feedback.reason) {
-      const patternHash = feedback.patternHash;
-      const patternStats = this.db.patterns[patternHash];
-
-      if (patternStats && patternStats.overridden >= 3) {
-        // Multiple overrides with reasons = potential convention
-        const conventionId = `${feedback.ruleId}-${patternHash}`;
-        
-        if (!this.db.conventions[conventionId]) {
-          this.db.conventions[conventionId] = {
-            pattern: feedback.codePattern,
-            ruleId: feedback.ruleId,
-            context: feedback.context,
-            reasons: [],
-            occurrences: 0,
-            approved: false,
-            createdAt: feedback.timestamp
-          };
-        }
-
-        const convention = this.db.conventions[conventionId];
-        convention.occurrences++;
-        convention.reasons.push(feedback.reason);
-        convention.lastUpdated = feedback.timestamp;
-
-        // Auto-approve if consistent pattern
-        if (convention.occurrences >= 5 && !convention.approved) {
-          convention.approved = true;
-          convention.approvedAt = feedback.timestamp;
-        }
-      }
-    }
-  }
-
-  /**
-   * Get approved conventions that match a violation
-   */
-  getMatchingConventions(ruleId, codePattern) {
-    const patternHash = this.hashPattern(codePattern);
-    const conventionId = `${ruleId}-${patternHash}`;
-    
-    const convention = this.db.conventions[conventionId];
-    if (convention?.approved) {
-      return [convention];
-    }
-
-    // Also check for similar patterns
-    const similar = [];
-    for (const [id, conv] of Object.entries(this.db.conventions)) {
-      if (conv.approved && conv.ruleId === ruleId) {
-        const similarity = this.calculatePatternSimilarity(codePattern, conv.pattern);
-        if (similarity > 0.8) {
-          similar.push({ ...conv, similarity });
-        }
-      }
-    }
-
-    return similar.sort((a, b) => b.similarity - a.similarity);
-  }
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // PERFORMANCE TRACKING
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  /**
-   * Update global performance metrics
-   */
-  updatePerformanceMetrics(feedback) {
-    const perf = this.db.performance;
-    perf.totalPredictions++;
-
-    switch (feedback.feedbackType) {
-      case FEEDBACK_TYPE.FIX:
-      case FEEDBACK_TYPE.BLOCK_CORRECT:
-        perf.correctPredictions++;
-        break;
-      case FEEDBACK_TYPE.DISMISS:
-      case FEEDBACK_TYPE.OVERRIDE:
-        perf.falsePositives++;
-        break;
-      case FEEDBACK_TYPE.ALLOW_INCORRECT:
-        perf.falseNegatives++;
-        break;
-    }
-
-    // Calculate metrics
-    const tp = perf.correctPredictions;
-    const fp = perf.falsePositives;
-    const fn = perf.falseNegatives;
-
-    perf.accuracy = perf.totalPredictions > 0 
-      ? perf.correctPredictions / perf.totalPredictions 
-      : 0;
-    
-    perf.precision = (tp + fp) > 0 ? tp / (tp + fp) : 0;
-    perf.recall = (tp + fn) > 0 ? tp / (tp + fn) : 0;
-    perf.f1Score = (perf.precision + perf.recall) > 0 
-      ? 2 * (perf.precision * perf.recall) / (perf.precision + perf.recall)
-      : 0;
-  }
-
-  /**
-   * Get performance report
-   */
-  getPerformanceReport() {
-    const perf = this.db.performance;
-    
-    return {
-      totalPredictions: perf.totalPredictions,
-      accuracy: (perf.accuracy * 100).toFixed(1) + "%",
-      precision: (perf.precision * 100).toFixed(1) + "%",
-      recall: (perf.recall * 100).toFixed(1) + "%",
-      f1Score: (perf.f1Score * 100).toFixed(1) + "%",
-      falsePositiveRate: perf.totalPredictions > 0 
-        ? ((perf.falsePositives / perf.totalPredictions) * 100).toFixed(1) + "%"
-        : "N/A",
-      topFalsePositivePatterns: this.getTopFalsePositivePatterns(5),
-      topFalsePositiveRules: this.getTopFalsePositiveRules(5),
-      conventionsLearned: Object.values(this.db.conventions).filter(c => c.approved).length
-    };
-  }
-
-  /**
-   * Get patterns with highest false positive rates
-   */
-  getTopFalsePositivePatterns(limit) {
-    const patterns = Object.entries(this.db.patterns)
-      .filter(([, stats]) => stats.occurrences >= this.minSamplesForAdjustment)
-      .map(([hash, stats]) => ({
-        hash,
-        pattern: stats.pattern,
-        fpRate: (stats.dismissed + stats.overridden) / stats.occurrences,
-        occurrences: stats.occurrences
-      }))
-      .sort((a, b) => b.fpRate - a.fpRate)
-      .slice(0, limit);
-
-    return patterns;
-  }
-
-  /**
-   * Get rules with highest false positive rates
-   */
-  getTopFalsePositiveRules(limit) {
-    const rules = Object.entries(this.db.rules)
-      .filter(([, stats]) => stats.total >= this.minSamplesForAdjustment)
-      .map(([ruleId, stats]) => ({
-        ruleId,
-        fpRate: stats.falsePositives / stats.total,
-        total: stats.total,
-        accuracy: stats.accuracy
-      }))
-      .sort((a, b) => b.fpRate - a.fpRate)
-      .slice(0, limit);
-
-    return rules;
-  }
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // UTILITY FUNCTIONS
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  /**
-   * Generate unique ID
-   */
-  generateId() {
-    return crypto.randomBytes(8).toString("hex");
-  }
-
-  /**
-   * Hash a code pattern for deduplication
-   */
-  hashPattern(pattern) {
-    if (!pattern) return "empty";
-    const normalized = this.normalizePattern(pattern);
-    return crypto.createHash("sha256").update(normalized).digest("hex").slice(0, 16);
-  }
-
-  /**
-   * Normalize a code pattern (remove whitespace, variable names, etc.)
-   */
-  normalizePattern(pattern) {
-    if (!pattern) return "";
-    
-    return pattern
-      .replace(/\s+/g, " ")                    // Normalize whitespace
-      .replace(/["'`].*?["'`]/g, '""')         // Normalize strings
-      .replace(/\b\d+\b/g, "0")                // Normalize numbers
-      .replace(/\b[a-z_][a-z0-9_]*\b/gi, "ID") // Normalize identifiers
-      .trim();
-  }
-
-  /**
-   * Extract a generalized path pattern from a file path
-   */
-  extractPathPattern(filePath) {
-    if (!filePath) return "unknown";
-    
-    // Extract meaningful parts: directory structure + file type
-    const parts = filePath.replace(/\\/g, "/").split("/");
-    const fileName = parts.pop();
-    const ext = path.extname(fileName);
-    
-    // Check for common patterns
-    if (/test|spec|__tests__|__mocks__/i.test(filePath)) {
-      return `**/*test*${ext}`;
-    }
-    if (/\.d\.ts$/.test(fileName)) {
-      return "**/*.d.ts";
-    }
-    if (/generated|__generated__|\.generated\./i.test(filePath)) {
-      return "**/generated/**";
-    }
-    if (/config|\.config\./i.test(fileName)) {
-      return `**/config*${ext}`;
-    }
-    
-    // Return directory pattern + extension
-    const lastDir = parts.filter(p => p && p !== ".").pop() || "";
-    return `**/${lastDir}/*${ext}`;
-  }
-
-  /**
-   * Calculate similarity between two patterns
-   */
-  calculatePatternSimilarity(pattern1, pattern2) {
-    const norm1 = this.normalizePattern(pattern1);
-    const norm2 = this.normalizePattern(pattern2);
-    
-    if (norm1 === norm2) return 1;
-    
-    // Levenshtein-based similarity
-    const maxLen = Math.max(norm1.length, norm2.length);
-    if (maxLen === 0) return 1;
-    
-    const distance = this.levenshteinDistance(norm1, norm2);
-    return 1 - (distance / maxLen);
-  }
-
-  /**
-   * Calculate Levenshtein distance
-   */
-  levenshteinDistance(str1, str2) {
-    const m = str1.length;
-    const n = str2.length;
-    const dp = Array(m + 1).fill(null).map(() => Array(n + 1).fill(0));
-
-    for (let i = 0; i <= m; i++) dp[i][0] = i;
-    for (let j = 0; j <= n; j++) dp[0][j] = j;
-
-    for (let i = 1; i <= m; i++) {
-      for (let j = 1; j <= n; j++) {
-        const cost = str1[i - 1] === str2[j - 1] ? 0 : 1;
-        dp[i][j] = Math.min(
-          dp[i - 1][j] + 1,
-          dp[i][j - 1] + 1,
-          dp[i - 1][j - 1] + cost
-        );
-      }
-    }
-
-    return dp[m][n];
-  }
-
-  /**
-   * Hash user ID for privacy
-   */
-  hashUserId(userId) {
-    return crypto.createHash("sha256").update(userId).digest("hex").slice(0, 12);
-  }
-
-  /**
-   * Sync feedback to cloud (placeholder for ecosystem learning)
-   */
-  async syncToCloud(feedback) {
-    // Would send anonymized feedback to cloud service
-    // for cross-project learning (opt-in only)
-  }
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // EXPORT/IMPORT
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  /**
-   * Export learning data for sharing
-   */
-  exportLearnings() {
-    return {
-      version: this.db.version,
-      exported: new Date().toISOString(),
-      patterns: Object.entries(this.db.patterns)
-        .filter(([, stats]) => stats.occurrences >= this.minSamplesForAdjustment)
-        .map(([hash, stats]) => ({
-          hash,
-          confidenceAdjustment: stats.confidenceAdjustment,
-          occurrences: stats.occurrences
-        })),
-      rules: Object.entries(this.db.rules)
-        .filter(([, stats]) => stats.total >= this.minSamplesForAdjustment)
-        .map(([ruleId, stats]) => ({
-          ruleId,
-          confidenceMultiplier: stats.confidenceMultiplier,
-          accuracy: stats.accuracy
-        })),
-      conventions: Object.values(this.db.conventions)
-        .filter(c => c.approved)
-        .map(c => ({
-          ruleId: c.ruleId,
-          pattern: c.pattern,
-          reasons: c.reasons.slice(0, 3) // Limit reasons
-        }))
-    };
-  }
-
-  /**
-   * Import learning data from another source
-   */
-  importLearnings(data, options = {}) {
-    const { merge = true, weight = 0.5 } = options;
-
-    if (!merge) {
-      // Replace mode - use imported data directly
-      this.db = { ...DEFAULT_LEARNING_DB, ...data };
-      this.saveDatabase();
-      return;
-    }
-
-    // Merge mode - combine with existing data
-    for (const pattern of (data.patterns || [])) {
-      if (this.db.patterns[pattern.hash]) {
-        // Average the adjustments
-        this.db.patterns[pattern.hash].confidenceAdjustment = 
-          (this.db.patterns[pattern.hash].confidenceAdjustment * (1 - weight)) +
-          (pattern.confidenceAdjustment * weight);
-      } else {
-        this.db.patterns[pattern.hash] = {
-          ...DEFAULT_LEARNING_DB.patterns,
-          confidenceAdjustment: pattern.confidenceAdjustment * weight,
-          occurrences: Math.round(pattern.occurrences * weight)
-        };
-      }
-    }
-
-    for (const rule of (data.rules || [])) {
-      if (this.db.rules[rule.ruleId]) {
-        this.db.rules[rule.ruleId].confidenceMultiplier = 
-          (this.db.rules[rule.ruleId].confidenceMultiplier * (1 - weight)) +
-          (rule.confidenceMultiplier * weight);
-      } else {
-        this.db.rules[rule.ruleId] = {
-          ...DEFAULT_LEARNING_DB.rules,
-          confidenceMultiplier: rule.confidenceMultiplier
-        };
-      }
-    }
-
-    this.saveDatabase();
-  }
-
-  /**
-   * Reset all learning data
-   */
-  reset() {
-    this.db = { ...DEFAULT_LEARNING_DB };
-    this.saveDatabase();
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// SINGLETON INSTANCE
-// ═══════════════════════════════════════════════════════════════════════════════
-
-let instance = null;
-
-function getLearningEngine(options = {}) {
-  if (!instance || options.projectRoot !== instance.projectRoot) {
-    instance = new LearningEngine(options);
-  }
-  return instance;
-}
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// EXPORTS
-// ═══════════════════════════════════════════════════════════════════════════════
-
-module.exports = {
-  LearningEngine,
-  getLearningEngine,
-  FEEDBACK_TYPE,
-  FEEDBACK_WEIGHT
-};