code-simplifier 1.1.0 → 1.2.0

package/lib/ai-auto-fix.js

@@ -0,0 +1,829 @@
+#!/usr/bin/env node
+
+/**
+ * AI-Powered Code Auto-Fix Engine
+ * Intelligently fixes code issues using AI analysis
+ */
+
+const fs = require('fs-extra')
+const path = require('path')
+const chalk = require('chalk')
+const ora = require('ora')
+const { OpenAI } = require('openai')
+const Anthropic = require('@anthropic-ai/sdk')
+const aiQualityAnalyzer = require('./ai-quality-analyzer')
+
+class AIAutoFix {
+  constructor() {
+    this.openai = null
+    this.anthropic = null
+    this.useMockMode = false
+    this.fixHistory = []
+    this.rollbackStack = []
+    this.initClients()
+  }
+
+  /**
+   * Initialize AI API clients
+   */
+  initClients() {
+    try {
+      if (process.env.OPENAI_API_KEY) {
+        this.openai = new OpenAI({
+          apiKey: process.env.OPENAI_API_KEY
+        })
+      }
+
+      if (process.env.ANTHROPIC_API_KEY) {
+        this.anthropic = new Anthropic({
+          apiKey: process.env.ANTHROPIC_API_KEY
+        })
+      }
+
+      if (!this.openai && !this.anthropic) {
+        console.log(chalk.yellow('⚠️  No AI API keys found, using mock mode'))
+        this.useMockMode = true
+      }
+    } catch (error) {
+      console.log(chalk.yellow('⚠️  Failed to initialize AI clients, using mock mode'))
+      this.useMockMode = true
+    }
+  }
+
+  /**
+   * Run AI auto-fix
+   */
+  async run(options = {}) {
+    console.log(chalk.blue.bold('\n🤖 AI-Powered Auto-Fix Engine'))
+    console.log(chalk.gray('='.repeat(70)))
+
+    const spinner = ora(chalk.blue('正在初始化AI修复引擎...')).start()
+
+    try {
+      const {
+        dir = '.',
+        pattern = '**/*.{js,ts,jsx,tsx,py,java,cs,cpp,php,rb,go,rs,swift,kt}',
+        dryRun = true,
+        aiProvider = 'auto',
+        maxIterations = 10
+      } = options
+
+      // 1. Analyze code using AI
+      spinner.text = chalk.blue('正在使用AI分析代码质量...')
+      const analysisResults = await this.analyzeCode(dir, pattern)
+      spinner.info(chalk.gray(`分析完成: ${analysisResults.files.length} 个文件`))
+
+      // 2. Generate AI-powered fixes
+      spinner.text = chalk.blue('正在生成AI修复建议...')
+      const fixes = await this.generateAIFixes(analysisResults, { aiProvider })
+
+      if (fixes.length === 0) {
+        spinner.succeed(chalk.green('没有发现需要修复的问题'))
+        return {
+          success: true,
+          dryRun,
+          totalIssues: 0,
+          fixes: []
+        }
+      }
+
+      // 3. Preview mode - show fixes before applying
+      if (dryRun) {
+        spinner.info(chalk.yellow('预览模式 - 显示修复建议'))
+        const preview = await this.previewFixes(fixes)
+        return {
+          success: true,
+          dryRun: true,
+          totalIssues: fixes.length,
+          fixes: preview
+        }
+      }
+
+      // 4. Execution mode - apply fixes
+      spinner.text = chalk.blue('正在应用AI修复...')
+      const result = await this.applyAIFixes(fixes, { maxIterations })
+
+      spinner.succeed(chalk.green('AI修复完成'))
+      return result
+
+    } catch (error) {
+      spinner.fail(chalk.red('AI修复失败'))
+      console.error(chalk.red(error))
+      throw error
+    }
+  }
+
+  /**
+   * Analyze code using AI quality analyzer
+   */
+  async analyzeCode(dir, pattern) {
+    return await aiQualityAnalyzer.run({
+      dir,
+      pattern,
+      aiProvider: 'auto',
+      outputFormat: 'json'
+    })
+  }
+
+  /**
+   * Generate AI-powered fixes based on analysis
+   */
+  async generateAIFixes(analysisResults, options = {}) {
+    const fixes = []
+
+    for (const fileResult of analysisResults.files) {
+      if (!fileResult.issues || fileResult.issues.length === 0) continue
+
+      const fileFixes = await this.generateFixesForFile(fileResult, options)
+      fixes.push(...fileFixes)
+    }
+
+    return fixes
+  }
+
+  /**
+   * Generate fixes for a single file
+   */
+  async generateFixesForFile(fileResult, options = {}) {
+    const fixes = []
+    const { aiProvider = 'auto' } = options
+
+    try {
+      const filePath = fileResult.file
+      const originalContent = await fs.readFile(filePath, 'utf8')
+
+      // Group issues by type
+      const issuesByType = this.groupIssuesByType(fileResult.issues)
+
+      for (const [issueType, issues] of Object.entries(issuesByType)) {
+        // Generate fix using AI
+        const fix = await this.generateFixForIssueType(
+          filePath,
+          originalContent,
+          issueType,
+          issues,
+          aiProvider
+        )
+
+        if (fix) {
+          fixes.push(fix)
+        }
+      }
+    } catch (error) {
+      console.error(chalk.red(`生成修复失败 (${fileResult.file}):`), error.message)
+    }
+
+    return fixes
+  }
+
+  /**
+   * Group issues by type
+   */
+  groupIssuesByType(issues) {
+    const grouped = {}
+
+    for (const issue of issues) {
+      const type = issue.type || 'unknown'
+      if (!grouped[type]) {
+        grouped[type] = []
+      }
+      grouped[type].push(issue)
+    }
+
+    return grouped
+  }
+
+  /**
+   * Generate fix for a specific issue type using AI
+   */
+  async generateFixForIssueType(filePath, content, issueType, issues, aiProvider) {
+    const language = this.detectLanguage(filePath)
+
+    if (this.useMockMode) {
+      return this.generateMockFix(filePath, content, issueType, issues, language)
+    }
+
+    try {
+      const prompt = this.buildFixPrompt(filePath, content, issueType, issues, language)
+
+      if (aiProvider === 'openai' && this.openai) {
+        return await this.generateFixWithOpenAI(prompt, filePath, content, issueType, issues)
+      } else if (aiProvider === 'anthropic' && this.anthropic) {
+        return await this.generateFixWithAnthropic(prompt, filePath, content, issueType, issues)
+      } else {
+        // Auto-select provider
+        return this.openai
+          ? await this.generateFixWithOpenAI(prompt, filePath, content, issueType, issues)
+          : await this.generateFixWithAnthropic(prompt, filePath, content, issueType, issues)
+      }
+    } catch (error) {
+      console.error(chalk.yellow(`AI修复生成失败，使用规则修复: ${error.message}`))
+      return this.generateRuleBasedFix(filePath, content, issueType, issues, language)
+    }
+  }
+
+  /**
+   * Build fix prompt for AI
+   */
+  buildFixPrompt(filePath, content, issueType, issues, language) {
+    const issueDescriptions = issues.map(issue => {
+      return `- Line ${issue.line}: ${issue.message} (${issue.severity})`
+    }).join('\n')
+
+    return `As an expert ${language} code reviewer, analyze the following code and provide a fix.
+
+File: ${filePath}
+Language: ${language}
+Issue Type: ${issueType}
+
+Issues found:
+${issueDescriptions}
+
+Original Code:
+\`\`\`${language}
+${content}
+\`\`\`
+
+Please provide a JSON response with the following structure:
+{
+  "fixDescription": "Brief description of what will be fixed",
+  "reasoning": "Why this fix improves the code",
+  "changes": [
+    {
+      "type": "replace|add|remove",
+      "line": number,
+      "original": "original code snippet",
+      "fixed": "fixed code snippet",
+      "explanation": "why this change was made"
+    }
+  ],
+  "preservedComments": ["list of comments that were preserved"],
+  "preservedLogic": "description of logic preserved"
+}
+
+IMPORTANT:
+- Preserve all comments and docstrings
+- Maintain original code logic and functionality
+- Fix only the identified issues
+- Provide specific line-by-line changes
+- Ensure the fix is safe and correct`
+  }
+
+  /**
+   * Generate fix using OpenAI
+   */
+  async generateFixWithOpenAI(prompt, filePath, content, issueType, issues) {
+    const completion = await this.openai.chat.completions.create({
+      model: 'gpt-4',
+      messages: [
+        {
+          role: 'system',
+          content: 'You are an expert code reviewer and refactoring specialist. Always respond with valid JSON.'
+        },
+        {
+          role: 'user',
+          content: prompt
+        }
+      ],
+      temperature: 0.2,
+      max_tokens: 2000
+    })
+
+    const response = completion.choices[0].message.content
+    return this.parseAIResponse(response, filePath, content, issueType, issues)
+  }
+
+  /**
+   * Generate fix using Anthropic
+   */
+  async generateFixWithAnthropic(prompt, filePath, content, issueType, issues) {
+    const response = await this.anthropic.messages.create({
+      model: 'claude-3-sonnet-20240229',
+      max_tokens: 2000,
+      temperature: 0.2,
+      messages: [
+        {
+          role: 'user',
+          content: prompt
+        }
+      ]
+    })
+
+    const responseText = response.content[0].text
+    return this.parseAIResponse(responseText, filePath, content, issueType, issues)
+  }
+
+  /**
+   * Parse AI response
+   */
+  parseAIResponse(responseText, filePath, content, issueType, issues) {
+    try {
+      // Extract JSON from response
+      const jsonMatch = responseText.match(/\{[\s\S]*\}/)
+      if (!jsonMatch) {
+        throw new Error('No JSON found in response')
+      }
+
+      const parsed = JSON.parse(jsonMatch[0])
+
+      return {
+        file: filePath,
+        issueType,
+        issues,
+        description: parsed.fixDescription || `Fix ${issueType}`,
+        reasoning: parsed.reasoning || 'AI-generated fix',
+        changes: parsed.changes || [],
+        preservedComments: parsed.preservedComments || [],
+        preservedLogic: parsed.preservedLogic || '',
+        confidence: 0.9
+      }
+    } catch (error) {
+      console.error(chalk.yellow('解析AI响应失败:', error.message))
+      return null
+    }
+  }
+
+  /**
+   * Generate mock fix for testing
+   */
+  generateMockFix(filePath, content, issueType, issues, language) {
+    const mockFixes = {
+      'long-function': {
+        description: 'Extract long function into smaller functions',
+        reasoning: 'Breaking down long functions improves readability and maintainability',
+        changes: [
+          {
+            type: 'replace',
+            line: issues[0].line,
+            original: 'function longFunction() {',
+            fixed: 'function shorterFunction() {',
+            explanation: 'Extracted to smaller function'
+          }
+        ],
+        preservedComments: [],
+        preservedLogic: 'All original logic preserved'
+      },
+      'bad-variable-names': {
+        description: 'Rename variables to be more descriptive',
+        reasoning: 'Descriptive variable names improve code readability',
+        changes: [
+          {
+            type: 'replace',
+            line: issues[0].line,
+            original: 'let x = 10',
+            fixed: 'let userAge = 10',
+            explanation: 'Renamed for clarity'
+          }
+        ],
+        preservedComments: [],
+        preservedLogic: 'All original logic preserved'
+      },
+      'high-complexity': {
+        description: 'Simplify complex conditional logic',
+        reasoning: 'Reducing complexity improves code maintainability',
+        changes: [
+          {
+            type: 'replace',
+            line: issues[0].line,
+            original: 'if (a && b && c && d) {',
+            fixed: 'if (isValidCondition(a, b, c, d)) {',
+            explanation: 'Extracted condition to named function'
+          }
+        ],
+        preservedComments: [],
+        preservedLogic: 'All original logic preserved'
+      }
+    }
+
+    const mockFix = mockFixes[issueType] || {
+      description: `Fix ${issueType} issues`,
+      reasoning: 'Automated AI fix',
+      changes: [],
+      preservedComments: [],
+      preservedLogic: 'All original logic preserved'
+    }
+
+    return {
+      file: filePath,
+      issueType,
+      issues,
+      ...mockFix,
+      confidence: 0.7
+    }
+  }
+
+  /**
+   * Generate rule-based fix as fallback
+   */
+  generateRuleBasedFix(filePath, content, issueType, issues, language) {
+    const ruleFixes = {
+      'trailing-space': (filePath, content, issues) => {
+        let fixed = content
+        const changes = []
+
+        for (const issue of issues) {
+          const lines = fixed.split('\n')
+          if (lines[issue.line - 1]) {
+            const original = lines[issue.line - 1]
+            const fixedLine = original.replace(/[ \t]+$/, '')
+            if (original !== fixedLine) {
+              lines[issue.line - 1] = fixedLine
+              changes.push({
+                type: 'replace',
+                line: issue.line,
+                original: original,
+                fixed: fixedLine,
+                explanation: 'Remove trailing whitespace'
+              })
+            }
+          }
+        }
+
+        return {
+          description: 'Remove trailing whitespace',
+          reasoning: 'Cleaning up formatting issues',
+          changes,
+          preservedComments: [],
+          preservedLogic: 'No logic changes'
+        }
+      },
+      'console-log': (filePath, content, issues) => {
+        let fixed = content
+        const changes = []
+
+        for (const issue of issues) {
+          const lines = fixed.split('\n')
+          if (lines[issue.line - 1] && lines[issue.line - 1].includes('console.log')) {
+            const original = lines[issue.line - 1]
+            lines[issue.line - 1] = original.replace(
+              /console\.log\([^)]*\);?/,
+              '// TODO: Remove console.log'
+            )
+            changes.push({
+              type: 'replace',
+              line: issue.line,
+              original: original,
+              fixed: lines[issue.line - 1],
+              explanation: 'Comment out console.log'
+            })
+          }
+        }
+
+        return {
+          description: 'Comment out console statements',
+          reasoning: 'Remove debug statements',
+          changes,
+          preservedComments: [],
+          preservedLogic: 'No logic changes'
+        }
+      },
+      'var-declaration': (filePath, content, issues) => {
+        let fixed = content
+        const changes = []
+
+        for (const issue of issues) {
+          const lines = fixed.split('\n')
+          if (lines[issue.line - 1] && lines[issue.line - 1].trim().startsWith('var ')) {
+            const original = lines[issue.line - 1]
+            lines[issue.line - 1] = original.replace(/^(\s*)var\s+/, '$1let ')
+            changes.push({
+              type: 'replace',
+              line: issue.line,
+              original: original,
+              fixed: lines[issue.line - 1],
+              explanation: 'Replace var with let'
+            })
+          }
+        }
+
+        return {
+          description: 'Replace var with let/const',
+          reasoning: 'Use modern JavaScript declarations',
+          changes,
+          preservedComments: [],
+          preservedLogic: 'No logic changes'
+        }
+      }
+    }
+
+    const ruleFix = ruleFixes[issueType]
+
+    if (ruleFix) {
+      return {
+        file: filePath,
+        issueType,
+        issues,
+        ...ruleFix(filePath, content, issues),
+        confidence: 0.8
+      }
+    }
+
+    return null
+  }
+
+  /**
+   * Preview fixes before applying
+   */
+  async previewFixes(fixes) {
+    console.log(chalk.blue.bold('\n📋 AI修复预览'))
+    console.log(chalk.gray('='.repeat(70)))
+
+    const preview = []
+
+    for (const fix of fixes) {
+      console.log(chalk.cyan(`\n文件: ${fix.file}`))
+      console.log(chalk.yellow(`问题类型: ${fix.issueType}`))
+      console.log(`描述: ${fix.description}`)
+      console.log(chalk.gray(`推理: ${fix.reasoning}`))
+      console.log(chalk.gray(`可信度: ${(fix.confidence * 100).toFixed(0)}%`))
+
+      if (fix.changes && fix.changes.length > 0) {
+        console.log(chalk.blue('\n变更详情:'))
+        fix.changes.forEach((change, index) => {
+          console.log(`  ${index + 1}. Line ${change.line}: ${change.type}`)
+          if (change.original) {
+            console.log(chalk.red(`     - ${change.original.substring(0, 50)}...`))
+          }
+          if (change.fixed) {
+            console.log(chalk.green(`     + ${change.fixed.substring(0, 50)}...`))
+          }
+          console.log(chalk.gray(`     ${change.explanation}`))
+        })
+      }
+
+      if (fix.preservedComments && fix.preservedComments.length > 0) {
+        console.log(chalk.blue('\n保留的注释:'))
+        fix.preservedComments.forEach(comment => {
+          console.log(chalk.green(`  + ${comment}`))
+        })
+      }
+
+      preview.push({
+        ...fix,
+        willApply: true
+      })
+    }
+
+    return preview
+  }
+
+  /**
+   * Apply AI-powered fixes
+   */
+  async applyAIFixes(fixes, options = {}) {
+    const { maxIterations = 10 } = options
+    const appliedFixes = []
+    const failedFixes = []
+    const rollbackData = []
+
+    try {
+      // Create rollback point
+      await this.createRollbackPoint()
+
+      // Group fixes by file
+      const fixesByFile = this.groupFixesByFile(fixes)
+
+      // Apply fixes
+      for (const [filePath, fileFixes] of Object.entries(fixesByFile)) {
+        try {
+          const result = await this.applyFixesToFile(filePath, fileFixes)
+          appliedFixes.push(...result.applied)
+          rollbackData.push(...result.rollbackData)
+        } catch (error) {
+          console.error(chalk.red(`应用修复失败 (${filePath}):`), error.message)
+          failedFixes.push({ file: filePath, error: error.message })
+        }
+      }
+
+      // Generate report
+      const report = this.generateFixReport({
+        totalFixes: fixes.length,
+        applied: appliedFixes.length,
+        failed: failedFixes.length,
+        fixes: appliedFixes,
+        failedFixes
+      })
+
+      // Save report
+      await this.saveReport(report)
+
+      return {
+        success: true,
+        totalIssues: fixes.length,
+        applied: appliedFixes.length,
+        failed: failedFixes.length,
+        fixes: appliedFixes,
+        failedFixes,
+        report
+      }
+
+    } catch (error) {
+      // Rollback on error
+      console.error(chalk.red('修复过程中发生错误，正在回滚...'))
+      await this.rollback()
+      throw error
+    }
+  }
+
+  /**
+   * Group fixes by file
+   */
+  groupFixesByFile(fixes) {
+    const grouped = {}
+
+    for (const fix of fixes) {
+      if (!grouped[fix.file]) {
+        grouped[fix.file] = []
+      }
+      grouped[fix.file].push(fix)
+    }
+
+    return grouped
+  }
+
+  /**
+   * Apply fixes to a single file
+   */
+  async applyFixesToFile(filePath, fixes) {
+    const originalContent = await fs.readFile(filePath, 'utf8')
+    let fixedContent = originalContent
+    const applied = []
+    const rollbackData = []
+
+    // Sort fixes by line number (descending to avoid offset issues)
+    const allChanges = []
+    for (const fix of fixes) {
+      for (const change of fix.changes) {
+        allChanges.push({
+          ...change,
+          issueType: fix.issueType,
+          description: fix.description
+        })
+      }
+    }
+
+    allChanges.sort((a, b) => b.line - a.line)
+
+    // Apply changes
+    for (const change of allChanges) {
+      try {
+        const lines = fixedContent.split('\n')
+
+        if (change.line > 0 && change.line <= lines.length) {
+          const originalLine = lines[change.line - 1]
+
+          // Store for rollback
+          rollbackData.push({
+            file: filePath,
+            line: change.line,
+            original: originalLine
+          })
+
+          // Apply change
+          if (change.type === 'replace') {
+            lines[change.line - 1] = change.fixed
+          } else if (change.type === 'remove') {
+            lines.splice(change.line - 1, 1)
+          } else if (change.type === 'add') {
+            lines.splice(change.line - 1, 0, change.fixed)
+          }
+
+          fixedContent = lines.join('\n')
+          applied.push(change)
+        }
+      } catch (error) {
+        console.error(chalk.yellow(`应用变更失败: ${error.message}`))
+      }
+    }
+
+    // Write fixed content
+    await fs.writeFile(filePath, fixedContent, 'utf8')
+
+    return {
+      applied,
+      rollbackData
+    }
+  }
+
+  /**
+   * Create rollback point
+   */
+  async createRollbackPoint() {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-')
+    const rollbackDir = path.join('.rollback', timestamp)
+
+    await fs.ensureDir(rollbackDir)
+    this.rollbackStack.push(rollbackDir)
+
+    return rollbackDir
+  }
+
+  /**
+   * Rollback changes
+   */
+  async rollback() {
+    if (this.rollbackStack.length === 0) {
+      console.log(chalk.yellow('没有可回滚的更改'))
+      return
+    }
+
+    const rollbackDir = this.rollbackStack.pop()
+    console.log(chalk.blue(`回滚到: ${rollbackDir}`))
+    // In a full implementation, this would restore files from rollbackDir
+  }
+
+  /**
+   * Generate fix report
+   */
+  generateFixReport(result) {
+    const timestamp = new Date().toLocaleString()
+
+    let report = `# AI自动修复报告\n\n`
+    report += `**生成时间**: ${timestamp}\n`
+    report += `**执行模式**: 实际修复\n\n`
+
+    report += `## 统计\n\n`
+    report += `- 总问题数: ${result.totalFixes}\n`
+    report += `- 已修复: ${result.applied}\n`
+    report += `- 失败: ${result.failed}\n\n`
+
+    if (result.fixes.length > 0) {
+      report += `## 修复详情\n\n`
+
+      const fixesByFile = {}
+      for (const fix of result.fixes) {
+        if (!fixesByFile[fix.file]) {
+          fixesByFile[fix.file] = []
+        }
+        fixesByFile[fix.file].push(fix)
+      }
+
+      for (const [file, fileFixes] of Object.entries(fixesByFile)) {
+        report += `### ${file}\n\n`
+
+        fileFixes.forEach((fix, index) => {
+          report += `${index + 1}. **Line ${fix.line}** - ${fix.type}\n`
+          report += `   - 问题类型: ${fix.issueType}\n`
+          report += `   - 描述: ${fix.description}\n`
+          report += `   - 解释: ${fix.explanation}\n\n`
+        })
+      }
+    }
+
+    if (result.failedFixes.length > 0) {
+      report += `## 修复失败\n\n`
+      result.failedFixes.forEach(failed => {
+        report += `- **${failed.file}**: ${failed.error}\n`
+      })
+      report += `\n`
+    }
+
+    report += `---\n*由 Code-Simplifier AI 自动修复生成*\n`
+
+    return report
+  }
+
+  /**
+   * Save report to file
+   */
+  async saveReport(report) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-')
+    const reportPath = path.join('reports', `ai-fix-report-${timestamp}.md`)
+
+    await fs.ensureDir(path.dirname(reportPath))
+    await fs.writeFile(reportPath, report, 'utf8')
+
+    console.log(chalk.blue(`报告已保存: ${reportPath}`))
+
+    return reportPath
+  }
+
+  /**
+   * Detect programming language from file extension
+   */
+  detectLanguage(filePath) {
+    const ext = path.extname(filePath).toLowerCase()
+
+    const languageMap = {
+      '.js': 'javascript',
+      '.jsx': 'javascript',
+      '.ts': 'typescript',
+      '.tsx': 'typescript',
+      '.py': 'python',
+      '.java': 'java',
+      '.cs': 'csharp',
+      '.cpp': 'cpp',
+      '.c': 'c',
+      '.php': 'php',
+      '.rb': 'ruby',
+      '.go': 'go',
+      '.rs': 'rust',
+      '.swift': 'swift',
+      '.kt': 'kotlin'
+    }
+
+    return languageMap[ext] || 'text'
+  }
+}
+
+module.exports = new AIAutoFix()