@spaceflow/review 0.46.0 → 0.47.0

package/.spaceflow/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "spaceflow",
+  "private": true,
+  "type": "module",
+  "dependencies": {
+    "@spaceflow/core": "workspace:*"
+  }
+}

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [0.46.0](https://github.com/Lydanne/spaceflow/compare/@spaceflow/review@0.45.0...@spaceflow/review@0.46.0) (2026-02-27)
+
+### 新特性
+
+* **cli:** 实现 MCP meta-tool 代理模式 ([86426e9](https://github.com/Lydanne/spaceflow/commit/86426e979ea989a3688721f33e17035d7c96c984))
+
+### 其他修改
+
+* **cli:** released version 0.36.0 [no ci] ([e48738a](https://github.com/Lydanne/spaceflow/commit/e48738a3d56a0fc8f5e48f2bbfffd2ca90041376))
+* **core:** released version 0.14.0 [no ci] ([67f47ac](https://github.com/Lydanne/spaceflow/commit/67f47ac3a894529f174f3136925707d24570df98))
+* **publish:** released version 0.38.0 [no ci] ([2a3adf7](https://github.com/Lydanne/spaceflow/commit/2a3adf75af6a44a890b198609bed1090f6d3be6d))
+* **review-summary:** released version 0.15.0 [no ci] ([626b7dd](https://github.com/Lydanne/spaceflow/commit/626b7dd5b73c62d5f5c48f7dc585f60eb775dad0))
+* **scripts:** released version 0.15.0 [no ci] ([bf9e533](https://github.com/Lydanne/spaceflow/commit/bf9e53349884b3bd4ca845f493d28421a5ffc91d))
+* **shared:** released version 0.5.0 [no ci] ([c936cfc](https://github.com/Lydanne/spaceflow/commit/c936cfc432a517e87639e99870a11729b4c91ae4))
+* **shell:** released version 0.15.0 [no ci] ([0dc9b31](https://github.com/Lydanne/spaceflow/commit/0dc9b31f4d73ac359e2efa7f07e1e5778f9e85c2))
+
 ## [0.45.0](https://github.com/Lydanne/spaceflow/compare/@spaceflow/review@0.44.0...@spaceflow/review@0.45.0) (2026-02-27)
 
 ### 新特性

package/dist/index.js

@@ -4915,17 +4915,13 @@ ${deletedCodeSection}
 
 
 
-/** MCP 工具输入 schema */ const listRulesInputSchema = z.object({
-    cwd: z.string().optional().describe(t("review:mcp.dto.cwd"))
-});
+/** MCP 工具输入 schema */ const listRulesInputSchema = z.object({});
 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"))
 });
 const getRuleDetailInputSchema = z.object({
-    ruleId: z.string().describe(t("review:mcp.dto.ruleId")),
-    cwd: z.string().optional().describe(t("review:mcp.dto.cwd"))
+    ruleId: z.string().describe(t("review:mcp.dto.ruleId"))
 });
 /**
  * 获取 GitProviderService（可选）
@@ -4978,117 +4974,109 @@ const getRuleDetailInputSchema = z.object({
     }
     return specService.deduplicateSpecs(allSpecs);
 }
-/**
- * Review MCP 服务器定义
- */ const reviewMcpServer = {
-    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;
-                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;
-                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 __webpack_require__.e(/* import() */ "551").then(__webpack_require__.bind(__webpack_require__, 946));
-                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;
-                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 tools = [
+    {
+        name: "list_rules",
+        description: t("review:mcp.listRules"),
+        inputSchema: listRulesInputSchema,
+        handler: async (_input, ctx)=>{
+            const workDir = ctx.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, includeExamples } = input;
+            const workDir = ctx.cwd;
+            const allSpecs = await loadAllSpecs(workDir, ctx);
+            const specService = new ReviewSpecService();
+            const applicableSpecs = specService.filterApplicableSpecs(allSpecs, [
+                {
+                    filename: filePath
                 }
-                const { rule, spec } = result;
+            ]);
+            const micromatchModule = await __webpack_require__.e(/* import() */ "551").then(__webpack_require__.bind(__webpack_require__, 946));
+            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 } = input;
+            const workDir = ctx.cwd;
+            const specs = await loadAllSpecs(workDir, ctx);
+            const specService = new ReviewSpecService();
+            const result = specService.findRuleById(ruleId, specs);
+            if (!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
-                        }))
+                    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
+                    }))
+            };
         }
-    ]
-};
+    }
+];
 
 ;// CONCATENATED MODULE: ./src/index.ts
 
@@ -5107,7 +5095,7 @@ const extension = defineExtension({
     description: t("review:extensionDescription"),
     configKey: "review",
     configSchema: reviewSchema,
-    mcp: reviewMcpServer,
+    tools: tools,
     commands: [
         {
             name: "review",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spaceflow/review",
-  "version": "0.46.0",
+  "version": "0.47.0",
   "description": "Spaceflow 代码审查插件，使用 LLM 对 PR 代码进行自动审查",
   "license": "MIT",
   "author": "Lydanne",
@@ -25,10 +25,10 @@
     "@vitest/coverage-v8": "^4.0.18",
     "unplugin-swc": "^1.5.9",
     "vitest": "^4.0.18",
-    "@spaceflow/cli": "0.36.0"
+    "@spaceflow/cli": "0.37.0"
   },
   "peerDependencies": {
-    "@spaceflow/core": "0.14.0"
+    "@spaceflow/core": "0.15.0"
   },
   "spaceflow": {
     "type": "flow",

package/src/index.ts

@@ -8,7 +8,7 @@ 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";
+import { tools } from "./mcp";
 
 export const extension = defineExtension({
   name: "review",
@@ -16,7 +16,7 @@ export const extension = defineExtension({
   description: t("review:extensionDescription"),
   configKey: "review",
   configSchema: reviewSchema,
-  mcp: reviewMcpServer,
+  tools,
   commands: [
     {
       name: "review",

package/src/mcp/index.ts

@@ -1,29 +1,19 @@
-import {
-  t,
-  z,
-  type McpServerDefinition,
-  type SpaceflowContext,
-  type GitProviderService,
-} from "@spaceflow/core";
+import { t, z, 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 listRulesInputSchema = z.object({});
 
 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")),
 });
 
 /**
@@ -81,111 +71,98 @@ async function loadAllSpecs(cwd: string, ctx: SpaceflowContext) {
   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 {
+export const tools = [
+  {
+    name: "list_rules",
+    description: t("review:mcp.listRules"),
+    inputSchema: listRulesInputSchema,
+    handler: async (_input, ctx) => {
+      const workDir = ctx.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,
+          description:
+            rule.description.slice(0, 200) + (rule.description.length > 200 ? "..." : ""),
           severity: rule.severity || spec.severity,
-          specFile: spec.filename,
           extensions: spec.extensions,
+          specFile: spec.filename,
           includes: spec.includes,
-          overrides: rule.overrides,
-          examples: rule.examples.map((ex) => ({
-            type: ex.type,
-            lang: ex.lang,
-            code: ex.code,
+          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, includeExamples } = input as z.infer<typeof getRulesForFileInputSchema>;
+      const workDir = ctx.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 } = input as z.infer<typeof getRuleDetailInputSchema>;
+      const workDir = ctx.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,
+        })),
+      };
     },
-  ],
-};
+  },
+];