@spaceflow/core 0.1.1

package/src/shared/package-manager/index.ts

@@ -0,0 +1,115 @@
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { join } from "path";
+
+/**
+ * 检测项目使用的包管理器
+ * 必须同时满足：命令可用 AND lock 文件存在
+ * @param cwd 工作目录，默认为 process.cwd()
+ */
+export function getPackageManager(cwd?: string): string {
+  const workDir = cwd || process.cwd();
+
+  // pnpm: 命令可用 + pnpm-lock.yaml 存在
+  if (existsSync(join(workDir, "pnpm-lock.yaml"))) {
+    try {
+      execSync("pnpm --version", { stdio: "ignore" });
+      return "pnpm";
+    } catch {
+      // pnpm 命令不可用，继续检测其他
+    }
+  }
+
+  // yarn: 命令可用 + yarn.lock 存在
+  if (existsSync(join(workDir, "yarn.lock"))) {
+    try {
+      execSync("yarn --version", { stdio: "ignore" });
+      return "yarn";
+    } catch {
+      // yarn 命令不可用，继续检测其他
+    }
+  }
+
+  // npm: 命令可用 + package-lock.json 存在
+  if (existsSync(join(workDir, "package-lock.json"))) {
+    try {
+      execSync("npm --version", { stdio: "ignore" });
+      return "npm";
+    } catch {
+      // npm 命令不可用
+    }
+  }
+
+  // 默认回退到 npm
+  return "npm";
+}
+
+/**
+ * 检测指定目录使用的包管理器（基于 lock 文件）
+ * 如果没有 lock 文件，尝试检测 pnpm 是否可用
+ * @param dir 目标目录
+ */
+export function detectPackageManager(dir: string): string {
+  if (existsSync(join(dir, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (existsSync(join(dir, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (existsSync(join(dir, "package-lock.json"))) {
+    return "npm";
+  }
+  // 默认使用 pnpm（如果可用）
+  try {
+    execSync("pnpm --version", { stdio: "ignore" });
+    return "pnpm";
+  } catch {
+    return "npm";
+  }
+}
+
+/**
+ * 检测当前目录是否为 pnpm workspace
+ * @param cwd 工作目录，默认为 process.cwd()
+ */
+export function isPnpmWorkspace(cwd?: string): boolean {
+  const workDir = cwd || process.cwd();
+  return existsSync(join(workDir, "pnpm-workspace.yaml"));
+}
+
+/**
+ * 将 .spaceflow 添加到根项目的 devDependencies 中
+ * 使用 file: 协议，兼容 npm 和 pnpm
+ * @param cwd 工作目录，默认为 process.cwd()
+ * @returns 是否成功添加（如果已存在则返回 false）
+ */
+export function addSpaceflowToDevDependencies(cwd?: string): boolean {
+  const { readFileSync, writeFileSync } = require("fs");
+  const workDir = cwd || process.cwd();
+  const packageJsonPath = join(workDir, "package.json");
+
+  if (!existsSync(packageJsonPath)) {
+    return false;
+  }
+
+  try {
+    const content = readFileSync(packageJsonPath, "utf-8");
+    const pkg = JSON.parse(content);
+
+    // 检查是否已存在
+    if (pkg.devDependencies?.["spaceflow"]) {
+      return false;
+    }
+
+    // 添加到 devDependencies
+    if (!pkg.devDependencies) {
+      pkg.devDependencies = {};
+    }
+    pkg.devDependencies["spaceflow"] = "file:.spaceflow";
+
+    writeFileSync(packageJsonPath, JSON.stringify(pkg, null, 2) + "\n");
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/shared/parallel/index.ts

@@ -0,0 +1 @@
+export * from "./parallel-executor";

package/src/shared/parallel/parallel-executor.ts

@@ -0,0 +1,169 @@
+export interface ParallelTask<T, R> {
+  id: string;
+  data: T;
+  execute: (data: T) => Promise<R>;
+}
+
+export interface ParallelResult<R> {
+  id: string;
+  success: boolean;
+  result?: R;
+  error?: Error;
+}
+
+export interface ParallelExecutorOptions {
+  concurrency?: number;
+  timeout?: number;
+  retries?: number;
+  retryDelay?: number;
+  onProgress?: (completed: number, total: number, taskId: string) => void;
+  onTaskStart?: (taskId: string) => void;
+  onTaskComplete?: (taskId: string, success: boolean) => void;
+  onRetry?: (taskId: string, attempt: number, error: Error) => void;
+  stopOnError?: boolean;
+}
+
+export class ParallelExecutor {
+  private readonly concurrency: number;
+  private readonly timeout?: number;
+  private readonly retries: number;
+  private readonly retryDelay: number;
+  private readonly onProgress?: (completed: number, total: number, taskId: string) => void;
+  private readonly onTaskStart?: (taskId: string) => void;
+  private readonly onTaskComplete?: (taskId: string, success: boolean) => void;
+  private readonly onRetry?: (taskId: string, attempt: number, error: Error) => void;
+  private readonly stopOnError: boolean;
+
+  constructor(options: ParallelExecutorOptions = {}) {
+    this.concurrency = options.concurrency ?? 5;
+    this.timeout = options.timeout;
+    this.retries = options.retries ?? 0;
+    this.retryDelay = options.retryDelay ?? 1000;
+    this.onProgress = options.onProgress;
+    this.onTaskStart = options.onTaskStart;
+    this.onTaskComplete = options.onTaskComplete;
+    this.onRetry = options.onRetry;
+    this.stopOnError = options.stopOnError ?? false;
+  }
+
+  async execute<T, R>(tasks: ParallelTask<T, R>[]): Promise<ParallelResult<R>[]> {
+    if (tasks.length === 0) {
+      return [];
+    }
+
+    const results: ParallelResult<R>[] = [];
+    const total = tasks.length;
+    let completed = 0;
+    let shouldStop = false;
+
+    const executeTask = async (task: ParallelTask<T, R>): Promise<ParallelResult<R>> => {
+      if (shouldStop) {
+        return { id: task.id, success: false, error: new Error("Execution stopped") };
+      }
+
+      this.onTaskStart?.(task.id);
+
+      let lastError: Error | undefined;
+
+      for (let attempt = 0; attempt <= this.retries; attempt++) {
+        if (attempt > 0) {
+          this.onRetry?.(task.id, attempt, lastError!);
+          await this.delay(this.retryDelay);
+        }
+
+        try {
+          const result = await this.executeWithTimeout(task, task.data);
+          completed++;
+          this.onProgress?.(completed, total, task.id);
+          this.onTaskComplete?.(task.id, true);
+          return { id: task.id, success: true, result };
+        } catch (error) {
+          lastError = error instanceof Error ? error : new Error(String(error));
+        }
+      }
+
+      completed++;
+      this.onProgress?.(completed, total, task.id);
+      this.onTaskComplete?.(task.id, false);
+
+      if (this.stopOnError) {
+        shouldStop = true;
+      }
+
+      return {
+        id: task.id,
+        success: false,
+        error: lastError,
+      };
+    };
+
+    // 使用滑动窗口并发控制
+    const pending: Promise<void>[] = [];
+    const taskQueue = [...tasks];
+
+    while (taskQueue.length > 0 || pending.length > 0) {
+      // 填充到并发上限
+      while (pending.length < this.concurrency && taskQueue.length > 0 && !shouldStop) {
+        const task = taskQueue.shift()!;
+        const promise = executeTask(task).then((result) => {
+          results.push(result);
+          // 从 pending 中移除
+          const index = pending.indexOf(promise);
+          if (index > -1) {
+            pending.splice(index, 1);
+          }
+        });
+        pending.push(promise);
+      }
+
+      // 等待任意一个完成
+      if (pending.length > 0) {
+        await Promise.race(pending);
+      }
+    }
+
+    // 按原始顺序排序结果
+    const taskIdOrder = new Map(tasks.map((t, i) => [t.id, i]));
+    results.sort((a, b) => (taskIdOrder.get(a.id) ?? 0) - (taskIdOrder.get(b.id) ?? 0));
+
+    return results;
+  }
+
+  async map<T, R>(
+    items: T[],
+    fn: (item: T, index: number) => Promise<R>,
+    getId?: (item: T, index: number) => string,
+  ): Promise<ParallelResult<R>[]> {
+    const tasks: ParallelTask<{ item: T; index: number }, R>[] = items.map((item, index) => ({
+      id: getId ? getId(item, index) : String(index),
+      data: { item, index },
+      execute: async ({ item, index }) => fn(item, index),
+    }));
+
+    return this.execute(tasks);
+  }
+
+  private async executeWithTimeout<T, R>(task: ParallelTask<T, R>, data: T): Promise<R> {
+    if (!this.timeout) {
+      return task.execute(data);
+    }
+
+    return Promise.race([
+      task.execute(data),
+      new Promise<R>((_, reject) =>
+        setTimeout(
+          () => reject(new Error(`Task ${task.id} timed out after ${this.timeout}ms`)),
+          this.timeout,
+        ),
+      ),
+    ]);
+  }
+
+  private delay(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+
+export function parallel(options?: ParallelExecutorOptions): ParallelExecutor {
+  return new ParallelExecutor(options);
+}

package/src/shared/rspack-config/index.ts

@@ -0,0 +1 @@
+export * from "./rspack-config";

package/src/shared/rspack-config/rspack-config.ts

@@ -0,0 +1,157 @@
+import { resolve } from "path";
+import type { Configuration, RuleSetRule } from "@rspack/core";
+
+/**
+ * 插件构建配置选项
+ */
+export interface PluginBuildOptions {
+  /** 插件名称 */
+  name: string;
+  /** 插件根目录路径 */
+  path: string;
+  /** 入口文件路径，默认 ./src/index.ts */
+  entry?: string;
+  /** 输出目录，默认 dist */
+  outDir?: string;
+  /** 是否压缩，默认 false */
+  minimize?: boolean;
+  /** 额外的外部依赖 */
+  externals?: Configuration["externals"];
+  /** 额外的 resolve alias */
+  alias?: Record<string, string>;
+  /** 自定义 module rules */
+  rules?: RuleSetRule[];
+}
+
+/**
+ * 核心框架路径配置
+ */
+export interface CorePathOptions {
+  /** core 包根目录 */
+  coreRoot: string;
+}
+
+/**
+ * 默认的外部依赖列表
+ */
+export const DEFAULT_EXTERNALS: Configuration["externals"] = [
+  // Spaceflow 核心 - 运行时从 core 加载
+  { "@spaceflow/core": "module @spaceflow/core" },
+  // NestJS 相关 - 这些由 core 提供
+  { "@nestjs/common": "module @nestjs/common" },
+  { "@nestjs/config": "module @nestjs/config" },
+  { "@nestjs/core": "module @nestjs/core" },
+  { "nest-commander": "module nest-commander" },
+  { "reflect-metadata": "module reflect-metadata" },
+  // 排除所有 node_modules（除了相对路径和 src/ 别名）
+  /^(?!\.\/|\.\.\/|src\/)[^./]/,
+];
+
+/**
+ * 默认的 TypeScript 编译规则
+ */
+export const DEFAULT_TS_RULE: RuleSetRule = {
+  test: /\.ts$/,
+  exclude: /node_modules/,
+  loader: "builtin:swc-loader",
+  options: {
+    jsc: {
+      parser: {
+        syntax: "typescript",
+        decorators: true,
+      },
+      transform: {
+        legacyDecorator: true,
+        decoratorMetadata: true,
+      },
+      target: "es2022",
+    },
+  },
+};
+
+/**
+ * 创建插件构建的 rspack 配置
+ */
+export function createPluginConfig(
+  options: PluginBuildOptions,
+  coreOptions: CorePathOptions,
+): Configuration {
+  const {
+    name,
+    path: pluginPath,
+    entry = "./src/index.ts",
+    outDir = "dist",
+    minimize = false,
+    externals: customExternals = [],
+    alias: customAlias = {},
+    rules: customRules = [],
+  } = options;
+
+  const { coreRoot } = coreOptions;
+
+  // 合并外部依赖
+  const mergedExternals = Array.isArray(customExternals)
+    ? [...(DEFAULT_EXTERNALS as any[]), ...customExternals]
+    : [...(DEFAULT_EXTERNALS as any[]), customExternals];
+
+  // 合并 alias
+  const alias = {
+    "@spaceflow/core": resolve(coreRoot, "src", "index.ts"),
+    ...customAlias,
+  };
+
+  // 合并 rules
+  const rules = [DEFAULT_TS_RULE, ...customRules];
+
+  return {
+    name,
+    context: pluginPath,
+    optimization: {
+      minimize,
+    },
+    entry: {
+      index: entry,
+    },
+    target: "node",
+    mode: process.env.NODE_ENV === "production" ? "production" : "development",
+    output: {
+      filename: "[name].js",
+      path: resolve(pluginPath, outDir),
+      library: { type: "module" },
+      chunkFormat: "module",
+      clean: true,
+    },
+    experiments: {
+      outputModule: true,
+    },
+    externalsType: "module-import",
+    externals: mergedExternals,
+    resolve: {
+      extensions: [".ts", ".js"],
+      extensionAlias: {
+        ".js": [".ts", ".js"],
+      },
+      alias,
+    },
+    module: {
+      rules,
+    },
+  };
+}
+
+/**
+ * 创建多入口插件配置
+ */
+export function createMultiEntryPluginConfig(
+  options: Omit<PluginBuildOptions, "entry"> & {
+    entries: Record<string, string>;
+  },
+  coreOptions: CorePathOptions,
+): Configuration {
+  const config = createPluginConfig({ ...options, entry: "./src/index.ts" }, coreOptions);
+
+  return {
+    ...config,
+    entry: options.entries,
+  };
+}

package/src/shared/source-utils/index.ts

@@ -0,0 +1,130 @@
+/**
+ * Source 类型定义
+ */
+export type SourceType = "npm" | "git" | "local";
+
+/**
+ * 判断是否为 Git URL
+ * 支持: git@xxx.git, https://xxx.git, git+ssh://xxx, git+https://xxx
+ */
+export function isGitUrl(source: string): boolean {
+  return (
+    source.startsWith("git@") ||
+    source.startsWith("git+") ||
+    (source.startsWith("https://") && source.endsWith(".git")) ||
+    source.endsWith(".git")
+  );
+}
+
+/**
+ * 判断是否为本地路径
+ * 支持: ./path, ../path, /path, link:./path, skills/
+ */
+export function isLocalPath(source: string): boolean {
+  return (
+    source.startsWith("link:") ||
+    source.startsWith("./") ||
+    source.startsWith("../") ||
+    source.startsWith("/") ||
+    source.startsWith("skills/")
+  );
+}
+
+/**
+ * 获取 source 类型
+ */
+export function getSourceType(source: string): SourceType {
+  if (isLocalPath(source)) return "local";
+  if (isGitUrl(source)) return "git";
+  return "npm";
+}
+
+/**
+ * 规范化 source（移除 link: 前缀等）
+ */
+export function normalizeSource(source: string): string {
+  if (source.startsWith("link:")) {
+    return source.substring(5); // 移除 "link:" 前缀
+  }
+  return source;
+}
+
+/**
+ * 从 npm 包名中提取纯包名（去除版本号后缀）
+ * 例如: @spaceflow/review@0.10.0 → @spaceflow/review
+ *       some-package@1.2.3 → some-package
+ */
+export function extractNpmPackageName(source: string): string {
+  // 处理 scoped 包: @scope/name@version
+  if (source.startsWith("@")) {
+    const slashIndex = source.indexOf("/");
+    if (slashIndex !== -1) {
+      const afterSlash = source.substring(slashIndex + 1);
+      const atIndex = afterSlash.indexOf("@");
+      if (atIndex !== -1) {
+        return source.substring(0, slashIndex + 1 + atIndex);
+      }
+    }
+    return source;
+  }
+  // 处理普通包: name@version
+  const atIndex = source.indexOf("@");
+  if (atIndex !== -1) {
+    return source.substring(0, atIndex);
+  }
+  return source;
+}
+
+/**
+ * 从 source 提取名称
+ * npm 包: @scope/package -> package
+ * git URL: git@git.example.com:org/repo.git -> repo
+ * 本地路径: ./skills/publish -> publish
+ */
+export function extractName(source: string): string {
+  if (isLocalPath(source)) {
+    // 本地路径：取最后一个目录名
+    const parts = source.replace(/\/$/, "").split("/").filter(Boolean);
+    return parts[parts.length - 1] || "unknown";
+  } else if (isGitUrl(source)) {
+    let path = source;
+    path = path.replace(/\.git$/, "");
+    path = path.replace(/^git@[^:]+:/, "");
+    path = path.replace(/^https?:\/\/[^/]+\//, "");
+    const parts = path.split("/").filter(Boolean);
+    return parts[parts.length - 1] || "unknown";
+  } else {
+    // npm 包名：先去除版本号后缀，再提取名称
+    // @spaceflow/review@0.10.0 → @spaceflow/review → review
+    const packageName = extractNpmPackageName(source);
+    const parts = packageName.split("/");
+    const lastPart = parts[parts.length - 1];
+    // 移除 spaceflow-plugin- 或 plugin- 前缀
+    return lastPart.replace(/^spaceflow-plugin-/, "").replace(/^plugin-/, "");
+  }
+}
+
+/**
+ * 构建 git 仓库的 package spec（用于 pnpm add）
+ * git@xxx.git -> git+ssh://git@xxx.git
+ * https://xxx.git -> git+https://xxx.git
+ */
+export function buildGitPackageSpec(source: string, ref?: string): string {
+  let spec: string;
+  if (source.startsWith("git@")) {
+    // SSH 格式: git@host:org/repo.git -> git+ssh://git@host/org/repo.git
+    const sshUrl = source.replace(":", "/").replace("git@", "git+ssh://git@");
+    spec = sshUrl;
+  } else if (source.startsWith("https://")) {
+    spec = `git+${source}`;
+  } else {
+    spec = source;
+  }
+
+  // 添加 ref（分支/tag/commit）
+  if (ref) {
+    spec += `#${ref}`;
+  }
+
+  return spec;
+}