@chongyan/autospec 1.0.1 → 1.0.2

package/plugins/skills/project-evolve-learner/SKILL.md

@@ -0,0 +1,103 @@
+---
+name: project-evolve-learner
+description: "学习模式：观察人工操作，学习团队偏好，调整进化策略"
+type: learner
+---
+
+# Project-Evolve Learner
+
+## 定位
+
+学习模式技能，观察人工操作，学习团队偏好，调整进化策略。
+
+## 输入
+
+- 人工修改记录
+- 团队偏好配置
+
+## 输出
+
+- 学习结果：团队偏好
+- 策略调整：优化建议
+- 偏好配置：更新后的偏好
+
+## 执行步骤
+
+### Step 1: 人工操作收集
+
+```
+收集人工操作：
+1. Git 提交记录
+2. 代码审查记录
+3. 配置变更
+4. 人工跳过建议
+```
+
+### Step 2: 行为分析
+
+```
+分析团队行为：
+1. 代码风格偏好
+2. 常用工具
+3. 审批习惯
+4. 问题处理方式
+```
+
+### Step 3: 偏好提取
+
+```
+提取团队偏好：
+1. 命名规范
+2. 注释习惯
+3. 测试策略
+4. 文档要求
+```
+
+### Step 4: 策略调整
+
+```
+调整进化策略：
+1. 降低某些建议优先级
+2. 增加特定检查
+3. 调整阈值
+4. 更新偏好配置
+```
+
+### Step 5: 效果验证
+
+```
+验证学习效果：
+1. 建议采纳率
+2. 人工干预减少
+3. 团队满意度
+```
+
+## 使用示例
+
+```
+# 执行学习模式
+读取 plugins/skills/project-evolve-learner/SKILL.md 并执行
+
+# 输出
+- 分析提交: 50
+- 发现偏好: 5
+- 策略调整: 3
+- 建议采纳率: +20%
+```
+
+## 学习内容
+
+| 类别 | 学习内容 | 应用 |
+|------|----------|------|
+| 代码风格 | 命名、格式、注释 | 调整 lint 规则 |
+| 测试策略 | 覆盖率、测试位置 | 调整检查阈值 |
+| 文档要求 | 文档深度、格式 | 调整文档检查 |
+| 审批流程 | 审批人、流程 | 调整确认点 |
+
+## 与其他技能的区别
+
+| 技能 | 侧重点 |
+|------|--------|
+| analyzer | 问题识别 |
+| fixer | 自动修复 |
+| **learner** | 从人工操作学习 |

package/plugins/skills/project-evolve-reviewer/SKILL.md

@@ -0,0 +1,104 @@
+---
+name: project-evolve-reviewer
+description: "效果回顾：回顾进化效果，持续改进，分析进化趋势"
+type: reviewer
+---
+
+# Project-Evolve Reviewer
+
+## 定位
+
+效果回顾技能，回顾进化效果，持续改进，分析进化趋势。
+
+## 输入
+
+- 历史进化记录
+- 时间范围（最近 N 天）
+
+## 输出
+
+- 效果报告：进化前后对比
+- 趋势分析：质量趋势
+- 改进机会：新的优化点
+
+## 执行步骤
+
+### Step 1: 历史数据收集
+
+```
+收集历史记录：
+1. 进化次数
+2. 修复数量
+3. 质量变化
+4. 时间线
+```
+
+### Step 2: 效果分析
+
+```
+分析进化效果：
+1. 代码质量趋势
+2. 测试覆盖率趋势
+3. 构建时间趋势
+4. Bug 率趋势
+```
+
+### Step 3: 改进评估
+
+```
+评估改进效果：
+1. 哪些改进有效
+2. 哪些改进无效
+3. 原因分析
+4. 经验总结
+```
+
+### Step 4: 机会识别
+
+```
+识别新机会：
+1. 重复问题模式
+2. 优化空间
+3. 自动化机会
+4. 工具改进
+```
+
+### Step 5: 报告生成
+
+```
+生成回顾报告：
+1. 效果总结
+2. 趋势图表
+3. 经验教训
+4. 下一步建议
+```
+
+## 使用示例
+
+```
+# 执行效果回顾
+读取 plugins/skills/project-evolve-reviewer/SKILL.md 并执行
+
+# 输出
+- 进化次数: 12
+- 质量提升: +15%
+- 有效改进: 85%
+- 下一步: 3个优化点
+```
+
+## 分析维度
+
+| 维度 | 分析内容 | 指标 |
+|------|----------|------|
+| 频率分析 | 进化频率 | 次/周 |
+| 效果分析 | 质量提升 | 分数变化 |
+| 效率分析 | 修复效率 | 时间/修复 |
+| 趋势分析 | 长期趋势 | 环比/同比 |
+
+## 与其他技能的区别
+
+| 技能 | 侧重点 |
+|------|--------|
+| analyzer | 当前问题分析 |
+| verifier | 单次修复验证 |
+| **reviewer** | 长期效果回顾 |

