@spaceflow/publish 0.21.1

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@spaceflow/publish",
+  "version": "0.21.1",
+  "description": "Spaceflow CI 发布插件，用于在发布流程中锁定/解锁分支",
+  "license": "MIT",
+  "author": "Lydanne",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Lydanne/spaceflow.git",
+    "directory": "extensions/publish"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "dependencies": {
+    "@release-it/conventional-changelog": "^10.0.4",
+    "release-it": "^19.2.2",
+    "release-it-gitea": "^1.8.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.0",
+    "@spaceflow/cli": "0.19.2"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^11.0.1",
+    "@nestjs/config": "^4.0.2",
+    "nest-commander": "^3.20.1",
+    "@spaceflow/core": "0.1.2"
+  },
+  "spaceflow": {
+    "type": "flow",
+    "entry": "."
+  },
+  "scripts": {
+    "build": "spaceflow build",
+    "dev": "spaceflow dev"
+  }
+}

package/src/index.ts

@@ -0,0 +1,30 @@
+import "./locales";
+import { SpaceflowExtension, SpaceflowExtensionMetadata, t } from "@spaceflow/core";
+import { PublishModule } from "./publish.module";
+import { publishSchema } from "./publish.config";
+/** publish Extension 元数据 */
+export const publishMetadata: SpaceflowExtensionMetadata = {
+  name: "publish",
+  commands: ["publish"],
+  configKey: "publish",
+  configSchema: () => publishSchema,
+  version: "1.0.0",
+  description: t("publish:extensionDescription"),
+};
+
+export class PublishExtension implements SpaceflowExtension {
+  getMetadata(): SpaceflowExtensionMetadata {
+    return publishMetadata;
+  }
+
+  getModule() {
+    return PublishModule;
+  }
+}
+
+export default PublishExtension;
+
+export * from "./publish.command";
+export * from "./publish.service";
+export * from "./publish.module";
+export * from "./monorepo.service";

package/src/locales/en/publish.json

@@ -0,0 +1,8 @@
+{
+  "description": "CI publish command for branch lock/unlock during release",
+  "options.prerelease": "Prerelease tag, e.g. rc, beta, alpha, nightly",
+  "options.rehearsal": "Rehearsal mode: execute hooks but no file/git changes, sets PUBLISH_REHEARSAL=true",
+  "rehearsalMode": "🎭 REHEARSAL mode: hooks will execute, but no file/git changes",
+  "dryRunMode": "🔍 DRY-RUN mode: no actual execution",
+  "extensionDescription": "CI publish command for branch lock/unlock during release"
+}

package/src/locales/index.ts

@@ -0,0 +1,11 @@
+import { addLocaleResources } from "@spaceflow/core";
+import zhCN from "./zh-cn/publish.json";
+import en from "./en/publish.json";
+
+/** publish 命令 i18n 资源 */
+export const publishLocales: Record<string, Record<string, string>> = {
+  "zh-CN": zhCN,
+  en,
+};
+
+addLocaleResources("publish", publishLocales);

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

@@ -0,0 +1,8 @@
+{
+  "description": "CI 发布命令，用于在发布流程中锁定/解锁分支",
+  "options.prerelease": "预发布标签，如 rc、beta、alpha、nightly 等",
+  "options.rehearsal": "预演模式：执行 hooks 但不修改文件/git，设置 PUBLISH_REHEARSAL=true 环境变量",
+  "rehearsalMode": "🎭 REHEARSAL mode: hooks will execute, but no file/git changes",
+  "dryRunMode": "🔍 DRY-RUN mode: no actual execution",
+  "extensionDescription": "CI 发布命令，用于在发布流程中锁定/解锁分支"
+}

package/src/monorepo.service.ts

