@chongyan/autospec 1.0.1

package/plugins/hooks/lib/project-structure-detector.js

@@ -0,0 +1,326 @@
+/**
+ * 项目结构检测模块（确定性规则）
+ *
+ * 通过目录扫描和构建文件检测识别项目结构，不依赖固定目录名。
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { detectTechStacks } from './technology-stack-detector.js';
+import { detectDataAIComponents } from './data-and-ai-detector.js';
+
+/**
+ * 检测项目结构
+ * @param {string} projectDir - 项目根目录
+ * @returns {Object} 项目结构分析结果
+ */
+export function detectProjectStructure(projectDir) {
+  const structure = {
+    // 项目类型
+    projectType: null,  // monorepo | single-app | microservices | library
+
+    // 技术栈列表
+    techStacks: [],
+
+    // 模块/子系统列表
+    modules: [],
+
+    // 入口文件
+    entryPoints: [],
+
+    // 数据/AI 组件
+    dataAIComponents: null,
+
+    // 目录结构概览
+    directoryOverview: []
+  };
+
+  // Step 1: 扫描目录结构
+  structure.directoryOverview = scanDirectories(projectDir);
+
+  // Step 2: 检测技术栈
+  structure.techStacks = detectTechStacks(projectDir);
+
+  // Step 3: 识别模块
+  structure.modules = identifyModules(projectDir, structure.techStacks);
+
+  // Step 4: 检测入口文件
+  structure.entryPoints = detectEntryPoints(projectDir, structure.techStacks);
+
+  // Step 5: 检测数据/AI 组件
+  structure.dataAIComponents = detectDataAIComponents(projectDir, structure.techStacks);
+
+  // Step 6: 推断项目类型
+  structure.projectType = inferProjectType(structure);
+
+  return structure;
+}
+
+/**
+ * 扫描目录结构
+ */
+function scanDirectories(projectDir, maxDepth = 2) {
+  const result = [];
+
+  function scan(dir, depth) {
+    if (depth > maxDepth) return;
+
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (entry.isDirectory() && !shouldIgnore(entry.name)) {
+          const fullPath = path.join(dir, entry.name);
+          const relativePath = path.relative(projectDir, fullPath);
+
+          result.push({
+            name: entry.name,
+            path: relativePath,
+            depth: depth
+          });
+
+          scan(fullPath, depth + 1);
+        }
+      }
+    } catch (e) {
+      // 忽略无权限目录
+    }
+  }
+
+  scan(projectDir, 0);
+  return result;
+}
+
+/**
+ * 判断是否应该忽略的目录
+ */
+function shouldIgnore(name) {
+  const ignorePatterns = [
+    'node_modules', '.git', '.svn', '.hg',
+    'dist', 'build', 'out', 'target',
+    '__pycache__', '.pytest_cache', '.mypy_cache',
+    'venv', 'env', '.venv', '.env',
+    '.idea', '.vscode', '.claude',
+    '.autospec', 'docs', 'tests', 'test'
+  ];
+
+  return ignorePatterns.includes(name) || name.startsWith('.');
+}
+
+/**
+ * 识别模块
+ */
+function identifyModules(projectDir, techStacks) {
+  const modules = [];
+
+  // 基于技术栈路径识别模块
+  const pathSet = new Set();
+  for (const tech of techStacks) {
+    const modulePath = tech.path;
+    if (modulePath && modulePath !== '.' && !pathSet.has(modulePath)) {
+      pathSet.add(modulePath);
+
+      modules.push({
+        name: path.basename(modulePath),
+        path: modulePath,
+        type: tech.type,
+        techStack: tech,
+        inferredFrom: 'build-file'
+      });
+    }
+  }
+
+  // 如果没有识别到模块，检查是否是单模块项目
+  if (modules.length === 0 && techStacks.length > 0) {
+    modules.push({
+      name: 'main',
+      path: '.',
+      type: techStacks[0].type,
+      techStack: techStacks[0],
+      inferredFrom: 'single-module'
+    });
+  }
+
+  return modules;
+}
+
+/**
+ * 检测入口文件
+ */
+function detectEntryPoints(projectDir, techStacks) {
+  const entryPoints = [];
+
+  // 入口文件模式（确定性规则）
+  const entryPatterns = {
+    python: [
+      'main.py', 'app.py', 'manage.py', 'run.py', 'wsgi.py', 'asgi.py',
+      'src/main.py', 'app/main.py'
+    ],
+    javascript: [
+      'index.js', 'app.js', 'server.js', 'main.js',
+      'src/index.js', 'src/app.js', 'src/server.js',
+      'index.ts', 'main.ts', 'app.ts',
+      'src/index.ts', 'src/main.ts', 'src/app.ts'
+    ],
+    java: [
+      'src/main/java/**/Application.java',
+      'src/main/java/**/Main.java',
+      'app/src/main/java/**/Application.java'
+    ],
+    go: [
+      'main.go', 'cmd/main.go', 'cmd/server/main.go'
+    ],
+    rust: [
+      'src/main.rs', 'src/lib.rs'
+    ],
+    dart: [
+      'lib/main.dart'
+    ]
+  };
+
+  for (const tech of techStacks) {
+    const lang = tech.lang;
+    const patterns = entryPatterns[lang] || [];
+
+    for (const pattern of patterns) {
+      // 简单的文件存在检查
+      const searchPath = tech.path === '.' ? pattern : `${tech.path}/${pattern}`;
+
+      // 处理通配符
+      if (pattern.includes('**')) {
+        const baseDir = path.dirname(searchPath.replace('**', ''));
+        const fileName = path.basename(pattern);
+        const fullBaseDir = path.join(projectDir, baseDir);
+
+        if (fs.existsSync(fullBaseDir)) {
+          const found = findFileRecursive(fullBaseDir, fileName.replace('.java', ''));
+          if (found) {
+            entryPoints.push({
+              path: path.relative(projectDir, found),
+              lang: lang,
+              module: tech.path
+            });
+          }
+        }
+      } else {
+        const fullPath = path.join(projectDir, searchPath);
+        if (fs.existsSync(fullPath)) {
+          entryPoints.push({
+            path: searchPath,
+            lang: lang,
+            module: tech.path
+          });
+        }
+      }
+    }
+  }
+
+  return entryPoints;
+}
+
+/**
+ * 递归查找文件
+ */
+function findFileRecursive(dir, namePart) {
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const found = findFileRecursive(path.join(dir, entry.name), namePart);
+        if (found) return found;
+      } else if (entry.name.includes(namePart)) {
+        return path.join(dir, entry.name);
+      }
+    }
+  } catch (e) {
+    // 忽略
+  }
+
+  return null;
+}
+
+/**
+ * 推断项目类型
+ */
+function inferProjectType(structure) {
+  const { techStacks, modules, directoryOverview } = structure;
+
+  // 多模块且有明确路径 → monorepo
+  if (modules.length > 1) {
+    // 检查是否有典型的 monorepo 目录
+    const hasPackages = directoryOverview.some(d => d.name === 'packages');
+    const hasApps = directoryOverview.some(d => d.name === 'apps');
+    const hasServices = directoryOverview.some(d => d.name === 'services');
+
+    if (hasPackages || hasApps) {
+      return 'monorepo';
+    }
+
+    if (modules.some(m => m.type === 'backend') &&
+        modules.some(m => m.type === 'frontend' || m.type === 'mobile')) {
+      return 'monorepo';
+    }
+
+    // 多个独立服务 → microservices
+    if (modules.filter(m => m.type === 'backend').length > 1) {
+      return 'microservices';
+    }
+
+    return 'monorepo';
+  }
+
+  // 单模块 → single-app 或 library
+  if (modules.length === 1) {
+    // 检查是否是库
+    const hasLibDir = directoryOverview.some(d => d.name === 'lib' || d.name === 'src');
+    const hasIndexFile = structure.entryPoints.some(e => e.path.includes('index.'));
+    const hasNoApp = !structure.entryPoints.some(e =>
+      e.path.includes('app.') || e.path.includes('server.') || e.path.includes('main.')
+    );
+
+    if (hasLibDir && hasIndexFile && hasNoApp) {
+      return 'library';
+    }
+
+    return 'single-app';
+  }
+
+  return 'unknown';
+}
+
+/**
+ * 获取项目结构摘要（用于展示）
+ */
+export function getStructureSummary(structure) {
+  const lines = [];
+
+  lines.push(`项目类型：${structure.projectType}`);
+  lines.push('');
+
+  if (structure.techStacks.length > 0) {
+    lines.push('技术栈:');
+    for (const tech of structure.techStacks) {
+      const typeLabel = tech.type ? ` (${tech.type})` : '';
+      lines.push(`  - ${tech.framework || tech.lang}${typeLabel} [${tech.path}]`);
+    }
+    lines.push('');
+  }
+
+  if (structure.modules.length > 0) {
+    lines.push('模块:');
+    for (const mod of structure.modules) {
+      lines.push(`  - ${mod.name} [${mod.path}] (${mod.type})`);
+    }
+    lines.push('');
+  }
+
+  if (structure.entryPoints.length > 0) {
+    lines.push('入口文件:');
+    for (const entry of structure.entryPoints) {
+      lines.push(`  - ${entry.path}`);
+    }
+  }
+
+  return lines.join('\n');
+}

