@spaceflow/review 0.77.0 → 0.78.0

package/src/utils/review-llm.ts

@@ -1,13 +1,158 @@
 import type { PullRequestCommit } from "@spaceflow/core";
+import type { CodeBlockType } from "../review-includes-filter";
 
-export function buildLinesWithNumbers(contentLines: [string, string][]): string {
+/**
+ * 构建带行号的文件内容字符串。
+ *
+ * @param contentLines  [hash, code] 行数组
+ * @param visibleRanges 可选，指定需要输出的行号区间 [startLine, endLine]（不含则输出全文）
+ *                      被跳过的连续行用 `...... ..| ignore {start}-{end} code` 占位
+ */
+export function buildLinesWithNumbers(
+  contentLines: [string, string][],
+  visibleRanges?: [number, number][],
+): string {
   const padWidth = String(contentLines.length).length;
-  return contentLines
-    .map(([hash, line], index) => {
-      const lineNum = index + 1;
-      return `${hash} ${String(lineNum).padStart(padWidth)}| ${line}`;
-    })
-    .join("\n");
+
+  if (!visibleRanges || visibleRanges.length === 0) {
+    return contentLines
+      .map(([hash, line], index) => {
+        const lineNum = index + 1;
+        return `${hash} ${String(lineNum).padStart(padWidth)}| ${line}`;
+      })
+      .join("\n");
+  }
+
+  // 将 ranges 按起始行号排序并合并重叠区间
+  const sorted = [...visibleRanges].sort((a, b) => a[0] - b[0]);
+  const merged: [number, number][] = [];
+  for (const range of sorted) {
+    if (merged.length > 0 && range[0] <= merged[merged.length - 1][1] + 1) {
+      merged[merged.length - 1][1] = Math.max(merged[merged.length - 1][1], range[1]);
+    } else {
+      merged.push([...range]);
+    }
+  }
+
+  const output: string[] = [];
+  let prevEnd = 0;
+
+  for (const [start, end] of merged) {
+    const clampedStart = Math.max(1, start);
+    const clampedEnd = Math.min(contentLines.length, end);
+
+    // 被忽略的前缀区间
+    if (clampedStart > prevEnd + 1) {
+      output.push(`....... ignore ${prevEnd + 1}-${clampedStart - 1} line .......`);
+    }
+
+    // 输出可见行
+    for (let i = clampedStart - 1; i < clampedEnd; i++) {
+      const [hash, line] = contentLines[i];
+      const lineNum = i + 1;
+      output.push(`${hash} ${String(lineNum).padStart(padWidth)}| ${line}`);
+    }
+
+    prevEnd = clampedEnd;
+  }
+
+  // 被忽略的末尾区间
+  if (prevEnd < contentLines.length) {
+    output.push(`....... ignore ${prevEnd + 1}-${contentLines.length} line .......`);
+  }
+
+  return output.join("\n");
+}
+
+/**
+ * 从 contentLines 中提取新增代码里的指定结构类型的行号范围。
+ *
+ * 逻辑：
+ * 1. 只考虑 hash !== "-------" 的新增行
+ * 2. 用各类型的正则匹配结构开头行，再用层级计数找到结尾行
+ * 3. 返回行号范围列表 [startLine, endLine]（从 1 计）
+ *
+ * @param contentLines  文件的 [hash, code] 行列表
+ * @param types         要提取的结构类型
+ */
+export function extractCodeBlocks(
+  contentLines: [string, string][],
+  types: CodeBlockType[],
+): [number, number][] {
+  if (types.length === 0) return [];
+
+  const ranges: [number, number][] = [];
+
+  // 将所有行的实际代码组成文本（用于层级计数）
+  const fullLines = contentLines.map(([, code]) => code);
+
+  // 各类型的开头識别正则（匹配行首）
+  const PATTERNS: Record<CodeBlockType, RegExp> = {
+    function: /^\s*(?:export\s+)?(?:async\s+)?function\s+\w+/,
+    class: /^\s*(?:export\s+)?(?:abstract\s+)?class\s+\w+/,
+    interface: /^\s*(?:export\s+)?interface\s+\w+/,
+    type: /^\s*(?:export\s+)?type\s+\w+\s*[=<]/,
+    method:
+      /^\s*(?:(?:public|protected|private|static|async|override|readonly|abstract)\s+)*(?!(?:if|for|while|switch|return|const|let|var|throw|new)\b)(\w+)\s*[(<]/,
+  };
+
+  for (let i = 0; i < fullLines.length; i++) {
+    const lineNum = i + 1;
+    const isAdded = contentLines[i][0] !== "-------";
+    if (!isAdded) continue;
+
+    for (const type of types) {
+      const pattern = PATTERNS[type];
+      if (!pattern.test(fullLines[i])) continue;
+
+      // 找到结构开头，用层级计数找封闭括号结尾
+      const endLine = findBlockEnd(fullLines, i);
+      ranges.push([lineNum, endLine]);
+      break; // 同一行只匹配一种类型
+    }
+  }
+
+  return mergeRanges(ranges);
+}
+
+/**
+ * 从开始行向下层级计数，找到匹配的封闭括号位置（行号从 1 计）。
+ * 如果没有找到匹配括号，返回开始行到文件末尾。
+ */
+function findBlockEnd(lines: string[], startIndex: number): number {
+  let depth = 0;
+  let foundOpen = false;
+
+  for (let i = startIndex; i < lines.length; i++) {
+    for (const ch of lines[i]) {
+      if (ch === "{") {
+        depth++;
+        foundOpen = true;
+      } else if (ch === "}") {
+        depth--;
+        if (foundOpen && depth === 0) {
+          return i + 1; // 行号从 1 计
+        }
+      }
+    }
+  }
+
+  return lines.length; // 没有找到匹配括号，返回文件末尾
+}
+
+function mergeRanges(ranges: [number, number][]): [number, number][] {
+  if (ranges.length === 0) return [];
+  const sorted = [...ranges].sort((a, b) => a[0] - b[0]);
+  const merged: [number, number][] = [sorted[0]];
+  for (let i = 1; i < sorted.length; i++) {
+    const last = merged[merged.length - 1];
+    if (sorted[i][0] <= last[1] + 1) {
+      last[1] = Math.max(last[1], sorted[i][1]);
+    } else {
+      merged.push([...sorted[i]]);
+    }
+  }
+  return merged;
 }
 
 export function buildCommitsSection(

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/{review-pr-comment-utils.ts → utils/review-pr-comment.ts}

@@ -1,5 +1,5 @@
-import { ReviewIssue, ReviewResult, ReviewStats } from "./review-spec";
-import { PullRequestModel } from "./pull-request-model";
+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 -->";