@vitarx/release-cli 1.0.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-present 朱冲林
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,195 @@
+# @vitarx/release-cli
+
+一个用于自动化发布 npm 包的 CLI 工具，支持 workspace 模式和多种包管理器。
+
+## 功能特性
+
+- ✅ 自动化版本管理和发布
+- ✅ 支持 npm、pnpm、yarn 包管理器检测
+- ✅ 支持 workspace 多包项目管理
+- ✅ 支持指定包名发布 (--package 选项)
+- ✅ 交互式版本类型选择
+- ✅ 预发布版本支持（alpha、beta、rc）
+- ✅ 自动生成 changelog (workspace多包项目时仅在发布的包名同根包名时在根目录生成 changelog)
+- ✅ dry-run 模式测试
+- ✅ 错误回滚机制
+
+## 安装
+
+### 全局安装
+
+```bash
+# 使用 npm
+npm install -g @vitarx/release-cli
+
+# 使用 pnpm  
+pnpm install -g @vitarx/release-cli
+
+# 使用 yarn
+yarn global add @vitarx/release-cli
+```
+
+### 临时使用 (无需安装)
+
+```bash
+# 使用 npx
+npx @vitarx/release-cli
+
+# 使用 pnpm
+pnpm dlx @vitarx/release-cli
+
+# 使用 yarn
+yarn dlx @vitarx/release-cli
+```
+
+## 使用方法
+
+### 基本使用
+
+```bash
+# 发布当前包 (自动检测包管理器)
+@vitarx/release-cli # 如果是 workspace 项目，会以对话形式选择要发布的包
+
+# 指定包名发布 (workspace 项目)
+@vitarx/release-cli --package <包名>
+
+# 使用 dry-run 模式测试
+@vitarx/release-cli --dry-run
+
+# 指定版本类型
+@vitarx/release-cli patch
+@vitarx/release-cli minor
+@vitarx/release-cli major
+# 自定义版本号
+@vitarx/release-cli 1.0.1
+```
+
+### 高级用法
+
+```bash
+# 组合使用选项
+@vitarx/release-cli patch --dry-run --package my-package
+@vitarx/release-cli minor --verbose
+
+# 预发布版本
+@vitarx/release-cli prerelease --preid alpha
+@vitarx/release-cli prerelease --preid beta
+@vitarx/release-cli prerelease --preid rc
+
+# 从预发布升级到正式版本
+@vitarx/release-cli release
+
+# changelog 相关选项
+@vitarx/release-cli patch --preset conventionalcommits --infile HISTORY.md
+@vitarx/release-cli minor --no-same-file --output-unreleased
+@vitarx/release-cli major --tag-prefix "" --release-count 5
+```
+
+### 支持的版本类型
+
+- `patch` - 修复 bug 或兼容性更新
+- `minor` - 新增功能（兼容旧版本）
+- `major` - 重大变更（不兼容旧版本）
+- `prepatch` - 预发布补丁版本
+- `preminor` - 预发布功能版本
+- `premajor` - 预发布主版本
+- `prerelease` - 预发布版本（递增 preid）
+- `release` - 从预发布版本升级为正式版本
+- `custom` - 自定义版本号
+
+### 命令行选项参考
+
+| 选项                    | 缩写   | 描述                       | 默认值            |
+|-----------------------|------|--------------------------|----------------|
+| `--help`              | `-h` | 显示帮助信息                   | -              |
+| `--dry-run`           | `-d` | 试运行模式，不实际执行操作            | `false`        |
+| `--preid`             | -    | 预发布版本标识符（alpha/beta/rc）  | -              |
+| `--preset`            | -    | conventional-changelog预设 | `angular`      |
+| `--infile`            | -    | changelog输入文件名           | `CHANGELOG.md` |
+| `--outfile`           | `-o` | changelog输出文件名           | 同输入文件          |
+| `--same-file`         | `-s` | 追加到现有changelog文件         | `true`         |
+| `--no-same-file`      | -    | 禁用追加到现有changelog文件       | -              |
+| `--append`            | `-a` | 将新版本追加到旧版本后面             | -              |
+| `--first-release`     | `-f` | 首次生成changelog            | -              |
+| `--skip-unstable`     | -    | 跳过不稳定版本（alpha/beta/rc）   | -              |
+| `--output-unreleased` | `-u` | 输出未发布的变更日志               | -              |
+| `--config`            | `-n` | 自定义配置文件路径                | -              |
+| `--context`           | `-c` | 模板变量上下文文件                | -              |
+| `--commit-path`       | -    | 只生成指定目录的提交日志             | -              |
+| `--tag-prefix`        | -    | Git 标签前缀                 | `v`            |
+| `--verbose`           | `-v` | 详细输出模式                   | `false`        |
+| `--release-count`     | -    | 生成的发布记录数量                | `0`            |
+| `--package`           | -    | 指定要发布的包名                 | -              |
+
+### Workspace 支持
+
+如果你的项目是 workspace 项目（包含 `workspaces` 配置），工具会自动检测并让你选择要发布的包。
+
+你可以使用 `--package` 选项直接指定要发布的包名，避免交互式选择：
+
+```bash
+@vitarx/release-cli --package my-package
+@vitarx/release-cli patch --package my-package --dry-run
+```
+
+## 发布流程
+
+1. **Git 状态检查** - 确保工作目录干净
+2. **版本类型选择** - 交互式选择版本升级类型
+3. **版本号更新** - 自动更新 package.json 版本号
+4. **构建项目** - 执行构建命令（如果存在）
+5. **Changelog 生成** - 如果是主包发布则使用 conventional-changelog 生成变更日志
+6. **Git 提交** - 提交版本变更和 changelog
+7. **NPM 发布** - 发布到 npm 仓库
+8. **Git 标签** - 创建版本标签
+9. **Git 推送** - 推送代码和标签到远程仓库
+
+> 从第2个步骤过后发生异常，都会回滚所有更改。
+
+## 配置要求
+
+### 项目配置
+
+确保你的项目包含：
+
+- `package.json` - 包含正确的包信息
+- 构建脚本 - 在 `package.json` 的 `scripts.build` 中定义
+- Git 仓库 - 已初始化并配置远程仓库
+- 多包项目 - 在 `package.json` 中指定 `workspaces`和`name`（用于生成 changelog）
+
+### Conventional Changelog
+
+1. 工具使用 `conventional-changelog-cli` 生成
+   changelog，确保你的提交信息符合 [Conventional Commits](https://www.conventionalcommits.org/) 规范。
+2. 如果是多包项目，请确保 根`package.json` 中包含 `name` 字段，如果发布的包名同根包名，则生成根目录的 changelog。
+
+## 开发
+
+### 安装依赖
+
+```bash
+pnpm install
+```
+
+### 构建项目
+
+```bash
+pnpm run build
+```
+
+### 本地测试
+
+```bash
+# 使用 dry-run 模式测试
+node dist/index.js --dry-run
+
+# 测试特定版本类型
+node dist/index.js patch --dry-run
+
+# 测试指定包名发布
+node dist/index.js patch --dry-run --package test-package
+```
+
+## 许可证
+
+MIT License

package/dist/constant.d.ts

@@ -0,0 +1,12 @@
+export declare const VERSION_TYPE_DESC: {
+    readonly patch: "修复 bug 或兼容性更新";
+    readonly minor: "新增功能（兼容旧版本）";
+    readonly major: "重大变更（不兼容旧版本）";
+    readonly prepatch: "预发布补丁版本(补丁测试版本)";
+    readonly preminor: "预发布功能版本(新功能测试版本)";
+    readonly premajor: "预发布主版本(重大变更测试版本)";
+    readonly prerelease: "预发布版本（递增 preid）";
+    readonly release: "测试结束，发布正式版本";
+};
+export type VersionType = keyof typeof VERSION_TYPE_DESC;
+export declare const VERSION_TYPE: VersionType[];

package/dist/constant.js

@@ -0,0 +1,11 @@
+export const VERSION_TYPE_DESC = {
+    patch: '修复 bug 或兼容性更新',
+    minor: '新增功能（兼容旧版本）',
+    major: '重大变更（不兼容旧版本）',
+    prepatch: '预发布补丁版本(补丁测试版本)',
+    preminor: '预发布功能版本(新功能测试版本)',
+    premajor: '预发布主版本(重大变更测试版本)',
+    prerelease: '预发布版本（递增 preid）',
+    release: '测试结束，发布正式版本'
+};
+export const VERSION_TYPE = Object.keys(VERSION_TYPE_DESC);

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import process from 'node:process';
+import { main } from './release.js';
+// 主入口
+main().catch(err => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/release.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env ts-node
+/**
+ * 主函数，用于执行包发布流程
+ * 该函数会检查Git状态，检测包管理器，判断是否为workspace项目，
+ * 并根据项目类型执行相应的发布逻辑
+ *
+ * @returns {Promise<void>} 返回一个Promise，解析为void
+ */
+export declare function main(): Promise<void>;

package/dist/release.js

@@ -0,0 +1,311 @@
+#!/usr/bin/env ts-node
+import chalk from 'chalk';
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { checkGitStatus, detectPackageManager, formatVersionNumber, getWorkspacePackages, isWorkspaceProject, log, prompt, rollbackChanges, runCommand, selectVersion, updateVersion } from './utils.js';
+/**
+ * 解析命令行参数
+ * @returns 包含版本类型、预发布标识符、dry-run模式等参数的对象
+ */
+function parseArgs() {
+    // 获取命令行参数，排除前两个元素（node和脚本路径）
+    const args = process.argv.slice(2);
+    // 初始化结果对象，设置默认值
+    const result = {
+        isDryRun: false, // 是否为试运行模式
+        showHelp: false, // 是否显示帮助信息
+        changelogPreset: 'angular', // 更改日志预设模板
+        changelogInfile: 'CHANGELOG.md', // 更改日志输入文件
+        changelogSameFile: true, // 是否使用同一文件
+        changelogReleaseCount: 0, // 发布版本数量
+        changelogTagPrefix: 'v' // 版本标签前缀
+    };
+    // 遍历所有命令行参数
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--help' || arg === '-h') {
+            result.showHelp = true;
+        }
+        else if (arg === '--dry-run' || arg === '-d') {
+            result.isDryRun = true;
+        }
+        else if (arg === '--preid' && args[i + 1]) {
+            result.preid = args[++i];
+        }
+        else if (arg === '--preset' && args[i + 1]) {
+            result.changelogPreset = args[++i];
+        }
+        else if (arg === '--infile' && args[i + 1]) {
+            result.changelogInfile = args[++i];
+        }
+        else if (arg === '--same-file' || arg === '-s') {
+            result.changelogSameFile = true;
+        }
+        else if (arg === '--no-same-file') {
+            result.changelogSameFile = false;
+        }
+        else if (arg === '--release-count' && args[i + 1]) {
+            result.changelogReleaseCount = parseInt(args[++i], 10);
+        }
+        else if (arg === '--outfile' && args[i + 1]) {
+            result.changelogOutfile = args[++i];
+        }
+        else if (arg === '--append' || arg === '-a') {
+            result.changelogAppend = true;
+        }
+        else if (arg === '--first-release' || arg === '-f') {
+            result.changelogFirstRelease = true;
+        }
+        else if (arg === '--skip-unstable') {
+            result.changelogSkipUnstable = true;
+        }
+        else if (arg === '--output-unreleased' || arg === '-u') {
+            result.changelogOutputUnreleased = true;
+        }
+        else if (arg === '--config' && args[i + 1]) {
+            result.changelogConfig = args[++i];
+        }
+        else if (arg === '--context' && args[i + 1]) {
+            result.changelogContext = args[++i];
+        }
+        else if (arg === '--commit-path' && args[i + 1]) {
+            result.changelogCommitPath = args[++i];
+        }
+        else if (arg === '--tag-prefix' && args[i + 1]) {
+            result.changelogTagPrefix = args[++i];
+        }
+        else if (arg === '--verbose' || arg === '-v') {
+            result.changelogVerbose = true;
+        }
+        else if (arg === '--package' && args[i + 1]) {
+            result.packageName = args[++i];
+        }
+        else if (!arg.startsWith('--')) {
+            result.versionType = arg;
+        }
+    }
+    return result;
+}
+/**
+ * 发布包到 npm 的主函数
+ * @param pkgDir - 包的目录路径
+ * @param packageManager - 检测到的包管理器类型
+ * @param isDryRun - 是否为试运行模式，默认为 false
+ * @param args - 命令行参数对象
+ */
+async function publishPackage(pkgDir, packageManager, isDryRun = false, args) {
+    // 获取 package.json 的完整路径
+    const pkgPath = path.join(pkgDir, 'package.json');
+    // 读取并解析 package.json 文件
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    // 获取当前版本号
+    const currentVersion = pkg.version;
+    // 新版本号
+    let newVersion = '';
+    try {
+        if (args.versionType) {
+            newVersion = await formatVersionNumber(currentVersion, args.versionType, args.preid);
+        }
+        else {
+            newVersion = await selectVersion(currentVersion);
+        }
+    }
+    catch (e) {
+        log.error(e.message);
+        process.exit(1);
+    }
+    // 版本标签
+    let tagName;
+    try {
+        // -------------------- Step 3: 更新版本号 --------------------
+        updateVersion(pkgPath, newVersion, isDryRun);
+        // 打印发布信息
+        console.log(`\n📦 新版本: ${chalk.green(pkg.name)}@${chalk.cyan(newVersion)}`);
+        // 确认是否发布
+        const confirm = await prompt(`是否确认发布 ${pkg.name}@${newVersion}? (y/N) `);
+        if (confirm && confirm.toLowerCase() !== 'y') {
+            log.warn('已取消发布');
+            process.exit(0);
+        }
+        // -------------------- Step 4: 构建和测试项目 --------------------
+        log.info(`📦 Building package: ${pkg.name}...`);
+        runCommand(`npm run build --prefix ${pkgDir}`);
+        // -------------------- Step 5: 生成日志 --------------------
+        // 是否为根包
+        const isRootPackage = JSON.parse(fs.readFileSync(path.join(process.cwd(), 'package.json'), 'utf-8')).name === pkg.name;
+        if (isRootPackage) {
+            // 生成 changelog
+            try {
+                log.info(`📝 正在生成 CHANGELOG.md...`);
+                const changelogArgs = [
+                    '-p', args.changelogPreset || 'angular',
+                    '-i', args.changelogInfile || 'CHANGELOG.md',
+                    args.changelogOutfile ? ['-o', args.changelogOutfile] : '',
+                    args.changelogSameFile ? '-s' : '',
+                    args.changelogAppend ? '-a' : '',
+                    args.changelogFirstRelease ? '-f' : '',
+                    args.changelogSkipUnstable ? '--skip-unstable' : '',
+                    args.changelogOutputUnreleased ? '-u' : '',
+                    args.changelogConfig ? ['-n', args.changelogConfig] : '',
+                    args.changelogContext ? ['-c', args.changelogContext] : '',
+                    args.changelogCommitPath ? ['--commit-path', args.changelogCommitPath] : '',
+                    args.changelogTagPrefix ? ['-t', args.changelogTagPrefix] : '',
+                    args.changelogVerbose ? '-v' : '',
+                    '-r', args.changelogReleaseCount ? args.changelogReleaseCount.toString() : '0'
+                ].flat().filter(arg => arg !== '');
+                runCommand(`conventional-changelog ${changelogArgs.join(' ')}`, isDryRun);
+            }
+            catch {
+                const confirm = await prompt(chalk.yellow('⚠️ 生成 changelog 失败，要继续发布流程吗? (y/N) '));
+                if (confirm.toLowerCase() !== 'y') {
+                    log.warn('已取消发布');
+                    process.exit(0);
+                }
+            }
+        }
+        // -------------------- Step 6: 提交更改到 git --------------------
+        log.info(`📤 Committing changes...`);
+        runCommand(`git add ${pkgPath}${isRootPackage ? ` ${args.changelogInfile || 'CHANGELOG.md'}` : ''}`, isDryRun);
+        runCommand(`git commit -m "build(${pkg.name}): release ${args.changelogTagPrefix + newVersion}"`, isDryRun);
+        if (isRootPackage) {
+            log.info(`🏷  Tagging: ${args.changelogTagPrefix + newVersion}`);
+            runCommand(`git tag -a ${args.changelogTagPrefix + newVersion} -m "Release ${newVersion}"`, isDryRun);
+            // 发布成功后把标签赋值给 tagName
+            tagName = `${args.changelogTagPrefix + newVersion}`;
+        }
+        // -------------------- Step 7: 发布到 npm --------------------
+        log.info(`🚀 Publishing ${pkg.name}@${newVersion}...`);
+        const publishCmd = packageManager === 'pnpm'
+            ? `pnpm publish ${pkgDir} --access public --registry https://registry.npmjs.org/`
+            : `npm publish ${pkgDir} --access public --registry https://registry.npmjs.org/`;
+        // 执行发布命令
+        runCommand(publishCmd, isDryRun);
+        // -------------------- Step 8: 推送代码和标签到远程仓库 --------------------
+        log.info('⬆️  Pushing to remote...');
+        try {
+            runCommand(`git push${tagName ? '&& git push --tags' : ''}`, isDryRun);
+        }
+        catch {
+            log.warn('包已发布到pnm，但推送代码和标签到远程仓库意外失败，请仔细核查npm仓库和远程仓库状态。');
+        }
+        // 打印发布成功信息
+        log.success(`发布完成 ${pkg.name}@${newVersion}` + (isDryRun ? ' (dry-run)' : ''));
+    }
+    catch (err) {
+        // 错误处理
+        log.error(err.message);
+        // 回滚更改
+        rollbackChanges(tagName, isDryRun);
+        process.exit(1);
+    }
+}
+/**
+ * 主函数，用于执行包发布流程
+ * 该函数会检查Git状态，检测包管理器，判断是否为workspace项目，
+ * 并根据项目类型执行相应的发布逻辑
+ *
+ * @returns {Promise<void>} 返回一个Promise，解析为void
+ */
+export async function main() {
+    const args = parseArgs();
+    if (args.showHelp) {
+        console.log(chalk.cyan('📦 Release CLI - NPM包发布工具'));
+        console.log('');
+        console.log(chalk.yellow('使用方法:'));
+        console.log('  release-cli [版本类型] [选项]');
+        console.log('');
+        console.log(chalk.yellow('版本类型:'));
+        console.log('  patch        - 修复 bug 或兼容性更新');
+        console.log('  minor        - 新增功能（兼容旧版本）');
+        console.log('  major        - 重大变更（不兼容旧版本）');
+        console.log('  prepatch     - 预发布补丁版本');
+        console.log('  preminor     - 预发布功能版本');
+        console.log('  premajor     - 预发布主版本');
+        console.log('  prerelease   - 预发布版本（递增 preid）');
+        console.log('  release      - 测试结束，发布正式版本');
+        console.log('  custom       - 自定义版本号');
+        console.log('');
+        console.log(chalk.yellow('选项:'));
+        console.log('  -h, --help              - 显示帮助信息');
+        console.log('  -d, --dry-run           - 试运行模式，不实际执行操作，（默认false）');
+        console.log('  --preid <标识符>         - 预发布版本标识符（alpha/beta/rc）');
+        console.log('  --preset <预设>          - conventional-changelog预设（默认: angular）');
+        console.log('  --infile <文件名>        - changelog输入文件名（默认: CHANGELOG.md）');
+        console.log('  -o, --outfile <文件名>   - changelog输出文件名（默认: 同输入文件）');
+        console.log('  -s, --same-file         - 追加到现有changelog文件（默认启用）');
+        console.log('  --no-same-file          - 禁用追加到现有changelog文件');
+        console.log('  -a, --append            - 将新版本追加到旧版本后面');
+        console.log('  -f, --first-release     - 首次生成changelog');
+        console.log('  --skip-unstable         - 跳过不稳定版本（alpha/beta/rc）');
+        console.log('  -u, --output-unreleased - 输出未发布的变更日志');
+        console.log('  -n, --config <文件>      - 自定义配置文件路径');
+        console.log('  -c, --context <文件>     - 模板变量上下文文件');
+        console.log('  --commit-path <目录>      - 只生成指定目录的提交日志');
+        console.log('  --tag-prefix <前缀>      - Git 标签前缀（默认: v）');
+        console.log('  -v, --verbose           - 详细输出模式');
+        console.log('  --release-count <数量>   - 生成的发布记录数量（默认: 0）');
+        console.log('  --package <包名>         - 指定要发布的包名');
+        console.log('');
+        console.log(chalk.yellow('示例:'));
+        console.log('  release-cli patch --dry-run');
+        console.log('  release-cli minor --preid beta');
+        console.log('  release-cli --preset angular --infile CHANGELOG.md');
+        process.exit(0);
+    }
+    const isDryRun = args.isDryRun;
+    // 如果有未提交的更改，则报错退出
+    if (!isDryRun && !checkGitStatus()) {
+        log.error('请先提交或暂存当前更改再发布。');
+        process.exit(1);
+    }
+    const packageManager = detectPackageManager();
+    const isWorkspace = isWorkspaceProject();
+    log.info(`当前包管理器: ${packageManager}`);
+    log.info(`当前工作目录: ${process.cwd()}`);
+    log.info(`当前运行模式: ${isDryRun ? 'dry-run' : 'publish'}`);
+    if (isWorkspace) {
+        log.info('检测到 workspace 项目');
+        const packages = getWorkspacePackages();
+        if (packages.length === 0) {
+            log.error('未找到 workspace 包');
+            process.exit(1);
+        }
+        let selectedPackage;
+        if (args.packageName) {
+            // 如果指定了包名，查找对应的包
+            selectedPackage = packages.find(pkg => pkg.name === args.packageName);
+            if (!selectedPackage) {
+                log.error(`未找到包名为 ${args.packageName} 的包`);
+                process.exit(1);
+            }
+            log.info(`已选择包: ${selectedPackage.name}`);
+        }
+        else {
+            // 未指定包名，显示选择界面
+            console.log(chalk.cyan('\n请选择要发布的包：'));
+            packages.forEach((pkg, i) => {
+                console.log(`${chalk.yellow(i + 1 + '.')}${chalk.green(pkg.name)}：${chalk.cyan(pkg.version)} (${pkg.path})`);
+            });
+            const answer = await prompt('\n输入序号选择包: ');
+            const index = parseInt(answer, 10);
+            if (isNaN(index) || index < 1 || index > packages.length) {
+                log.error('无效的选择');
+                process.exit(1);
+            }
+            selectedPackage = packages[index - 1];
+        }
+        await publishPackage(selectedPackage.path, packageManager, isDryRun, args);
+    }
+    else {
+        // 单包项目，发布根目录
+        await publishPackage(process.cwd(), packageManager, isDryRun, args);
+    }
+}
+// 执行主函数
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main().catch((err) => {
+        log.error(err.message);
+        process.exit(1);
+    });
+}

