@spaceflow/review 0.29.1

package/src/issue-verify.service.ts

@@ -0,0 +1,309 @@
+import {
+  Injectable,
+  LlmProxyService,
+  type LLMMode,
+  type VerboseLevel,
+  shouldLog,
+  type LlmJsonPutSchema,
+  LlmJsonPut,
+  parallel,
+} from "@spaceflow/core";
+import {
+  ReviewIssue,
+  ReviewSpec,
+  ReviewRule,
+  ReviewSpecService,
+  FileContentsMap,
+  FileContentLine,
+} from "./review-spec";
+
+interface VerifyResult {
+  fixed: boolean;
+  valid: boolean;
+  reason: string;
+}
+
+const TRUE = "true";
+const FALSE = "false";
+
+const VERIFY_SCHEMA: LlmJsonPutSchema = {
+  type: "object",
+  properties: {
+    fixed: {
+      type: "boolean",
+      description: "问题是否已被修复",
+    },
+    valid: {
+      type: "boolean",
+      description: "问题是否有效，有效的条件就是你需要看看代码是否符合规范",
+    },
+    reason: {
+      type: "string",
+      description: "判断依据，说明为什么认为问题已修复或仍存在",
+    },
+  },
+  required: ["fixed", "valid", "reason"],
+  additionalProperties: false,
+};
+
+@Injectable()
+export class IssueVerifyService {
+  constructor(
+    protected readonly llmProxyService: LlmProxyService,
+    protected readonly reviewSpecService: ReviewSpecService,
+  ) {}
+
+  /**
+   * 验证历史 issues 是否已被修复
+   * 按并发数批量验证，每批并行调用 LLM
+   */
+  async verifyIssueFixes(
+    existingIssues: ReviewIssue[],
+    fileContents: FileContentsMap,
+    specs: ReviewSpec[],
+    llmMode: LLMMode,
+    verbose?: VerboseLevel,
+    concurrency: number = 10,
+  ): Promise<ReviewIssue[]> {
+    if (existingIssues.length === 0) {
+      return [];
+    }
+
+    if (shouldLog(verbose, 1)) {
+      console.log(
+        `\n🔍 开始验证 ${existingIssues.length} 个历史问题是否已修复 (并发: ${concurrency})...`,
+      );
+    }
+
+    const verifiedIssues: ReviewIssue[] = [];
+    const llmJsonPut = new LlmJsonPut<VerifyResult>(VERIFY_SCHEMA);
+
+    // 预处理：分离已修复和需要验证的 issues
+    const toVerify: {
+      issue: ReviewIssue;
+      fileContent: FileContentLine[];
+      ruleInfo: { rule: ReviewRule; spec: ReviewSpec } | null;
+    }[] = [];
+    for (const issue of existingIssues) {
+      if (issue.fixed) {
+        if (shouldLog(verbose, 1)) {
+          console.log(`   ⏭️  跳过已修复: ${issue.file}:${issue.line} (${issue.ruleId})`);
+        }
+        verifiedIssues.push(issue);
+        continue;
+      }
+
+      // valid === 'false' 的问题跳过复查（已确认无效的问题无需再次验证）
+      if (issue.valid === "false") {
+        if (shouldLog(verbose, 1)) {
+          console.log(`   ⏭️  跳过无效问题: ${issue.file}:${issue.line} (${issue.ruleId})`);
+        }
+        verifiedIssues.push(issue);
+        continue;
+      }
+
+      const fileContent = fileContents.get(issue.file);
+      if (fileContent === undefined) {
+        if (shouldLog(verbose, 1)) {
+          console.log(`   ✅ 文件已删除: ${issue.file}:${issue.line} (${issue.ruleId})`);
+        }
+        verifiedIssues.push({
+          ...issue,
+          fixed: new Date().toISOString(),
+          valid: FALSE,
+          reason: "文件已删除",
+        });
+        continue;
+      }
+
+      const ruleInfo = this.reviewSpecService.findRuleById(issue.ruleId, specs);
+      toVerify.push({ issue, fileContent, ruleInfo });
+    }
+
+    // 使用 parallel 库并行处理
+    const executor = parallel({
+      concurrency,
+      onTaskStart: (taskId) => {
+        if (shouldLog(verbose, 1)) {
+          console.log(`   🔎 验证: ${taskId}`);
+        }
+      },
+      onTaskComplete: (taskId, success) => {
+        if (shouldLog(verbose, 1)) {
+          console.log(`   ${success ? "✅" : "❌"} 完成: ${taskId}`);
+        }
+      },
+    });
+
+    const results = await executor.map(
+      toVerify,
+      async ({ issue, fileContent, ruleInfo }) =>
+        this.verifySingleIssue(issue, fileContent, ruleInfo, llmMode, llmJsonPut, verbose),
+      ({ issue }) => `${issue.file}:${issue.line}`,
+    );
+
+    for (const result of results) {
+      if (result.success && result.result) {
+        verifiedIssues.push(result.result);
+      } else {
+        // 失败时保留原始 issue
+        const originalItem = toVerify.find(
+          (item) => `${item.issue.file}:${item.issue.line}` === result.id,
+        );
+        if (originalItem) {
+          verifiedIssues.push(originalItem.issue);
+        }
+      }
+    }
+
+    const fixedCount = verifiedIssues.filter((i) => i.fixed).length;
+    const unfixedCount = verifiedIssues.length - fixedCount;
+    if (shouldLog(verbose, 1)) {
+      console.log(`\n📊 验证完成: ${fixedCount} 个已修复, ${unfixedCount} 个未修复`);
+    }
+
+    return verifiedIssues;
+  }
+
+  /**
+   * 验证单个 issue 是否已修复
+   */
+  protected async verifySingleIssue(
+    issue: ReviewIssue,
+    fileContent: FileContentLine[],
+    ruleInfo: { rule: ReviewRule; spec: ReviewSpec } | null,
+    llmMode: LLMMode,
+    llmJsonPut: LlmJsonPut<VerifyResult>,
+    verbose?: VerboseLevel,
+  ): Promise<ReviewIssue> {
+    const verifyPrompt = this.buildVerifyPrompt(issue, fileContent, ruleInfo);
+
+    try {
+      const stream = this.llmProxyService.chatStream(
+        [
+          { role: "system", content: verifyPrompt.systemPrompt },
+          { role: "user", content: verifyPrompt.userPrompt },
+        ],
+        {
+          adapter: llmMode,
+          jsonSchema: llmJsonPut,
+          verbose,
+        },
+      );
+
+      let result: VerifyResult | undefined;
+      for await (const event of stream) {
+        if (event.type === "result") {
+          result = event.response.structuredOutput as VerifyResult | undefined;
+        } else if (event.type === "error") {
+          console.error(`      ❌ 验证失败: ${event.message}`);
+        }
+      }
+
+      if (result) {
+        const updatedIssue: ReviewIssue = {
+          ...issue,
+          valid: result.valid ? TRUE : FALSE,
+        };
+
+        if (result.fixed) {
+          if (shouldLog(verbose, 1)) {
+            console.log(`      ✅ 已修复: ${result.reason}`);
+          }
+          updatedIssue.fixed = new Date().toISOString();
+        } else if (!result.valid) {
+          if (shouldLog(verbose, 1)) {
+            console.log(`      ❌ 无效问题: ${result.reason}`);
+          }
+        } else {
+          if (shouldLog(verbose, 1)) {
+            console.log(`      ⚠️  未修复: ${result.reason}`);
+          }
+        }
+
+        return updatedIssue;
+      } else {
+        return issue;
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(`      ❌ 验证出错: ${error.message}`);
+        if (error.stack) {
+          console.error(`      堆栈信息:\n${error.stack}`);
+        }
+      } else {
+        console.error(`      ❌ 验证出错: ${String(error)}`);
+      }
+      return issue;
+    }
+  }
+
+  /**
+   * 构建验证单个 issue 是否已修复的 prompt
+   */
+  protected buildVerifyPrompt(
+    issue: ReviewIssue,
+    fileContent: FileContentLine[],
+    ruleInfo: { rule: ReviewRule; spec: ReviewSpec } | null,
+  ): { systemPrompt: string; userPrompt: string } {
+    const padWidth = String(fileContent.length).length;
+    const linesWithNumbers = fileContent
+      .map(([, line], index) => `${String(index + 1).padStart(padWidth)}| ${line}`)
+      .join("\n");
+
+    const systemPrompt = `你是一个代码审查专家。你的任务是判断之前发现的一个代码问题：
+1. 是否有效（是否真的违反了规则）
+2. 是否已经被修复
+
+请仔细分析当前的代码内容。
+
+## 输出要求
+- valid: 布尔值，true 表示问题有效（代码确实违反了规则），false 表示问题无效（误报）
+- fixed: 布尔值，true 表示问题已经被修复，false 表示问题仍然存在
+- reason: 判断依据
+
+## 判断标准
+
+### valid 判断
+- 根据规则 ID 和问题描述，判断代码是否真的违反了该规则
+- 如果问题描述与实际代码不符，valid 为 false
+- 如果规则不适用于该代码场景，valid 为 false
+
+### fixed 判断
+- 只有当问题所在的代码已被修改，且修改后的代码不再违反规则时，fixed 才为 true
+- 如果问题所在的代码仍然存在且仍违反规则，fixed 必须为 false
+- 如果代码行号发生变化但问题本质仍存在，fixed 必须为 false
+
+## 重要提醒
+- valid=false 时，fixed 的值无意义（无效问题无需修复）
+- 请确保 valid 和 fixed 的值与 reason 的描述一致！`;
+
+    // 构建规则定义部分
+    let ruleSection = "";
+    if (ruleInfo) {
+      ruleSection = this.reviewSpecService.buildSpecsSection([ruleInfo.spec]);
+    }
+
+    const userPrompt = `## 规则定义
+
+${ruleSection}
+
+## 之前发现的问题
+
+- **文件**: ${issue.file}
+- **行号**: ${issue.line}
+- **规则**: ${issue.ruleId} (来自 ${issue.specFile})
+- **问题描述**: ${issue.reason}
+${issue.suggestion ? `- **原建议**: ${issue.suggestion}` : ""}
+
+## 当前文件内容
+
+\`\`\`
+${linesWithNumbers}
+\`\`\`
+
+请判断这个问题是否有效，以及是否已经被修复。`;
+
+    return { systemPrompt, userPrompt };
+  }
+}