@@ -0,0 +1,376 @@
+import { Injectable } from "@nestjs/common";
+import { execSync } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+
+export interface PackageInfo {
+  /** 包目录路径（相对于项目根目录） */
+  dir: string;
+  /** 包名称（从 package.json 读取） */
+  name: string;
+  /** 包版本 */
+  version: string;
+  /** workspace 依赖的包名列表 */
+  workspaceDeps: string[];
+}
+
+export interface MonorepoAnalysisResult {
+  /** 所有变更的包 */
+  changedPackages: PackageInfo[];
+  /** 需要发布的包（包含依赖变更的包），按拓扑排序 */
+  packagesToPublish: PackageInfo[];
+}
+
+@Injectable()
+export class MonorepoService {
+  private readonly cwd: string;
+
+  constructor() {
+    this.cwd = process.cwd();
+  }
+
+  /**
+   * 分析 monorepo 变更，返回需要发布的包列表（拓扑排序后）
+   * @param dryRun 是否为 dry-run 模式
+   * @param propagateDeps 是否传递依赖变更（依赖的包变更时，依赖方也发布）
+   */
+  async analyze(dryRun: boolean, propagateDeps = true): Promise<MonorepoAnalysisResult> {
+    const workspacePackages = this.getWorkspacePackages();
+    const allPackages = this.getAllPackageInfos(workspacePackages);
+
+    // 为每个包单独检测变更（基于各自的最新 tag）
+    const changedPackages = this.getChangedPackages(allPackages, dryRun);
+
+    if (dryRun) {
+      console.log(`📦 直接变更的包: ${changedPackages.map((p) => p.name).join(", ") || "无"}`);
+    }
+
+    // 计算依赖传递，找出所有需要发布的包
+    const packagesToPublish = propagateDeps
+      ? this.calculateAffectedPackages(changedPackages, allPackages)
+      : changedPackages;
+
+    if (dryRun) {
+      console.log(
+        `🔄 需要发布的包（含依赖传递）: ${packagesToPublish.map((p) => p.name).join(", ") || "无"}`,
+      );
+    }
+
+    // 拓扑排序
+    const sortedPackages = this.topologicalSort(packagesToPublish, allPackages);
+
+    if (dryRun) {
+      console.log(`📋 发布顺序: ${sortedPackages.map((p) => p.name).join(" -> ") || "无"}`);
+    }
+
+    return {
+      changedPackages,
+      packagesToPublish: sortedPackages,
+    };
+  }
+
+  /**
+   * 简单解析 pnpm-workspace.yaml（只提取 packages 数组）
+   */
+  private parseSimpleYaml(content: string): { packages?: string[] } {
+    const packages: string[] = [];
+    const lines = content.split("\n");
+    let inPackages = false;
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed === "packages:") {
+        inPackages = true;
+        continue;
+      }
+      if (inPackages) {
+        if (trimmed.startsWith("- ")) {
+          // 提取包路径，去除引号
+          let pkg = trimmed.slice(2).trim();
+          pkg = pkg.replace(/^["']|["']$/g, "");
+          packages.push(pkg);
+        } else if (trimmed && !trimmed.startsWith("#") && !trimmed.startsWith("-")) {
+          // 遇到新的顶级 key，停止解析
+          break;
+        }
+      }
+    }
+
+    return { packages: packages.length > 0 ? packages : undefined };
+  }
+
+  /**
+   * 从 pnpm-workspace.yaml 读取 workspace 包配置
+   */
+  private getWorkspacePackages(): string[] {
+    const workspaceFile = join(this.cwd, "pnpm-workspace.yaml");
+    if (!existsSync(workspaceFile)) {
+      throw new Error("未找到 pnpm-workspace.yaml 文件");
+    }
+
+    const content = readFileSync(workspaceFile, "utf-8");
+    const config = this.parseSimpleYaml(content);
+
+    if (!config.packages || !Array.isArray(config.packages)) {
+      throw new Error("pnpm-workspace.yaml 中未配置 packages");
+    }
+
+    return config.packages;
+  }
+
+  /**
+   * 展开 workspace 包配置，获取所有实际的包目录
+   */
+  private expandWorkspacePatterns(patterns: string[]): string[] {
+    const dirs: string[] = [];
+
+    for (const pattern of patterns) {
+      if (pattern.includes("*")) {
+        // 使用 glob 展开，这里简化处理，只支持 extensions/* 这种模式
+        const baseDir = pattern.replace("/*", "");
+        const basePath = join(this.cwd, baseDir);
+        if (existsSync(basePath)) {
+          const { readdirSync, statSync } = require("fs");
+          const entries = readdirSync(basePath) as string[];
+          for (const entry of entries) {
+            const entryPath = join(basePath, entry);
+            if (statSync(entryPath).isDirectory()) {
+              const pkgJson = join(entryPath, "package.json");
+              if (existsSync(pkgJson)) {
+                dirs.push(join(baseDir, entry));
+              }
+            }
+          }
+        }
+      } else {
+        // 直接目录
+        const pkgJson = join(this.cwd, pattern, "package.json");
+        if (existsSync(pkgJson)) {
+          dirs.push(pattern);
+        }
+      }
+    }
+
+    return dirs;
+  }
+
+  /**
+   * 获取所有包的详细信息（排除私有包）
+   */
+  private getAllPackageInfos(patterns: string[]): PackageInfo[] {
+    const dirs = this.expandWorkspacePatterns(patterns);
+    const packages: PackageInfo[] = [];
+
+    for (const dir of dirs) {
+      const pkgJsonPath = join(this.cwd, dir, "package.json");
+      if (!existsSync(pkgJsonPath)) continue;
+
+      const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+
+      // 跳过私有包
+      if (pkgJson.private === true) continue;
+
+      const workspaceDeps = this.extractWorkspaceDeps(pkgJson);
+
+      packages.push({
+        dir,
+        name: pkgJson.name,
+        version: pkgJson.version,
+        workspaceDeps,
+      });
+    }
+
+    return packages;
+  }
+
+  /**
+   * 提取包的 workspace 依赖
+   */
+  private extractWorkspaceDeps(pkgJson: Record<string, unknown>): string[] {
+    const deps: string[] = [];
+    const allDeps = {
+      ...(pkgJson.dependencies as Record<string, string> | undefined),
+      ...(pkgJson.devDependencies as Record<string, string> | undefined),
+      ...(pkgJson.peerDependencies as Record<string, string> | undefined),
+    };
+
+    for (const [name, version] of Object.entries(allDeps)) {
+      if (version && (version.startsWith("workspace:") || version === "*")) {
+        deps.push(name);
+      }
+    }
+
+    return deps;
+  }
+
+  /**
+   * 检测每个包的变更（基于各自的最新 tag）
+   */
+  private getChangedPackages(allPackages: PackageInfo[], dryRun: boolean): PackageInfo[] {
+    const changedPackages: PackageInfo[] = [];
+
+    for (const pkg of allPackages) {
+      const hasChanges = this.hasPackageChanges(pkg);
+      if (hasChanges) {
+        changedPackages.push(pkg);
+      }
+      if (dryRun) {
+        console.log(`  ${hasChanges ? "✅" : "⭕"} ${pkg.name}`);
+      }
+    }
+
+    return changedPackages;
+  }
+
+  /**
+   * 检测单个包是否有变更（基于该包的最新 tag）
+   */
+  private hasPackageChanges(pkg: PackageInfo): boolean {
+    try {
+      // 获取该包的最新 tag（格式: @scope/pkg@version 或 pkg@version）
+      const tagPattern = `${pkg.name}@*`;
+      const latestTag = execSync(
+        `git describe --tags --abbrev=0 --match "${tagPattern}" 2>/dev/null || echo ''`,
+        { cwd: this.cwd, encoding: "utf-8" },
+      ).trim();
+
+      if (!latestTag) {
+        // 没有 tag，说明是新包，需要发布
+        console.log(`📌 ${pkg.name}: 无 tag，需要发布`);
+        return true;
+      }
+
+      // 检测从该 tag 到 HEAD，该包目录下是否有变更
+      const diffOutput = execSync(`git diff --name-only "${latestTag}"..HEAD -- "${pkg.dir}"`, {
+        cwd: this.cwd,
+        encoding: "utf-8",
+      }).trim();
+
+      const hasChanges = diffOutput.length > 0;
+      if (hasChanges) {
+        console.log(`📌 ${pkg.name}: ${latestTag} -> HEAD 有变更`);
+        console.log(
+          `    变更文件: ${diffOutput.split("\n").slice(0, 3).join(", ")}${diffOutput.split("\n").length > 3 ? "..." : ""}`,
+        );
+      }
+      return hasChanges;
+    } catch (error) {
+      // 出错时保守处理，认为有变更
+      console.log(`📌 ${pkg.name}: 检测出错，保守处理为有变更`);
+      console.log(`    错误: ${error instanceof Error ? error.message : error}`);
+      return true;
+    }
+  }
+
+  /**
+   * 将变更文件映射到包目录
+   */
+  private mapFilesToPackages(files: string[], patterns: string[]): Set<string> {
+    const packageDirs = this.expandWorkspacePatterns(patterns);
+    const changedPackages = new Set<string>();
+
+    for (const file of files) {
+      for (const dir of packageDirs) {
+        if (file.startsWith(dir + "/") || file === dir) {
+          changedPackages.add(dir);
+          break;
+        }
+      }
+    }
+
+    return changedPackages;
+  }
+
+  /**
+   * 计算受影响的包（包含依赖传递）
+   */
+  private calculateAffectedPackages(
+    changedPackages: PackageInfo[],
+    allPackages: PackageInfo[],
+  ): PackageInfo[] {
+    const changedNames = new Set(changedPackages.map((p) => p.name));
+    const affectedNames = new Set(changedNames);
+
+    // 构建反向依赖图：谁依赖了我
+    const reverseDeps = new Map<string, Set<string>>();
+    for (const pkg of allPackages) {
+      for (const dep of pkg.workspaceDeps) {
+        if (!reverseDeps.has(dep)) {
+          reverseDeps.set(dep, new Set());
+        }
+        reverseDeps.get(dep)!.add(pkg.name);
+      }
+    }
+
+    // BFS 传递依赖
+    const queue = [...changedNames];
+    while (queue.length > 0) {
+      const current = queue.shift()!;
+      const dependents = reverseDeps.get(current);
+      if (dependents) {
+        for (const dependent of dependents) {
+          if (!affectedNames.has(dependent)) {
+            affectedNames.add(dependent);
+            queue.push(dependent);
+          }
+        }
+      }
+    }
+
+    return allPackages.filter((p) => affectedNames.has(p.name));
+  }
+
+  /**
+   * 拓扑排序：被依赖的包先发布
+   */
+  private topologicalSort(packages: PackageInfo[], _allPackages: PackageInfo[]): PackageInfo[] {
+    const packageNames = new Set(packages.map((p) => p.name));
+    const nameToPackage = new Map(packages.map((p) => [p.name, p]));
+
+    // 构建依赖图（只考虑待发布包之间的依赖）
+    const inDegree = new Map<string, number>();
+    const graph = new Map<string, string[]>();
+
+    for (const pkg of packages) {
+      inDegree.set(pkg.name, 0);
+      graph.set(pkg.name, []);
+    }
+
+    for (const pkg of packages) {
+      for (const dep of pkg.workspaceDeps) {
+        if (packageNames.has(dep)) {
+          graph.get(dep)!.push(pkg.name);
+          inDegree.set(pkg.name, (inDegree.get(pkg.name) || 0) + 1);
+        }
+      }
+    }
+
+    // Kahn's algorithm
+    const queue: string[] = [];
+    for (const [name, degree] of inDegree) {
+      if (degree === 0) {
+        queue.push(name);
+      }
+    }
+
+    const sorted: PackageInfo[] = [];
+    while (queue.length > 0) {
+      const current = queue.shift()!;
+      sorted.push(nameToPackage.get(current)!);
+
+      for (const neighbor of graph.get(current) || []) {
+        const newDegree = (inDegree.get(neighbor) || 0) - 1;
+        inDegree.set(neighbor, newDegree);
+        if (newDegree === 0) {
+          queue.push(neighbor);
+        }
+      }
+    }
+
+    if (sorted.length !== packages.length) {
+      throw new Error("检测到循环依赖，无法确定发布顺序");
+    }
+
+    return sorted;
+  }
+}