package/dist/type.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Package.json 文件结构接口
+ */
+export interface PackageJson {
+    /** 包名称 */
+    name: string;
+    /** 包版本号 */
+    version: string;
+    /** 生产环境依赖 */
+    dependencies?: Record<string, string>;
+    /** 开发环境依赖 */
+    devDependencies?: Record<string, string>;
+    /** 对等依赖 */
+    peerDependencies?: Record<string, string>;
+    /** 可选依赖 */
+    optionalDependencies?: Record<string, string>;
+    /** 其他自定义字段 */
+    [key: string]: unknown;
+}
+/**
+ * 发布配置接口
+ */
+export interface ReleaseConfig {
+    /** 版本类型 (major, minor, patch, premajor, preminor, prepatch, prerelease) */
+    versionType?: string;
+    /** 预发布标识 (如 alpha, beta, rc) */
+    preid?: string;
+    /** 要发布的包名 */
+    packageName?: string;
+    /** 是否为干运行模式，不实际执行操作 */
+    isDryRun: boolean;
+    /** changelog 预设配置 */
+    changelogPreset?: string;
+    /** changelog 输入文件名 */
+    changelogInfile?: string;
+    /** changelog 输出文件名 */
+    changelogOutfile?: string;
+    /** 是否在同一文件中更新 changelog */
+    changelogSameFile?: boolean;
+    /** 要包含的发布版本数量 */
+    changelogReleaseCount?: number;
+    /** 是否追加到现有 changelog 文件 */
+    changelogAppend?: boolean;
+    /** 是否为首次发布 */
+    changelogFirstRelease?: boolean;
+    /** 是否跳过不稳定版本 */
+    changelogSkipUnstable?: boolean;
+    /** 是否输出未发布的变更 */
+    changelogOutputUnreleased?: boolean;
+    /** changelog 配置文件路径 */
+    changelogConfig?: string;
+    /** changelog 上下文配置 */
+    changelogContext?: string;
+    /** 只生成指定目录的提交日志 */
+    changelogCommitPath?: string;
+    /** Git 标签前缀 */
+    changelogTagPrefix?: string;
+    /** 是否显示详细输出 */
+    changelogVerbose?: boolean;
+    /** 是否显示帮助信息 */
+    showHelp: boolean;
+}

