@spaceflow/review 0.29.3 → 0.31.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spaceflow/review",
-  "version": "0.29.3",
+  "version": "0.31.0",
   "description": "Spaceflow 代码审查插件，使用 LLM 对 PR 代码进行自动审查",
   "license": "MIT",
   "author": "Lydanne",
@@ -18,7 +18,6 @@
     "micromatch": "^4.0.8"
   },
   "devDependencies": {
-    "@nestjs/testing": "^11.0.1",
     "@swc/core": "1.15.3",
     "@types/micromatch": "^4.0.9",
     "@types/node": "^22.15.0",
@@ -26,16 +25,10 @@
     "@vitest/coverage-v8": "^4.0.18",
     "unplugin-swc": "^1.5.9",
     "vitest": "^4.0.18",
-    "@spaceflow/cli": "0.19.4"
+    "@spaceflow/cli": "0.21.0"
   },
   "peerDependencies": {
-    "@nestjs/common": "^11.0.1",
-    "@nestjs/config": "^4.0.2",
-    "@nestjs/swagger": "^11.2.6",
-    "class-transformer": "^0.5.1",
-    "class-validator": "^0.14.3",
-    "nest-commander": "^3.20.1",
-    "@spaceflow/core": "0.1.3"
+    "@spaceflow/core": "0.3.0"
   },
   "spaceflow": {
     "type": "flow",

package/src/deletion-impact.service.spec.ts

@@ -1,6 +1,4 @@
-import { vi, type Mocked, type Mock } from "vitest";
-import { Test, TestingModule } from "@nestjs/testing";
-import { LlmProxyService, GitProviderService } from "@spaceflow/core";
+import { vi, type Mock } from "vitest";
 import { DeletionImpactService } from "./deletion-impact.service";
 import * as child_process from "child_process";
 import { EventEmitter } from "events";
@@ -13,30 +11,21 @@ vi.mock("child_process");
 
 describe("DeletionImpactService", () => {
   let service: DeletionImpactService;
-  let llmProxyService: Mocked<LlmProxyService>;
-  let gitProvider: Mocked<GitProviderService>;
+  let llmProxyService: any;
+  let gitProvider: any;
 
-  beforeEach(async () => {
-    const mockLlmProxyService = {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    llmProxyService = {
       chatStream: vi.fn(),
     };
 
-    const mockGitProvider = {
+    gitProvider = {
       getPullRequestFiles: vi.fn(),
       getPullRequestDiff: vi.fn(),
     };
 
-    const module: TestingModule = await Test.createTestingModule({
-      providers: [
-        DeletionImpactService,
-        { provide: LlmProxyService, useValue: mockLlmProxyService },
-        { provide: GitProviderService, useValue: mockGitProvider },
-      ],
-    }).compile();
-
-    service = module.get<DeletionImpactService>(DeletionImpactService);
-    llmProxyService = module.get(LlmProxyService) as Mocked<LlmProxyService>;
-    gitProvider = module.get(GitProviderService) as Mocked<GitProviderService>;
+    service = new DeletionImpactService(llmProxyService as any, gitProvider as any);
   });
 
   describe("analyzeDeletionImpact", () => {

package/src/deletion-impact.service.ts

@@ -1,5 +1,4 @@
 import {
-  Injectable,
   LlmProxyService,
   logStreamEvent,
   createStreamLoggerState,
@@ -73,7 +72,6 @@ export interface DeletionAnalysisContext {
   includes?: string[];
 }
 
-@Injectable()
 export class DeletionImpactService {
   constructor(
     protected readonly llmProxyService: LlmProxyService,

package/src/index.ts

@@ -1,32 +1,131 @@
 import "./locales";
-import { SpaceflowExtension, SpaceflowExtensionMetadata, t } from "@spaceflow/core";
-import { ReviewModule } from "./review.module";
-import { reviewSchema } from "./review.config";
-/** review Extension 元数据 */
-export const reviewMetadata: SpaceflowExtensionMetadata = {
+import { defineExtension, t } from "@spaceflow/core";
+import type {
+  GitProviderService,
+  ConfigReaderService,
+  LlmProxyService,
+  GitSdkService,
+  LLMMode,
+} from "@spaceflow/core";
+import { parseVerbose } from "@spaceflow/core";
+import { reviewSchema, type AnalyzeDeletionsMode } from "./review.config";
+import { ReviewService } from "./review.service";
+import { ReviewSpecService } from "./review-spec";
+import { ReviewReportService, type ReportFormat } from "./review-report";
+import { IssueVerifyService } from "./issue-verify.service";
+import { DeletionImpactService } from "./deletion-impact.service";
+import { reviewMcpServer } from "./mcp";
+
+export const extension = defineExtension({
   name: "review",
-  commands: ["review"],
-  configKey: "review",
-  configSchema: reviewSchema,
   version: "1.0.0",
   description: t("review:extensionDescription"),
-};
+  configKey: "review",
+  configSchema: reviewSchema,
+  mcp: reviewMcpServer,
+  commands: [
+    {
+      name: "review",
+      description: t("review:description"),
+      options: [
+        { flags: "-d, --dry-run", description: t("review:options.dryRun") },
+        { flags: "-c, --ci", description: t("common.options.ci") },
+        { flags: "-p, --pr-number <number>", description: t("review:options.prNumber") },
+        { flags: "-b, --base <ref>", description: t("review:options.base") },
+        { flags: "--head <ref>", description: t("review:options.head") },
+        { flags: "-i, --includes <patterns...>", description: t("review:options.includes") },
+        { flags: "-l, --llm-mode <mode>", description: t("review:options.llmMode") },
+        { flags: "-f, --files <files...>", description: t("review:options.files") },
+        { flags: "--commits <commits...>", description: t("review:options.commits") },
+        { flags: "--verify-fixes", description: t("review:options.verifyFixes") },
+        { flags: "--no-verify-fixes", description: t("review:options.noVerifyFixes") },
+        { flags: "--analyze-deletions [mode]", description: t("review:options.analyzeDeletions") },
+        {
+          flags: "--deletion-analysis-mode <mode>",
+          description: t("review:options.deletionAnalysisMode"),
+        },
+        { flags: "--deletion-only", description: t("review:options.deletionOnly") },
+        { flags: "-o, --output-format <format>", description: t("review:options.outputFormat") },
+        { flags: "--generate-description", description: t("review:options.generateDescription") },
+        { flags: "--show-all", description: t("review:options.showAll") },
+        { flags: "--flush", description: t("review:options.flush") },
+        { flags: "--event-action <action>", description: t("review:options.eventAction") },
+      ],
+      run: async (_args, options, ctx) => {
+        const isFlush = !!options?.flush;
+        if (!ctx.hasService("gitProvider")) {
+          ctx.output.error(
+            "review 命令需要配置 Git Provider，请在 spaceflow.json 中配置 gitProvider 字段",
+          );
+          process.exit(1);
+        }
+        if (!isFlush && !ctx.hasService("llmProxy")) {
+          ctx.output.error("review 命令需要配置 LLM 服务，请在 spaceflow.json 中配置 llm 字段");
+          process.exit(1);
+        }
+
+        const gitProvider = ctx.getService<GitProviderService>("gitProvider");
+        const configReader = ctx.getService<ConfigReaderService>("config");
+        const llmProxy = ctx.hasService("llmProxy")
+          ? ctx.getService<LlmProxyService>("llmProxy")
+          : (undefined as unknown as LlmProxyService);
+        const gitSdk = ctx.hasService("gitSdk")
+          ? ctx.getService<GitSdkService>("gitSdk")
+          : undefined;
+
+        const reviewSpecService = new ReviewSpecService(gitProvider);
+        const reviewReportService = new ReviewReportService();
+        const issueVerifyService = new IssueVerifyService(llmProxy, reviewSpecService);
+        const deletionImpactService = new DeletionImpactService(llmProxy, gitProvider);
 
-export class ReviewExtension implements SpaceflowExtension {
-  getMetadata(): SpaceflowExtensionMetadata {
-    return reviewMetadata;
-  }
+        const reviewService = new ReviewService(
+          gitProvider,
+          ctx.config,
+          configReader,
+          reviewSpecService,
+          llmProxy,
+          reviewReportService,
+          issueVerifyService,
+          deletionImpactService,
+          gitSdk!,
+        );
 
-  getModule() {
-    return ReviewModule;
-  }
-}
+        const reviewOptions = {
+          dryRun: !!options?.dryRun,
+          ci: !!options?.ci,
+          prNumber: options?.prNumber ? parseInt(options.prNumber as string, 10) : undefined,
+          base: options?.base as string,
+          head: options?.head as string,
+          verbose: parseVerbose(options?.verbose as string | boolean | undefined),
+          includes: options?.includes as string[],
+          llmMode: options?.llmMode as LLMMode,
+          files: options?.files as string[],
+          commits: options?.commits as string[],
+          verifyFixes: options?.verifyFixes as boolean,
+          analyzeDeletions: options?.analyzeDeletions as AnalyzeDeletionsMode,
+          deletionAnalysisMode: options?.deletionAnalysisMode as LLMMode,
+          deletionOnly: !!options?.deletionOnly,
+          outputFormat: options?.outputFormat as ReportFormat,
+          generateDescription: !!options?.generateDescription,
+          showAll: !!options?.showAll,
+          flush: isFlush,
+          eventAction: options?.eventAction as string,
+        };
 
-export default ReviewExtension;
+        try {
+          const context = await reviewService.getContextFromEnv(reviewOptions);
+          await reviewService.execute(context);
+        } catch (error) {
+          if (error instanceof Error) {
+            ctx.output.error(t("common.executionFailed", { error: error.message }));
+          } else {
+            ctx.output.error(t("common.executionFailed", { error: String(error) }));
+          }
+          process.exit(1);
+        }
+      },
+    },
+  ],
+});
 
-export * from "./review.module";
-export * from "./review.command";
-export * from "./review.service";
-export * from "./review.mcp";
-export * from "./issue-verify.service";
-export * from "./deletion-impact.service";
+export default extension;

package/src/issue-verify.service.spec.ts

@@ -1,7 +1,5 @@
-import { vi, type Mocked } from "vitest";
-import { Test, TestingModule } from "@nestjs/testing";
-import { LlmProxyService } from "@spaceflow/core";
-import { ReviewIssue, FileContentsMap, ReviewSpecService } from "./review-spec";
+import { vi } from "vitest";
+import { ReviewIssue, FileContentsMap } from "./review-spec";
 import { IssueVerifyService } from "./issue-verify.service";
 
 vi.mock("@anthropic-ai/claude-agent-sdk", () => ({
@@ -10,10 +8,11 @@ vi.mock("@anthropic-ai/claude-agent-sdk", () => ({
 
 describe("IssueVerifyService", () => {
   let service: IssueVerifyService;
-  let llmProxyService: Mocked<LlmProxyService>;
+  let llmProxyService: any;
 
-  beforeEach(async () => {
-    const mockLlmProxyService = {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    llmProxyService = {
       chatStream: vi.fn(),
     };
 
@@ -22,22 +21,7 @@ describe("IssueVerifyService", () => {
       buildSpecsSection: vi.fn().mockReturnValue("mock rule specs"),
     };
 
-    const module: TestingModule = await Test.createTestingModule({
-      providers: [
-        IssueVerifyService,
-        {
-          provide: LlmProxyService,
-          useValue: mockLlmProxyService,
-        },
-        {
-          provide: ReviewSpecService,
-          useValue: mockReviewSpecService,
-        },
-      ],
-    }).compile();
-
-    service = module.get<IssueVerifyService>(IssueVerifyService);
-    llmProxyService = module.get(LlmProxyService) as Mocked<LlmProxyService>;
+    service = new IssueVerifyService(llmProxyService as any, mockReviewSpecService as any);
   });
 
   it("should return empty array if no issues provided", async () => {

package/src/issue-verify.service.ts

@@ -1,5 +1,4 @@
 import {
-  Injectable,
   LlmProxyService,
   type LLMMode,
   type VerboseLevel,
@@ -46,7 +45,6 @@ const VERIFY_SCHEMA: LlmJsonPutSchema = {
   additionalProperties: false,
 };
 
-@Injectable()
 export class IssueVerifyService {
   constructor(
     protected readonly llmProxyService: LlmProxyService,

package/src/locales/en/review.json

@@ -17,6 +17,7 @@
   "options.outputFormat": "Output format: markdown, terminal, json. Auto-selected if not specified (markdown for PR, terminal for CLI)",
   "options.generateDescription": "Generate PR description using AI",
   "options.showAll": "Show all issues found, including those on unchanged lines",
+  "options.flush": "Only sync status (reactions, resolved conversations, replies), skip LLM review",
   "options.eventAction": "PR event type (opened, synchronize, closed, etc.), closed only collects stats without AI review",
   "extensionDescription": "Code review command using LLM for automated PR review",
   "mcp.serverDescription": "Code review rules query service",

package/src/locales/zh-cn/review.json

@@ -17,6 +17,7 @@
   "options.outputFormat": "输出格式: markdown, terminal, json。不指定则智能选择（PR 用 markdown，终端用 terminal）",
   "options.generateDescription": "使用 AI 生成 PR 功能描述",
   "options.showAll": "显示所有发现的问题，不过滤非变更行的问题",
+  "options.flush": "仅刷新状态（同步 reactions、resolved conversations、replies），不执行 LLM 审查",
   "options.eventAction": "PR 事件类型（opened, synchronize, closed 等），closed 时仅收集统计不进行 AI 审查",
   "extensionDescription": "代码审查命令，使用 LLM 对 PR 代码进行自动审查",
   "mcp.serverDescription": "代码审查规则查询服务",

package/src/mcp/index.ts

@@ -0,0 +1,191 @@
+import {
+  t,
+  z,
+  type McpServerDefinition,
+  type SpaceflowContext,
+  type GitProviderService,
+} from "@spaceflow/core";
+import { ReviewSpecService } from "../review-spec";
+import type { ReviewConfig } from "../review.config";
+import { join } from "path";
+import { existsSync } from "fs";
+
+/** MCP 工具输入 schema */
+export const listRulesInputSchema = z.object({
+  cwd: z.string().optional().describe(t("review:mcp.dto.cwd")),
+});
+
+export const getRulesForFileInputSchema = z.object({
+  filePath: z.string().describe(t("review:mcp.dto.filePath")),
+  cwd: z.string().optional().describe(t("review:mcp.dto.cwd")),
+  includeExamples: z.boolean().optional().describe(t("review:mcp.dto.includeExamples")),
+});
+
+export const getRuleDetailInputSchema = z.object({
+  ruleId: z.string().describe(t("review:mcp.dto.ruleId")),
+  cwd: z.string().optional().describe(t("review:mcp.dto.cwd")),
+});
+
+/**
+ * 获取 GitProviderService（可选）
+ */
+function getGitProvider(ctx: SpaceflowContext): GitProviderService | undefined {
+  try {
+    return ctx.getService<GitProviderService>("gitProvider");
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * 获取项目的规则目录
+ */
+async function getSpecDirs(cwd: string, ctx: SpaceflowContext): Promise<string[]> {
+  const dirs: string[] = [];
+  try {
+    const reviewConfig = ctx.config.get<ReviewConfig>("review");
+    if (reviewConfig?.references?.length) {
+      const gitProvider = getGitProvider(ctx);
+      const specService = new ReviewSpecService(gitProvider);
+      const resolved = await specService.resolveSpecSources(reviewConfig.references);
+      dirs.push(...resolved);
+    }
+  } catch {
+    // 忽略配置读取错误
+  }
+  const defaultDirs = [
+    join(cwd, ".claude", "skills"),
+    join(cwd, ".cursor", "skills"),
+    join(cwd, "review-specs"),
+  ];
+  for (const dir of defaultDirs) {
+    if (existsSync(dir)) {
+      dirs.push(dir);
+    }
+  }
+  return [...new Set(dirs)];
+}
+
+/**
+ * 加载所有规则
+ */
+async function loadAllSpecs(cwd: string, ctx: SpaceflowContext) {
+  const gitProvider = getGitProvider(ctx);
+  const specService = new ReviewSpecService(gitProvider);
+  const specDirs = await getSpecDirs(cwd, ctx);
+  const allSpecs = [];
+  for (const dir of specDirs) {
+    const specs = await specService.loadReviewSpecs(dir);
+    allSpecs.push(...specs);
+  }
+  return specService.deduplicateSpecs(allSpecs);
+}
+
+/**
+ * Review MCP 服务器定义
+ */
+export const reviewMcpServer: McpServerDefinition = {
+  name: "review-mcp",
+  version: "1.0.0",
+  description: t("review:mcp.serverDescription"),
+  tools: [
+    {
+      name: "list_rules",
+      description: t("review:mcp.listRules"),
+      inputSchema: listRulesInputSchema,
+      handler: async (input, ctx) => {
+        const { cwd } = input as z.infer<typeof listRulesInputSchema>;
+        const workDir = cwd || process.cwd();
+        const specs = await loadAllSpecs(workDir, ctx);
+        const rules = specs.flatMap((spec) =>
+          spec.rules.map((rule) => ({
+            id: rule.id,
+            title: rule.title,
+            description:
+              rule.description.slice(0, 200) + (rule.description.length > 200 ? "..." : ""),
+            severity: rule.severity || spec.severity,
+            extensions: spec.extensions,
+            specFile: spec.filename,
+            includes: spec.includes,
+            hasExamples: rule.examples.length > 0,
+          })),
+        );
+        return { total: rules.length, rules };
+      },
+    },
+    {
+      name: "get_rules_for_file",
+      description: t("review:mcp.getRulesForFile"),
+      inputSchema: getRulesForFileInputSchema,
+      handler: async (input, ctx) => {
+        const { filePath, cwd, includeExamples } = input as z.infer<
+          typeof getRulesForFileInputSchema
+        >;
+        const workDir = cwd || process.cwd();
+        const allSpecs = await loadAllSpecs(workDir, ctx);
+        const specService = new ReviewSpecService();
+        const applicableSpecs = specService.filterApplicableSpecs(allSpecs, [
+          { 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;
+              return micromatch.isMatch(filePath, includes, { matchBase: true });
+            })
+            .map((rule) => ({
+              id: rule.id,
+              title: rule.title,
+              description: rule.description,
+              severity: rule.severity || spec.severity,
+              specFile: spec.filename,
+              ...(includeExamples && rule.examples.length > 0
+                ? {
+                    examples: rule.examples.map((ex) => ({
+                      type: ex.type,
+                      lang: ex.lang,
+                      code: ex.code,
+                    })),
+                  }
+                : {}),
+            })),
+        );
+        return { file: filePath, total: rules.length, rules };
+      },
+    },
+    {
+      name: "get_rule_detail",
+      description: t("review:mcp.getRuleDetail"),
+      inputSchema: getRuleDetailInputSchema,
+      handler: async (input, ctx) => {
+        const { ruleId, cwd } = input as z.infer<typeof getRuleDetailInputSchema>;
+        const workDir = cwd || process.cwd();
+        const specs = await loadAllSpecs(workDir, ctx);
+        const specService = new ReviewSpecService();
+        const result = specService.findRuleById(ruleId, specs);
+        if (!result) {
+          return { error: t("review:mcp.ruleNotFound", { ruleId }) };
+        }
+        const { rule, spec } = result;
+        return {
+          id: rule.id,
+          title: rule.title,
+          description: rule.description,
+          severity: rule.severity || spec.severity,
+          specFile: spec.filename,
+          extensions: spec.extensions,
+          includes: spec.includes,
+          overrides: rule.overrides,
+          examples: rule.examples.map((ex) => ({
+            type: ex.type,
+            lang: ex.lang,
+            code: ex.code,
+          })),
+        };
+      },
+    },
+  ],
+};

package/src/review-report/index.ts

@@ -1,4 +1,3 @@
 export * from "./types";
 export * from "./formatters";
 export * from "./review-report.service";
-export * from "./review-report.module";

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

@@ -1,9 +1,7 @@
-import { Injectable } from "@nestjs/common";
 import { ReviewResult, ReviewStats } from "../review-spec/types";
 import { JsonFormatter, MarkdownFormatter, TerminalFormatter } from "./formatters";
 import { ParsedReport, ReportFormat, ReportOptions, ReviewReportFormatter } from "./types";
 
-@Injectable()
 export class ReviewReportService {
   private readonly markdownFormatter = new MarkdownFormatter();
   private readonly terminalFormatter = new TerminalFormatter();

package/src/review-spec/index.ts

@@ -1,3 +1,2 @@
 export * from "./types";
 export * from "./review-spec.service";
-export * from "./review-spec.module";

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

@@ -1,7 +1,5 @@
 import { vi, type Mock } from "vitest";
-import { Test, TestingModule } from "@nestjs/testing";
 import { ReviewSpecService } from "./review-spec.service";
-import { GitProviderService } from "@spaceflow/core";
 import { readdir, readFile, mkdir, access, writeFile } from "fs/promises";
 import * as child_process from "child_process";
 
@@ -13,16 +11,13 @@ describe("ReviewSpecService", () => {
 
   let gitProvider: { listRepositoryContents: Mock; getFileContent: Mock };
 
-  beforeEach(async () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
     gitProvider = {
       listRepositoryContents: vi.fn(),
       getFileContent: vi.fn(),
     };
-    const module: TestingModule = await Test.createTestingModule({
-      providers: [ReviewSpecService, { provide: GitProviderService, useValue: gitProvider }],
-    }).compile();
-
-    service = module.get<ReviewSpecService>(ReviewSpecService);
+    service = new ReviewSpecService(gitProvider as any);
   });
 
   afterEach(() => {

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

@@ -1,5 +1,4 @@
 import {
-  Injectable,
   type ChangedFile,
   type VerboseLevel,
   shouldLog,
@@ -8,7 +7,6 @@ import {
   type RemoteRepoRef,
   type RepositoryContent,
 } from "@spaceflow/core";
-import { Optional } from "@nestjs/common";
 import { readdir, readFile, mkdir, access, writeFile } from "fs/promises";
 import { join, basename, extname } from "path";
 import { homedir } from "os";
@@ -19,9 +17,8 @@ import { ReviewSpec, ReviewRule, RuleExample, Severity } from "./types";
 /** 远程规则缓存 TTL（毫秒），默认 5 分钟 */
 const REMOTE_SPEC_CACHE_TTL = 5 * 60 * 1000;
 
-@Injectable()
 export class ReviewSpecService {
-  constructor(@Optional() protected readonly gitProvider?: GitProviderService) {}
+  constructor(protected readonly gitProvider?: GitProviderService) {}
   /**
    * 检查规则 ID 是否匹配（精确匹配或前缀匹配）
    * 例如: "JsTs.FileName" 匹配 "JsTs.FileName" 和 "JsTs.FileName.UpperCamel"