@chongyan/autospec 1.0.2 → 1.0.3

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

@@ -1,326 +0,0 @@
-/**
- * 项目结构检测模块（确定性规则）
- *
- * 通过目录扫描和构建文件检测识别项目结构，不依赖固定目录名。
- */
-
-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

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