@chongyan/autospec 1.0.2 → 1.0.3

package/plugins/hooks/lib/auto-fix-loop.js

@@ -1,605 +0,0 @@
-/**
- * AutoSpec Auto-Fix Loop - 自主修复循环核心逻辑
- *
- * 实现"检测障碍 → 分析根因 → 决策策略 → 执行修复 → 验证结果"的自主闭环能力
- *
- * 核心设计原则：
- * - DP15 Brownfield 适配：先搜索后实现，优先复用项目已有框架
- * - P10 开闭原则：对扩展开放，对修改关闭
- * - P13 面向变化设计：封装隔离变化点
- * - 依赖倒转：面向接口编程
- * - 单一职责：每个类/方法只做一件事
- * - 高内聚低耦合：模块内聚，模块间松耦合
- * - AOP：通过切面方式增强功能，不侵入业务代码
- *
- * 修复边界：
- * - 冻结区：constitution.md, evolution.md, 核心原则 → 不可自主修改
- * - 受控区：框架核心机制、接口契约变更 → 需人工批准
- * - 自由区：依赖添加、配置修正、语法/类型错误、测试文件修复 → 可自主修复
- *
- * 重试上限：同一问题最多自主修复 3 次
- */
-
-import fs from 'fs';
-import path from 'path';
-import { execSync } from 'child_process';
-import { createHookLogger } from './hook-logger.js';
-import { getState, updateState, getTraceId } from './hook-state-manager.js';
-
-const logger = createHookLogger('auto-fix-loop');
-
-// 最大重试次数
-const MAX_RETRY_COUNT = 3;
-
-// 冻结区文件模式
-const FROZEN_PATTERNS = [
-  'constitution.md',
-  'evolution.md',
-  'design-philosophy.md',
-  'core-principles.md',
-  '.autospec/constitution',
-  'knowledge/01-principles/09-constitution',
-  'knowledge/01-principles/10-evolution-mechanism'
-];
-
-// 错误分类
-export const ERROR_TYPES = {
-  DEPENDENCY: 'dependency',      // 依赖类
-  CONFIG: 'config',              // 配置类
-  CODE: 'code',                  // 代码类
-  RESOURCE: 'resource',          // 资源类
-  VALIDATION: 'validation',      // 验证类
-  LOGIC: 'logic'                 // 逻辑类（需人工）
-};
-
-// 修复区域
-export const REPAIR_ZONES = {
-  FROZEN: 'frozen',              // 冻结区
-  CONTROLLED: 'controlled',      // 受控区
-  FREE: 'free'                   // 自由区
-};
-
-/**
- * 检测文件是否在冻结区
- * @param {string} filePath - 文件路径
- * @returns {boolean} 是否在冻结区
- */
-export function isFrozenFile(filePath) {
-  if (!filePath) return false;
-
-  const normalizedPath = filePath.replace(/\\/g, '/').toLowerCase();
-
-  for (const pattern of FROZEN_PATTERNS) {
-    if (normalizedPath.includes(pattern.toLowerCase())) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-/**
- * 判断修复区域
- * @param {string} filePath - 文件路径
- * @param {string} errorType - 错误类型
- * @returns {string} 修复区域
- */
-export function getRepairZone(filePath, errorType) {
-  // 冻结区文件
-  if (isFrozenFile(filePath)) {
-    return REPAIR_ZONES.FROZEN;
-  }
-
-  // 逻辑类错误需要人工确认
-  if (errorType === ERROR_TYPES.LOGIC) {
-    return REPAIR_ZONES.CONTROLLED;
-  }
-
-  // 自由区：依赖、配置、语法错误、测试文件
-  if (errorType === ERROR_TYPES.DEPENDENCY ||
-      errorType === ERROR_TYPES.CONFIG ||
-      errorType === ERROR_TYPES.CODE ||
-      errorType === ERROR_TYPES.RESOURCE) {
-    return REPAIR_ZONES.FREE;
-  }
-
-  return REPAIR_ZONES.CONTROLLED;
-}
-
-/**
- * 分析错误类型
- * @param {Object} errorContext - 错误上下文
- * @returns {string} 错误类型
- */
-export function analyzeErrorType(errorContext) {
-  const { errorMessage, errorOutput, command } = errorContext;
-
-  const message = (errorMessage || '').toLowerCase();
-  const output = (errorOutput || '').toLowerCase();
-  const fullText = message + ' ' + output;
-
-  // 依赖类错误
-  if (fullText.includes('package not found') ||
-      fullText.includes('cannot find module') ||
-      fullText.includes('dependency') ||
-      fullText.includes('package does not exist') ||
-      fullText.includes('module not found') ||
-      fullText.includes('npm err! cannot find module') ||
-      fullText.includes('maven') && fullText.includes('not found') ||
-      fullText.includes('does not exist')) {
-    return ERROR_TYPES.DEPENDENCY;
-  }
-
-  // 配置类错误
-  if (fullText.includes('config') ||
-      fullText.includes('configuration') ||
-      fullText.includes('invalid json') ||
-      fullText.includes('yaml') ||
-      fullText.includes('environment variable') ||
-      fullText.includes('.env')) {
-    return ERROR_TYPES.CONFIG;
-  }
-
-  // 代码类错误（优先于验证类）
-  if (fullText.includes('syntax error') ||
-      fullText.includes('type error') ||
-      fullText.includes('cannot find name') ||
-      fullText.includes('is not defined') ||
-      fullText.includes('property does not exist') ||
-      fullText.includes('import') ||
-      fullText.includes('compilation failed') ||
-      fullText.includes('unexpected token')) {
-    return ERROR_TYPES.CODE;
-  }
-
-  // 资源类错误
-  if (fullText.includes('not found') ||
-      fullText.includes('no such file') ||
-      fullText.includes('directory') ||
-      fullText.includes('ENOENT') ||
-      fullText.includes('resource not found')) {
-    return ERROR_TYPES.RESOURCE;
-  }
-
-  // 验证类错误
-  if (fullText.includes('test failed') ||
-      fullText.includes('assertion') ||
-      fullText.includes('expect') ||
-      fullText.includes('validation failed') ||
-      fullText.includes('lint') ||
-      command?.includes('test') ||
-      command?.includes('lint')) {
-    return ERROR_TYPES.VALIDATION;
-  }
-
-  // 默认为逻辑类（需要人工）
-  return ERROR_TYPES.LOGIC;
-}
-
-/**
- * 执行修复命令
- * @param {string} command - 命令
- * @param {string} cwd - 工作目录
- * @returns {Object} 执行结果
- */
-export function executeFixCommand(command, cwd) {
-  try {
-    const result = execSync(command, {
-      cwd,
-      encoding: 'utf-8',
-      stdio: ['pipe', 'pipe', 'pipe']
-    });
-
-    return {
-      success: true,
-      output: result,
-      command
-    };
-  } catch (e) {
-    return {
-      success: false,
-      error: e.message,
-      stdout: e.stdout,
-      stderr: e.stderr,
-      command
-    };
-  }
-}
-
-/**
- * 记录实践日志
- * @param {string} projectRoot - 项目根目录
- * @param {Object} fixRecord - 修复记录
- */
-export function recordPracticeLog(projectRoot, fixRecord) {
-  try {
-    const logDir = path.join(projectRoot, '.autospec', 'practice-log');
-    if (!fs.existsSync(logDir)) {
-      fs.mkdirSync(logDir, { recursive: true });
-    }
-
-    const date = new Date().toISOString().split('T')[0];
-    const logPath = path.join(logDir, `${date}-autofix.md`);
-
-    const entry = `## [${new Date().toISOString()}] 自主修复记录
-
-**问题**: ${fixRecord.problem}
-**根因**: ${fixRecord.rootCause}
-**修复方案**: ${fixRecord.fix}
-**验证结果**: ${fixRecord.verification?.rerunResult || 'pending'}
-**分类**: ${fixRecord.category}
-**区域**: ${fixRecord.zone}
-**重试次数**: ${fixRecord.retryCount || 0}
-
----
-
-`;
-
-    if (fs.existsSync(logPath)) {
-      fs.appendFileSync(logPath, entry, 'utf-8');
-    } else {
-      fs.writeFileSync(logPath, entry, 'utf-8');
-    }
-
-    logger.debug('Practice log recorded', { path: logPath });
-  } catch (e) {
-    logger.warn('Failed to record practice log', { error: e.message });
-  }
-}
-
-/**
- * 自主修复循环
- * @param {Object} errorContext - 错误上下文
- * @param {string} projectRoot - 项目根目录
- * @param {Function} reexecuteCommand - 重新执行原命令的函数
- * @returns {Promise<Object>} 修复结果
- */
-export async function autoFixLoop(errorContext, projectRoot, reexecuteCommand) {
-  const {
-    errorType: initialErrorType,
-    errorMessage,
-    errorLocation,
-    errorOutput,
-    command,
-    retryCount = 0
-  } = errorContext;
-
-  // 检查是否超过最大重试次数
-  if (retryCount >= MAX_RETRY_COUNT) {
-    logger.info('Max retry count reached, escalating to human', { retryCount });
-
-    return {
-      status: 'blocked',
-      reason: 'max_retry_exceeded',
-      retryCount,
-      message: `同一问题已尝试修复 ${MAX_RETRY_COUNT} 次，需要人工介入`
-    };
-  }
-
-  // 分析错误类型
-  const errorType = initialErrorType || analyzeErrorType({ errorMessage, errorOutput, command });
-
-  // 判断修复区域
-  const repairZone = getRepairZone(errorLocation, errorType);
-
-  // 冻结区：直接拒绝
-  if (repairZone === REPAIR_ZONES.FROZEN) {
-    logger.warn('Attempted to modify frozen file, blocked', { errorLocation, errorType });
-
-    return {
-      status: 'blocked',
-      reason: 'frozen_zone',
-      retryCount,
-      message: `不可修改宪法文件或核心原则文件：${errorLocation}`
-    };
-  }
-
-  // 受控区：需要人工确认
-  if (repairZone === REPAIR_ZONES.CONTROLLED) {
-    logger.info('Controlled zone issue, needs human confirmation', { errorType });
-
-    return {
-      status: 'needs_human',
-      reason: 'controlled_zone',
-      retryCount,
-      errorType,
-      message: '问题需要人工确认（业务逻辑错误或架构变更）'
-    };
-  }
-
-  // 自由区：尝试自主修复
-  logger.info('Attempting auto-fix for free zone issue', { errorType, retryCount });
-
-  // 执行修复策略
-  const fixResult = await executeFixStrategy(errorType, errorContext, projectRoot);
-
-  if (!fixResult.success) {
-    logger.warn('Auto-fix failed', { error: fixResult.error });
-
-    // 重试
-    return autoFixLoop({
-      ...errorContext,
-      retryCount: retryCount + 1,
-      errorOutput: fixResult.error
-    }, projectRoot, reexecuteCommand);
-  }
-
-  // 验证修复结果
-  if (reexecuteCommand) {
-    const verifyResult = await reexecuteCommand();
-
-    if (verifyResult.success) {
-      logger.info('Auto-fix verified successfully');
-
-      // 记录实践日志
-      recordPracticeLog(projectRoot, {
-        problem: errorMessage,
-        rootCause: errorType,
-        fix: fixResult.description,
-        verification: { rerunResult: 'pass' },
-        category: errorType,
-        zone: repairZone,
-        retryCount
-      });
-
-      return {
-        status: 'fixed',
-        fixApplied: fixResult.description,
-        changes: fixResult.changes,
-        verification: {
-          rerunResult: 'pass',
-          output: verifyResult.output
-        },
-        retryCount
-      };
-    } else {
-      logger.warn('Verification failed, retrying');
-
-      // 验证失败，继续重试
-      return autoFixLoop({
-        ...errorContext,
-        retryCount: retryCount + 1,
-        errorOutput: verifyResult.error
-      }, projectRoot, reexecuteCommand);
-    }
-  }
-
-  // 无法验证，假设修复成功
-  return {
-    status: 'fixed',
-    fixApplied: fixResult.description,
-    changes: fixResult.changes,
-    retryCount
-  };
-}
-
-/**
- * 执行修复策略
- * @param {string} errorType - 错误类型
- * @param {Object} errorContext - 错误上下文
- * @param {string} projectRoot - 项目根目录
- * @returns {Promise<Object>} 修复结果
- */
-async function executeFixStrategy(errorType, errorContext, projectRoot) {
-  switch (errorType) {
-    case ERROR_TYPES.DEPENDENCY:
-      return fixDependency(errorContext, projectRoot);
-
-    case ERROR_TYPES.CONFIG:
-      return fixConfig(errorContext, projectRoot);
-
-    case ERROR_TYPES.CODE:
-      return fixCode(errorContext, projectRoot);
-
-    case ERROR_TYPES.RESOURCE:
-      return fixResource(errorContext, projectRoot);
-
-    case ERROR_TYPES.VALIDATION:
-      return fixValidation(errorContext, projectRoot);
-
-    default:
-      return {
-        success: false,
-        error: `Unknown error type: ${errorType}`
-      };
-  }
-}
-
-/**
- * 修复依赖类错误
- */
-async function fixDependency(errorContext, projectRoot) {
-  const { errorOutput, command } = errorContext;
-  const output = errorOutput || '';
-
-  // 检测 Maven 依赖缺失
-  const mavenMatch = output.match(/package ([\w.]+) does not exist/);
-  if (mavenMatch) {
-    const packageName = mavenMatch[1];
-    logger.info('Detected Maven dependency missing', { packageName });
-
-    // 尝试找到 pom.xml 并添加依赖
-    const pomPath = findPomXml(projectRoot);
-    if (pomPath) {
-      // 这里只是记录，实际添加依赖需要更复杂的逻辑
-      return {
-        success: true,
-        description: `检测到 Maven 依赖缺失：${packageName}，需要添加到 ${pomPath}`,
-        changes: [{ file: pomPath, change: `Add dependency: ${packageName}` }],
-        needsHumanConfirmation: true,
-        suggestion: `在 ${pomPath} 中添加 ${packageName} 依赖`
-      };
-    }
-  }
-
-  // 检测 npm 依赖缺失
-  const npmMatch = output.match(/Cannot find module ['"]([^'"]+)['"]/);
-  if (npmMatch) {
-    const moduleName = npmMatch[1];
-    logger.info('Detected npm module missing', { moduleName });
-
-    // 尝试安装
-    const result = executeFixCommand(`npm install ${moduleName}`, projectRoot);
-
-    if (result.success) {
-      return {
-        success: true,
-        description: `已安装缺失的 npm 模块：${moduleName}`,
-        changes: [{ file: 'package.json', change: `npm install ${moduleName}` }]
-      };
-    }
-
-    return {
-      success: false,
-      error: `Failed to install npm module: ${moduleName}`
-    };
-  }
-
-  return {
-    success: false,
-    error: 'Could not identify specific dependency issue'
-  };
-}
-
-/**
- * 修复配置类错误
- */
-async function fixConfig(errorContext, projectRoot) {
-  const { errorLocation, errorOutput } = errorContext;
-
-  // JSON 语法错误修复
-  if (errorLocation?.endsWith('.json')) {
-    try {
-      const content = fs.readFileSync(errorLocation, 'utf-8');
-      // 尝试解析，失败则报告
-      try {
-        JSON.parse(content);
-      } catch (e) {
-        return {
-          success: false,
-          error: `JSON syntax error: ${e.message}`,
-          suggestion: 'Check JSON syntax'
-        };
-      }
-    } catch (e) {
-      return {
-        success: false,
-        error: `Cannot read config file: ${errorLocation}`
-      };
-    }
-  }
-
-  return {
-    success: false,
-    error: 'Config fix not implemented for this case'
-  };
-}
-
-/**
- * 修复代码类错误
- */
-async function fixCode(errorContext, projectRoot) {
-  const { errorLocation, errorOutput } = errorContext;
-
-  // 语法错误
-  if (errorOutput?.includes('syntax error')) {
-    return {
-      success: false,
-      error: 'Syntax error detected, needs manual review',
-      suggestion: `Check syntax at: ${errorLocation}`
-    };
-  }
-
-  // 导入缺失
-  if (errorOutput?.includes('is not defined') || errorOutput?.includes('cannot find name')) {
-    return {
-      success: false,
-      error: 'Undefined symbol detected, needs manual review',
-      suggestion: `Check import/definition at: ${errorLocation}`
-    };
-  }
-
-  return {
-    success: false,
-    error: 'Code fix not implemented for this case'
-  };
-}
-
-/**
- * 修复资源类错误
- */
-async function fixResource(errorContext, projectRoot) {
-  const { errorLocation } = errorContext;
-
-  // 文件不存在，尝试创建目录
-  if (errorLocation) {
-    const dir = path.dirname(errorLocation);
-    try {
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-        return {
-          success: true,
-          description: `Created directory: ${dir}`,
-          changes: [{ file: dir, change: 'mkdir -p' }]
-        };
-      }
-    } catch (e) {
-      return {
-        success: false,
-        error: `Cannot create directory: ${dir}`
-      };
-    }
-  }
-
-  return {
-    success: false,
-    error: 'Resource fix not implemented for this case'
-  };
-}
-
-/**
- * 修复验证类错误
- */
-async function fixValidation(errorContext, projectRoot) {
-  // 验证错误通常需要分析具体失败原因
-  return {
-    success: false,
-    error: 'Validation error needs analysis',
-    suggestion: 'Review test output and fix underlying issue'
-  };
-}
-
-/**
- * 查找 pom.xml 文件
- * @param {string} projectRoot - 项目根目录
- * @returns {string|null} pom.xml 路径
- */
-function findPomXml(projectRoot) {
-  const pomPath = path.join(projectRoot, 'pom.xml');
-  if (fs.existsSync(pomPath)) {
-    return pomPath;
-  }
-
-  // 查找子模块
-  const subdirs = ['app/service', 'service', 'backend'];
-  for (const subdir of subdirs) {
-    const subPomPath = path.join(projectRoot, subdir, 'pom.xml');
-    if (fs.existsSync(subPomPath)) {
-      return subPomPath;
-    }
-  }
-
-  return null;
-}
-
-export default {
-  autoFixLoop,
-  analyzeErrorType,
-  getRepairZone,
-  isFrozenFile,
-  executeFixCommand,
-  recordPracticeLog,
-  ERROR_TYPES,
-  REPAIR_ZONES,
-  MAX_RETRY_COUNT
-};