@spaceflow/review 0.83.0 → 1.0.0

package/src/mcp/index.ts

@@ -2,7 +2,7 @@ import { t, z, type SpaceflowContext, type GitProviderService } from "@spaceflow
 import { ReviewSpecService } from "../review-spec";
 import { ChangedFileCollection } from "../changed-file-collection";
 import type { ReviewConfig } from "../review.config";
-import { extractGlobsFromIncludes } from "../review-includes-filter";
+import { matchIncludes } from "../review-includes-filter";
 import { join } from "path";
 import { existsSync } from "fs";
 
@@ -115,16 +115,11 @@ export const tools = [
         allSpecs,
         ChangedFileCollection.from([{ filename: filePath }]),
       );
-      const micromatchModule = await import("micromatch");
-      const micromatch = micromatchModule.default || micromatchModule;
       const rules = applicableSpecs.flatMap((spec) =>
         spec.rules
           .filter((rule) => {
             const includes = rule.includes || spec.includes;
-            if (includes.length === 0) return true;
-            const globs = extractGlobsFromIncludes(includes);
-            if (globs.length === 0) return true;
-            return micromatch.isMatch(filePath, globs, { matchBase: true });
+            return matchIncludes(includes, filePath);
           })
           .map((rule) => ({
             id: rule.id,
@@ -135,9 +130,13 @@ export const tools = [
             ...(includeExamples && rule.examples.length > 0
               ? {
                   examples: rule.examples.map((ex) => ({
-                    type: ex.type,
-                    lang: ex.lang,
-                    code: ex.code,
+                    title: ex.title,
+                    description: ex.description,
+                    content: ex.content.map((c) => ({
+                      title: c.title,
+                      type: c.type,
+                      description: c.description,
+                    })),
                   })),
                 }
               : {}),
@@ -170,9 +169,13 @@ export const tools = [
         includes: spec.includes,
         overrides: rule.overrides,
         examples: rule.examples.map((ex) => ({
-          type: ex.type,
-          lang: ex.lang,
-          code: ex.code,
+          title: ex.title,
+          description: ex.description,
+          content: ex.content.map((c) => ({
+            title: c.title,
+            type: c.type,
+            description: c.description,
+          })),
         })),
       };
     },
@@ -209,9 +212,13 @@ export const tools = [
           ...(includeExamples && rule.examples.length > 0
             ? {
                 examples: rule.examples.map((ex) => ({
-                  type: ex.type,
-                  lang: ex.lang,
-                  code: ex.code,
+                  title: ex.title,
+                  description: ex.description,
+                  content: ex.content.map((c) => ({
+                    title: c.title,
+                    type: c.type,
+                    description: c.description,
+                  })),
                 })),
               }
             : { hasExamples: rule.examples.length > 0 }),

package/src/prompt/specs-section.ts

@@ -0,0 +1,47 @@
+import type { ReviewSpec, RuleExample, RuleContent } from "../review-spec/types";
+
+/**
+ * 构建 specs 的 prompt 部分
+ */
+export function buildSpecsSection(specs: ReviewSpec[]): string {
+  return specs
+    .map((spec) => {
+      const firstRule = spec.rules[0];
+      const rulesText = spec.rules
+        .slice(1)
+        .map((rule) => {
+          let text = `#### [${rule.id}] ${rule.title}\n`;
+          if (rule.description) {
+            text += `${rule.description}\n`;
+          }
+          if (rule.examples.length > 0) {
+            for (const example of rule.examples) {
+              text += formatExample(example);
+            }
+          }
+          return text;
+        })
+        .join("\n");
+
+      return `### ${firstRule.title}\n- 规范文件: ${spec.filename}\n- 适用扩展名: ${spec.extensions.join(", ")}\n\n${rulesText}`;
+    })
+    .join("\n\n-------------------\n\n");
+}
+
+function formatExample(example: RuleExample): string {
+  let text = "";
+  if (example.title) {
+    text += `##### ${example.title}\n`;
+  }
+  if (example.description) {
+    text += `${example.description}\n`;
+  }
+  for (const item of example.content) {
+    text += formatContent(item);
+  }
+  return text;
+}
+
+function formatContent(item: RuleContent): string {
+  return `###### ${item.type}${item.title ? `: ${item.title}` : ""}\n${item.description}\n`;
+}

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

@@ -4,6 +4,7 @@ import {
   filterFilesByIncludes,
   extractGlobsFromIncludes,
   extractCodeBlockTypes,
+  matchIncludes,
 } from "./review-includes-filter";
 
 describe("review-includes-filter", () => {
@@ -281,4 +282,86 @@ describe("review-includes-filter", () => {
       expect(extractCodeBlockTypes([])).toEqual([]);
     });
   });
+
+  describe("matchIncludes", () => {
+    const glob = "**/*.ts";
+
+    it("includes 为空时返回 true", () => {
+      expect(matchIncludes([], "src/foo.ts")).toBe(true);
+    });
+
+    it("filename 为空时返回 false", () => {
+      expect(matchIncludes([glob], "")).toBe(false);
+    });
+
+    it("不传 fileStatus 时降级为纯 glob 匹配", () => {
+      expect(matchIncludes([glob], "src/foo.ts")).toBe(true);
+      expect(matchIncludes([glob], "src/foo.vue")).toBe(false);
+    });
+
+    it("不传 fileStatus 时 status 前缀降级为纯 glob 匹配", () => {
+      // added|**/*.ts 在无 status 信息时，降级为 glob **/*.ts 匹配
+      expect(matchIncludes([`added|${glob}`], "src/foo.ts")).toBe(true);
+      expect(matchIncludes([`added|${glob}`], "src/foo.vue")).toBe(false);
+    });
+
+    it("无前缀 glob 不限 status，匹配所有符合的文件", () => {
+      expect(matchIncludes([glob], "src/foo.ts", "added")).toBe(true);
+      expect(matchIncludes([glob], "src/foo.ts", "modified")).toBe(true);
+      expect(matchIncludes([glob], "src/foo.ts", "removed")).toBe(true);
+    });
+
+    it("added| 前缀只匹配 added 状态文件", () => {
+      expect(matchIncludes([`added|${glob}`], "src/foo.ts", "added")).toBe(true);
+      expect(matchIncludes([`added|${glob}`], "src/foo.ts", "modified")).toBe(false);
+    });
+
+    it("modified| 前缀只匹配 modified 状态文件", () => {
+      expect(matchIncludes([`modified|${glob}`], "src/foo.ts", "modified")).toBe(true);
+      expect(matchIncludes([`modified|${glob}`], "src/foo.ts", "added")).toBe(false);
+    });
+
+    it("deleted| 前缀匹配 removed 和 deleted 状态文件", () => {
+      expect(matchIncludes([`deleted|${glob}`], "src/old.ts", "removed")).toBe(true);
+      expect(matchIncludes([`deleted|${glob}`], "src/old.ts", "deleted")).toBe(true);
+      expect(matchIncludes([`deleted|${glob}`], "src/old.ts", "modified")).toBe(false);
+    });
+
+    it("排除模式 ! 优先过滤", () => {
+      expect(matchIncludes([glob, "!**/*.spec.ts"], "src/foo.spec.ts", "added")).toBe(false);
+      expect(matchIncludes([glob, "!**/*.spec.ts"], "src/foo.ts", "added")).toBe(true);
+    });
+
+    it("多个 status 前缀之间是 OR 关系", () => {
+      expect(matchIncludes([`added|${glob}`, `modified|${glob}`], "src/foo.ts", "added")).toBe(
+        true,
+      );
+      expect(matchIncludes([`added|${glob}`, `modified|${glob}`], "src/foo.ts", "modified")).toBe(
+        true,
+      );
+    });
+
+    it("无前缀 glob 与 status 前缀混用时任一命中即保留", () => {
+      expect(matchIncludes([glob, "added|**/*.vue"], "src/foo.ts", "modified")).toBe(true);
+      expect(matchIncludes([glob, "added|**/*.vue"], "src/foo.vue", "added")).toBe(true);
+      expect(matchIncludes([glob, "added|**/*.vue"], "src/foo.vue", "modified")).toBe(false);
+    });
+
+    it("status 内排除语法 added|!**/*.spec.ts", () => {
+      expect(matchIncludes([`added|${glob}`, "added|!**/*.spec.ts"], "src/foo.ts", "added")).toBe(
+        true,
+      );
+      expect(
+        matchIncludes([`added|${glob}`, "added|!**/*.spec.ts"], "src/foo.spec.ts", "added"),
+      ).toBe(false);
+    });
+
+    it("fileStatus 为 undefined 时走降级路径（纯 glob 匹配）", () => {
+      // matchIncludes 中 undefined 表示无 status 信息，降级为纯 glob 匹配
+      // 这与 filterFilesByIncludes 中 status=undefined fallback 为 modified 不同
+      // 因为 matchIncludes 用于 spec includes 场景，无 status 时应宽松匹配
+      expect(matchIncludes([`modified|${glob}`], "src/foo.ts")).toBe(true);
+      expect(matchIncludes([`added|${glob}`], "src/foo.ts")).toBe(true);
+    });
+  });
 });

package/src/review-includes-filter.ts

@@ -180,6 +180,86 @@ export function extractGlobsFromIncludes(includes: string[]): string[] {
   return includes.map((p) => parseIncludePattern(p).glob).filter((g) => g.length > 0);
 }
 
+/**
+ * 检查单个文件是否匹配 includes 模式列表，支持 `status|glob` 前缀语法。
+ *
+ * - 当 `fileStatus` 未提供时，status 前缀的 includes 降级为纯 glob 匹配（向后兼容）
+ * - 当 `fileStatus` 提供时，完整支持 `added|`/`modified|`/`deleted|` 前缀语义
+ *
+ * 算法与 `filterFilesByIncludes` 一致，但针对单文件场景优化：
+ * 1. 排除模式(`!`) 优先过滤
+ * 2. 无前缀正向 glob 匹配
+ * 3. 有 status 前缀的 glob 按文件实际 status 过滤
+ *
+ * @param includes    include 模式列表
+ * @param filename    待匹配的文件名
+ * @param fileStatus  文件变更状态（如 "added"/"modified"/"removed"），不提供时降级为纯 glob
+ * @returns           是否匹配
+ */
+export function matchIncludes(includes: string[], filename: string, fileStatus?: string): boolean {
+  if (!includes || includes.length === 0) return true;
+  if (!filename) return false;
+
+  const parsed = includes.map(parseIncludePattern);
+
+  // 无 status 信息时降级为纯 glob 匹配（向后兼容）
+  if (!fileStatus) {
+    const globs = extractGlobsFromIncludes(includes);
+    if (globs.length === 0) return true;
+    return micromatch.isMatch(filename, globs, { matchBase: true });
+  }
+
+  const normalizedStatus = STATUS_ALIAS[fileStatus.toLowerCase()] ?? "modified";
+
+  // 排除模式（以 ! 开头），用于最终全局过滤
+  const negativeGlobs = parsed
+    .filter((p) => p.status === undefined && p.glob.startsWith("!"))
+    .map((p) => p.glob.slice(1));
+  // 无前缀的正向 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);
+
+  // 最终排除：命中排除模式的文件直接过滤掉
+  if (
+    negativeGlobs.length > 0 &&
+    micromatch.isMatch(filename, negativeGlobs, { matchBase: true })
+  ) {
+    return false;
+  }
+
+  // 正向匹配：无前缀 glob
+  if (plainGlobs.length > 0 && micromatch.isMatch(filename, plainGlobs, { matchBase: true })) {
+    return true;
+  }
+
+  // 正向匹配：有 status 前缀的 glob，按文件实际 status 过滤
+  if (statusPatterns.length > 0) {
+    const matchingStatusGlobs = statusPatterns
+      .filter(({ status }) => status === normalizedStatus)
+      .map(({ glob }) => glob);
+    if (matchingStatusGlobs.length > 0) {
+      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) {
+          return true;
+        }
+      }
+    }
+  }
+
+  return false;
+}
+
 /**
  * 从 whenModifiedCode 配置中解析代码结构过滤类型。
  * 只接受简单的类型名称，如 "function"、"class"、"interface"、"type"、"method"

package/src/review-llm.ts

@@ -19,11 +19,10 @@ import {
 } from "./review-spec";
 import { readdir } from "fs/promises";
 import { dirname, extname } from "path";
-import micromatch from "micromatch";
 import type { FileReviewPrompt, ReviewPrompt, LLMReviewOptions } from "./types/review-llm";
 import { buildLinesWithNumbers, buildCommitsSection, extractCodeBlocks } from "./utils/review-llm";
 import { ChangedFileCollection } from "./changed-file-collection";
-import { extractCodeBlockTypes, extractGlobsFromIncludes } from "./review-includes-filter";
+import { matchIncludes, extractCodeBlockTypes } from "./review-includes-filter";
 import {
   REVIEW_SCHEMA,
   buildFileReviewPrompt,
@@ -63,8 +62,9 @@ export class ReviewLlmProcessor {
    * 根据文件过滤 specs，只返回与该文件匹配的规则
    * - 如果 spec 有 includes 配置，只有当文件名匹配 includes 模式时才包含该 spec
    * - 如果 spec 没有 includes 配置，则按扩展名匹配
+   * - 支持 `added|`/`modified|`/`deleted|` 前缀语法，需传入 fileStatus
    */
-  filterSpecsForFile(specs: ReviewSpec[], filename: string): ReviewSpec[] {
+  filterSpecsForFile(specs: ReviewSpec[], filename: string, fileStatus?: string): ReviewSpec[] {
     const ext = extname(filename).slice(1).toLowerCase();
     if (!ext) return [];
 
@@ -75,11 +75,9 @@ export class ReviewLlmProcessor {
       }
 
       // 如果有 includes 配置，检查文件名是否匹配 includes 模式
-      // 需先提取纯 glob（去掉 added|/modified| 前缀，过滤 code-* 空串），避免 micromatch 报错
+      // 使用 matchIncludes 支持 status|glob 前缀语法
       if (spec.includes.length > 0) {
-        const globs = extractGlobsFromIncludes(spec.includes);
-        if (globs.length === 0) return true;
-        return micromatch.isMatch(filename, globs, { matchBase: true });
+        return matchIncludes(spec.includes, filename, fileStatus);
       }
 
       // 没有 includes 配置，扩展名匹配即可
@@ -124,7 +122,7 @@ export class ReviewLlmProcessor {
           const fileDirectoryInfo = await this.getFileDirectoryInfo(filename);
 
           // 根据文件过滤 specs，只注入与当前文件匹配的规则
-          const fileSpecs = this.filterSpecsForFile(specs, filename);
+          const fileSpecs = this.filterSpecsForFile(specs, filename, file.status);
 
           // 从全局 whenModifiedCode 配置中解析代码结构过滤类型
           const codeBlockTypes = whenModifiedCode ? extractCodeBlockTypes(whenModifiedCode) : [];

package/src/review-spec/review-spec.service.spec.ts

@@ -35,7 +35,7 @@ describe("ReviewSpecService", () => {
 - 排除配置文件
 - 排除测试文件
 
-### Good
+#### Good: 合理的常量命名
 \`\`\`js
 const MAX_COUNT = 100;
 \`\`\``;
@@ -59,10 +59,13 @@ const MAX_COUNT = 100;
       expect(specs[0].rules[1].description).toContain("排除配置文件");
       expect(specs[0].rules[1].description).toContain("排除测试文件");
       expect(specs[0].rules[1].examples).toHaveLength(1);
-      expect(specs[0].rules[1].examples[0]).toEqual({
-        lang: "js",
-        code: "const MAX_COUNT = 100;",
+      expect(specs[0].rules[1].examples[0].title).toBe("");
+      expect(specs[0].rules[1].examples[0].description).toBe("");
+      expect(specs[0].rules[1].examples[0].content).toHaveLength(1);
+      expect(specs[0].rules[1].examples[0].content[0]).toEqual({
+        title: "合理的常量命名",
         type: "good",
+        description: "const MAX_COUNT = 100;",
       });
 
       expect(specs[1].filename).toBe("vue.file-name.md");
@@ -309,7 +312,7 @@ const MAX_COUNT = 100;
 
 > - severity \`warn\`
 
-### Good
+#### Good: 合理的常量命名
 \`\`\`js
 const MAX_COUNT = 100;
 \`\`\``;
@@ -566,6 +569,92 @@ const MAX_COUNT = 100;
 
       expect(result).toHaveLength(2);
     });
+
+    it("should filter issues by spec includes with added| prefix when fileStatusMap provided", () => {
+      const specs = [
+        {
+          filename: "js.models.md",
+          extensions: ["js"],
+          type: "models",
+          content: "",
+          overrides: [],
+          severity: "error" as const,
+          includes: ["added|*.model.js"],
+          rules: [
+            { id: "Js.Models", title: "Models", description: "", examples: [], overrides: [] },
+          ],
+        },
+      ];
+
+      const issues = [
+        { file: "user/models/user.model.js", ruleId: "Js.Models.Rule1", reason: "test" },
+        { file: "user/models/product.model.js", ruleId: "Js.Models.Rule2", reason: "test" },
+      ];
+
+      // added 文件保留，modified 文件被 added| 前缀过滤
+      const changedFiles = ChangedFileCollection.from([
+        { filename: "user/models/user.model.js", status: "added" },
+        { filename: "user/models/product.model.js", status: "modified" },
+      ]);
+      const result = service.filterIssuesByIncludes(issues, specs, changedFiles);
+      expect(result).toHaveLength(1);
+      expect(result[0].file).toBe("user/models/user.model.js");
+    });
+
+    it("should fall back to pure glob matching when fileStatusMap not provided", () => {
+      const specs = [
+        {
+          filename: "js.models.md",
+          extensions: ["js"],
+          type: "models",
+          content: "",
+          overrides: [],
+          severity: "error" as const,
+          includes: ["added|*.model.js"],
+          rules: [
+            { id: "Js.Models", title: "Models", description: "", examples: [], overrides: [] },
+          ],
+        },
+      ];
+
+      const issues = [
+        { file: "user/models/user.model.js", ruleId: "Js.Models.Rule1", reason: "test" },
+        { file: "src/app.js", ruleId: "Js.Models.Rule2", reason: "test" },
+      ];
+
+      // 无 status map 时，added| 前缀降级为纯 glob 匹配
+      const result = service.filterIssuesByIncludes(issues, specs);
+      expect(result).toHaveLength(1);
+      expect(result[0].file).toBe("user/models/user.model.js");
+    });
+
+    it("should filter issues by spec includes with modified| prefix", () => {
+      const specs = [
+        {
+          filename: "js.nest.md",
+          extensions: ["ts"],
+          type: "nest",
+          content: "",
+          overrides: [],
+          severity: "error" as const,
+          includes: ["modified|*.controller.ts"],
+          rules: [{ id: "JsTs.Nest", title: "Nest", description: "", examples: [], overrides: [] }],
+        },
+      ];
+
+      const issues = [
+        { file: "user.controller.ts", ruleId: "JsTs.Nest.Rule1", reason: "test" },
+        { file: "app.controller.ts", ruleId: "JsTs.Nest.Rule2", reason: "test" },
+      ];
+
+      const changedFiles = ChangedFileCollection.from([
+        { filename: "user.controller.ts", status: "modified" },
+        { filename: "app.controller.ts", status: "added" },
+      ]);
+      const result = service.filterIssuesByIncludes(issues, specs, changedFiles);
+      expect(result).toHaveLength(1);
+      expect(result[0].file).toBe("user.controller.ts");
+    });
   });
 
   describe("matchRuleId", () => {
@@ -714,7 +803,13 @@ const MAX_COUNT = 100;
               id: "JsTs.Base.Rule1",
               title: "Rule1",
               description: "rule desc",
-              examples: [{ lang: "ts", code: "const x = 1;", type: "good" as const }],
+              examples: [
+                {
+                  title: "",
+                  description: "",
+                  content: [{ title: "", type: "good" as const, description: "const x = 1;" }],
+                },
+              ],
               overrides: [],
             },
           ],
@@ -723,7 +818,7 @@ const MAX_COUNT = 100;
       const result = service.buildSpecsSection(specs);
       expect(result).toContain("基础规范");
       expect(result).toContain("Rule1");
-      expect(result).toContain("推荐做法");
+      expect(result).toContain("good");
     });
 
     it("should handle rules without examples", () => {
@@ -1163,7 +1258,7 @@ const MAX_COUNT = 100;
       ];
       const issues = [{ ruleId: "JsTs.FileName", file: "src/app.ts", line: "10" }];
       const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-      const result = service.filterIssuesByOverrides(issues, specs, 1);
+      const result = service.filterIssuesByOverrides(issues, specs, undefined, 1);
       expect(result).toHaveLength(0);
       expect(consoleSpy).toHaveBeenCalled();
       consoleSpy.mockRestore();
@@ -1192,7 +1287,7 @@ const MAX_COUNT = 100;
       ];
       const issues = [{ ruleId: "Other.Rule", file: "src/app.ts" }];
       const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-      service.filterIssuesByOverrides(issues, specs, 3);
+      service.filterIssuesByOverrides(issues, specs, undefined, 3);
       expect(consoleSpy).toHaveBeenCalled();
       consoleSpy.mockRestore();
     });
