@spaceflow/core 0.8.0 → 0.9.0

package/src/commands/list/index.ts

@@ -0,0 +1,33 @@
+import { defineExtension, type VerboseLevel } from "@spaceflow/core";
+import { ListService } from "./list.service";
+import type { ExtensionLoader } from "../../cli-runtime/extension-loader";
+
+/**
+ * List 命令扩展
+ */
+export const listExtension = defineExtension({
+  name: "list",
+  version: "1.0.0",
+  description: "列出已安装的 Extension",
+  commands: [
+    {
+      name: "list",
+      description: "列出已安装的 Extension",
+      aliases: ["ls"],
+      options: [
+        {
+          flags: "-v, --verbose",
+          description: "详细输出",
+        },
+      ],
+      run: async (args, options, ctx) => {
+        const verbose = (options?.verbose ? 2 : 1) as VerboseLevel;
+        const extensionLoader = ctx.getService<ExtensionLoader>("extensionLoader");
+        const listService = new ListService(extensionLoader);
+        await listService.execute(verbose);
+      },
+    },
+  ],
+});
+
+export * from "./list.service";

package/src/commands/list/list.service.ts

@@ -0,0 +1,127 @@
+import { join } from "path";
+import { existsSync } from "fs";
+import type { ExtensionLoader } from "../../cli-runtime/extension-loader";
+import {
+  shouldLog,
+  type VerboseLevel,
+  getEditorDirName,
+  getSourceType,
+  normalizeSource,
+  getDependencies,
+  getSupportedEditors,
+  t,
+} from "@spaceflow/core";
+
+interface ExtensionListInfo {
+  name: string;
+  source: string;
+  type: "npm" | "git" | "local";
+  commands: string[];
+  installed: boolean;
+}
+
+export class ListService {
+  constructor(private readonly extensionLoader: ExtensionLoader) {}
+
+  /**
+   * 执行列表展示
+   */
+  async execute(verbose: VerboseLevel = 1): Promise<void> {
+    const cwd = process.cwd();
+
+    // 读取合并后的 dependencies（支持 .spaceflowrc、.spaceflow/spaceflow.json 等所有配置源）
+    const dependencies = getDependencies(cwd);
+
+    if (Object.keys(dependencies).length === 0) {
+      if (shouldLog(verbose, 1)) {
+        console.log(t("list:noSkills"));
+        console.log("");
+        console.log(t("list:installHint"));
+        console.log("  spaceflow install <npm-package>");
+        console.log("  spaceflow install <git-url> --name <name>");
+      }
+      return;
+    }
+
+    const editors = getSupportedEditors(cwd);
+    // 收集所有外部扩展信息
+    const extensionInfos: ExtensionListInfo[] = [];
+    for (const [name, source] of Object.entries(dependencies)) {
+      const type = getSourceType(source);
+      const installed = await this.checkInstalled(name, source, type, editors);
+      extensionInfos.push({ name, source, type, installed, commands: [] });
+    }
+    if (!shouldLog(verbose, 1)) return;
+    // 计算最大名称宽度用于对齐
+    const maxNameLen = Math.max(...extensionInfos.map((e) => e.name.length), 10);
+    const installedCount = extensionInfos.filter((e) => e.installed).length;
+    console.log(
+      t("list:installedExtensions", { installed: installedCount, total: extensionInfos.length }) +
+        "\n",
+    );
+    for (const ext of extensionInfos) {
+      const icon = ext.installed ? "\x1b[32m✔\x1b[0m" : "\x1b[33m○\x1b[0m";
+      const typeLabel =
+        ext.type === "local"
+          ? "\x1b[36mlocal\x1b[0m"
+          : ext.type === "npm"
+            ? "\x1b[35mnpm\x1b[0m"
+            : "\x1b[33mgit\x1b[0m";
+      const displaySource = this.getDisplaySource(ext.source, ext.type);
+      console.log(`  ${icon} ${ext.name.padEnd(maxNameLen + 2)} ${typeLabel}  ${displaySource}`);
+      // 显示命令列表
+      if (ext.commands.length > 0) {
+        console.log(
+          `    ${"".padEnd(maxNameLen)}  ${t("list:commands", { commands: ext.commands.join(", ") })}`,
+        );
+      }
+    }
+    console.log("");
+  }
+
+  /**
+   * 获取用于展示的 source 字符串
+   */
+  private getDisplaySource(source: string, type: "npm" | "git" | "local"): string {
+    if (type === "local") {
+      return normalizeSource(source);
+    }
+    if (type === "git") {
+      // 简化 git URL 展示
+      const match = source.match(/[/:](\w+\/[\w.-]+?)(?:\.git)?$/);
+      return match ? match[1] : source;
+    }
+    return source;
+  }
+
+  /**
+   * 检查是否已安装
+   */
+  private async checkInstalled(
+    name: string,
+    source: string,
+    type: "npm" | "git" | "local",
+    editors: string[],
+  ): Promise<boolean> {
+    const cwd = process.cwd();
+    if (type === "local") {
+      const localPath = join(cwd, normalizeSource(source));
+      return existsSync(localPath);
+    } else if (type === "npm") {
+      try {
+        require.resolve(source);
+        return true;
+      } catch {
+        return false;
+      }
+    } else {
+      const possiblePaths = [join(cwd, "skills", name)];
+      for (const editor of editors) {
+        const editorDirName = getEditorDirName(editor);
+        possiblePaths.push(join(cwd, editorDirName, "skills", name));
+        possiblePaths.push(join(cwd, editorDirName, "commands", name));
+      }
+      return possiblePaths.some((p) => existsSync(p));
+    }
+  }
+}

