@coze-arch/rush-publish-plugin 0.0.3 → 0.0.4

package/lib/index.js

@@ -1,28 +1,1631 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-const commander_1 = require("commander");
-const release_1 = require("./action/release");
-const publish_1 = require("./action/publish");
-const change_1 = require("./action/change");
+'use strict';
+
+var path = require('path');
+var fs$1 = require('fs');
+var commander = require('commander');
+var shelljs = require('shelljs');
+var fs = require('fs/promises');
+var rushSdk = require('@rushstack/rush-sdk');
+var crypto = require('crypto');
+var semver = require('semver');
+var chalk = require('chalk');
+var prompts = require('@inquirer/prompts');
+var dayjs = require('dayjs');
+var ChangeFile = require('@rushstack/rush-sdk/lib/api/ChangeFile');
+
+/**
+ * 日志工具
+ *
+ * 提供统一的日志输出接口，支持不同级别的日志，包括彩色输出
+ */
+
+// 日志级别枚举
+var LogLevel; (function (LogLevel) {
+  const DEBUG = 0; LogLevel[LogLevel["DEBUG"] = DEBUG] = "DEBUG";
+  const INFO = 1; LogLevel[LogLevel["INFO"] = INFO] = "INFO";
+  const WARN = 2; LogLevel[LogLevel["WARN"] = WARN] = "WARN";
+  const ERROR = 3; LogLevel[LogLevel["ERROR"] = ERROR] = "ERROR";
+  const SUCCESS = 4; LogLevel[LogLevel["SUCCESS"] = SUCCESS] = "SUCCESS";
+  const NONE = 5; LogLevel[LogLevel["NONE"] = NONE] = "NONE"; // 用于完全禁用日志
+})(LogLevel || (LogLevel = {}));
+
+// ANSI 颜色代码
+const colors = {
+  reset: '\x1b[0m',
+  debug: '\x1b[36m', // 青色
+  info: '\x1b[34m', // 蓝色
+  warn: '\x1b[33m', // 黄色
+  error: '\x1b[31m', // 红色
+  success: '\x1b[32m', // 绿色
+};
+
+// 默认日志级别
+let currentLogLevel = LogLevel.INFO;
+
+/**
+ * 基础日志函数
+ * @param level 日志级别
+ * @param message 日志消息
+ * @param showPrefix 是否显示前缀，默认为 true
+ */
+function log(level, message, showPrefix = true) {
+  if (level < currentLogLevel) {
+    return;
+  }
+
+  let prefix = '';
+  let color = '';
+
+  switch (level) {
+    case LogLevel.DEBUG: {
+      prefix = '[DEBUG]';
+      color = colors.debug;
+      break;
+    }
+    case LogLevel.WARN: {
+      prefix = '[WARN]';
+      color = colors.warn;
+      break;
+    }
+    case LogLevel.ERROR: {
+      prefix = '[ERROR]';
+      color = colors.error;
+      break;
+    }
+    case LogLevel.SUCCESS: {
+      prefix = '[SUCCESS]';
+      color = colors.success;
+      break;
+    }
+    case LogLevel.INFO:
+    default: {
+      prefix = '[INFO]';
+      color = colors.info;
+      break;
+    }
+  }
+
+  // 格式化日志前缀
+  const formattedPrefix = showPrefix ? `${color}${prefix}${colors.reset} ` : '';
+
+  // 输出日志
+  console.log(`${formattedPrefix}${message}`);
+}
+
+/**
+ * 导出的日志工具
+ */
+const logger = {
+  /**
+   * 调试日志
+   * @param message 日志消息
+   * @param showPrefix 是否显示前缀，默认为 true
+   */
+  debug(message, showPrefix = true) {
+    log(LogLevel.DEBUG, message, showPrefix);
+  },
+
+  /**
+   * 信息日志
+   * @param message 日志消息
+   * @param showPrefix 是否显示前缀，默认为 true
+   */
+  info(message, showPrefix = true) {
+    log(LogLevel.INFO, message, showPrefix);
+  },
+
+  /**
+   * 警告日志
+   * @param message 日志消息
+   * @param showPrefix 是否显示前缀，默认为 true
+   */
+  warn(message, showPrefix = true) {
+    log(LogLevel.WARN, message, showPrefix);
+  },
+
+  /**
+   * 错误日志
+   * @param message 日志消息
+   * @param showPrefix 是否显示前缀，默认为 true
+   */
+  error(message, showPrefix = true) {
+    log(LogLevel.ERROR, message, showPrefix);
+  },
+
+  /**
+   * 成功日志
+   * @param message 日志消息
+   * @param showPrefix 是否显示前缀，默认为 true
+   */
+  success(message, showPrefix = true) {
+    log(LogLevel.SUCCESS, message, showPrefix);
+  },
+};
+
+class ExecError extends Error {
+  
+  
+  
+  constructor(result) {
+    super(result.stderr || result.stdout);
+    this.code = result.code;
+    this.stderr = result.stderr;
+    this.stdout = result.stdout;
+  }
+}
+
+const exec = (
+  cmd,
+  options = { silent: true },
+) =>
+  new Promise((r, j) => {
+    shelljs.exec(cmd, options, (code, stdout, stderr) => {
+      if (code === 0) {
+        r({ code, stdout, stderr });
+      } else {
+        j(new ExecError({ code, stderr, stdout }));
+      }
+    });
+  });
+
+const serializeFilesName = (output) =>
+  output
+    .split('\n')
+    .map(line => {
+      if (line) {
+        const trimmedLine = line.trim();
+        return trimmedLine;
+      }
+      return '';
+    })
+    .filter(line => line && line.length > 0);
+
+const getChangedFilesFromCached = async () => {
+  const output = await exec('git diff --name-only --diff-filter=ACMR --cached');
+  if (!output) {
+    return [];
+  }
+  return serializeFilesName(output.stdout);
+};
+
+/**
+ * 获取当前分支名称
+ * @returns string
+ */
+const getCurrentBranchName = async () => {
+  const { stdout } = await exec('git rev-parse --abbrev-ref HEAD');
+  return stdout.trim();
+};
+
+const isMainBranch = async () => {
+  const currentBranchName = await getCurrentBranchName();
+  return currentBranchName === 'main';
+};
+
+const getChangedFiles = async () => {
+  const output = await exec('git diff --name-only --diff-filter=ACMR');
+  return serializeFilesName(output.stdout);
+};
+
+/**
+ * 确保没有未提交的变更
+ */
+const ensureNotUncommittedChanges = async () => {
+  const changedFiles = (
+    await Promise.all([getChangedFilesFromCached(), getChangedFiles()])
+  ).flat();
+  if (changedFiles.length > 0) {
+    throw new Error(
+      'There are uncommitted changes in the working tree, please commit them first.',
+    );
+  }
+  return true;
+};
+
+/**
+ * 获取当前 Git 仓库设置的 origin 远程源地址
+ * @param cwd 当前工作目录
+ * @returns origin 远程源地址
+ */
+const getCurrentOrigin = async (
+  cwd = process.cwd(),
+) => {
+  try {
+    const { stdout } = await exec('git remote get-url origin', { cwd });
+    return stdout.trim();
+  } catch (error) {
+    return undefined;
+  }
+};
+
+const readJsonFile = async ( path) => {
+  const content = await fs.readFile(path, 'utf8');
+  return JSON.parse(content) ;
+};
+
+const writeJsonFile = async (path, data) => {
+  await fs.writeFile(path, JSON.stringify(data, null, 2), 'utf8');
+};
+
+const isFileExists = async (path) =>
+  fs
+    .access(path)
+    .then(() => true)
+    .catch(() => false);
+
+const isDirExists = async (path) =>
+  fs
+    .access(path)
+    .then(() => true)
+    .catch(() => false);
+
+const getRushConfiguration = (() => {
+  let rushConfiguration = null;
+  return (useCache = true) => {
+    if (!useCache) {
+      rushConfiguration = null;
+    }
+    return (rushConfiguration ||= rushSdk.RushConfiguration.loadFromDefaultLocation({
+      startingFolder: process.cwd(),
+    }));
+  };
+})();
+
+/**
+ * 更新依赖版本
+ */
+const updateDependencyVersions = async (
+  packageJson,
+) => {
+  const rushConfiguration = getRushConfiguration();
+  const { dependencies } = packageJson;
+  if (dependencies) {
+    for (const [dep, ver] of Object.entries(dependencies)) {
+      const project = rushConfiguration.getProjectByName(dep);
+      if (/^workspace:/.test(ver) && project) {
+        dependencies[dep] = project.packageJson.version;
+      }
+    }
+  }
+  return Promise.resolve(packageJson);
+};
+
+const applyCozePublishConfig = async (
+  packageJson,
+) => {
+  const { cozePublishConfig } = packageJson;
+  if (cozePublishConfig) {
+    const keys = Object.keys(cozePublishConfig);
+    for (const key of keys) {
+      packageJson[key] = cozePublishConfig[key];
+    }
+  }
+  return Promise.resolve(packageJson);
+};
+
+const applyPublishConfig = async (project) => {
+  const jobs = [
+    updateDependencyVersions,
+    applyCozePublishConfig,
+  ];
+  const packageJsonPath = path.join(project.projectFolder, 'package.json');
+  let packageJson = await readJsonFile(packageJsonPath);
+  for (const job of jobs) {
+    packageJson = await job(packageJson);
+  }
+  await writeJsonFile(packageJsonPath, packageJson);
+};
+
+/**
+ * 发布包
+ */
+const publishPackage = async (
+  project,
+  releaseOptions,
+) => {
+  const { dryRun, registry } = releaseOptions;
+  const token = process.env.NPM_AUTH_TOKEN;
+  const { version } = project.packageJson;
+  const tag = version.includes('alpha')
+    ? 'alpha'
+    : version.includes('beta')
+      ? 'beta'
+      : 'latest';
+  const args = [`NPM_AUTH_TOKEN=${token}`, 'npm', 'publish', `--tag ${tag}`];
+  if (dryRun) {
+    args.push('--dry-run');
+  }
+  if (registry) {
+    args.push(`--registry=${registry}`);
+  }
+
+  await exec(args.join(' '), {
+    cwd: project.projectFolder,
+  });
+
+  logger.success(`- Published ${project.packageName}@${version}`);
+};
+
+const releasePackage = async (
+  releaseManifest,
+  releaseOptions,
+) => {
+  const { project } = releaseManifest;
+  const { packageName } = project;
+  logger.info(`Preparing release for package: ${packageName}`);
+  await applyPublishConfig(project);
+  await publishPackage(project, releaseOptions);
+};
+
+const buildProjects = async (releaseManifests) => {
+  const packageNames = releaseManifests.map(
+    manifest => manifest.project.packageName,
+  );
+  const buildCommands = `rush build ${packageNames.map(name => `--to ${name}`).join(' ')}`;
+  await exec(buildCommands);
+};
+
+const releasePackages = async (
+  releaseManifests,
+  releaseOptions,
+) => {
+  await buildProjects(releaseManifests);
+  await Promise.all(
+    releaseManifests.map(async manifest => {
+      await releasePackage(manifest, releaseOptions);
+    }),
+  );
+};
+
+var ReleaseType; (function (ReleaseType) {
+  const ALPHA = 'alpha'; ReleaseType["ALPHA"] = ALPHA;
+  const BETA = 'beta'; ReleaseType["BETA"] = BETA;
+  const LATEST = 'latest'; ReleaseType["LATEST"] = LATEST;
+})(ReleaseType || (ReleaseType = {}));
+
+const calReleaseType = (version) => {
+  const tag = version.includes('alpha')
+    ? ReleaseType.ALPHA
+    : version.includes('beta')
+      ? ReleaseType.BETA
+      : ReleaseType.LATEST;
+  return tag;
+};
+
+const calReleasePlan = (releaseManifests) => {
+  const plan = releaseManifests.map(r => calReleaseType(r.version));
+  if (plan.some(p => p === ReleaseType.LATEST)) {
+    return ReleaseType.LATEST;
+  }
+  if (plan.some(p => p === ReleaseType.BETA)) {
+    return ReleaseType.BETA;
+  }
+  return ReleaseType.ALPHA;
+};
+
+const checkReleasePlan = (
+  releaseManifests,
+  branchName,
+) => {
+  const releasePlan = calReleasePlan(releaseManifests);
+  if (
+    releasePlan === ReleaseType.LATEST &&
+    !['main', 'feat/auto-publish'].includes(branchName)
+  ) {
+    throw new Error('For LATEST release, should be on main branch only.');
+  }
+  return true;
+};
+
+/**
+ * 构建发布依赖树
+ */
+function buildReleaseManifest(
+  packages,
+) {
+  const rushConfiguration = getRushConfiguration();
+  return packages.map(pkg => {
+    const project = rushConfiguration.getProjectByName(pkg.packageName);
+    if (!project) {
+      throw new Error(`Cannot find project: ${pkg.packageName}`);
+    }
+    return { project, version: project.packageJson.version };
+  });
+}
+
+/**
+ * 从 git tag 中解析需要发布的包信息
+ */
+const getPackagesToPublish = async (
+  commit,
+) => {
+  // 获取指定 commit 的所有 tag
+  const { stdout } = await exec(`git tag --points-at ${commit}`);
+  const tags = stdout.split('\n').filter(Boolean);
+
+  // 解析符合 v/{packagename}@{version} 格式的 tag
+  const packagePattern = /^v\/(.+)@(.+)$/;
+  const packages = [];
+
+  for (const tag of tags) {
+    const match = tag.match(packagePattern);
+    if (match) {
+      const [, packageName, version] = match;
+      packages.push({
+        packageName,
+        version,
+      });
+    }
+  }
+
+  return packages;
+};
+
+async function release(options) {
+  const { commit, dryRun = false, registry } = options;
+
+  // 1. 获取需要发布的包列表
+  const packagesToPublish = await getPackagesToPublish(commit);
+  if (packagesToPublish.length === 0) {
+    logger.warn('No packages to publish');
+    return;
+  }
+
+  // 2. 构建发布依赖树
+  const releaseManifests = buildReleaseManifest(packagesToPublish);
+  logger.info('Release manifests:');
+  logger.info(
+    releaseManifests
+      .map(manifest => `${manifest.project.packageName}@${manifest.version}`)
+      .join(', '),
+    false,
+  );
+  const branchName = await getCurrentBranchName();
+  checkReleasePlan(releaseManifests, branchName);
+  await exec(`git checkout ${commit}`);
+
+  await releasePackages(releaseManifests, { dryRun, registry });
+  logger.success('All packages published successfully!');
+  logger.success(
+    releaseManifests
+      .map(manifest => `- ${manifest.project.packageName}@${manifest.version}`)
+      .join('\n'),
+    false,
+  );
+}
+
+const installAction$2 = (program) => {
+  program
+    .command('release')
+    .description('Release packages based on git tags.')
+    .requiredOption('--commit <string>', '需要执行发布的 commit id')
+    .option('--dry-run', '是否只执行不真实发布', false)
+    .option(
+      '-r, --registry <string>',
+      '发布到的 registry',
+      'https://registry.npmjs.org',
+    )
+    .action(async (options) => {
+      try {
+        if (!options.commit) {
+          throw new Error('请提供需要发布的 commit id');
+        }
+        if (!process.env.NPM_AUTH_TOKEN) {
+          throw new Error('请设置 NPM_AUTH_TOKEN 环境变量');
+        }
+        await release(options);
+      } catch (error) {
+        logger.error('Release failed!');
+        logger.error((error ).message);
+        process.exit(1);
+      }
+    });
+};
+
+const GIT_REPO_URL_REGEX = /git@github\.com:([^\/]+)\/([^\.]+)\.git/;
+
+/**
+ * 生成指定长度的随机字符串(使用 crypto 模块)
+ * @param digit 字符串长度
+ * @returns 随机字符串
+ */
+function randomHash(digit) {
+  return crypto
+    .randomBytes(Math.ceil(digit / 2))
+    .toString('hex')
+    .slice(0, digit);
+}
+
+var BumpType; (function (BumpType) {
+  const ALPHA = 'alpha'; BumpType["ALPHA"] = ALPHA;
+  const BETA = 'beta'; BumpType["BETA"] = BETA;
+  const PATCH = 'patch'; BumpType["PATCH"] = PATCH;
+  const MINOR = 'minor'; BumpType["MINOR"] = MINOR;
+  const MAJOR = 'major'; BumpType["MAJOR"] = MAJOR;
+})(BumpType || (BumpType = {}));
+
+/**
+ * 获取更新类型的描述
+ */
+const getTypeDescription = (type) => {
+  switch (type) {
+    case BumpType.MAJOR:
+      return `Major update, incompatible API changes, for example: ${chalk.green('1.1.1 -> 2.0.0')}`;
+    case BumpType.MINOR:
+      return `Minor update, backwards-compatible features, for example: ${chalk.green('1.1.1 -> 1.2.0')}`;
+    case BumpType.PATCH:
+      return `Patch update, backwards-compatible bug fixes, for example: ${chalk.green('1.1.1 -> 1.1.2')}`;
+    case BumpType.BETA:
+      return `Beta pre-release version, for example: ${chalk.green('1.1.1-beta.1')}`;
+    case BumpType.ALPHA:
+      return `Alpha pre-release version, for example: ${chalk.green('1.1.1-alpha.2597f3')}`;
+    default:
+      return '';
+  }
+};
+
+/**
+ * 让用户选择版本更新类型
+ */
+const requestBumpType = async () => {
+  const bumpTypesChoices = [
+    BumpType.ALPHA,
+    BumpType.BETA,
+    BumpType.PATCH,
+    BumpType.MINOR,
+    BumpType.MAJOR,
+  ];
+  const choices = bumpTypesChoices.map(type => ({
+    name: `${chalk.bold(type.toUpperCase())}: ${getTypeDescription(type)}`,
+    value: type,
+  }));
+
+  try {
+    const selected = await prompts.select({
+      message: 'Select version bump type:',
+      choices,
+    });
+
+    return selected;
+  } catch (error) {
+    return null;
+  }
+};
+
+/**
+ * 根据当前版本和发布类型计算新版本号
+ */
+const calculateNewVersion = (
+  currentVersion,
+  bumpType,
+  sessionId,
+) => {
+  // 解析当前版本
+  const parsed = semver.parse(currentVersion);
+  if (!parsed) {
+    throw new Error(`Invalid current version: ${currentVersion}`);
+  }
+
+  const { major, minor, patch, prerelease } = parsed;
+
+  switch (bumpType) {
+    case BumpType.PATCH:
+    case BumpType.MINOR:
+    case BumpType.MAJOR: {
+      // 如果当前是预发布版本，去掉预发布标识
+      const cc =
+        prerelease.length > 0 ? `${major}.${minor}.${patch}` : currentVersion;
+      // 否则增加 patch 版本
+      return semver.inc(cc, bumpType) || currentVersion;
+    }
+    case BumpType.BETA: {
+      // 如果当前已经是 beta 版本，增加 beta 版本号
+      if (prerelease[0] === 'beta') {
+        const nextVersion = semver.inc(currentVersion, 'prerelease', 'beta');
+        return nextVersion || currentVersion;
+      }
+      // 否则基于当前版本创建新的 beta 版本
+      const baseVersion = `${major}.${minor}.${patch}`;
+      return `${baseVersion}-beta.1`;
+    }
+    case BumpType.ALPHA: {
+      // 否则基于当前版本创建新的 alpha 版本
+      const baseVersion = `${major}.${minor}.${patch}`;
+      // 生成随机哈希值
+      return `${baseVersion}-alpha.${sessionId || randomHash(6)}`;
+    }
+    default: {
+      throw new Error(
+        `Invalid bump type: ${bumpType}, should be one of ${Object.values(BumpType).join(', ')}`,
+      );
+    }
+  }
+};
+
+/**
+ * 生成新版本号
+ * 策略优先级:
+ * 1. 指定版本号
+ * 2. 指定发布类型
+ * 3. 交互式选择
+ */
+const generateNewVersionForPackage = (
+  project,
+  options,
+) => {
+  const currentVersion = project.packageJson.version;
+  // 1. 如果指定了版本号，直接使用
+  if (options.version) {
+    return options.version;
+  }
+
+  // 1. 如果指定了发布类型，计算新版本号
+  const { bumpType } = options;
+  if (!bumpType) {
+    throw new Error('Version selection was cancelled');
+  }
+  const newVersion = calculateNewVersion(
+    currentVersion,
+    bumpType,
+    options.sessionId,
+  );
+
+  return newVersion;
+};
+
+const calBumpPolicy = (options) => {
+  const { version, bumpType } = options;
+  if (version) {
+    return version;
+  }
+  return bumpType;
+};
+
+/**
+ * 生成发布清单
+ */
+const generatePublishManifest = async (
+  packages,
+  options,
+
+
+
+) => {
+  const manifests = [];
+  const { version, bumpType } = options;
+  if (version && !semver.valid(version)) {
+    throw new Error(`Invalid version specified: ${version}`);
+  } else if (!bumpType) {
+    const newBumpType = await requestBumpType();
+    if (!newBumpType) {
+      throw new Error('Version selection was cancelled!');
+    }
+    options.bumpType = newBumpType;
+  }
+  for (const pkg of packages) {
+    const currentVersion = pkg.packageJson.version;
+    const newVersion = await generateNewVersionForPackage(pkg, options);
+    manifests.push({
+      project: pkg,
+      newVersion,
+      currentVersion,
+    });
+  }
+  const bumpPolicy = calBumpPolicy(options);
+  return {
+    manifests,
+    bumpPolicy,
+  };
+};
+
+async function commitChanges({
+  sessionId,
+  files,
+  cwd,
+  publishManifests,
+  branchName,
+  createTags,
+}) {
+  await exec(`git add ${files.join(' ')}`, { cwd });
+  await exec(`git commit -m "chore: Publish ${branchName}" -n`, { cwd });
+
+  let tags = [];
+  if (createTags) {
+    tags = publishManifests.map(
+      m => `v/${m.project.packageName}@${m.newVersion}`,
+    );
+    await exec(
+      tags.map(tag => `git tag -a ${tag} -m "Bump type ${tag}"`).join(' && '),
+      { cwd },
+    );
+  }
+  return { effects: [...tags, branchName], branchName };
+}
+
+
+
+
+
+
+
+async function push({ refs, cwd, repoUrl }) {
+  await exec(`git push ${repoUrl} ${refs.join(' ')} --no-verify`, {
+    cwd,
+  });
+}
+
+const pushToRemote = async (options) => {
+  const {
+    sessionId,
+    changedFiles,
+    cwd,
+    publishManifests,
+    bumpPolicy,
+    skipCommit,
+    skipPush,
+    repoUrl,
+  } = options;
+  if (skipCommit) {
+    return;
+  }
+
+  // 获取仓库 URL
+  const actualRepoUrl = repoUrl;
+
+  let branchName;
+  if (bumpPolicy === BumpType.BETA) {
+    branchName = await getCurrentBranchName();
+  } else {
+    const date = dayjs().format('YYYYMMDD');
+    branchName = `release/${date}-${sessionId}`;
+    await exec(`git checkout -b ${branchName}`, { cwd });
+  }
+  const isTestPublish = [BumpType.ALPHA, BumpType.BETA].includes(
+    bumpPolicy ,
+  );
+
+  // 4. 创建并推送发布分支
+  const { effects } = await commitChanges({
+    sessionId,
+    files: changedFiles,
+    cwd,
+    publishManifests,
+    branchName,
+    // 只有 alpha、beta 需要创建 tag，正式发布会在 .github/workflows/common-pr-checks.yml 创建并发布tag
+    createTags: isTestPublish,
+  });
+  if (skipPush) {
+    return;
+  }
+  await push({
+    refs: effects,
+    cwd,
+    repoUrl: actualRepoUrl,
+  });
+
+  // 从 git URL 提取组织和仓库名称，用于构建 GitHub 链接
+  const repoInfoMatch = actualRepoUrl.match(GIT_REPO_URL_REGEX);
+  if (!repoInfoMatch) {
+    throw new Error('Invalid git repository URL');
+  }
+  const repoOwner = repoInfoMatch[1];
+  const repoName = repoInfoMatch[2];
+
+  if (isTestPublish) {
+    logger.success(
+      `Please refer to https://github.com/${repoOwner}/${repoName}/actions/workflows/release.yml for the release progress.`,
+    );
+  } else {
+    const prUrl = `https://github.com/${repoOwner}/${repoName}/compare/${branchName}?expand=1`;
+    const log = [
+      '************************************************',
+      '*',
+      `* Please create PR: ${prUrl}`,
+      '*',
+      '************************************************',
+    ];
+    logger.success(log.join('\n'), false);
+    const open = await import('open');
+    await open.default(prUrl);
+  }
+};
+
+function _optionalChain$1(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var RetrievePattern; (function (RetrievePattern) {
+  const TO = 'to'; RetrievePattern["TO"] = TO;
+  const FROM = 'from'; RetrievePattern["FROM"] = FROM;
+  const ONLY = 'only'; RetrievePattern["ONLY"] = ONLY;
+})(RetrievePattern || (RetrievePattern = {}));
+
+const retrievePackages = (
+  pattern,
+  packages,
+) => {
+  const rushConfiguration = getRushConfiguration();
+  const matchedPackages = new Set();
+  packages.forEach(pkg => {
+    const project = rushConfiguration.getProjectByName(pkg);
+    if (!project) {
+      throw new Error(`Package "${pkg}" not found in rush configuration`);
+    }
+    if (!project.shouldPublish) {
+      throw new Error(
+        `Package "${pkg}" is not set to publish. if you want to publish it, please set the "shouldPublish" property to true in the \`rush.json\` file.`,
+      );
+    }
+    const matched = [];
+    switch (pattern) {
+      case 'to': {
+        matched.push(project.dependencyProjects);
+        break;
+      }
+      case 'from': {
+        matched.push(project.consumingProjects);
+        matched.push(project.dependencyProjects);
+        break;
+      }
+      case 'only': {
+        // do nothing
+        break;
+      }
+      default: {
+        throw new Error('Unexpected package selection state');
+      }
+    }
+
+    for (const matchedSet of matched) {
+      for (const p of matchedSet) {
+        if (p.shouldPublish) {
+          matchedPackages.add(p);
+        }
+      }
+    }
+    matchedPackages.add(project);
+  });
+  return matchedPackages;
+};
+
+const validateAndGetPackages = (options) => {
+  const retrievePatterns = Object.values(RetrievePattern);
+  if (retrievePatterns.every(pattern => (_optionalChain$1([options, 'access', _ => _[pattern], 'optionalAccess', _2 => _2.length]) || 0) <= 0)) {
+    throw new Error('No packages to publish');
+  }
+  return retrievePatterns.reduce((acc, pattern) => {
+    const packages = options[pattern];
+    if (!packages || packages.length <= 0) {
+      return acc;
+    }
+    const placeholders = retrievePackages(pattern , packages);
+    return new Set([...acc, ...placeholders]);
+  }, new Set());
+};
+
+const confirmForPublish = async (
+  publishManifest,
+  dryRun,
+) => {
+  console.log(chalk.gray('Will publish the following packages:'));
+  publishManifest.forEach(manifest => {
+    const msg = `${manifest.project.packageName}: ${chalk.bgGreen(`${manifest.currentVersion} -> ${chalk.bold(manifest.newVersion)}`)}`;
+    console.log(`- ${msg}`);
+  });
+  if (dryRun) {
+    return false;
+  }
+
+  console.log('\n');
+  try {
+    const result = await prompts.confirm({
+      message: 'Are you sure to publish?',
+      default: true,
+    });
+    return result;
+  } catch (error) {
+    return false;
+  }
+};
+
+function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * Convert change type to corresponding title
+ */
+const getChangeTypeTitle = (type) => {
+  switch (type) {
+    case 'major':
+      return '### Breaking Changes';
+    case 'minor':
+      return '### New Features';
+    case 'patch':
+      return '### Bug Fixes';
+    case 'dependency':
+      return '### Dependencies';
+    case 'none':
+      return '### Other Changes';
+    default:
+      return '';
+  }
+};
+
+/**
+ * Generate changelog for a single version
+ */
+const generateVersionChangelog = ({
+  version,
+  changes,
+  tag,
+  defaultChangelog,
+}
+
+
+
+
+) => {
+  // Group changes by type
+  const groupedChanges =
+    changes.length > 0
+      ? changes.reduce(
+          (acc, change) => {
+            const { type, comment, customFields } = change;
+            if (!acc[type]) {
+              acc[type] = [];
+            }
+            const node = acc[type];
+            if (node.some(existing => existing.comment === comment) === false) {
+              node.push({
+                comment,
+                customFields,
+              });
+            }
+            return acc;
+          },
+          {} ,
+        )
+      : { none: [{ comment: defaultChangelog }] };
+
+  return {
+    version,
+    tag,
+    date: dayjs().toISOString(),
+    comments: groupedChanges ,
+  };
+};
+
+/**
+ * Convert changelog to Markdown format
+ */
+const changelogToMarkdown = (changelog) => {
+  const lines = [];
+  lines.push(`# ${changelog.name}`);
+  lines.push('');
+
+  changelog.entries.forEach(entry => {
+    lines.push(
+      `## ${entry.version} - ${dayjs(entry.date).format('YYYY-MM-DD')}`,
+    );
+    lines.push('');
+
+    // Output different types of changes in fixed order
+    const typeOrder = [
+      'major',
+      'minor',
+      'patch',
+      'dependency',
+      'none',
+    ];
+
+    typeOrder.forEach(type => {
+      const changes = entry.comments[type];
+      if (_optionalChain([changes, 'optionalAccess', _ => _.length])) {
+        lines.push(getChangeTypeTitle(type));
+        lines.push('');
+        changes.forEach(change => {
+          lines.push(`- ${change.comment}`);
+          // Add custom fields to changelog if they exist
+          if (change.customFields) {
+            Object.entries(change.customFields).forEach(([key, value]) => {
+              lines.push(`  - ${key}: ${value}`);
+            });
+          }
+        });
+        lines.push('');
+      }
+    });
+
+    lines.push('');
+  });
+
+  return lines.join('\n');
+};
+
+
+
+
+
+
+
+
+
+/**
+ * Merge and generate changelog
+ */
+const generateChangelog$1 = ({
+  commingChanges,
+  previousChangelog,
+  version,
+  packageName,
+  tag,
+  defaultChangelog = 'Publish for noop',
+}
+
+
+) => {
+  // Create new changelog entry
+  const newEntry = generateVersionChangelog({
+    version,
+    changes: commingChanges.flatMap(r => r.changes),
+    tag: tag || 'HEAD',
+    defaultChangelog,
+  });
+
+  const allEntries = (
+    previousChangelog ? [newEntry, ...previousChangelog.entries] : [newEntry]
+  ).sort((a, b) => {
+    // Handle invalid version numbers
+    if (!semver.valid(a.version) || !semver.valid(b.version)) {
+      return 0;
+    }
+    // Use semver.rcompare for descending sort (newer versions first)
+    return semver.rcompare(a.version, b.version);
+  });
+
+  // Merge with existing changelog
+  const changelog = {
+    name: packageName,
+    entries: allEntries,
+  };
+
+  // Convert to markdown
+  const markdown = changelogToMarkdown(changelog);
+  return {
+    changelog,
+    report: markdown,
+  };
+};
+
+const deleteFiles = async (files) => {
+  await Promise.all(
+    files.map(async file => {
+      await fs.unlink(file);
+    }),
+  );
+};
+
+const readChangeFiles = async (changedFolderOfPkg) => {
+  if (!(await isDirExists(changedFolderOfPkg))) {
+    return [];
+  }
+  const changeFiles = (await fs.readdir(changedFolderOfPkg)).filter(r =>
+    r.endsWith('.json'),
+  );
+  return changeFiles.map(r => path.resolve(changedFolderOfPkg, r));
+};
+
+const readChanges = async (changeFiles) => {
+  const changes = (
+    await Promise.all(
+      changeFiles.map(async r => {
+        try {
+          const res = await readJsonFile(r);
+          return res;
+        } catch (e) {
+          return null;
+        }
+      }),
+    )
+  ).filter(r => r !== null);
+  return changes;
+};
+
+const readPreviousChangelog = async (
+  changelogJsonPath,
+  packageName,
+) => {
+  const defaultValue = {
+    name: packageName,
+    entries: [] ,
+  };
+  if (!(await isFileExists(changelogJsonPath))) {
+    return defaultValue;
+  }
+  try {
+    const changelog = await readJsonFile(changelogJsonPath);
+    return changelog;
+  } catch (e) {
+    return defaultValue;
+  }
+};
+
+const generateChangelogForProject = async (manifest) => {
+  const { project, newVersion } = manifest;
+  const rushConfiguration = getRushConfiguration();
+  const { changesFolder } = rushConfiguration;
+  const changedFolderOfPkg = path.resolve(changesFolder, project.packageName);
+  const changelogJsonPath = path.resolve(
+    project.projectFolder,
+    'CHANGELOG.json',
+  );
+  const changelogMarkdownPath = path.resolve(
+    project.projectFolder,
+    'CHANGELOG.md',
+  );
+
+  const changeFiles = await readChangeFiles(changedFolderOfPkg);
+  const changes = await readChanges(changeFiles);
+
+  const previousChangelog = await readPreviousChangelog(
+    changelogJsonPath,
+    project.packageName,
+  );
+  const { changelog, report: changelogMarkdown } = await generateChangelog$1({
+    packageName: project.packageName,
+    version: newVersion,
+    commingChanges: changes,
+    previousChangelog,
+  });
+
+  // side effects
+  await writeJsonFile(changelogJsonPath, changelog);
+  await fs.writeFile(changelogMarkdownPath, changelogMarkdown);
+  await deleteFiles(changeFiles);
+  return [changelogJsonPath, changelogMarkdownPath, ...changeFiles];
+};
+
+const generateChangelog = async (
+  manifests,
+) => {
+  const modifiedFiles = await Promise.all(
+    manifests.map(manifest => generateChangelogForProject(manifest)),
+  );
+  return modifiedFiles.flat();
+};
+
+const updatePackageVersion = async (
+  project,
+  newVersion,
+) => {
+  const packageJsonPath = path.resolve(project.projectFolder, 'package.json');
+  const packageJson = await readJsonFile(packageJsonPath);
+  packageJson.version = newVersion;
+  await writeJsonFile(packageJsonPath, packageJson);
+  return packageJsonPath;
+};
+
+const applyPublishManifest = async (
+  manifests,
+) => {
+  const modifiedFiles = await Promise.all(
+    manifests.map(async manifest => {
+      const { project, newVersion } = manifest;
+
+      const modifiedFile = await updatePackageVersion(project, newVersion);
+      return modifiedFile;
+    }),
+  );
+  logger.info(
+    `Updated version for packages: ${manifests.map(m => m.project.packageName).join(', ')}`,
+  );
+  return modifiedFiles;
+};
+
+// 针对不同类型的发布，对应不同 sideEffects：
+// 1. alpha: 直接创建并push 分支，触发 CI，执行发布；
+// 2. beta: 本分支直接切换版本号，并发布
+// 3. 正式版本：发起MR，MR 合入 main 后，触发发布
+
+const publish = async (options) => {
+  const sessionId = randomHash(6);
+  const rushConfiguration = getRushConfiguration();
+  const rushFolder = rushConfiguration.rushJsonFolder;
+  if (process.env.SKIP_UNCOMMITTED_CHECK !== 'true') {
+    await ensureNotUncommittedChanges();
+  }
+
+  // 1. 验证并获取需要发布的包列表
+  const packagesToPublish = validateAndGetPackages(options);
+  if (packagesToPublish.size === 0) {
+    logger.error(
+      'No packages to publish, should specify some package by `--to` or `--from` or `--only`',
+    );
+    return;
+  }
+  logger.debug(
+    `Will publish the following packages:\n ${[...packagesToPublish].map(pkg => pkg.packageName).join('\n')}`,
+  );
+
+  // 2. 生成发布清单
+  const { manifests: publishManifests, bumpPolicy } =
+    await generatePublishManifest(packagesToPublish, {
+      ...options,
+      sessionId,
+    });
+  const isBetaPublish = [BumpType.BETA, BumpType.ALPHA].includes(
+    bumpPolicy ,
+  );
+  if (isBetaPublish === false && (await isMainBranch()) === false) {
+    // 只允许在主分支发布
+    logger.error(
+      'You are not in main branch, please switch to main branch and try again.',
+    );
+    return;
+  }
+
+  const continuePublish = await confirmForPublish(
+    publishManifests,
+    !!options.dryRun,
+  );
+
+  if (!continuePublish) {
+    return;
+  }
+
+  // 3. 应用更新，注意这里会修改文件，产生 sideEffect
+  const postHandles = [applyPublishManifest];
+  if (isBetaPublish === false) {
+    postHandles.push(generateChangelog);
+  }
+  const changedFiles = (
+    await Promise.all(postHandles.map(handle => handle(publishManifests)))
+  ).flat();
+
+  // 4. 创建并推送发布分支
+  await pushToRemote({
+    publishManifests,
+    bumpPolicy: bumpPolicy ,
+    sessionId,
+    changedFiles,
+    cwd: rushFolder,
+    skipCommit: !!options.skipCommit,
+    skipPush: !!options.skipPush,
+    repoUrl: options.repoUrl,
+  });
+  logger.success('Publish success.');
+};
+
+const installAction$1 = (program) => {
+  program
+    .command('pub')
+    .description('Generate new version and create release branch.')
+    .option('-v, --version <string>', 'Specify publish version')
+    .option('-d, --dry-run', 'Enable dry run mode', false)
+    .option(
+      '-t, --to <packages...>',
+      'Publish specified packages and their downstream dependencies',
+    )
+    .option(
+      '-f, --from <packages...>',
+      'Publish specified packages and their upstream/downstream dependencies',
+    )
+    .option('-o, --only <packages...>', 'Only publish specified packages')
+    .option('-s, --skip-commit', 'Skip git commit', false)
+    .option('-p, --skip-push', 'Skip git push', false)
+    .option(
+      '-b, --bump-type <type>',
+      'Version bump type (alpha/beta/patch/minor/major)',
+      /^(alpha|beta|patch|minor|major)$/,
+    )
+    .option(
+      '--repo-url <url>',
+      'Git repository URL (e.g. git@github.com:coze-dev/coze-js.git)',
+      undefined,
+    )
+    .action(async (options) => {
+      try {
+        const repoUrl = options.repoUrl || (await getCurrentOrigin());
+        if (!repoUrl) {
+          throw new Error('Git repository URL is required');
+        }
+        if (!GIT_REPO_URL_REGEX.test(repoUrl)) {
+          throw new Error(
+            `Invalid git repository URL: ${repoUrl}, it should be follow the format: git@github.com:\${org}/\${repo}.git`,
+          );
+        }
+        const normalizeOptions = {
+          ...options,
+          repoUrl,
+        };
+        await publish(normalizeOptions);
+      } catch (error) {
+        logger.error('Publish failed!');
+        logger.error((error ).message);
+      }
+    });
+};
+
+const whoAmI = async () => {
+  const [name, email] = await Promise.all([
+    exec('git config user.name', { cwd: __dirname, silent: true }),
+    exec('git config user.email', { cwd: __dirname, silent: true }),
+  ]);
+  return {
+    name: name.stdout.toString().replace('\n', ''),
+    email: email.stdout.toString().replace('\n', ''),
+  };
+};
+
+// 这两个包没有 module 导出
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const { sync } = require('conventional-commits-parser');
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const defaultChangelogOpts = require('conventional-changelog-angular');
+
+const VERSIONS = ['major', 'minor', 'patch'];
+
+/**
+ * 收集需要更新 changes 的包
+ * @returns  RushConfigurationProject[]
+ */
+const collectShouldUpdateChangesProjects = async (
+
+) => {
+  const changedFiles = await getChangedFilesFromCached();
+  const rushConfiguration = getRushConfiguration();
+  const lookup = rushConfiguration.getProjectLookupForRoot(
+    rushConfiguration.rushJsonFolder,
+  );
+
+  const relativeChangesFolder = path.relative(
+    rushConfiguration.rushJsonFolder,
+    rushConfiguration.changesFolder,
+  );
+  const ignorePackage = [];
+  const shouldUpdateChangesProjects = new Set();
+
+  for (const file of changedFiles) {
+    // 收集有 common/changes 下变更的包
+    if (file.startsWith(relativeChangesFolder)) {
+      const packageName = path.relative(
+        relativeChangesFolder,
+        path.dirname(file),
+      );
+      ignorePackage.push(packageName);
+    }
+
+    const project = lookup.findChildPath(file);
+    // 按是否发布提取相关包信息，同时过滤掉changes包含在本次变更内的文件（该策略是手动更改优先级大于自动生成）
+    if (project && !ignorePackage.includes(project.packageName)) {
+      if (!shouldUpdateChangesProjects.has(project) && project.shouldPublish) {
+        shouldUpdateChangesProjects.add(project);
+      }
+    }
+  }
+
+  return [...shouldUpdateChangesProjects];
+};
+
+/**
+ * 解析 commit-mag
+ * @param message
+ * @param parser
+ * @param parserOpts
+ * @returns
+ */
+// https://github.com/conventional-changelog/commitlint/blob/8b8a6e62f57511c0be05346d14959247851cdfeb/%40commitlint/parse/src/index.ts#L6
+async function parseCommit(
+  message,
+  parser = sync,
+  parserOpts,
+) {
+  const defaultOpts = (await defaultChangelogOpts).parserOpts;
+  const opts = {
+    ...defaultOpts,
+    ...({}),
+    fieldPattern: null,
+  };
+  const parsed = parser(message, opts) ;
+  parsed.raw = message;
+  return parsed;
+}
+
+/**
+ * 生成可能更新的版本类型
+ * @param commits
+ * @returns
+ */
+// https://github.com/conventional-changelog/conventional-changelog/blob/master/packages/conventional-recommended-bump/index.js
+function whatBump(commits)
+
+
+
+ {
+  const DEFAULT_LEVEL = 2;
+  let level = DEFAULT_LEVEL;
+  let breakings = 0;
+  let features = 0;
+
+  commits.forEach(commit => {
+    if (commit.notes.length > 0) {
+      breakings += commit.notes.length;
+      level = 0;
+    } else if (commit.type === 'feat') {
+      features += 1;
+      if (level === DEFAULT_LEVEL) {
+        level = 1;
+      }
+    }
+  });
+
+  return {
+    level,
+    releaseType: VERSIONS[level],
+    reason:
+      breakings === 1
+        ? `There is ${breakings} BREAKING CHANGE and ${features} features`
+        : `There are ${breakings} BREAKING CHANGES and ${features} features`,
+  };
+}
+
+async function analysisCommitMsg(
+  msg,
+) {
+  const parsedCommit = await parseCommit(msg);
+  const bumpInfo = whatBump([parsedCommit]);
+
+  return { type: bumpInfo.releaseType, content: parsedCommit.subject || '' };
+}
+
+/**
+ * 生成 changes
+ */
+async function generateAllChangesFile(
+  comment,
+  patchType,
+) {
+  const rushConfiguration = getRushConfiguration();
+  const needUpdateProjects = await collectShouldUpdateChangesProjects();
+  const { email } = await whoAmI();
+
+  // 重新组织已有 change 文件和待新增的 change
+  for (const project of needUpdateProjects) {
+    const { packageName } = project;
+    // TODO: ChangeFile 需要的 IChangeInfo 类型和当前规范存在属性差异，暂时先忽略 email
+    const changeFile = new ChangeFile.ChangeFile(
+      { changes: [], packageName, email },
+      rushConfiguration ,
+    );
+    changeFile.addChange({ packageName, comment, type: patchType });
+    changeFile.writeSync();
+
+    const updateChangesPath = path.resolve(
+      rushConfiguration.changesFolder,
+      packageName,
+    );
+    await exec(`git add ${updateChangesPath}`);
+    logger.success(`Success update ${packageName} changes file`);
+  }
+}
+
+const amendCommit = async () => {
+  const changedFiles = await getChangedFilesFromCached();
+  const rushConfiguration = getRushConfiguration();
+
+  const relativeChangesFolder = path.relative(
+    rushConfiguration.rushJsonFolder,
+    rushConfiguration.changesFolder,
+  );
+
+  for (const file of changedFiles) {
+    if (file.startsWith(relativeChangesFolder)) {
+      await exec('git commit --amend --no-edit -n');
+      break;
+    }
+  }
+};
+
+const generateChangeFiles = async (options) => {
+  // CI 环境的提交不做处理
+  if (options.ci || process.env.CI === 'true') {
+    return;
+  }
+  if (options.amendCommit) {
+    amendCommit();
+    return;
+  }
+  try {
+    let { commitMsg } = options;
+    if (!commitMsg) {
+      const rushConfiguration = getRushConfiguration();
+      commitMsg = await fs.readFile(
+        path.resolve(rushConfiguration.rushJsonFolder, '.git/COMMIT_EDITMSG'),
+        'utf-8',
+      );
+    }
+
+    const { content, type } = await analysisCommitMsg(commitMsg);
+    if (!content) {
+      logger.warn('Invalid subject');
+      return;
+    }
+    generateAllChangesFile(content, type);
+  } catch (e) {
+    logger.error(`Generate changes file fail \n ${e}`);
+  }
+};
+
+const installAction = (program) => {
+  program
+    .command('change')
+    .description('Generate changes in a simple way.')
+    .option(
+      '-c, --commit-msg <string>',
+      '本次提交信息,默认读取 .git/COMMIT_EDITMSG',
+    )
+    .option('-a, --amend-commit', '是否 amend commit 阶段')
+    .option('-i, --ci', '是否在 CI 环境')
+    .action(async (options) => {
+      await generateChangeFiles({ ...options });
+    });
+};
+
 const main = () => {
-    const packageJson = JSON.parse(fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../package.json'), 'utf8'));
-    const program = new commander_1.Command();
-    program
-        .name(packageJson.name)
-        .description(packageJson.description)
-        .version(packageJson.version)
-        .showSuggestionAfterError(true)
-        .showHelpAfterError(true);
-    const actions = [change_1.installAction, release_1.installAction, publish_1.installAction];
-    actions.forEach(a => {
-        a(program);
-    });
-    program.parse();
+  const packageJson = JSON.parse(
+    fs$1.readFileSync(path.resolve(__dirname, '../package.json'), 'utf8'),
+  );
+  const program = new commander.Command();
+
+  program
+    .name(packageJson.name)
+    .description(packageJson.description)
+    .version(packageJson.version)
+    .showSuggestionAfterError(true)
+    .showHelpAfterError(true);
+
+  const actions = [installAction, installAction$2, installAction$1];
+
+  actions.forEach(a => {
+    a(program);
+  });
+
+  program.parse();
 };
+
 main();
-//# sourceMappingURL=index.js.map