@spaceflow/review 0.77.0 → 0.79.0

package/src/utils/review-llm.spec.ts

@@ -0,0 +1,277 @@
+import { describe, it, expect } from "vitest";
+import { buildLinesWithNumbers, buildCommitsSection, extractCodeBlocks } from "./review-llm";
+
+describe("utils/review-llm", () => {
+  describe("buildLinesWithNumbers", () => {
+    const lines: [string, string][] = [
+      ["abc1234", "line one"],
+      ["-------", "line two"],
+      ["abc1234", "line three"],
+    ];
+
+    it("无 visibleRanges 时输出全部行，带行号和 hash", () => {
+      expect(buildLinesWithNumbers(lines)).toBe(
+        "abc1234 1| line one\n------- 2| line two\nabc1234 3| line three",
+      );
+    });
+
+    it("行号宽度按总行数自动 pad（10 行时个位行号前有空格）", () => {
+      const tenLines: [string, string][] = Array.from({ length: 10 }, (_, i) => [
+        "abc1234",
+        `line ${i + 1}`,
+      ]);
+      const result = buildLinesWithNumbers(tenLines);
+      expect(result.split("\n")[0]).toContain(" 1|");
+      expect(result.split("\n")[9]).toContain("10|");
+    });
+
+    it("visibleRanges 为空数组时等价于无 visibleRanges，输出全部行", () => {
+      expect(buildLinesWithNumbers(lines, [])).toBe(buildLinesWithNumbers(lines));
+    });
+
+    it("只指定首行时，末尾被忽略区间产生 ignore 占位", () => {
+      const result = buildLinesWithNumbers(lines, [[1, 1]]);
+      expect(result).toBe("abc1234 1| line one\n....... ignore 2-3 line .......");
+    });
+
+    it("只指定末行时，开头被忽略区间产生 ignore 占位", () => {
+      const result = buildLinesWithNumbers(lines, [[3, 3]]);
+      expect(result).toBe("....... ignore 1-2 line .......\nabc1234 3| line three");
+    });
+
+    it("只指定中间行时，前后均产生 ignore 占位", () => {
+      const result = buildLinesWithNumbers(lines, [[2, 2]]);
+      expect(result).toBe(
+        "....... ignore 1-1 line .......\n------- 2| line two\n....... ignore 3-3 line .......",
+      );
+    });
+
+    it("多个不相邻范围各自产生 ignore 占位", () => {
+      const fiveLines: [string, string][] = [
+        ["abc1234", "a"],
+        ["-------", "b"],
+        ["abc1234", "c"],
+        ["-------", "d"],
+        ["abc1234", "e"],
+      ];
+      const result = buildLinesWithNumbers(fiveLines, [
+        [1, 1],
+        [5, 5],
+      ]);
+      expect(result).toBe("abc1234 1| a\n....... ignore 2-4 line .......\nabc1234 5| e");
+    });
+
+    it("重叠的 visibleRanges 合并后不产生 ignore 占位", () => {
+      const result = buildLinesWithNumbers(lines, [
+        [1, 2],
+        [2, 3],
+      ]);
+      expect(result).not.toContain("ignore");
+      expect(result.split("\n")).toHaveLength(3);
+    });
+
+    it("visibleRanges 超出文件范围时自动裁剪，不产生 ignore 占位", () => {
+      const result = buildLinesWithNumbers(lines, [[0, 100]]);
+      expect(result).not.toContain("ignore");
+      expect(result.split("\n")).toHaveLength(3);
+    });
+
+    it("visibleRanges 无序时按起始行号排序后正常输出", () => {
+      const result = buildLinesWithNumbers(lines, [
+        [3, 3],
+        [1, 1],
+      ]);
+      expect(result).toBe(
+        "abc1234 1| line one\n....... ignore 2-2 line .......\nabc1234 3| line three",
+      );
+    });
+  });
+
+  describe("extractCodeBlocks", () => {
+    it("types 为空时返回空数组", () => {
+      expect(extractCodeBlocks([["abc1234", "function foo() {}"]], [])).toEqual([]);
+    });
+
+    it("空 contentLines 返回空数组", () => {
+      expect(extractCodeBlocks([], ["function"])).toEqual([]);
+    });
+
+    it("全为上下文行时返回空数组", () => {
+      const lines: [string, string][] = [
+        ["-------", "function foo() { }"],
+        ["-------", "class Bar { }"],
+      ];
+      expect(extractCodeBlocks(lines, ["function", "class"])).toEqual([]);
+    });
+
+    it("提取新增的单行 function", () => {
+      expect(
+        extractCodeBlocks([["abc1234", "function foo() { return 1; }"]], ["function"]),
+      ).toEqual([[1, 1]]);
+    });
+
+    it("提取新增的多行 function", () => {
+      const lines: [string, string][] = [
+        ["abc1234", "function foo() {"],
+        ["abc1234", "  return 1;"],
+        ["abc1234", "}"],
+      ];
+      expect(extractCodeBlocks(lines, ["function"])).toEqual([[1, 3]]);
+    });
+
+    it("提取 export function", () => {
+      expect(extractCodeBlocks([["abc1234", "export function hello() { }"]], ["function"])).toEqual(
+        [[1, 1]],
+      );
+    });
+
+    it("提取 async function", () => {
+      expect(extractCodeBlocks([["abc1234", "async function load() { }"]], ["function"])).toEqual([
+        [1, 1],
+      ]);
+    });
+
+    it("上下文行中的 function 不被提取，只提取新增行中的", () => {
+      const lines: [string, string][] = [
+        ["-------", "function foo() {"],
+        ["-------", "  return 1;"],
+        ["-------", "}"],
+        ["abc1234", "function bar() { return 2; }"],
+      ];
+      expect(extractCodeBlocks(lines, ["function"])).toEqual([[4, 4]]);
+    });
+
+    it("提取多行 class 代码块", () => {
+      const lines: [string, string][] = [
+        ["abc1234", "class Foo {"],
+        ["abc1234", "  bar() {}"],
+        ["abc1234", "}"],
+      ];
+      expect(extractCodeBlocks(lines, ["class"])).toEqual([[1, 3]]);
+    });
+
+    it("提取 export class", () => {
+      expect(extractCodeBlocks([["abc1234", "export class Bar { }"]], ["class"])).toEqual([[1, 1]]);
+    });
+
+    it("提取多行 interface", () => {
+      const lines: [string, string][] = [
+        ["abc1234", "export interface IFoo {"],
+        ["abc1234", "  name: string;"],
+        ["abc1234", "}"],
+      ];
+      expect(extractCodeBlocks(lines, ["interface"])).toEqual([[1, 3]]);
+    });
+
+    it("提取 type 别名（含 =）", () => {
+      expect(
+        extractCodeBlocks([["abc1234", "export type MyType = string | number;"]], ["type"]),
+      ).toEqual([[1, 1]]);
+    });
+
+    it("提取泛型 type（含 <）", () => {
+      expect(extractCodeBlocks([["abc1234", "type Result<T> = { data: T };"]], ["type"])).toEqual([
+        [1, 1],
+      ]);
+    });
+
+    it("同时提取 function 和 class，中间上下文行不影响结果", () => {
+      const lines: [string, string][] = [
+        ["abc1234", "function foo() { }"],
+        ["-------", "const x = 1;"],
+        ["abc1234", "class Bar { }"],
+      ];
+      expect(extractCodeBlocks(lines, ["function", "class"])).toEqual([
+        [1, 1],
+        [3, 3],
+      ]);
+    });
+
+    it("相邻代码块合并为一个范围", () => {
+      const lines: [string, string][] = [
+        ["abc1234", "function a() {"],
+        ["abc1234", "}"],
+        ["abc1234", "function b() {"],
+        ["abc1234", "}"],
+      ];
+      expect(extractCodeBlocks(lines, ["function"])).toEqual([[1, 4]]);
+    });
+
+    it("嵌套括号时找到最外层封闭括号作为结尾", () => {
+      const lines: [string, string][] = [
+        ["abc1234", "function outer() {"],
+        ["abc1234", "  if (true) {"],
+        ["abc1234", "    inner();"],
+        ["abc1234", "  }"],
+        ["abc1234", "}"],
+      ];
+      expect(extractCodeBlocks(lines, ["function"])).toEqual([[1, 5]]);
+    });
+
+    it("method：public 修饰的方法识别为完整代码块", () => {
+      const lines: [string, string][] = [
+        ["abc1234", "  public getName() {"],
+        ["abc1234", "    return this.name;"],
+        ["abc1234", "  }"],
+      ];
+      expect(extractCodeBlocks(lines, ["method"])).toEqual([[1, 3]]);
+    });
+
+    it("method：async 方法识别为完整代码块", () => {
+      const lines: [string, string][] = [
+        ["abc1234", "  async fetchData() {"],
+        ["abc1234", "    return await api();"],
+        ["abc1234", "  }"],
+      ];
+      expect(extractCodeBlocks(lines, ["method"])).toHaveLength(1);
+    });
+  });
+
+  describe("buildCommitsSection", () => {
+    const lines: [string, string][] = [
+      ["abc1234", "const x = 1;"],
+      ["-------", "const y = 2;"],
+      ["def5678", "const z = 3;"],
+    ];
+
+    it("有匹配 commit 时返回 markdown 列表（- `hash` 首行消息）", () => {
+      const commits = [
+        { sha: "abc1234abcdef", commit: { message: "feat: add x\n详细说明" } },
+        { sha: "def5678abcdef", commit: { message: "fix: fix z" } },
+      ] as any;
+      const result = buildCommitsSection(lines, commits);
+      expect(result).toContain("- `abc1234` feat: add x");
+      expect(result).toContain("- `def5678` fix: fix z");
+    });
+
+    it("commit 消息只取第一行，忽略后续内容", () => {
+      const commits = [
+        { sha: "abc1234abc", commit: { message: "first line\nsecond line\nthird line" } },
+      ] as any;
+      expect(buildCommitsSection(lines, commits)).toBe("- `abc1234` first line");
+    });
+
+    it("没有匹配 commit 时返回默认文案", () => {
+      const commits = [{ sha: "xxxxxxxxxxxxxxx", commit: { message: "unrelated" } }] as any;
+      expect(buildCommitsSection(lines, commits)).toBe("- 无相关 commits");
+    });
+
+    it("commits 为空数组时返回默认文案", () => {
+      expect(buildCommitsSection(lines, [])).toBe("- 无相关 commits");
+    });
+
+    it("contentLines 全为上下文行时返回默认文案", () => {
+      const ctxLines: [string, string][] = [
+        ["-------", "line 1"],
+        ["-------", "line 2"],
+      ];
+      const commits = [{ sha: "abc1234abc", commit: { message: "msg" } }] as any;
+      expect(buildCommitsSection(ctxLines, commits)).toBe("- 无相关 commits");
+    });
+
+    it("commit sha 为 undefined 时不崩溃，返回默认文案", () => {
+      const commits = [{ sha: undefined, commit: { message: "msg" } }] as any;
+      expect(buildCommitsSection(lines, commits)).toBe("- 无相关 commits");
+    });
+  });
+});

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(