aios-core 4.2.13 → 4.2.15

package/.aios-core/development/scripts/pattern-learner.js

@@ -1,1225 +1,1225 @@
-const fs = require('fs').promises;
-const path = require('path');
-const chalk = require('chalk');
-const EventEmitter = require('events');
-
-/**
- * Pattern learning system for successful modifications
- * Learns from successful modifications to suggest improvements and automate common patterns
- */
-class PatternLearner extends EventEmitter {
-  constructor(options = {}) {
-    super();
-    this.rootPath = options.rootPath || process.cwd();
-    this.patternsDir = path.join(this.rootPath, '.aios', 'patterns');
-    this.historyFile = path.join(this.patternsDir, 'modification_history.json');
-    this.patternsFile = path.join(this.patternsDir, 'learned_patterns.json');
-    this.patterns = new Map();
-    this.modificationHistory = [];
-    this.learningThreshold = options.learningThreshold || 3; // Minimum occurrences to learn pattern
-    this.similarityThreshold = options.similarityThreshold || 0.8; // 80% similarity
-  }
-
-  /**
-   * Initialize pattern learner
-   */
-  async initialize() {
-    await fs.mkdir(this.patternsDir, { recursive: true });
-    await this.loadHistory();
-    await this.loadPatterns();
-    console.log(chalk.green('✅ Pattern learner initialized'));
-  }
-
-  /**
-   * Record successful modification for learning
-   */
-  async recordSuccessfulModification(modification) {
-    const record = {
-      id: `mod-${Date.now()}-${Math.random().toString(36).substr(2, 6)}`,
-      timestamp: new Date().toISOString(),
-      componentType: modification.componentType,
-      modificationType: modification.modificationType,
-      patterns: await this.extractPatterns(modification),
-      outcomes: {
-        success: true,
-        metrics: modification.metrics || {},
-        improvements: modification.improvements || []
-      },
-      metadata: {
-        author: modification.author || process.env.USER || 'unknown',
-        duration: modification.duration,
-        complexity: modification.complexity
-      }
-    };
-
-    // Add to history
-    this.modificationHistory.push(record);
-    
-    // Learn from this modification
-    await this.learnFromModification(record);
-    
-    // Save updated history
-    await this.saveHistory();
-    
-    // Emit event for real-time learning
-    this.emit('modification_recorded', record);
-    
-    console.log(chalk.green(`✅ Recorded successful modification: ${record.id}`));
-    
-    return {
-      recordId: record.id,
-      patternsExtracted: record.patterns.length,
-      learningTriggered: await this.checkLearningThreshold(record.patterns)
-    };
-  }
-
-  /**
-   * Extract patterns from modification
-   */
-  async extractPatterns(modification) {
-    const patterns = [];
-
-    // Code change patterns
-    if (modification.codeChanges) {
-      patterns.push(...this.extractCodePatterns(modification.codeChanges));
-    }
-
-    // Structural patterns
-    if (modification.structuralChanges) {
-      patterns.push(...this.extractStructuralPatterns(modification.structuralChanges));
-    }
-
-    // Refactoring patterns
-    if (modification.refactoringType) {
-      patterns.push(...this.extractRefactoringPatterns(modification));
-    }
-
-    // Dependency patterns
-    if (modification.dependencyChanges) {
-      patterns.push(...this.extractDependencyPatterns(modification.dependencyChanges));
-    }
-
-    // Performance patterns
-    if (modification.performanceImprovements) {
-      patterns.push(...this.extractPerformancePatterns(modification.performanceImprovements));
-    }
-
-    return patterns;
-  }
-
-  /**
-   * Extract code change patterns
-   */
-  extractCodePatterns(codeChanges) {
-    const patterns = [];
-
-    for (const change of codeChanges) {
-      // Function transformation patterns
-      if (change.type === 'function_transformation') {
-        patterns.push({
-          type: 'code_transformation',
-          subtype: 'function',
-          from: this.normalizeCode(change.before),
-          to: this.normalizeCode(change.after),
-          context: change.context,
-          benefits: change.benefits || []
-        });
-      }
-
-      // Error handling patterns
-      if (change.type === 'error_handling') {
-        patterns.push({
-          type: 'error_handling',
-          subtype: change.handlingType,
-          pattern: change.pattern,
-          improvement: change.improvement
-        });
-      }
-
-      // Async/await patterns
-      if (change.type === 'async_transformation') {
-        patterns.push({
-          type: 'async_pattern',
-          from: change.callbackPattern,
-          to: change.asyncPattern,
-          complexity_reduction: change.complexityReduction
-        });
-      }
-
-      // API usage patterns
-      if (change.type === 'api_improvement') {
-        patterns.push({
-          type: 'api_usage',
-          oldPattern: change.oldUsage,
-          newPattern: change.newUsage,
-          benefits: change.benefits
-        });
-      }
-    }
-
-    return patterns;
-  }
-
-  /**
-   * Extract structural patterns
-   */
-  extractStructuralPatterns(structuralChanges) {
-    const patterns = [];
-
-    for (const change of structuralChanges) {
-      patterns.push({
-        type: 'structural',
-        changeType: change.type,
-        pattern: {
-          before: change.beforeStructure,
-          after: change.afterStructure
-        },
-        benefits: {
-          modularity: change.modularityImprovement || 0,
-          maintainability: change.maintainabilityImprovement || 0,
-          testability: change.testabilityImprovement || 0
-        }
-      });
-    }
-
-    return patterns;
-  }
-
-  /**
-   * Extract refactoring patterns
-   */
-  extractRefactoringPatterns(modification) {
-    const patterns = [];
-
-    patterns.push({
-      type: 'refactoring',
-      refactoringType: modification.refactoringType,
-      triggers: modification.triggers || [],
-      steps: modification.steps || [],
-      validation: modification.validation || {},
-      benefits: modification.measuredBenefits || {}
-    });
-
-    return patterns;
-  }
-
-  /**
-   * Extract dependency patterns
-   */
-  extractDependencyPatterns(dependencyChanges) {
-    const patterns = [];
-
-    for (const change of dependencyChanges) {
-      if (change.type === 'consolidation') {
-        patterns.push({
-          type: 'dependency_consolidation',
-          from: change.originalDependencies,
-          to: change.consolidatedDependency,
-          reduction: change.dependencyReduction
-        });
-      }
-
-      if (change.type === 'upgrade') {
-        patterns.push({
-          type: 'dependency_upgrade',
-          dependency: change.dependency,
-          fromVersion: change.fromVersion,
-          toVersion: change.toVersion,
-          migrationSteps: change.migrationSteps
-        });
-      }
-    }
-
-    return patterns;
-  }
-
-  /**
-   * Extract performance patterns
-   */
-  extractPerformancePatterns(performanceImprovements) {
-    const patterns = [];
-
-    for (const improvement of performanceImprovements) {
-      patterns.push({
-        type: 'performance',
-        optimizationType: improvement.type,
-        technique: improvement.technique,
-        metrics: {
-          before: improvement.metricsBefore,
-          after: improvement.metricsAfter,
-          improvement: improvement.percentageImprovement
-        },
-        applicableContexts: improvement.contexts || []
-      });
-    }
-
-    return patterns;
-  }
-
-  /**
-   * Learn from modification
-   */
-  async learnFromModification(record) {
-    for (const pattern of record.patterns) {
-      const patternKey = this.generatePatternKey(pattern);
-      
-      // Check if similar pattern exists
-      const similarPattern = await this.findSimilarPattern(pattern);
-      
-      if (similarPattern) {
-        // Update existing pattern
-        await this.updatePattern(similarPattern, pattern, record);
-      } else {
-        // Create new pattern entry
-        await this.createPattern(patternKey, pattern, record);
-      }
-    }
-
-    // Analyze cross-pattern relationships
-    await this.analyzePatternRelationships(record.patterns);
-    
-    // Update pattern rankings
-    await this.updatePatternRankings();
-  }
-
-  /**
-   * Find similar pattern
-   */
-  async findSimilarPattern(pattern) {
-    for (const [key, existingPattern] of this.patterns) {
-      const similarity = await this.calculatePatternSimilarity(pattern, existingPattern);
-      
-      if (similarity >= this.similarityThreshold) {
-        return { key, pattern: existingPattern, similarity };
-      }
-    }
-    
-    return null;
-  }
-
-  /**
-   * Calculate pattern similarity
-   */
-  async calculatePatternSimilarity(pattern1, pattern2) {
-    // Type must match
-    if (pattern1.type !== pattern2.type) return 0;
-
-    let similarity = 0;
-    let factors = 0;
-
-    // Type-specific similarity calculation
-    switch (pattern1.type) {
-      case 'code_transformation':
-        similarity += this.calculateCodeSimilarity(pattern1, pattern2) * 0.7;
-        similarity += this.calculateContextSimilarity(pattern1.context, pattern2.context) * 0.3;
-        factors = 1;
-        break;
-
-      case 'structural':
-        similarity += this.calculateStructuralSimilarity(pattern1.pattern, pattern2.pattern) * 0.6;
-        similarity += this.calculateBenefitSimilarity(pattern1.benefits, pattern2.benefits) * 0.4;
-        factors = 1;
-        break;
-
-      case 'refactoring':
-        similarity += this.calculateRefactoringSimilarity(pattern1, pattern2);
-        factors = 1;
-        break;
-
-      case 'performance':
-        similarity += this.calculatePerformanceSimilarity(pattern1, pattern2);
-        factors = 1;
-        break;
-
-      default:
-        // Generic similarity based on pattern structure
-        similarity = this.calculateGenericSimilarity(pattern1, pattern2);
-        factors = 1;
-    }
-
-    return factors > 0 ? similarity / factors : 0;
-  }
-
-  /**
-   * Calculate code similarity
-   */
-  calculateCodeSimilarity(pattern1, pattern2) {
-    const from1 = this.tokenizeCode(pattern1.from);
-    const from2 = this.tokenizeCode(pattern2.from);
-    const to1 = this.tokenizeCode(pattern1.to);
-    const to2 = this.tokenizeCode(pattern2.to);
-
-    const fromSimilarity = this.calculateTokenSimilarity(from1, from2);
-    const toSimilarity = this.calculateTokenSimilarity(to1, to2);
-
-    return (fromSimilarity + toSimilarity) / 2;
-  }
-
-  /**
-   * Tokenize code for comparison
-   */
-  tokenizeCode(code) {
-    if (!code) return [];
-    
-    // Simple tokenization - can be enhanced with proper AST parsing
-    return code
-      .replace(/\s+/g, ' ')
-      .replace(/[{}();,]/g, ' $& ')
-      .split(/\s+/)
-      .filter(token => token.length > 0);
-  }
-
-  /**
-   * Calculate token similarity
-   */
-  calculateTokenSimilarity(tokens1, tokens2) {
-    const set1 = new Set(tokens1);
-    const set2 = new Set(tokens2);
-    
-    const intersection = new Set([...set1].filter(x => set2.has(x)));
-    const union = new Set([...set1, ...set2]);
-    
-    return union.size > 0 ? intersection.size / union.size : 0;
-  }
-
-  /**
-   * Update existing pattern
-   */
-  async updatePattern(similarPattern, newPattern, record) {
-    const existingPattern = similarPattern.pattern;
-    
-    // Update occurrence count
-    existingPattern.occurrences = (existingPattern.occurrences || 0) + 1;
-    
-    // Update success rate
-    existingPattern.successCount = (existingPattern.successCount || 0) + 1;
-    existingPattern.successRate = existingPattern.successCount / existingPattern.occurrences;
-    
-    // Merge benefits/improvements
-    if (newPattern.benefits) {
-      existingPattern.aggregatedBenefits = this.aggregateBenefits(
-        existingPattern.aggregatedBenefits || {},
-        newPattern.benefits
-      );
-    }
-    
-    // Add to usage history
-    if (!existingPattern.usageHistory) {
-      existingPattern.usageHistory = [];
-    }
-    existingPattern.usageHistory.push({
-      recordId: record.id,
-      timestamp: record.timestamp,
-      author: record.metadata.author,
-      outcomes: record.outcomes
-    });
-    
-    // Update confidence score
-    existingPattern.confidence = this.calculatePatternConfidence(existingPattern);
-    
-    // Check if pattern should be promoted
-    if (existingPattern.occurrences >= this.learningThreshold && existingPattern.confidence > 0.8) {
-      existingPattern.status = 'learned';
-      existingPattern.learnedAt = new Date().toISOString();
-      
-      console.log(chalk.green(`✅ Pattern promoted to learned: ${similarPattern.key}`));
-      this.emit('pattern_learned', existingPattern);
-    }
-  }
-
-  /**
-   * Create new pattern
-   */
-  async createPattern(key, pattern, record) {
-    const newPattern = {
-      ...pattern,
-      key: key,
-      occurrences: 1,
-      successCount: 1,
-      successRate: 1.0,
-      firstSeen: record.timestamp,
-      lastSeen: record.timestamp,
-      status: 'candidate',
-      confidence: 0.3, // Initial low confidence
-      usageHistory: [{
-        recordId: record.id,
-        timestamp: record.timestamp,
-        author: record.metadata.author,
-        outcomes: record.outcomes
-      }]
-    };
-    
-    this.patterns.set(key, newPattern);
-    
-    console.log(chalk.gray(`New pattern candidate created: ${key}`));
-  }
-
-  /**
-   * Calculate pattern confidence
-   */
-  calculatePatternConfidence(pattern) {
-    let confidence = 0;
-    
-    // Occurrence factor (up to 0.3)
-    const occurrenceFactor = Math.min(pattern.occurrences / 10, 0.3);
-    confidence += occurrenceFactor;
-    
-    // Success rate factor (up to 0.4)
-    confidence += pattern.successRate * 0.4;
-    
-    // Consistency factor (up to 0.2)
-    const consistencyFactor = this.calculateConsistencyFactor(pattern.usageHistory);
-    confidence += consistencyFactor * 0.2;
-    
-    // Recency factor (up to 0.1)
-    const recencyFactor = this.calculateRecencyFactor(pattern.lastSeen);
-    confidence += recencyFactor * 0.1;
-    
-    return Math.min(confidence, 1.0);
-  }
-
-  /**
-   * Get pattern suggestions for modification
-   */
-  async getPatternSuggestions(_context) {
-    const suggestions = [];
-    
-    // Filter applicable patterns
-    const applicablePatterns = Array.from(this.patterns.values()).filter(pattern => {
-      return pattern.status === 'learned' && 
-             this.isPatternApplicable(pattern, context) &&
-             pattern.confidence > 0.7;
-    });
-    
-    // Sort by relevance and confidence
-    applicablePatterns.sort((a, b) => {
-      const relevanceA = this.calculateRelevance(a, context);
-      const relevanceB = this.calculateRelevance(b, context);
-      return (relevanceB * b.confidence) - (relevanceA * a.confidence);
-    });
-    
-    // Create suggestions
-    for (const pattern of applicablePatterns.slice(0, 5)) {
-      suggestions.push({
-        pattern: pattern,
-        relevance: this.calculateRelevance(pattern, context),
-        confidence: pattern.confidence,
-        expectedBenefits: pattern.aggregatedBenefits || {},
-        applicationGuide: await this.generateApplicationGuide(pattern, context),
-        examples: this.getPatternExamples(pattern)
-      });
-    }
-    
-    return suggestions;
-  }
-
-  /**
-   * Check if pattern is applicable
-   */
-  isPatternApplicable(pattern, context) {
-    // Check component type compatibility
-    if (pattern.componentType && context.componentType) {
-      if (pattern.componentType !== context.componentType && pattern.componentType !== 'any') {
-        return false;
-      }
-    }
-    
-    // Check context requirements
-    if (pattern.requiredContext) {
-      for (const requirement of pattern.requiredContext) {
-        if (!this.meetsContextRequirement(_context, requirement)) {
-          return false;
-        }
-      }
-    }
-    
-    // Check applicability conditions
-    if (pattern.applicableContexts) {
-      return pattern.applicableContexts.some(ctx => 
-        this.matchesContext(_context, ctx)
-      );
-    }
-    
-    return true;
-  }
-
-  /**
-   * Generate application guide
-   */
-  async generateApplicationGuide(pattern, context) {
-    const guide = {
-      steps: [],
-      preconditions: [],
-      expectedOutcome: {},
-      risks: [],
-      alternatives: []
-    };
-    
-    // Generate steps based on pattern type
-    switch (pattern.type) {
-      case 'code_transformation':
-        guide.steps = this.generateCodeTransformationSteps(pattern, context);
-        break;
-      case 'refactoring':
-        guide.steps = pattern.steps || [];
-        guide.preconditions = pattern.triggers || [];
-        break;
-      case 'performance':
-        guide.steps = this.generatePerformanceOptimizationSteps(pattern, context);
-        guide.expectedOutcome = pattern.metrics;
-        break;
-    }
-    
-    // Add general guidance
-    guide.confidence = `${Math.round(pattern.confidence * 100)}%`;
-    guide.successRate = `${Math.round(pattern.successRate * 100)}%`;
-    guide.usageCount = pattern.occurrences;
-    
-    return guide;
-  }
-
-  /**
-   * Analyze pattern relationships
-   */
-  async analyzePatternRelationships(patterns) {
-    // Find patterns that commonly occur together
-    const coOccurrences = new Map();
-    
-    for (let i = 0; i < patterns.length; i++) {
-      for (let j = i + 1; j < patterns.length; j++) {
-        const key = this.generateRelationshipKey(patterns[i], patterns[j]);
-        const existing = coOccurrences.get(key) || { count: 0, patterns: [] };
-        existing.count++;
-        existing.patterns = [patterns[i], patterns[j]];
-        coOccurrences.set(key, existing);
-      }
-    }
-    
-    // Store significant relationships
-    for (const [key, relationship] of coOccurrences) {
-      if (relationship.count >= 2) {
-        await this.storePatternRelationship(key, relationship);
-      }
-    }
-  }
-
-  /**
-   * Get pattern analytics
-   */
-  async getPatternAnalytics() {
-    const analytics = {
-      totalPatterns: this.patterns.size,
-      learnedPatterns: 0,
-      candidatePatterns: 0,
-      patternsByType: {},
-      topPatterns: [],
-      recentTrends: [],
-      effectivenessMetrics: {}
-    };
-    
-    // Count patterns by status and type
-    for (const pattern of this.patterns.values()) {
-      if (pattern.status === 'learned') {
-        analytics.learnedPatterns++;
-      } else {
-        analytics.candidatePatterns++;
-      }
-      
-      analytics.patternsByType[pattern.type] = 
-        (analytics.patternsByType[pattern.type] || 0) + 1;
-    }
-    
-    // Get top patterns by usage
-    const sortedPatterns = Array.from(this.patterns.values())
-      .sort((a, b) => b.occurrences - a.occurrences);
-    
-    analytics.topPatterns = sortedPatterns.slice(0, 10).map(p => ({
-      key: p.key,
-      type: p.type,
-      occurrences: p.occurrences,
-      successRate: p.successRate,
-      confidence: p.confidence
-    }));
-    
-    // Calculate effectiveness metrics
-    analytics.effectivenessMetrics = await this.calculateEffectivenessMetrics();
-    
-    // Get recent trends
-    analytics.recentTrends = await this.analyzeRecentTrends();
-    
-    return analytics;
-  }
-
-  /**
-   * Calculate effectiveness metrics
-   */
-  async calculateEffectivenessMetrics() {
-    const metrics = {
-      averageSuccessRate: 0,
-      averageConfidence: 0,
-      patternCoverage: 0,
-      learningRate: 0
-    };
-    
-    const learnedPatterns = Array.from(this.patterns.values())
-      .filter(p => p.status === 'learned');
-    
-    if (learnedPatterns.length > 0) {
-      metrics.averageSuccessRate = learnedPatterns.reduce((sum, p) => 
-        sum + p.successRate, 0) / learnedPatterns.length;
-      
-      metrics.averageConfidence = learnedPatterns.reduce((sum, p) => 
-        sum + p.confidence, 0) / learnedPatterns.length;
-    }
-    
-    // Calculate pattern coverage
-    const modificationTypes = new Set(this.modificationHistory.map(m => m.modificationType));
-    const coveredTypes = new Set(learnedPatterns.map(p => p.type));
-    metrics.patternCoverage = modificationTypes.size > 0 ? 
-      coveredTypes.size / modificationTypes.size : 0;
-    
-    // Calculate learning rate
-    const recentHistory = this.modificationHistory.slice(-20);
-    const recentLearned = recentHistory.filter(m => 
-      m.patterns.some(p => this.patterns.get(this.generatePatternKey(p))?.status === 'learned')
-    );
-    metrics.learningRate = recentHistory.length > 0 ? 
-      recentLearned.length / recentHistory.length : 0;
-    
-    return metrics;
-  }
-
-  /**
-   * Helper methods
-   */
-
-  normalizeCode(code) {
-    if (!code) return '';
-    return code.trim().replace(/\s+/g, ' ');
-  }
-
-  generatePatternKey(pattern) {
-    return `${pattern.type}:${pattern.subtype || 'default'}:${
-      crypto.createHash('md5').update(JSON.stringify(pattern)).digest('hex').substr(0, 8)
-    }`;
-  }
-
-  aggregateBenefits(existing, newBenefits) {
-    const aggregated = { ...existing };
-    
-    for (const [key, value] of Object.entries(newBenefits)) {
-      if (typeof value === 'number') {
-        aggregated[key] = (aggregated[key] || 0) + value;
-        aggregated[`${key}_avg`] = aggregated[key] / ((aggregated[`${key}_count`] || 0) + 1);
-        aggregated[`${key}_count`] = (aggregated[`${key}_count`] || 0) + 1;
-      }
-    }
-    
-    return aggregated;
-  }
-
-  calculateConsistencyFactor(usageHistory) {
-    if (usageHistory.length < 2) return 1.0;
-    
-    // Check time intervals between uses
-    const intervals = [];
-    for (let i = 1; i < usageHistory.length; i++) {
-      const interval = new Date(usageHistory[i].timestamp) - new Date(usageHistory[i-1].timestamp);
-      intervals.push(interval);
-    }
-    
-    // Calculate variance
-    const avgInterval = intervals.reduce((sum, i) => sum + i, 0) / intervals.length;
-    const variance = intervals.reduce((sum, i) => sum + Math.pow(i - avgInterval, 2), 0) / intervals.length;
-    const stdDev = Math.sqrt(variance);
-    
-    // Lower variance = higher consistency
-    return 1 / (1 + stdDev / avgInterval);
-  }
-
-  calculateRecencyFactor(lastSeen) {
-    const daysSinceLastSeen = (Date.now() - new Date(lastSeen).getTime()) / (1000 * 60 * 60 * 24);
-    return Math.max(0, 1 - daysSinceLastSeen / 30); // Decay over 30 days
-  }
-
-  calculateRelevance(pattern, context) {
-    let relevance = 0;
-    
-    // Type match
-    if (pattern.type === context.modificationType) {
-      relevance += 0.3;
-    }
-    
-    // Component type match
-    if (pattern.componentType === context.componentType) {
-      relevance += 0.2;
-    }
-    
-    // Context similarity
-    if (pattern.context && context.currentContext) {
-      relevance += this.calculateContextSimilarity(pattern.context, context.currentContext) * 0.3;
-    }
-    
-    // Goal alignment
-    if (pattern.benefits && context.goals) {
-      relevance += this.calculateGoalAlignment(pattern.benefits, context.goals) * 0.2;
-    }
-    
-    return relevance;
-  }
-
-  getPatternExamples(pattern) {
-    return pattern.usageHistory
-      .slice(-3)
-      .map(usage => ({
-        recordId: usage.recordId,
-        timestamp: usage.timestamp,
-        author: usage.author,
-        outcomes: usage.outcomes
-      }));
-  }
-
-  /**
-   * Save and load methods
-   */
-
-  async saveHistory() {
-    await fs.writeFile(
-      this.historyFile, 
-      JSON.stringify(this.modificationHistory, null, 2)
-    );
-  }
-
-  async loadHistory() {
-    try {
-      const content = await fs.readFile(this.historyFile, 'utf-8');
-      this.modificationHistory = JSON.parse(content);
-    } catch (_error) {
-      // No history file yet
-      this.modificationHistory = [];
-    }
-  }
-
-  async savePatterns() {
-    const patternsArray = Array.from(this.patterns.entries()).map(([key, pattern]) => ({
-      key,
-      ...pattern
-    }));
-    
-    await fs.writeFile(
-      this.patternsFile,
-      JSON.stringify(patternsArray, null, 2)
-    );
-  }
-
-  async loadPatterns() {
-    try {
-      const content = await fs.readFile(this.patternsFile, 'utf-8');
-      const patternsArray = JSON.parse(content);
-      
-      this.patterns.clear();
-      for (const pattern of patternsArray) {
-        this.patterns.set(pattern.key, pattern);
-      }
-    } catch (_error) {
-      // No patterns file yet
-    }
-  }
-
-  /**
-   * Check learning threshold
-   */
-  async checkLearningThreshold(patterns) {
-    let learnedCount = 0;
-    
-    for (const pattern of patterns) {
-      const key = this.generatePatternKey(pattern);
-      const existing = this.patterns.get(key);
-      
-      if (existing && existing.occurrences >= this.learningThreshold) {
-        learnedCount++;
-      }
-    }
-    
-    return learnedCount > 0;
-  }
-
-  calculateContextSimilarity(context1, context2) {
-    // Simple context similarity - can be enhanced
-    if (!context1 || !context2) return 0;
-    
-    const keys1 = Object.keys(context1);
-    const keys2 = Object.keys(context2);
-    const commonKeys = keys1.filter(k => keys2.includes(k));
-    
-    if (commonKeys.length === 0) return 0;
-    
-    let similarity = commonKeys.length / Math.max(keys1.length, keys2.length);
-    
-    // Check value similarity for common keys
-    for (const key of commonKeys) {
-      if (context1[key] === context2[key]) {
-        similarity += 0.1;
-      }
-    }
-    
-    return Math.min(similarity, 1.0);
-  }
-
-  calculateStructuralSimilarity(struct1, struct2) {
-    // Compare structural patterns
-    if (!struct1 || !struct2) return 0;
-    
-    const before1 = JSON.stringify(struct1.before);
-    const before2 = JSON.stringify(struct2.before);
-    const after1 = JSON.stringify(struct1.after);
-    const after2 = JSON.stringify(struct2.after);
-    
-    const beforeSim = before1 === before2 ? 1 : 0.5;
-    const afterSim = after1 === after2 ? 1 : 0.5;
-    
-    return (beforeSim + afterSim) / 2;
-  }
-
-  calculateBenefitSimilarity(benefits1, benefits2) {
-    if (!benefits1 || !benefits2) return 0;
-    
-    const keys1 = Object.keys(benefits1);
-    const keys2 = Object.keys(benefits2);
-    const allKeys = new Set([...keys1, ...keys2]);
-    
-    let similarity = 0;
-    for (const key of allKeys) {
-      if (benefits1[key] && benefits2[key]) {
-        // Both have the benefit
-        similarity += 1;
-      }
-    }
-    
-    return allKeys.size > 0 ? similarity / allKeys.size : 0;
-  }
-
-  calculateRefactoringSimilarity(refactor1, refactor2) {
-    if (refactor1.refactoringType !== refactor2.refactoringType) return 0;
-    
-    let similarity = 0.5; // Base similarity for same type
-    
-    // Compare triggers
-    if (refactor1.triggers && refactor2.triggers) {
-      const commonTriggers = refactor1.triggers.filter(t => 
-        refactor2.triggers.includes(t)
-      );
-      similarity += commonTriggers.length / Math.max(refactor1.triggers.length, refactor2.triggers.length) * 0.3;
-    }
-    
-    // Compare steps
-    if (refactor1.steps && refactor2.steps) {
-      const stepSimilarity = Math.min(refactor1.steps.length, refactor2.steps.length) / 
-                           Math.max(refactor1.steps.length, refactor2.steps.length);
-      similarity += stepSimilarity * 0.2;
-    }
-    
-    return similarity;
-  }
-
-  calculatePerformanceSimilarity(perf1, perf2) {
-    if (perf1.optimizationType !== perf2.optimizationType) return 0;
-    
-    let similarity = 0.4; // Base similarity for same type
-    
-    if (perf1.technique === perf2.technique) {
-      similarity += 0.3;
-    }
-    
-    // Compare applicable contexts
-    if (perf1.applicableContexts && perf2.applicableContexts) {
-      const commonContexts = perf1.applicableContexts.filter(c => 
-        perf2.applicableContexts.includes(c)
-      );
-      similarity += commonContexts.length / Math.max(perf1.applicableContexts.length, perf2.applicableContexts.length) * 0.3;
-    }
-    
-    return similarity;
-  }
-
-  calculateGenericSimilarity(pattern1, pattern2) {
-    // Generic JSON similarity
-    const json1 = JSON.stringify(pattern1);
-    const json2 = JSON.stringify(pattern2);
-    
-    if (json1 === json2) return 1.0;
-    
-    // Calculate Levenshtein distance ratio
-    const distance = this.levenshteinDistance(json1, json2);
-    const maxLength = Math.max(json1.length, json2.length);
-    
-    return 1 - (distance / maxLength);
-  }
-
-  levenshteinDistance(str1, str2) {
-    const matrix = [];
-    
-    for (let i = 0; i <= str2.length; i++) {
-      matrix[i] = [i];
-    }
-    
-    for (let j = 0; j <= str1.length; j++) {
-      matrix[0][j] = j;
-    }
-    
-    for (let i = 1; i <= str2.length; i++) {
-      for (let j = 1; j <= str1.length; j++) {
-        if (str2.charAt(i - 1) === str1.charAt(j - 1)) {
-          matrix[i][j] = matrix[i - 1][j - 1];
-        } else {
-          matrix[i][j] = Math.min(
-            matrix[i - 1][j - 1] + 1,
-            matrix[i][j - 1] + 1,
-            matrix[i - 1][j] + 1
-          );
-        }
-      }
-    }
-    
-    return matrix[str2.length][str1.length];
-  }
-
-  meetsContextRequirement(_context, requirement) {
-    // Check if context meets specific requirement
-    if (requirement.type === 'has_property') {
-      return context[requirement.property] !== undefined;
-    }
-    
-    if (requirement.type === 'property_value') {
-      return context[requirement.property] === requirement.value;
-    }
-    
-    if (requirement.type === 'property_range') {
-      const value = context[requirement.property];
-      return value >= requirement.min && value <= requirement.max;
-    }
-    
-    return true;
-  }
-
-  matchesContext(_context, patternContext) {
-    // Check if contexts match
-    for (const [key, value] of Object.entries(patternContext)) {
-      if (context[key] !== value) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  generateCodeTransformationSteps(pattern, context) {
-    const steps = [];
-    
-    steps.push({
-      step: 1,
-      action: 'Identify target code pattern',
-      description: `Look for code matching: ${pattern.from}`,
-      validation: 'Ensure code structure matches the pattern'
-    });
-    
-    steps.push({
-      step: 2,
-      action: 'Apply transformation',
-      description: `Transform to: ${pattern.to}`,
-      validation: 'Verify transformation preserves functionality'
-    });
-    
-    if (pattern.context) {
-      steps.push({
-        step: 3,
-        action: 'Validate context',
-        description: 'Ensure transformation is appropriate for context',
-        validation: pattern.context
-      });
-    }
-    
-    steps.push({
-      step: 4,
-      action: 'Test changes',
-      description: 'Run tests to ensure no regression',
-      validation: 'All tests pass'
-    });
-    
-    return steps;
-  }
-
-  generatePerformanceOptimizationSteps(pattern, context) {
-    const steps = [];
-    
-    steps.push({
-      step: 1,
-      action: 'Measure baseline performance',
-      description: 'Capture current performance metrics',
-      validation: 'Baseline metrics recorded'
-    });
-    
-    steps.push({
-      step: 2,
-      action: `Apply ${pattern.technique} optimization`,
-      description: pattern.description || 'Apply performance optimization technique',
-      validation: 'Optimization applied correctly'
-    });
-    
-    steps.push({
-      step: 3,
-      action: 'Measure improved performance',
-      description: 'Capture post-optimization metrics',
-      validation: `Expected improvement: ${pattern.metrics.improvement}%`
-    });
-    
-    steps.push({
-      step: 4,
-      action: 'Validate functionality',
-      description: 'Ensure optimization didn\'t break functionality',
-      validation: 'All tests pass'
-    });
-    
-    return steps;
-  }
-
-  generateRelationshipKey(pattern1, pattern2) {
-    const types = [pattern1.type, pattern2.type].sort();
-    return `rel:${types.join(':')}`;
-  }
-
-  async storePatternRelationship(key, relationship) {
-    // Store pattern relationships for future analysis
-    const relationshipsFile = path.join(this.patternsDir, 'relationships.json');
-    
-    let relationships = {};
-    try {
-      const content = await fs.readFile(relationshipsFile, 'utf-8');
-      relationships = JSON.parse(content);
-    } catch (_error) {
-      // No relationships file yet
-    }
-    
-    relationships[key] = relationship;
-    
-    await fs.writeFile(relationshipsFile, JSON.stringify(relationships, null, 2));
-  }
-
-  async analyzeRecentTrends() {
-    const recentModifications = this.modificationHistory.slice(-30);
-    const trends = {
-      emergingPatterns: [],
-      decliningPatterns: [],
-      stablePatterns: []
-    };
-    
-    // Analyze pattern usage over time
-    const patternUsage = new Map();
-    
-    for (const mod of recentModifications) {
-      for (const pattern of mod.patterns) {
-        const key = this.generatePatternKey(pattern);
-        const usage = patternUsage.get(key) || { count: 0, recent: 0 };
-        usage.count++;
-        
-        // Check if in last 10 modifications
-        const modIndex = recentModifications.indexOf(mod);
-        if (modIndex >= recentModifications.length - 10) {
-          usage.recent++;
-        }
-        
-        patternUsage.set(key, usage);
-      }
-    }
-    
-    // Classify patterns
-    for (const [key, usage] of patternUsage) {
-      const pattern = this.patterns.get(key);
-      if (!pattern) continue;
-      
-      const recentRatio = usage.recent / usage.count;
-      
-      if (recentRatio > 0.6) {
-        trends.emergingPatterns.push({
-          key: key,
-          type: pattern.type,
-          trend: 'emerging',
-          usage: usage
-        });
-      } else if (recentRatio < 0.2) {
-        trends.decliningPatterns.push({
-          key: key,
-          type: pattern.type,
-          trend: 'declining',
-          usage: usage
-        });
-      } else {
-        trends.stablePatterns.push({
-          key: key,
-          type: pattern.type,
-          trend: 'stable',
-          usage: usage
-        });
-      }
-    }
-    
-    return trends;
-  }
-
-  calculateGoalAlignment(benefits, goals) {
-    if (!benefits || !goals) return 0;
-    
-    let alignment = 0;
-    let _matchedGoals = 0;
-    
-    for (const goal of goals) {
-      if (goal.type === 'performance' && benefits.performanceImprovement) {
-        alignment += benefits.performanceImprovement > goal.target ? 1 : 0.5;
-        matchedGoals++;
-      }
-      
-      if (goal.type === 'maintainability' && benefits.maintainability) {
-        alignment += benefits.maintainability > goal.target ? 1 : 0.5;
-        matchedGoals++;
-      }
-      
-      if (goal.type === 'testability' && benefits.testability) {
-        alignment += benefits.testability > goal.target ? 1 : 0.5;
-        matchedGoals++;
-      }
-    }
-    
-    return goals.length > 0 ? alignment / goals.length : 0;
-  }
-
-  async updatePatternRankings() {
-    // Update pattern rankings based on multiple factors
-    for (const pattern of this.patterns.values()) {
-      pattern.ranking = this.calculatePatternRanking(pattern);
-    }
-    
-    // Save updated patterns
-    await this.savePatterns();
-  }
-
-  calculatePatternRanking(pattern) {
-    let ranking = 0;
-    
-    // Success rate (40%)
-    ranking += pattern.successRate * 40;
-    
-    // Usage frequency (30%)
-    const usageScore = Math.min(pattern.occurrences / 20, 1);
-    ranking += usageScore * 30;
-    
-    // Confidence (20%)
-    ranking += pattern.confidence * 20;
-    
-    // Recency (10%)
-    const recencyScore = this.calculateRecencyFactor(pattern.lastSeen);
-    ranking += recencyScore * 10;
-    
-    return ranking;
-  }
-}
-
+const fs = require('fs').promises;
+const path = require('path');
+const chalk = require('chalk');
+const EventEmitter = require('events');
+
+/**
+ * Pattern learning system for successful modifications
+ * Learns from successful modifications to suggest improvements and automate common patterns
+ */
+class PatternLearner extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.rootPath = options.rootPath || process.cwd();
+    this.patternsDir = path.join(this.rootPath, '.aios', 'patterns');
+    this.historyFile = path.join(this.patternsDir, 'modification_history.json');
+    this.patternsFile = path.join(this.patternsDir, 'learned_patterns.json');
+    this.patterns = new Map();
+    this.modificationHistory = [];
+    this.learningThreshold = options.learningThreshold || 3; // Minimum occurrences to learn pattern
+    this.similarityThreshold = options.similarityThreshold || 0.8; // 80% similarity
+  }
+
+  /**
+   * Initialize pattern learner
+   */
+  async initialize() {
+    await fs.mkdir(this.patternsDir, { recursive: true });
+    await this.loadHistory();
+    await this.loadPatterns();
+    console.log(chalk.green('✅ Pattern learner initialized'));
+  }
+
+  /**
+   * Record successful modification for learning
+   */
+  async recordSuccessfulModification(modification) {
+    const record = {
+      id: `mod-${Date.now()}-${Math.random().toString(36).substr(2, 6)}`,
+      timestamp: new Date().toISOString(),
+      componentType: modification.componentType,
+      modificationType: modification.modificationType,
+      patterns: await this.extractPatterns(modification),
+      outcomes: {
+        success: true,
+        metrics: modification.metrics || {},
+        improvements: modification.improvements || []
+      },
+      metadata: {
+        author: modification.author || process.env.USER || 'unknown',
+        duration: modification.duration,
+        complexity: modification.complexity
+      }
+    };
+
+    // Add to history
+    this.modificationHistory.push(record);
+    
+    // Learn from this modification
+    await this.learnFromModification(record);
+    
+    // Save updated history
+    await this.saveHistory();
+    
+    // Emit event for real-time learning
+    this.emit('modification_recorded', record);
+    
+    console.log(chalk.green(`✅ Recorded successful modification: ${record.id}`));
+    
+    return {
+      recordId: record.id,
+      patternsExtracted: record.patterns.length,
+      learningTriggered: await this.checkLearningThreshold(record.patterns)
+    };
+  }
+
+  /**
+   * Extract patterns from modification
+   */
+  async extractPatterns(modification) {
+    const patterns = [];
+
+    // Code change patterns
+    if (modification.codeChanges) {
+      patterns.push(...this.extractCodePatterns(modification.codeChanges));
+    }
+
+    // Structural patterns
+    if (modification.structuralChanges) {
+      patterns.push(...this.extractStructuralPatterns(modification.structuralChanges));
+    }
+
+    // Refactoring patterns
+    if (modification.refactoringType) {
+      patterns.push(...this.extractRefactoringPatterns(modification));
+    }
+
+    // Dependency patterns
+    if (modification.dependencyChanges) {
+      patterns.push(...this.extractDependencyPatterns(modification.dependencyChanges));
+    }
+
+    // Performance patterns
+    if (modification.performanceImprovements) {
+      patterns.push(...this.extractPerformancePatterns(modification.performanceImprovements));
+    }
+
+    return patterns;
+  }
+
+  /**
+   * Extract code change patterns
+   */
+  extractCodePatterns(codeChanges) {
+    const patterns = [];
+
+    for (const change of codeChanges) {
+      // Function transformation patterns
+      if (change.type === 'function_transformation') {
+        patterns.push({
+          type: 'code_transformation',
+          subtype: 'function',
+          from: this.normalizeCode(change.before),
+          to: this.normalizeCode(change.after),
+          context: change.context,
+          benefits: change.benefits || []
+        });
+      }
+
+      // Error handling patterns
+      if (change.type === 'error_handling') {
+        patterns.push({
+          type: 'error_handling',
+          subtype: change.handlingType,
+          pattern: change.pattern,
+          improvement: change.improvement
+        });
+      }
+
+      // Async/await patterns
+      if (change.type === 'async_transformation') {
+        patterns.push({
+          type: 'async_pattern',
+          from: change.callbackPattern,
+          to: change.asyncPattern,
+          complexity_reduction: change.complexityReduction
+        });
+      }
+
+      // API usage patterns
+      if (change.type === 'api_improvement') {
+        patterns.push({
+          type: 'api_usage',
+          oldPattern: change.oldUsage,
+          newPattern: change.newUsage,
+          benefits: change.benefits
+        });
+      }
+    }
+
+    return patterns;
+  }
+
+  /**
+   * Extract structural patterns
+   */
+  extractStructuralPatterns(structuralChanges) {
+    const patterns = [];
+
+    for (const change of structuralChanges) {
+      patterns.push({
+        type: 'structural',
+        changeType: change.type,
+        pattern: {
+          before: change.beforeStructure,
+          after: change.afterStructure
+        },
+        benefits: {
+          modularity: change.modularityImprovement || 0,
+          maintainability: change.maintainabilityImprovement || 0,
+          testability: change.testabilityImprovement || 0
+        }
+      });
+    }
+
+    return patterns;
+  }
+
+  /**
+   * Extract refactoring patterns
+   */
+  extractRefactoringPatterns(modification) {
+    const patterns = [];
+
+    patterns.push({
+      type: 'refactoring',
+      refactoringType: modification.refactoringType,
+      triggers: modification.triggers || [],
+      steps: modification.steps || [],
+      validation: modification.validation || {},
+      benefits: modification.measuredBenefits || {}
+    });
+
+    return patterns;
+  }
+
+  /**
+   * Extract dependency patterns
+   */
+  extractDependencyPatterns(dependencyChanges) {
+    const patterns = [];
+
+    for (const change of dependencyChanges) {
+      if (change.type === 'consolidation') {
+        patterns.push({
+          type: 'dependency_consolidation',
+          from: change.originalDependencies,
+          to: change.consolidatedDependency,
+          reduction: change.dependencyReduction
+        });
+      }
+
+      if (change.type === 'upgrade') {
+        patterns.push({
+          type: 'dependency_upgrade',
+          dependency: change.dependency,
+          fromVersion: change.fromVersion,
+          toVersion: change.toVersion,
+          migrationSteps: change.migrationSteps
+        });
+      }
+    }
+
+    return patterns;
+  }
+
+  /**
+   * Extract performance patterns
+   */
+  extractPerformancePatterns(performanceImprovements) {
+    const patterns = [];
+
+    for (const improvement of performanceImprovements) {
+      patterns.push({
+        type: 'performance',
+        optimizationType: improvement.type,
+        technique: improvement.technique,
+        metrics: {
+          before: improvement.metricsBefore,
+          after: improvement.metricsAfter,
+          improvement: improvement.percentageImprovement
+        },
+        applicableContexts: improvement.contexts || []
+      });
+    }
+
+    return patterns;
+  }
+
+  /**
+   * Learn from modification
+   */
+  async learnFromModification(record) {
+    for (const pattern of record.patterns) {
+      const patternKey = this.generatePatternKey(pattern);
+      
+      // Check if similar pattern exists
+      const similarPattern = await this.findSimilarPattern(pattern);
+      
+      if (similarPattern) {
+        // Update existing pattern
+        await this.updatePattern(similarPattern, pattern, record);
+      } else {
+        // Create new pattern entry
+        await this.createPattern(patternKey, pattern, record);
+      }
+    }
+
+    // Analyze cross-pattern relationships
+    await this.analyzePatternRelationships(record.patterns);
+    
+    // Update pattern rankings
+    await this.updatePatternRankings();
+  }
+
+  /**
+   * Find similar pattern
+   */
+  async findSimilarPattern(pattern) {
+    for (const [key, existingPattern] of this.patterns) {
+      const similarity = await this.calculatePatternSimilarity(pattern, existingPattern);
+      
+      if (similarity >= this.similarityThreshold) {
+        return { key, pattern: existingPattern, similarity };
+      }
+    }
+    
+    return null;
+  }
+
+  /**
+   * Calculate pattern similarity
+   */
+  async calculatePatternSimilarity(pattern1, pattern2) {
+    // Type must match
+    if (pattern1.type !== pattern2.type) return 0;
+
+    let similarity = 0;
+    let factors = 0;
+
+    // Type-specific similarity calculation
+    switch (pattern1.type) {
+      case 'code_transformation':
+        similarity += this.calculateCodeSimilarity(pattern1, pattern2) * 0.7;
+        similarity += this.calculateContextSimilarity(pattern1.context, pattern2.context) * 0.3;
+        factors = 1;
+        break;
+
+      case 'structural':
+        similarity += this.calculateStructuralSimilarity(pattern1.pattern, pattern2.pattern) * 0.6;
+        similarity += this.calculateBenefitSimilarity(pattern1.benefits, pattern2.benefits) * 0.4;
+        factors = 1;
+        break;
+
+      case 'refactoring':
+        similarity += this.calculateRefactoringSimilarity(pattern1, pattern2);
+        factors = 1;
+        break;
+
+      case 'performance':
+        similarity += this.calculatePerformanceSimilarity(pattern1, pattern2);
+        factors = 1;
+        break;
+
+      default:
+        // Generic similarity based on pattern structure
+        similarity = this.calculateGenericSimilarity(pattern1, pattern2);
+        factors = 1;
+    }
+
+    return factors > 0 ? similarity / factors : 0;
+  }
+
+  /**
+   * Calculate code similarity
+   */
+  calculateCodeSimilarity(pattern1, pattern2) {
+    const from1 = this.tokenizeCode(pattern1.from);
+    const from2 = this.tokenizeCode(pattern2.from);
+    const to1 = this.tokenizeCode(pattern1.to);
+    const to2 = this.tokenizeCode(pattern2.to);
+
+    const fromSimilarity = this.calculateTokenSimilarity(from1, from2);
+    const toSimilarity = this.calculateTokenSimilarity(to1, to2);
+
+    return (fromSimilarity + toSimilarity) / 2;
+  }
+
+  /**
+   * Tokenize code for comparison
+   */
+  tokenizeCode(code) {
+    if (!code) return [];
+    
+    // Simple tokenization - can be enhanced with proper AST parsing
+    return code
+      .replace(/\s+/g, ' ')
+      .replace(/[{}();,]/g, ' $& ')
+      .split(/\s+/)
+      .filter(token => token.length > 0);
+  }
+
+  /**
+   * Calculate token similarity
+   */
+  calculateTokenSimilarity(tokens1, tokens2) {
+    const set1 = new Set(tokens1);
+    const set2 = new Set(tokens2);
+    
+    const intersection = new Set([...set1].filter(x => set2.has(x)));
+    const union = new Set([...set1, ...set2]);
+    
+    return union.size > 0 ? intersection.size / union.size : 0;
+  }
+
+  /**
+   * Update existing pattern
+   */
+  async updatePattern(similarPattern, newPattern, record) {
+    const existingPattern = similarPattern.pattern;
+    
+    // Update occurrence count
+    existingPattern.occurrences = (existingPattern.occurrences || 0) + 1;
+    
+    // Update success rate
+    existingPattern.successCount = (existingPattern.successCount || 0) + 1;
+    existingPattern.successRate = existingPattern.successCount / existingPattern.occurrences;
+    
+    // Merge benefits/improvements
+    if (newPattern.benefits) {
+      existingPattern.aggregatedBenefits = this.aggregateBenefits(
+        existingPattern.aggregatedBenefits || {},
+        newPattern.benefits
+      );
+    }
+    
+    // Add to usage history
+    if (!existingPattern.usageHistory) {
+      existingPattern.usageHistory = [];
+    }
+    existingPattern.usageHistory.push({
+      recordId: record.id,
+      timestamp: record.timestamp,
+      author: record.metadata.author,
+      outcomes: record.outcomes
+    });
+    
+    // Update confidence score
+    existingPattern.confidence = this.calculatePatternConfidence(existingPattern);
+    
+    // Check if pattern should be promoted
+    if (existingPattern.occurrences >= this.learningThreshold && existingPattern.confidence > 0.8) {
+      existingPattern.status = 'learned';
+      existingPattern.learnedAt = new Date().toISOString();
+      
+      console.log(chalk.green(`✅ Pattern promoted to learned: ${similarPattern.key}`));
+      this.emit('pattern_learned', existingPattern);
+    }
+  }
+
+  /**
+   * Create new pattern
+   */
+  async createPattern(key, pattern, record) {
+    const newPattern = {
+      ...pattern,
+      key: key,
+      occurrences: 1,
+      successCount: 1,
+      successRate: 1.0,
+      firstSeen: record.timestamp,
+      lastSeen: record.timestamp,
+      status: 'candidate',
+      confidence: 0.3, // Initial low confidence
+      usageHistory: [{
+        recordId: record.id,
+        timestamp: record.timestamp,
+        author: record.metadata.author,
+        outcomes: record.outcomes
+      }]
+    };
+    
+    this.patterns.set(key, newPattern);
+    
+    console.log(chalk.gray(`New pattern candidate created: ${key}`));
+  }
+
+  /**
+   * Calculate pattern confidence
+   */
+  calculatePatternConfidence(pattern) {
+    let confidence = 0;
+    
+    // Occurrence factor (up to 0.3)
+    const occurrenceFactor = Math.min(pattern.occurrences / 10, 0.3);
+    confidence += occurrenceFactor;
+    
+    // Success rate factor (up to 0.4)
+    confidence += pattern.successRate * 0.4;
+    
+    // Consistency factor (up to 0.2)
+    const consistencyFactor = this.calculateConsistencyFactor(pattern.usageHistory);
+    confidence += consistencyFactor * 0.2;
+    
+    // Recency factor (up to 0.1)
+    const recencyFactor = this.calculateRecencyFactor(pattern.lastSeen);
+    confidence += recencyFactor * 0.1;
+    
+    return Math.min(confidence, 1.0);
+  }
+
+  /**
+   * Get pattern suggestions for modification
+   */
+  async getPatternSuggestions(_context) {
+    const suggestions = [];
+    
+    // Filter applicable patterns
+    const applicablePatterns = Array.from(this.patterns.values()).filter(pattern => {
+      return pattern.status === 'learned' && 
+             this.isPatternApplicable(pattern, context) &&
+             pattern.confidence > 0.7;
+    });
+    
+    // Sort by relevance and confidence
+    applicablePatterns.sort((a, b) => {
+      const relevanceA = this.calculateRelevance(a, context);
+      const relevanceB = this.calculateRelevance(b, context);
+      return (relevanceB * b.confidence) - (relevanceA * a.confidence);
+    });
+    
+    // Create suggestions
+    for (const pattern of applicablePatterns.slice(0, 5)) {
+      suggestions.push({
+        pattern: pattern,
+        relevance: this.calculateRelevance(pattern, context),
+        confidence: pattern.confidence,
+        expectedBenefits: pattern.aggregatedBenefits || {},
+        applicationGuide: await this.generateApplicationGuide(pattern, context),
+        examples: this.getPatternExamples(pattern)
+      });
+    }
+    
+    return suggestions;
+  }
+
+  /**
+   * Check if pattern is applicable
+   */
+  isPatternApplicable(pattern, context) {
+    // Check component type compatibility
+    if (pattern.componentType && context.componentType) {
+      if (pattern.componentType !== context.componentType && pattern.componentType !== 'any') {
+        return false;
+      }
+    }
+    
+    // Check context requirements
+    if (pattern.requiredContext) {
+      for (const requirement of pattern.requiredContext) {
+        if (!this.meetsContextRequirement(_context, requirement)) {
+          return false;
+        }
+      }
+    }
+    
+    // Check applicability conditions
+    if (pattern.applicableContexts) {
+      return pattern.applicableContexts.some(ctx => 
+        this.matchesContext(_context, ctx)
+      );
+    }
+    
+    return true;
+  }
+
+  /**
+   * Generate application guide
+   */
+  async generateApplicationGuide(pattern, context) {
+    const guide = {
+      steps: [],
+      preconditions: [],
+      expectedOutcome: {},
+      risks: [],
+      alternatives: []
+    };
+    
+    // Generate steps based on pattern type
+    switch (pattern.type) {
+      case 'code_transformation':
+        guide.steps = this.generateCodeTransformationSteps(pattern, context);
+        break;
+      case 'refactoring':
+        guide.steps = pattern.steps || [];
+        guide.preconditions = pattern.triggers || [];
+        break;
+      case 'performance':
+        guide.steps = this.generatePerformanceOptimizationSteps(pattern, context);
+        guide.expectedOutcome = pattern.metrics;
+        break;
+    }
+    
+    // Add general guidance
+    guide.confidence = `${Math.round(pattern.confidence * 100)}%`;
+    guide.successRate = `${Math.round(pattern.successRate * 100)}%`;
+    guide.usageCount = pattern.occurrences;
+    
+    return guide;
+  }
+
+  /**
+   * Analyze pattern relationships
+   */
+  async analyzePatternRelationships(patterns) {
+    // Find patterns that commonly occur together
+    const coOccurrences = new Map();
+    
+    for (let i = 0; i < patterns.length; i++) {
+      for (let j = i + 1; j < patterns.length; j++) {
+        const key = this.generateRelationshipKey(patterns[i], patterns[j]);
+        const existing = coOccurrences.get(key) || { count: 0, patterns: [] };
+        existing.count++;
+        existing.patterns = [patterns[i], patterns[j]];
+        coOccurrences.set(key, existing);
+      }
+    }
+    
+    // Store significant relationships
+    for (const [key, relationship] of coOccurrences) {
+      if (relationship.count >= 2) {
+        await this.storePatternRelationship(key, relationship);
+      }
+    }
+  }
+
+  /**
+   * Get pattern analytics
+   */
+  async getPatternAnalytics() {
+    const analytics = {
+      totalPatterns: this.patterns.size,
+      learnedPatterns: 0,
+      candidatePatterns: 0,
+      patternsByType: {},
+      topPatterns: [],
+      recentTrends: [],
+      effectivenessMetrics: {}
+    };
+    
+    // Count patterns by status and type
+    for (const pattern of this.patterns.values()) {
+      if (pattern.status === 'learned') {
+        analytics.learnedPatterns++;
+      } else {
+        analytics.candidatePatterns++;
+      }
+      
+      analytics.patternsByType[pattern.type] = 
+        (analytics.patternsByType[pattern.type] || 0) + 1;
+    }
+    
+    // Get top patterns by usage
+    const sortedPatterns = Array.from(this.patterns.values())
+      .sort((a, b) => b.occurrences - a.occurrences);
+    
+    analytics.topPatterns = sortedPatterns.slice(0, 10).map(p => ({
+      key: p.key,
+      type: p.type,
+      occurrences: p.occurrences,
+      successRate: p.successRate,
+      confidence: p.confidence
+    }));
+    
+    // Calculate effectiveness metrics
+    analytics.effectivenessMetrics = await this.calculateEffectivenessMetrics();
+    
+    // Get recent trends
+    analytics.recentTrends = await this.analyzeRecentTrends();
+    
+    return analytics;
+  }
+
+  /**
+   * Calculate effectiveness metrics
+   */
+  async calculateEffectivenessMetrics() {
+    const metrics = {
+      averageSuccessRate: 0,
+      averageConfidence: 0,
+      patternCoverage: 0,
+      learningRate: 0
+    };
+    
+    const learnedPatterns = Array.from(this.patterns.values())
+      .filter(p => p.status === 'learned');
+    
+    if (learnedPatterns.length > 0) {
+      metrics.averageSuccessRate = learnedPatterns.reduce((sum, p) => 
+        sum + p.successRate, 0) / learnedPatterns.length;
+      
+      metrics.averageConfidence = learnedPatterns.reduce((sum, p) => 
+        sum + p.confidence, 0) / learnedPatterns.length;
+    }
+    
+    // Calculate pattern coverage
+    const modificationTypes = new Set(this.modificationHistory.map(m => m.modificationType));
+    const coveredTypes = new Set(learnedPatterns.map(p => p.type));
+    metrics.patternCoverage = modificationTypes.size > 0 ? 
+      coveredTypes.size / modificationTypes.size : 0;
+    
+    // Calculate learning rate
+    const recentHistory = this.modificationHistory.slice(-20);
+    const recentLearned = recentHistory.filter(m => 
+      m.patterns.some(p => this.patterns.get(this.generatePatternKey(p))?.status === 'learned')
+    );
+    metrics.learningRate = recentHistory.length > 0 ? 
+      recentLearned.length / recentHistory.length : 0;
+    
+    return metrics;
+  }
+
+  /**
+   * Helper methods
+   */
+
+  normalizeCode(code) {
+    if (!code) return '';
+    return code.trim().replace(/\s+/g, ' ');
+  }
+
+  generatePatternKey(pattern) {
+    return `${pattern.type}:${pattern.subtype || 'default'}:${
+      crypto.createHash('md5').update(JSON.stringify(pattern)).digest('hex').substr(0, 8)
+    }`;
+  }
+
+  aggregateBenefits(existing, newBenefits) {
+    const aggregated = { ...existing };
+    
+    for (const [key, value] of Object.entries(newBenefits)) {
+      if (typeof value === 'number') {
+        aggregated[key] = (aggregated[key] || 0) + value;
+        aggregated[`${key}_avg`] = aggregated[key] / ((aggregated[`${key}_count`] || 0) + 1);
+        aggregated[`${key}_count`] = (aggregated[`${key}_count`] || 0) + 1;
+      }
+    }
+    
+    return aggregated;
+  }
+
+  calculateConsistencyFactor(usageHistory) {
+    if (usageHistory.length < 2) return 1.0;
+    
+    // Check time intervals between uses
+    const intervals = [];
+    for (let i = 1; i < usageHistory.length; i++) {
+      const interval = new Date(usageHistory[i].timestamp) - new Date(usageHistory[i-1].timestamp);
+      intervals.push(interval);
+    }
+    
+    // Calculate variance
+    const avgInterval = intervals.reduce((sum, i) => sum + i, 0) / intervals.length;
+    const variance = intervals.reduce((sum, i) => sum + Math.pow(i - avgInterval, 2), 0) / intervals.length;
+    const stdDev = Math.sqrt(variance);
+    
+    // Lower variance = higher consistency
+    return 1 / (1 + stdDev / avgInterval);
+  }
+
+  calculateRecencyFactor(lastSeen) {
+    const daysSinceLastSeen = (Date.now() - new Date(lastSeen).getTime()) / (1000 * 60 * 60 * 24);
+    return Math.max(0, 1 - daysSinceLastSeen / 30); // Decay over 30 days
+  }
+
+  calculateRelevance(pattern, context) {
+    let relevance = 0;
+    
+    // Type match
+    if (pattern.type === context.modificationType) {
+      relevance += 0.3;
+    }
+    
+    // Component type match
+    if (pattern.componentType === context.componentType) {
+      relevance += 0.2;
+    }
+    
+    // Context similarity
+    if (pattern.context && context.currentContext) {
+      relevance += this.calculateContextSimilarity(pattern.context, context.currentContext) * 0.3;
+    }
+    
+    // Goal alignment
+    if (pattern.benefits && context.goals) {
+      relevance += this.calculateGoalAlignment(pattern.benefits, context.goals) * 0.2;
+    }
+    
+    return relevance;
+  }
+
+  getPatternExamples(pattern) {
+    return pattern.usageHistory
+      .slice(-3)
+      .map(usage => ({
+        recordId: usage.recordId,
+        timestamp: usage.timestamp,
+        author: usage.author,
+        outcomes: usage.outcomes
+      }));
+  }
+
+  /**
+   * Save and load methods
+   */
+
+  async saveHistory() {
+    await fs.writeFile(
+      this.historyFile, 
+      JSON.stringify(this.modificationHistory, null, 2)
+    );
+  }
+
+  async loadHistory() {
+    try {
+      const content = await fs.readFile(this.historyFile, 'utf-8');
+      this.modificationHistory = JSON.parse(content);
+    } catch (_error) {
+      // No history file yet
+      this.modificationHistory = [];
+    }
+  }
+
+  async savePatterns() {
+    const patternsArray = Array.from(this.patterns.entries()).map(([key, pattern]) => ({
+      key,
+      ...pattern
+    }));
+    
+    await fs.writeFile(
+      this.patternsFile,
+      JSON.stringify(patternsArray, null, 2)
+    );
+  }
+
+  async loadPatterns() {
+    try {
+      const content = await fs.readFile(this.patternsFile, 'utf-8');
+      const patternsArray = JSON.parse(content);
+      
+      this.patterns.clear();
+      for (const pattern of patternsArray) {
+        this.patterns.set(pattern.key, pattern);
+      }
+    } catch (_error) {
+      // No patterns file yet
+    }
+  }
+
+  /**
+   * Check learning threshold
+   */
+  async checkLearningThreshold(patterns) {
+    let learnedCount = 0;
+    
+    for (const pattern of patterns) {
+      const key = this.generatePatternKey(pattern);
+      const existing = this.patterns.get(key);
+      
+      if (existing && existing.occurrences >= this.learningThreshold) {
+        learnedCount++;
+      }
+    }
+    
+    return learnedCount > 0;
+  }
+
+  calculateContextSimilarity(context1, context2) {
+    // Simple context similarity - can be enhanced
+    if (!context1 || !context2) return 0;
+    
+    const keys1 = Object.keys(context1);
+    const keys2 = Object.keys(context2);
+    const commonKeys = keys1.filter(k => keys2.includes(k));
+    
+    if (commonKeys.length === 0) return 0;
+    
+    let similarity = commonKeys.length / Math.max(keys1.length, keys2.length);
+    
+    // Check value similarity for common keys
+    for (const key of commonKeys) {
+      if (context1[key] === context2[key]) {
+        similarity += 0.1;
+      }
+    }
+    
+    return Math.min(similarity, 1.0);
+  }
+
+  calculateStructuralSimilarity(struct1, struct2) {
+    // Compare structural patterns
+    if (!struct1 || !struct2) return 0;
+    
+    const before1 = JSON.stringify(struct1.before);
+    const before2 = JSON.stringify(struct2.before);
+    const after1 = JSON.stringify(struct1.after);
+    const after2 = JSON.stringify(struct2.after);
+    
+    const beforeSim = before1 === before2 ? 1 : 0.5;
+    const afterSim = after1 === after2 ? 1 : 0.5;
+    
+    return (beforeSim + afterSim) / 2;
+  }
+
+  calculateBenefitSimilarity(benefits1, benefits2) {
+    if (!benefits1 || !benefits2) return 0;
+    
+    const keys1 = Object.keys(benefits1);
+    const keys2 = Object.keys(benefits2);
+    const allKeys = new Set([...keys1, ...keys2]);
+    
+    let similarity = 0;
+    for (const key of allKeys) {
+      if (benefits1[key] && benefits2[key]) {
+        // Both have the benefit
+        similarity += 1;
+      }
+    }
+    
+    return allKeys.size > 0 ? similarity / allKeys.size : 0;
+  }
+
+  calculateRefactoringSimilarity(refactor1, refactor2) {
+    if (refactor1.refactoringType !== refactor2.refactoringType) return 0;
+    
+    let similarity = 0.5; // Base similarity for same type
+    
+    // Compare triggers
+    if (refactor1.triggers && refactor2.triggers) {
+      const commonTriggers = refactor1.triggers.filter(t => 
+        refactor2.triggers.includes(t)
+      );
+      similarity += commonTriggers.length / Math.max(refactor1.triggers.length, refactor2.triggers.length) * 0.3;
+    }
+    
+    // Compare steps
+    if (refactor1.steps && refactor2.steps) {
+      const stepSimilarity = Math.min(refactor1.steps.length, refactor2.steps.length) / 
+                           Math.max(refactor1.steps.length, refactor2.steps.length);
+      similarity += stepSimilarity * 0.2;
+    }
+    
+    return similarity;
+  }
+
+  calculatePerformanceSimilarity(perf1, perf2) {
+    if (perf1.optimizationType !== perf2.optimizationType) return 0;
+    
+    let similarity = 0.4; // Base similarity for same type
+    
+    if (perf1.technique === perf2.technique) {
+      similarity += 0.3;
+    }
+    
+    // Compare applicable contexts
+    if (perf1.applicableContexts && perf2.applicableContexts) {
+      const commonContexts = perf1.applicableContexts.filter(c => 
+        perf2.applicableContexts.includes(c)
+      );
+      similarity += commonContexts.length / Math.max(perf1.applicableContexts.length, perf2.applicableContexts.length) * 0.3;
+    }
+    
+    return similarity;
+  }
+
+  calculateGenericSimilarity(pattern1, pattern2) {
+    // Generic JSON similarity
+    const json1 = JSON.stringify(pattern1);
+    const json2 = JSON.stringify(pattern2);
+    
+    if (json1 === json2) return 1.0;
+    
+    // Calculate Levenshtein distance ratio
+    const distance = this.levenshteinDistance(json1, json2);
+    const maxLength = Math.max(json1.length, json2.length);
+    
+    return 1 - (distance / maxLength);
+  }
+
+  levenshteinDistance(str1, str2) {
+    const matrix = [];
+    
+    for (let i = 0; i <= str2.length; i++) {
+      matrix[i] = [i];
+    }
+    
+    for (let j = 0; j <= str1.length; j++) {
+      matrix[0][j] = j;
+    }
+    
+    for (let i = 1; i <= str2.length; i++) {
+      for (let j = 1; j <= str1.length; j++) {
+        if (str2.charAt(i - 1) === str1.charAt(j - 1)) {
+          matrix[i][j] = matrix[i - 1][j - 1];
+        } else {
+          matrix[i][j] = Math.min(
+            matrix[i - 1][j - 1] + 1,
+            matrix[i][j - 1] + 1,
+            matrix[i - 1][j] + 1
+          );
+        }
+      }
+    }
+    
+    return matrix[str2.length][str1.length];
+  }
+
+  meetsContextRequirement(_context, requirement) {
+    // Check if context meets specific requirement
+    if (requirement.type === 'has_property') {
+      return context[requirement.property] !== undefined;
+    }
+    
+    if (requirement.type === 'property_value') {
+      return context[requirement.property] === requirement.value;
+    }
+    
+    if (requirement.type === 'property_range') {
+      const value = context[requirement.property];
+      return value >= requirement.min && value <= requirement.max;
+    }
+    
+    return true;
+  }
+
+  matchesContext(_context, patternContext) {
+    // Check if contexts match
+    for (const [key, value] of Object.entries(patternContext)) {
+      if (context[key] !== value) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  generateCodeTransformationSteps(pattern, context) {
+    const steps = [];
+    
+    steps.push({
+      step: 1,
+      action: 'Identify target code pattern',
+      description: `Look for code matching: ${pattern.from}`,
+      validation: 'Ensure code structure matches the pattern'
+    });
+    
+    steps.push({
+      step: 2,
+      action: 'Apply transformation',
+      description: `Transform to: ${pattern.to}`,
+      validation: 'Verify transformation preserves functionality'
+    });
+    
+    if (pattern.context) {
+      steps.push({
+        step: 3,
+        action: 'Validate context',
+        description: 'Ensure transformation is appropriate for context',
+        validation: pattern.context
+      });
+    }
+    
+    steps.push({
+      step: 4,
+      action: 'Test changes',
+      description: 'Run tests to ensure no regression',
+      validation: 'All tests pass'
+    });
+    
+    return steps;
+  }
+
+  generatePerformanceOptimizationSteps(pattern, context) {
+    const steps = [];
+    
+    steps.push({
+      step: 1,
+      action: 'Measure baseline performance',
+      description: 'Capture current performance metrics',
+      validation: 'Baseline metrics recorded'
+    });
+    
+    steps.push({
+      step: 2,
+      action: `Apply ${pattern.technique} optimization`,
+      description: pattern.description || 'Apply performance optimization technique',
+      validation: 'Optimization applied correctly'
+    });
+    
+    steps.push({
+      step: 3,
+      action: 'Measure improved performance',
+      description: 'Capture post-optimization metrics',
+      validation: `Expected improvement: ${pattern.metrics.improvement}%`
+    });
+    
+    steps.push({
+      step: 4,
+      action: 'Validate functionality',
+      description: 'Ensure optimization didn\'t break functionality',
+      validation: 'All tests pass'
+    });
+    
+    return steps;
+  }
+
+  generateRelationshipKey(pattern1, pattern2) {
+    const types = [pattern1.type, pattern2.type].sort();
+    return `rel:${types.join(':')}`;
+  }
+
+  async storePatternRelationship(key, relationship) {
+    // Store pattern relationships for future analysis
+    const relationshipsFile = path.join(this.patternsDir, 'relationships.json');
+    
+    let relationships = {};
+    try {
+      const content = await fs.readFile(relationshipsFile, 'utf-8');
+      relationships = JSON.parse(content);
+    } catch (_error) {
+      // No relationships file yet
+    }
+    
+    relationships[key] = relationship;
+    
+    await fs.writeFile(relationshipsFile, JSON.stringify(relationships, null, 2));
+  }
+
+  async analyzeRecentTrends() {
+    const recentModifications = this.modificationHistory.slice(-30);
+    const trends = {
+      emergingPatterns: [],
+      decliningPatterns: [],
+      stablePatterns: []
+    };
+    
+    // Analyze pattern usage over time
+    const patternUsage = new Map();
+    
+    for (const mod of recentModifications) {
+      for (const pattern of mod.patterns) {
+        const key = this.generatePatternKey(pattern);
+        const usage = patternUsage.get(key) || { count: 0, recent: 0 };
+        usage.count++;
+        
+        // Check if in last 10 modifications
+        const modIndex = recentModifications.indexOf(mod);
+        if (modIndex >= recentModifications.length - 10) {
+          usage.recent++;
+        }
+        
+        patternUsage.set(key, usage);
+      }
+    }
+    
+    // Classify patterns
+    for (const [key, usage] of patternUsage) {
+      const pattern = this.patterns.get(key);
+      if (!pattern) continue;
+      
+      const recentRatio = usage.recent / usage.count;
+      
+      if (recentRatio > 0.6) {
+        trends.emergingPatterns.push({
+          key: key,
+          type: pattern.type,
+          trend: 'emerging',
+          usage: usage
+        });
+      } else if (recentRatio < 0.2) {
+        trends.decliningPatterns.push({
+          key: key,
+          type: pattern.type,
+          trend: 'declining',
+          usage: usage
+        });
+      } else {
+        trends.stablePatterns.push({
+          key: key,
+          type: pattern.type,
+          trend: 'stable',
+          usage: usage
+        });
+      }
+    }
+    
+    return trends;
+  }
+
+  calculateGoalAlignment(benefits, goals) {
+    if (!benefits || !goals) return 0;
+    
+    let alignment = 0;
+    let _matchedGoals = 0;
+    
+    for (const goal of goals) {
+      if (goal.type === 'performance' && benefits.performanceImprovement) {
+        alignment += benefits.performanceImprovement > goal.target ? 1 : 0.5;
+        matchedGoals++;
+      }
+      
+      if (goal.type === 'maintainability' && benefits.maintainability) {
+        alignment += benefits.maintainability > goal.target ? 1 : 0.5;
+        matchedGoals++;
+      }
+      
+      if (goal.type === 'testability' && benefits.testability) {
+        alignment += benefits.testability > goal.target ? 1 : 0.5;
+        matchedGoals++;
+      }
+    }
+    
+    return goals.length > 0 ? alignment / goals.length : 0;
+  }
+
+  async updatePatternRankings() {
+    // Update pattern rankings based on multiple factors
+    for (const pattern of this.patterns.values()) {
+      pattern.ranking = this.calculatePatternRanking(pattern);
+    }
+    
+    // Save updated patterns
+    await this.savePatterns();
+  }
+
+  calculatePatternRanking(pattern) {
+    let ranking = 0;
+    
+    // Success rate (40%)
+    ranking += pattern.successRate * 40;
+    
+    // Usage frequency (30%)
+    const usageScore = Math.min(pattern.occurrences / 20, 1);
+    ranking += usageScore * 30;
+    
+    // Confidence (20%)
+    ranking += pattern.confidence * 20;
+    
+    // Recency (10%)
+    const recencyScore = this.calculateRecencyFactor(pattern.lastSeen);
+    ranking += recencyScore * 10;
+    
+    return ranking;
+  }
+}
+
 module.exports = PatternLearner;