@chongyan/autospec 1.0.1 → 1.0.2

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

@@ -0,0 +1,605 @@
+/**
+ * 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
+};

package/plugins/hooks/lib/environment-config-loader.js

@@ -141,22 +141,26 @@ function parseValue(value) {
 
 /**
  * 查找配置文件
+ * 搜索顺序：
+ * 1. .autospec/environment/ (运行时配置，优先级最高)
+ * 2. knowledge/06-environment/ (框架模板)
+ * 3. 当前工作目录
  */
 function findConfigFile(filename) {
   const searchPaths = [
+    // 运行时配置目录（优先级最高，由 env-sync 生成）
+    path.join(process.cwd(), '.autospec', 'environment'),
+    // 框架模板目录
+    path.join(process.cwd(), 'knowledge', '06-environment'),
+    // 当前工作目录
     process.cwd(),
-    path.join(process.cwd(), '.autospec'),
-    path.join(process.cwd(), 'framework'),
-    path.join(process.cwd(), 'framework', 'environment'),
-    path.join(process.cwd(), 'framework', 'config'),
   ];
 
   // 如果是框架内部运行，添加框架路径
   try {
     const frameworkRoot = path.dirname(path.dirname(path.dirname(import.meta.url.replace('file://', ''))));
     searchPaths.push(frameworkRoot);
-    searchPaths.push(path.join(frameworkRoot, 'framework', 'environment'));
-    searchPaths.push(path.join(frameworkRoot, 'framework', 'config'));
+    searchPaths.push(path.join(frameworkRoot, 'knowledge', '06-environment'));
   } catch (e) {
     // 忽略
   }
@@ -271,7 +275,7 @@ function getDefaultValidationConfig() {
     frozenPatterns: [
       { pattern: 'constitution\\.md$' },
       { pattern: 'evolution\\.md$' },
-      { pattern: 'pipeline/overview\\.md$' }
+      { pattern: 'knowledge/02-process/00-overview\\.md$' }
     ]
   };
 }