@chongyan/autospec 1.0.2 → 1.0.3

package/plugins/hooks/lib/metrics-analyzer.js

@@ -1,489 +0,0 @@
-/**
- * Metrics Analyzer - 指标分析和计算模块
- *
- * 提供质量分数计算、错误模式检测等功能
- */
-
-import { getMetrics } from './hook-state-manager.js';
-
-/**
- * 质量分数权重配置
- */
-export const QUALITY_WEIGHTS = {
-  // 过程指标权重
-  process: {
-    layer1FirstPassRate: 0.25,
-    layer2FirstPassRate: 0.20,
-    humanInterventionRate: 0.15,  // 反向指标
-    rollbackRate: 0.15,           // 反向指标
-    errorRate: 0.10,              // 反向指标
-    stageSuccessRate: 0.15
-  },
-  // 结果指标权重（产出物评测）
-  result: {
-    artifactAverageScore: 0.40,
-    consistencyScore: 0.30,
-    structureScore: 0.30
-  },
-  // 路径指标权重（SDD 引导效果）
-  path: {
-    complianceScore: 0.30,
-    efficiencyScore: 0.25,
-    decisionScore: 0.25,
-    exceptionScore: 0.20
-  },
-  // 综合评分权重
-  overall: {
-    process: 0.30,
-    result: 0.40,
-    path: 0.30
-  }
-};
-
-/**
- * 计算过程指标分数
- * @param {Object} metrics - metrics.json 数据
- * @returns {Object} 过程指标分数
- */
-export function calculateProcessScore(metrics) {
-  const summary = metrics?.summary || {};
-  const totals = metrics?.totals || {};
-
-  // 计算 Layer1 首次通过率
-  const layer1FirstPassRate = totals.layer1FirstAttempts > 0
-    ? totals.layer1FirstPass / totals.layer1FirstAttempts
-    : 1;
-
-  // 计算 Layer2 首次通过率
-  const layer2FirstPassRate = totals.layer2FirstAttempts > 0
-    ? totals.layer2FirstPass / totals.layer2FirstAttempts
-    : 1;
-
-  // 计算人工介入率
-  const stageCount = summary.stageCount || 6;
-  const humanInterventionRate = totals.humanInterventions / stageCount;
-
-  // 计算回退率
-  const rollbackRate = totals.rollbacks / stageCount;
-
-  // 计算错误率
-  const totalOperations = totals.layer1Pass + totals.layer1Fail + totals.agentCalls;
-  const errorRate = totals.errors?.length / Math.max(totalOperations, 1);
-
-  // 计算阶段成功率
-  const stageSuccessRate = summary.stageSuccessCount / stageCount;
-
-  // 加权计算分数
-  const weights = QUALITY_WEIGHTS.process;
-  let score = 0;
-  score += layer1FirstPassRate * weights.layer1FirstPassRate * 100;
-  score += layer2FirstPassRate * weights.layer2FirstPassRate * 100;
-  score += (1 - humanInterventionRate) * weights.humanInterventionRate * 100;
-  score += (1 - rollbackRate) * weights.rollbackRate * 100;
-  score += (1 - errorRate) * weights.errorRate * 100;
-  score += stageSuccessRate * weights.stageSuccessRate * 100;
-
-  return {
-    score: Math.round(score),
-    details: {
-      layer1FirstPassRate: Math.round(layer1FirstPassRate * 100),
-      layer2FirstPassRate: Math.round(layer2FirstPassRate * 100),
-      humanInterventionRate: Math.round(humanInterventionRate * 100),
-      rollbackRate: Math.round(rollbackRate * 100),
-      errorRate: Math.round(errorRate * 100),
-      stageSuccessRate: Math.round(stageSuccessRate * 100)
-    }
-  };
-}
-
-/**
- * 计算结果指标分数（产出物评测）
- * @param {Object} metrics - metrics.json 数据
- * @returns {Object} 结果指标分数
- */
-export function calculateResultScore(metrics) {
-  const artifacts = metrics?.artifacts || {};
-  const artifactSummary = metrics?.artifactSummary || {};
-
-  // 产出物平均分数
-  const artifactAverageScore = artifactSummary.averageScore || 0;
-
-  // 一致性分数
-  const consistencyScore = calculateConsistencyScore(artifacts);
-
-  // 结构完整性分数
-  const structureScore = calculateStructureScore(artifacts);
-
-  // 加权计算分数
-  const weights = QUALITY_WEIGHTS.result;
-  let score = 0;
-  score += (artifactAverageScore / 100) * weights.artifactAverageScore * 100;
-  score += (consistencyScore / 100) * weights.consistencyScore * 100;
-  score += (structureScore / 100) * weights.structureScore * 100;
-
-  return {
-    score: Math.round(score),
-    details: {
-      artifactAverageScore: Math.round(artifactAverageScore),
-      consistencyScore: Math.round(consistencyScore),
-      structureScore: Math.round(structureScore),
-      lowScoreArtifacts: artifactSummary.lowScoreArtifacts || []
-    }
-  };
-}
-
-/**
- * 计算一致性分数
- * @param {Object} artifacts - 产出物评测数据
- * @returns {number} 一致性分数 (0-100)
- */
-function calculateConsistencyScore(artifacts) {
-  const consistencyScores = [];
-
-  for (const artifact of Object.values(artifacts)) {
-    if (artifact.evaluations?.consistency?.score !== undefined) {
-      consistencyScores.push(artifact.evaluations.consistency.score);
-    }
-  }
-
-  if (consistencyScores.length === 0) {
-    return 100; // 没有一致性检测时默认满分
-  }
-
-  return consistencyScores.reduce((a, b) => a + b, 0) / consistencyScores.length;
-}
-
-/**
- * 计算结构完整性分数
- * @param {Object} artifacts - 产出物评测数据
- * @returns {number} 结构完整性分数 (0-100)
- */
-function calculateStructureScore(artifacts) {
-  const structureScores = [];
-
-  for (const artifact of Object.values(artifacts)) {
-    if (artifact.evaluations?.structure?.score !== undefined) {
-      structureScores.push(artifact.evaluations.structure.score);
-    }
-  }
-
-  if (structureScores.length === 0) {
-    return 100; // 没有结构检测时默认满分
-  }
-
-  return structureScores.reduce((a, b) => a + b, 0) / structureScores.length;
-}
-
-/**
- * 计算路径指标分数（SDD 引导效果）
- * @param {Object} metrics - metrics.json 数据
- * @returns {Object} 路径指标分数
- */
-export function calculatePathScore(metrics) {
-  const pathEvaluation = metrics?.pathEvaluation || {};
-
-  // 如果有路径评测结果，直接使用
-  if (pathEvaluation.overall !== undefined) {
-    return {
-      score: pathEvaluation.overall,
-      details: {
-        complianceScore: pathEvaluation.compliance?.score || 0,
-        efficiencyScore: pathEvaluation.efficiency?.score || 0,
-        decisionScore: pathEvaluation.decision?.score || 0,
-        exceptionScore: pathEvaluation.exception?.score || 0
-      }
-    };
-  }
-
-  // 否则基于执行路径数据计算
-  const executionPath = metrics?.executionPath || {};
-  const complianceScore = calculateComplianceFromPath(executionPath);
-  const efficiencyScore = calculateEfficiencyFromPath(executionPath);
-  const decisionScore = calculateDecisionFromPath(executionPath, metrics);
-  const exceptionScore = calculateExceptionFromPath(executionPath, metrics);
-
-  // 加权计算分数
-  const weights = QUALITY_WEIGHTS.path;
-  let score = 0;
-  score += (complianceScore / 100) * weights.complianceScore * 100;
-  score += (efficiencyScore / 100) * weights.efficiencyScore * 100;
-  score += (decisionScore / 100) * weights.decisionScore * 100;
-  score += (exceptionScore / 100) * weights.exceptionScore * 100;
-
-  return {
-    score: Math.round(score),
-    details: {
-      complianceScore: Math.round(complianceScore),
-      efficiencyScore: Math.round(efficiencyScore),
-      decisionScore: Math.round(decisionScore),
-      exceptionScore: Math.round(exceptionScore)
-    }
-  };
-}
-
-/**
- * 从执行路径计算合规性分数
- */
-function calculateComplianceFromPath(executionPath) {
-  const gateStats = executionPath.gateStats || { passed: 0, blocked: 0 };
-  const total = gateStats.passed + gateStats.blocked;
-
-  if (total === 0) return 100;
-
-  // 门禁通过率
-  const gatePassRate = gateStats.passed / total;
-
-  // 检查必要阶段是否执行
-  const stages = executionPath.stages || [];
-  const requiredStages = ['01-require', '02-design', '03-implement'];
-  const missingStages = requiredStages.filter(s => !stages.includes(s));
-
-  // 缺失阶段扣分
-  const missingPenalty = missingStages.length * 10;
-
-  return Math.max(0, Math.round(gatePassRate * 100 - missingPenalty));
-}
-
-/**
- * 从执行路径计算效率分数
- */
-function calculateEfficiencyFromPath(executionPath) {
-  const toolStats = executionPath.toolStats || {};
-  const rollbackStats = executionPath.rollbackStats || { total: 0, success: 0 };
-
-  // 重复操作检测
-  const totalToolCalls = Object.values(toolStats).reduce((a, b) => a + b, 0);
-  const uniqueTools = Object.keys(toolStats).length;
-  const avgCallsPerTool = uniqueTools > 0 ? totalToolCalls / uniqueTools : 1;
-
-  // 重复调用惩罚
-  const repetitionPenalty = Math.max(0, (avgCallsPerTool - 3) * 5);
-
-  // 回退惩罚
-  const rollbackPenalty = rollbackStats.total * 5;
-
-  return Math.max(0, Math.round(100 - repetitionPenalty - rollbackPenalty));
-}
-
-/**
- * 从执行路径计算决策质量分数
- */
-function calculateDecisionFromPath(executionPath, metrics) {
-  const decisionStats = executionPath.decisionStats || { total: 0, human: 0, auto: 0 };
-  const totals = metrics?.totals || {};
-
-  if (decisionStats.total === 0) return 100;
-
-  // 人工介入率
-  const humanRate = decisionStats.human / decisionStats.total;
-
-  // 自动决策成功率（如果有记录）
-  const autoSuccessRate = totals.autoDecisionSuccess
-    ? totals.autoDecisionSuccess / Math.max(decisionStats.auto, 1)
-    : 1;
-
-  // 分数计算：人工介入越少越好，自动决策成功越高越好
-  const score = (1 - humanRate) * 50 + autoSuccessRate * 50;
-
-  return Math.round(score);
-}
-
-/**
- * 从执行路径计算异常处理分数
- */
-function calculateExceptionFromPath(executionPath, metrics) {
-  const rollbackStats = executionPath.rollbackStats || { total: 0, success: 0 };
-  const totals = metrics?.totals || {};
-
-  const errorCount = totals.errors?.length || 0;
-
-  if (errorCount === 0 && rollbackStats.total === 0) return 100;
-
-  // 错误恢复率
-  const recoveryRate = rollbackStats.total > 0
-    ? rollbackStats.success / rollbackStats.total
-    : 1;
-
-  // 错误惩罚
-  const errorPenalty = Math.min(errorCount * 5, 30);
-
-  return Math.round(recoveryRate * 100 - errorPenalty);
-}
-
-/**
- * 计算框架综合质量分数
- * @param {string} projectRoot - 项目根目录
- * @returns {Object} 综合质量分数
- */
-export function calculateFrameworkQualityScore(projectRoot) {
-  const metrics = getMetrics(projectRoot, false);
-
-  // 计算各维度分数
-  const processScore = calculateProcessScore(metrics);
-  const resultScore = calculateResultScore(metrics);
-  const pathScore = calculatePathScore(metrics);
-
-  // 加权计算综合分数
-  const weights = QUALITY_WEIGHTS.overall;
-  const overallScore = Math.round(
-    processScore.score * weights.process +
-    resultScore.score * weights.result +
-    pathScore.score * weights.path
-  );
-
-  return {
-    overall: overallScore,
-    grade: getScoreGrade(overallScore),
-    breakdown: {
-      process: processScore,
-      result: resultScore,
-      path: pathScore
-    }
-  };
-}
-
-/**
- * 获取分数等级
- * @param {number} score - 分数 (0-100)
- * @returns {string} 等级
- */
-export function getScoreGrade(score) {
-  if (score >= 90) return 'A';
-  if (score >= 80) return 'B';
-  if (score >= 70) return 'C';
-  if (score >= 60) return 'D';
-  return 'F';
-}
-
-/**
- * 检测错误模式
- * @param {Object} metrics - metrics.json 数据
- * @returns {Array} 错误模式列表
- */
-export function detectErrorPatterns(metrics) {
-  const errors = metrics?.totals?.errors || [];
-  const patterns = [];
-
-  // 按类型分组
-  const errorsByType = {};
-  for (const error of errors) {
-    const type = error.type || 'unknown';
-    if (!errorsByType[type]) {
-      errorsByType[type] = [];
-    }
-    errorsByType[type].push(error);
-  }
-
-  // 检测重复模式
-  for (const [type, typeErrors] of Object.entries(errorsByType)) {
-    if (typeErrors.length >= 3) {
-      patterns.push({
-        type: 'repeated_errors',
-        errorType: type,
-        count: typeErrors.length,
-        severity: 'high',
-        suggestion: `发现 ${type} 类型错误重复出现 ${typeErrors.length} 次，建议检查根本原因`
-      });
-    }
-  }
-
-  // 检测连续失败模式
-  const recentErrors = errors.slice(-5);
-  const recentTimeWindow = 5 * 60 * 1000; // 5分钟
-  const now = Date.now();
-
-  const recentFailures = recentErrors.filter(e => {
-    const errorTime = new Date(e.time).getTime();
-    return now - errorTime < recentTimeWindow;
-  });
-
-  if (recentFailures.length >= 3) {
-    patterns.push({
-      type: 'consecutive_failures',
-      count: recentFailures.length,
-      timeWindow: '5min',
-      severity: 'high',
-      suggestion: '短时间内多次失败，建议暂停并检查环境配置'
-    });
-  }
-
-  return patterns;
-}
-
-/**
- * 生成指标摘要
- * @param {string} projectRoot - 项目根目录
- * @returns {Object} 指标摘要
- */
-export function generateMetricsSummary(projectRoot) {
-  const metrics = getMetrics(projectRoot, false);
-  const qualityScore = calculateFrameworkQualityScore(projectRoot);
-  const errorPatterns = detectErrorPatterns(metrics);
-
-  return {
-    traceId: metrics.traceId,
-    pipelineStart: metrics.pipelineStart,
-    pipelineEnd: metrics.pipelineEnd || null,
-    qualityScore,
-    errorPatterns,
-    recommendations: generateRecommendations(qualityScore, errorPatterns)
-  };
-}
-
-/**
- * 生成改进建议
- * @param {Object} qualityScore - 质量分数
- * @param {Array} errorPatterns - 错误模式
- * @returns {Array} 改进建议列表
- */
-function generateRecommendations(qualityScore, errorPatterns) {
-  const recommendations = [];
-
-  // 基于分数的建议
-  if (qualityScore.breakdown.process.score < 70) {
-    recommendations.push({
-      area: 'process',
-      priority: 'high',
-      suggestion: '过程指标较低，建议优化 Layer1 验证流程，减少回退次数'
-    });
-  }
-
-  if (qualityScore.breakdown.result.score < 70) {
-    recommendations.push({
-      area: 'result',
-      priority: 'high',
-      suggestion: '产出物质量较低，建议加强需求分析和设计阶段的审查'
-    });
-  }
-
-  if (qualityScore.breakdown.path.score < 70) {
-    recommendations.push({
-      area: 'path',
-      priority: 'medium',
-      suggestion: '执行路径效率较低，建议检查是否存在重复操作或无效回退'
-    });
-  }
-
-  // 基于错误模式的建议
-  for (const pattern of errorPatterns) {
-    recommendations.push({
-      area: 'error',
-      priority: pattern.severity,
-      suggestion: pattern.suggestion
-    });
-  }
-
-  return recommendations;
-}
-
-export default {
-  QUALITY_WEIGHTS,
-  calculateProcessScore,
-  calculateResultScore,
-  calculatePathScore,
-  calculateFrameworkQualityScore,
-  getScoreGrade,
-  detectErrorPatterns,
-  generateMetricsSummary,
-  generateRecommendations
-};