@spaceflow/review 0.76.0 → 0.78.0

package/src/review-includes-filter.spec.ts

@@ -0,0 +1,284 @@
+import { describe, it, expect } from "vitest";
+import {
+  parseIncludePattern,
+  filterFilesByIncludes,
+  extractGlobsFromIncludes,
+  extractCodeBlockTypes,
+} from "./review-includes-filter";
+
+describe("review-includes-filter", () => {
+  describe("parseIncludePattern", () => {
+    it("无分隔符时返回原始 glob，status 为 undefined", () => {
+      expect(parseIncludePattern("*/**/*.ts")).toEqual({ status: undefined, glob: "*/**/*.ts" });
+    });
+
+    it("! 开头的排除模式直接返回，不解析前缀", () => {
+      expect(parseIncludePattern("!*/**/*.spec.ts")).toEqual({
+        status: undefined,
+        glob: "!*/**/*.spec.ts",
+      });
+    });
+
+    it("added| 前缀解析为 status=added", () => {
+      expect(parseIncludePattern("added|*/**/*.ts")).toEqual({
+        status: "added",
+        glob: "*/**/*.ts",
+      });
+    });
+
+    it("modified| 前缀解析为 status=modified", () => {
+      expect(parseIncludePattern("modified|*/**/*.ts")).toEqual({
+        status: "modified",
+        glob: "*/**/*.ts",
+      });
+    });
+
+    it("deleted| 前缀解析为 status=deleted", () => {
+      expect(parseIncludePattern("deleted|*/**/*.ts")).toEqual({
+        status: "deleted",
+        glob: "*/**/*.ts",
+      });
+    });
+
+    it("glob 部分可以带 ! 前缀（status 内排除语法）", () => {
+      expect(parseIncludePattern("added|!*/**/*.spec.ts")).toEqual({
+        status: "added",
+        glob: "!*/**/*.spec.ts",
+      });
+    });
+
+    it("无法识别的前缀当作普通 glob 处理（容错）", () => {
+      expect(parseIncludePattern("unknown|*/**/*.ts")).toEqual({
+        status: undefined,
+        glob: "unknown|*/**/*.ts",
+      });
+    });
+
+    it("extglob 中含 | 不被误识别为前缀分隔符", () => {
+      expect(parseIncludePattern("+(*.ts|*.js)")).toEqual({
+        status: undefined,
+        glob: "+(*.ts|*.js)",
+      });
+    });
+
+    it("前缀大小写不敏感", () => {
+      expect(parseIncludePattern("Added|*/**/*.ts")).toEqual({
+        status: "added",
+        glob: "*/**/*.ts",
+      });
+      expect(parseIncludePattern("MODIFIED|*/**/*.ts")).toEqual({
+        status: "modified",
+        glob: "*/**/*.ts",
+      });
+    });
+
+    it("平台别名：created 映射为 added", () => {
+      expect(parseIncludePattern("created|*/**/*.ts")).toEqual({
+        status: "added",
+        glob: "*/**/*.ts",
+      });
+    });
+
+    it("平台别名：removed 映射为 deleted", () => {
+      expect(parseIncludePattern("removed|*/**/*.ts")).toEqual({
+        status: "deleted",
+        glob: "*/**/*.ts",
+      });
+    });
+
+    it("平台别名：renamed 映射为 modified", () => {
+      expect(parseIncludePattern("renamed|*/**/*.ts")).toEqual({
+        status: "modified",
+        glob: "*/**/*.ts",
+      });
+    });
+  });
+
+  describe("filterFilesByIncludes", () => {
+    const files = [
+      { filename: "src/foo.ts", status: "added" },
+      { filename: "src/foo.spec.ts", status: "added" },
+      { filename: "src/bar.ts", status: "modified" },
+      { filename: "src/bar.spec.ts", status: "modified" },
+      { filename: "src/old.ts", status: "removed" },
+      { filename: "src/old.spec.ts", status: "removed" },
+    ];
+    const glob = "**/*.ts";
+    const specGlob = "**/*.spec.ts";
+
+    it("includes 为空时返回全部文件", () => {
+      expect(filterFilesByIncludes(files, [])).toEqual(files);
+    });
+
+    it("无前缀 glob 不限 status，匹配所有 .ts 文件", () => {
+      const result = filterFilesByIncludes(files, [glob]);
+      expect(result.map((f) => f.filename)).toEqual([
+        "src/foo.ts",
+        "src/foo.spec.ts",
+        "src/bar.ts",
+        "src/bar.spec.ts",
+        "src/old.ts",
+        "src/old.spec.ts",
+      ]);
+    });
+
+    it("排除模式过滤掉 spec 文件", () => {
+      const result = filterFilesByIncludes(files, [glob, `!${specGlob}`]);
+      expect(result.map((f) => f.filename)).toEqual(["src/foo.ts", "src/bar.ts", "src/old.ts"]);
+    });
+
+    it("排除模式优先于所有正向匹配", () => {
+      const result = filterFilesByIncludes(files, [`added|${glob}`, `!${specGlob}`]);
+      expect(result.map((f) => f.filename)).toEqual(["src/foo.ts"]);
+    });
+
+    it("added| 前缀只匹配 added 状态文件", () => {
+      const result = filterFilesByIncludes(files, [`added|${glob}`]);
+      expect(result.map((f) => f.filename)).toEqual(["src/foo.ts", "src/foo.spec.ts"]);
+    });
+
+    it("modified| 前缀只匹配 modified 状态文件", () => {
+      const result = filterFilesByIncludes(files, [`modified|${glob}`]);
+      expect(result.map((f) => f.filename)).toEqual(["src/bar.ts", "src/bar.spec.ts"]);
+    });
+
+    it("deleted| 前缀匹配 removed 状态文件（平台别名）", () => {
+      const result = filterFilesByIncludes(files, [`deleted|${glob}`]);
+      expect(result.map((f) => f.filename)).toEqual(["src/old.ts", "src/old.spec.ts"]);
+    });
+
+    it("多个 status 前缀之间是 OR 关系", () => {
+      const result = filterFilesByIncludes(files, [`added|${glob}`, `modified|${glob}`]);
+      expect(result.map((f) => f.filename)).toEqual([
+        "src/foo.ts",
+        "src/foo.spec.ts",
+        "src/bar.ts",
+        "src/bar.spec.ts",
+      ]);
+    });
+
+    it("status 前缀内排除语法 added|!**/*.spec.ts", () => {
+      const result = filterFilesByIncludes(files, [`added|${glob}`, `added|!${specGlob}`]);
+      expect(result.map((f) => f.filename)).toEqual(["src/foo.ts"]);
+    });
+
+    it("status 内排除只影响对应 status，不影响其他 status 的匹配", () => {
+      const result = filterFilesByIncludes(files, [
+        `added|${glob}`,
+        `added|!${specGlob}`,
+        `modified|${glob}`,
+      ]);
+      expect(result.map((f) => f.filename)).toEqual([
+        "src/foo.ts",
+        "src/bar.ts",
+        "src/bar.spec.ts",
+      ]);
+    });
+
+    it("无前缀 glob 与 status 前缀混用时任一命中即保留", () => {
+      const result = filterFilesByIncludes(files, [glob, "added|**/*.vue"]);
+      expect(result.map((f) => f.filename)).toEqual([
+        "src/foo.ts",
+        "src/foo.spec.ts",
+        "src/bar.ts",
+        "src/bar.spec.ts",
+        "src/old.ts",
+        "src/old.spec.ts",
+      ]);
+    });
+
+    it("status 未知的文件 fallback 为 modified", () => {
+      const unknownFiles = [{ filename: "src/foo.ts", status: undefined }];
+      const result = filterFilesByIncludes(unknownFiles, [`modified|${glob}`]);
+      expect(result.map((f) => f.filename)).toEqual(["src/foo.ts"]);
+    });
+
+    it("status 未知的文件不被 added| 匹配", () => {
+      const unknownFiles = [{ filename: "src/foo.ts", status: undefined }];
+      const result = filterFilesByIncludes(unknownFiles, [`added|${glob}`]);
+      expect(result).toEqual([]);
+    });
+
+    it("filename 为空的文件被过滤掉", () => {
+      const withEmpty = [
+        { filename: "", status: "added" },
+        { filename: "src/foo.ts", status: "added" },
+      ];
+      const result = filterFilesByIncludes(withEmpty, [glob]);
+      expect(result.map((f) => f.filename)).toEqual(["src/foo.ts"]);
+    });
+
+    it("GitHub 平台 status=removed 被 deleted| 前缀匹配", () => {
+      const ghFiles = [{ filename: "src/old.ts", status: "removed" }];
+      expect(filterFilesByIncludes(ghFiles, [`deleted|${glob}`])).toHaveLength(1);
+    });
+
+    it("GitLab 平台 status=deleted 被 deleted| 前缀匹配", () => {
+      const glFiles = [{ filename: "src/old.ts", status: "deleted" }];
+      expect(filterFilesByIncludes(glFiles, [`deleted|${glob}`])).toHaveLength(1);
+    });
+
+    it("全量 diff 语义：文件在当前分支首次引入后被多次修改，status 仍为 added，added| 始终匹配", () => {
+      // 场景：a.ts 在 commit1 创建（status=added），在 commit2 修改
+      // 全量 diff（当前分支 vs base）时，compare API 返回的 status 仍为 added
+      // 因此 added|*.ts 在后续每次 review 中都能匹配到该文件
+      const diffFiles = [{ filename: "src/a.ts", status: "added" }];
+      const result = filterFilesByIncludes(diffFiles, [`added|${glob}`]);
+      expect(result.map((f) => f.filename)).toEqual(["src/a.ts"]);
+    });
+  });
+
+  describe("extractGlobsFromIncludes", () => {
+    it("无前缀的 glob 原样返回", () => {
+      expect(extractGlobsFromIncludes(["**/*.ts", "!**/*.spec.ts"])).toEqual([
+        "**/*.ts",
+        "!**/*.spec.ts",
+      ]);
+    });
+
+    it("有 status 前缀的 pattern 去掉前缀只返回 glob 部分", () => {
+      expect(extractGlobsFromIncludes(["added|**/*.ts", "modified|**/*.vue"])).toEqual([
+        "**/*.ts",
+        "**/*.vue",
+      ]);
+    });
+
+    it("混合模式只提取 glob 部分", () => {
+      expect(extractGlobsFromIncludes(["**/*.ts", "added|**/*.vue", "!**/*.spec.ts"])).toEqual([
+        "**/*.ts",
+        "**/*.vue",
+        "!**/*.spec.ts",
+      ]);
+    });
+
+    it("空数组返回空数组", () => {
+      expect(extractGlobsFromIncludes([])).toEqual([]);
+    });
+  });
+
+  describe("extractCodeBlockTypes", () => {
+    it("提取纯类型名", () => {
+      const result = extractCodeBlockTypes(["function", "class"]);
+      expect(result).toEqual(["function", "class"]);
+    });
+
+    it("status|code-* 语法不被识别，返回空", () => {
+      const result = extractCodeBlockTypes(["added|code-function", "added|code-class"]);
+      expect(result).toEqual([]);
+    });
+
+    it("混合：纯类型名保留，status 前缀语法忽略", () => {
+      const result = extractCodeBlockTypes(["added|code-function", "class"]);
+      expect(result).toEqual(["class"]);
+    });
+
+    it("去重：同一类型出现多次只返回一次", () => {
+      const result = extractCodeBlockTypes(["function", "function"]);
+      expect(result).toEqual(["function"]);
+    });
+
+    it("空数组返回空数组", () => {
+      expect(extractCodeBlockTypes([])).toEqual([]);
+    });
+  });
+});