package/src/publish.command.ts

@@ -0,0 +1,71 @@
+import { Command, CommandRunner, Option } from "nest-commander";
+import { t } from "@spaceflow/core";
+import { PublishService } from "./publish.service";
+
+export interface PublishOptions {
+  dryRun: boolean;
+  ci: boolean;
+  prerelease?: string;
+  /** 预演模式：执行 hooks 但不修改文件/git */
+  rehearsal: boolean;
+}
+
+@Command({
+  name: "publish",
+  description: t("publish:description"),
+})
+export class PublishCommand extends CommandRunner {
+  constructor(protected readonly publishService: PublishService) {
+    super();
+  }
+
+  async run(_passedParams: string[], options: PublishOptions): Promise<void> {
+    if (options.rehearsal) {
+      console.log(t("publish:rehearsalMode"));
+    } else if (options.dryRun) {
+      console.log(t("publish:dryRunMode"));
+    }
+
+    try {
+      const context = this.publishService.getContextFromEnv(options);
+      await this.publishService.execute(context);
+    } catch (error) {
+      console.error(
+        t("common.executionFailed", { error: error instanceof Error ? error.message : error }),
+      );
+      process.exit(1);
+    }
+  }
+
+  @Option({
+    flags: "-d, --dry-run",
+    description: t("common.options.dryRun"),
+  })
+  parseDryRun(val: boolean): boolean {
+    return val;
+  }
+
+  @Option({
+    flags: "-c, --ci",
+    description: t("common.options.ci"),
+  })
+  parseCi(val: boolean): boolean {
+    return val;
+  }
+
+  @Option({
+    flags: "-p, --prerelease <tag>",
+    description: t("publish:options.prerelease"),
+  })
+  parsePrerelease(val: string): string {
+    return val;
+  }
+
+  @Option({
+    flags: "-r, --rehearsal",
+    description: t("publish:options.rehearsal"),
+  })
+  parseRehearsal(val: boolean): boolean {
+    return val;
+  }
+}

