@chongyan/autospec 1.0.1

package/plugins/hooks/lib/test-failure-analyzer.js

@@ -0,0 +1,375 @@
+/**
+ * Failure Analyzer - 分析失败原因、分类错误
+ *
+ * 从 src/core/test/test-failure-analyzer.js 迁移
+ * 此文件是 hooks 模块的一部分，可独立运行于目标项目中。
+ */
+
+import { execSync } from 'child_process';
+
+/**
+ * 错误分类
+ */
+export const ERROR_TYPES = {
+  SYNTAX: 'syntax',           // 语法错误
+  IMPORT: 'import',           // 导入错误
+  REFERENCE: 'reference',    // 引用错误
+  TYPE: 'type',              // 类型错误
+  LOGIC: 'logic',            // 逻辑错误
+  TEST: 'test',              // 测试失败
+  RUNTIME: 'runtime',         // 运行时错误
+  UNKNOWN: 'unknown'         // 未知错误
+};
+
+/**
+ * 错误严重级别
+ */
+export const SEVERITY = {
+  LOW: 'low',       // 低：格式、拼写
+  MEDIUM: 'medium', // 中：逻辑、边界
+  HIGH: 'high',     // 高：安全、性能
+  CRITICAL: 'critical' // 严重：数据丢失、安全漏洞
+};
+
+/**
+ * 错误分类规则
+ */
+const ERROR_PATTERNS = [
+  {
+    type: ERROR_TYPES.SYNTAX,
+    patterns: [
+      /SyntaxError/,
+      /unexpected token/,
+      /unexpected character/,
+      /unterminated string/,
+      /missing (?:semicolon|parentheses|brackets|brace)/
+    ],
+    severity: SEVERITY.HIGH,
+    autoFixable: true
+  },
+  {
+    type: ERROR_TYPES.IMPORT,
+    patterns: [
+      /Cannot find module/,
+      /Cannot resolve/,
+      /module not found/,
+      /import.*failed/
+    ],
+    severity: SEVERITY.HIGH,
+    autoFixable: true
+  },
+  {
+    type: ERROR_TYPES.REFERENCE,
+    patterns: [
+      /is not defined/,
+      /is not a function/,
+      /is not an (?:object|function)/,
+      /undefined (?:is not|has no)/
+    ],
+    severity: SEVERITY.HIGH,
+    autoFixable: false
+  },
+  {
+    type: ERROR_TYPES.TYPE,
+    patterns: [
+      /TypeError/,
+      /is not a type/,
+      /type mismatch/
+    ],
+    severity: SEVERITY.HIGH,
+    autoFixable: false
+  },
+  {
+    type: ERROR_TYPES.RUNTIME,
+    patterns: [
+      /RuntimeError/,
+      /Error:/,
+      /Exception:/
+    ],
+    severity: SEVERITY.MEDIUM,
+    autoFixable: false
+  },
+  {
+    type: ERROR_TYPES.TEST,
+    patterns: [
+      /expect.*toBe/,
+      /expect.*toEqual/,
+      /AssertionError/,
+      /FAIL.*test/,
+      /×/
+    ],
+    severity: SEVERITY.MEDIUM,
+    autoFixable: false
+  }
+];
+
+/**
+ * 分析测试失败
+ * @param {Object} testResult - 测试结果
+ * @returns {Object} 分析结果
+ */
+export function analyzeFailures(testResult) {
+  const { errors = [], files = [] } = testResult;
+
+  if (errors.length === 0) {
+    return {
+      hasErrors: false,
+      errorCount: 0,
+      classifiedErrors: [],
+      severity: null,
+      summary: 'No errors found',
+      suggestions: []
+    };
+  }
+
+  // 分类错误
+  const classifiedErrors = errors.map(error => classifyError(error));
+
+  // 计算总体严重级别
+  const severity = calculateOverallSeverity(classifiedErrors);
+
+  // 按类型分组
+  const byType = groupByType(classifiedErrors);
+
+  // 按文件分组
+  const byFile = groupByFile(classifiedErrors);
+
+  // 生成修复建议
+  const suggestions = generateSuggestions(classifiedErrors);
+
+  return {
+    hasErrors: true,
+    errorCount: errors.length,
+    classifiedErrors,
+    severity,
+    byType,
+    byFile,
+    suggestions,
+    summary: `${errors.length} errors found (${severity} severity)`
+  };
+}
+
+/**
+ * 分类单个错误
+ */
+function classifyError(error) {
+  const message = error.message || error.toString();
+
+  for (const rule of ERROR_PATTERNS) {
+    for (const pattern of rule.patterns) {
+      if (pattern.test(message)) {
+        return {
+          ...error,
+          type: rule.type,
+          severity: rule.severity,
+          autoFixable: rule.autoFixable,
+          originalMessage: message
+        };
+      }
+    }
+  }
+
+  // 未匹配到任何规则
+  return {
+    ...error,
+    type: ERROR_TYPES.UNKNOWN,
+    severity: SEVERITY.MEDIUM,
+    autoFixable: false,
+    originalMessage: message
+  };
+}
+
+/**
+ * 计算总体严重级别
+ */
+function calculateOverallSeverity(errors) {
+  if (errors.some(e => e.severity === SEVERITY.CRITICAL)) {
+    return SEVERITY.CRITICAL;
+  }
+  if (errors.some(e => e.severity === SEVERITY.HIGH)) {
+    return SEVERITY.HIGH;
+  }
+  if (errors.some(e => e.severity === SEVERITY.MEDIUM)) {
+    return SEVERITY.MEDIUM;
+  }
+  return SEVERITY.LOW;
+}
+
+/**
+ * 按类型分组
+ */
+function groupByType(errors) {
+  const groups = {};
+
+  for (const error of errors) {
+    if (!groups[error.type]) {
+      groups[error.type] = [];
+    }
+    groups[error.type].push(error);
+  }
+
+  return groups;
+}
+
+/**
+ * 按文件分组
+ */
+function groupByFile(errors) {
+  const groups = {};
+
+  for (const error of errors) {
+    const file = error.file || 'unknown';
+    if (!groups[file]) {
+      groups[file] = [];
+    }
+    groups[file].push(error);
+  }
+
+  return groups;
+}
+
+/**
+ * 生成修复建议
+ */
+function generateSuggestions(errors) {
+  const suggestions = [];
+
+  for (const error of errors) {
+    const suggestion = generateSingleSuggestion(error);
+    if (suggestion) {
+      suggestions.push(suggestion);
+    }
+  }
+
+  return suggestions;
+}
+
+/**
+ * 生成单个错误的修复建议
+ */
+function generateSingleSuggestion(error) {
+  const { type, autoFixable, file, originalMessage } = error;
+
+  const base = {
+    file,
+    errorType: type,
+    autoFixable,
+    message: originalMessage
+  };
+
+  switch (type) {
+    case ERROR_TYPES.SYNTAX:
+      return {
+        ...base,
+        action: 'fix_syntax',
+        description: '语法错误，需要修复代码语法',
+        fixable: autoFixable,
+        fixCommand: file ? `node --check ${file}` : null
+      };
+
+    case ERROR_TYPES.IMPORT:
+      return {
+        ...base,
+        action: 'fix_import',
+        description: '导入错误，检查模块路径和依赖安装',
+        fixable: autoFixable,
+        fixCommand: 'npm install'
+      };
+
+    case ERROR_TYPES.REFERENCE:
+      return {
+        ...base,
+        action: 'review_code',
+        description: '引用错误，需要检查变量/函数定义',
+        fixable: false,
+        fixCommand: null
+      };
+
+    case ERROR_TYPES.TYPE:
+      return {
+        ...base,
+        action: 'review_type',
+        description: '类型错误，需要检查类型定义',
+        fixable: false,
+        fixCommand: null
+      };
+
+    case ERROR_TYPES.TEST:
+      return {
+        ...base,
+        action: 'fix_test',
+        description: '测试失败，需要修复测试用例或代码逻辑',
+        fixable: false,
+        fixCommand: null
+      };
+
+    case ERROR_TYPES.RUNTIME:
+      return {
+        ...base,
+        action: 'debug_runtime',
+        description: '运行时错误，需要调试',
+        fixable: false,
+        fixCommand: null
+      };
+
+    default:
+      return {
+        ...base,
+        action: 'manual_review',
+        description: '需要人工审查',
+        fixable: false,
+        fixCommand: null
+      };
+  }
+}
+
+/**
+ * 查找根本原因
+ */
+export function findRootCause(testFailures) {
+  // 简化实现：返回最可能的根本原因
+  const errors = testFailures.classifiedErrors || [];
+
+  // 统计错误类型
+  const typeCount = {};
+  for (const error of errors) {
+    typeCount[error.type] = (typeCount[error.type] || 0) + 1;
+  }
+
+  // 找到最常见的错误类型
+  let mostCommonType = null;
+  let maxCount = 0;
+  for (const [type, count] of Object.entries(typeCount)) {
+    if (count > maxCount) {
+      maxCount = count;
+      mostCommonType = type;
+    }
+  }
+
+  return {
+    likelyRootCause: mostCommonType,
+    confidence: maxCount / errors.length,
+    typeCount
+  };
+}
+
+/**
+ * 判断是否需要人工确认
+ */
+export function requiresHumanConfirmation(analysis) {
+  // 关键错误需要人工确认
+  const criticalTypes = [ERROR_TYPES.REFERENCE, ERROR_TYPES.TYPE, ERROR_TYPES.RUNTIME];
+
+  for (const error of analysis.classifiedErrors) {
+    if (criticalTypes.includes(error.type) && !error.autoFixable) {
+      return true;
+    }
+  }
+
+  // 高严重级别也需要确认
+  if (analysis.severity === SEVERITY.CRITICAL || analysis.severity === SEVERITY.HIGH) {
+    return true;
+  }
+
+  return false;
+}

