@spaceflow/core 0.8.0 → 0.9.0

package/src/cli-runtime/index.ts

@@ -0,0 +1,131 @@
+import { Command } from "commander";
+import type { ExtensionDefinition } from "@spaceflow/core";
+import { ServiceContainer, initializeContainer } from "./di";
+import { ExtensionLoader } from "./extension-loader";
+import { internalExtensions } from "./internal-extensions";
+import { initCliI18n } from "./i18n";
+
+export { ServiceContainer } from "./di";
+export { ExtensionLoader } from "./extension-loader";
+export { initCliI18n } from "./i18n";
+export { internalExtensions } from "./internal-extensions";
+
+/**
+ * Core.exec() — CLI 运行时入口
+ * 接收外部扩展列表，结合内部扩展，构建并执行 commander 程序
+ *
+ * @param extensions 外部扩展定义列表（来自 .spaceflow/bin/index.js 的静态导入）
+ */
+export async function exec(extensions: ExtensionDefinition[] = []): Promise<void> {
+  // 1. 初始化 i18n（如果尚未初始化，由生成的 bin/index.js 提前调用）
+  initCliI18n();
+
+  // 2. 创建并初始化服务容器
+  const container = new ServiceContainer();
+  initializeContainer(container);
+
+  // 3. 创建扩展加载器
+  const extensionLoader = new ExtensionLoader(container);
+  container.registerService("extensionLoader", extensionLoader);
+
+  // 4. 注册内部扩展
+  for (const ext of internalExtensions) {
+    extensionLoader.registerExtension(ext);
+  }
+
+  // 5. 注册外部扩展（由 CLI 壳子加载并传入）
+  for (const ext of extensions) {
+    extensionLoader.registerExtension(ext);
+  }
+
+  // 6. 创建 CLI 程序
+  const program = new Command();
+  program.name("spaceflow").description("Spaceflow CLI").version("1.0.0");
+
+  // 定义全局 verbose 选项（支持计数：-v, -vv, -vvv）
+  program.option(
+    "-v, --verbose",
+    "详细输出（可叠加：-v, -vv, -vvv）",
+    (_, prev: number) => prev + 1,
+    0,
+  );
+
+  // 全局选项列表
+  const globalOptions = ["-h, --help", "-V, --version", "-v, --verbose"];
+
+  // 8. 注册所有命令
+  const commands = extensionLoader.getCommands();
+  for (const cmd of commands) {
+    const command = new Command(cmd.name).description(cmd.description);
+
+    // 添加别名
+    if (cmd.aliases) {
+      for (const alias of cmd.aliases) {
+        command.alias(alias);
+      }
+    }
+
+    // 添加参数
+    if (cmd.arguments) {
+      command.arguments(cmd.arguments);
+    }
+
+    // 添加选项（排除已定义的全局选项）
+    if (cmd.options) {
+      for (const opt of cmd.options) {
+        if (!globalOptions.some((go) => opt.flags.startsWith(go.split(",")[0].trim()))) {
+          if (opt.isCount) {
+            command.option(
+              opt.flags as string,
+              opt.description as string,
+              (_, prev: number) => prev + 1,
+              0,
+            );
+          } else {
+            const defaultValue = opt.default as string | boolean | string[] | undefined;
+            command.option(opt.flags as string, opt.description as string, defaultValue);
+          }
+        }
+      }
+    }
+
+    // 添加子命令
+    if (cmd.subcommands) {
+      for (const sub of cmd.subcommands) {
+        const subCmd = new Command(sub.name).description(sub.description);
+        if (sub.options) {
+          for (const opt of sub.options) {
+            if (!globalOptions.some((go) => opt.flags.startsWith(go.split(",")[0].trim()))) {
+              const defaultValue = opt.default as string | boolean | string[] | undefined;
+              subCmd.option(opt.flags as string, opt.description as string, defaultValue);
+            }
+          }
+        }
+        subCmd.action(async (args, options) => {
+          await sub.run([args], options, container);
+        });
+        command.addCommand(subCmd);
+      }
+    }
+
+    // 添加执行函数
+    command.action(async (...actionArgs) => {
+      const opts = actionArgs[actionArgs.length - 2] || {};
+      const positionalArgs = actionArgs.slice(0, -2);
+      // 合并全局 verbose 选项
+      const globalOpts = program.opts();
+      if (globalOpts.verbose && !opts.verbose) {
+        opts.verbose = globalOpts.verbose;
+      }
+      await cmd.run(positionalArgs, opts, container);
+    });
+
+    program.addCommand(command);
+  }
+
+  // 9. 解析命令行参数
+  await program.parseAsync(process.argv);
+
+  // 10. 清理
+  await container.destroy();
+}