package/src/locales/en/review.json

@@ -0,0 +1,31 @@
+{
+  "description": "Code review command using LLM for automated PR review",
+  "options.dryRun": "Only print actions without posting comments",
+  "options.prNumber": "PR number, auto-detected from env if not specified",
+  "options.base": "Base branch/tag for diff comparison",
+  "options.head": "Head branch/tag for diff comparison",
+  "options.includes": "File glob patterns to review, e.g. *.ts *.js (can be specified multiple times)",
+  "options.llmMode": "LLM mode: claude-code, openai, gemini",
+  "options.files": "Only review specified files (space-separated)",
+  "options.commits": "Only review specified commits (space-separated)",
+  "options.verifyFixes": "Verify if historical issues are fixed (default from config)",
+  "options.noVerifyFixes": "Disable historical issue verification",
+  "options.verifyConcurrency": "Concurrency for verifying historical issues (default 10)",
+  "options.analyzeDeletions": "Analyze impact of deleted code (true, false, ci, pr, terminal)",
+  "options.deletionAnalysisMode": "Deletion analysis mode: openai (standard) or claude-code (Agent mode with tools)",
+  "options.deletionOnly": "Only run deletion analysis, skip regular code review",
+  "options.outputFormat": "Output format: markdown, terminal, json. Auto-selected if not specified (markdown for PR, terminal for CLI)",
+  "options.generateDescription": "Generate PR description using AI",
+  "options.showAll": "Show all issues found, including those on unchanged lines",
+  "options.eventAction": "PR event type (opened, synchronize, closed, etc.), closed only collects stats without AI review",
+  "extensionDescription": "Code review command using LLM for automated PR review",
+  "mcp.serverDescription": "Code review rules query service",
+  "mcp.listRules": "List all code review rules for the current project, returning rule list with ID, title, description, applicable file extensions, etc.",
+  "mcp.getRulesForFile": "Get applicable code review rules for a specific file, filtered by file extension and includes configuration",
+  "mcp.getRuleDetail": "Get full details of a specific rule, including description, example code, etc.",
+  "mcp.ruleNotFound": "Rule {{ruleId}} not found",
+  "mcp.dto.cwd": "Project root directory path, defaults to current working directory",
+  "mcp.dto.filePath": "File path, can be relative or absolute",
+  "mcp.dto.includeExamples": "Whether to include rule example code, defaults to false",
+  "mcp.dto.ruleId": "Rule ID, e.g. JsTs.Naming.FileName"
+}