package/src/review-includes-filter.ts

@@ -0,0 +1,196 @@
+import micromatch from "micromatch";
+
+/**
+ * includes 模式中的变更类型前缀
+ *
+ * 语法：`<status>|<glob>`，例如：
+ * - `added|*\/**\/*.ts`          → 仅匹配新增文件
+ * - `modified|*\/**\/*.ts`       → 仅匹配修改文件
+ * - `deleted|*\/**\/*.ts`        → 仅匹配删除文件
+ * - `*\/**\/*.ts`               → 不限变更类型（原有行为）
+ *
+ * ## 全量 diff 语义说明
+ *
+ * 每次 review 是对当前分支与 base 分支（develop/master）的**全量 diff**，
+ * 文件的 status 由平台 compare API 给出，表示该文件**相对 base 分支**的变更类型。
+ *
+ * 因此，若 `a.ts` 是在当前分支上首次引入的（相对 base 不存在），
+ * 无论后续经过多少次 commit 修改，其 status **始终为 `added`**。
+ * 这意味着 `added|*.ts` 在后续每次 review 中都会继续匹配该文件，
+ * 这是符合预期的行为——只要文件相对 base 是"新建"的，`added|` 就应该始终生效。
+ */
+export type IncludeStatusPrefix = "added" | "modified" | "deleted";
+
+/**
+ * 代码结构类型，用于 whenModifiedCode 配置
+ */
+export type CodeBlockType = "function" | "class" | "interface" | "type" | "method";
+
+export const CODE_BLOCK_TYPES: CodeBlockType[] = [
+  "function",
+  "class",
+  "interface",
+  "type",
+  "method",
+];
+
+/** status 值到前缀的映射（兼容 GitHub/GitLab/Gitea 各平台） */
+const STATUS_ALIAS: Record<string, IncludeStatusPrefix> = {
+  added: "added",
+  created: "added",
+  renamed: "modified",
+  modified: "modified",
+  changed: "modified",
+  removed: "deleted",
+  deleted: "deleted",
+};
+
+export interface ParsedIncludePattern {
+  /** 变更类型前缀，undefined 表示不限类型 */
+  status: IncludeStatusPrefix | undefined;
+  /** 去掉前缀后的 glob 模式 */
+  glob: string;
+}
+
+/**
+ * 解析单条 include 模式，拆分 status 前缀和 glob。
+ *
+ * 只有当 `|` 前面的部分是已知 status 关键字时才视为前缀，否则当作普通 glob 处理（容错），
+ * 这样可以避免误解析 extglob 语法中含 `|` 的模式（如 `+(*.ts|*.js)`）。
+ * 排除模式（以 `!` 开头）始终作为普通 glob 处理。
+ */
+export function parseIncludePattern(pattern: string): ParsedIncludePattern {
+  if (pattern.startsWith("!")) {
+    return { status: undefined, glob: pattern };
+  }
+  const separatorIndex = pattern.indexOf("|");
+  if (separatorIndex === -1) {
+    return { status: undefined, glob: pattern };
+  }
+  const prefix = pattern.slice(0, separatorIndex).trim().toLowerCase();
+  const glob = pattern.slice(separatorIndex + 1).trim();
+  const status = STATUS_ALIAS[prefix] as IncludeStatusPrefix | undefined;
+  if (!status) {
+    // 前缀无法识别（如 extglob 中的 `|`），当作普通 glob 处理
+    return { status: undefined, glob: pattern };
+  }
+
+  return { status, glob };
+}
+
+export interface FileWithStatus {
+  filename?: string;
+  status?: string;
+}
+
+/**
+ * 根据 includes 模式列表过滤文件，支持 `status|glob` 前缀语法。
+ *
+ * 算法：
+ * 1. 将 includes 拆分为：排除模式(`!`)、无前缀正向 glob、有 status 前缀 glob
+ * 2. 每个文件先检查是否命中任意正向条件（无前缀 glob 或匹配 status 的前缀 glob）
+ * 3. 最后用排除模式做全局过滤（排除模式始终优先）
+ *
+ * @param files     待过滤的文件列表
+ * @param includes  include 模式列表，支持 `added|*.ts`、`modified|*.ts`、`deleted|*.ts` 前缀
+ * @returns         匹配的文件列表
+ */
+export function filterFilesByIncludes<T extends FileWithStatus>(
+  files: T[],
+  includes: string[],
+): T[] {
+  if (!includes || includes.length === 0) return files;
+
+  const parsed = includes.map(parseIncludePattern);
+  console.log(`[filterFilesByIncludes] parsed patterns=${JSON.stringify(parsed)}`);
+
+  // 排除模式（以 ! 开头），用于最终全局过滤
+  const negativeGlobs = parsed
+    .filter((p) => p.status === undefined && p.glob.startsWith("!"))
+    .map((p) => p.glob.slice(1)); // 去掉 ! 前缀，用 micromatch.not 处理
+  // 无前缀的正向 globs
+  const plainGlobs = parsed
+    .filter((p) => p.status === undefined && !p.glob.startsWith("!"))
+    .map((p) => p.glob);
+  // 有 status 前缀的 patterns
+  const statusPatterns = parsed.filter((p) => p.status !== undefined);
+
+  console.log(
+    `[filterFilesByIncludes] negativeGlobs=${JSON.stringify(negativeGlobs)}, plainGlobs=${JSON.stringify(plainGlobs)}, statusPatterns=${JSON.stringify(statusPatterns)}`,
+  );
+
+  return files.filter((file) => {
+    const filename = file.filename ?? "";
+    const fileStatus = STATUS_ALIAS[file.status?.toLowerCase() ?? ""] ?? "modified";
+    if (!filename) return false;
+
+    // 最终排除：命中排除模式的文件直接过滤掉
+    if (
+      negativeGlobs.length > 0 &&
+      micromatch.isMatch(filename, negativeGlobs, { matchBase: true })
+    ) {
+      console.log(`[filterFilesByIncludes] ${filename} excluded by negativeGlobs`);
+      return false;
+    }
+
+    // 正向匹配：无前缀 glob
+    if (plainGlobs.length > 0 && micromatch.isMatch(filename, plainGlobs, { matchBase: true })) {
+      console.log(`[filterFilesByIncludes] ${filename} matched plainGlobs`);
+      return true;
+    }
+
+    // 正向匹配：有 status 前缀的 glob，按文件实际 status 过滤
+    // glob 可以带 ! 前缀表示在该 status 范围内排除，如 added|!**/*.spec.ts
+    if (statusPatterns.length > 0) {
+      // 按 status 分组，每组内正向 glob + 排除 glob 合并后批量匹配
+      const matchingStatusGlobs = statusPatterns
+        .filter(({ status }) => status === fileStatus)
+        .map(({ glob }) => glob);
+      if (matchingStatusGlobs.length > 0) {
+        // 有正向 glob 才有意义，纯排除 glob 组合 micromatch 会视为全匹配再排除
+        const positiveGlobs = matchingStatusGlobs.filter((g) => !g.startsWith("!"));
+        const negativeStatusGlobs = matchingStatusGlobs
+          .filter((g) => g.startsWith("!"))
+          .map((g) => g.slice(1));
+        if (positiveGlobs.length > 0) {
+          const matchesPositive = micromatch.isMatch(filename, positiveGlobs, { matchBase: true });
+          const matchesNegative =
+            negativeStatusGlobs.length > 0 &&
+            micromatch.isMatch(filename, negativeStatusGlobs, { matchBase: true });
+          if (matchesPositive && !matchesNegative) {
+            console.log(
+              `[filterFilesByIncludes] ${filename} (status=${fileStatus}) matched statusPatterns`,
+            );
+            return true;
+          }
+        }
+      }
+    }
+
+    console.log(`[filterFilesByIncludes] ${filename} (status=${fileStatus}) NOT matched`);
+    return false;
+  });
+}
+
+/**
+ * 从 includes 模式列表中提取纯 glob（用于 commit 过滤，commit 没有 status 概念）。
+ * 带 status 前缀的模式会去掉前缀，仅保留 glob 部分。
+ */
+export function extractGlobsFromIncludes(includes: string[]): string[] {
+  return includes.map((p) => parseIncludePattern(p).glob).filter((g) => g.length > 0);
+}
+
+/**
+ * 从 whenModifiedCode 配置中解析代码结构过滤类型。
+ * 只接受简单的类型名称，如 "function"、"class"、"interface"、"type"、"method"
+ */
+export function extractCodeBlockTypes(whenModifiedCode: string[]): CodeBlockType[] {
+  const types = new Set<CodeBlockType>();
+  for (const entry of whenModifiedCode) {
+    const trimmed = entry.trim();
+    if ((CODE_BLOCK_TYPES as string[]).includes(trimmed)) {
+      types.add(trimmed as CodeBlockType);
+    }
+  }
+  return [...types];
+}