package/dist/type.js

@@ -0,0 +1 @@
+export {};

package/dist/utils.d.ts

@@ -0,0 +1,95 @@
+/**
+ * 创建一个命令行提示函数，用于向用户提问并获取用户输入
+ * @param question - 要向用户显示的问题字符串
+ * @returns {Promise<string>} 返回一个Promise，解析为用户输入的答案（去除首尾空格）
+ */
+export declare function prompt(question: string): Promise<string>;
+/**
+ * 检查Git工作目录的状态
+ * 该函数通过执行git status命令并检查输出结果来确定工作目录是否干净
+ *
+ * @returns {boolean} 如果工作目录干净（没有未跟踪的文件、没有修改的文件）则返回true，否则返回false
+ */
+export declare function checkGitStatus(): boolean;
+/**
+ * 日志输出
+ *
+ * @property info - 信息日志
+ * @property success - 成功日志
+ * @property error - 错误日志
+ * @property warn - 警告日志
+ */
+export declare const log: {
+    readonly info: (message: string) => void;
+    readonly success: (message: string) => void;
+    readonly error: (message: string) => void;
+    readonly warn: (message: string) => void;
+};
+/**
+ * 选择版本升级类型
+ * @param currentVersion 当前版本号
+ * @returns {Promise<string>} 返回格式化后的新版本号
+ */
+export declare function selectVersion(currentVersion: string): Promise<string>;
+/**
+ * 获取预发布标识符（preid）的函数
+ * @param currentVersion 当前版本号
+ * @param isPreRelease 是否为预发布版本
+ * @returns {Promise<string>} 返回预发布标识符
+ */
+export declare function getPreid(currentVersion: string, isPreRelease: boolean): Promise<string>;
+/**
+ * 检测当前项目使用的包管理器
+ * @returns 返回 'npm' | 'pnpm' | 'yarn' 之一，表示当前项目使用的包管理器类型
+ */
+export declare function detectPackageManager(): 'npm' | 'pnpm' | 'yarn';
+/**
+ * 判断当前项目是否为工作空间项目
+ * 通过检查package.json中是否存在workspaces字段来判断
+ * @returns {boolean} 如果是工作空间项目返回true，否则返回false
+ */
+export declare function isWorkspaceProject(): boolean;
+/**
+ * 获取工作空间中的所有包信息
+ * @returns {Array<{ name: string; path: string; version: string }>} 返回一个包含包名、路径和版本的数组，如果不是工作空间项目则返回空数组
+ */
+export declare function getWorkspacePackages(): Array<{
+    name: string;
+    path: string;
+    version: string;
+}>;
+/**
+ * 格式化版本号函数
+ * 根据当前版本号和下一个版本类型或自定义版本号生成新的版本号
+ * @param currentVersion 当前版本号
+ * @param nextVersion 下一个版本类型或自定义版本号
+ * @param preid 预发布标识符（可选）
+ * @returns {Promise<string>} 返回格式化后的新版本号
+ * @throws Error 如果输入的版本类型/版本号无效，则抛出错误
+ */
+export declare function formatVersionNumber(currentVersion: string, // 当前版本号，字符串类型
+nextVersion: string, // 下一个版本类型或自定义版本号，字符串类型
+preid: string | undefined): Promise<string>;
+/**
+ * 执行命令函数
+ * @param cmd - 需要执行的命令字符串
+ * @param isDryRun - 是否为试运行模式，默认为false
+ * 当isDryRun为true时，仅打印命令而不实际执行
+ * 当isDryRun为false时，打印命令并实际执行
+ */
+export declare function runCommand(cmd: string, isDryRun?: boolean): void;
+/**
+ * 回滚代码变更的函数
+ * @param tagName - 可选的标签名称，用于删除创建的标签
+ * @param isDryRun - 是否为试运行模式，默认为false
+ */
+export declare function rollbackChanges(tagName?: string, isDryRun?: boolean): void;
+/**
+ * 更新指定包的版本号
+ * @param pkgPath - 包的文件路径
+ * @param newVersion - 新的版本号
+ * @param isDryRun - 是否为试运行模式，默认为false
+ */
+export declare function updateVersion(pkgPath: string, // 包的文件路径
+newVersion: string, // 新的版本号
+isDryRun?: boolean): void;

