@chongyan/autospec 1.0.2 → 1.0.4

package/plugins/hooks/lib/execution-path.js

@@ -1,427 +0,0 @@
-/**
- * Execution Path - 执行路径记录模块
- *
- * 记录和分析执行路径，评估 SDD 引导效果
- */
-
-import fs from 'fs';
-import path from 'path';
-import { getState, getMetrics, updateMetrics } from './hook-state-manager.js';
-import { getTraceId, generateEventId } from './trace-context.js';
-
-/**
- * 路径事件类型
- */
-export const PATH_EVENT_TYPES = {
-  COMMAND: 'command',       // 命令调用
-  STAGE: 'stage',           // 阶段转换
-  HOOK: 'hook',             // Hook 触发
-  TOOL: 'tool',             // 工具调用
-  DECISION: 'decision',     // 决策点
-  ROLLBACK: 'rollback',     // 回退
-  GATE: 'gate'              // 门禁检查
-};
-
-/**
- * 记录路径事件
- * @param {string} projectRoot - 项目根目录
- * @param {string} eventType - 事件类型
- * @param {Object} eventData - 事件数据
- */
-export function recordPathEvent(projectRoot, eventType, eventData) {
-  const traceId = getTraceId(projectRoot);
-
-  const event = {
-    eventId: generateEventId(),
-    traceId,
-    timestamp: new Date().toISOString(),
-    type: eventType,
-    ...eventData
-  };
-
-  // 更新 metrics.json 中的 executionPath
-  const metrics = getMetrics(projectRoot, false);
-
-  if (!metrics.executionPath) {
-    metrics.executionPath = {
-      commands: [],
-      stages: [],
-      toolStats: {},
-      decisionStats: { total: 0, human: 0, auto: 0 },
-      rollbackStats: { total: 0, success: 0, escalate: 0 },
-      gateStats: { passed: 0, blocked: 0 },
-      events: []
-    };
-  }
-
-  // 根据事件类型更新统计
-  switch (eventType) {
-    case PATH_EVENT_TYPES.COMMAND:
-      if (eventData.command && !metrics.executionPath.commands.includes(eventData.command)) {
-        metrics.executionPath.commands.push(eventData.command);
-      }
-      break;
-
-    case PATH_EVENT_TYPES.STAGE:
-      if (eventData.stage && !metrics.executionPath.stages.includes(eventData.stage)) {
-        metrics.executionPath.stages.push(eventData.stage);
-      }
-      break;
-
-    case PATH_EVENT_TYPES.TOOL:
-      if (eventData.tool) {
-        metrics.executionPath.toolStats[eventData.tool] =
-          (metrics.executionPath.toolStats[eventData.tool] || 0) + 1;
-      }
-      break;
-
-    case PATH_EVENT_TYPES.DECISION:
-      metrics.executionPath.decisionStats.total++;
-      if (eventData.decisionType === 'human') {
-        metrics.executionPath.decisionStats.human++;
-      } else {
-        metrics.executionPath.decisionStats.auto++;
-      }
-      break;
-
-    case PATH_EVENT_TYPES.ROLLBACK:
-      metrics.executionPath.rollbackStats.total++;
-      if (eventData.outcome === 'success') {
-        metrics.executionPath.rollbackStats.success++;
-      } else if (eventData.outcome === 'escalate') {
-        metrics.executionPath.rollbackStats.escalate++;
-      }
-      break;
-
-    case PATH_EVENT_TYPES.GATE:
-      if (eventData.passed) {
-        metrics.executionPath.gateStats.passed++;
-      } else {
-        metrics.executionPath.gateStats.blocked++;
-      }
-      break;
-  }
-
-  // 添加事件到事件列表（限制最近 1000 个）
-  metrics.executionPath.events.push(event);
-  if (metrics.executionPath.events.length > 1000) {
-    metrics.executionPath.events = metrics.executionPath.events.slice(-1000);
-  }
-
-  updateMetrics(projectRoot, metrics);
-
-  return event;
-}
-
-/**
- * 生成执行路径摘要
- * @param {string} projectRoot - 项目根目录
- * @returns {Object} 执行路径摘要
- */
-export function generatePathSummary(projectRoot) {
-  const metrics = getMetrics(projectRoot, true);
-  const executionPath = metrics?.executionPath || {};
-
-  return {
-    // 命令序列
-    commands: executionPath.commands || [],
-
-    // 阶段路径
-    stages: executionPath.stages || [],
-
-    // 工具调用统计
-    toolStats: executionPath.toolStats || {},
-
-    // 决策点统计
-    decisionStats: executionPath.decisionStats || { total: 0, human: 0, auto: 0 },
-
-    // 回退统计
-    rollbackStats: executionPath.rollbackStats || { total: 0, success: 0, escalate: 0 },
-
-    // 门禁统计
-    gateStats: executionPath.gateStats || { passed: 0, blocked: 0 },
-
-    // 事件总数
-    totalEvents: (executionPath.events || []).length
-  };
-}
-
-/**
- * 提取命令序列
- * @param {Object} traceLog - trace 日志
- * @returns {Array} 命令序列
- */
-export function extractCommandSequence(traceLog) {
-  const events = traceLog?.events || [];
-  return events
-    .filter(e => e.type === PATH_EVENT_TYPES.COMMAND)
-    .map(e => ({
-      command: e.command,
-      timestamp: e.timestamp
-    }));
-}
-
-/**
- * 提取阶段序列
- * @param {Object} traceLog - trace 日志
- * @returns {Array} 阶段序列
- */
-export function extractStageSequence(traceLog) {
-  const events = traceLog?.events || [];
-  const stages = [];
-  const seen = new Set();
-
-  for (const event of events) {
-    if (event.type === PATH_EVENT_TYPES.STAGE && event.stage && !seen.has(event.stage)) {
-      stages.push({
-        stage: event.stage,
-        timestamp: event.timestamp
-      });
-      seen.add(event.stage);
-    }
-  }
-
-  return stages;
-}
-
-/**
- * 计算工具统计
- * @param {Object} traceLog - trace 日志
- * @returns {Object} 工具统计
- */
-export function calculateToolStats(traceLog) {
-  const events = traceLog?.events || [];
-  const stats = {};
-
-  for (const event of events) {
-    if (event.type === PATH_EVENT_TYPES.TOOL && event.tool) {
-      stats[event.tool] = (stats[event.tool] || 0) + 1;
-    }
-  }
-
-  return stats;
-}
-
-/**
- * 计算决策统计
- * @param {Object} traceLog - trace 日志
- * @returns {Object} 决策统计
- */
-export function calculateDecisionStats(traceLog) {
-  const events = traceLog?.events || [];
-  const stats = { total: 0, human: 0, auto: 0, byType: {} };
-
-  for (const event of events) {
-    if (event.type === PATH_EVENT_TYPES.DECISION) {
-      stats.total++;
-      if (event.decisionType === 'human') {
-        stats.human++;
-      } else {
-        stats.auto++;
-      }
-
-      const decisionType = event.decisionType || 'unknown';
-      stats.byType[decisionType] = (stats.byType[decisionType] || 0) + 1;
-    }
-  }
-
-  return stats;
-}
-
-/**
- * 计算回退统计
- * @param {Object} traceLog - trace 日志
- * @returns {Object} 回退统计
- */
-export function calculateRollbackStats(traceLog) {
-  const events = traceLog?.events || [];
-  const stats = { total: 0, success: 0, escalate: 0, byLevel: {} };
-
-  for (const event of events) {
-    if (event.type === PATH_EVENT_TYPES.ROLLBACK) {
-      stats.total++;
-      if (event.outcome === 'success') {
-        stats.success++;
-      } else if (event.outcome === 'escalate') {
-        stats.escalate++;
-      }
-
-      const level = event.level || 'unknown';
-      stats.byLevel[level] = (stats.byLevel[level] || 0) + 1;
-    }
-  }
-
-  return stats;
-}
-
-/**
- * 计算门禁统计
- * @param {Object} traceLog - trace 日志
- * @returns {Object} 门禁统计
- */
-export function calculateGateStats(traceLog) {
-  const events = traceLog?.events || [];
-  const stats = { passed: 0, blocked: 0, byGate: {} };
-
-  for (const event of events) {
-    if (event.type === PATH_EVENT_TYPES.GATE) {
-      if (event.passed) {
-        stats.passed++;
-      } else {
-        stats.blocked++;
-      }
-
-      const gate = event.gate || 'unknown';
-      if (!stats.byGate[gate]) {
-        stats.byGate[gate] = { passed: 0, blocked: 0 };
-      }
-      if (event.passed) {
-        stats.byGate[gate].passed++;
-      } else {
-        stats.byGate[gate].blocked++;
-      }
-    }
-  }
-
-  return stats;
-}
-
-/**
- * 检测重复操作
- * @param {Object} traceLog - trace 日志
- * @returns {Array} 重复操作列表
- */
-export function detectRepeatedOperations(traceLog) {
-  const events = traceLog?.events || [];
-  const operations = {};
-  const repeated = [];
-
-  for (const event of events) {
-    if (event.type === PATH_EVENT_TYPES.TOOL) {
-      const key = `${event.tool}:${event.action || ''}`;
-      if (!operations[key]) {
-        operations[key] = { count: 0, timestamps: [] };
-      }
-      operations[key].count++;
-      operations[key].timestamps.push(event.timestamp);
-    }
-  }
-
-  for (const [key, data] of Object.entries(operations)) {
-    if (data.count >= 3) {
-      repeated.push({
-        operation: key,
-        count: data.count,
-        timestamps: data.timestamps.slice(-5)
-      });
-    }
-  }
-
-  return repeated;
-}
-
-/**
- * 检测无效操作
- * @param {Object} traceLog - trace 日志
- * @returns {Array} 无效操作列表
- */
-export function detectWastedOperations(traceLog) {
-  const events = traceLog?.events || [];
-  const wasted = [];
-
-  // 检测回退后重做的操作
-  const rollbackEvents = events.filter(e => e.type === PATH_EVENT_TYPES.ROLLBACK);
-
-  for (const rollback of rollbackEvents) {
-    // 找到回退后 5 分钟内的相同操作
-    const rollbackTime = new Date(rollback.timestamp).getTime();
-    const relatedEvents = events.filter(e => {
-      const eventTime = new Date(e.timestamp).getTime();
-      return eventTime > rollbackTime && eventTime < rollbackTime + 5 * 60 * 1000;
-    });
-
-    if (relatedEvents.length > 0) {
-      wasted.push({
-        rollbackType: rollback.trigger,
-        wastedCount: relatedEvents.length,
-        message: `回退后 ${relatedEvents.length} 次操作可能为重复工作`
-      });
-    }
-  }
-
-  return wasted;
-}
-
-/**
- * 便捷方法：记录命令调用
- */
-export function recordCommand(projectRoot, command) {
-  return recordPathEvent(projectRoot, PATH_EVENT_TYPES.COMMAND, { command });
-}
-
-/**
- * 便捷方法：记录阶段转换
- */
-export function recordStage(projectRoot, stage) {
-  return recordPathEvent(projectRoot, PATH_EVENT_TYPES.STAGE, { stage });
-}
-
-/**
- * 便捷方法：记录工具调用
- */
-export function recordTool(projectRoot, tool, action = null) {
-  return recordPathEvent(projectRoot, PATH_EVENT_TYPES.TOOL, { tool, action });
-}
-
-/**
- * 便捷方法：记录决策
- */
-export function recordDecision(projectRoot, decisionType, context = {}) {
-  return recordPathEvent(projectRoot, PATH_EVENT_TYPES.DECISION, {
-    decisionType,
-    ...context
-  });
-}
-
-/**
- * 便捷方法：记录回退
- */
-export function recordRollback(projectRoot, level, trigger, outcome, context = {}) {
-  return recordPathEvent(projectRoot, PATH_EVENT_TYPES.ROLLBACK, {
-    level,
-    trigger,
-    outcome,
-    ...context
-  });
-}
-
-/**
- * 便捷方法：记录门禁检查
- */
-export function recordGate(projectRoot, gate, passed, reason = null) {
-  return recordPathEvent(projectRoot, PATH_EVENT_TYPES.GATE, {
-    gate,
-    passed,
-    reason
-  });
-}
-
-export default {
-  PATH_EVENT_TYPES,
-  recordPathEvent,
-  generatePathSummary,
-  extractCommandSequence,
-  extractStageSequence,
-  calculateToolStats,
-  calculateDecisionStats,
-  calculateRollbackStats,
-  calculateGateStats,
-  detectRepeatedOperations,
-  detectWastedOperations,
-  recordCommand,
-  recordStage,
-  recordTool,
-  recordDecision,
-  recordRollback,
-  recordGate
-};

