@pigcloud/skills 1.0.0

package/skills/code-review/references/template-review.md

@@ -0,0 +1,214 @@
+# 代码评审报告模板
+
+> 用于 code-review Skill 输出的标准格式
+
+---
+
+## 模板内容
+
+```markdown
+# 代码评审报告
+
+## 评审概要
+
+| 字段 | 内容 |
+|------|------|
+| 评审时间 | {datetime} |
+| 评审文件数 | {count} |
+| 变更行数 | +{add} / -{del} |
+| 评审耗时 | {duration} |
+| 规则覆盖率 | {coverage}% |
+| Rubric 评分 | {score}/10 |
+
+---
+
+## 问题列表
+
+### P0 问题（阻断性 - 必须修复）
+
+#### 问题 #1
+
+| 字段 | 内容 |
+|------|------|
+| 文件 | `{filePath}` |
+| 行号 | {lineNumber} |
+| 规则 | {ruleId}: {ruleName} |
+| 类型 | MUST / NEVER |
+| 问题 | {问题描述} |
+| 代码 | `{问题代码片段}` |
+| 修复 | `{修复建议}` |
+| 依据 | [规则定义](references/rules.md#{ruleId}) |
+
+---
+
+### P1 问题（严重 - 必须修复）
+
+#### 问题 #2
+
+| 字段 | 内容 |
+|------|------|
+| 文件 | `{filePath}` |
+| 行号 | {lineNumber} |
+| 规则 | {ruleId}: {ruleName} |
+| 类型 | MUST / NEVER |
+| 问题 | {问题描述} |
+| 代码 | `{问题代码片段}` |
+| 修复 | `{修复建议}` |
+| 依据 | [规则定义](references/rules.md#{ruleId}) |
+
+---
+
+### P2 问题（最佳实践 - 建议修复）
+
+#### 问题 #3
+
+| 字段 | 内容 |
+|------|------|
+| 文件 | `{filePath}` |
+| 行号 | {lineNumber} |
+| 规则 | {ruleId}: {ruleName} |
+| 问题 | {问题描述} |
+| 修复 | `{修复建议}` |
+
+---
+
+### P3 问题（建议改进）
+
+#### 问题 #4
+
+| 字段 | 内容 |
+|------|------|
+| 文件 | `{filePath}` |
+| 规则 | {ruleId}: {ruleName} |
+| 问题 | {问题描述} |
+| 建议 | `{改进建议}` |
+
+---
+
+## 跨模块影响分析
+
+### 变更文件
+
+| 文件 | 类型 | 模块 |
+|------|------|------|
+| `{filePath}` | 新增 / 修改 / 删除 | `{module}` |
+
+### 影响模块
+
+| 模块 | 影响类型 | 变更内容 | 建议 |
+|------|----------|----------|------|
+| `{module}` | API变更 / 依赖变更 / 数据变更 | `{content}` | `{suggestion}` |
+
+### 依赖关系图
+
+```
+{moduleA} → {moduleB} → {moduleC}
+    ↓
+{moduleD}
+```
+
+---
+
+## 安全检查结果
+
+| 维度 | 结果 | 问题数 | 详情 |
+|------|------|--------|------|
+| 硬编码 | ✅ / ⚠️ | {count} | {details} |
+| 日志 | ✅ / ⚠️ | {count} | {details} |
+| SQL注入 | ✅ / ⚠️ | {count} | {details} |
+| XSS | ✅ / ⚠️ | {count} | {details} |
+
+---
+
+## 性能检查结果
+
+| 维度 | 结果 | 问题数 | 详情 |
+|------|------|--------|------|
+| N+1查询 | ✅ / ⚠️ | {count} | {details} |
+| Left-fuzzy LIKE | ✅ / ⚠️ | {count} | {details} |
+| 批量操作 | ✅ / ⚠️ | {count} | {details} |
+
+---
+
+## Rubric 自检结果
+
+| 规则 | 结果 | 说明 |
+|------|------|------|
+| R1: 渐进式加载 | ✅ / ⚠️ | {message} |
+| R2: 规则覆盖率 | ✅ / ⚠️ | {coverage}% |
+| R3: 位置准确性 | ✅ / ⚠️ | 偏差 {diff} 行 |
+| R4: 可解释性 | ✅ / ⚠️ | {coverage}% |
+| R5: 问题分级 | ✅ / ⚠️ | {message} |
+| R6: 跨模块影响 | ✅ / ⚠️ | {message} |
+| R7: 输出格式 | ✅ / ⚠️ | {message} |
+| R8: 确认节点 | ✅ / ⚠️ | {message} |
+| R9: Pre-Delivery | ✅ / ⚠️ | {message} |
+| R10: 反 Slop | ✅ / ⚠️ | {message} |
+
+---
+
+## 评审结论
+
+| 结论 | 条件 | 当前状态 |
+|------|------|----------|
+| ✅ 通过 | 0 个 P0/P1 问题 | {status} |
+| ⚠️ 需修改后通过 | 有 P0/P1 问题，修复后重新评审 | {status} |
+| ❌ 不通过 | >5 个 P0 问题 | {status} |
+
+---
+
+## 下一步建议
+
+1. {修复建议1}
+2. {修复建议2}
+3. 执行 `mvn compile -q` 验证编译
+4. 执行 `mvn test -q` 验证测试
+5. 重新提交评审
+
+---
+
+## 评审人
+
+| 字段 | 内容 |
+|------|------|
+| 评审工具 | pig-skills code-review v{version} |
+| 评审模型 | {model} |
+| Rubric 评分 | {score}/10 |
+
+---
+
+*报告生成时间: {timestamp}*
+```
+
+---
+
+## 使用说明
+
+### 填充变量
+
+| 变量 | 来源 |
+|------|------|
+| `{datetime}` | 当前时间 |
+| `{count}` | Git diff 文件数 |
+| `{add}` / `{del}` | Git diff 行数统计 |
+| `{duration}` | 评审耗时 |
+| `{coverage}` | lint 脚本计算 |
+| `{score}` | Rubric 自检结果 |
+| `{filePath}` | 变更文件路径 |
+| `{lineNumber}` | lint 脚本定位 |
+| `{ruleId}` | 规则ID（MUST-001 等） |
+| `{ruleName}` | 规则名称 |
+| `{module}` | 模块名称（包路径） |
+
+### 输出位置
+
+```
+.agents/specs/REVIEW-{timestamp}.md
+```
+
+### 命名规则
+
+```
+REVIEW-{YYYYMMDD}-{HHMMSS}.md
+例如: REVIEW-20260616-143000.md
+```

