@spaceflow/review 0.29.1

package/src/parse-title-options.ts

@@ -0,0 +1,185 @@
+import type { LLMMode, VerboseLevel } from "@spaceflow/core";
+import type { AnalyzeDeletionsMode } from "./review.config";
+import { normalizeVerbose } from "@spaceflow/core";
+
+/**
+ * 从 PR 标题中解析的命令参数
+ */
+export interface TitleOptions {
+  llmMode?: LLMMode;
+  verbose?: VerboseLevel;
+  dryRun?: boolean;
+  includes?: string[];
+  verifyFixes?: boolean;
+  analyzeDeletions?: AnalyzeDeletionsMode;
+  deletionOnly?: boolean;
+  deletionAnalysisMode?: LLMMode;
+}
+
+/**
+ * 从 PR 标题中解析命令参数
+ *
+ * 支持的格式：标题末尾 [/review -l openai -v 2]
+ *
+ * 支持的参数：
+ * - `-l, --llm-mode <mode>`: LLM 模式 (claude-code, openai, gemini)
+ * - `-v, --verbose [level]`: 详细输出级别 (1 或 2)
+ * - `-d, --dry-run`: 仅打印不执行
+ * - `-i, --includes <pattern>`: 文件过滤模式
+ * - `--verify-fixes`: 验证历史问题
+ * - `--no-verify-fixes`: 禁用历史问题验证
+ * - `--analyze-deletions`: 分析删除代码
+ * - `--deletion-only`: 仅执行删除代码分析
+ * - `--deletion-analysis-mode <mode>`: 删除分析模式
+ *
+ * @param title PR 标题
+ * @returns 解析出的命令参数，如果没有找到命令则返回空对象
+ */
+export function parseTitleOptions(title: string): TitleOptions {
+  const options: TitleOptions = {};
+
+  // 匹配 [/review ...] 或 [/ai-review ...] (保持向后兼容) 格式
+  const match = title.match(/\[\/(review|ai-review)\s+([^\]]+)\]/i);
+  if (!match) {
+    return options;
+  }
+
+  const argsString = match[2].trim();
+  const args = parseArgs(argsString);
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    switch (arg) {
+      case "-l":
+      case "--llm-mode": {
+        const value = args[++i];
+        if (value && isValidLLMMode(value)) {
+          options.llmMode = value;
+        }
+        break;
+      }
+
+      case "-v":
+      case "--verbose": {
+        const nextArg = args[i + 1];
+        if (nextArg && !nextArg.startsWith("-")) {
+          const level = parseInt(nextArg, 10);
+          if (level === 1 || level === 2) {
+            options.verbose = level;
+            i++;
+          } else {
+            options.verbose = normalizeVerbose(1);
+          }
+        } else {
+          options.verbose = normalizeVerbose(1);
+        }
+        break;
+      }
+
+      case "-d":
+      case "--dry-run":
+        options.dryRun = true;
+        break;
+
+      case "-i":
+      case "--includes": {
+        const value = args[++i];
+        if (value && !value.startsWith("-")) {
+          if (!options.includes) {
+            options.includes = [];
+          }
+          options.includes.push(value);
+        }
+        break;
+      }
+
+      case "--verify-fixes":
+        options.verifyFixes = true;
+        break;
+
+      case "--no-verify-fixes":
+        options.verifyFixes = false;
+        break;
+
+      case "--analyze-deletions": {
+        const nextArg = args[i + 1];
+        if (nextArg && !nextArg.startsWith("-") && isValidAnalyzeDeletionsMode(nextArg)) {
+          options.analyzeDeletions = parseAnalyzeDeletionsValue(nextArg);
+          i++;
+        } else {
+          options.analyzeDeletions = true;
+        }
+        break;
+      }
+
+      case "--deletion-only":
+        options.deletionOnly = true;
+        break;
+
+      case "--deletion-analysis-mode": {
+        const value = args[++i];
+        if (value && isValidDeletionAnalysisMode(value)) {
+          options.deletionAnalysisMode = value;
+        }
+        break;
+      }
+    }
+  }
+
+  return options;
+}
+
+/**
+ * 解析参数字符串为数组
+ * 支持引号包裹的参数值
+ */
+function parseArgs(argsString: string): string[] {
+  const args: string[] = [];
+  let current = "";
+  let inQuote = false;
+  let quoteChar = "";
+
+  for (let i = 0; i < argsString.length; i++) {
+    const char = argsString[i];
+
+    if ((char === '"' || char === "'") && !inQuote) {
+      inQuote = true;
+      quoteChar = char;
+    } else if (char === quoteChar && inQuote) {
+      inQuote = false;
+      quoteChar = "";
+    } else if (char === " " && !inQuote) {
+      if (current) {
+        args.push(current);
+        current = "";
+      }
+    } else {
+      current += char;
+    }
+  }
+
+  if (current) {
+    args.push(current);
+  }
+
+  return args;
+}
+
+function isValidLLMMode(value: string): value is LLMMode {
+  return ["claude-code", "openai", "gemini"].includes(value);
+}
+
+function isValidDeletionAnalysisMode(value: string): value is LLMMode {
+  return ["openai", "claude-code"].includes(value);
+}
+
+function isValidAnalyzeDeletionsMode(value: string): boolean {
+  return ["true", "false", "ci", "pr", "terminal"].includes(value);
+}
+
+function parseAnalyzeDeletionsValue(value: string): AnalyzeDeletionsMode {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  return value as "ci" | "pr" | "terminal";
+}

