@spaceflow/review 0.76.0 → 0.78.0

package/src/utils/review-pr-comment.spec.ts

@@ -0,0 +1,340 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import {
+  REVIEW_COMMENT_MARKER,
+  REVIEW_LINE_COMMENTS_MARKER,
+  extractIssueKeyFromBody,
+  isAiGeneratedComment,
+  generateIssueKey,
+  syncRepliesToIssues,
+  deleteExistingAiReviews,
+  calculateIssueStats,
+} from "./review-pr-comment";
+
+describe("utils/review-pr-comment", () => {
+  // ─── 常量 ────────────────────────────────────────────────
+
+  describe("markers", () => {
+    it("REVIEW_COMMENT_MARKER 包含预期字符串", () => {
+      expect(REVIEW_COMMENT_MARKER).toBe("<!-- spaceflow-review -->");
+    });
+
+    it("REVIEW_LINE_COMMENTS_MARKER 包含预期字符串", () => {
+      expect(REVIEW_LINE_COMMENTS_MARKER).toBe("<!-- spaceflow-review-lines -->");
+    });
+  });
+
+  // ─── extractIssueKeyFromBody ─────────────────────────────
+
+  describe("extractIssueKeyFromBody", () => {
+    it("提取标准格式的 issue key", () => {
+      expect(extractIssueKeyFromBody("<!-- issue-key: src/a.ts:10:R1 -->")).toBe(
+        "src/a.ts:10:R1",
+      );
+    });
+
+    it("body 不含 issue-key 时返回 null", () => {
+      expect(extractIssueKeyFromBody("普通评论内容")).toBeNull();
+    });
+
+    it("issue key 含空格时正确提取（trim）", () => {
+      expect(extractIssueKeyFromBody("<!-- issue-key: a.ts:1:R1 -->")).toBe("a.ts:1:R1");
+    });
+  });
+
+  // ─── isAiGeneratedComment ────────────────────────────────
+
+  describe("isAiGeneratedComment", () => {
+    it("含 issue-key 标记时返回 true", () => {
+      expect(isAiGeneratedComment("some body <!-- issue-key: a.ts:1:R1 --> end")).toBe(true);
+    });
+
+    it("同时含规则和文件字段时返回 true", () => {
+      expect(isAiGeneratedComment("- **规则**: R1\n- **文件**: a.ts:1")).toBe(true);
+    });
+
+    it("普通用户评论返回 false", () => {
+      expect(isAiGeneratedComment("LGTM")).toBe(false);
+    });
+
+    it("空字符串返回 false", () => {
+      expect(isAiGeneratedComment("")).toBe(false);
+    });
+
+    it("只含规则字段（不含文件字段）返回 false", () => {
+      expect(isAiGeneratedComment("- **规则**: R1")).toBe(false);
+    });
+  });
+
+  // ─── generateIssueKey ───────────────────────────────────
+
+  describe("generateIssueKey", () => {
+    it("拼接 file:line:ruleId", () => {
+      expect(
+        generateIssueKey({ file: "src/a.ts", line: "10", ruleId: "R1" } as any),
+      ).toBe("src/a.ts:10:R1");
+    });
+  });
+
+  // ─── calculateIssueStats ────────────────────────────────
+
+  describe("calculateIssueStats", () => {
+    it("空数组返回全零统计", () => {
+      const stats = calculateIssueStats([]);
+      expect(stats).toEqual({
+        total: 0,
+        validTotal: 0,
+        fixed: 0,
+        resolved: 0,
+        invalid: 0,
+        pending: 0,
+        fixRate: 0,
+        resolveRate: 0,
+      });
+    });
+
+    it("全部待处理问题", () => {
+      const issues = [
+        { file: "a.ts", line: "1", ruleId: "R1" },
+        { file: "b.ts", line: "2", ruleId: "R2" },
+      ] as any[];
+      const stats = calculateIssueStats(issues);
+      expect(stats.total).toBe(2);
+      expect(stats.validTotal).toBe(2);
+      expect(stats.pending).toBe(2);
+      expect(stats.fixed).toBe(0);
+      expect(stats.resolved).toBe(0);
+      expect(stats.invalid).toBe(0);
+    });
+
+    it("valid=false 的问题计入 invalid，不计入 pending", () => {
+      const issues = [
+        { file: "a.ts", line: "1", ruleId: "R1", valid: "false" },
+        { file: "b.ts", line: "2", ruleId: "R2" },
+      ] as any[];
+      const stats = calculateIssueStats(issues);
+      expect(stats.total).toBe(2);
+      expect(stats.invalid).toBe(1);
+      expect(stats.validTotal).toBe(1);
+      expect(stats.pending).toBe(1);
+    });
+
+    it("fixed 问题计入 fixed，不计入 pending", () => {
+      const issues = [
+        { file: "a.ts", line: "1", ruleId: "R1", fixed: "2024-01-01" },
+        { file: "b.ts", line: "2", ruleId: "R2" },
+      ] as any[];
+      const stats = calculateIssueStats(issues);
+      expect(stats.fixed).toBe(1);
+      expect(stats.pending).toBe(1);
+    });
+
+    it("resolved（非 fixed）计入 resolved，不计入 pending", () => {
+      const issues = [
+        { file: "a.ts", line: "1", ruleId: "R1", resolved: "2024-01-01" },
+      ] as any[];
+      const stats = calculateIssueStats(issues);
+      expect(stats.resolved).toBe(1);
+      expect(stats.pending).toBe(0);
+    });
+
+    it("fixed 同时有 resolved 时只计入 fixed", () => {
+      const issues = [
+        { file: "a.ts", line: "1", ruleId: "R1", fixed: "2024-01-01", resolved: "2024-01-01" },
+      ] as any[];
+      const stats = calculateIssueStats(issues);
+      expect(stats.fixed).toBe(1);
+      expect(stats.resolved).toBe(0);
+    });
+
+    it("fixRate 计算正确（2/4 = 50%）", () => {
+      const issues = Array.from({ length: 4 }, (_, i) => ({
+        file: "a.ts",
+        line: String(i + 1),
+        ruleId: "R1",
+        ...(i < 2 ? { fixed: "2024-01-01" } : {}),
+      })) as any[];
+      const stats = calculateIssueStats(issues);
+      expect(stats.fixRate).toBe(50);
+    });
+  });
+
+  // ─── syncRepliesToIssues ─────────────────────────────────
+
+  describe("syncRepliesToIssues", () => {
+    const lineMatchesPosition = (line: string, pos?: number) =>
+      pos !== undefined && String(pos) === line;
+
+    it("单条评论（无回复）不产生 replies", async () => {
+      const issue = { file: "a.ts", line: "1", ruleId: "R1" } as any;
+      const result = { issues: [issue] } as any;
+      const comments = [
+        {
+          id: 1,
+          path: "a.ts",
+          position: 1,
+          body: `🔴 **问题**\n<!-- issue-key: a.ts:1:R1 -->`,
+          created_at: "2024-01-01T00:00:00Z",
+        },
+      ];
+      await syncRepliesToIssues(comments, result, lineMatchesPosition);
+      expect(issue.replies).toBeUndefined();
+    });
+
+    it("用户回复通过 issue-key 精确匹配后加入 replies", async () => {
+      const issue = { file: "a.ts", line: "1", ruleId: "R1" } as any;
+      const result = { issues: [issue] } as any;
+      const comments = [
+        {
+          id: 1,
+          path: "a.ts",
+          position: 1,
+          body: `🔴 问题\n<!-- issue-key: a.ts:1:R1 -->`,
+          created_at: "2024-01-01T00:00:00Z",
+        },
+        {
+          id: 2,
+          path: "a.ts",
+          position: 1,
+          body: "已修复",
+          user: { id: 42, login: "dev1" },
+          created_at: "2024-01-01T01:00:00Z",
+        },
+      ];
+      await syncRepliesToIssues(comments, result, lineMatchesPosition);
+      expect(issue.replies).toHaveLength(1);
+      expect(issue.replies[0].body).toBe("已修复");
+      expect(issue.replies[0].user.login).toBe("dev1");
+    });
+
+    it("AI 格式特征的评论不被计为用户回复", async () => {
+      const issue = { file: "a.ts", line: "1", ruleId: "R1" } as any;
+      const result = { issues: [issue] } as any;
+      const comments = [
+        {
+          id: 1,
+          path: "a.ts",
+          position: 1,
+          body: `🔴 问题\n<!-- issue-key: a.ts:1:R1 -->`,
+          created_at: "2024-01-01T00:00:00Z",
+        },
+        {
+          id: 2,
+          path: "a.ts",
+          position: 1,
+          body: "- **规则**: R2\n- **文件**: b.ts:2",
+          created_at: "2024-01-01T01:00:00Z",
+        },
+      ];
+      await syncRepliesToIssues(comments, result, lineMatchesPosition);
+      expect(issue.replies).toBeUndefined();
+    });
+
+    it("同一 issue 多条用户回复全部追加", async () => {
+      const issue = { file: "a.ts", line: "1", ruleId: "R1" } as any;
+      const result = { issues: [issue] } as any;
+      const comments = [
+        {
+          id: 1,
+          path: "a.ts",
+          position: 1,
+          body: `<!-- issue-key: a.ts:1:R1 -->`,
+          created_at: "2024-01-01T00:00:00Z",
+        },
+        {
+          id: 2,
+          path: "a.ts",
+          position: 1,
+          body: "回复1",
+          user: { login: "u1" },
+          created_at: "2024-01-01T01:00:00Z",
+        },
+        {
+          id: 3,
+          path: "a.ts",
+          position: 1,
+          body: "回复2",
+          user: { login: "u2" },
+          created_at: "2024-01-01T02:00:00Z",
+        },
+      ];
+      await syncRepliesToIssues(comments, result, lineMatchesPosition);
+      expect(issue.replies).toHaveLength(2);
+    });
+  });
+
+  // ─── deleteExistingAiReviews ─────────────────────────────
+
+  describe("deleteExistingAiReviews", () => {
+    let pr: any;
+
+    beforeEach(() => {
+      pr = {
+        getReviews: vi.fn(),
+        deleteReview: vi.fn(),
+        getComments: vi.fn(),
+        deleteComment: vi.fn(),
+      };
+    });
+
+    it("删除含 REVIEW_LINE_COMMENTS_MARKER 的 PR Review", async () => {
+      pr.getReviews.mockResolvedValue([
+        { id: 1, body: `${REVIEW_LINE_COMMENTS_MARKER} Round 1` },
+        { id: 2, body: "普通 review" },
+      ]);
+      pr.deleteReview.mockResolvedValue(undefined);
+      pr.getComments.mockResolvedValue([]);
+
+      await deleteExistingAiReviews(pr);
+
+      expect(pr.deleteReview).toHaveBeenCalledTimes(1);
+      expect(pr.deleteReview).toHaveBeenCalledWith(1);
+    });
+
+    it("删除含 REVIEW_COMMENT_MARKER 的 Issue Comment", async () => {
+      pr.getReviews.mockResolvedValue([]);
+      pr.getComments.mockResolvedValue([
+        { id: 10, body: `${REVIEW_COMMENT_MARKER} 报告内容` },
+        { id: 11, body: "普通评论" },
+      ]);
+      pr.deleteComment.mockResolvedValue(undefined);
+
+      await deleteExistingAiReviews(pr);
+
+      expect(pr.deleteComment).toHaveBeenCalledTimes(1);
+      expect(pr.deleteComment).toHaveBeenCalledWith(10);
+    });
+
+    it("deleteReview 失败时静默忽略，继续处理其他", async () => {
+      pr.getReviews.mockResolvedValue([
+        { id: 1, body: REVIEW_LINE_COMMENTS_MARKER },
+        { id: 2, body: REVIEW_LINE_COMMENTS_MARKER },
+      ]);
+      pr.deleteReview
+        .mockRejectedValueOnce(new Error("submitted review cannot be deleted"))
+        .mockResolvedValueOnce(undefined);
+      pr.getComments.mockResolvedValue([]);
+
+      await expect(deleteExistingAiReviews(pr)).resolves.not.toThrow();
+      expect(pr.deleteReview).toHaveBeenCalledTimes(2);
+    });
+
+    it("getReviews 失败时静默忽略，继续处理 comments", async () => {
+      pr.getReviews.mockRejectedValue(new Error("API error"));
+      pr.getComments.mockResolvedValue([{ id: 10, body: REVIEW_COMMENT_MARKER }]);
+      pr.deleteComment.mockResolvedValue(undefined);
+
+      await expect(deleteExistingAiReviews(pr)).resolves.not.toThrow();
+      expect(pr.deleteComment).toHaveBeenCalledWith(10);
+    });
+
+    it("无 AI 评论时不调用任何 delete", async () => {
+      pr.getReviews.mockResolvedValue([{ id: 1, body: "普通 review" }]);
+      pr.getComments.mockResolvedValue([{ id: 10, body: "普通评论" }]);
+
+      await deleteExistingAiReviews(pr);
+
+      expect(pr.deleteReview).not.toHaveBeenCalled();
+      expect(pr.deleteComment).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/utils/review-pr-comment.ts

@@ -0,0 +1,186 @@
+import { ReviewIssue, ReviewResult, ReviewStats } from "../review-spec";
+import { PullRequestModel } from "../pull-request-model";
+
+export const REVIEW_COMMENT_MARKER = "<!-- spaceflow-review -->";
+export const REVIEW_LINE_COMMENTS_MARKER = "<!-- spaceflow-review-lines -->";
+
+/**
+ * 从评论 body 中提取 issue key（AI 行级评论末尾的 HTML 注释标记）
+ * 格式：`<!-- issue-key: file:line:ruleId -->`
+ * 返回 null 表示非 AI 评论（即用户真实回复）
+ */
+export function extractIssueKeyFromBody(body: string): string | null {
+  const match = body.match(/<!-- issue-key: (.+?) -->/);
+  return match ? match[1] : null;
+}
+
+/**
+ * 判断评论是否为 AI 生成的评论（非用户真实回复）
+ * 除 issue-key 标记外，还通过结构化格式特征识别
+ */
+export function isAiGeneratedComment(body: string): boolean {
+  if (!body) return false;
+  // 含 issue-key 标记
+  if (body.includes("<!-- issue-key:")) return true;
+  // 含 AI 评论的结构化格式特征（同时包含「规则」和「文件」字段）
+  if (body.includes("- **规则**:") && body.includes("- **文件**:")) return true;
+  return false;
+}
+
+export function generateIssueKey(issue: ReviewIssue): string {
+  return `${issue.file}:${issue.line}:${issue.ruleId}`;
+}
+
+/**
+ * 同步评论回复到对应的 issues
+ * review 评论回复是通过同一个 review 下的后续评论实现的
+ *
+ * 通过 AI 评论 body 中嵌入的 issue key 精确匹配 issue：
+ * - 含 issue key 的评论是 AI 自身评论，过滤掉不作为回复
+ * - 不含 issue key 但匹配 AI 格式特征的评论也视为 AI 评论，过滤掉
+ * - 其余评论是用户真实回复，归到其前面最近的 AI 评论对应的 issue
+ */
+export async function syncRepliesToIssues(
+  reviewComments: {
+    id?: number;
+    path?: string;
+    position?: number;
+    body?: string;
+    user?: { id?: number; login?: string };
+    created_at?: string;
+  }[],
+  result: ReviewResult,
+  lineMatchesPosition: (issueLine: string, position?: number) => boolean,
+): Promise<void> {
+  try {
+    // 构建 issue key → issue 的映射，用于快速查找
+    const issueByKey = new Map<string, ReviewResult["issues"][0]>();
+    for (const issue of result.issues) {
+      issueByKey.set(generateIssueKey(issue), issue);
+    }
+    // 按文件路径和行号分组评论
+    const commentsByLocation = new Map<string, typeof reviewComments>();
+    for (const comment of reviewComments) {
+      if (!comment.path || !comment.position) continue;
+      const key = `${comment.path}:${comment.position}`;
+      const comments = commentsByLocation.get(key) || [];
+      comments.push(comment);
+      commentsByLocation.set(key, comments);
+    }
+    // 遍历每个位置的评论
+    for (const [, comments] of commentsByLocation) {
+      if (comments.length <= 1) continue;
+      // 按创建时间排序
+      comments.sort((a, b) => {
+        const timeA = a.created_at ? new Date(a.created_at).getTime() : 0;
+        const timeB = b.created_at ? new Date(b.created_at).getTime() : 0;
+        return timeA - timeB;
+      });
+      // 遍历评论，用 issue key 精确匹配
+      let lastIssueKey: string | null = null;
+      for (const comment of comments) {
+        const commentBody = comment.body || "";
+        const issueKey = extractIssueKeyFromBody(commentBody);
+        if (issueKey) {
+          // AI 自身评论（含 issue-key），记录 issue key 但不作为回复
+          lastIssueKey = issueKey;
+          continue;
+        }
+        // 跳过不含 issue-key 但匹配 AI 格式特征的评论（如其他轮次的 bot 评论）
+        if (isAiGeneratedComment(commentBody)) {
+          continue;
+        }
+        // 用户真实回复，通过前面最近的 AI 评论的 issue key 精确匹配
+        let matchedIssue = lastIssueKey ? (issueByKey.get(lastIssueKey) ?? null) : null;
+        // 回退：如果 issue key 匹配失败，使用 path:position 匹配
+        if (!matchedIssue) {
+          matchedIssue =
+            result.issues.find(
+              (issue) =>
+                issue.file === comment.path && lineMatchesPosition(issue.line, comment.position),
+            ) ?? null;
+        }
+        if (!matchedIssue) continue;
+        // 追加回复（而非覆盖，同一 issue 可能有多条用户回复）
+        if (!matchedIssue.replies) {
+          matchedIssue.replies = [];
+        }
+        matchedIssue.replies.push({
+          user: {
+            id: comment.user?.id?.toString(),
+            login: comment.user?.login || "unknown",
+          },
+          body: comment.body || "",
+          createdAt: comment.created_at || "",
+        });
+      }
+    }
+  } catch (error) {
+    console.warn("⚠️ 同步评论回复失败:", error);
+  }
+}
+
+/**
+ * 删除已有的 AI review（通过 marker 识别）
+ * - 删除行级评论的 PR Review（带 REVIEW_LINE_COMMENTS_MARKER）
+ * - 删除主评论的 Issue Comment（带 REVIEW_COMMENT_MARKER）
+ */
+export async function deleteExistingAiReviews(pr: PullRequestModel): Promise<void> {
+  let deletedCount = 0;
+  // 删除行级评论的 PR Review
+  try {
+    const reviews = await pr.getReviews();
+    const aiReviews = reviews.filter(
+      (r) =>
+        r.body?.includes(REVIEW_LINE_COMMENTS_MARKER) || r.body?.includes(REVIEW_COMMENT_MARKER),
+    );
+    for (const review of aiReviews) {
+      if (review.id) {
+        try {
+          await pr.deleteReview(review.id);
+          deletedCount++;
+        } catch {
+          // 已提交的 review 无法删除，忽略
+        }
+      }
+    }
+  } catch (error) {
+    console.warn("⚠️ 列出 PR reviews 失败:", error);
+  }
+  // 删除主评论的 Issue Comment
+  try {
+    const comments = await pr.getComments();
+    const aiComments = comments.filter((c) => c.body?.includes(REVIEW_COMMENT_MARKER));
+    for (const comment of aiComments) {
+      if (comment.id) {
+        try {
+          await pr.deleteComment(comment.id);
+          deletedCount++;
+        } catch (error) {
+          console.warn(`⚠️ 删除评论 ${comment.id} 失败:`, error);
+        }
+      }
+    }
+  } catch (error) {
+    console.warn("⚠️ 列出 issue comments 失败:", error);
+  }
+  if (deletedCount > 0) {
+    console.log(`🗑️ 已删除 ${deletedCount} 个旧的 AI review`);
+  }
+}
+
+/**
+ * 计算问题状态统计
+ */
+export function calculateIssueStats(issues: ReviewIssue[]): ReviewStats {
+  const total = issues.length;
+  const validIssue = issues.filter((i) => i.valid !== "false");
+  const validTotal = validIssue.length;
+  const fixed = validIssue.filter((i) => i.fixed).length;
+  const resolved = validIssue.filter((i) => i.resolved && !i.fixed).length;
+  const invalid = total - validTotal;
+  const pending = validTotal - fixed - resolved;
+  const fixRate = validTotal > 0 ? Math.round((fixed / validTotal) * 100 * 10) / 10 : 0;
+  const resolveRate = validTotal > 0 ? Math.round((resolved / validTotal) * 100 * 10) / 10 : 0;
+  return { total, validTotal, fixed, resolved, invalid, pending, fixRate, resolveRate };
+}

package/tsconfig.json

@@ -1,5 +1,5 @@
 {
-  "extends": "../../packages/core/tsconfig.skill.json",
+  "extends": "../../packages/core/tsconfig.extension.json",
   "compilerOptions": {
     "types": ["vitest/globals"]
   },