package/dist/utils.js

@@ -0,0 +1,337 @@
+import chalk from 'chalk';
+import { execSync } from 'node:child_process';
+import * as console from 'node:console';
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import readline from 'node:readline';
+import semver from 'semver';
+import { VERSION_TYPE, VERSION_TYPE_DESC } from './constant.js';
+/**
+ * 创建一个命令行提示函数，用于向用户提问并获取用户输入
+ * @param question - 要向用户显示的问题字符串
+ * @returns {Promise<string>} 返回一个Promise，解析为用户输入的答案（去除首尾空格）
+ */
+export function prompt(question) {
+    // 使用readline模块创建一个接口，用于处理用户输入和输出
+    const rl = readline.createInterface({
+        input: process.stdin, // 设置输入流为标准输入
+        output: process.stdout // 设置输出流为标准输出
+    });
+    // 返回一个新的Promise，用于异步处理用户输入
+    return new Promise(resolve => 
+    // 使用rl.question方法向用户提问，并在收到答案后执行回调
+    rl.question(question, ans => {
+        rl.close(); // 关闭readline接口
+        resolve(ans.trim()); // 解析Promise，返回去除首尾空格的答案
+    }));
+}
+/**
+ * 检查Git工作目录的状态
+ * 该函数通过执行git status命令并检查输出结果来确定工作目录是否干净
+ *
+ * @returns {boolean} 如果工作目录干净（没有未跟踪的文件、没有修改的文件）则返回true，否则返回false
+ */
+export function checkGitStatus() {
+    // 执行git status --porcelain命令，获取简短的git状态输出
+    // --porcelain选项会以机器可读的格式显示状态信息
+    const gitStatus = execSync('git status --porcelain').toString().trim();
+    // 检查状态输出是否为空字符串
+    // 如果为空，表示工作目录干净，没有未提交的更改
+    return gitStatus === '';
+}
+/**
+ * 日志输出
+ *
+ * @property info - 信息日志
+ * @property success - 成功日志
+ * @property error - 错误日志
+ * @property warn - 警告日志
+ */
+export const log = {
+    info: (message) => {
+        console.log(chalk.cyan(`Info：${message}`));
+    },
+    success: (message) => {
+        console.log(chalk.green(`Success：✅ ${message}`));
+    },
+    error: (message) => {
+        console.log(chalk.red(`Error：❌ ${message}`));
+    },
+    warn: (message) => {
+        console.log(chalk.yellow(`Warn：⚠️ ${message}`));
+    }
+};
+/**
+ * 选择版本升级类型
+ * @param currentVersion 当前版本号
+ * @returns {Promise<string>} 返回格式化后的新版本号
+ */
+export async function selectVersion(currentVersion) {
+    console.log(chalk.cyan('\n请选择版本升级类型：')); // 打印提示信息
+    const items = [];
+    // 解析预发布版本标识符和版本号
+    const prerelease = semver.prerelease(currentVersion);
+    // 如果已经是预发布版本，且存在标识符，则返回标识符
+    const defaultPreid = prerelease && prerelease.length === 2 ? prerelease[0] : 'alpha';
+    VERSION_TYPE.forEach((t) => {
+        const next = semver.inc(currentVersion, t, t.startsWith('pre') ? defaultPreid : ''); // 计算下一个版本号
+        if (next) {
+            items.push(t);
+            console.log(`${chalk.yellow(items.length + '.')}${chalk.green(t)}：${VERSION_TYPE_DESC[t]}${chalk.cyan(`（${currentVersion} → ${next}）`)}`);
+        }
+    });
+    console.log(`${chalk.yellow('&.')}${chalk.green('custom')}：输入一个自定义版本号`);
+    // 如果已经是预发布版本，且存在标识符，则默认更新预发布版本
+    const defaultType = prerelease && prerelease.length === 2 ? 'prepatch' : 'patch';
+    const answer = await prompt(`
+输入序号选择类型 (默认 ${defaultType}): `); // 获取用户输入
+    // 自定义版本号，则返回输入的版本号
+    if (answer.length > 1) {
+        return await formatVersionNumber(currentVersion, answer, undefined);
+    }
+    const index = parseInt(answer, 10); // 将输入转换为数字
+    const type = items[index - 1] || defaultType;
+    return await formatVersionNumber(currentVersion, type, undefined);
+}
+/**
+ * 获取预发布标识符（preid）的函数
+ * @param currentVersion 当前版本号
+ * @param isPreRelease 是否为预发布版本
+ * @returns {Promise<string>} 返回预发布标识符
+ */
+export async function getPreid(currentVersion, isPreRelease) {
+    // 解析预发布版本标识符和版本号
+    const prerelease = semver.prerelease(currentVersion);
+    // 如果已经是预发布版本，且存在标识符，则返回标识符
+    const defaultPreid = prerelease?.length === 2 ? prerelease[0] : 'alpha';
+    if (isPreRelease && prerelease?.length === 2)
+        return defaultPreid;
+    // 打印提示信息，让用户选择预发布标识
+    log.info('请选择预发布标识 preid：');
+    // 定义预发布标识选项列表
+    const preids = {
+        alpha: '内测版本',
+        beta: '公测版本',
+        rc: '候选版本'
+    };
+    const items = Object.keys(preids);
+    // 打印所有预发布标识选项
+    items.forEach((p, i) => console.log(`${chalk.yellow(i + 1 + '.')}${chalk.green(p)}：${preids[p]}`));
+    console.log(`${chalk.yellow('&.')}${chalk.green('custom')}：输入一个自定义标识符`);
+    // 提示用户输入序号选择preid，默认为alpha
+    const answer = await prompt(`输入序号选择 preid (默认 ${defaultPreid}): `);
+    // 如果未输入，则返回默认值
+    if (!answer)
+        return defaultPreid;
+    // 将输入转换为数字
+    const index = parseInt(answer, 10);
+    // 自定义版本号，则返回输入的版本号
+    if (isNaN(index))
+        return answer;
+    // 返回用户选择的preid，如果未选择则返回默认值
+    return items[index - 1] || defaultPreid;
+}
+/**
+ * 检测当前项目使用的包管理器
+ * @returns 返回 'npm' | 'pnpm' | 'yarn' 之一，表示当前项目使用的包管理器类型
+ */
+export function detectPackageManager() {
+    try {
+        // 检查是否存在 pnpm-lock.yaml 或 yarn.lock
+        if (fs.existsSync('pnpm-lock.yaml')) {
+            return 'pnpm';
+        }
+        else if (fs.existsSync('yarn.lock')) {
+            return 'yarn';
+        }
+        else if (fs.existsSync('package-lock.json')) {
+            return 'npm';
+        }
+        // 如果没有lock文件，尝试执行命令检测
+        try {
+            execSync('pnpm --version', { stdio: 'ignore' });
+            return 'pnpm';
+        }
+        catch {
+            try {
+                execSync('yarn --version', { stdio: 'ignore' });
+                return 'yarn';
+            }
+            catch {
+                return 'npm';
+            }
+        }
+    }
+    catch {
+        return 'npm'; // 默认使用 npm
+    }
+}
+/**
+ * 判断当前项目是否为工作空间项目
+ * 通过检查package.json中是否存在workspaces字段来判断
+ * @returns {boolean} 如果是工作空间项目返回true，否则返回false
+ */
+export function isWorkspaceProject() {
+    try {
+        // 读取并解析package.json文件
+        const pkg = JSON.parse(fs.readFileSync('package.json', 'utf-8'));
+        // 检查是否存在workspaces字段，并转换为布尔值返回
+        return !!pkg.workspaces;
+    }
+    catch {
+        // 如果读取或解析package.json时发生错误，返回false
+        return false;
+    }
+}
+/**
+ * 获取工作空间中的所有包信息
+ * @returns {Array<{ name: string; path: string; version: string }>} 返回一个包含包名、路径和版本的数组，如果不是工作空间项目则返回空数组
+ */
+export function getWorkspacePackages() {
+    // 首先检查是否为工作空间项目，如果不是则直接返回空数组
+    if (!isWorkspaceProject())
+        return [];
+    // 用于存储所有包信息的数组
+    const packages = [];
+    try {
+        // 读取根目录的package.json文件
+        const pkg = JSON.parse(fs.readFileSync('package.json', 'utf-8'));
+        // 获取workspaces配置，如果没有则为空数组
+        const workspaces = pkg.workspaces || [];
+        // 遍历所有workspace模式
+        for (const workspacePattern of workspaces) {
+            // 获取所有目录
+            const workspaceDirs = fs
+                .readdirSync('.', { withFileTypes: true })
+                .filter((dirent) => dirent.isDirectory())
+                .map((dirent) => dirent.name)
+                .filter((dir) => {
+                // 简单的模式匹配（支持通配符）
+                if (workspacePattern.includes('*')) {
+                    const pattern = workspacePattern.replace(/\*/g, '.*');
+                    return new RegExp(`^${pattern}$`).test(dir);
+                }
+                return dir === workspacePattern;
+            });
+            for (const dir of workspaceDirs) {
+                const pkgPath = path.join(dir, 'package.json');
+                if (fs.existsSync(pkgPath)) {
+                    const pkgContent = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+                    packages.push({
+                        name: pkgContent.name,
+                        path: dir,
+                        version: pkgContent.version
+                    });
+                }
+            }
+        }
+    }
+    catch (error) {
+        log.warn(`获取 workspace 包信息失败 - ${error}`);
+    }
+    return packages;
+}
+/**
+ * 格式化版本号函数
+ * 根据当前版本号和下一个版本类型或自定义版本号生成新的版本号
+ * @param currentVersion 当前版本号
+ * @param nextVersion 下一个版本类型或自定义版本号
+ * @param preid 预发布标识符（可选）
+ * @returns {Promise<string>} 返回格式化后的新版本号
+ * @throws Error 如果输入的版本类型/版本号无效，则抛出错误
+ */
+export async function formatVersionNumber(currentVersion, // 当前版本号，字符串类型
+nextVersion, // 下一个版本类型或自定义版本号，字符串类型
+preid // 预发布标识符，可选字符串类型
+) {
+    let newVersion; // 声明新版本号变量
+    // 检查nextVersion是否是预定义的版本类型之一
+    if (VERSION_TYPE.includes(nextVersion)) {
+        // 如果是预发布版本则获取预发布标识符
+        if (!preid && nextVersion.startsWith('pre')) {
+            preid = await getPreid(currentVersion, nextVersion === 'prerelease');
+        }
+        newVersion = semver.inc(currentVersion, nextVersion, preid);
+        if (!newVersion)
+            throw new Error(`输入的版本类型 '${nextVersion}' 无法完成版本号更新，请检查当前版本号${currentVersion}是否符合此类型更新要求`);
+    }
+    else {
+        newVersion = nextVersion;
+    }
+    if (!semver.valid(newVersion)) {
+        throw new Error(`输入无效的版本类型/版本号 '${nextVersion}'，支持有效的版本类型 (${VERSION_TYPE.join(',')}) 或有效的自定义版本号`);
+    }
+    if (semver.lte(newVersion, currentVersion)) {
+        throw new Error(`输入的版本号 '${newVersion}' 必须大于当前版本号 (${currentVersion})`);
+    }
+    return newVersion;
+}
+/**
+ * 执行命令函数
+ * @param cmd - 需要执行的命令字符串
+ * @param isDryRun - 是否为试运行模式，默认为false
+ * 当isDryRun为true时，仅打印命令而不实际执行
+ * 当isDryRun为false时，打印命令并实际执行
+ */
+export function runCommand(cmd, isDryRun = false) {
+    // 打印要执行的命令信息
+    console.log(`${chalk.blue(`${isDryRun ? '模拟' : ''}执行命令`)}: ${cmd}`);
+    // 如果不是试运行模式，则实际执行命令
+    if (!isDryRun) {
+        // 使用execSync执行命令，stdio: 'inherit'表示子进程的stdio与父进程共享
+        execSync(cmd, { stdio: 'inherit' });
+    }
+}
+/**
+ * 回滚代码变更的函数
+ * @param tagName - 可选的标签名称，用于删除创建的标签
+ * @param isDryRun - 是否为试运行模式，默认为false
+ */
+export function rollbackChanges(tagName, isDryRun = false) {
+    // 输出警告信息，提示用户正在回滚
+    log.warn('发生错误，正在回滚...');
+    try {
+        // 执行git命令，回退到上一个提交
+        runCommand('git reset --hard HEAD~1', isDryRun);
+    }
+    catch {
+        // 捕获并忽略执行过程中的错误
+        log.error('回滚失败，请手动处理。');
+    }
+    // 如果提供了标签名称，则尝试删除该标签
+    if (tagName) {
+        try {
+            runCommand(`git tag -d ${tagName}`, isDryRun);
+        }
+        catch {
+            // 捕获并忽略执行过程中的错误
+            log.error('删除标签失败，请手动处理。');
+        }
+    }
+    // 输出错误信息，告知用户已回滚完成
+    log.error('已回滚到初始状态。');
+}
+/**
+ * 更新指定包的版本号
+ * @param pkgPath - 包的文件路径
+ * @param newVersion - 新的版本号
+ * @param isDryRun - 是否为试运行模式，默认为false
+ */
+export function updateVersion(pkgPath, // 包的文件路径
+newVersion, // 新的版本号
+isDryRun = false // 是否为试运行模式，默认为false
+) {
+    // 如果不是试运行模式，则执行实际的版本更新操作
+    if (!isDryRun) {
+        // 读取并解析包文件
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        // 更新版本号
+        pkg.version = newVersion;
+        // 将更新后的包内容写回文件，并添加格式化和换行
+        fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+    }
+    else {
+        log.info(`dry-run 模式下跳过写入新版本号${newVersion}`);
+    }
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@vitarx/release-cli",
+  "version": "1.0.0-alpha.0",
+  "description": "A CLI tool for automated npm package release with workspace support",
+  "main": "dist/index.js",
+  "type": "module",
+  "author": "zhuchonglin <8210856@qq.com>",
+  "license": "MIT",
+  "bin": {
+    "release-cli": "dist/index.js"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^19.8.1",
+    "@commitlint/config-conventional": "^19.8.1",
+    "@commitlint/types": "^19.8.1",
+    "@types/node": "^24.3.1",
+    "@types/semver": "^7.7.1",
+    "husky": "^9.1.7",
+    "typescript": "^5.9.2"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "conventional-changelog": "^7.1.1",
+    "conventional-changelog-angular": "^8.0.0",
+    "semver": "^7.7.2"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "rimraf dist && tsc",
+    "test": "node dist/index.js --dry-run"
+  }
+}