package/src/locales/index.ts

@@ -0,0 +1,11 @@
+import { addLocaleResources } from "@spaceflow/core";
+import zhCN from "./zh-cn/review.json";
+import en from "./en/review.json";
+
+/** review 命令 i18n 资源 */
+export const reviewLocales: Record<string, Record<string, string>> = {
+  "zh-CN": zhCN,
+  en,
+};
+
+addLocaleResources("review", reviewLocales);

package/src/locales/zh-cn/review.json

@@ -0,0 +1,31 @@
+{
+  "description": "代码审查命令，使用 LLM 对 PR 代码进行自动审查",
+  "options.dryRun": "仅打印将要执行的操作，不实际提交评论",
+  "options.prNumber": "PR 编号，如果不指定则从环境变量获取",
+  "options.base": "基准分支/tag，用于比较差异",
+  "options.head": "目标分支/tag，用于比较差异",
+  "options.includes": "要审查的文件 glob 模式，如 *.ts *.js（可多次指定）",
+  "options.llmMode": "使用的 LLM 模式: claude-code, openai, gemini",
+  "options.files": "仅审查指定的文件（空格分隔）",
+  "options.commits": "仅审查指定的 commits（空格分隔）",
+  "options.verifyFixes": "是否验证历史问题是否已修复（默认从配置文件读取）",
+  "options.noVerifyFixes": "禁用历史问题验证",
+  "options.verifyConcurrency": "验证历史问题的并发数（默认 10）",
+  "options.analyzeDeletions": "分析删除代码可能带来的影响 (true, false, ci, pr, terminal)",
+  "options.deletionAnalysisMode": "删除代码分析模式: openai (标准模式) 或 claude-code (Agent 模式，可使用工具)",
+  "options.deletionOnly": "仅执行删除代码分析，跳过常规代码审查",
+  "options.outputFormat": "输出格式: markdown, terminal, json。不指定则智能选择（PR 用 markdown，终端用 terminal）",
+  "options.generateDescription": "使用 AI 生成 PR 功能描述",
+  "options.showAll": "显示所有发现的问题，不过滤非变更行的问题",
+  "options.eventAction": "PR 事件类型（opened, synchronize, closed 等），closed 时仅收集统计不进行 AI 审查",
+  "extensionDescription": "代码审查命令，使用 LLM 对 PR 代码进行自动审查",
+  "mcp.serverDescription": "代码审查规则查询服务",
+  "mcp.listRules": "获取当前项目的所有代码审查规则，返回规则列表包含 ID、标题、描述、适用的文件扩展名等信息",
+  "mcp.getRulesForFile": "获取某个文件应该使用的代码审查规则，根据文件扩展名和 includes 配置过滤",
+  "mcp.getRuleDetail": "获取某个规则的完整详情，包括描述、示例代码等",
+  "mcp.ruleNotFound": "规则 {{ruleId}} 不存在",
+  "mcp.dto.cwd": "项目根目录路径，默认为当前工作目录",
+  "mcp.dto.filePath": "文件路径，可以是相对路径或绝对路径",
+  "mcp.dto.includeExamples": "是否包含规则示例代码，默认 false",
+  "mcp.dto.ruleId": "规则 ID，如 JsTs.Naming.FileName"
+}