@@ -1558,14 +1653,16 @@ const MAX_COUNT = 100;
 
   describe("extractExamples - bad type", () => {
     it("should extract bad examples", () => {
-      const content = `### Bad
+      const content = `#### Bad: 不合理的命名
 
 \`\`\`ts
 const bad_name = 1;
 \`\`\``;
       const examples = (service as any).extractExamples(content);
       expect(examples).toHaveLength(1);
-      expect(examples[0].type).toBe("bad");
+      expect(examples[0].content).toHaveLength(1);
+      expect(examples[0].content[0].type).toBe("bad");
+      expect(examples[0].content[0].title).toBe("不合理的命名");
     });
   });
 
@@ -1617,4 +1714,125 @@ const bad_name = 1;
       expect(result[0].file).toBe("user.controller.ts");
     });
   });
+
+  describe("extractExamples - #### level with colon", () => {
+    it("should extract examples from #### Good: / #### Bad: format without group", () => {
+      const content = `#### Good: 合理的常量命名
+
+\`\`\`javascript
+const MAX_COUNT = 100;
+\`\`\`
+
+#### Bad: 不合理的常量命名
+
+\`\`\`javascript
+const maxCount = 100;
+\`\`\``;
+      const examples = (service as any).extractExamples(content);
+      expect(examples).toHaveLength(1);
+      expect(examples[0].title).toBe("");
+      expect(examples[0].description).toBe("");
+      expect(examples[0].content).toHaveLength(2);
+      expect(examples[0].content[0]).toEqual({
+        title: "合理的常量命名",
+        type: "good",
+        description: "const MAX_COUNT = 100;",
+      });
+      expect(examples[0].content[1]).toEqual({
+        title: "不合理的常量命名",
+        type: "bad",
+        description: "const maxCount = 100;",
+      });
+    });
+
+    it("should parse full rule with #### examples", () => {
+      const mockContent = `# 基础代码规范 \`[JsTs.Base]\`
+
+## 常量名使用大写加下划线命名 \`[JsTs.Base.ConstUpperCase]\`
+
+- 不检查 nodejs 的导包定义
+- 常量检查只需检查 const 声明的静态值
+
+#### Good: 合理的常量命名
+
+\`\`\`javascript
+const MAX_COUNT = 100;
+\`\`\`
+
+#### Bad: 不合理的常量命名
+
+\`\`\`javascript
+const maxCount = 100;
+\`\`\``;
+
+      const spec = service.parseSpecFile("js&ts.base.md", mockContent);
+      expect(spec).not.toBeNull();
+      expect(spec!.rules).toHaveLength(2);
+      expect(spec!.rules[1].id).toBe("JsTs.Base.ConstUpperCase");
+      expect(spec!.rules[1].description).toContain("不检查 nodejs");
+      expect(spec!.rules[1].description).not.toContain("Good");
+      expect(spec!.rules[1].examples).toHaveLength(1);
+      expect(spec!.rules[1].examples[0].content).toHaveLength(2);
+      expect(spec!.rules[1].examples[0].content[0].type).toBe("good");
+      expect(spec!.rules[1].examples[0].content[1].type).toBe("bad");
+    });
+
+    it("should parse multiple example groups with ### Example:", () => {
+      const mockContent = `# 基础代码规范 \`[JsTs.Base]\`
+
+## 常量名使用大写加下划线命名 \`[JsTs.Base.ConstUpperCase]\`
+
+- 不检查 nodejs 的导包定义
+- 常量检查只需检查 const 声明的静态值
+
+### Example: 下面的明明规则说明
+
+#### Good: 合理的常量命名
+
+\`\`\`javascript
+const MAX_COUNT = 100;
+\`\`\`
+
+#### Bad: 不合理的常量命名
+
+\`\`\`javascript
+const maxCount = 100;
+\`\`\`
+
+### Example: 另一种场景
+
+#### Good: 枚举值命名
+
+\`\`\`javascript
+const STATUS_ACTIVE = "active";
+\`\`\`
+
+#### Bad: 枚举值小驼峰
+
+\`\`\`javascript
+const statusActive = "active";
+\`\`\``;
+
+      const spec = service.parseSpecFile("js&ts.base.md", mockContent);
+      expect(spec).not.toBeNull();
+      expect(spec!.rules[1].id).toBe("JsTs.Base.ConstUpperCase");
+      expect(spec!.rules[1].description).toContain("不检查 nodejs");
+      expect(spec!.rules[1].description).not.toContain("Example");
+      expect(spec!.rules[1].examples).toHaveLength(2);
+
+      // 第一组
+      expect(spec!.rules[1].examples[0].title).toBe("Example");
+      expect(spec!.rules[1].examples[0].description).toBe("下面的明明规则说明");
+      expect(spec!.rules[1].examples[0].content).toHaveLength(2);
+      expect(spec!.rules[1].examples[0].content[0].type).toBe("good");
+      expect(spec!.rules[1].examples[0].content[1].type).toBe("bad");
+
+      // 第二组
+      expect(spec!.rules[1].examples[1].title).toBe("Example");
+      expect(spec!.rules[1].examples[1].description).toBe("另一种场景");
+      expect(spec!.rules[1].examples[1].content).toHaveLength(2);
+      expect(spec!.rules[1].examples[1].content[0].type).toBe("good");
+      expect(spec!.rules[1].examples[1].content[1].type).toBe("bad");
+    });
+  });
 });