package/src/cli-runtime/internal-extensions.ts

@@ -0,0 +1,33 @@
+import { buildExtension } from "../commands/build";
+import { clearExtension } from "../commands/clear";
+import { commitExtension } from "../commands/commit";
+import { createExtension } from "../commands/create";
+import { devExtension } from "../commands/dev";
+import { installExtension } from "../commands/install";
+import { listExtension } from "../commands/list";
+import { mcpExtension } from "../commands/mcp";
+import { runxExtension } from "../commands/runx";
+import { schemaExtension } from "../commands/schema";
+import { setupExtension } from "../commands/setup";
+import { uninstallExtension } from "../commands/uninstall";
+import { updateExtension } from "../commands/update";
+
+/**
+ * 内部扩展列表
+ * 从各命令目录导入 defineExtension 定义
+ */
+export const internalExtensions = [
+  buildExtension,
+  clearExtension,
+  commitExtension,
+  createExtension,
+  devExtension,
+  installExtension,
+  listExtension,
+  mcpExtension,
+  runxExtension,
+  schemaExtension,
+  setupExtension,
+  uninstallExtension,
+  updateExtension,
+];

package/src/commands/build/build.service.ts

@@ -0,0 +1,323 @@
+import { rspack, type Compiler, type Configuration, type Stats } from "@rspack/core";
+import { readdir, stat } from "fs/promises";
+import { join, dirname, resolve } from "path";
+import { existsSync, readFileSync } from "fs";
+import { createRequire } from "module";
+import { createPluginConfig, getDependencies } from "@spaceflow/core";
+import { shouldLog, type VerboseLevel, t } from "@spaceflow/core";
+
+export interface ExtensionInfo {
+  name: string;
+  path: string;
+  hasPackageJson: boolean;
+}
+
+export interface BuildResult {
+  extension: string;
+  success: boolean;
+  duration?: number;
+  errors?: string[];
+  warnings?: string[];
+}
+
+export class BuildService {
+  private readonly projectRoot = this.findProjectRoot();
+  private readonly extensionDirs = this.discoverExtensionDirs();
+  private readonly coreRoot = this.resolveCoreRoot();
+  private watchers: Map<string, Compiler> = new Map();
+
+  /**
+   * 查找项目根目录（包含 spaceflow.json 或 .spaceflow/spaceflow.json 的目录）
+   */
+  private findProjectRoot(): string {
+    let dir = process.cwd();
+    while (dir !== dirname(dir)) {
+      // 检查根目录下的 spaceflow.json
+      if (existsSync(join(dir, "spaceflow.json"))) {
+        return dir;
+      }
+      // 检查 .spaceflow/spaceflow.json
+      if (existsSync(join(dir, ".spaceflow", "spaceflow.json"))) {
+        return dir;
+      }
+      dir = dirname(dir);
+    }
+    // 如果找不到，回退到 cwd
+    return process.cwd();
+  }
+
+  /**
+   * 构建插件
+   */
+  async build(extensionName?: string, verbose: VerboseLevel = 1): Promise<BuildResult[]> {
+    const extensions = await this.getExtensionsToBuild(extensionName);
+
+    if (extensions.length === 0) {
+      if (shouldLog(verbose, 1)) console.log(t("build:noPlugins"));
+      return [];
+    }
+
+    if (shouldLog(verbose, 1))
+      console.log(t("build:startBuilding", { count: extensions.length }) + "\n");
+
+    const results: BuildResult[] = [];
+    for (const ext of extensions) {
+      const result = await this.buildExtension(ext, verbose);
+      results.push(result);
+    }
+
+    const successCount = results.filter((r) => r.success).length;
+    const failCount = results.filter((r) => !r.success).length;
+
+    if (shouldLog(verbose, 1))
+      console.log("\n" + t("build:buildComplete", { success: successCount, fail: failCount }));
+    return results;
+  }
+
+  /**
+   * 监听模式构建
+   */
+  async watch(extensionName?: string, verbose: VerboseLevel = 1): Promise<void> {
+    const extensions = await this.getExtensionsToBuild(extensionName);
+
+    if (extensions.length === 0) {
+      if (shouldLog(verbose, 1)) console.log(t("build:noPlugins"));
+      return;
+    }
+
+    if (shouldLog(verbose, 1))
+      console.log(t("build:startWatching", { count: extensions.length }) + "\n");
+
+    // 并行启动所有 watcher
+    await Promise.all(extensions.map((ext) => this.watchExtension(ext, verbose)));
+
+    // 保持进程运行
+    await new Promise(() => {});
+  }
+
+  /**
+   * 停止所有 watcher
+   */
+  async stopWatch(verbose: VerboseLevel = 1): Promise<void> {
+    for (const [name, compiler] of this.watchers) {
+      await new Promise<void>((resolve) => {
+        compiler.close(() => {
+          if (shouldLog(verbose, 1)) console.log(t("build:stopWatching", { name }));
+          resolve();
+        });
+      });
+    }
+    this.watchers.clear();
+  }
+
+  /**
+   * 从 spaceflow.json 的 dependencies 中发现本地 extension 所在的目录
+   * 解析所有 link: 路径，收集去重后的父目录
+   */
+  private discoverExtensionDirs(): string[] {
+    const dependencies = getDependencies(this.projectRoot);
+    const parentDirs = new Set<string>();
+    for (const source of Object.values(dependencies)) {
+      if (!source.startsWith("link:")) continue;
+      const linkPath = source.slice(5);
+      const absolutePath = resolve(this.projectRoot, linkPath);
+      parentDirs.add(dirname(absolutePath));
+    }
+    return Array.from(parentDirs);
+  }
+
+  /**
+   * 动态解析 @spaceflow/core 的根目录
+   * 优先通过 require.resolve 定位，回退到 node_modules
+   */
+  private resolveCoreRoot(): string {
+    try {
+      const req = createRequire(join(this.projectRoot, "package.json"));
+      const corePkgPath = req.resolve("@spaceflow/core/package.json");
+      return dirname(corePkgPath);
+    } catch {
+      return join(this.projectRoot, "node_modules", "@spaceflow", "core");
+    }
+  }
+
+  /**
+   * 获取需要构建的 Extension 列表
+   */
+  private async getExtensionsToBuild(extensionName?: string): Promise<ExtensionInfo[]> {
+    // 如果没有指定名称，检查是否在 Extension 目录中运行
+    if (!extensionName) {
+      const current = this.detectCurrentExtension();
+      if (current) {
+        return [current];
+      }
+    }
+    // 从所有 extension 目录中扫描
+    const result: ExtensionInfo[] = [];
+    for (const extDir of this.extensionDirs) {
+      if (!existsSync(extDir)) continue;
+      const entries = await readdir(extDir);
+      for (const entry of entries) {
+        if (entry.startsWith(".")) continue;
+        const extPath = join(extDir, entry);
+        const stats = await stat(extPath);
+        if (!stats.isDirectory()) continue;
+        if (extensionName && entry !== extensionName) continue;
+        const packageJsonPath = join(extPath, "package.json");
+        if (existsSync(packageJsonPath)) {
+          result.push({ name: entry, path: extPath, hasPackageJson: true });
+        }
+      }
+    }
+    return result;
+  }
+
+  /**
+   * 检测当前目录是否为 spaceflow Extension
+   * 通过检查 package.json 中的 spaceflow 配置判断，不依赖固定目录名
+   */
+  private detectCurrentExtension(): ExtensionInfo | null {
+    const cwd = process.cwd();
+    const packageJsonPath = join(cwd, "package.json");
+    if (!existsSync(packageJsonPath)) {
+      return null;
+    }
+    try {
+      const content = readFileSync(packageJsonPath, "utf-8");
+      const pkg = JSON.parse(content);
+      if (!pkg.spaceflow) {
+        return null;
+      }
+      const name = cwd.split("/").pop() || "";
+      return { name, path: cwd, hasPackageJson: true };
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * 构建单个 Extension
+   */
+  private async buildExtension(
+    ext: ExtensionInfo,
+    verbose: VerboseLevel = 1,
+  ): Promise<BuildResult> {
+    const startTime = Date.now();
+    if (shouldLog(verbose, 1)) console.log(t("build:building", { name: ext.name }));
+
+    try {
+      const config = await this.getConfig(ext);
+      const compiler = rspack(config);
+
+      const stats = await new Promise<Stats>((resolve, reject) => {
+        compiler.run((err, stats) => {
+          compiler.close((closeErr) => {
+            if (err) return reject(err);
+            if (closeErr) return reject(closeErr);
+            if (!stats) return reject(new Error("No stats returned"));
+            resolve(stats);
+          });
+        });
+      });
+
+      const duration = Date.now() - startTime;
+      const info = stats.toJson({ errors: true, warnings: true });
+
+      if (stats.hasErrors()) {
+        const errors = info.errors?.map((e) => e.message) || [];
+        console.log(t("build:buildFailedWithDuration", { duration }));
+        errors.forEach((e) => console.log(`      ${e}`));
+        return { extension: ext.name, success: false, duration, errors };
+      }
+
+      if (stats.hasWarnings()) {
+        const warnings = info.warnings?.map((w) => w.message) || [];
+        if (shouldLog(verbose, 1))
+          console.log(t("build:buildWarnings", { duration, count: warnings.length }));
+        return { extension: ext.name, success: true, duration, warnings };
+      }
+
+      if (shouldLog(verbose, 1)) console.log(t("build:buildSuccess", { duration }));
+      return { extension: ext.name, success: true, duration };
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(t("build:buildFailedWithMessage", { duration, message }));
+      return { extension: ext.name, success: false, duration, errors: [message] };
+    }
+  }
+
+  /**
+   * 监听单个 Extension
+   */
+  private async watchExtension(ext: ExtensionInfo, verbose: VerboseLevel = 1): Promise<void> {
+    if (shouldLog(verbose, 1)) console.log(t("build:watching", { name: ext.name }));
+
+    try {
+      const config = await this.getConfig(ext);
+      const compiler = rspack(config);
+
+      this.watchers.set(ext.name, compiler);
+
+      compiler.watch({}, (err, stats) => {
+        if (err) {
+          console.log(t("build:watchError", { name: ext.name, message: err.message }));
+          return;
+        }
+
+        if (!stats) return;
+
+        const info = stats.toJson({ errors: true, warnings: true });
+
+        if (stats.hasErrors()) {
+          console.log(t("build:watchBuildFailed", { name: ext.name }));
+          info.errors?.forEach((e) => console.log(`      ${e.message}`));
+        } else if (stats.hasWarnings()) {
+          if (shouldLog(verbose, 1))
+            console.log(
+              t("build:watchBuildWarnings", { name: ext.name, count: info.warnings?.length }),
+            );
+        } else {
+          if (shouldLog(verbose, 1)) console.log(t("build:watchBuildSuccess", { name: ext.name }));
+        }
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(t("build:watchInitFailed", { name: ext.name, message }));
+    }
+  }
+
+  /**
+   * 获取 Extension 的 rspack 配置
+   */
+  private async getConfig(ext: ExtensionInfo): Promise<Configuration> {
+    const customConfigPath = join(ext.path, "rspack.config.mjs");
+    const customConfigPathJs = join(ext.path, "rspack.config.js");
+
+    if (existsSync(customConfigPath)) {
+      const module = await import(customConfigPath);
+      return module.default || module;
+    }
+
+    if (existsSync(customConfigPathJs)) {
+      const module = await import(customConfigPathJs);
+      return module.default || module;
+    }
+
+    return this.getDefaultConfig(ext);
+  }
+
+  /**
+   * 生成默认的 rspack 配置
+   */
+  private getDefaultConfig(ext: ExtensionInfo): Configuration {
+    return createPluginConfig(
+      {
+        name: ext.name,
+        path: ext.path,
+      },
+      {
+        coreRoot: this.coreRoot,
+      },
+    );
+  }
+}

package/src/commands/build/index.ts

@@ -0,0 +1,49 @@
+import { defineExtension, type VerboseLevel } from "@spaceflow/core";
+import { BuildService } from "./build.service";
+
+/**
+ * Build 命令扩展
+ */
+export const buildExtension = defineExtension({
+  name: "build",
+  version: "1.0.0",
+  description: "构建 Extension 插件包",
+  commands: [
+    {
+      name: "build",
+      description: "构建指定或所有 Extension",
+      arguments: "[extension]",
+      options: [
+        {
+          flags: "-w, --watch",
+          description: "监听模式",
+        },
+        {
+          flags: "-v, --verbose",
+          description: "详细输出",
+        },
+      ],
+      run: async (args, options, ctx) => {
+        const extensionName = args[0];
+        const verbose = (options?.verbose ? 2 : 1) as VerboseLevel;
+        const buildService = new BuildService();
+        try {
+          if (options?.watch) {
+            await buildService.watch(extensionName, verbose);
+          } else {
+            const results = await buildService.build(extensionName, verbose);
+            const hasErrors = results.some((r) => !r.success);
+            if (hasErrors) {
+              process.exit(1);
+            }
+          }
+        } catch (error) {
+          ctx.output.error(`构建失败: ${error instanceof Error ? error.message : error}`);
+          process.exit(1);
+        }
+      },
+    },
+  ],
+});
+
+export * from "./build.service";

package/src/commands/clear/clear.service.ts

@@ -0,0 +1,159 @@
+import { readFile, rm } from "fs/promises";
+import { join } from "path";
+import { existsSync, readdirSync, lstatSync } from "fs";
+import { shouldLog, type VerboseLevel, t } from "@spaceflow/core";
+import { getEditorDirName, DEFAULT_EDITOR } from "@spaceflow/core";
+
+export class ClearService {
+  /**
+   * 获取支持的编辑器列表
+   */
+  protected async getSupportedEditors(configPath: string): Promise<string[]> {
+    try {
+      if (!existsSync(configPath)) return [DEFAULT_EDITOR];
+      const content = await readFile(configPath, "utf-8");
+      const config = JSON.parse(content);
+      return config.support || [DEFAULT_EDITOR];
+    } catch {
+      return [DEFAULT_EDITOR];
+    }
+  }
+
+  /**
+   * 执行清理
+   */
+  async execute(isGlobal = false, verbose: VerboseLevel = 1): Promise<void> {
+    if (shouldLog(verbose, 1)) {
+      if (isGlobal) {
+        console.log(t("clear:clearingGlobal"));
+      } else {
+        console.log(t("clear:clearing"));
+      }
+    }
+
+    const cwd = process.cwd();
+    const home = process.env.HOME || process.env.USERPROFILE || "~";
+    const configPath = join(cwd, "spaceflow.json");
+
+    // 1. 清理 .spaceflow/deps 目录
+    await this.clearSpaceflowDeps(isGlobal, verbose);
+
+    // 2. 清理各编辑器的 skills 和 commands 目录
+    const editors = await this.getSupportedEditors(configPath);
+
+    for (const editor of editors) {
+      const editorDirName = getEditorDirName(editor);
+      const editorRoot = isGlobal ? join(home, editorDirName) : join(cwd, editorDirName);
+      await this.clearEditorDir(editorRoot, editor, verbose);
+    }
+
+    if (shouldLog(verbose, 1)) console.log(t("clear:clearDone"));
+  }
+
+  /**
+   * 清理 .spaceflow 目录内部文件（保留 spaceflow.json）
+   */
+  private async clearSpaceflowDeps(isGlobal: boolean, verbose: VerboseLevel = 1): Promise<void> {
+    const cwd = process.cwd();
+    const home = process.env.HOME || process.env.USERPROFILE || "~";
+    const spaceflowRoot = isGlobal ? join(home, ".spaceflow") : join(cwd, ".spaceflow");
+
+    if (!existsSync(spaceflowRoot)) {
+      if (shouldLog(verbose, 1)) console.log(t("clear:spaceflowNotExist"));
+      return;
+    }
+
+    // 需要保留的文件
+    const preserveFiles = ["spaceflow.json", "package.json"];
+
+    const entries = readdirSync(spaceflowRoot);
+    const toDelete = entries.filter((entry) => !preserveFiles.includes(entry));
+
+    if (toDelete.length === 0) {
+      if (shouldLog(verbose, 1)) console.log(t("clear:spaceflowNoClean"));
+      return;
+    }
+
+    if (shouldLog(verbose, 1))
+      console.log(t("clear:clearingSpaceflow", { count: toDelete.length }));
+
+    for (const entry of toDelete) {
+      const entryPath = join(spaceflowRoot, entry);
+      try {
+        await rm(entryPath, { recursive: true, force: true });
+        if (shouldLog(verbose, 2)) console.log(t("clear:deleted", { entry }));
+      } catch (error) {
+        if (shouldLog(verbose, 1)) {
+          console.warn(
+            t("clear:deleteFailed", { entry }),
+            error instanceof Error ? error.message : error,
+          );
+        }
+      }
+    }
+  }
+
+  /**
+   * 清理编辑器目录下的 skills 和 commands
+   */
+  private async clearEditorDir(
+    editorRoot: string,
+    editorName: string,
+    verbose: VerboseLevel = 1,
+  ): Promise<void> {
+    if (!existsSync(editorRoot)) {
+      return;
+    }
+
+    // 清理 skills 目录
+    const skillsDir = join(editorRoot, "skills");
+    if (existsSync(skillsDir)) {
+      const entries = readdirSync(skillsDir);
+      if (entries.length > 0) {
+        if (shouldLog(verbose, 1))
+          console.log(t("clear:clearingSkills", { editor: editorName, count: entries.length }));
+        for (const entry of entries) {
+          const entryPath = join(skillsDir, entry);
+          try {
+            await rm(entryPath, { recursive: true, force: true });
+            if (shouldLog(verbose, 2)) console.log(t("clear:deleted", { entry }));
+          } catch (error) {
+            if (shouldLog(verbose, 1)) {
+              console.warn(
+                t("clear:deleteFailed", { entry }),
+                error instanceof Error ? error.message : error,
+              );
+            }
+          }
+        }
+      }
+    }
+
+    // 清理 commands 目录中的 .md 文件
+    const commandsDir = join(editorRoot, "commands");
+    if (existsSync(commandsDir)) {
+      const entries = readdirSync(commandsDir).filter((f) => f.endsWith(".md"));
+      if (entries.length > 0) {
+        if (shouldLog(verbose, 1))
+          console.log(t("clear:clearingCommands", { editor: editorName, count: entries.length }));
+        for (const entry of entries) {
+          const entryPath = join(commandsDir, entry);
+          try {
+            const stats = lstatSync(entryPath);
+            if (stats.isFile()) {
+              await rm(entryPath);
+              if (shouldLog(verbose, 2)) console.log(t("clear:deleted", { entry }));
+            }
+          } catch (error) {
+            if (shouldLog(verbose, 1)) {
+              console.warn(
+                t("clear:deleteFailed", { entry }),
+                error instanceof Error ? error.message : error,
+              );
+            }
+          }
+        }
+      }
+    }
+  }
+}