@chongyan/autospec 1.0.1

package/plugins/hooks/lib/benchmarks/integration-example.js

@@ -0,0 +1,169 @@
+/**
+ * Benchmarks Integration Example
+ * 实战项目 benchmarks 集成示例
+ *
+ * 展示如何在实际项目中使用 AutoSpec benchmarks 系统进行自动化评测
+ */
+
+const ChangeDetector = require('./change-detector');
+const BenchmarkEvaluator = require('./evaluator');
+
+class BenchmarksIntegration {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.changeDetector = new ChangeDetector(projectRoot);
+    this.evaluator = new BenchmarkEvaluator(projectRoot);
+  }
+
+  /**
+   * 初始化 benchmarks 系统
+   */
+  init() {
+    this.changeDetector.init();
+    this.evaluator.init();
+
+    // 启动文件监听
+    this.setupWatchers();
+
+    console.log('✅ Benchmarks 系统已初始化');
+    return this;
+  }
+
+  /**
+   * 设置文件监听器
+   */
+  setupWatchers() {
+    const stages = ['requirement', 'design', 'implementation', 'testing'];
+
+    for (const stage of stages) {
+      this.changeDetector.on('change', (changes) => {
+        console.log(`\n📝 检测到 ${changes.stage} 阶段产出物变更:`);
+        console.log(this.changeDetector.generateChangeSummary(changes));
+
+        // 自动触发评测
+        this.runEvaluation(changes.stage);
+      });
+    }
+  }
+
+  /**
+   * 执行评测
+   */
+  async runEvaluation(stage) {
+    console.log(`\n🔍 正在执行 ${stage} 阶段 benchmarks 评测...`);
+
+    try {
+      const report = await this.evaluator.evaluate(stage, {
+        trigger: 'auto'
+      });
+
+      // 输出评测结果摘要
+      this.printReportSummary(report);
+
+      // 根据结果采取行动
+      await this.handleEvaluationResult(report);
+
+    } catch (error) {
+      console.error(`评测执行失败: ${error.message}`);
+    }
+  }
+
+  /**
+   * 打印评测报告摘要
+   */
+  printReportSummary(report) {
+    const { summary } = report;
+
+    console.log('\n📊 评测结果:');
+    console.log(`  总分: ${summary.overall_score} (${summary.grade})`);
+    console.log(`  通过: ${summary.passed}/${summary.total}`);
+    console.log(`  通过率: ${summary.pass_rate}%`);
+    console.log(`  耗时: ${summary.duration_ms}ms`);
+
+    // 显示未通过的 benchmark
+    const failed = report.results.filter(r => r.status === 'failed');
+    if (failed.length > 0) {
+      console.log('\n❌ 未通过的 Benchmarks:');
+      for (const result of failed) {
+        console.log(`  - ${result.benchmark_id}: ${result.name} (${result.score}分)`);
+      }
+    }
+
+    // 显示改进建议
+    if (report.recommendations.length > 0) {
+      console.log('\n💡 改进建议:');
+      for (const rec of report.recommendations.slice(0, 3)) {
+        console.log(`  [${rec.priority}] ${rec.suggestion}`);
+      }
+    }
+  }
+
+  /**
+   * 处理评测结果
+   */
+  async handleEvaluationResult(report) {
+    const { summary } = report;
+
+    // 判断是否通过准出标准
+    const passed = summary.overall_score >= 80 &&
+                   report.results.every(r =>
+                     r.priority !== 'P0' || r.status === 'passed'
+                   );
+
+    if (passed) {
+      console.log('\n✅ 评测通过，允许进入下一阶段');
+      this.updateStageState(report.stage, 'passed');
+    } else {
+      console.log('\n⚠️ 评测未通过，需要改进');
+      this.updateStageState(report.stage, 'failed');
+
+      // 如果有可自动修复的建议，尝试自动修复
+      const autoFixable = report.recommendations.filter(r => r.auto_fixable);
+      if (autoFixable.length > 0) {
+        console.log(`\n🔧 尝试自动修复 ${autoFixable.length} 个问题...`);
+        // 执行自动修复...
+      }
+    }
+  }
+
+  /**
+   * 更新阶段状态
+   */
+  updateStageState(stage, status) {
+    // 更新 .autospec/runtime/state.json
+    const statePath = `${this.projectRoot}/.autospec/runtime/state.json`;
+    // 实现状态更新逻辑...
+  }
+
+  /**
+   * 手动触发评测
+   */
+  async manualEvaluate(stage) {
+    return this.runEvaluation(stage);
+  }
+
+  /**
+   * 获取评测历史趋势
+   */
+  getTrend(stage) {
+    return this.evaluator.getTrend(stage);
+  }
+}
+
+// 使用示例
+async function main() {
+  const projectRoot = process.cwd();
+  const benchmarks = new BenchmarksIntegration(projectRoot);
+
+  benchmarks.init();
+
+  // 手动触发 requirement 阶段评测
+  // await benchmarks.manualEvaluate('requirement');
+}
+
+module.exports = { BenchmarksIntegration };
+
+// 如果直接运行此文件
+if (require.main === module) {
+  main().catch(console.error);
+}