package/plugins/hooks/lib/test-failure-fixer.js

@@ -0,0 +1,268 @@
+/**
+ * Auto Fixer - 自动修复、确认机制
+ *
+ * 从 src/core/test/test-failure-fixer.js 迁移
+ * 此文件是 hooks 模块的一部分，可独立运行于目标项目中。
+ */
+
+import fs from 'fs';
+import { execSync } from 'child_process';
+import { requiresHumanConfirmation } from './test-failure-analyzer.js';
+
+/**
+ * 修复动作类型
+ */
+export const FIX_ACTIONS = {
+  FIX_SYNTAX: 'fix_syntax',
+  FIX_IMPORT: 'fix_import',
+  REVIEW_CODE: 'review_code',
+  REVIEW_TYPE: 'review_type',
+  FIX_TEST: 'fix_test',
+  DEBUG_RUNTIME: 'debug_runtime',
+  MANUAL_REVIEW: 'manual_review'
+};
+
+/**
+ * 尝试自动修复
+ * @param {Object} analysis - 分析结果
+ * @param {Object} options - 选项
+ * @returns {Promise<Object>} 修复结果
+ */
+export async function attemptFix(analysis, options = {}) {
+  const { dryRun = false, interactive = false } = options;
+
+  const results = {
+    fixed: [],
+    failed: [],
+    skipped: [],
+    requiresConfirmation: []
+  };
+
+  // 检查是否需要人工确认
+  if (requiresHumanConfirmation(analysis)) {
+    return {
+      ...results,
+      requiresConfirmation: analysis.classifiedErrors.filter(e => !e.autoFixable),
+      needsHumanConfirmation: true
+    };
+  }
+
+  // 逐个处理可修复的错误
+  for (const suggestion of analysis.suggestions) {
+    if (!suggestion.fixable) {
+      results.skipped.push(suggestion);
+      continue;
+    }
+
+    if (dryRun) {
+      results.fixed.push({
+        ...suggestion,
+        dryRun: true
+      });
+      continue;
+    }
+
+    try {
+      const fixResult = await applyFix(suggestion);
+      if (fixResult.success) {
+        results.fixed.push(fixResult);
+      } else {
+        results.failed.push(fixResult);
+      }
+    } catch (e) {
+      results.failed.push({
+        ...suggestion,
+        error: e.message
+      });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * 应用单个修复
+ */
+async function applyFix(suggestion) {
+  const { action, file, message } = suggestion;
+
+  switch (action) {
+    case FIX_ACTIONS.FIX_SYNTAX:
+      return fixSyntaxError(file, message);
+
+    case FIX_ACTIONS.FIX_IMPORT:
+      return fixImportError(file, message);
+
+    default:
+      return {
+        success: false,
+        error: `Unknown action: ${action}`,
+        suggestion
+      };
+  }
+}
+
+/**
+ * 修复语法错误
+ */
+function fixSyntaxError(file, message) {
+  if (!file) {
+    return { success: false, error: 'No file specified' };
+  }
+
+  // 常见语法错误修复
+  let content = fs.readFileSync(file, 'utf-8');
+  let fixed = false;
+
+  // 修复：缺少分号
+  if (message.includes('missing semicolon')) {
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      // 检查是否是可能缺少分号的行
+      if (line.trim() && !line.trim().endsWith(';') && !line.trim().endsWith('{') && !line.trim().endsWith('}')) {
+        // 简单修复：添加分号
+        lines[i] = line + ';';
+        fixed = true;
+        break;
+      }
+    }
+    if (fixed) {
+      content = lines.join('\n');
+    }
+  }
+
+  // 修复：缺少引号
+  if (message.includes('unterminated string')) {
+    // 尝试修复未闭合的字符串
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const singleQuotes = (line.match(/'/g) || []).length;
+      const doubleQuotes = (line.match(/"/g) || []).length;
+
+      if (singleQuotes % 2 !== 0 || doubleQuotes % 2 !== 0) {
+        // 简单处理：移除有问题的行
+        lines[i] = '// ' + line;
+        fixed = true;
+        break;
+      }
+    }
+    if (fixed) {
+      content = lines.join('\n');
+    }
+  }
+
+  if (fixed) {
+    fs.writeFileSync(file, content, 'utf-8');
+    return {
+      success: true,
+      file,
+      action: 'fix_syntax',
+      description: 'Applied syntax fix'
+    };
+  }
+
+  return {
+    success: false,
+    file,
+    action: 'fix_syntax',
+    error: 'Could not auto-fix syntax error'
+  };
+}
+
+/**
+ * 修复导入错误
+ */
+function fixImportError(file, message) {
+  // 提取缺失的模块名
+  const match = message.match(/Cannot find module ['"]([^'"]+)['"]/);
+  if (!match) {
+    return { success: false, error: 'Could not parse module name' };
+  }
+
+  const moduleName = match[1];
+
+  // 尝试安装缺失的模块
+  try {
+    execSync(`npm install ${moduleName}`, {
+      stdio: 'pipe',
+      cwd: process.cwd()
+    });
+
+    return {
+      success: true,
+      moduleName,
+      action: 'fix_import',
+      description: `Installed missing module: ${moduleName}`
+    };
+  } catch (e) {
+    return {
+      success: false,
+      moduleName,
+      action: 'fix_import',
+      error: `Failed to install module: ${e.message}`
+    };
+  }
+}
+
+/**
+ * 检查是否需要人工确认
+ */
+export function checkConfirmationNeeded(analysis) {
+  return requiresHumanConfirmation(analysis);
+}
+
+/**
+ * 生成修复报告
+ */
+export function generateFixReport(fixResult) {
+  const {
+    fixed = [],
+    failed = [],
+    skipped = [],
+    requiresConfirmation = [],
+    needsHumanConfirmation
+  } = fixResult;
+
+  return {
+    summary: {
+      total: fixed.length + failed.length + skipped.length,
+      fixed: fixed.length,
+      failed: failed.length,
+      skipped: skipped.length,
+      needsConfirmation: requiresConfirmation.length
+    },
+    needsHumanConfirmation,
+    fixed,
+    failed,
+    skipped,
+    requiresConfirmation
+  };
+}
+
+/**
+ * 验证修复结果
+ * @param {Object} fixResult - 修复结果
+ * @param {Function} testRunner - 测试运行函数
+ * @returns {Promise<Object>} 验证结果
+ */
+export async function verifyFix(fixResult, testRunner) {
+  const { fixed } = fixResult;
+
+  if (fixed.length === 0) {
+    return {
+      verified: false,
+      reason: 'No fixes to verify'
+    };
+  }
+
+  // 运行测试验证修复
+  const testResult = await testRunner();
+
+  return {
+    verified: testResult.passed,
+    testResult,
+    fixedCount: fixed.length
+  };
+}