@chongyan/autospec 1.0.1

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

@@ -0,0 +1,427 @@
+/**
+ * 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

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