package/plugins/hooks/lib/hook-error-recorder.js

@@ -1,245 +0,0 @@
-/**
- * Hook 执行日志记录器
- *
- * 记录完整的 hook 执行历史，包括：
- * - 输入（stdin）
- * - 输出（stdout）
- * - 执行时间
- * - 错误信息
- *
- * 日志存储位置：.autospec/logs/hooks/hook-execution-{date}.json
- */
-
-import fs from 'fs';
-import path from 'path';
-import { getTraceId, generateEventId, appendTraceEvent } from './trace-context.js';
-
-/**
- * 获取 hook 日志目录
- */
-function getHookLogDir(projectRoot) {
-  return path.join(projectRoot, '.autospec', 'logs', 'hooks');
-}
-
-/**
- * 确保 hook 日志目录存在
- */
-function ensureHookLogDir(projectRoot) {
-  const logDir = getHookLogDir(projectRoot);
-  if (!fs.existsSync(logDir)) {
-    fs.mkdirSync(logDir, { recursive: true });
-  }
-  return logDir;
-}
-
-/**
- * 获取当天的 hook 日志文件路径
- */
-function getHookLogFile(projectRoot) {
-  const date = new Date().toISOString().split('T')[0];
-  return path.join(getHookLogDir(projectRoot), `hook-execution-${date}.json`);
-}
-
-/**
- * 读取 hook 日志
- */
-function readHookLog(projectRoot) {
-  const logPath = getHookLogFile(projectRoot);
-  if (fs.existsSync(logPath)) {
-    try {
-      return JSON.parse(fs.readFileSync(logPath, 'utf-8'));
-    } catch {
-      return { executions: [], errors: [], summary: {} };
-    }
-  }
-  return { executions: [], errors: [], summary: {} };
-}
-
-/**
- * 写入 hook 日志
- */
-function writeHookLog(projectRoot, logData) {
-  ensureHookLogDir(projectRoot);
-  const logPath = getHookLogFile(projectRoot);
-  fs.writeFileSync(logPath, JSON.stringify(logData, null, 2), 'utf-8');
-}
-
-/**
- * 记录 hook 执行（成功或失败）
- * @param {string} projectRoot - 项目根目录
- * @param {string} hookName - Hook 名称
- * @param {Object} input - Hook 输入
- * @param {Object} output - Hook 输出
- * @param {number} duration - 执行时长（毫秒）
- * @param {boolean} success - 是否成功
- */
-export function recordHookExecution(projectRoot, hookName, input, output, duration, success) {
-  if (!projectRoot) return null;
-
-  const logData = readHookLog(projectRoot);
-  const traceId = getTraceId(projectRoot);
-
-  const execution = {
-    eventId: generateEventId(),
-    traceId,
-    timestamp: new Date().toISOString(),
-    hookName,
-    duration: `${duration}ms`,
-    success,
-    // 输入摘要（避免记录过大内容）
-    input: {
-      toolName: input?.tool_name,
-      filePath: input?.tool_input?.file_path,
-      event: input?.event_name
-    },
-    // 输出摘要
-    output: output ? {
-      hadPermissionDecision: !!output.hookSpecificOutput?.permissionDecision,
-      hadAdditionalContext: !!output.hookSpecificOutput?.additionalContext
-    } : null
-  };
-
-  logData.executions.push(execution);
-
-  // 更新摘要
-  updateSummary(logData, hookName, success);
-
-  // 限制日志大小（保留最近 1000 条）
-  if (logData.executions.length > 1000) {
-    logData.executions = logData.executions.slice(-1000);
-  }
-
-  writeHookLog(projectRoot, logData);
-
-  return execution;
-}
-
-/**
- * 记录 hook 错误
- * @param {string} projectRoot - 项目根目录
- * @param {Object} errorInfo - 错误信息
- */
-export function recordHookError(projectRoot, errorInfo) {
-  if (!projectRoot) return null;
-
-  const logData = readHookLog(projectRoot);
-  const traceId = getTraceId(projectRoot);
-
-  const errorEntry = {
-    eventId: generateEventId(),
-    traceId,
-    ...errorInfo
-  };
-
-  logData.errors.push(errorEntry);
-
-  // 更新错误摘要
-  if (!logData.summary.errorsByHook) {
-    logData.summary.errorsByHook = {};
-  }
-  logData.summary.errorsByHook[errorInfo.hookName] =
-    (logData.summary.errorsByHook[errorInfo.hookName] || 0) + 1;
-
-  // 限制错误日志大小
-  if (logData.errors.length > 500) {
-    logData.errors = logData.errors.slice(-500);
-  }
-
-  writeHookLog(projectRoot, logData);
-
-  // 同时写入 trace 日志
-  if (traceId) {
-    appendTraceEvent(projectRoot, {
-      eventId: errorEntry.eventId,
-      traceId,
-      timestamp: errorEntry.timestamp,
-      type: 'hook_error',
-      source: errorInfo.hookName,
-      data: {
-        errorType: errorInfo.errorType,
-        errorMessage: errorInfo.errorMessage
-      }
-    });
-  }
-
-  return errorEntry;
-}
-
-/**
- * 更新摘要统计
- */
-function updateSummary(logData, hookName, success) {
-  if (!logData.summary.byHook) {
-    logData.summary.byHook = {};
-  }
-
-  if (!logData.summary.byHook[hookName]) {
-    logData.summary.byHook[hookName] = { total: 0, success: 0, fail: 0 };
-  }
-
-  logData.summary.byHook[hookName].total++;
-  if (success) {
-    logData.summary.byHook[hookName].success++;
-  } else {
-    logData.summary.byHook[hookName].fail++;
-  }
-
-  // 计算全局统计
-  logData.summary.totalExecutions = logData.executions.length;
-  logData.summary.totalErrors = logData.errors.length;
-}
-
-/**
- * 获取 hook 错误率
- * @param {string} projectRoot - 项目根目录
- * @param {string} hookName - Hook 名称（可选，不传则返回全局错误率）
- * @returns {number} 错误率（0-1）
- */
-export function getHookErrorRate(projectRoot, hookName = null) {
-  const logData = readHookLog(projectRoot);
-
-  if (hookName) {
-    const stats = logData.summary.byHook?.[hookName];
-    if (!stats || stats.total === 0) return 0;
-    return stats.fail / stats.total;
-  }
-
-  // 全局错误率
-  const total = logData.executions.length;
-  if (total === 0) return 0;
-  return logData.errors.length / total;
-}
-
-/**
- * 获取最近的 hook 错误
- * @param {string} projectRoot - 项目根目录
- * @param {number} limit - 限制数量
- * @returns {Array} 错误列表
- */
-export function getRecentHookErrors(projectRoot, limit = 10) {
-  const logData = readHookLog(projectRoot);
-  return logData.errors.slice(-limit);
-}
-
-/**
- * 获取 hook 执行统计
- * @param {string} projectRoot - 项目根目录
- * @returns {Object} 统计信息
- */
-export function getHookStats(projectRoot) {
-  const logData = readHookLog(projectRoot);
-  return {
-    totalExecutions: logData.summary.totalExecutions || 0,
-    totalErrors: logData.summary.totalErrors || 0,
-    byHook: logData.summary.byHook || {},
-    errorsByHook: logData.summary.errorsByHook || {}
-  };
-}
-
-export default {
-  recordHookExecution,
-  recordHookError,
-  getHookErrorRate,
-  getRecentHookErrors,
-  getHookStats
-};