package/src/review-report/formatters/deletion-impact.formatter.ts

@@ -0,0 +1,144 @@
+import type { DeletionImpactResult, DeletionImpact } from "../../review-spec/types";
+
+const RISK_EMOJI: Record<string, string> = {
+  high: "🔴",
+  medium: "🟡",
+  low: "🟢",
+  none: "⚪",
+};
+
+const RISK_LABEL: Record<string, string> = {
+  high: "高风险",
+  medium: "中风险",
+  low: "低风险",
+  none: "无风险",
+};
+
+export interface DeletionImpactReportOptions {
+  includeJsonData?: boolean;
+}
+
+const DELETION_IMPACT_DATA_START = "<!-- spaceflow-deletion-impact-data-start -->";
+const DELETION_IMPACT_DATA_END = "<!-- spaceflow-deletion-impact-data-end -->";
+
+export class DeletionImpactFormatter {
+  format(result: DeletionImpactResult, options: DeletionImpactReportOptions = {}): string {
+    const { includeJsonData = true } = options;
+    const lines: string[] = [];
+
+    lines.push("## 🗑️ 删除代码影响分析\n");
+
+    // 防御性检查：确保 impacts 是数组
+    const impacts = result.impacts && Array.isArray(result.impacts) ? result.impacts : [];
+
+    if (impacts.length === 0) {
+      lines.push("✅ **未发现有风险的代码删除**\n");
+      lines.push(result.summary);
+      return lines.join("\n");
+    }
+
+    // 统计风险等级
+    const highRisk = impacts.filter((i) => i.riskLevel === "high");
+    const mediumRisk = impacts.filter((i) => i.riskLevel === "medium");
+    const lowRisk = impacts.filter((i) => i.riskLevel === "low");
+
+    lines.push("### 📊 风险概览\n");
+    lines.push(`| 风险等级 | 数量 |`);
+    lines.push(`|----------|------|`);
+    if (highRisk.length > 0) {
+      lines.push(`| ${RISK_EMOJI.high} 高风险 | ${highRisk.length} |`);
+    }
+    if (mediumRisk.length > 0) {
+      lines.push(`| ${RISK_EMOJI.medium} 中风险 | ${mediumRisk.length} |`);
+    }
+    if (lowRisk.length > 0) {
+      lines.push(`| ${RISK_EMOJI.low} 低风险 | ${lowRisk.length} |`);
+    }
+    lines.push("");
+
+    // 详情折叠
+    lines.push("<details>");
+    lines.push("<summary>📋 点击查看详情</summary>\n");
+
+    // 高风险项详情
+    if (highRisk.length > 0) {
+      lines.push("### 🔴 高风险删除\n");
+      lines.push(this.formatImpactList(highRisk));
+    }
+
+    // 中风险项详情
+    if (mediumRisk.length > 0) {
+      lines.push("### 🟡 中风险删除\n");
+      lines.push(this.formatImpactList(mediumRisk));
+    }
+
+    // 低风险项
+    if (lowRisk.length > 0) {
+      lines.push("### 🟢 低风险删除\n");
+      lines.push(this.formatImpactList(lowRisk));
+    }
+
+    // 总结
+    lines.push("\n### 📝 总结\n");
+    lines.push(result.summary);
+
+    lines.push("\n</details>");
+
+    return lines.join("\n");
+  }
+
+  private formatImpactList(impacts: DeletionImpact[]): string {
+    const lines: string[] = [];
+
+    for (const impact of impacts) {
+      const emoji = RISK_EMOJI[impact.riskLevel] || RISK_EMOJI.none;
+      const label = RISK_LABEL[impact.riskLevel] || "未知";
+      const codePreview =
+        impact.deletedCode.length > 50
+          ? impact.deletedCode.slice(0, 50) + "..."
+          : impact.deletedCode;
+
+      lines.push(`#### ${emoji} \`${impact.file}\`\n`);
+      lines.push(`- **风险等级**: ${label}`);
+      lines.push(`- **删除代码**: \`${codePreview.replace(/\n/g, " ")}\``);
+
+      if (impact.affectedFiles.length > 0) {
+        lines.push(`- **受影响文件**:`);
+        for (const file of impact.affectedFiles.slice(0, 5)) {
+          lines.push(`  - \`${file}\``);
+        }
+        if (impact.affectedFiles.length > 5) {
+          lines.push(`  - ... 还有 ${impact.affectedFiles.length - 5} 个文件`);
+        }
+      }
+
+      lines.push(`- **影响分析**: ${impact.reason}`);
+
+      if (impact.suggestion) {
+        lines.push(`- **建议**: ${impact.suggestion}`);
+      }
+
+      lines.push("");
+    }
+
+    return lines.join("\n");
+  }
+
+  parse(content: string): DeletionImpactResult | null {
+    const startIndex = content.indexOf(DELETION_IMPACT_DATA_START);
+    const endIndex = content.indexOf(DELETION_IMPACT_DATA_END);
+
+    if (startIndex === -1 || endIndex === -1 || startIndex >= endIndex) {
+      return null;
+    }
+
+    const jsonStart = startIndex + DELETION_IMPACT_DATA_START.length;
+    const jsonContent = content.slice(jsonStart, endIndex).trim();
+
+    try {
+      return JSON.parse(jsonContent) as DeletionImpactResult;
+    } catch {
+      return null;
+    }
+  }
+}

