grimoire-framework 1.0.0

package/.grimoire/development/tasks/dev-optimize-performance.md

@@ -0,0 +1,1035 @@
+---
+
+## 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: devOptimizePerformance()
+responsável: Dex (Builder)
+responsavel_type: Agente
+atomic_layer: Strategy
+
+**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: 5-20 min (estimated)
+cost_estimated: $0.003-0.015
+token_usage: ~2,000-8,000 tokens
+```
+
+**Optimization Notes:**
+- Iterative analysis with depth limits; cache intermediate results; batch similar operations
+
+---
+
+## Metadata
+
+```yaml
+story: N/A
+version: 1.0.0
+dependencies:
+  - N/A
+tags:
+  - development
+  - code
+updated_at: 2025-11-17
+```
+
+---
+
+checklists:
+  - dev-master-checklist.md
+---
+
+# Optimize Performance - grimoire Developer Task
+
+## Purpose
+Analyze code for performance bottlenecks and suggest optimizations to improve runtime performance, memory usage, and scalability.
+
+## Command Pattern
+```
+*optimize-performance <path> [options]
+```
+
+## Parameters
+- `path`: File or directory path to analyze
+- `options`: Performance analysis configuration
+
+### Options
+- `--patterns <types>`: Comma-separated optimization patterns to check
+- `--profile`: Enable runtime profiling (if applicable)
+- `--threshold <level>`: Minimum impact threshold for suggestions (low/medium/high)
+- `--report <file>`: Generate performance report
+- `--apply <optimization-id>`: Apply specific optimization
+- `--recursive`: Analyze directories recursively
+- `--exclude <patterns>`: Exclude file patterns
+- `--focus <category>`: Focus on specific category (algorithm/memory/async/database/bundle/react)
+
+## Optimization Patterns
+- `algorithm_complexity`: High time complexity algorithms
+- `loop_optimization`: Nested loops and iterations
+- `memory_usage`: Memory consumption and leaks
+- `async_operations`: Async/await patterns
+- `caching`: Memoization opportunities
+- `database_queries`: N+1 and query optimization
+- `bundle_size`: JavaScript bundle optimization
+- `react_performance`: React-specific optimizations
+- `string_operations`: String manipulation
+- `object_operations`: Object creation and access
+
+## Examples
+```bash
+# Analyze single file
+*optimize-performance grimoire/scripts/data-processor.js
+
+# Analyze directory with specific patterns
+*optimize-performance grimoire/agents --patterns algorithm_complexity,async_operations --recursive
+
+# Generate performance report
+*optimize-performance . --recursive --report performance-report.json
+
+# Focus on database optimizations
+*optimize-performance grimoire/services --focus database --recursive
+
+# Apply specific optimization
+*optimize-performance grimoire/scripts/calculator.js --apply opt-001
+```
+
+## Implementation
+
+```javascript
+const fs = require('fs').promises;
+const path = require('path');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const glob = require('glob').promises;
+
+class OptimizePerformanceTask {
+  constructor() {
+    this.taskName = 'optimize-performance';
+    this.description = 'Analyze and optimize code performance';
+    this.rootPath = process.cwd();
+    this.performanceOptimizer = null;
+    this.analysisResults = [];
+    this.appliedOptimizations = [];
+  }
+
+  async execute(params) {
+    try {
+      console.log(chalk.blue('⚡ grimoire Performance Optimization'));
+      console.log(chalk.gray('Analyzing code for performance improvements\n'));
+
+      // Parse parameters
+      const config = await this.parseParameters(params);
+      
+      // Initialize dependencies
+      await this.initializeDependencies();
+
+      // Get files to analyze
+      const files = await this.getFilesToAnalyze(config);
+      
+      if (files.length === 0) {
+        console.log(chalk.yellow('No files found to analyze'));
+        return { success: true, results: [] };
+      }
+
+      console.log(chalk.gray(`Found ${files.length} files to analyze\n`));
+
+      // Execute based on mode
+      if (config.apply) {
+        // Apply specific optimization
+        await this.applyOptimization(config.apply, config);
+      } else {
+        // Analyze files
+        await this.analyzeFiles(files, config);
+        
+        // Display results
+        await this.displayResults(config);
+        
+        // Generate report if requested
+        if (config.report) {
+          await this.generateReport(config.report);
+        }
+      }
+
+      return {
+        success: true,
+        filesAnalyzed: files.length,
+        totalIssues: this.getTotalIssues(),
+        criticalIssues: this.getCriticalIssues()
+      };
+
+    } catch (error) {
+      console.error(chalk.red(`\n❌ Performance optimization failed: ${error.message}`));
+      throw error;
+    }
+  }
+
+  async parseParameters(params) {
+    if (params.length < 1) {
+      throw new Error('Usage: *optimize-performance <path> [options]');
+    }
+
+    const config = {
+      targetPath: params[0],
+      patterns: null,
+      profile: false,
+      threshold: 'low',
+      report: null,
+      apply: null,
+      recursive: false,
+      exclude: [],
+      focus: null
+    };
+
+    // Parse options
+    for (let i = 1; i < params.length; i++) {
+      const param = params[i];
+      
+      if (param === '--profile') {
+        config.profile = true;
+      } else if (param === '--recursive') {
+        config.recursive = true;
+      } else if (param.startsWith('--patterns') && params[i + 1]) {
+        config.patterns = params[++i].split(',').map(p => p.trim());
+      } else if (param.startsWith('--threshold') && params[i + 1]) {
+        config.threshold = params[++i];
+      } else if (param.startsWith('--report') && params[i + 1]) {
+        config.report = params[++i];
+      } else if (param.startsWith('--apply') && params[i + 1]) {
+        config.apply = params[++i];
+      } else if (param.startsWith('--exclude') && params[i + 1]) {
+        config.exclude = params[++i].split(',').map(e => e.trim());
+      } else if (param.startsWith('--focus') && params[i + 1]) {
+        config.focus = params[++i];
+      }
+    }
+
+    // Validate threshold
+    if (!['low', 'medium', 'high'].includes(config.threshold)) {
+      throw new Error('Threshold must be: low, medium, or high');
+    }
+
+    return config;
+  }
+
+  async initializeDependencies() {
+    try {
+      const PerformanceOptimizer = require('../scripts/performance-optimizer');
+      this.performanceOptimizer = new PerformanceOptimizer({ 
+        rootPath: this.rootPath,
+        enableProfiling: true
+      });
+
+      // Listen to events
+      this.performanceOptimizer.on('analyzed', (analysis) => {
+        this.analysisResults.push(analysis);
+      });
+
+    } catch (error) {
+      throw new Error(`Failed to initialize dependencies: ${error.message}`);
+    }
+  }
+
+  async getFilesToAnalyze(config) {
+    const targetPath = path.resolve(this.rootPath, config.targetPath);
+    const files = [];
+
+    try {
+      const stats = await fs.stat(targetPath);
+      
+      if (stats.isFile()) {
+        // Single file
+        if (this.shouldAnalyzeFile(targetPath, config)) {
+          files.push(targetPath);
+        }
+      } else if (stats.isDirectory()) {
+        // Directory
+        const pattern = config.recursive ? '**/*.{js,jsx,ts,tsx}' : '*.{js,jsx,ts,tsx}';
+        const globPattern = path.join(targetPath, pattern);
+        
+        const matches = await glob(globPattern, {
+          ignore: config.exclude.map(e => path.join(targetPath, '**', e)),
+          nodir: true
+        });
+        
+        for (const match of matches) {
+          if (this.shouldAnalyzeFile(match, config)) {
+            files.push(match);
+          }
+        }
+      }
+    } catch (error) {
+      console.warn(chalk.yellow(`Cannot access ${targetPath}: ${error.message}`));
+    }
+
+    return files;
+  }
+
+  shouldAnalyzeFile(filePath, config) {
+    // Skip test files unless analyzing tests
+    if (filePath.includes('.test.') || filePath.includes('.spec.')) {
+      return false;
+    }
+    
+    // Skip minified files
+    if (filePath.includes('.min.')) {
+      return false;
+    }
+    
+    // Skip build artifacts
+    if (filePath.includes('/dist/') || filePath.includes('/build/')) {
+      return false;
+    }
+    
+    // Skip node_modules
+    if (filePath.includes('node_modules')) {
+      return false;
+    }
+    
+    return true;
+  }
+
+  async analyzeFiles(files, config) {
+    console.log(chalk.blue('🔍 Analyzing performance...'));
+    
+    const progressInterval = Math.max(1, Math.floor(files.length / 20));
+    
+    for (let i = 0; i < files.length; i++) {
+      const file = files[i];
+      
+      try {
+        const analysis = await this.performanceOptimizer.analyzePerformance(file, {
+          patterns: config.patterns,
+          enableProfiling: config.profile
+        });
+        
+        // Filter by threshold
+        if (analysis.issues && analysis.issues.length > 0) {
+          analysis.issues = this.filterByThreshold(analysis.issues, config.threshold);
+        }
+        
+        // Filter by focus category
+        if (config.focus && analysis.issues) {
+          analysis.issues = analysis.issues.filter(issue => 
+            issue.category === config.focus
+          );
+        }
+        
+        // Show progress
+        if (i % progressInterval === 0) {
+          const progress = Math.floor((i / files.length) * 100);
+          process.stdout.write(`\rProgress: ${progress}%`);
+        }
+        
+      } catch (error) {
+        console.warn(chalk.yellow(`\nFailed to analyze ${file}: ${error.message}`));
+      }
+    }
+    
+    console.log('\rProgress: 100%\n');
+  }
+
+  filterByThreshold(issues, threshold) {
+    const thresholdMap = {
+      low: ['low', 'medium', 'high', 'critical'],
+      medium: ['medium', 'high', 'critical'],
+      high: ['high', 'critical']
+    };
+    
+    const allowedImpacts = thresholdMap[threshold];
+    
+    return issues.filter(issue => 
+      allowedImpacts.includes(issue.impact) || 
+      allowedImpacts.includes(issue.severity)
+    );
+  }
+
+  async displayResults(config) {
+    const totalIssues = this.getTotalIssues();
+    
+    if (totalIssues === 0) {
+      console.log(chalk.green('✅ No performance issues found!'));
+      console.log(chalk.gray('Your code is already well optimized.'));
+      return;
+    }
+
+    console.log(chalk.blue(`\n📊 Performance Analysis Results\n`));
+    console.log(chalk.gray('Found ') + chalk.yellow(totalIssues) + chalk.gray(' optimization opportunities\n'));
+
+    // Group by category
+    const byCategory = this.groupByCategory();
+    
+    // Display by category
+    for (const [category, results] of Object.entries(byCategory)) {
+      console.log(chalk.blue(`\n${this.getCategoryIcon(category)} ${this.getCategoryName(category)}`));
+      console.log(chalk.gray('─'.repeat(50)));
+      
+      for (const result of results) {
+        this.displayFileResults(result);
+      }
+    }
+
+    // Show performance scores
+    this.displayPerformanceScores();
+
+    // Show top recommendations
+    this.displayTopRecommendations();
+
+    // Show next steps
+    console.log(chalk.blue('\n📌 Next Steps:'));
+    console.log('1. Review critical issues first');
+    console.log('2. Apply optimizations incrementally');
+    console.log('3. Test after each optimization');
+    console.log('4. Monitor performance improvements');
+    if (config.report) {
+      console.log(`5. View detailed report: ${config.report}`);
+    }
+  }
+
+  displayFileResults(result) {
+    const relativePath = path.relative(this.rootPath, result.filePath);
+    
+    console.log(`\n📄 ${chalk.blue(relativePath)}`);
+    
+    if (result.metrics?.performanceScore !== undefined) {
+      const score = result.metrics.performanceScore;
+      const scoreColor = score >= 80 ? chalk.green : score >= 60 ? chalk.yellow : chalk.red;
+      console.log(`   Performance Score: ${scoreColor(score + '/100')}`);
+    }
+    
+    // Display issues
+    for (const issue of result.issues) {
+      this.displayIssue(issue);
+      
+      // Display suggestions for this issue
+      const suggestion = result.suggestions?.find(s => 
+        s.issueId === issue.id || s.pattern === issue.pattern
+      );
+      
+      if (suggestion) {
+        this.displaySuggestion(suggestion);
+      }
+    }
+  }
+
+  displayIssue(issue) {
+    const impactColors = {
+      critical: chalk.red,
+      high: chalk.red,
+      medium: chalk.yellow,
+      low: chalk.gray
+    };
+    
+    const impactColor = impactColors[issue.impact || issue.severity] || chalk.gray;
+    
+    console.log(`\n   ${impactColor(`[${(issue.impact || issue.severity || 'info').toUpperCase()}]`)} ${issue.description}`);
+    
+    if (issue.location) {
+      console.log(chalk.gray(`   Location: Line ${issue.location.start?.line || '?'}`));
+    }
+    
+    if (issue.type) {
+      console.log(chalk.gray(`   Type: ${issue.type}`));
+    }
+  }
+
+  displaySuggestion(suggestion) {
+    console.log(chalk.green('   💡 Suggestion:'));
+    
+    if (suggestion.optimizations) {
+      for (const opt of suggestion.optimizations) {
+        console.log(`      - ${opt.description}`);
+        
+        if (opt.code) {
+          console.log(chalk.gray('        Example:'));
+          const codeLines = opt.code.split('\n');
+          for (const line of codeLines) {
+            console.log(chalk.gray(`          ${line}`));
+          }
+        }
+        
+        if (opt.improvement) {
+          console.log(chalk.green(`        → ${opt.improvement}`));
+        }
+      }
+    }
+    
+    if (suggestion.estimatedImprovement) {
+      console.log(chalk.green(`      Estimated improvement: ${suggestion.estimatedImprovement}`));
+    }
+  }
+
+  groupByCategory() {
+    const grouped = {};
+    
+    for (const result of this.analysisResults) {
+      if (!result.issues || result.issues.length === 0) continue;
+      
+      for (const issue of result.issues) {
+        const category = issue.category || 'other';
+        
+        if (!grouped[category]) {
+          grouped[category] = [];
+        }
+        
+        // Find or create file entry
+        let fileEntry = grouped[category].find(r => r.filePath === result.filePath);
+        if (!fileEntry) {
+          fileEntry = {
+            filePath: result.filePath,
+            issues: [],
+            suggestions: result.suggestions || [],
+            metrics: result.metrics
+          };
+          grouped[category].push(fileEntry);
+        }
+        
+        fileEntry.issues.push(issue);
+      }
+    }
+    
+    return grouped;
+  }
+
+  getCategoryIcon(category) {
+    const icons = {
+      algorithm: '🔄',
+      memory: '💾',
+      async: '⚡',
+      database: '🗄️',
+      bundle: '📦',
+      react: '⚛️',
+      caching: '💰',
+      framework: '🏗️',
+      other: '🔧'
+    };
+    
+    return icons[category] || icons.other;
+  }
+
+  getCategoryName(category) {
+    const names = {
+      algorithm: 'Algorithm Optimization',
+      memory: 'Memory Usage',
+      async: 'Async Operations',
+      database: 'Database Queries',
+      bundle: 'Bundle Size',
+      react: 'React Performance',
+      caching: 'Caching Opportunities',
+      framework: 'Framework-Specific',
+      other: 'Other Optimizations'
+    };
+    
+    return names[category] || category;
+  }
+
+  displayPerformanceScores() {
+    console.log(chalk.blue('\n📈 Performance Summary'));
+    console.log(chalk.gray('─'.repeat(50)));
+    
+    let totalScore = 0;
+    let fileCount = 0;
+    
+    for (const result of this.analysisResults) {
+      if (result.metrics?.performanceScore !== undefined) {
+        totalScore += result.metrics.performanceScore;
+        fileCount++;
+      }
+    }
+    
+    if (fileCount > 0) {
+      const avgScore = Math.round(totalScore / fileCount);
+      const scoreColor = avgScore >= 80 ? chalk.green : avgScore >= 60 ? chalk.yellow : chalk.red;
+      
+      console.log(`Average Performance Score: ${scoreColor(avgScore + '/100')}`);
+      console.log(`Files Analyzed: ${fileCount}`);
+    }
+    
+    // Issue breakdown
+    const criticalCount = this.getCriticalIssues();
+    const highCount = this.getIssuesByImpact('high');
+    const mediumCount = this.getIssuesByImpact('medium');
+    const lowCount = this.getIssuesByImpact('low');
+    
+    console.log('\nIssue Breakdown:');
+    if (criticalCount > 0) console.log(chalk.red(`  Critical: ${criticalCount}`));
+    if (highCount > 0) console.log(chalk.red(`  High: ${highCount}`));
+    if (mediumCount > 0) console.log(chalk.yellow(`  Medium: ${mediumCount}`));
+    if (lowCount > 0) console.log(chalk.gray(`  Low: ${lowCount}`));
+  }
+
+  displayTopRecommendations() {
+    console.log(chalk.blue('\n🎯 Top Recommendations'));
+    console.log(chalk.gray('─'.repeat(50)));
+    
+    const recommendations = this.getTopRecommendations();
+    
+    if (recommendations.length === 0) {
+      console.log(chalk.gray('No specific recommendations'));
+      return;
+    }
+    
+    for (let i = 0; i < Math.min(5, recommendations.length); i++) {
+      const rec = recommendations[i];
+      console.log(`\n${i + 1}. ${rec.title}`);
+      console.log(chalk.gray(`   ${rec.description}`));
+      if (rec.files) {
+        console.log(chalk.gray(`   Files affected: ${rec.files.length}`));
+      }
+    }
+  }
+
+  getTopRecommendations() {
+    const recommendations = [];
+    const byCategory = this.groupByCategory();
+    
+    // Algorithm complexity issues
+    if (byCategory.algorithm?.length > 0) {
+      const highComplexity = byCategory.algorithm.filter(r => 
+        r.issues.some(i => i.type === 'high_complexity' && i.severity === 'critical')
+      );
+      
+      if (highComplexity.length > 0) {
+        recommendations.push({
+          title: 'Optimize High-Complexity Algorithms',
+          description: 'Several functions have O(n²) or worse complexity. Consider using more efficient algorithms.',
+          priority: 'critical',
+          files: highComplexity
+        });
+      }
+    }
+    
+    // Async issues
+    if (byCategory.async?.length > 0) {
+      const sequentialAwaits = byCategory.async.filter(r => 
+        r.issues.some(i => i.type === 'sequential_awaits')
+      );
+      
+      if (sequentialAwaits.length > 0) {
+        recommendations.push({
+          title: 'Parallelize Async Operations',
+          description: 'Use Promise.all to run independent async operations in parallel.',
+          priority: 'high',
+          files: sequentialAwaits
+        });
+      }
+    }
+    
+    // Database issues
+    if (byCategory.database?.length > 0) {
+      const nPlusOne = byCategory.database.filter(r => 
+        r.issues.some(i => i.type === 'n_plus_one')
+      );
+      
+      if (nPlusOne.length > 0) {
+        recommendations.push({
+          title: 'Fix N+1 Query Problems',
+          description: 'Database queries in loops cause performance degradation. Use JOINs or batch loading.',
+          priority: 'critical',
+          files: nPlusOne
+        });
+      }
+    }
+    
+    // Memory issues
+    if (byCategory.memory?.length > 0) {
+      recommendations.push({
+        title: 'Optimize Memory Usage',
+        description: 'Review memory allocations and potential leaks. Consider using more efficient data structures.',
+        priority: 'medium',
+        files: byCategory.memory
+      });
+    }
+    
+    // Caching opportunities
+    if (byCategory.caching?.length > 0) {
+      recommendations.push({
+        title: 'Implement Caching',
+        description: 'Add memoization or caching for expensive repeated operations.',
+        priority: 'medium',
+        files: byCategory.caching
+      });
+    }
+    
+    // Sort by priority
+    const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+    recommendations.sort((a, b) => 
+      priorityOrder[a.priority] - priorityOrder[b.priority]
+    );
+    
+    return recommendations;
+  }
+
+  async applyOptimization(optimizationId, config) {
+    console.log(chalk.blue(`\n🔧 Applying optimization: ${optimizationId}`));
+    
+    // Find the optimization in results
+    let targetOptimization = null;
+    let targetFile = null;
+    
+    for (const result of this.analysisResults) {
+      const suggestion = result.suggestions?.find(s => 
+        s.issueId === optimizationId || s.id === optimizationId
+      );
+      
+      if (suggestion) {
+        targetOptimization = suggestion;
+        targetFile = result.filePath;
+        break;
+      }
+    }
+    
+    if (!targetOptimization) {
+      throw new Error(`Optimization not found: ${optimizationId}`);
+    }
+    
+    console.log(chalk.gray(`File: ${path.relative(this.rootPath, targetFile)}`));
+    console.log(chalk.gray(`Type: ${targetOptimization.type || 'General optimization'}`));
+    
+    // Show optimization details
+    if (targetOptimization.optimizations) {
+      console.log(chalk.blue('\nOptimizations to apply:'));
+      for (const opt of targetOptimization.optimizations) {
+        console.log(`  - ${opt.description}`);
+      }
+    }
+    
+    // Confirm application
+    const { confirm } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirm',
+      message: 'Apply this optimization?',
+      default: true
+    }]);
+    
+    if (!confirm) {
+      console.log(chalk.gray('Optimization cancelled'));
+      return;
+    }
+    
+    // Apply the optimization
+    try {
+      const result = await this.performanceOptimizer.applyOptimization(
+        targetFile,
+        targetOptimization
+      );
+      
+      if (result.success) {
+        console.log(chalk.green('✅ Optimization applied successfully'));
+        
+        // Show changes
+        for (const change of result.changes) {
+          console.log(chalk.gray(`  - ${change.description}`));
+        }
+        
+        this.appliedOptimizations.push({
+          file: targetFile,
+          optimization: targetOptimization,
+          result,
+          timestamp: new Date().toISOString()
+        });
+      } else {
+        console.error(chalk.red(`Failed to apply optimization: ${result.error}`));
+      }
+    } catch (error) {
+      console.error(chalk.red(`Error applying optimization: ${error.message}`));
+    }
+  }
+
+  async generateReport(reportPath) {
+    console.log(chalk.blue('\n📤 Generating performance report...'));
+    
+    const report = await this.performanceOptimizer.generateOptimizationReport();
+    
+    // Add analysis results
+    report.analysisResults = this.analysisResults.map(r => ({
+      file: path.relative(this.rootPath, r.filePath),
+      performanceScore: r.metrics?.performanceScore,
+      issues: r.issues.length,
+      criticalIssues: r.issues.filter(i => 
+        i.impact === 'critical' || i.severity === 'critical'
+      ).length,
+      suggestions: r.suggestions?.length || 0
+    }));
+    
+    // Add applied optimizations
+    report.appliedOptimizations = this.appliedOptimizations;
+    
+    await fs.writeFile(reportPath, JSON.stringify(report, null, 2));
+    console.log(chalk.green(`✅ Report generated: ${reportPath}`));
+    
+    // Show report summary
+    console.log(chalk.blue('\n📊 Report Summary:'));
+    console.log(`  Files analyzed: ${report.summary.filesAnalyzed}`);
+    console.log(`  Total issues: ${report.summary.totalIssues}`);
+    console.log(`  Critical issues: ${report.summary.criticalIssues}`);
+    console.log(`  Optimizations applied: ${report.summary.optimizationsApplied}`);
+  }
+
+  getTotalIssues() {
+    return this.analysisResults.reduce((total, result) => 
+      total + (result.issues?.length || 0), 0
+    );
+  }
+
+  getCriticalIssues() {
+    return this.analysisResults.reduce((total, result) => 
+      total + (result.issues?.filter(i => 
+        i.impact === 'critical' || i.severity === 'critical'
+      ).length || 0), 0
+    );
+  }
+
+  getIssuesByImpact(impact) {
+    return this.analysisResults.reduce((total, result) => 
+      total + (result.issues?.filter(i => 
+        i.impact === impact || i.severity === impact
+      ).length || 0), 0
+    );
+  }
+}
+
+module.exports = OptimizePerformanceTask;
+```
+
+## Integration Points
+
+### Performance Optimizer
+- Core analysis engine
+- Pattern detection system
+- Optimization suggestion generator
+- Runtime profiling capability
+
+### Analysis Categories
+- **Algorithm**: Time complexity, nested loops
+- **Memory**: Allocations, leaks, data structures
+- **Async**: Promise patterns, parallelization
+- **Database**: Query optimization, N+1 problems
+- **Bundle**: Import optimization, tree-shaking
+- **React**: Component rendering, memoization
+- **Caching**: Memoization opportunities
+
+### Metrics Collection
+- Static code analysis
+- Complexity calculations
+- Performance scoring
+- Impact assessment
+
+## Performance Analysis Workflow
+
+### Detection Phase
+1. Parse source code into AST
+2. Run pattern detectors
+3. Calculate complexity metrics
+4. Identify bottlenecks
+5. Score performance impact
+
+### Analysis Phase
+1. Evaluate issue severity
+2. Group related issues
+3. Generate optimization suggestions
+4. Estimate improvements
+5. Prioritize recommendations
+
+### Optimization Phase
+1. Review suggestions
+2. Validate safety
+3. Apply transformations
+4. Test results
+5. Measure improvements
+
+## Best Practices
+
+### Performance Analysis
+- Start with critical issues
+- Focus on hot paths
+- Measure before and after
+- Test optimizations thoroughly
+- Consider trade-offs
+
+### Optimization Strategy
+- Profile first, optimize second
+- Target biggest bottlenecks
+- Preserve code readability
+- Document optimizations
+- Monitor regression
+
+### Continuous Improvement
+- Regular performance audits
+- Automated performance tests
+- Track metrics over time
+- Share optimization patterns
+- Build performance culture
+
+## Security Considerations
+- Validate optimization safety
+- Preserve functionality
+- Avoid premature optimization
+- Test edge cases
+- Monitor side effects 
+