package/skills/code-review/scripts/lint-code-review.mjs

@@ -0,0 +1,431 @@
+#!/usr/bin/env node
+
+/**
+ * lint-code-review.mjs - 零依赖代码审查 Lint 脚本
+ * 
+ * 用法:
+ *   node lint-code-review.mjs --files <file-list>
+ *   node lint-code-review.mjs --files <file-list> --json
+ *   node lint-code-review.mjs --files <file-list> --quick
+ * 
+ * 输出:
+ *   P0-P3 分级问题列表
+ *   JSON 格式支持 CI 集成
+ */
+
+import { readFileSync, existsSync, statSync } from 'fs';
+import { join, basename } from 'path';
+
+// 命令行参数解析
+const args = process.argv.slice(2);
+const options = {
+  files: [],
+  json: false,
+  quick: false
+};
+
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--files') {
+    options.files = args[i + 1]?.split(',').filter(f => f) || [];
+    i++;
+  } else if (args[i] === '--json') {
+    options.json = true;
+  } else if (args[i] === '--quick') {
+    options.quick = true;
+  }
+}
+
+// 规则定义
+const RULES = {
+  // MUST 规则
+  'MUST-001': {
+    level: 'P1',
+    name: 'Entity 基类',
+    pattern: /class\s+\w+Entity\s+extends\s+/,
+    check: (content, filePath) => {
+      if (!filePath.includes('Entity')) return null;
+      if (!content.includes('MpRealDelEntity') && !content.includes('MpLogicDelEntity')) {
+        return {
+          message: 'Entity 未继承 MpRealDelEntity 或 MpLogicDelEntity',
+          fix: 'extends MpRealDelEntity<Entity>'
+        };
+      }
+      return null;
+    }
+  },
+  'MUST-002': {
+    level: 'P1',
+    name: '主键注解',
+    pattern: /@TableId/,
+    check: (content, filePath) => {
+      if (!filePath.includes('Entity')) return null;
+      if (content.includes('@TableId') && !content.includes('IdType.ASSIGN_ID')) {
+        return {
+          message: '主键未使用雪花算法',
+          fix: '@TableId(type = IdType.ASSIGN_ID)'
+        };
+      }
+      return null;
+    }
+  },
+  'MUST-004': {
+    level: 'P0',
+    name: '分层规范',
+    pattern: /@Autowired|@Resource/,
+    check: (content, filePath) => {
+      if (!filePath.includes('Controller')) return null;
+      // Controller 直接注入 Mapper
+      const mapperInject = content.match(/@(Autowired|Resource)\s*(private\s+)?(\w+Mapper)/);
+      if (mapperInject) {
+        const lineNum = getLineNumber(content, mapperInject[0]);
+        return {
+          line: lineNum,
+          message: 'Controller 直接注入 Mapper，违反分层规范',
+          code: mapperInject[0],
+          fix: '通过 Service 层访问数据'
+        };
+      }
+      return null;
+    }
+  },
+  'MUST-005': {
+    level: 'P1',
+    name: '返回规范',
+    pattern: /public\s+\w+\s+\w+\s*\(/,
+    check: (content, filePath) => {
+      if (!filePath.includes('Controller')) return null;
+      // 检查 REST 方法返回类型
+      const methods = content.matchAll(/@(GetMapping|PostMapping|PutMapping|DeleteMapping|RequestMapping)[\s\S]*?public\s+(\w+(?:<[^>]+>)?)\s+\w+\s*\(/g);
+      for (const method of methods) {
+        const returnType = method[2];
+        if (!returnType.includes('Result') && returnType !== 'void') {
+          const lineNum = getLineNumber(content, method[0]);
+          return {
+            line: lineNum,
+            message: `REST 方法返回类型应为 Result<T>，当前为 ${returnType}`,
+            fix: '返回 Result<T>'
+          };
+        }
+      }
+      return null;
+    }
+  },
+  'MUST-006': {
+    level: 'P1',
+    name: '事务注解',
+    pattern: /@Transactional/,
+    check: (content, filePath) => {
+      if (!filePath.includes('Service')) return null;
+      // 检查是否有跨表操作但无事务
+      const hasMultiTableOp = content.includes('insert') && content.includes('update') ||
+                               content.includes('insert') && content.includes('delete') ||
+                               content.includes('mapper') && content.includes('mapper');
+      if (hasMultiTableOp && !content.includes('@Transactional')) {
+        return {
+          message: '跨表操作未添加事务注解',
+          fix: '@Transactional(rollbackFor = Exception.class)'
+        };
+      }
+      return null;
+    }
+  },
+  
+  // NEVER 规则
+  'NEVER-001': {
+    level: 'P0',
+    name: 'Controller 直接访问 Mapper',
+    pattern: /Mapper\s+mapper/,
+    check: (content, filePath) => {
+      if (!filePath.includes('Controller')) return null;
+      const mapperRef = content.match(/(\w+Mapper)\s+\w+;/);
+      if (mapperRef) {
+        const lineNum = getLineNumber(content, mapperRef[0]);
+        return {
+          line: lineNum,
+          message: 'Controller 直接访问 Mapper',
+          code: mapperRef[0],
+          fix: '通过 Service 层访问'
+        };
+      }
+      return null;
+    }
+  },
+  'NEVER-002': {
+    level: 'P0',
+    name: '事务中远程调用',
+    pattern: /@Transactional[\s\S]*?(FeignClient|RestTemplate|HttpClient|WebClient)/,
+    check: (content, filePath) => {
+      if (!filePath.includes('Service')) return null;
+      // 检查事务方法中是否有远程调用
+      const transactionalBlock = content.match(/@Transactional[\s\S]{0,500}(?:@FeignClient|restTemplate|httpClient|webClient|\.api\()/);
+      if (transactionalBlock) {
+        const lineNum = getLineNumber(content, transactionalBlock[0]);
+        return {
+          line: lineNum,
+          message: '事务方法中执行远程调用',
+          fix: '将远程调用移到事务方法外部'
+        };
+      }
+      return null;
+    }
+  },
+  'NEVER-003': {
+    level: 'P1',
+    name: 'Mapper 业务逻辑',
+    pattern: /default\s+(void|Result|boolean)/,
+    check: (content, filePath) => {
+      if (!filePath.includes('Mapper')) return null;
+      // Mapper 中有 default 方法实现业务逻辑
+      const defaultMethod = content.match(/default\s+(?!class|interface)\w+\s+\w+\s*\([^)]*\)\s*\{[\s\S]{50,}/);
+      if (defaultMethod && !defaultMethod[0].includes('selectById') && !defaultMethod[0].includes('insert')) {
+        const lineNum = getLineNumber(content, defaultMethod[0]);
+        return {
+          line: lineNum,
+          message: 'Mapper 中放置业务逻辑',
+          fix: '将业务逻辑移到 Service 层'
+        };
+      }
+      return null;
+    }
+  },
+  'NEVER-004': {
+    level: 'P1',
+    name: 'String column names',
+    pattern: /\.eq\("|\.\s*like\("|\.\s*ne\("|\.\s*gt\("|\.\s*lt\("|\.\s*ge\("|\.\s*le\("/,
+    check: (content, filePath) => {
+      const stringColumn = content.match(/queryWrapper\.(?:eq|ne|gt|lt|ge|le|like)\s*\(\s*"/);
+      if (stringColumn) {
+        const lineNum = getLineNumber(content, stringColumn[0]);
+        return {
+          line: lineNum,
+          message: '使用 string column names 查询',
+          code: stringColumn[0],
+          fix: '使用 lambdaQuery().eq(Entity::getField, value)'
+        };
+      }
+      return null;
+    }
+  },
+  'NEVER-005': {
+    level: 'P2',
+    name: 'Left-fuzzy LIKE',
+    pattern: /\.like\("%|\.likeLeft\(/,
+    check: (content) => {
+      const leftFuzzy = content.match(/\.like\s*\(\s*["']%/);
+      if (leftFuzzy) {
+        const lineNum = getLineNumber(content, leftFuzzy[0]);
+        return {
+          line: lineNum,
+          message: '使用 left-fuzzy LIKE，性能较差',
+          fix: '使用 likeRight 或避免左模糊查询'
+        };
+      }
+      return null;
+    }
+  },
+  'NEVER-006': {
+    level: 'P2',
+    name: 'Magic values',
+    pattern: /==\s*[0-9]+\s*\)|==\s*"[^"]+"\s*\)/,
+    check: (content) => {
+      const magicValue = content.match(/(?:status|type|state|level)\s*==\s*(?:[0-9]+|"[^"]+")\s*\)/);
+      if (magicValue) {
+        const lineNum = getLineNumber(content, magicValue[0]);
+        return {
+          line: lineNum,
+          message: '使用 magic values 状态比较',
+          code: magicValue[0],
+          fix: '使用 @EnumValue + CodeMessageEnumable'
+        };
+      }
+      return null;
+    }
+  },
+  
+  // 安全检查
+  'SEC-001': {
+    level: 'P0',
+    name: '硬编码密码',
+    pattern: /password\s*=\s*"[^"]+"/,
+    check: (content) => {
+      const hardcoded = content.match(/(?:password|passwd|pwd|secret|token|key)\s*=\s*"[^"]{8,}"/);
+      if (hardcoded && !hardcoded[0].includes('${') && !hardcoded[0].includes('placeholder')) {
+        const lineNum = getLineNumber(content, hardcoded[0]);
+        return {
+          line: lineNum,
+          message: '硬编码敏感信息',
+          fix: '使用配置文件或环境变量'
+        };
+      }
+      return null;
+    }
+  },
+  'SEC-002': {
+    level: 'P0',
+    name: 'SQL 注入',
+    pattern: /\$\{[^}]+\}/,
+    check: (content) => {
+      // 检查 Mapper XML 中的 ${} 参数
+      if (content.includes('${') && !content.includes('${orderBy')) {
+        const sqlInjection = content.match(/\$\{[^}]+\}/);
+        if (sqlInjection) {
+          const lineNum = getLineNumber(content, sqlInjection[0]);
+          return {
+            line: lineNum,
+            message: 'SQL 注入风险：使用 ${} 参数',
+            fix: '使用 #{} 参数替代'
+          };
+        }
+      }
+      return null;
+    }
+  }
+};
+
+// 获取行号
+function getLineNumber(content, searchStr) {
+  const lines = content.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes(searchStr.substring(0, 50))) {
+      return i + 1;
+    }
+  }
+  return 1;
+}
+
+// 检查单个文件
+function checkFile(filePath) {
+  const issues = [];
+  
+  if (!existsSync(filePath)) {
+    return issues;
+  }
+  
+  const content = readFileSync(filePath, 'utf-8');
+  
+  for (const [ruleId, rule] of Object.entries(RULES)) {
+    // Quick 模式只检查 P0 规则
+    if (options.quick && rule.level !== 'P0') {
+      continue;
+    }
+    
+    try {
+      const result = rule.check(content, filePath);
+      if (result) {
+        issues.push({
+          ruleId,
+          ruleName: rule.name,
+          level: rule.level,
+          file: filePath,
+          line: result.line || 1,
+          message: result.message,
+          code: result.code || '',
+          fix: result.fix || ''
+        });
+      }
+    } catch (e) {
+      // 规则检查失败，跳过
+    }
+  }
+  
+  return issues;
+}
+
+// 主函数
+function lint() {
+  const results = {
+    p0Count: 0,
+    p1Count: 0,
+    p2Count: 0,
+    p3Count: 0,
+    issues: [],
+    filesChecked: options.files.length,
+    timestamp: new Date().toISOString()
+  };
+  
+  for (const filePath of options.files) {
+    const fileIssues = checkFile(filePath);
+    results.issues.push(...fileIssues);
+    
+    for (const issue of fileIssues) {
+      if (issue.level === 'P0') results.p0Count++;
+      else if (issue.level === 'P1') results.p1Count++;
+      else if (issue.level === 'P2') results.p2Count++;
+      else results.p3Count++;
+    }
+  }
+  
+  return results;
+}
+
+// 输出结果
+function output(results) {
+  if (options.json) {
+    console.log(JSON.stringify(results, null, 2));
+  } else {
+    console.log('\n=== Code Review Lint ===\n');
+    console.log(`检查文件数: ${results.filesChecked}`);
+    console.log(`P0 问题: ${results.p0Count}`);
+    console.log(`P1 问题: ${results.p1Count}`);
+    console.log(`P2 问题: ${results.p2Count}`);
+    console.log(`P3 问题: ${results.p3Count}`);
+    
+    if (results.issues.length > 0) {
+      console.log('\n--- 问题列表 ---\n');
+      
+      const p0Issues = results.issues.filter(i => i.level === 'P0');
+      const p1Issues = results.issues.filter(i => i.level === 'P1');
+      const p2Issues = results.issues.filter(i => i.level === 'P2');
+      
+      if (p0Issues.length > 0) {
+        console.log('### P0 问题（阻断性 - 必须修复）\n');
+        for (const issue of p0Issues) {
+          console.log(`[${issue.ruleId}] ${issue.file}:${issue.line}`);
+          console.log(`  问题: ${issue.message}`);
+          console.log(`  修复: ${issue.fix}\n`);
+        }
+      }
+      
+      if (p1Issues.length > 0) {
+        console.log('### P1 问题（严重 - 必须修复）\n');
+        for (const issue of p1Issues) {
+          console.log(`[${issue.ruleId}] ${issue.file}:${issue.line}`);
+          console.log(`  问题: ${issue.message}`);
+          console.log(`  修复: ${issue.fix}\n`);
+        }
+      }
+      
+      if (p2Issues.length > 0 && !options.quick) {
+        console.log('### P2 问题（最佳实践 - 建议修复）\n');
+        for (const issue of p2Issues) {
+          console.log(`[${issue.ruleId}] ${issue.file}:${issue.line}`);
+          console.log(`  问题: ${issue.message}`);
+          console.log(`  修复: ${issue.fix}\n`);
+        }
+      }
+    }
+    
+    console.log('--- 结论 ---');
+    if (results.p0Count + results.p1Count === 0) {
+      console.log('✅ 通过');
+    } else {
+      console.log(`⚠️ 需修复 ${results.p0Count + results.p1Count} 个 P0/P1 问题后重新评审`);
+    }
+  }
+}
+
+// 执行
+if (options.files.length === 0) {
+  console.error('用法: node lint-code-review.mjs --files <file-list> [--json] [--quick]');
+  process.exit(1);
+}
+
+const results = lint();
+output(results);
+
+// CI 退出码
+if (results.p0Count + results.p1Count > 0) {
+  process.exit(1);
+} else {
+  process.exit(0);
+}