package/plugins/hooks/lib/rollback-tracker.js

@@ -0,0 +1,346 @@
+/**
+ * Rollback Tracker - 回退原因追踪模块
+ *
+ * 记录和分析回退事件，支持精准回退机制（DP6）
+ */
+
+import { getMetrics, updateMetrics } from './hook-state-manager.js';
+import { getTraceId, recordEvent } from './trace-context.js';
+import { recordRollback } from './execution-path.js';
+
+/**
+ * 回退级别
+ */
+export const ROLLBACK_LEVELS = {
+  LEVEL_1: 1,  // 内联重试
+  LEVEL_2: 2,  // 修正循环（最多 3 次）
+  LEVEL_2_5: 2.5,  // 3-Strike 假设验证
+  LEVEL_3: 3   // 升级人工
+};
+
+/**
+ * 回退触发原因
+ */
+export const ROLLBACK_TRIGGERS = {
+  VALIDATION_FAIL: 'validation_fail',      // Layer1/Layer2 验证失败
+  SAFETY_CHECK: 'safety_check',            // 安全检查触发
+  HUMAN_INTERVENTION: 'human_intervention', // 人工干预
+  SCOPE_DRIFT: 'scope_drift',              // 范围漂移
+  DESIGN_GAP: 'design_gap',                // 设计缺陷
+  ENV_ISSUE: 'env_issue'                   // 环境问题
+};
+
+/**
+ * 回退结果
+ */
+export const ROLLBACK_OUTCOMES = {
+  SUCCESS: 'success',      // 回退成功，继续执行
+  ESCALATE: 'escalate',    // 需要升级
+  BLOCKED: 'blocked',      // 被阻塞
+  RETRY: 'retry'           // 需要重试
+};
+
+/**
+ * 记录回退事件
+ * @param {string} projectRoot - 项目根目录
+ * @param {Object} rollbackInfo - 回退信息
+ * @returns {Object} 记录结果
+ */
+export function trackRollback(projectRoot, rollbackInfo) {
+  const {
+    level,
+    trigger,
+    stage,
+    rootCause,
+    attemptedFix,
+    outcome,
+    context = {}
+  } = rollbackInfo;
+
+  const traceId = getTraceId(projectRoot);
+
+  // 创建回退记录
+  const entry = {
+    timestamp: new Date().toISOString(),
+    traceId,
+    level,
+    trigger,
+    stage,
+    rootCause,
+    attemptedFix,
+    outcome,
+    context,
+    retryCount: context.retryCount || 0
+  };
+
+  // 更新 metrics.json
+  const metrics = getMetrics(projectRoot, false);
+
+  if (!metrics.rollbacks) {
+    metrics.rollbacks = [];
+  }
+
+  metrics.rollbacks.push(entry);
+
+  // 更新汇总统计
+  if (!metrics.rollbackSummary) {
+    metrics.rollbackSummary = {
+      total: 0,
+      byLevel: {},
+      byTrigger: {},
+      byOutcome: {},
+      successRate: 0
+    };
+  }
+
+  metrics.rollbackSummary.total++;
+  metrics.rollbackSummary.byLevel[level] = (metrics.rollbackSummary.byLevel[level] || 0) + 1;
+  metrics.rollbackSummary.byTrigger[trigger] = (metrics.rollbackSummary.byTrigger[trigger] || 0) + 1;
+  metrics.rollbackSummary.byOutcome[outcome] = (metrics.rollbackSummary.byOutcome[outcome] || 0) + 1;
+
+  // 计算成功率
+  const successCount = metrics.rollbacks.filter(r => r.outcome === ROLLBACK_OUTCOMES.SUCCESS).length;
+  metrics.rollbackSummary.successRate = successCount / metrics.rollbacks.length;
+
+  updateMetrics(projectRoot, metrics);
+
+  // 记录到执行路径
+  recordRollback(projectRoot, level, trigger, outcome, {
+    stage,
+    rootCause
+  });
+
+  // 记录到 trace 日志
+  if (traceId) {
+    recordEvent(projectRoot, 'rollback', {
+      source: 'rollback-tracker',
+      stage,
+      action: 'rollback',
+       data: {
+        level,
+        trigger,
+        outcome,
+        rootCause
+      }
+    });
+  }
+
+  return entry;
+}
+
+/**
+ * 获取回退历史
+ * @param {string} projectRoot - 项目根目录
+ * @param {Object} filters - 过滤条件
+ * @returns {Array} 回退历史
+ */
+export function getRollbackHistory(projectRoot, filters = {}) {
+  const metrics = getMetrics(projectRoot, true);
+  let rollbacks = metrics?.rollbacks || [];
+
+  if (filters.stage) {
+    rollbacks = rollbacks.filter(r => r.stage === filters.stage);
+  }
+
+  if (filters.trigger) {
+    rollbacks = rollbacks.filter(r => r.trigger === filters.trigger);
+  }
+
+  if (filters.level) {
+    rollbacks = rollbacks.filter(r => r.level === filters.level);
+  }
+
+  if (filters.traceId) {
+    rollbacks = rollbacks.filter(r => r.traceId === filters.traceId);
+  }
+
+  return rollbacks;
+}
+
+/**
+ * 分析回退模式
+ * @param {string} projectRoot - 项目根目录
+ * @returns {Object} 回退模式分析
+ */
+export function analyzeRollbackPatterns(projectRoot) {
+  const metrics = getMetrics(projectRoot, true);
+  const rollbacks = metrics?.rollbacks || [];
+
+  if (rollbacks.length === 0) {
+    return {
+      hasPatterns: false,
+      patterns: [],
+      recommendations: []
+    };
+  }
+
+  const patterns = [];
+
+  // 检测重复触发模式
+  const triggerCounts = {};
+  for (const rollback of rollbacks) {
+    triggerCounts[rollback.trigger] = (triggerCounts[rollback.trigger] || 0) + 1;
+  }
+
+  for (const [trigger, count] of Object.entries(triggerCounts)) {
+    if (count >= 3) {
+      patterns.push({
+        type: 'repeated_trigger',
+        trigger,
+        count,
+        severity: 'high',
+        message: `${trigger} 触发回退 ${count} 次，建议检查根本原因`
+      });
+    }
+  }
+
+  // 检测阶段回退模式
+  const stageCounts = {};
+  for (const rollback of rollbacks) {
+    stageCounts[rollback.stage] = (stageCounts[rollback.stage] || 0) + 1;
+  }
+
+  for (const [stage, count] of Object.entries(stageCounts)) {
+    if (count >= 3) {
+      patterns.push({
+        type: 'stage_issue',
+        stage,
+        count,
+        severity: 'medium',
+        message: `${stage} 阶段回退 ${count} 次，可能需要改进该阶段的 skill`
+      });
+    }
+  }
+
+  // 检测升级模式
+  const escalatedRollbacks = rollbacks.filter(r => r.outcome === ROLLBACK_OUTCOMES.ESCALATE);
+  if (escalatedRollbacks.length >= 2) {
+    patterns.push({
+      type: 'escalation_pattern',
+      count: escalatedRollbacks.length,
+      severity: 'high',
+      message: `${escalatedRollbacks.length} 次回退升级到人工，建议分析是否可自动化`
+    });
+  }
+
+  // 生成建议
+  const recommendations = [];
+  for (const pattern of patterns) {
+    if (pattern.type === 'repeated_trigger') {
+      recommendations.push({
+        priority: 'high',
+        area: pattern.trigger,
+        suggestion: `针对 ${pattern.trigger} 创建专门的 skill 或更新现有 skill`
+      });
+    } else if (pattern.type === 'stage_issue') {
+      recommendations.push({
+        priority: 'medium',
+        area: pattern.stage,
+        suggestion: `改进 ${pattern.stage} 阶段的执行策略`
+      });
+    } else if (pattern.type === 'escalation_pattern') {
+      recommendations.push({
+        priority: 'high',
+        area: 'automation',
+        suggestion: '分析升级原因，考虑自动化解决方案'
+      });
+    }
+  }
+
+  return {
+    hasPatterns: patterns.length > 0,
+    patterns,
+    recommendations,
+    summary: metrics?.rollbackSummary || {}
+  };
+}
+
+/**
+ * 检查是否需要升级人工
+ * @param {string} projectRoot - 项目根目录
+ * @param {string} stage - 当前阶段
+ * @param {string} trigger - 触发原因
+ * @returns {Object} { shouldEscalate: boolean, reason: string }
+ */
+export function shouldEscalateToHuman(projectRoot, stage, trigger) {
+  const metrics = getMetrics(projectRoot, true);
+  const rollbacks = metrics?.rollbacks || [];
+
+  // 检查同一阶段同一触发原因的回退次数
+  const recentRollbacks = rollbacks.filter(r =>
+    r.stage === stage &&
+    r.trigger === trigger &&
+    Date.now() - new Date(r.timestamp).getTime() < 30 * 60 * 1000  // 30 分钟内
+  );
+
+  if (recentRollbacks.length >= 3) {
+    return {
+      shouldEscalate: true,
+      reason: `同一问题在 30 分钟内回退 ${recentRollbacks.length} 次，建议升级人工处理`
+    };
+  }
+
+  // 检查 Level 2 回退次数
+  const level2Rollbacks = rollbacks.filter(r =>
+    r.level === ROLLBACK_LEVELS.LEVEL_2 &&
+    r.stage === stage
+  );
+
+  if (level2Rollbacks.length >= 3) {
+    return {
+      shouldEscalate: true,
+      reason: `Level 2 修正循环已达 ${level2Rollbacks.length} 次，需要人工介入`
+    };
+  }
+
+  return {
+    shouldEscalate: false,
+    reason: '回退次数在可接受范围内'
+  };
+}
+
+/**
+ * 生成回退报告
+ * @param {string} projectRoot - 项目根目录
+ * @returns {Object} 回退报告
+ */
+export function generateRollbackReport(projectRoot) {
+  const history = getRollbackHistory(projectRoot);
+  const patterns = analyzeRollbackPatterns(projectRoot);
+  const metrics = getMetrics(projectRoot, true);
+
+  return {
+    summary: {
+      totalRollbacks: history.length,
+      successRate: metrics?.rollbackSummary?.successRate || 0,
+      mostCommonTrigger: getMostCommon(metrics?.rollbackSummary?.byTrigger),
+      mostProblematicStage: getMostCommon(metrics?.rollbackSummary?.byStage)
+    },
+    patterns,
+    recentRollbacks: history.slice(-10),
+    recommendations: patterns.recommendations
+  };
+}
+
+/**
+ * 获取最常见的项
+ */
+function getMostCommon(counts) {
+  if (!counts || Object.keys(counts).length === 0) {
+    return null;
+  }
+
+  return Object.entries(counts)
+    .sort((a, b) => b[1] - a[1])[0][0];
+}
+
+export default {
+  ROLLBACK_LEVELS,
+  ROLLBACK_TRIGGERS,
+  ROLLBACK_OUTCOMES,
+  trackRollback,
+  getRollbackHistory,
+  analyzeRollbackPatterns,
+  shouldEscalateToHuman,
+  generateRollbackReport
+};