package/src/publish.config.ts

@@ -0,0 +1,90 @@
+import { z } from "@spaceflow/core";
+
+/** publish 命令配置 schema */
+export const publishSchema = z.object({
+  /** monorepo 发布模式配置 */
+  monorepo: z
+    .object({
+      /** 是否启用 monorepo 发布模式 */
+      enabled: z.boolean().default(false),
+      /** 是否传递依赖变更（依赖的包变更时，依赖方也发布） */
+      propagateDeps: z.boolean().default(true),
+    })
+    .optional(),
+  changelog: z
+    .object({
+      /** changelog 文件输出目录 */
+      infileDir: z.string().default(".").optional(),
+      preset: z
+        .object({
+          /** preset 名称，默认 conventionalcommits */
+          name: z.string().default("conventionalcommits").optional(),
+          /** commit type 到 section 的映射 */
+          type: z
+            .array(
+              z.object({
+                type: z.string(),
+                section: z.string(),
+              }),
+            )
+            .default([]),
+        })
+        .optional(),
+    })
+    .optional(),
+  /** npm 发布配置 */
+  npm: z
+    .object({
+      /** 是否发布到 npm registry */
+      publish: z.boolean().default(false),
+      /** 包管理器，npm 或 pnpm */
+      packageManager: z.enum(["npm", "pnpm"]).default("npm"),
+      /** npm registry 地址 */
+      registry: z.string().optional(),
+      /** npm tag，如 latest、beta、next */
+      tag: z.string().default("latest"),
+      /** 是否忽略 package.json 中的版本号 */
+      ignoreVersion: z.boolean().default(true),
+      /** npm version 命令额外参数 */
+      versionArgs: z.array(z.string()).default(["--workspaces false"]),
+      /** npm/pnpm publish 命令额外参数 */
+      publishArgs: z.array(z.string()).default([]),
+    })
+    .optional(),
+  release: z
+    .object({
+      host: z.string().default("localhost"),
+      assetSourcemap: z
+        .object({
+          path: z.string(),
+          name: z.string(),
+        })
+        .optional(),
+      assets: z
+        .array(
+          z.object({
+            path: z.string(),
+            name: z.string(),
+            type: z.string(),
+          }),
+        )
+        .default([]),
+    })
+    .optional(),
+  /** git 配置 */
+  git: z
+    .object({
+      /** 允许发布的分支列表 */
+      requireBranch: z.array(z.string()).default(["main", "dev", "develop"]),
+      /** 分支锁定时允许推送的用户名白名单（如 CI 机器人） */
+      pushWhitelistUsernames: z.array(z.string()).default([]),
+      /** 是否在发布时锁定分支 */
+      lockBranch: z.boolean().default(true),
+    })
+    .optional(),
+  /** release-it hooks 配置，如 before:bump, after:bump 等 */
+  hooks: z.record(z.string(), z.union([z.string(), z.array(z.string())])).optional(),
+});
+
+/** publish 配置类型（从 schema 推导） */
+export type PublishConfig = z.infer<typeof publishSchema>;

package/src/publish.module.ts

@@ -0,0 +1,12 @@
+import { Module } from "@nestjs/common";
+import { ConfigModule } from "@nestjs/config";
+import { GitProviderModule, ConfigReaderModule, ciConfig } from "@spaceflow/core";
+import { PublishCommand } from "./publish.command";
+import { PublishService } from "./publish.service";
+import { MonorepoService } from "./monorepo.service";
+
+@Module({
+  imports: [ConfigModule.forFeature(ciConfig), GitProviderModule.forFeature(), ConfigReaderModule],
+  providers: [PublishCommand, PublishService, MonorepoService],
+})
+export class PublishModule {}