package/plugins/skills/project-evolve-scanner/SKILL.md

@@ -0,0 +1,95 @@
+---
+name: project-evolve-scanner
+description: "项目扫描：检测技术栈、目录结构、依赖配置，自动发现项目特征和评测点"
+type: scanner
+---
+
+# Project-Evolve Scanner
+
+## 定位
+
+项目扫描技能，用于检测项目技术栈、目录结构、依赖配置，自动发现项目特征和评测点。
+
+## 输入
+
+- 项目路径（默认当前目录）
+- 扫描深度配置
+
+## 输出
+
+- 项目特征报告：项目类型、框架、技术栈
+- 评测点列表：可优化的代码质量点
+- 记忆结构：用于后续进化分析
+
+## 执行步骤
+
+### Step 1: 技术栈检测
+
+```
+检测构建文件：
+- package.json → Node.js/React/Vue
+- pom.xml/build.gradle → Java/Spring
+- go.mod → Go
+- requirements.txt/pyproject.toml → Python
+- Cargo.toml → Rust
+- Gemfile → Ruby
+```
+
+### Step 2: 目录结构分析
+
+```
+检测目录：
+- src/, lib/ → 源码目录
+- tests/, test/ → 测试目录
+- docs/, documentation/ → 文档目录
+- config/ → 配置目录
+```
+
+### Step 3: 依赖分析
+
+```
+分析依赖：
+- 生产依赖
+- 开发依赖
+- 依赖版本
+```
+
+### Step 4: 评测点发现
+
+```
+自动发现：
+- 代码复杂度
+- 测试覆盖率
+- 文档完整性
+- 配置规范性
+```
+
+### Step 5: 生成记忆结构
+
+```
+创建记忆：
+- 项目特征
+- 评测点
+- 优化建议
+```
+
+## 使用示例
+
+```
+# 扫描当前项目
+读取 plugins/skills/project-evolve-scanner/SKILL.md 并执行
+
+# 输出
+- 项目类型: Node.js + React
+- 技术栈: TypeScript, Jest, ESLint
+- 评测点: 15个
+- 优化建议: 8条
+```
+
+## 与 self-evolve-scanner 的区别
+
+| 特性 | self-evolve-scanner | project-evolve-scanner |
+|------|---------------------|------------------------|
+| 目标 | 框架自我测试 | 扫描真实项目 |
+| 扫描内容 | 框架代码 | 用户项目代码 |
+| 输出 | 框架指标 | 项目评测点 |

package/plugins/skills/project-evolve-scanner/scripts/dependency-reuse-checker.js