package/src/parse-title-options.spec.ts

@@ -0,0 +1,251 @@
+import { parseTitleOptions } from "./parse-title-options";
+
+describe("parseTitleOptions", () => {
+  describe("基本解析", () => {
+    it("应该从 PR 标题末尾解析命令参数 (/review)", () => {
+      const title = "feat: 添加新功能 [/review -l openai -v 2]";
+      const options = parseTitleOptions(title);
+
+      expect(options.llmMode).toBe("openai");
+      expect(options.verbose).toBe(2);
+    });
+
+    it("应该支持旧的 /ai-review 格式", () => {
+      const title = "feat: 添加新功能 [/ai-review -l openai -v 2]";
+      const options = parseTitleOptions(title);
+
+      expect(options.llmMode).toBe("openai");
+      expect(options.verbose).toBe(2);
+    });
+
+    it("没有命令参数时应返回空对象", () => {
+      const title = "feat: 添加新功能";
+      const options = parseTitleOptions(title);
+
+      expect(options).toEqual({});
+    });
+
+    it("格式不正确时应返回空对象", () => {
+      const title = "feat: 添加新功能 [ai-review -l openai]"; // 缺少 /
+      const options = parseTitleOptions(title);
+
+      expect(options).toEqual({});
+    });
+  });
+
+  describe("LLM 模式参数", () => {
+    it("应该解析 -l 短参数", () => {
+      const title = "fix: bug [/ai-review -l claude-code]";
+      const options = parseTitleOptions(title);
+
+      expect(options.llmMode).toBe("claude-code");
+    });
+
+    it("应该解析 --llm-mode 长参数", () => {
+      const title = "fix: bug [/ai-review --llm-mode gemini]";
+      const options = parseTitleOptions(title);
+
+      expect(options.llmMode).toBe("gemini");
+    });
+
+    it("无效的 LLM 模式应被忽略", () => {
+      const title = "fix: bug [/ai-review -l invalid-mode]";
+      const options = parseTitleOptions(title);
+
+      expect(options.llmMode).toBeUndefined();
+    });
+  });
+
+  describe("详细输出级别参数", () => {
+    it("应该解析 -v 1", () => {
+      const title = "fix: bug [/ai-review -v 1]";
+      const options = parseTitleOptions(title);
+
+      expect(options.verbose).toBe(1);
+    });
+
+    it("应该解析 -v 2", () => {
+      const title = "fix: bug [/ai-review -v 2]";
+      const options = parseTitleOptions(title);
+
+      expect(options.verbose).toBe(2);
+    });
+
+    it("-v 不带值时应默认为 1", () => {
+      const title = "fix: bug [/ai-review -v]";
+      const options = parseTitleOptions(title);
+
+      expect(options.verbose).toBe(1);
+    });
+
+    it("-v 后跟其他参数时应默认为 1", () => {
+      const title = "fix: bug [/ai-review -v -l openai]";
+      const options = parseTitleOptions(title);
+
+      expect(options.verbose).toBe(1);
+      expect(options.llmMode).toBe("openai");
+    });
+
+    it("应该解析 --verbose 长参数", () => {
+      const title = "fix: bug [/ai-review --verbose 2]";
+      const options = parseTitleOptions(title);
+
+      expect(options.verbose).toBe(2);
+    });
+  });
+
+  describe("dry-run 参数", () => {
+    it("应该解析 -d 短参数", () => {
+      const title = "fix: bug [/ai-review -d]";
+      const options = parseTitleOptions(title);
+
+      expect(options.dryRun).toBe(true);
+    });
+
+    it("应该解析 --dry-run 长参数", () => {
+      const title = "fix: bug [/ai-review --dry-run]";
+      const options = parseTitleOptions(title);
+
+      expect(options.dryRun).toBe(true);
+    });
+  });
+
+  describe("includes 参数", () => {
+    it("应该解析 -i 短参数", () => {
+      const title = "fix: bug [/ai-review -i *.ts]";
+      const options = parseTitleOptions(title);
+
+      expect(options.includes).toEqual(["*.ts"]);
+    });
+
+    it("应该解析多个 includes", () => {
+      const title = "fix: bug [/ai-review -i *.ts -i *.js]";
+      const options = parseTitleOptions(title);
+
+      expect(options.includes).toEqual(["*.ts", "*.js"]);
+    });
+  });
+
+  describe("verify-fixes 参数", () => {
+    it("应该解析 --verify-fixes", () => {
+      const title = "fix: bug [/ai-review --verify-fixes]";
+      const options = parseTitleOptions(title);
+
+      expect(options.verifyFixes).toBe(true);
+    });
+
+    it("应该解析 --no-verify-fixes", () => {
+      const title = "fix: bug [/ai-review --no-verify-fixes]";
+      const options = parseTitleOptions(title);
+
+      expect(options.verifyFixes).toBe(false);
+    });
+  });
+
+  describe("删除代码分析参数", () => {
+    it("应该解析 --analyze-deletions 无值时默认为 true", () => {
+      const title = "fix: bug [/ai-review --analyze-deletions]";
+      const options = parseTitleOptions(title);
+
+      expect(options.analyzeDeletions).toBe(true);
+    });
+
+    it("应该解析 --analyze-deletions true", () => {
+      const title = "fix: bug [/ai-review --analyze-deletions true]";
+      const options = parseTitleOptions(title);
+
+      expect(options.analyzeDeletions).toBe(true);
+    });
+
+    it("应该解析 --analyze-deletions false", () => {
+      const title = "fix: bug [/ai-review --analyze-deletions false]";
+      const options = parseTitleOptions(title);
+
+      expect(options.analyzeDeletions).toBe(false);
+    });
+
+    it("应该解析 --analyze-deletions ci", () => {
+      const title = "fix: bug [/ai-review --analyze-deletions ci]";
+      const options = parseTitleOptions(title);
+
+      expect(options.analyzeDeletions).toBe("ci");
+    });
+
+    it("应该解析 --analyze-deletions pr", () => {
+      const title = "fix: bug [/ai-review --analyze-deletions pr]";
+      const options = parseTitleOptions(title);
+
+      expect(options.analyzeDeletions).toBe("pr");
+    });
+
+    it("应该解析 --analyze-deletions terminal", () => {
+      const title = "fix: bug [/ai-review --analyze-deletions terminal]";
+      const options = parseTitleOptions(title);
+
+      expect(options.analyzeDeletions).toBe("terminal");
+    });
+
+    it("应该解析 --deletion-only", () => {
+      const title = "fix: bug [/ai-review --deletion-only]";
+      const options = parseTitleOptions(title);
+
+      expect(options.deletionOnly).toBe(true);
+    });
+
+    it("应该解析 --deletion-analysis-mode", () => {
+      const title = "fix: bug [/ai-review --deletion-analysis-mode claude-code]";
+      const options = parseTitleOptions(title);
+
+      expect(options.deletionAnalysisMode).toBe("claude-code");
+    });
+  });
+
+  describe("组合参数", () => {
+    it("应该正确解析多个参数组合", () => {
+      const title = "feat: 新功能 [/ai-review -l openai -v 2 -d --no-verify-fixes]";
+      const options = parseTitleOptions(title);
+
+      expect(options.llmMode).toBe("openai");
+      expect(options.verbose).toBe(2);
+      expect(options.dryRun).toBe(true);
+      expect(options.verifyFixes).toBe(false);
+    });
+
+    it("应该处理带引号的参数值", () => {
+      const title = 'fix: bug [/ai-review -i "src/**/*.ts"]';
+      const options = parseTitleOptions(title);
+
+      expect(options.includes).toEqual(["src/**/*.ts"]);
+    });
+  });
+
+  describe("大小写不敏感", () => {
+    it("命令名称应该大小写不敏感", () => {
+      const title = "fix: bug [/AI-REVIEW -l openai]";
+      const options = parseTitleOptions(title);
+
+      expect(options.llmMode).toBe("openai");
+    });
+  });
+
+  describe("边界情况", () => {
+    it("空标题应返回空对象", () => {
+      const options = parseTitleOptions("");
+      expect(options).toEqual({});
+    });
+
+    it("命令在标题中间也应该被解析", () => {
+      const title = "feat: [/review -l openai] 替换 [/ai-review -l openai] 添加新功能";
+      const options = parseTitleOptions(title);
+
+      expect(options.llmMode).toBe("openai");
+    });
+
+    it("多个命令只解析第一个", () => {
+      const title = "feat: [/review -l openai] 替换 [/ai-review -l openai] [/ai-review -l gemini]";
+      const options = parseTitleOptions(title);
+
+      expect(options.llmMode).toBe("openai");
+    });
+  });
+});