code-simplifier 1.0.0 → 1.2.0

package/lib/ai-refactor-advisor.js

@@ -0,0 +1,853 @@
+#!/usr/bin/env node
+
+/**
+ * AI-Powered Refactor Advisor
+ * Provides intelligent refactoring suggestions with impact assessment
+ * Generates step-by-step refactoring plans and before/after comparisons
+ */
+
+const fs = require('fs-extra')
+const path = require('path')
+const chalk = require('chalk')
+const AIQualityAnalyzer = require('./ai-quality-analyzer')
+const { OpenAI } = require('openai')
+const Anthropic = require('@anthropic-ai/sdk')
+
+/**
+ * AI Refactor Advisor
+ */
+class AIRefactorAdvisor {
+  constructor(config = {}) {
+    this.config = {
+      refactorTypes: config.refactorTypes || [
+        'extract-method',
+        'inline-method',
+        'rename-variable',
+        'rename-class',
+        'extract-class',
+        'move-method',
+        'replace-loop-with-pipeline',
+        'simplify-conditional',
+        'remove-duplicate-code',
+        'decompose-conditional',
+        'replace-temp-with-query',
+        'introduce-parameter-object',
+        'replace-magic-number',
+        'consolidate-duplicate-conditional',
+        'extract-interface',
+        'move-class',
+        'change-function-signature',
+        'extract-superclass',
+        'push-down-method',
+        'pull-up-method'
+      ],
+      confidenceThreshold: config.confidenceThreshold || 0.8,
+      maxRefactorSuggestions: config.maxRefactorSuggestions || 50,
+      impactThreshold: config.impactThreshold || 0.8,
+      openaiApiKey: config.openaiApiKey || process.env.OPENAI_API_KEY,
+      anthropicApiKey: config.anthropicApiKey || process.env.ANTHROPIC_API_KEY,
+      ...config
+    }
+
+    this.refactorSuggestions = []
+    this.analysisResults = {}
+    this.stats = {
+      opportunitiesIdentified: 0,
+      suggestionsGenerated: 0,
+      highImpactRefactors: 0,
+      avgConfidence: 0
+    }
+
+    this.qualityAnalyzer = new AIQualityAnalyzer({
+      openaiApiKey: this.config.openaiApiKey,
+      anthropicApiKey: this.config.anthropicApiKey
+    })
+
+    this.openai = this.config.openaiApiKey ? new OpenAI({ apiKey: this.config.openaiApiKey }) : null
+    this.anthropic = this.config.anthropicApiKey ? new Anthropic({ apiKey: this.config.anthropicApiKey }) : null
+
+    // Refactoring patterns database
+    this.refactorPatterns = {
+      'extract-method': {
+        description: 'Extract a method from a large function',
+        indicators: ['long function', 'duplicate code', 'multiple responsibilities'],
+        impact: 'high',
+        complexity: 'medium',
+        timeEstimate: '1-2 hours'
+      },
+      'rename-variable': {
+        description: 'Rename variables to be more descriptive',
+        indicators: ['bad variable names', 'single letter variables', 'unclear names'],
+        impact: 'medium',
+        complexity: 'low',
+        timeEstimate: '15-30 minutes'
+      },
+      'extract-class': {
+        description: 'Extract a class from a large class or module',
+        indicators: ['god class', 'too many methods', '分散责任'],
+        impact: 'high',
+        complexity: 'high',
+        timeEstimate: '4-8 hours'
+      },
+      'move-method': {
+        description: 'Move a method to a more appropriate class',
+        indicators: ['feature envy', 'inappropriate intimacy'],
+        impact: 'medium',
+        complexity: 'medium',
+        timeEstimate: '1-3 hours'
+      },
+      'simplify-conditional': {
+        description: 'Simplify complex conditional logic',
+        indicators: ['complex conditionals', 'deeply nested ifs'],
+        impact: 'high',
+        complexity: 'medium',
+        timeEstimate: '2-4 hours'
+      },
+      'replace-loop-with-pipeline': {
+        description: 'Replace loops with functional programming patterns',
+        indicators: ['imperative loops', 'manual iteration'],
+        impact: 'medium',
+        complexity: 'medium',
+        timeEstimate: '1-2 hours'
+      },
+      'remove-duplicate-code': {
+        description: 'Remove duplicate code by creating shared methods',
+        indicators: ['duplicate code', 'code clones'],
+        impact: 'high',
+        complexity: 'low',
+        timeEstimate: '30 minutes - 2 hours'
+      },
+      'extract-interface': {
+        description: 'Extract interface from class for better abstraction',
+        indicators: ['concrete implementation only', 'multiple implementations'],
+        impact: 'medium',
+        complexity: 'medium',
+        timeEstimate: '1-3 hours'
+      },
+      'introduce-parameter-object': {
+        description: 'Replace long parameter lists with parameter object',
+        indicators: ['long parameter list', 'parameter groups'],
+        impact: 'medium',
+        complexity: 'medium',
+        timeEstimate: '1-2 hours'
+      },
+      'replace-magic-number': {
+        description: 'Replace magic numbers with named constants',
+        indicators: ['magic numbers', 'hardcoded values'],
+        impact: 'low',
+        complexity: 'low',
+        timeEstimate: '15-30 minutes'
+      },
+      'decompose-conditional': {
+        description: 'Break down complex conditionals into smaller functions',
+        indicators: ['complex conditionals', 'long boolean expressions'],
+        impact: 'medium',
+        complexity: 'medium',
+        timeEstimate: '1-2 hours'
+      },
+      'push-down-method': {
+        description: 'Move method from parent class to child class',
+        indicators: ['method not used by all children'],
+        impact: 'medium',
+        complexity: 'medium',
+        timeEstimate: '2-4 hours'
+      },
+      'pull-up-method': {
+        description: 'Move method from child class to parent class',
+        indicators: ['duplicate methods in children'],
+        impact: 'medium',
+        complexity: 'medium',
+        timeEstimate: '2-4 hours'
+      },
+      'change-function-signature': {
+        description: 'Change function parameters or return type',
+        indicators: ['function needs different params', 'api change needed'],
+        impact: 'high',
+        complexity: 'high',
+        timeEstimate: '2-6 hours'
+      },
+      'extract-superclass': {
+        description: 'Extract common functionality into superclass',
+        indicators: ['duplicate code in siblings', 'shared behavior'],
+        impact: 'medium',
+        complexity: 'high',
+        timeEstimate: '4-8 hours'
+      }
+    }
+  }
+
+  /**
+   * Initialize Refactor Advisor
+   */
+  async initialize() {
+    console.log(chalk.blue('🔧 Initializing AI Refactor Advisor...'))
+    console.log(chalk.green(`✓ Loaded ${Object.keys(this.refactorPatterns).length} refactoring patterns`))
+    console.log(chalk.green('✓ AI Refactor Advisor initialized'))
+  }
+
+  /**
+   * Analyze code and identify refactoring opportunities
+   */
+  async analyzeCode(codePath, options = {}) {
+    console.log(chalk.blue('\n🔧 Analyzing code for refactoring opportunities...'))
+
+    try {
+      // Analyze code quality
+      const analysis = await this.qualityAnalyzer.analyzeCode(codePath, {
+        languages: options.languages || ['javascript', 'typescript', 'python', 'java'],
+        includeTests: options.includeTests || false
+      })
+
+      // Identify refactoring opportunities
+      const opportunities = this.identifyOpportunities(analysis)
+
+      // Generate suggestions
+      this.refactorSuggestions = await this.generateSuggestions(opportunities, analysis)
+
+      // Calculate statistics
+      this.stats.opportunitiesIdentified = opportunities.length
+      this.stats.suggestionsGenerated = this.refactorSuggestions.length
+      this.stats.highImpactRefactors = this.refactorSuggestions.filter(s => s.impact === 'high').length
+      this.stats.avgConfidence = this.calculateAverageConfidence()
+
+      console.log(chalk.green(`✓ Found ${opportunities.length} refactoring opportunities`))
+      console.log(chalk.green(`✓ Generated ${this.refactorSuggestions.length} suggestions`))
+
+      return this.generateReport()
+
+    } catch (error) {
+      console.error(chalk.red('❌ Refactoring analysis failed:'), error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Identify refactoring opportunities from code analysis
+   */
+  identifyOpportunities(analysis) {
+    const opportunities = []
+
+    for (const fileResult of analysis.files || []) {
+      const issues = fileResult.issues || []
+
+      // Map issues to refactoring opportunities
+      issues.forEach(issue => {
+        const opportunity = this.mapIssueToRefactor(issue, fileResult)
+        if (opportunity) {
+          opportunities.push(opportunity)
+        }
+      })
+
+      // Additional opportunity detection
+      this.detectCodeSmells(fileResult).forEach(opp => {
+        opportunities.push(opp)
+      })
+    }
+
+    return opportunities
+  }
+
+  /**
+   * Map code issues to refactoring opportunities
+   */
+  mapIssueToRefactor(issue, fileResult) {
+    const type = issue.type
+    const severity = issue.severity
+
+    // Map based on issue type
+    const refactorMap = {
+      'longFunction': {
+        refactorType: 'extract-method',
+        confidence: 0.9,
+        reason: 'Function is too long and should be split'
+      },
+      'badVariableNames': {
+        refactorType: 'rename-variable',
+        confidence: 0.85,
+        reason: 'Variable names are unclear'
+      },
+      'duplicateCode': {
+        refactorType: 'remove-duplicate-code',
+        confidence: 0.95,
+        reason: 'Duplicate code found'
+      },
+      'highComplexity': {
+        refactorType: 'simplify-conditional',
+        confidence: 0.8,
+        reason: 'High cyclomatic complexity'
+      },
+      'magicNumbers': {
+        refactorType: 'replace-magic-number',
+        confidence: 0.9,
+        reason: 'Magic numbers should be replaced with constants'
+      },
+      'nestedConditionals': {
+        refactorType: 'decompose-conditional',
+        confidence: 0.85,
+        reason: 'Nested conditionals are hard to understand'
+      },
+      'longParameterList': {
+        refactorType: 'introduce-parameter-object',
+        confidence: 0.8,
+        reason: 'Parameter list is too long'
+      }
+    }
+
+    const refactorInfo = refactorMap[type]
+    if (!refactorInfo) return null
+
+    return {
+      filePath: fileResult.filePath,
+      language: fileResult.language,
+      issue: issue,
+      refactorType: refactorInfo.refactorType,
+      confidence: refactorInfo.confidence,
+      reason: refactorInfo.reason,
+      line: issue.line,
+      severity: severity
+    }
+  }
+
+  /**
+   * Detect code smells not covered by quality analyzer
+   */
+  detectCodeSmells(fileResult) {
+    const opportunities = []
+
+    // Read file content to analyze
+    // This would be implemented with actual file parsing
+
+    return opportunities
+  }
+
+  /**
+   * Generate refactoring suggestions
+   */
+  async generateSuggestions(opportunities, analysis) {
+    const suggestions = []
+
+    for (const opportunity of opportunities) {
+      // Get AI-powered suggestion
+      const aiSuggestion = await this.generateAISuggestion(opportunity, analysis)
+
+      // Enhance with pattern information
+      const pattern = this.refactorPatterns[opportunity.refactorType]
+      const suggestion = {
+        id: this.generateSuggestionId(),
+        ...opportunity,
+        title: this.generateTitle(opportunity, pattern),
+        description: pattern.description,
+        impact: pattern.impact,
+        complexity: pattern.complexity,
+        timeEstimate: pattern.timeEstimate,
+        steps: aiSuggestion.steps || this.generateDefaultSteps(opportunity.refactorType),
+        beforeCode: aiSuggestion.beforeCode,
+        afterCode: aiSuggestion.afterCode,
+        benefits: aiSuggestion.benefits || this.generateDefaultBenefits(opportunity.refactorType),
+        risks: aiSuggestion.risks || this.generateDefaultRisks(opportunity.refactorType),
+        testStrategy: aiSuggestion.testStrategy || this.generateDefaultTestStrategy(opportunity.refactorType),
+        dependencies: aiSuggestion.dependencies || [],
+        estimatedRisk: this.calculateRisk(opportunity, pattern),
+        aiConfidence: aiSuggestion.confidence || opportunity.confidence,
+        finalConfidence: (opportunity.confidence + (aiSuggestion.confidence || 0)) / 2
+      }
+
+      suggestions.push(suggestion)
+    }
+
+    // Sort by confidence and impact
+    suggestions.sort((a, b) => {
+      if (a.impact !== b.impact) {
+        const impactOrder = { high: 3, medium: 2, low: 1 }
+        return impactOrder[b.impact] - impactOrder[a.impact]
+      }
+      return b.finalConfidence - a.finalConfidence
+    })
+
+    return suggestions.slice(0, this.config.maxRefactorSuggestions)
+  }
+
+  /**
+   * Generate AI-powered suggestion
+   */
+  async generateAISuggestion(opportunity, analysis) {
+    const prompt = `
+      As an expert refactoring advisor, provide a detailed refactoring plan:
+
+      File: ${opportunity.filePath}
+      Language: ${opportunity.language}
+      Refactoring Type: ${opportunity.refactorType}
+      Issue: ${opportunity.reason}
+      Line: ${opportunity.line}
+
+      Provide a detailed refactoring suggestion in JSON format:
+      {
+        "steps": ["Step 1", "Step 2", "..."],
+        "beforeCode": "Code before refactoring",
+        "afterCode": "Code after refactoring",
+        "benefits": ["Benefit 1", "Benefit 2", "..."],
+        "risks": ["Risk 1", "Risk 2", "..."],
+        "testStrategy": "How to test this refactoring",
+        "confidence": 0.0-1.0
+      }
+
+      Make the steps actionable and specific.
+    `
+
+    try {
+      const response = await this.generateWithAI(prompt)
+      return JSON.parse(response)
+    } catch (error) {
+      console.warn(chalk.yellow(`⚠ AI suggestion failed, using template`))
+      return this.generateTemplateSuggestion(opportunity)
+    }
+  }
+
+  /**
+   * Generate template suggestion
+   */
+  generateTemplateSuggestion(opportunity) {
+    const pattern = this.refactorPatterns[opportunity.refactorType]
+
+    return {
+      steps: this.generateDefaultSteps(opportunity.refactorType),
+      benefits: this.generateDefaultBenefits(opportunity.refactorType),
+      risks: this.generateDefaultRisks(opportunity.refactorType),
+      testStrategy: this.generateDefaultTestStrategy(opportunity.refactorType),
+      confidence: 0.7
+    }
+  }
+
+  /**
+   * Generate default steps for refactoring type
+   */
+  generateDefaultSteps(refactorType) {
+    const stepMap = {
+      'extract-method': [
+        'Identify the section of code to extract',
+        'Create a new method with a descriptive name',
+        'Move the code to the new method',
+        'Replace the original code with a call to the new method',
+        'Pass parameters as needed',
+        'Update tests to cover the new method'
+      ],
+      'rename-variable': [
+        'Choose a more descriptive name',
+        'Find all occurrences of the variable',
+        'Rename all occurrences consistently',
+        'Update comments that reference the old name',
+        'Run tests to ensure no breakage'
+      ],
+      'remove-duplicate-code': [
+        'Identify the duplicate code section',
+        'Create a shared method or constant',
+        'Replace all instances with calls to the shared code',
+        'Ensure the shared code handles all use cases',
+        'Update tests accordingly'
+      ],
+      'simplify-conditional': [
+        'Analyze the complex conditional logic',
+        'Extract complex conditions into well-named methods',
+        'Use early returns to reduce nesting',
+        'Simplify boolean expressions',
+        'Add comments to explain the logic',
+        'Test all code paths'
+      ]
+    }
+
+    return stepMap[refactorType] || [
+      'Analyze the code to be refactored',
+      'Plan the refactoring approach',
+      'Implement the refactoring',
+      'Test thoroughly',
+      'Review the changes'
+    ]
+  }
+
+  /**
+   * Generate default benefits
+   */
+  generateDefaultBenefits(refactorType) {
+    const benefitMap = {
+      'extract-method': [
+        'Improved readability',
+        'Reduced code duplication',
+        'Easier to test individual methods',
+        'Better adherence to Single Responsibility Principle'
+      ],
+      'rename-variable': [
+        'Improved code readability',
+        'Reduced cognitive load',
+        'Easier maintenance',
+        'Self-documenting code'
+      ],
+      'remove-duplicate-code': [
+        'Reduced maintenance burden',
+        'Single source of truth',
+        'Easier bug fixes',
+        'Reduced code size'
+      ]
+    }
+
+    return benefitMap[refactorType] || [
+      'Improved code quality',
+      'Better maintainability',
+      'Enhanced readability'
+    ]
+  }
+
+  /**
+   * Generate default risks
+   */
+  generateDefaultRisks(refactorType) {
+    return [
+      'Potential to introduce bugs if not tested thoroughly',
+      'May affect existing code that depends on the current structure',
+      'Requires comprehensive testing',
+      'May need to update documentation'
+    ]
+  }
+
+  /**
+   * Generate default test strategy
+   */
+  generateDefaultTestStrategy(refactorType) {
+    return [
+      'Run existing test suite before refactoring',
+      'Write tests for the refactored code if not present',
+      'Run tests after each step of refactoring',
+      'Perform integration testing',
+      'Review test coverage'
+    ]
+  }
+
+  /**
+   * Generate suggestion title
+   */
+  generateTitle(opportunity, pattern) {
+    return `${this.titleCase(opportunity.refactorType)} in ${path.basename(opportunity.filePath)}`
+  }
+
+  /**
+   * Calculate risk for refactoring
+   */
+  calculateRisk(opportunity, pattern) {
+    let riskScore = 0
+
+    // Higher risk for high impact
+    if (pattern.impact === 'high') riskScore += 3
+    else if (pattern.impact === 'medium') riskScore += 2
+    else riskScore += 1
+
+    // Higher risk for high complexity
+    if (pattern.complexity === 'high') riskScore += 3
+    else if (pattern.complexity === 'medium') riskScore += 2
+    else riskScore += 1
+
+    // Adjust based on confidence (inverse relationship)
+    riskScore = riskScore * (1 - opportunity.confidence)
+
+    if (riskScore >= 5) return 'high'
+    if (riskScore >= 3) return 'medium'
+    return 'low'
+  }
+
+  /**
+   * Calculate average confidence
+   */
+  calculateAverageConfidence() {
+    if (this.refactorSuggestions.length === 0) return 0
+
+    const total = this.refactorSuggestions.reduce((sum, s) => sum + s.finalConfidence, 0)
+    return (total / this.refactorSuggestions.length).toFixed(2)
+  }
+
+  /**
+   * Generate comprehensive refactoring report
+   */
+  generateReport() {
+    const report = {
+      timestamp: new Date().toISOString(),
+      summary: {
+        totalOpportunities: this.stats.opportunitiesIdentified,
+        totalSuggestions: this.stats.suggestionsGenerated,
+        highImpactRefactors: this.stats.highImpactRefactors,
+        averageConfidence: this.stats.avgConfidence,
+        refactoringTypes: [...new Set(this.refactorSuggestions.map(s => s.refactorType))].length
+      },
+      suggestions: this.refactorSuggestions,
+      groupedByImpact: this.groupByImpact(),
+      phasedPlan: this.generatePhasedPlan(),
+      statistics: this.stats
+    }
+
+    return report
+  }
+
+  /**
+   * Group suggestions by impact
+   */
+  groupByImpact() {
+    const grouped = {
+      high: [],
+      medium: [],
+      low: []
+    }
+
+    this.refactorSuggestions.forEach(suggestion => {
+      grouped[suggestion.impact].push(suggestion)
+    })
+
+    return grouped
+  }
+
+  /**
+   * Generate phased refactoring plan
+   */
+  generatePhasedPlan() {
+    // Phase 1: Low risk, high confidence
+    const phase1 = this.refactorSuggestions.filter(s =>
+      s.estimatedRisk === 'low' && s.finalConfidence >= this.config.confidenceThreshold
+    )
+
+    // Phase 2: Medium risk or medium confidence
+    const phase2 = this.refactorSuggestions.filter(s =>
+      s.estimatedRisk === 'medium' && s.finalConfidence >= 0.7
+    )
+
+    // Phase 3: High risk or lower confidence
+    const phase3 = this.refactorSuggestions.filter(s =>
+      s.estimatedRisk === 'high' || s.finalConfidence < 0.7
+    )
+
+    return {
+      phase1: {
+        name: 'Quick Wins',
+        description: 'Low risk, high confidence refactoring',
+        suggestions: phase1,
+        estimatedTime: this.calculatePhaseTime(phase1)
+      },
+      phase2: {
+        name: 'Moderate Changes',
+        description: 'Medium risk, moderate impact refactoring',
+        suggestions: phase2,
+        estimatedTime: this.calculatePhaseTime(phase2)
+      },
+      phase3: {
+        name: 'Major Refactoring',
+        description: 'High risk, complex refactoring',
+        suggestions: phase3,
+        estimatedTime: this.calculatePhaseTime(phase3)
+      }
+    }
+  }
+
+  /**
+   * Calculate time for a phase
+   */
+  calculatePhaseTime(suggestions) {
+    const totalHours = suggestions.reduce((sum, s) => {
+      const hours = this.parseTimeEstimate(s.timeEstimate)
+      return sum + hours
+    }, 0)
+
+    if (totalHours < 1) return 'Less than 1 hour'
+    if (totalHours < 8) return `${Math.ceil(totalHours)} hours`
+    return `${Math.ceil(totalHours / 8)} days`
+  }
+
+  /**
+   * Parse time estimate string to hours
+   */
+  parseTimeEstimate(estimate) {
+    if (estimate.includes('minutes')) {
+      const match = estimate.match(/(\d+)/)
+      return match ? parseInt(match[1]) / 60 : 0.5
+    }
+    if (estimate.includes('hour')) {
+      const match = estimate.match(/(\d+)/)
+      return match ? parseInt(match[1]) : 1
+    }
+    if (estimate.includes('day')) {
+      const match = estimate.match(/(\d+)/)
+      return match ? parseInt(match[1]) * 8 : 8
+    }
+    return 1 // Default
+  }
+
+  /**
+   * Display refactoring suggestions
+   */
+  displaySuggestions(report) {
+    console.log(chalk.blue('\n' + '='.repeat(70)))
+    console.log(chalk.blue('🔧 REFACTORING ADVISOR REPORT'))
+    console.log(chalk.blue('='.repeat(70)))
+
+    // Summary
+    console.log(chalk.cyan('\n📊 Summary:'))
+    console.log(`  Opportunities Found: ${report.summary.totalOpportunities}`)
+    console.log(`  Suggestions Generated: ${report.summary.totalSuggestions}`)
+    console.log(`  High Impact Refactors: ${report.summary.highImpactRefactors}`)
+    console.log(`  Average Confidence: ${report.summary.averageConfidence}`)
+    console.log(`  Refactoring Types: ${report.summary.refactoringTypes}`)
+
+    // Phased plan
+    console.log(chalk.cyan('\n📋 Phased Refactoring Plan:'))
+    Object.entries(report.phasedPlan).forEach(([phaseKey, phase]) => {
+      if (phase.suggestions.length === 0) return
+
+      console.log(chalk.green(`\n  ${phase.name}:`))
+      console.log(`    ${phase.description}`)
+      console.log(`    Estimated Time: ${phase.estimatedTime}`)
+      console.log(`    Suggestions: ${phase.suggestions.length}`)
+
+      // Show top 3 suggestions
+      phase.suggestions.slice(0, 3).forEach(s => {
+        console.log(chalk.yellow(`    • ${s.title}`))
+      })
+
+      if (phase.suggestions.length > 3) {
+        console.log(`    ... and ${phase.suggestions.length - 3} more`)
+      }
+    })
+
+    // Top suggestions
+    console.log(chalk.cyan('\n⭐ Top Suggestions:'))
+    report.suggestions.slice(0, 5).forEach((s, i) => {
+      console.log(chalk.green(`\n  ${i + 1}. ${s.title}`))
+      console.log(`     Type: ${s.refactorType}`)
+      console.log(`     Impact: ${s.impact}, Risk: ${s.estimatedRisk}`)
+      console.log(`     Confidence: ${(s.finalConfidence * 100).toFixed(0)}%`)
+      console.log(`     Time: ${s.timeEstimate}`)
+      console.log(`     Steps: ${s.steps.length} steps`)
+    })
+
+    console.log(chalk.blue('\n' + '='.repeat(70)))
+  }
+
+  /**
+   * Export report
+   */
+  async exportReport(report, format = 'json', outputPath) {
+    if (!outputPath) {
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-')
+      outputPath = path.join(process.cwd(), `refactor-report-${timestamp}.${format}`)
+    }
+
+    if (format === 'json') {
+      await fs.writeJson(outputPath, report, { spaces: 2 })
+    } else if (format === 'markdown') {
+      const markdown = this.generateMarkdownReport(report)
+      await fs.writeFile(outputPath, markdown)
+    }
+
+    console.log(chalk.green(`✓ Report exported to: ${outputPath}`))
+  }
+
+  /**
+   * Generate Markdown report
+   */
+  generateMarkdownReport(report) {
+    let markdown = `# Refactoring Advisor Report
+
+Generated: ${report.timestamp}
+
+## Summary
+
+- **Total Opportunities:** ${report.summary.totalOpportunities}
+- **Suggestions Generated:** ${report.summary.totalSuggestions}
+- **High Impact Refactors:** ${report.summary.highImpactRefactors}
+- **Average Confidence:** ${report.summary.averageConfidence}
+- **Refactoring Types:** ${report.summary.refactoringTypes}
+
+## Phased Plan
+
+`
+
+    Object.entries(report.phasedPlan).forEach(([phaseKey, phase]) => {
+      if (phase.suggestions.length === 0) return
+
+      markdown += `### ${phase.name}\n\n`
+      markdown += `${phase.description}\n\n`
+      markdown += `**Estimated Time:** ${phase.estimatedTime}\n\n`
+      markdown += `**Suggestions:** ${phase.suggestions.length}\n\n`
+
+      phase.suggestions.forEach(s => {
+        markdown += `#### ${s.title}\n\n`
+        markdown += `- **Type:** ${s.refactorType}\n`
+        markdown += `- **Impact:** ${s.impact}\n`
+        markdown += `- **Risk:** ${s.estimatedRisk}\n`
+        markdown += `- **Confidence:** ${(s.finalConfidence * 100).toFixed(0)}%\n`
+        markdown += `- **Time Estimate:** ${s.timeEstimate}\n\n`
+        markdown += `**Description:** ${s.description}\n\n`
+        markdown += `**Steps:**\n`
+        s.steps.forEach(step => markdown += `1. ${step}\n`)
+        markdown += `\n`
+      })
+    })
+
+    return markdown
+  }
+
+  /**
+   * Generate suggestion ID
+   */
+  generateSuggestionId() {
+    return `REF-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
+  }
+
+  /**
+   * Title case helper
+   */
+  titleCase(str) {
+    return str.replace(/-/g, ' ')
+      .split(' ')
+      .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+      .join(' ')
+  }
+
+  /**
+   * Generate with AI
+   */
+  async generateWithAI(prompt) {
+    // Try OpenAI first
+    if (this.openai) {
+      try {
+        const response = await this.openai.chat.completions.create({
+          model: 'gpt-4',
+          messages: [{ role: 'user', content: prompt }],
+          temperature: 0.7,
+          max_tokens: 2000
+        })
+        return response.choices[0].message.content
+      } catch (error) {
+        console.warn(chalk.yellow('OpenAI failed, trying Anthropic...'))
+      }
+    }
+
+    // Try Anthropic
+    if (this.anthropic) {
+      try {
+        const response = await this.anthropic.messages.create({
+          model: 'claude-3-5-sonnet-20241022',
+          max_tokens: 2000,
+          messages: [{ role: 'user', content: prompt }]
+        })
+        return response.content[0].text
+      } catch (error) {
+        console.warn(chalk.yellow('Anthropic failed, using mock mode'))
+      }
+    }
+
+    // Mock mode
+    return JSON.stringify({
+      steps: ['Step 1', 'Step 2', 'Step 3'],
+      benefits: ['Improved code quality'],
+      risks: ['May need comprehensive testing'],
+      testStrategy: 'Run all tests before and after',
+      confidence: 0.8
+    })
+  }
+}
+
+module.exports = AIRefactorAdvisor