@@ -0,0 +1,395 @@
+#!/usr/bin/env node
+
+/**
+ * Dependency Reuse Checker
+ *
+ * 检查依赖包复用情况，识别重复造轮子
+ *
+ * 功能：
+ * 1. 扫描项目依赖（package.json / pom.xml / build.gradle / go.mod 等）
+ * 2. 提取功能需求关键词，匹配现有依赖包
+ * 3. 检查团队组件使用手册
+ * 4. 搜索项目现有代码中是否有可复用的实现
+ * 5. 输出"依赖包优先"建议
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// 常见功能关键词与依赖包映射
+const FUNCTION_TO_PACKAGES = {
+  // HTTP 请求
+  'http': ['axios', 'fetch', 'node-fetch', 'got', 'request'],
+  'request': ['axios', 'fetch', 'node-fetch', 'got', 'request'],
+  'fetch': ['axios', 'fetch', 'node-fetch', 'got'],
+
+  // 数据处理
+  'json': ['fast-json-stable-stringify', 'lodash', 'ramda'],
+  'date': ['dayjs', 'moment', 'date-fns', 'luxon'],
+  'format': ['sprintf-js', 'numeral', 'decimal.js'],
+
+  // 验证
+  'validate': ['joi', 'yup', 'zod', 'validator'],
+  'schema': ['joi', 'yup', 'zod', 'ajv'],
+  'type': ['joi', 'yup', 'zod', 'runtypes'],
+
+  // 工具
+  'deep': ['lodash', 'ramda', 'deep-equal'],
+  'clone': ['lodash', 'ramda', 'clone-deep'],
+  'merge': ['lodash', 'ramda', 'deepmerge'],
+  'pick': ['lodash', 'ramda', 'filter-obj'],
+  'omit': ['lodash', 'ramda', 'filter-obj'],
+
+  // 加密
+  'crypto': ['crypto-js', 'bcrypt', 'argon2', 'scrypt'],
+  'hash': ['crypto-js', 'bcrypt', 'argon2', 'md5'],
+  'encrypt': ['crypto-js', 'bcrypt', 'argon2'],
+  'password': ['bcrypt', 'argon2', 'scrypt'],
+
+  // 异步
+  'promise': ['bluebird'],
+  'async': ['async', 'p-series', 'p-map'],
+  'retry': ['async-retry', 'p-retry', 'promise-retry'],
+  'timeout': ['timeout-abort-controller'],
+
+  // 日志
+  'log': ['winston', 'pino', 'loglevel', 'bunyan'],
+  'logger': ['winston', 'pino', 'bunyan'],
+
+  // 测试
+  'test': ['jest', 'mocha', 'ava', 'tap'],
+  'mock': ['jest-mock', 'sinon', 'proxyquire', 'mock-fs'],
+  'coverage': ['nyc', 'c8', 'istanbul'],
+
+  // 命令行
+  'cli': ['commander', 'yargs', 'meow', 'argparse'],
+  'prompt': ['inquirer', 'prompts', 'enquirer'],
+  'table': ['cli-table', 'table', 'ascii-table'],
+
+  // 文件
+  'glob': ['glob', 'fast-glob', 'minimatch'],
+  'fs': ['fs-extra', 'graceful-fs'],
+  'watch': ['chokidar', 'watch', 'gaze'],
+
+  // 环境
+  'env': ['dotenv', 'env-var', 'envalid'],
+  'config': ['convict', 'config', 'node-config'],
+
+  // 邮件
+  'email': ['nodemailer', 'sendgrid', 'mailgun-js'],
+  'mail': ['nodemailer', 'sendgrid', 'mailgun-js'],
+
+  // 缓存
+  'cache': ['node-cache', 'memory-cache', 'lru-cache'],
+  'redis': ['ioredis', 'node-redis', 'redis'],
+
+  // WebSocket
+  'websocket': ['ws', 'socket.io', 'primus'],
+  'socket': ['socket.io', 'ws', 'primus'],
+
+  // 验证
+  'email-validate': ['email-validator', 'validator'],
+  'url-validate': ['validator', 'is-url'],
+  'phone': ['phone', 'libphonenumber-js'],
+};
+
+// 解析命令行参数
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const options = {
+    project: '.',
+    verbose: false,
+    output: null,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    switch (args[i]) {
+      case '--project':
+      case '-p':
+        options.project = args[++i];
+        break;
+      case '--verbose':
+      case '-v':
+        options.verbose = true;
+        break;
+      case '--output':
+      case '-o':
+        options.output = args[++i];
+        break;
+      case '--help':
+      case '-h':
+        printHelp();
+        process.exit(0);
+        break;
+    }
+  }
+
+  return options;
+}
+
+function printHelp() {
+  console.log(`
+Dependency Reuse Checker
+
+用法：
+  node dependency-reuse-checker.js --project <path> [选项]
+
+选项：
+  -p, --project <path>   项目路径（默认：当前目录）
+  -o, --output <path>   输出报告路径（默认：stdout）
+  -v, --verbose         详细输出
+  -h, --help            显示帮助
+
+示例：
+  node dependency-reuse-checker.js --project ./my-project
+  node dependency-reuse-checker.js --project ./my-project --output report.json
+`);
+}
+
+// 读取项目依赖
+function readDependencies(projectPath) {
+  const deps = {
+    dependencies: {},
+    devDependencies: {},
+  };
+
+  // package.json
+  const packageJsonPath = path.join(projectPath, 'package.json');
+  if (fs.existsSync(packageJsonPath)) {
+    try {
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+      deps.dependencies = packageJson.dependencies || {};
+      deps.devDependencies = packageJson.devDependencies || {};
+    } catch (e) {
+      console.error('解析 package.json 失败:', e.message);
+    }
+  }
+
+  return deps;
+}
+
+// 扫描代码中的功能关键词
+function scanCodeForKeywords(projectPath) {
+  const keywords = new Set();
+  const patterns = [
+    /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+    /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g,
+  ];
+
+  function scanDir(dir) {
+    if (!fs.existsSync(dir)) return;
+
+    const files = fs.readdirSync(dir);
+    for (const file of files) {
+      const fullPath = path.join(dir, file);
+      const stat = fs.statSync(fullPath);
+
+      if (stat.isDirectory()) {
+        // 跳过 node_modules 和隐藏目录
+        if (file !== 'node_modules' && !file.startsWith('.')) {
+          scanDir(fullPath);
+        }
+      } else if (/\.(js|ts|jsx|tsx)$/.test(file)) {
+        try {
+          const content = fs.readFileSync(fullPath, 'utf-8');
+          for (const pattern of patterns) {
+            let match;
+            while ((match = pattern.exec(content)) !== null) {
+              const pkg = match[1];
+              // 检查是否是本地模块
+              if (!pkg.startsWith('.') && !pkg.startsWith('/')) {
+                // 提取关键词
+                const basePkg = pkg.split('/')[0].replace('@', '');
+                if (FUNCTION_TO_PACKAGES[basePkg]) {
+                  keywords.add(basePkg);
+                }
+              }
+            }
+          }
+        } catch (e) {
+          // 忽略读取错误
+        }
+      }
+    }
+  }
+
+  const srcDir = path.join(projectPath, 'src');
+  const libDir = path.join(projectPath, 'lib');
+  const appDir = path.join(projectPath, 'app');
+
+  scanDir(fs.existsSync(srcDir) ? srcDir : projectPath);
+  if (fs.existsSync(libDir)) scanDir(libDir);
+  if (fs.existsSync(appDir)) scanDir(appDir);
+
+  return Array.from(keywords);
+}
+
+// 检查是否有可复用的现有实现
+function checkExistingImplementation(projectPath, keyword) {
+  const results = [];
+
+  // 搜索可能的工具函数目录
+  const utilsDirs = ['utils', 'util', 'helpers', 'helper', 'lib', 'tools', 'common'];
+
+  function searchDir(dir, depth = 0) {
+    if (depth > 3) return; // 限制搜索深度
+
+    if (!fs.existsSync(dir)) return;
+
+    try {
+      const files = fs.readdirSync(dir);
+      for (const file of files) {
+        const fullPath = path.join(dir, file);
+        const stat = fs.statSync(fullPath);
+
+        if (stat.isDirectory()) {
+          if (!file.startsWith('.') && file !== 'node_modules') {
+            searchDir(fullPath, depth + 1);
+          }
+        } else if (/\.(js|ts)$/.test(file)) {
+          try {
+            const content = fs.readFileSync(fullPath, 'utf-8');
+            if (content.toLowerCase().includes(keyword.toLowerCase())) {
+              results.push({
+                file: path.relative(projectPath, fullPath),
+                match: keyword,
+              });
+            }
+          } catch (e) {
+            // 忽略
+          }
+        }
+      }
+    } catch (e) {
+      // 忽略权限错误
+    }
+  }
+
+  for (const utilsDir of utilsDirs) {
+    searchDir(path.join(projectPath, utilsDir));
+  }
+
+  return results;
+}
+
+// 生成建议
+function generateSuggestions(keyword, existingDeps, existingImpl) {
+  const suggestions = [];
+
+  // 检查是否已安装相关包
+  const relatedPkgs = FUNCTION_TO_PACKAGES[keyword] || [];
+  const installed = relatedPkgs.filter(pkg =>
+    existingDeps.dependencies[pkg] || existingDeps.devDependencies[pkg]
+  );
+
+  if (installed.length > 0) {
+    suggestions.push({
+      type: 'use-existing',
+      message: `已安装相关依赖: ${installed.join(', ')}`,
+      priority: 'high',
+    });
+  }
+
+  // 检查是否有现有实现
+  if (existingImpl.length > 0) {
+    suggestions.push({
+      type: 'use-existing',
+      message: `发现现有实现: ${existingImpl.map(e => e.file).join(', ')}`,
+      priority: 'medium',
+    });
+  }
+
+  // 建议使用依赖包
+  if (installed.length === 0 && existingImpl.length === 0) {
+    suggestions.push({
+      type: 'consider-package',
+      message: `建议使用依赖包: ${relatedPkgs.join(', ')}`,
+      priority: 'low',
+    });
+  }
+
+  return suggestions;
+}
+
+// 主函数
+async function main() {
+  const options = parseArgs();
+
+  console.log('🔍 Dependency Reuse Checker\n');
+
+  try {
+    // 1. 读取项目依赖
+    console.log('📦 读取项目依赖...');
+    const deps = readDependencies(options.project);
+    console.log(`   依赖: ${Object.keys(deps.dependencies).length}`);
+    console.log(`   开发依赖: ${Object.keys(deps.devDependencies).length}`);
+
+    // 2. 扫描代码关键词
+    console.log('\n🔎 扫描代码关键词...');
+    const keywords = scanCodeForKeywords(options.project);
+    console.log(`   发现关键词: ${keywords.join(', ')}`);
+
+    // 3. 分析每个关键词
+    console.log('\n📊 分析复用机会...\n');
+    const results = [];
+
+    for (const keyword of keywords) {
+      const existingImpl = checkExistingImplementation(options.project, keyword);
+      const suggestions = generateSuggestions(keyword, deps, existingImpl);
+
+      results.push({
+        keyword,
+        suggestions,
+        existingImplementation: existingImpl,
+      });
+
+      if (options.verbose) {
+        console.log(`\n[${keyword}]`);
+        for (const s of suggestions) {
+          console.log(`  - ${s.message}`);
+        }
+      }
+    }
+
+    // 4. 生成报告
+    const report = {
+      timestamp: new Date().toISOString(),
+      project: options.project,
+      summary: {
+        totalKeywords: keywords.length,
+        reuseOpportunities: results.filter(r => r.suggestions.some(s => s.type === 'use-existing')).length,
+        newPackageSuggestions: results.filter(r => r.suggestions.some(s => s.type === 'consider-package')).length,
+      },
+      results,
+    };
+
+    // 5. 输出
+    if (options.output) {
+      fs.writeFileSync(options.output, JSON.stringify(report, null, 2));
+      console.log(`\n✅ 报告已保存: ${options.output}`);
+    } else {
+      console.log('\n📋 总结:');
+      console.log(`   关键词总数: ${report.summary.totalKeywords}`);
+      console.log(`   复用机会: ${report.summary.reuseOpportunities}`);
+      console.log(`   新包建议: ${report.summary.newPackageSuggestions}`);
+    }
+
+    process.exit(0);
+
+  } catch (error) {
+    console.error('\n❌ 检查失败:', error.message);
+    if (options.verbose) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+main().catch(error => {
+  console.error('未捕获的错误:', error);
+  process.exit(1);
+});