package/plugins/hooks/lib/data-and-ai-detector.js

@@ -0,0 +1,275 @@
+/**
+ * 数据/AI 开发检测模块（配置驱动）
+ *
+ * 检测数据开发和 AI 开发相关组件，规则从配置文件加载。
+ * 包括：
+ * - 数据仓库、ETL 管道、数据处理
+ * - 模型训练、推理服务、LLM 应用、Agent 框架
+ * - 向量存储、评测框架
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { getDataComponentRules, getAIComponentRules, getIgnoreDirectories } from './environment-config-loader.js';
+
+/**
+ * 检测数据/AI 组件
+ * @param {string} projectDir - 项目根目录
+ * @param {Array} techStacks - 已检测的技术栈
+ * @returns {Object} 数据/AI 组件检测结果
+ */
+export function detectDataAIComponents(projectDir, techStacks) {
+  const result = {
+    hasDataComponents: false,
+    hasAIComponents: false,
+    needsEvaluation: false,
+    components: []
+  };
+
+  // 从配置加载规则
+  const dataRules = getDataComponentRules();
+  const aiRules = getAIComponentRules();
+  const ignoreDirs = getIgnoreDirectories();
+
+  // 收集所有依赖
+  const allDependencies = new Set();
+  for (const tech of techStacks) {
+    if (tech.dependencies) {
+      tech.dependencies.forEach(d => allDependencies.add(d.toLowerCase()));
+    }
+  }
+
+  // 扫描目录
+  const directories = scanDirectories(projectDir, ignoreDirs);
+
+  // 扫描文件模式
+  const filePatterns = scanFilePatterns(projectDir, ignoreDirs);
+
+  // 检测数据组件
+  for (const [key, rule] of Object.entries(dataRules)) {
+    const detected = detectComponent(key, rule, directories, filePatterns, allDependencies, projectDir);
+    if (detected) {
+      result.components.push(detected);
+      result.hasDataComponents = true;
+    }
+  }
+
+  // 检测 AI 组件
+  const detectedAIComponents = {};
+  for (const [key, rule] of Object.entries(aiRules)) {
+    // 跳过需要组合检测的
+    if (rule.requiresBoth) continue;
+
+    const detected = detectComponent(key, rule, directories, filePatterns, allDependencies, projectDir);
+    if (detected) {
+      result.components.push(detected);
+      result.hasAIComponents = true;
+      detectedAIComponents[key] = detected;
+
+      if (rule.needsEvaluation) {
+        result.needsEvaluation = true;
+      }
+    }
+  }
+
+  // 检测 RAG 应用（需要向量存储 + LLM）
+  const ragRule = aiRules.ragApplication;
+  if (ragRule && detectedAIComponents.vectorStore && detectedAIComponents.llmApplication) {
+    result.components.push({
+      name: 'ragApplication',
+      label: ragRule.label,
+      type: ragRule.type,
+      needsEvaluation: true,
+      detectedFrom: 'combination',
+      components: ['vectorStore', 'llmApplication']
+    });
+    result.needsEvaluation = true;
+  }
+
+  return result;
+}
+
+/**
+ * 检测单个组件
+ */
+function detectComponent(key, rule, directories, filePatterns, dependencies, projectDir) {
+  const signals = [];
+
+  // 检查构建文件
+  if (rule.buildFiles) {
+    for (const bf of rule.buildFiles) {
+      const found = findBuildFile(projectDir, bf);
+      if (found) {
+        signals.push({ type: 'buildFile', value: found, weight: 3 });
+      }
+    }
+  }
+
+  // 检查目录
+  if (rule.directories) {
+    for (const dir of rule.directories) {
+      if (directories.has(dir.toLowerCase())) {
+        signals.push({ type: 'directory', value: dir, weight: 2 });
+      }
+    }
+  }
+
+  // 检查文件模式
+  if (rule.filePatterns) {
+    for (const pattern of rule.filePatterns) {
+      if (filePatterns.has(pattern.toLowerCase().replace('*', ''))) {
+        signals.push({ type: 'filePattern', value: pattern, weight: 1 });
+      }
+    }
+  }
+
+  // 检查依赖
+  if (rule.dependencies) {
+    for (const dep of rule.dependencies) {
+      if (dependencies.has(dep.toLowerCase())) {
+        signals.push({ type: 'dependency', value: dep, weight: 2 });
+      }
+    }
+  }
+
+  // 如果有信号，返回检测结果
+  if (signals.length > 0) {
+    const totalWeight = signals.reduce((sum, s) => sum + s.weight, 0);
+    return {
+      name: rule.label || key,
+      type: rule.type,
+      needsEvaluation: rule.needsEvaluation || false,
+      signals: signals,
+      confidence: totalWeight >= 3 ? 'high' : (totalWeight >= 2 ? 'medium' : 'low')
+    };
+  }
+
+  return null;
+}
+
+/**
+ * 扫描目录
+ */
+function scanDirectories(projectDir, ignoreDirs) {
+  const directories = new Set();
+
+  function scan(dir, depth) {
+    if (depth > 2) return;
+
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (entry.isDirectory() && !shouldIgnoreDir(entry.name, ignoreDirs)) {
+          directories.add(entry.name.toLowerCase());
+          scan(path.join(dir, entry.name), depth + 1);
+        }
+      }
+    } catch (e) {
+      // 忽略
+    }
+  }
+
+  scan(projectDir, 0);
+  return directories;
+}
+
+/**
+ * 扫描文件模式
+ */
+function scanFilePatterns(projectDir, ignoreDirs) {
+  const patterns = new Set();
+
+  function scan(dir, depth) {
+    if (depth > 2) return;
+
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+
+        if (entry.isDirectory() && !shouldIgnoreDir(entry.name, ignoreDirs)) {
+          scan(fullPath, depth + 1);
+        } else if (entry.isFile()) {
+          // 提取文件名模式
+          const name = entry.name.toLowerCase();
+          patterns.add(name);
+
+          // 提取关键词模式
+          if (name.includes('train')) patterns.add('train');
+          if (name.includes('eval')) patterns.add('eval');
+          if (name.includes('agent')) patterns.add('agent');
+          if (name.includes('pipeline')) patterns.add('pipeline');
+          if (name.includes('dag')) patterns.add('dag');
+        }
+      }
+    } catch (e) {
+      // 忽略
+    }
+  }
+
+  scan(projectDir, 0);
+  return patterns;
+}
+
+/**
+ * 查找构建文件
+ */
+function findBuildFile(projectDir, fileName) {
+  const searchPaths = ['.', 'src', 'lib', 'app'];
+
+  for (const sp of searchPaths) {
+    const fullPath = path.join(projectDir, sp, fileName);
+    if (fs.existsSync(fullPath)) {
+      return path.join(sp, fileName);
+    }
+  }
+
+  return null;
+}
+
+/**
+ * 判断是否应该忽略的目录
+ */
+function shouldIgnoreDir(name, ignoreDirs) {
+  return ignoreDirs.includes(name) || name.startsWith('.');
+}
+
+/**
+ * 获取数据/AI 组件摘要
+ */
+export function getDataAISummary(components) {
+  if (!components || components.length === 0) {
+    return '未检测到数据/AI 组件';
+  }
+
+  const lines = [];
+  const dataComps = components.filter(c =>
+    c.type.startsWith('data') || c.type === 'etl-pipeline'
+  );
+  const aiComps = components.filter(c =>
+    c.type.includes('llm') || c.type.includes('agent') ||
+    c.type.includes('model') || c.type.includes('inference') ||
+    c.type.includes('vector') || c.type.includes('rag') ||
+    c.type.includes('evaluation')
+  );
+
+  if (dataComps.length > 0) {
+    lines.push('数据组件:');
+    for (const comp of dataComps) {
+      const evalLabel = comp.needsEvaluation ? ' [需效果评测]' : '';
+      lines.push(`  - ${comp.name}${evalLabel}`);
+    }
+  }
+
+  if (aiComps.length > 0) {
+    lines.push('AI 组件:');
+    for (const comp of aiComps) {
+      const evalLabel = comp.needsEvaluation ? ' [需效果评测]' : '';
+      lines.push(`  - ${comp.name}${evalLabel}`);
+    }
+  }
+
+  return lines.join('\n');
+}