grimoire-framework 1.0.0

package/.grimoire/development/tasks/learn-patterns.md

@@ -0,0 +1,902 @@
+---
+
+# learn-patterns
+
+## Execution Modes
+
+**Choose your execution mode:**
+
+### 1. YOLO Mode - Fast, Autonomous (0-1 prompts)
+- Autonomous decision making with logging
+- Minimal user interaction
+- **Best for:** Simple, deterministic tasks
+
+### 2. Interactive Mode - Balanced, Educational (5-10 prompts) **[DEFAULT]**
+- Explicit decision checkpoints
+- Educational explanations
+- **Best for:** Learning, complex decisions
+
+### 3. Pre-Flight Planning - Comprehensive Upfront Planning
+- Task analysis phase (identify all ambiguities)
+- Zero ambiguity execution
+- **Best for:** Ambiguous requirements, critical work
+
+**Parameter:** `mode` (optional, default: `interactive`)
+
+---
+
+## Task Definition (grimoire Task Format V1.0)
+
+```yaml
+task: learnPatterns()
+responsável: Uma (Empathizer)
+responsavel_type: Agente
+atomic_layer: Molecule
+
+**Entrada:**
+- campo: task
+  tipo: string
+  origem: User Input
+  obrigatório: true
+  validação: Must be registered task
+
+- campo: parameters
+  tipo: object
+  origem: User Input
+  obrigatório: false
+  validação: Valid task parameters
+
+- campo: mode
+  tipo: string
+  origem: User Input
+  obrigatório: false
+  validação: yolo|interactive|pre-flight
+
+**Saída:**
+- campo: execution_result
+  tipo: object
+  destino: Memory
+  persistido: false
+
+- campo: logs
+  tipo: array
+  destino: File (.ai/logs/*)
+  persistido: true
+
+- campo: state
+  tipo: object
+  destino: State management
+  persistido: true
+```
+
+---
+
+## Pre-Conditions
+
+**Purpose:** Validate prerequisites BEFORE task execution (blocking)
+
+**Checklist:**
+
+```yaml
+pre-conditions:
+  - [ ] Task is registered; required parameters provided; dependencies met
+    tipo: pre-condition
+    blocker: true
+    validação: |
+      Check task is registered; required parameters provided; dependencies met
+    error_message: "Pre-condition failed: Task is registered; required parameters provided; dependencies met"
+```
+
+---
+
+## Post-Conditions
+
+**Purpose:** Validate execution success AFTER task completes
+
+**Checklist:**
+
+```yaml
+post-conditions:
+  - [ ] Task completed; exit code 0; expected outputs created
+    tipo: post-condition
+    blocker: true
+    validação: |
+      Verify task completed; exit code 0; expected outputs created
+    error_message: "Post-condition failed: Task completed; exit code 0; expected outputs created"
+```
+
+---
+
+## Acceptance Criteria
+
+**Purpose:** Definitive pass/fail criteria for task completion
+
+**Checklist:**
+
+```yaml
+acceptance-criteria:
+  - [ ] Task completed as expected; side effects documented
+    tipo: acceptance-criterion
+    blocker: true
+    validação: |
+      Assert task completed as expected; side effects documented
+    error_message: "Acceptance criterion not met: Task completed as expected; side effects documented"
+```
+
+---
+
+## Tools
+
+**External/shared resources used by this task:**
+
+- **Tool:** task-runner
+  - **Purpose:** Task execution and orchestration
+  - **Source:** .grimoire/core/task-runner.js
+
+- **Tool:** logger
+  - **Purpose:** Execution logging and error tracking
+  - **Source:** .grimoire/utils/logger.js
+
+---
+
+## Scripts
+
+**Agent-specific code for this task:**
+
+- **Script:** execute-task.js
+  - **Purpose:** Generic task execution wrapper
+  - **Language:** JavaScript
+  - **Location:** .grimoire/scripts/execute-task.js
+
+---
+
+## Error Handling
+
+**Strategy:** retry
+
+**Common Errors:**
+
+1. **Error:** Task Not Found
+   - **Cause:** Specified task not registered in system
+   - **Resolution:** Verify task name and registration
+   - **Recovery:** List available tasks, suggest similar
+
+2. **Error:** Invalid Parameters
+   - **Cause:** Task parameters do not match expected schema
+   - **Resolution:** Validate parameters against task definition
+   - **Recovery:** Provide parameter template, reject execution
+
+3. **Error:** Execution Timeout
+   - **Cause:** Task exceeds maximum execution time
+   - **Resolution:** Optimize task or increase timeout
+   - **Recovery:** Kill task, cleanup resources, log state
+
+---
+
+## Performance
+
+**Expected Metrics:**
+
+```yaml
+duration_expected: 2-5 min (estimated)
+cost_estimated: $0.001-0.003
+token_usage: ~1,000-3,000 tokens
+```
+
+**Optimization Notes:**
+- Parallelize independent operations; reuse atom results; implement early exits
+
+---
+
+## Metadata
+
+```yaml
+story: N/A
+version: 1.0.0
+dependencies:
+  - N/A
+tags:
+  - automation
+  - workflow
+updated_at: 2025-11-17
+```
+
+---
+
+# No checklists needed - analytical pattern learning task, no deliverables requiring validation
+---
+
+# Learn Patterns - grimoire Developer Task
+
+## Purpose
+Learn patterns from successful modifications to improve future meta-agent suggestions and automation.
+
+## Command Pattern
+```
+*learn-patterns [options]
+```
+
+## Parameters
+- `options`: Pattern learning configuration
+
+### Options
+- `--from-history <count>`: Learn from last N modifications (default: 50)
+- `--type <types>`: Comma-separated pattern types to learn (code,structural,refactoring,dependency,performance)
+- `--component <path>`: Learn patterns specific to a component
+- `--threshold <value>`: Similarity threshold for pattern matching (0-1, default: 0.8)
+- `--min-occurrences <count>`: Minimum occurrences before learning (default: 3)
+- `--export <file>`: Export learned patterns to file
+- `--import <file>`: Import patterns from file
+- `--analyze`: Show pattern analysis and statistics
+- `--reset`: Reset all learned patterns
+- `--suggest <modification-id>`: Get pattern suggestions for a modification
+
+## Examples
+```bash
+# Learn from recent modification history
+*learn-patterns --from-history 100
+
+# Learn specific pattern types
+*learn-patterns --type code,refactoring --threshold 0.9
+
+# Analyze patterns for a component
+*learn-patterns --component grimoire/agents/developer.md --analyze
+
+# Get suggestions for upcoming modification
+*learn-patterns --suggest mod-123456 --type refactoring
+
+# Export patterns for sharing
+*learn-patterns --export patterns-export.json
+```
+
+## Implementation
+
+```javascript
+const fs = require('fs').promises;
+const path = require('path');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+
+class LearnPatternsTask {
+  constructor() {
+    this.taskName = 'learn-patterns';
+    this.description = 'Learn patterns from successful modifications';
+    this.rootPath = process.cwd();
+    this.patternLearner = null;
+    this.modificationHistory = null;
+    this.componentRegistry = null;
+  }
+
+  async execute(params) {
+    try {
+      console.log(chalk.blue('🧠 grimoire Pattern Learning'));
+      console.log(chalk.gray('Learning from successful modifications\n'));
+
+      // Parse parameters
+      const config = await this.parseParameters(params);
+      
+      // Initialize dependencies
+      await this.initializeDependencies();
+
+      // Execute requested action
+      let result;
+      if (config.reset) {
+        result = await this.resetPatterns();
+      } else if (config.export) {
+        result = await this.exportPatterns(config.export);
+      } else if (config.import) {
+        result = await this.importPatterns(config.import);
+      } else if (config.analyze) {
+        result = await this.analyzePatterns(config);
+      } else if (config.suggest) {
+        result = await this.suggestPatterns(config.suggest, config);
+      } else {
+        result = await this.learnPatterns(config);
+      }
+
+      // Display results
+      await this.displayResults(result, config);
+
+      return {
+        success: true,
+        patternsLearned: result.patternsLearned || 0,
+        totalPatterns: result.totalPatterns || this.patternLearner.patterns.size,
+        suggestions: result.suggestions || []
+      };
+
+    } catch (error) {
+      console.error(chalk.red(`\n❌ Pattern learning failed: ${error.message}`));
+      throw error;
+    }
+  }
+
+  async parseParameters(params) {
+    const config = {
+      fromHistory: 50,
+      types: ['code', 'structural', 'refactoring', 'dependency', 'performance'],
+      component: null,
+      threshold: 0.8,
+      minOccurrences: 3,
+      export: null,
+      import: null,
+      analyze: false,
+      reset: false,
+      suggest: null
+    };
+
+    for (let i = 0; i < params.length; i++) {
+      const param = params[i];
+
+      if (param === '--analyze') {
+        config.analyze = true;
+      } else if (param === '--reset') {
+        config.reset = true;
+      } else if (param.startsWith('--from-history') && params[i + 1]) {
+        config.fromHistory = parseInt(params[++i]);
+      } else if (param.startsWith('--type') && params[i + 1]) {
+        config.types = params[++i].split(',').map(t => t.trim());
+      } else if (param.startsWith('--component') && params[i + 1]) {
+        config.component = params[++i];
+      } else if (param.startsWith('--threshold') && params[i + 1]) {
+        config.threshold = parseFloat(params[++i]);
+      } else if (param.startsWith('--min-occurrences') && params[i + 1]) {
+        config.minOccurrences = parseInt(params[++i]);
+      } else if (param.startsWith('--export') && params[i + 1]) {
+        config.export = params[++i];
+      } else if (param.startsWith('--import') && params[i + 1]) {
+        config.import = params[++i];
+      } else if (param.startsWith('--suggest') && params[i + 1]) {
+        config.suggest = params[++i];
+      }
+    }
+
+    // Validate configuration
+    if (config.threshold < 0 || config.threshold > 1) {
+      throw new Error('Threshold must be between 0 and 1');
+    }
+
+    const validTypes = ['code', 'structural', 'refactoring', 'dependency', 'performance'];
+    for (const type of config.types) {
+      if (!validTypes.includes(type)) {
+        throw new Error(`Invalid pattern type: ${type}`);
+      }
+    }
+
+    return config;
+  }
+
+  async initializeDependencies() {
+    try {
+      // const PatternLearner = require('../scripts/pattern-learner'); // Archived in archived-utilities/ (Story 3.1.3)
+      // this.patternLearner = new PatternLearner({ rootPath: this.rootPath }); // Archived in archived-utilities/ (Story 3.1.3)
+      // await this.patternLearner.initialize(); // Archived in archived-utilities/ (Story 3.1.3)
+
+      // const ModificationHistory = require('../scripts/modification-history'); // Archived in archived-utilities/ (Story 3.1.3)
+      // this.modificationHistory = new ModificationHistory({ rootPath: this.rootPath }); // Archived in archived-utilities/ (Story 3.1.3)
+
+      const ComponentRegistry = require('../scripts/component-registry');
+      this.componentRegistry = new ComponentRegistry({ rootPath: this.rootPath });
+
+    } catch (error) {
+      throw new Error(`Failed to initialize dependencies: ${error.message}`);
+    }
+  }
+
+  async learnPatterns(config) {
+    console.log(chalk.blue('\n📚 Learning from modification history...'));
+    
+    // Update learner configuration
+    this.patternLearner.learningThreshold = config.minOccurrences;
+    this.patternLearner.similarityThreshold = config.threshold;
+
+    // Load modification history
+    const modifications = await this.loadModificationHistory(config);
+    console.log(chalk.gray(`Loaded ${modifications.length} modifications for analysis`));
+
+    // Filter successful modifications
+    const successfulMods = modifications.filter(mod => 
+      mod.status === 'completed' && 
+      (!mod.rollback || mod.rollback.status !== 'rolled_back')
+    );
+    console.log(chalk.gray(`Found ${successfulMods.length} successful modifications`));
+
+    // Learn patterns from each modification
+    let patternsLearned = 0;
+    const progressInterval = Math.max(1, Math.floor(successfulMods.length / 20));
+
+    for (let i = 0; i < successfulMods.length; i++) {
+      const mod = successfulMods[i];
+      
+      try {
+        // Record modification for pattern learning
+        const learned = await this.patternLearner.recordModification(mod);
+        if (learned) patternsLearned++;
+
+        // Show progress
+        if (i % progressInterval === 0) {
+          const progress = Math.floor((i / successfulMods.length) * 100);
+          process.stdout.write(`\rProgress: ${progress}%`);
+        }
+      } catch (error) {
+        console.warn(chalk.yellow(`\nFailed to learn from ${mod.id}: ${error.message}`));
+      }
+    }
+
+    console.log(''); // New line after progress
+
+    return {
+      patternsLearned: patternsLearned,
+      totalPatterns: this.patternLearner.patterns.size,
+      modificationsAnalyzed: successfulMods.length
+    };
+  }
+
+  async loadModificationHistory(config) {
+    let modifications = [];
+
+    if (config.component) {
+      // Load modifications for specific component
+      modifications = await this.modificationHistory.getComponentHistory(
+        config.component,
+        { limit: config.fromHistory }
+      );
+    } else {
+      // Load recent modifications
+      modifications = await this.modificationHistory.getRecentModifications(
+        config.fromHistory
+      );
+    }
+
+    return modifications;
+  }
+
+  async analyzePatterns(config) {
+    console.log(chalk.blue('\n📊 Pattern Analysis'));
+    console.log(chalk.gray('━'.repeat(50)));
+
+    const analytics = this.patternLearner.getAnalytics();
+    
+    // Overall statistics
+    console.log(chalk.blue('\n📈 Overall Statistics:'));
+    console.log(`Total patterns: ${chalk.white(analytics.totalPatterns)}`);
+    console.log(`Total occurrences: ${chalk.white(analytics.totalOccurrences)}`);
+    console.log(`Average confidence: ${chalk.white((analytics.averageConfidence * 100).toFixed(1) + '%')}`);
+    console.log(`High confidence patterns: ${chalk.white(analytics.highConfidenceCount)}`);
+    
+    // Pattern type breakdown
+    console.log(chalk.blue('\n📑 Pattern Types:'));
+    Object.entries(analytics.patternsByType).forEach(([type, patterns]) => {
+      if (config.types.includes(type)) {
+        console.log(`${type}: ${chalk.white(patterns.length)} patterns`);
+      }
+    });
+
+    // Component-specific analysis
+    if (config.component) {
+      const componentPatterns = Array.from(this.patternLearner.patterns.values())
+        .filter(p => p.metadata.components && p.metadata.components.includes(config.component));
+      
+      console.log(chalk.blue(`\n🔍 Component Analysis: ${config.component}`));
+      console.log(`Patterns applicable: ${chalk.white(componentPatterns.length)}`);
+      
+      // Show top patterns for component
+      const topPatterns = componentPatterns
+        .sort((a, b) => b.confidence - a.confidence)
+        .slice(0, 5);
+      
+      if (topPatterns.length > 0) {
+        console.log(chalk.gray('\nTop patterns:'));
+        topPatterns.forEach((pattern, index) => {
+          console.log(`  ${index + 1}. ${pattern.description} (${(pattern.confidence * 100).toFixed(0)}% confidence)`);
+        });
+      }
+    }
+
+    // Recent learning activity
+    const recentPatterns = Array.from(this.patternLearner.patterns.values())
+      .sort((a, b) => new Date(b.lastSeen) - new Date(a.lastSeen))
+      .slice(0, 5);
+    
+    console.log(chalk.blue('\n🕐 Recently Active Patterns:'));
+    recentPatterns.forEach((pattern, index) => {
+      const lastSeen = new Date(pattern.lastSeen);
+      const daysAgo = Math.floor((Date.now() - lastSeen) / (1000 * 60 * 60 * 24));
+      console.log(`  ${index + 1}. ${pattern.description} (${daysAgo} days ago)`);
+    });
+
+    return analytics;
+  }
+
+  async suggestPatterns(modificationId, config) {
+    console.log(chalk.blue('\n💡 Pattern Suggestions'));
+    console.log(chalk.gray(`For modification: ${modificationId}\n`));
+
+    // Load modification details
+    const modification = await this.loadModification(modificationId);
+    if (!modification) {
+      throw new Error(`Modification not found: ${modificationId}`);
+    }
+
+    // Get pattern suggestions
+    const suggestions = this.patternLearner.suggestPatterns(modification, {
+      types: config.types,
+      minConfidence: 0.6,
+      maxSuggestions: 10
+    });
+
+    if (suggestions.length === 0) {
+      console.log(chalk.yellow('No applicable patterns found'));
+      return { suggestions: [] };
+    }
+
+    // Display suggestions
+    console.log(chalk.green(`Found ${suggestions.length} applicable patterns:\n`));
+    
+    suggestions.forEach((suggestion, index) => {
+      console.log(chalk.blue(`${index + 1}. ${suggestion.pattern.description}`));
+      console.log(`   Type: ${chalk.gray(suggestion.pattern.type)}`);
+      console.log(`   Confidence: ${this.formatConfidence(suggestion.confidence)}`);
+      console.log(`   Relevance: ${this.formatRelevance(suggestion.relevance)}`);
+      
+      if (suggestion.pattern.metadata.successRate) {
+        console.log(`   Success rate: ${chalk.green((suggestion.pattern.metadata.successRate * 100).toFixed(0) + '%')}`);
+      }
+      
+      if (suggestion.applicationGuide) {
+        console.log(chalk.gray('   Application guide:'));
+        suggestion.applicationGuide.steps.forEach((step, stepIndex) => {
+          console.log(chalk.gray(`     ${stepIndex + 1}. ${step}`));
+        });
+      }
+      
+      console.log('');
+    });
+
+    // Ask if user wants to apply suggestions
+    if (suggestions.length > 0) {
+      const { applyPatterns } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'applyPatterns',
+        message: 'Would you like to apply any of these patterns?',
+        default: false
+      }]);
+
+      if (applyPatterns) {
+        const { selectedPatterns } = await inquirer.prompt([{
+          type: 'checkbox',
+          name: 'selectedPatterns',
+          message: 'Select patterns to apply:',
+          choices: suggestions.map((s, i) => ({
+            name: `${s.pattern.description} (${(s.confidence * 100).toFixed(0)}%)`,
+            value: i
+          }))
+        }]);
+
+        // Apply selected patterns
+        for (const index of selectedPatterns) {
+          await this.applyPattern(suggestions[index], modification);
+        }
+      }
+    }
+
+    return { suggestions };
+  }
+
+  async applyPattern(suggestion, modification) {
+    console.log(chalk.blue(`\n🔧 Applying pattern: ${suggestion.pattern.description}`));
+    
+    try {
+      // Implementation would depend on pattern type
+      // This is a placeholder for the actual pattern application logic
+      console.log(chalk.green('✅ Pattern applied successfully'));
+      
+      // Record pattern application
+      this.patternLearner.recordPatternApplication(
+        suggestion.pattern.id,
+        modification.id,
+        true
+      );
+    } catch (error) {
+      console.error(chalk.red(`Failed to apply pattern: ${error.message}`));
+      
+      // Record failed application
+      this.patternLearner.recordPatternApplication(
+        suggestion.pattern.id,
+        modification.id,
+        false
+      );
+    }
+  }
+
+  async exportPatterns(exportPath) {
+    console.log(chalk.blue('\n📤 Exporting patterns...'));
+    
+    const exportData = {
+      version: 1,
+      exportDate: new Date().toISOString(),
+      patterns: Array.from(this.patternLearner.patterns.entries()).map(([id, pattern]) => ({
+        id,
+        ...pattern
+      })),
+      metadata: {
+        totalPatterns: this.patternLearner.patterns.size,
+        learningThreshold: this.patternLearner.learningThreshold,
+        similarityThreshold: this.patternLearner.similarityThreshold
+      }
+    };
+
+    await fs.writeFile(exportPath, JSON.stringify(exportData, null, 2));
+    console.log(chalk.green(`✅ Exported ${exportData.patterns.length} patterns to: ${exportPath}`));
+
+    return {
+      exported: true,
+      patternCount: exportData.patterns.length,
+      exportPath
+    };
+  }
+
+  async importPatterns(importPath) {
+    console.log(chalk.blue('\n📥 Importing patterns...'));
+    
+    try {
+      const content = await fs.readFile(importPath, 'utf-8');
+      const importData = JSON.parse(content);
+
+      if (importData.version !== 1) {
+        throw new Error(`Unsupported import version: ${importData.version}`);
+      }
+
+      // Ask for import strategy
+      const { strategy } = await inquirer.prompt([{
+        type: 'list',
+        name: 'strategy',
+        message: 'Import strategy:',
+        choices: [
+          { name: 'Merge with existing patterns', value: 'merge' },
+          { name: 'Replace all patterns', value: 'replace' },
+          { name: 'Cancel import', value: 'cancel' }
+        ]
+      }]);
+
+      if (strategy === 'cancel') {
+        console.log(chalk.yellow('Import cancelled'));
+        return { imported: false };
+      }
+
+      if (strategy === 'replace') {
+        this.patternLearner.patterns.clear();
+      }
+
+      // Import patterns
+      let imported = 0;
+      for (const pattern of importData.patterns) {
+        const { id, ...patternData } = pattern;
+        
+        if (strategy === 'merge' && this.patternLearner.patterns.has(id)) {
+          // Merge with existing pattern
+          const existing = this.patternLearner.patterns.get(id);
+          patternData.occurrences += existing.occurrences;
+          patternData.confidence = Math.max(patternData.confidence, existing.confidence);
+        }
+
+        this.patternLearner.patterns.set(id, patternData);
+        imported++;
+      }
+
+      // Save imported patterns
+      await this.patternLearner.savePatterns();
+
+      console.log(chalk.green(`✅ Imported ${imported} patterns`));
+      return {
+        imported: true,
+        patternCount: imported,
+        totalPatterns: this.patternLearner.patterns.size
+      };
+
+    } catch (error) {
+      throw new Error(`Import failed: ${error.message}`);
+    }
+  }
+
+  async resetPatterns() {
+    console.log(chalk.yellow('\n⚠️ Pattern Reset'));
+    
+    const { confirmReset } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirmReset',
+      message: 'Are you sure you want to reset all learned patterns?',
+      default: false
+    }]);
+
+    if (!confirmReset) {
+      console.log(chalk.gray('Reset cancelled'));
+      return { reset: false };
+    }
+
+    // Clear all patterns
+    this.patternLearner.patterns.clear();
+    this.patternLearner.modificationHistory = [];
+    await this.patternLearner.savePatterns();
+
+    console.log(chalk.green('✅ All patterns have been reset'));
+    return { reset: true };
+  }
+
+  async loadModification(modificationId) {
+    // Try multiple sources for modification data
+    const sources = [
+      path.join(this.rootPath, '.grimoire', 'modifications', `${modificationId}.json`),
+      path.join(this.rootPath, '.grimoire', 'history', `${modificationId}.json`),
+      path.join(this.rootPath, '.grimoire', 'proposals', `${modificationId}.json`)
+    ];
+
+    for (const source of sources) {
+      try {
+        const content = await fs.readFile(source, 'utf-8');
+        return JSON.parse(content);
+      } catch (error) {
+        // Try next source
+      }
+    }
+
+    return null;
+  }
+
+  async displayResults(result, config) {
+    console.log(chalk.blue('\n📊 Pattern Learning Results'));
+    console.log(chalk.gray('━'.repeat(50)));
+
+    if (result.patternsLearned !== undefined) {
+      console.log(`Patterns learned: ${chalk.green(result.patternsLearned)}`);
+      console.log(`Total patterns: ${chalk.white(result.totalPatterns)}`);
+      console.log(`Modifications analyzed: ${chalk.white(result.modificationsAnalyzed)}`);
+    }
+
+    if (result.exported) {
+      console.log(`Patterns exported: ${chalk.green(result.patternCount)}`);
+      console.log(`Export location: ${chalk.white(result.exportPath)}`);
+    }
+
+    if (result.imported) {
+      console.log(`Patterns imported: ${chalk.green(result.patternCount)}`);
+      console.log(`Total patterns: ${chalk.white(result.totalPatterns)}`);
+    }
+
+    if (result.reset) {
+      console.log(chalk.yellow('All patterns have been reset'));
+    }
+
+    // Show next steps
+    console.log(chalk.blue('\n📌 Next Steps:'));
+    if (result.patternsLearned > 0) {
+      console.log('1. Use --suggest to get pattern recommendations for new modifications');
+      console.log('2. Use --analyze to view pattern statistics');
+      console.log('3. Use --export to share patterns with other developers');
+    } else if (result.suggestions && result.suggestions.length > 0) {
+      console.log('1. Review suggested patterns carefully');
+      console.log('2. Apply patterns that match your modification goals');
+      console.log('3. Provide feedback on pattern effectiveness');
+    }
+  }
+
+  formatConfidence(confidence) {
+    const percentage = (confidence * 100).toFixed(0);
+    if (confidence >= 0.8) {
+      return chalk.green(`${percentage}%`);
+    } else if (confidence >= 0.6) {
+      return chalk.yellow(`${percentage}%`);
+    } else {
+      return chalk.red(`${percentage}%`);
+    }
+  }
+
+  formatRelevance(relevance) {
+    if (relevance >= 0.8) {
+      return chalk.green('High');
+    } else if (relevance >= 0.5) {
+      return chalk.yellow('Medium');
+    } else {
+      return chalk.red('Low');
+    }
+  }
+}
+
+module.exports = LearnPatternsTask;
+```
+
+## Pattern Types
+
+### Code Transformation Patterns
+- Variable renaming conventions
+- Function extraction patterns
+- Error handling additions
+- Async/await conversions
+- Code modernization patterns
+
+### Structural Patterns
+- Component organization changes
+- Module restructuring
+- Interface modifications
+- Class hierarchy changes
+- File organization patterns
+
+### Refactoring Patterns
+- Method extraction
+- Class decomposition
+- Interface segregation
+- Dependency injection
+- Code consolidation
+
+### Dependency Patterns
+- Package updates
+- Import reorganization
+- Dependency injection
+- Service layer patterns
+- API versioning
+
+### Performance Patterns
+- Caching implementations
+- Query optimizations
+- Lazy loading patterns
+- Memory usage improvements
+- Algorithm optimizations
+
+## Learning Process
+
+### Pattern Extraction
+1. Analyze successful modifications
+2. Extract change patterns using AST
+3. Calculate pattern similarity
+4. Group similar patterns
+5. Build pattern templates
+
+### Pattern Validation
+1. Check minimum occurrences
+2. Verify success rate
+3. Validate consistency
+4. Test applicability
+5. Calculate confidence score
+
+### Pattern Application
+1. Match current context
+2. Suggest relevant patterns
+3. Provide application guide
+4. Monitor application success
+5. Update pattern metrics
+
+## Integration Points
+
+### Pattern Learner Utility
+- Core pattern learning engine
+- Pattern storage and retrieval
+- Similarity calculations
+- Suggestion generation
+
+### Modification History
+- Access to past modifications
+- Success/failure tracking
+- Component change history
+- Impact analysis data
+
+### Component Registry
+- Component metadata
+- Dependency information
+- Usage patterns
+- Performance metrics
+
+## Security Considerations
+- Validate pattern sources
+- Prevent malicious patterns
+- Audit pattern applications
+- Secure pattern storage
+- Control pattern sharing
+
+## Best Practices
+1. Learn from diverse modifications
+2. Set appropriate thresholds
+3. Regularly analyze patterns
+4. Export valuable patterns
+5. Monitor pattern effectiveness
+6. Update patterns over time
+7. Share patterns across teams 
+