package/src/review-report/formatters/index.ts

@@ -0,0 +1,4 @@
+export * from "./markdown.formatter";
+export * from "./json.formatter";
+export * from "./terminal.formatter";
+export * from "./deletion-impact.formatter";

package/src/review-report/formatters/json.formatter.ts

@@ -0,0 +1,8 @@
+import { ReviewResult } from "../../review-spec/types";
+import { ReportOptions, ReviewReportFormatter } from "../types";
+
+export class JsonFormatter implements ReviewReportFormatter {
+  format(result: ReviewResult, _options: ReportOptions = {}): string {
+    return JSON.stringify(result, null, 2);
+  }
+}

package/src/review-report/formatters/markdown.formatter.ts

@@ -0,0 +1,291 @@
+import { extname } from "path";
+import {
+  FileSummary,
+  ReviewIssue,
+  ReviewResult,
+  ReviewStats,
+  SEVERITY_EMOJI,
+} from "../../review-spec/types";
+import { ParsedReport, ReportOptions, ReviewReportFormatter, ReviewReportParser } from "../types";
+import { DeletionImpactFormatter } from "./deletion-impact.formatter";
+
+const REVIEW_DATA_START = "<!-- spaceflow-review-data-start -->";
+const REVIEW_DATA_END = "<!-- spaceflow-review-data-end -->";
+
+function formatDateToUTC8(dateStr: string): string {
+  const date = new Date(dateStr);
+  if (isNaN(date.getTime())) return dateStr;
+  return date.toLocaleString("zh-CN", {
+    timeZone: "Asia/Shanghai",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false,
+  });
+}
+
+export class MarkdownFormatter implements ReviewReportFormatter, ReviewReportParser {
+  static clearReviewData(content: string, replaceData: string): string {
+    return content
+      .replace(new RegExp(`${REVIEW_DATA_START}[\\s\\S]*?${REVIEW_DATA_END}`, "g"), replaceData)
+      .trim();
+  }
+  private readonly deletionImpactFormatter = new DeletionImpactFormatter();
+
+  private formatIssueList(issues: ReviewIssue[]): string {
+    const lines: string[] = [];
+    for (const issue of issues) {
+      const severityEmoji = SEVERITY_EMOJI[issue.severity] || SEVERITY_EMOJI.error;
+      lines.push(`### ${issue.fixed ? "🟢" : severityEmoji} ${issue.file}:${issue.line}\n`);
+      lines.push(`- **问题**: ${issue.reason}`);
+      lines.push(`- **规则**: \`${issue.ruleId}\` (来自 \`${issue.specFile}\`)`);
+      if (issue.commit) {
+        lines.push(`- **Commit**: ${issue.commit}`);
+      }
+      lines.push(`- **开发人员**: ${issue.author ? "@" + issue.author.login : "未知"}`);
+      if (issue.date) {
+        lines.push(`- **发现时间**: ${formatDateToUTC8(issue.date)}`);
+      }
+      if (issue.fixed) {
+        lines.push(`- **修复时间**: ${formatDateToUTC8(issue.fixed)}`);
+      }
+      if (issue.suggestion) {
+        const ext = extname(issue.file).slice(1) || "";
+        const cleanSuggestion = issue.suggestion.replace(/```/g, "//").trim();
+        const lineCount = cleanSuggestion.split("\n").length;
+        lines.push("- **建议**:");
+        if (lineCount < 4) {
+          lines.push(`\`\`\`${ext}`);
+          lines.push(cleanSuggestion);
+          lines.push("```");
+        } else {
+          lines.push("<details>");
+          lines.push("<summary>💡 查看建议</summary>\n");
+          lines.push(`\`\`\`${ext}`);
+          lines.push(cleanSuggestion);
+          lines.push("```");
+          lines.push("\n</details>");
+        }
+      }
+      // 渲染消息（reactions 统计 + replies 详情，合并到一个折叠块）
+      const hasReactions = issue.reactions && issue.reactions.length > 0;
+      const hasReplies = issue.replies && issue.replies.length > 0;
+      if (hasReactions || hasReplies) {
+        const reactionCount = hasReactions
+          ? issue.reactions!.reduce((sum, r) => sum + r.users.length, 0)
+          : 0;
+        const replyCount = hasReplies ? issue.replies!.length : 0;
+        const totalCount = reactionCount + replyCount;
+        lines.push("<details>");
+        lines.push(`<summary>💬 消息 (${totalCount} 条)</summary>\n`);
+        // 先显示 reactions 统计（格式：👎(1) 👍(2)）
+        if (hasReactions) {
+          const reactionStats = issue.reactions!.map((r) => {
+            const emoji = this.getReactionEmoji(r.content);
+            return `${emoji}(${r.users.length})`;
+          });
+          lines.push(`> ${reactionStats.join(" ")}`);
+        }
+        // 再显示 replies 详情
+        if (hasReplies) {
+          for (const reply of issue.replies!) {
+            const time = reply.createdAt ? formatDateToUTC8(reply.createdAt) : "";
+            lines.push(`> @${reply.user.login} ${time ? `(${time})` : ""}:`);
+            lines.push(`>     ${reply.body.split("\n").join("\n>     ")}`);
+            lines.push("");
+          }
+        }
+        lines.push("</details>");
+      }
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+
+  /** 将 reaction content 转换为 emoji */
+  private getReactionEmoji(content: string): string {
+    const emojiMap: Record<string, string> = {
+      "+1": "👍",
+      "-1": "👎",
+      laugh: "😄",
+      hooray: "🎉",
+      confused: "😕",
+      heart: "❤️",
+      rocket: "🚀",
+      eyes: "👀",
+    };
+    return emojiMap[content] || content;
+  }
+
+  private formatFileSummaries(summaries: FileSummary[], issues: ReviewIssue[]): string {
+    if (summaries.length === 0) {
+      return "没有需要审查的文件";
+    }
+
+    const issuesByFile = new Map<string, { resolved: number; unresolved: number }>();
+    for (const issue of issues) {
+      if (issue.valid === "false") continue;
+      const stats = issuesByFile.get(issue.file) || { resolved: 0, unresolved: 0 };
+      if (issue.fixed) {
+        stats.resolved++;
+      } else {
+        stats.unresolved++;
+      }
+      issuesByFile.set(issue.file, stats);
+    }
+
+    const lines: string[] = [];
+    lines.push("| 文件 | 🟢 | 🔴 | 总结 |");
+    lines.push("|------|----|----|------|");
+
+    for (const fileSummary of summaries) {
+      const stats = issuesByFile.get(fileSummary.file) || { resolved: 0, unresolved: 0 };
+      const summaryText = fileSummary.summary
+        .split("\n")
+        .filter((line) => line.trim())
+        .join("<br>");
+      lines.push(
+        `| \`${fileSummary.file}\` | ${stats.resolved} | ${stats.unresolved} | ${summaryText} |`,
+      );
+    }
+
+    return lines.join("\n");
+  }
+
+  parse(content: string): ParsedReport | null {
+    const startIndex = content.indexOf(REVIEW_DATA_START);
+    const endIndex = content.indexOf(REVIEW_DATA_END);
+
+    if (startIndex === -1 || endIndex === -1 || startIndex >= endIndex) {
+      return null;
+    }
+
+    const dataStart = startIndex + REVIEW_DATA_START.length;
+    const encodedContent = content.slice(dataStart, endIndex).trim();
+
+    try {
+      // 尝试 Base64 解码，如果失败则尝试直接解析 JSON（兼容旧格式）
+      let jsonContent: string;
+      try {
+        jsonContent = Buffer.from(encodedContent, "base64").toString("utf-8");
+        // 验证解码后是否为有效 JSON
+        JSON.parse(jsonContent);
+      } catch {
+        // Base64 解码失败或解码后不是有效 JSON，尝试直接解析（旧格式）
+        jsonContent = encodedContent;
+      }
+      const parsed = JSON.parse(jsonContent);
+      const hasReanalysisRequest = content.includes("- [x]");
+
+      // 新格式：完整的 ReviewResult
+      return {
+        result: parsed as ReviewResult,
+        hasReanalysisRequest,
+      };
+    } catch {
+      return null;
+    }
+  }
+
+  format(result: ReviewResult, options: ReportOptions = {}): string {
+    const {
+      prNumber,
+      includeReanalysisCheckbox = true,
+      includeJsonData = true,
+      reviewCommentMarker,
+    } = options;
+
+    const lines: string[] = [];
+
+    if (reviewCommentMarker) {
+      lines.push(reviewCommentMarker);
+    }
+
+    const validIssues = result.issues.filter((issue) => issue.valid !== "false");
+    const invalidIssues = result.issues.filter((issue) => issue.valid === "false");
+
+    lines.push("# 🤖 AI 代码审查报告\n");
+
+    // 输出统计信息（如果有）
+    if (result.stats) {
+      lines.push(this.formatStats(result.stats));
+      lines.push("");
+    }
+
+    // 输出 PR 功能描述
+    if (result.description) {
+      lines.push("## 📋 功能概述\n");
+      // 将 description 中的标题级别降低（h1->h3, h2->h4, h3->h5 等）
+      const adjustedDescription = result.description.replace(/^(#{1,4})\s/gm, "$1##  ");
+      lines.push(adjustedDescription);
+      lines.push("");
+    }
+
+    lines.push("## 📝 新增代码分析\n");
+    lines.push("### 📊 审查概览\n");
+    lines.push(this.formatFileSummaries(result.summary, validIssues));
+    lines.push("<details>");
+    lines.push("<summary>📋 点击查看详情</summary>\n");
+    lines.push("### 🐛 详细问题\n");
+    if (validIssues.length === 0 && invalidIssues.length === 0) {
+      lines.push("✅ **未发现问题**\n");
+    } else {
+      if (validIssues.length === 0) {
+        lines.push("✅ **未发现有效问题**\n");
+      } else {
+        lines.push(`⚠️ **发现 ${validIssues.length} 个问题**\n`);
+        lines.push(this.formatIssueList(validIssues));
+      }
+
+      if (invalidIssues.length > 0) {
+        lines.push("\n<details>");
+        lines.push(`<summary>🚫 无效问题 (${invalidIssues.length} 个)</summary>\n`);
+        lines.push(this.formatIssueList(invalidIssues));
+        lines.push("\n</details>");
+      }
+    }
+    lines.push("\n</details>");
+
+    // if (includeReanalysisCheckbox) {
+    //   lines.push("\n---");
+    //   lines.push("<details>");
+    //   lines.push("<summary>🔄 重新分析</summary>\n");
+    //   if (prNumber) {
+    //     lines.push("- [ ] 勾选此复选框后保存评论，将触发重新分析");
+    //   }
+    //   lines.push("\n</details>");
+    // }
+
+    // 输出删除代码影响分析报告
+    if (result.deletionImpact) {
+      lines.push("\n---\n");
+      lines.push(this.deletionImpactFormatter.format(result.deletionImpact, { includeJsonData }));
+    }
+
+    if (includeJsonData) {
+      lines.push("");
+      lines.push("<details>");
+      lines.push("<summary>📊 审查数据 (JSON)</summary>\n");
+      lines.push(REVIEW_DATA_START);
+      lines.push(Buffer.from(JSON.stringify(result)).toString("base64"));
+      lines.push(REVIEW_DATA_END);
+      lines.push("\n</details>");
+    }
+
+    return lines.join("\n");
+  }
+
+  formatStats(stats: ReviewStats, prNumber?: number): string {
+    const title = prNumber ? `PR #${prNumber} Review 状态统计` : "Review 状态统计";
+    const lines = [`## 📊 ${title}\n`, `| 指标 | 数量 |`, `|------|------|`];
+    lines.push(`| 总问题数 | ${stats.total} |`);
+    lines.push(`| ✅ 已修复 | ${stats.fixed} |`);
+    lines.push(`| ❌ 无效 | ${stats.invalid} |`);
+    lines.push(`| ⚠️ 待处理 | ${stats.pending} |`);
+    lines.push(`| 修复率 | ${stats.fixRate}% |`);
+    return lines.join("\n");
+  }
+}