package/src/commands/mcp/index.ts

@@ -0,0 +1,37 @@
+import { defineExtension, type VerboseLevel } from "@spaceflow/core";
+import { McpService } from "./mcp.service";
+import type { ExtensionLoader } from "../../cli-runtime/extension-loader";
+
+/**
+ * MCP 命令扩展
+ */
+export const mcpExtension = defineExtension({
+  name: "mcp",
+  version: "1.0.0",
+  description: "MCP 工具",
+  commands: [
+    {
+      name: "mcp",
+      description: "启动 MCP Server",
+      options: [
+        {
+          flags: "-v, --verbose",
+          description: "详细输出",
+        },
+        {
+          flags: "--inspector",
+          description: "启动 MCP Inspector",
+        },
+      ],
+      run: async (_args, options, ctx) => {
+        const verbose = (options?.verbose ? 2 : 1) as VerboseLevel;
+        const inspector = options?.inspector as boolean | undefined;
+        const extensionLoader = ctx.getService<ExtensionLoader>("extensionLoader");
+        const mcpService = new McpService(extensionLoader);
+        await mcpService.startServer(verbose, inspector);
+      },
+    },
+  ],
+});
+
+export * from "./mcp.service";

package/src/commands/mcp/mcp.service.ts

@@ -0,0 +1,246 @@
+import { t } from "@spaceflow/core";
+import type { VerboseLevel } from "@spaceflow/core";
+import { shouldLog, type McpToolMetadata } from "@spaceflow/core";
+import type { ExtensionLoader } from "../../cli-runtime/extension-loader";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { spawn } from "child_process";
+
+export class McpService {
+  constructor(private readonly extensionLoader: ExtensionLoader) {}
+
+  /**
+   * 启动 MCP Server
+   * 收集所有扩展的 MCP 工具并启动服务
+   */
+  async startServer(verbose?: VerboseLevel, inspector?: boolean): Promise<void> {
+    // 如果启用 inspector 模式，使用 npx 启动 inspector
+    if (inspector) {
+      await this.startWithInspector();
+      return;
+    }
+    if (shouldLog(verbose, 1)) {
+      console.error(t("mcp:scanning"));
+    }
+
+    // 获取所有扩展（已在 exec() 阶段通过 registerExtension 注册完毕）
+    const extensions = this.extensionLoader.getExtensions();
+    const mcpServers = this.extensionLoader.getMcpServers();
+
+    if (shouldLog(verbose, 2)) {
+      console.error(t("mcp:foundExtensions", { count: extensions.length }));
+    }
+
+    // 收集所有扩展的 MCP 工具
+    const allTools: Array<{ tool: McpToolMetadata; handler: any; ctx: any }> = [];
+    for (const { extensionName, mcp } of mcpServers) {
+      if (shouldLog(verbose, 2)) {
+        console.error(`   扩展 ${extensionName} 提供 ${mcp.tools.length} 个 MCP 工具`);
+      }
+      for (const tool of mcp.tools) {
+        if (shouldLog(verbose, 3)) {
+          console.error(`      - ${tool.name}: ${tool.description}`);
+        }
+        allTools.push({
+          tool: {
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.inputSchema
+              ? (this.zodToJsonSchema(tool.inputSchema) as any)
+              : undefined,
+            methodName: "handler",
+          },
+          handler: tool.handler,
+          ctx: this.extensionLoader["ctx"], // 获取 SpaceflowContext
+        });
+      }
+    }
+
+    if (allTools.length === 0) {
+      console.error(t("mcp:noToolsFound"));
+      console.error(t("mcp:noToolsHint"));
+      process.exit(1);
+    }
+
+    if (shouldLog(verbose, 1)) {
+      console.error(t("mcp:toolsFound", { count: allTools.length }));
+      for (const { tool } of allTools) {
+        console.error(`   - ${tool.name}`);
+      }
+    }
+
+    // 如果 stdin 是 TTY（用户手动在终端运行），只打印信息不阻塞
+    if (process.stdin.isTTY) {
+      console.error("");
+      console.error(t("mcp:ttyHint"));
+      return;
+    }
+
+    // 被 MCP 客户端通过管道调用，正常启动 stdio server
+    await this.runServer(allTools, verbose);
+  }
+
+  /**
+   * 运行 MCP Server
+   */
+  private async runServer(
+    allTools: Array<{ tool: McpToolMetadata; handler: any; ctx: any }>,
+    verbose?: VerboseLevel,
+  ): Promise<void> {
+    const server = new McpServer({ name: "spaceflow", version: "1.0.0" });
+
+    // 注册所有工具（使用 v2 API: server.registerTool）
+    for (const { tool, handler, ctx } of allTools) {
+      // 将 JSON Schema 转换为 Zod schema
+      const schema = this.jsonSchemaToZod(tool.inputSchema);
+      server.registerTool(
+        tool.name,
+        {
+          description: tool.description,
+          inputSchema: Object.keys(schema).length > 0 ? z.object(schema) : z.object({}),
+        },
+        async (args: any) => {
+          try {
+            const result = await handler(args || {}, ctx);
+            return {
+              content: [
+                {
+                  type: "text" as const,
+                  text: typeof result === "string" ? result : JSON.stringify(result, null, 2),
+                },
+              ],
+            };
+          } catch (error) {
+            return {
+              content: [
+                {
+                  type: "text" as const,
+                  text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+              ],
+              isError: true,
+            };
+          }
+        },
+      );
+    }
+
+    // 启动 stdio 传输
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+
+    if (shouldLog(verbose, 1)) {
+      console.error(t("mcp:serverStarted", { count: allTools.length }));
+    }
+
+    // 保持进程运行
+    await new Promise<void>((resolve) => {
+      process.stdin.on("close", resolve);
+      process.on("SIGINT", resolve);
+      process.on("SIGTERM", resolve);
+    });
+  }
+
+  /**
+   * 使用 MCP Inspector 启动
+   */
+  private async startWithInspector(): Promise<void> {
+    const args = process.argv.slice(2).filter((arg) => arg !== "--inspector");
+    const child = spawn(
+      "npx",
+      ["-y", "@modelcontextprotocol/inspector", "node", process.argv[1], ...args],
+      {
+        stdio: "inherit",
+        env: { ...process.env, FORCE_COLOR: "1" },
+      },
+    );
+    child.on("exit", (code) => {
+      process.exit(code || 0);
+    });
+  }
+
+  /**
+   * 将 Zod schema 转换为 JSON Schema
+   */
+  private zodToJsonSchema(zodSchema: any): Record<string, any> {
+    if (!zodSchema || typeof zodSchema.shape !== "object") {
+      return {};
+    }
+    const properties: Record<string, any> = {};
+    const required: string[] = [];
+    for (const [key, value] of Object.entries(zodSchema.shape)) {
+      const zodType = value as any;
+      let type = "string";
+      let description = zodType._def?.description;
+      // 检查是否可选
+      const isOptional = zodType._def?.typeName === "ZodOptional";
+      const innerType = isOptional ? zodType._def?.innerType : zodType;
+      // 获取类型
+      switch (innerType?._def?.typeName) {
+        case "ZodString":
+          type = "string";
+          break;
+        case "ZodNumber":
+          type = "number";
+          break;
+        case "ZodBoolean":
+          type = "boolean";
+          break;
+        case "ZodArray":
+          type = "array";
+          break;
+        default:
+          type = "string";
+      }
+      properties[key] = { type };
+      if (description) {
+        properties[key].description = description;
+      }
+      if (!isOptional) {
+        required.push(key);
+      }
+    }
+    return { properties, required };
+  }
+
+  /**
+   * 将 JSON Schema 转换为 Zod schema
+   */
+  private jsonSchemaToZod(jsonSchema?: Record<string, any>): Record<string, any> {
+    if (!jsonSchema || !jsonSchema.properties) {
+      return {};
+    }
+
+    const zodShape: Record<string, any> = {};
+    for (const [key, prop] of Object.entries(jsonSchema.properties as Record<string, any>)) {
+      const isRequired = jsonSchema.required?.includes(key);
+      let zodType: any;
+
+      switch (prop.type) {
+        case "string":
+          zodType = z.string();
+          break;
+        case "number":
+          zodType = z.number();
+          break;
+        case "boolean":
+          zodType = z.boolean();
+          break;
+        case "array":
+          zodType = z.array(z.any());
+          break;
+        default:
+          zodType = z.any();
+      }
+
+      if (prop.description) {
+        zodType = zodType.describe(prop.description);
+      }
+
+      zodShape[key] = isRequired ? zodType : zodType.optional();
+    }
+
+    return zodShape;
+  }
+}

package/src/commands/runx/index.ts

@@ -0,0 +1,47 @@
+import { defineExtension, SchemaGeneratorService, type VerboseLevel } from "@spaceflow/core";
+import { RunxService } from "./runx.service";
+import { InstallService } from "../install/install.service";
+
+/**
+ * Runx 命令扩展
+ */
+export const runxExtension = defineExtension({
+  name: "runx",
+  version: "1.0.0",
+  description: "运行 x 命令",
+  commands: [
+    {
+      name: "runx",
+      description: "全局安装并运行扩展命令",
+      aliases: ["x"],
+      arguments: "<source> [args...]",
+      options: [
+        {
+          flags: "-n, --name <name>",
+          description: "指定安装名称",
+        },
+        {
+          flags: "-v, --verbose",
+          description: "详细输出",
+        },
+      ],
+      run: async (args, options, _ctx) => {
+        const source = args[0];
+        const cmdArgs = args.slice(1);
+        const verbose = (options?.verbose ? 2 : 1) as VerboseLevel;
+        const schemaGenerator = new SchemaGeneratorService();
+        const installService = new InstallService(schemaGenerator);
+        const runxService = new RunxService(installService);
+        await runxService.execute({
+          source,
+          name: options?.name as string,
+          args: cmdArgs,
+          verbose,
+        });
+      },
+    },
+  ],
+});
+
+export * from "./runx.service";
+export * from "./runx.utils";

package/src/commands/runx/runx.service.ts

@@ -0,0 +1,142 @@
+import { join } from "path";
+import { existsSync, realpathSync } from "fs";
+import { spawn } from "child_process";
+import { InstallService } from "../install/install.service";
+import type { VerboseLevel } from "@spaceflow/core";
+import { extractName, getSourceType, t } from "@spaceflow/core";
+
+export interface RunxOptions {
+  source: string;
+  name?: string;
+  args: string[];
+  verbose?: VerboseLevel;
+}
+
+/**
+ * Runx 服务
+ * 全局安装依赖后运行命令
+ */
+export class RunxService {
+  constructor(private readonly installService: InstallService) {}
+
+  /**
+   * 执行 runx：全局安装 + 运行命令
+   */
+  async execute(options: RunxOptions): Promise<void> {
+    const { source, args } = options;
+    const verbose = options.verbose ?? true;
+    const name = options.name || extractName(source);
+    const sourceType = getSourceType(source);
+
+    // npm 包直接使用 npx 执行
+    if (sourceType === "npm") {
+      if (verbose)
+        console.log(t("runx:runningCommand", { command: `npx ${source} ${args.join(" ")}` }));
+      await this.runWithNpx(source, args);
+      return;
+    }
+
+    // 第一步：全局安装（静默模式）
+    await this.installService.installGlobal(
+      {
+        source,
+        name: options.name,
+      },
+      false,
+    );
+    // 第二步：运行命令
+    if (verbose) console.log(t("runx:runningCommand", { command: `${name} ${args.join(" ")}` }));
+    await this.runCommand(name, args);
+  }
+
+  /**
+   * 使用 npx 运行 npm 包
+   */
+  private runWithNpx(packageName: string, args: string[]): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const child = spawn("npx", [packageName, ...args], {
+        stdio: "inherit",
+        shell: true,
+      });
+
+      child.on("close", (code) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(t("runx:npxExitCode", { package: packageName, code })));
+        }
+      });
+
+      child.on("error", (err) => {
+        reject(err);
+      });
+    });
+  }
+
+  /**
+   * 运行已安装的命令
+   * TODO: 迁移到新架构后实现
+   */
+  protected async runCommand(name: string, args: string[]): Promise<void> {
+    const home = process.env.HOME || process.env.USERPROFILE || "~";
+    const depPath = join(home, ".spaceflow", "node_modules", name);
+    // 检查命令是否存在
+    if (!existsSync(depPath)) {
+      throw new Error(t("runx:commandNotInstalled", { name }));
+    }
+    // 解析符号链接获取真实路径
+    const realDepPath = realpathSync(depPath);
+    // 检查是否有 dist/index.js
+    const distPath = join(realDepPath, "dist", "index.js");
+    if (!existsSync(distPath)) {
+      throw new Error(t("runx:commandNotBuilt", { name }));
+    }
+    // 动态加载插件（使用 Function 构造器绕过 rspack 转换）
+    const importUrl = `file://${distPath}`;
+    const dynamicImport = new Function("url", "return import(url)");
+    const pluginModule = await dynamicImport(importUrl);
+    const extensionDef = pluginModule.default;
+    if (!extensionDef) {
+      throw new Error(t("runx:pluginNoExport", { name }));
+    }
+    // 新架构：extensionDef 是 ExtensionDefinition 对象
+    // 查找匹配的命令并执行
+    const commands = extensionDef.commands || [];
+    const finalArgs = this.autoCompleteCommand(
+      args,
+      commands.map((c: { name: string }) => c.name),
+    );
+    // 查找要执行的命令
+    const cmdName = finalArgs[0];
+    const cmdDef = commands.find((c: { name: string }) => c.name === cmdName);
+    if (!cmdDef) {
+      throw new Error(t("runx:commandNotFound", { name: cmdName }));
+    }
+    // TODO: 需要创建 SpaceflowContext 来执行命令
+    // 暂时抛出未实现错误
+    throw new Error(`runx 命令正在迁移到新架构，暂不可用。请直接使用 space ${cmdName} 命令。`);
+  }
+
+  /**
+   * 自动补充命令名
+   * 如果插件只有一个命令，且用户没有指定子命令，自动在参数前补充命令名
+   */
+  private autoCompleteCommand(args: string[], commands?: string[]): string[] {
+    // 没有命令列表或为空，直接返回
+    if (!commands || commands.length === 0) {
+      return args;
+    }
+    // 如果只有一个命令
+    if (commands.length === 1) {
+      const cmdName = commands[0];
+      // 检查用户是否已经指定了该命令
+      if (args.length === 0 || args[0] !== cmdName) {
+        // 如果第一个参数是选项（以 - 开头），说明用户没有指定子命令
+        if (args.length === 0 || args[0].startsWith("-")) {
+          return [cmdName, ...args];
+        }
+      }
+    }
+    return args;
+  }
+}