@varlet/release 2.0.1 → 2.1.1

package/README.md

@@ -28,90 +28,156 @@ pnpm add @varlet/release -D
 
 ## Usage
 
-### Core Workflow
+### Features Overview
 
-When executing `vr release`, the following sequence of lifecycles occurs automatically:
+- [release](#release) - Automatically complete the standard workflow from version modification to publishing and creating git tags.
+- [publish](#publish) - Execute the npm publish process independently, usually suitable for CI/CD environments.
+- [changelog](#changelog) - Automatically generate formatted changelogs based on Git Commit conventions.
+- [commit-lint](#commit-lint) - Validate whether the Git Commit Message adheres to specifications, helping teams unify commit formats.
+- [lockfile-check](#lockfile-check) - Check the status of the project's lockfile and provide dependency update mechanisms when changes occur.
 
-1. Select/Confirm the **version** to publish interactively
-2. Execute the user-defined `task` function (optional, e.g., to rebuild projects based on the new version)
-3. Update the `package.json` **version** programmatically
-4. Generate the **Changelog**
-5. **Git Commit** & **Git Tag**
-6. **Publish** to npm
+---
 
-### Using Command
+### release
+
+**Description**: The core functional collection for package release, integrating all release preparation and subsequent operations.
+
+**Use cases**: Used when a new version needs to be released and all workspace changes have been committed. It guides through the publication via an intuitive command-line interaction.
+
+**Core Workflow**:
+
+1. Interactively prompt and confirm the new version number (automatically calculate patch, minor, major upgrades).
+2. Execute the user-customized `task` function (e.g., modifying files, bundling assets).
+3. Automatically update the version number in the project's `package.json`.
+4. Generate the `Changelog` for the corresponding version.
+5. Automatically complete the Git commit and create a new version Tag.
+6. Publish the updated packages to npm.
+
+**CLI Commands**:
+
+_Flags Reference_:
+
+```text
+Usage: vr release [flags...]
+
+Flags:
+  -r, --remote <string>             Remote repository name
+  -s, --skip-npm-publish            Skip npm publish
+      --skip-changelog              Skip generating changelog
+      --skip-git-tag                Skip git tag
+  -t, --npm-tag <string>            npm tag
+  -c, --check-remote-version        Check remote version
+```
+
+_Example_:
 
 ```shell
-# Release all packages and run the full workflow
+# Release all packages and execute the full workflow
 npx vr release
 
-# Specify remote name
+# Specify remote repository name (default origin)
 npx vr release -r origin
-# or
-npx vr release --remote origin
 
-# Just generate changelogs
-npx vr changelog
+# Skip npm publishing
+npx vr release -s
+# Skip generating changelog
+npx vr release --skip-changelog
+# Check remote version, interrupt execution if the identical version already exists
+npx vr release -c
+```
 
-# Specify changelog filename
-npx vr changelog -f changelog.md
-# or
-npx vr changelog --file changelog.md
+**Node API**:
+
+```typescript
+import { release } from '@varlet/release'
+
+release({
+  remote?: string              // Remote repository name, defaults to 'origin'
+  npmTag?: string              // NPM tag to publish, such as 'next', 'alpha'
+  cwd?: string                 // Working directory, defaults to process.cwd()
+  skipNpmPublish?: boolean     // Whether to skip the npm publish process
+  skipChangelog?: boolean      // Whether to skip changelog generation
+  skipGitTag?: boolean         // Whether to skip git tag creation
+  checkRemoteVersion?: boolean // Whether to check remote version to avoid conflicts
+  task?(newVersion: string, oldVersion: string): Promise<void> // Custom task executed during the release
+})
+```
 
-# Lint commit message
-npx vr commit-lint -p .git/COMMIT_EDITMSG
+_Example: Add custom handling logic_
 
-# Publish to npm, which can be called in the ci environment
-npx vr publish
+```javascript
+import { release } from '@varlet/release'
 
-# Check if lockfile has been updated
-npx vr lockfile-sync-check
+async function task(newVersion, oldVersion) {
+  // Execute building or file writing operations here
+  await doBuild()
+}
 
-# Auto install dependencies if lockfile changed
-npx vr lockfile-sync-check -i
+release({ task })
 ```
 
-### Git Hooks Integration (Best Practice)
+---
 
-It is highly recommended to use `commit-lint` with `simple-git-hooks` or `husky` in `package.json` to automatically check developers' commit messages before committing:
+### publish
 
-```json
-{
-  "simple-git-hooks": {
-    "commit-msg": "npx vr commit-lint -p $1"
-  }
-}
-```
+**Description**: Publish the package independently to the npm registry.
 
-### Configuration
+**Use cases**: Applicable in scenarios where manual version selection, changelog generation, or git tags are not needed, often used in CI/CD pipelines to trigger automated publication based on specific processes.
 
-#### release
+**Core Workflow**: Read the version number from the current package.json and run the corresponding publish process.
 
-```
-Usage: vr release [flags...]
+**CLI Commands**:
+
+_Flags Reference_:
+
+```text
+Usage: vr publish [flags...]
 
 Flags:
-  -r, --remote <string>             Remote name
-  -s, --skip-npm-publish            Skip npm publish
-      --skip-changelog              Skip generate changelog
-      --skip-git-tag                Skip git tag
-  -t, --npm-tag <string>            Npm tag
   -c, --check-remote-version        Check remote version
+  -t, --npm-tag <string>            npm tag
 ```
 
-#### publish
+_Example_:
 
-```
-Usage: vr publish [flags...]
+```shell
+# Publish directly to npm
+npx vr publish
 
-Flags:
-  -c, --check-remote-version        Check remote version
-  -t, --npm-tag <string>            Npm tag
+# Check if the same version already exists due to network or other reasons, and abort if so
+npx vr publish -c
+# Specify the npm dist-tag
+npx vr publish -t alpha
 ```
 
-#### changelog
+**Node API**:
 
+```typescript
+import { publish } from '@varlet/release'
+
+publish({
+  preRelease?: boolean         // Pre-release indicator, will add the '--tag alpha' option
+  checkRemoteVersion?: boolean // Check if the same version exists on the remote npm before publishing
+  npmTag?: string              // NPM tag to publish
+  cwd?: string                 // Working directory, defaults to process.cwd()
+})
 ```
+
+---
+
+### changelog
+
+**Description**: Automatically generate Markdown-formatted changelogs based on standard Commit history.
+
+**Use cases**: Useful for updating the `CHANGELOG.md` file independently without triggering the full release process.
+
+**Core Workflow**: Traverse the Git commit history and format the output classified by predefined conventional commit rules (e.g., feat, fix).
+
+**CLI Commands**:
+
+_Flags Reference_:
+
+```text
 Usage: vr changelog [flags...]
 
 Flags:
@@ -119,52 +185,144 @@ Flags:
   -f, --file <string>               Changelog filename
 ```
 
-#### commit-lint
+_Example_:
 
+```shell
+# Generate changelogs for all history and output as CHANGELOG.md in the current directory
+npx vr changelog
+
+# Specify the generated changelog filename
+npx vr changelog -f my-changelog.md
+# Limit the range of release versions to generate changelogs for (0 means all)
+npx vr changelog -c 0
+```
+
+**Node API**:
+
+```typescript
+import { changelog } from '@varlet/release'
+
+changelog({
+  cwd?: string                 // Working directory, defaults to process.cwd()
+  releaseCount?: number        // Number of recent releases to include in the log, defaults to 0 (all)
+  file?: string                // Output changelog filename, defaults to 'CHANGELOG.md'
+  showTypes?: string[]         // Commit types to display, defaults to ['feat', 'fix', 'perf', 'revert', 'refactor']
+  outputUnreleased?: boolean   // Whether to output unreleased changes
+  writerOpt?: object           // Specific configuration for conventional-changelog-writer
+})
 ```
+
+---
+
+### commit-lint
+
+**Description**: Validate Git commit message formats.
+
+**Use cases**: Used in combination with `git hooks` to enforce high-quality commit descriptions, ensuring the quality of the changelog.
+
+**Core Workflow**: Read the commit file. If it matches the configured regex, the process continues; otherwise, it prints specific failure messages and aborts the commit.
+
+**CLI Commands**:
+
+_Flags Reference_:
+
+```text
 Usage: vr commit-lint [flags...]
 
 Flags:
   -p, --commit-message-path <string>  Git commit message path
-  -r, --commit-message-re <string>    Validate the regular of whether the commit message passes
-  -e, --error-message <string>        Validation failed to display error messages
-  -w, --warning-message <string>      Validation failed to display warning messages
+  -r, --commit-message-re <string>    Validate the regex for commit message
+  -e, --error-message <string>        Error message displayed on validation failure
+  -w, --warning-message <string>      Warning message displayed on validation failure
 ```
 
-#### lockfile-sync-check
+_Example_:
 
+```shell
+# Check if the commit message at the given path is standard
+npx vr commit-lint -p .git/COMMIT_EDITMSG
+
+# Customize regex validation and prompt message
+npx vr commit-lint -p .git/COMMIT_EDITMSG -r "^feat: .*" -e "Commit validation failed"
 ```
-Usage: vr lockfile-sync-check [flags...]
+
+_It is recommended to integrate with `simple-git-hooks` or `husky` in `package.json`:_
+
+```json
+{
+  "simple-git-hooks": {
+    "commit-msg": "npx vr commit-lint -p $1"
+  }
+}
+```
+
+**Node API**:
+
+```typescript
+import { commitLint } from '@varlet/release'
+
+commitLint({
+  commitMessagePath: string            // Required: Path to Git commit message file
+  commitMessageRe?: string | RegExp    // Regex to validate the commit message format
+  errorMessage?: string                // Error message printed upon failure
+  warningMessage?: string              // Supplemental warning information printed upon failure
+})
+```
+
+---
+
+### lockfile-check
+
+**Description**: Detect and visually output in the console whether the lockfile of frontend dependencies has been modified.
+
+**Use cases**: Recommended to use after Git operations such as pulling updates (`git pull`), switching branches (`git checkout`), or merging code. It helps detect if upstream dependency lockfiles (like `pnpm-lock.yaml`) have changed. If a change is detected, you can invoke a package manager's installation command through specific options to synchronize the local environment with upstream instantly, preventing obscure bugs caused by outdated dependencies.
+
+**Core Workflow**: Execute a Git diff comparing the project's lockfile (e.g. `pnpm-lock.yaml` or corresponding environment lockfile) from the original HEAD. Print its modification status in the console. Furthermore, trigger the package manager to reinstall dependencies to sync with upstream if directed by the command options.
+
+**CLI Commands**:
+
+_Flags Reference_:
+
+```text
+Usage: vr lockfile-check [flags...]
 
 Flags:
   -m, --package-manager <string>    Package manager (npm, yarn, pnpm), default pnpm
   -i, --install                     Auto install dependencies if lockfile changed
 ```
 
-### Node API Custom Handle
+_Example_:
 
-You can write your own release scripts with Internal Node.js API instead of CLI.
-
-#### Example
+```shell
+# Check the synchronization status of the current lockfile
+npx vr lockfile-check
 
-```js
-import { changelog, release } from '@varlet/release'
+# Check current status, forcefully run installation to sync dependencies if updates exist
+npx vr lockfile-check -i
 
-// Run the core release workflow directly
-release()
+# Specify other package managers for checking (defaults to pnpm)
+npx vr lockfile-check -m npm
 ```
 
-You can pass in a custom `task` function that will be called after the package version is updated but before the remaining publish steps.
-
-```js
-import { changelog, release } from '@varlet/release'
+_It is also recommended to integrate with `simple-git-hooks` or `husky` in `package.json` (e.g. trigger checks and installations automatically during the `post-merge` or `post-checkout` hooks):_
 
-async function task(newVersion, oldVersion) {
-  await doSomething1()
-  await doSomething2()
+```json
+{
+  "simple-git-hooks": {
+    "post-merge": "npx vr lockfile-check -i"
+  }
 }
+```
 
-release({ task })
+**Node API**:
+
+```typescript
+import { lockfileCheck } from '@varlet/release'
+
+lockfileCheck({
+  packageManager?: 'npm' | 'yarn' | 'pnpm' // Choose package manager, defaults to 'pnpm'
+  install?: boolean                        // Whether to automatically run install if lockfile is out of sync
+})
 ```
 
 ## License

package/README.zh-CN.md

@@ -28,80 +28,109 @@ pnpm add @varlet/release -D
 
 ## 使用
 
-### 核心工作流
+### 功能概览
 
-执行 `vr release` 时，背后会自动完成以下流程（保障每一步的严谨性）：
+- [release](#release) - 自动完成从版本号变更到发布、打标签的标准工作流。
+- [publish](#publish) - 单独执行 npm 发布流程，通常适用于 CI/CD 环境。
+- [changelog](#changelog) - 根据 Git Commit 规范自动生成格式化的变更日志。
+- [commit-lint](#commit-lint) - 校验 Git Commit Message 是否符合规范，帮助团队统一提交格式。
+- [lockfile-check](#lockfile-check) - 检查项目 lockfile 状态并在变化时提供更新依赖机制。
 
-1. 交互式选择/确认要发布的版本号
-2. 执行用户自定义的额外 `task` 操作（可选，如重新构建以注入新版本号）
-3. 自动修改工程中的版本号信息
-4. 自动生成符合规范的 Changelog
-5. Git 提交 (Commit) 与打标签 (Tag)
-6. 发布至 npm
+---
 
-### 命令行使用
+### release
+
+**作用**：包版本发布的核心功能集合，集成和串联了所有的发布准备及后续操作。
+
+**使用场景**：在项目需要发布新版本且工作区变更已全部提交时使用。通过直观的命令行交互完成发布。
+
+**核心流程**：
+
+1. 交互式提示并确认发布版本号（自动计算 patch、minor 等升级维度）。
+2. 执行用户自定义的 `task` 函数（例如修改文件，打包构建）。
+3. 自动更新项目中 `package.json` 的版本号。
+4. 生成对应该版本的 `Changelog`。
+5. 自动完成 Git 提交动作并且打上新版本标签 (Tag)。
+6. 自动将更新后的包发布至 npm。
+
+**CMD 命令**：
+
+_标志参考_：
+
+```text
+用法: vr release [标志...]
+
+标志:
+  -r, --remote <string>             远程仓库名称
+  -s, --skip-npm-publish            跳过 npm 发布
+      --skip-changelog              跳过生成变更日志
+      --skip-git-tag                跳过 git tag
+  -t, --npm-tag <string>            npm tag
+  -c, --check-remote-version        检查远程版本
+```
+
+_使用示例_：
 
 ```shell
 # 发布所有包并执行完整工作流程
 npx vr release
 
-# 指定远程仓库名称
+# 指定远程仓库名称 (默认 origin)
 npx vr release -r origin
-# 或
-npx vr release --remote origin
 
-# 仅生成变更日志
-npx vr changelog
+# 跳过 npm 发布
+npx vr release -s
+# 跳过生成变更日志
+npx vr release --skip-changelog
+# 检查远程版本，若已存在相同版本则中断执行
+npx vr release -c
+```
 
-# 指定变更日志文件名
-npx vr changelog -f changelog.md
-# 或
-npx vr changelog --file changelog.md
+**Node 调用**：
+
+```typescript
+import { release } from '@varlet/release'
+
+release({
+  remote?: string              // 远程仓库名称，默认为 'origin'
+  npmTag?: string              // 发布的 npm tag，如 'next'、'alpha'
+  cwd?: string                 // 工作目录，默认为 process.cwd()
+  skipNpmPublish?: boolean     // 是否跳过 npm publish 过程
+  skipChangelog?: boolean      // 是否跳过生成变更日志
+  skipGitTag?: boolean         // 是否跳过构建 git tag 过程
+  checkRemoteVersion?: boolean // 是否检查远程版本，保证不发生版本冲突
+  task?(newVersion: string, oldVersion: string): Promise<void> // 发布过程中执行的自定义任务
+})
+```
 
-# 检测 commit message 是否符合规范
-npx vr commit-lint -p .git/COMMIT_EDITMSG
+_例：增加自定义处理逻辑_
 
-# 发布到 npm（通常在 CI/CD 中执行）
-npx vr publish
+```javascript
+import { release } from '@varlet/release'
 
-# 检查 lockfile 是否已更新
-npx vr lockfile-sync-check
+async function task(newVersion, oldVersion) {
+  // 在此处执行构建或写入文件的操作
+  await doBuild()
+}
 
-# 如果 lockfile 发生变化则自动安装依赖
-npx vr lockfile-sync-check -i
+release({ task })
 ```
 
-### Git Hooks 集成 (推荐最佳实践)
-
-建议在 `package.json` 中配合 `simple-git-hooks` 或 `husky` 使用 `commit-lint`，在开发者提交代码时自动触发校验：
+---
 
-```json
-{
-  "simple-git-hooks": {
-    "commit-msg": "npx vr commit-lint -p $1"
-  }
-}
-```
+### publish
 
-### 配置参考
+**作用**：单独将包发布至 npm 仓库。
 
-#### release
+**使用场景**：适用于无需手动选择版本、生成 Changelog 或打 Git Tag 的场景，常用于在 CI/CD 流水线中针对特定过程触发自动化发布。
 
-```
-用法: vr release [标志...]
+**核心流程**：读取当前 package.json 中的版本号，运行对应的 publish 流程。
 
-标志:
-  -r, --remote <string>             远程仓库名称
-  -s, --skip-npm-publish            跳过 npm 发布
-      --skip-changelog              跳过生成变更日志
-      --skip-git-tag                跳过 git tag
-  -t, --npm-tag <string>            npm tag
-  -c, --check-remote-version        检查远程版本
-```
+**CMD 命令**：
 
-#### publish
+_标志参考_：
 
-```
+```text
 用法: vr publish [标志...]
 
 标志:
@@ -109,9 +138,46 @@ npx vr lockfile-sync-check -i
   -t, --npm-tag <string>            npm tag
 ```
 
-#### changelog
+_使用示例_：
+
+```shell
+# 直接发布到 npm
+npx vr publish
+
+# 检查由于网络等原因是否已存在相同版本，存在则放弃发布
+npx vr publish -c
+# 指定 npm 的 dist-tag
+npx vr publish -t alpha
+```
+
+**Node 调用**：
 
+```typescript
+import { publish } from '@varlet/release'
+
+publish({
+  preRelease?: boolean         // 预发布标示，将添加 '--tag alpha' 选项
+  checkRemoteVersion?: boolean // 发布前检查远程 npm 上是否已存在相同版本
+  npmTag?: string              // 发布的 npm tag
+  cwd?: string                 // 工作目录，默认为 process.cwd()
+})
 ```
+
+---
+
+### changelog
+
+**作用**：基于规范的 Commit 历史自动生成 Markdown 格式的变更日志。
+
+**使用场景**：单独更新 `CHANGELOG.md` 记录，单点生成所需日志。
+
+**核心流程**：遍历 Git 提交历史，依据预设的 conventional commit 规则分类（如 feat、fix 等），格式化输出。
+
+**CMD 命令**：
+
+_标志参考_：
+
+```text
 用法: vr changelog [标志...]
 
 标志:
@@ -119,9 +185,48 @@ npx vr lockfile-sync-check -i
   -f, --file <string>               变更日志文件名
 ```
 
-#### commit-lint
+_使用示例_：
+
+```shell
+# 生成所有历史的变更日志并在当前目录输出为 CHANGELOG.md
+npx vr changelog
+
+# 指定生成的变更日志文件名
+npx vr changelog -f my-changelog.md
+# 限定发布版本的范围数量以生成变更日志 (0 为全量)
+npx vr changelog -c 0
+```
+
+**Node 调用**：
+
+```typescript
+import { changelog } from '@varlet/release'
 
+changelog({
+  cwd?: string                 // 工作目录，默认为 process.cwd()
+  releaseCount?: number        // 输出日志涉及的最近发布的版本数量，默认为 0（全部）
+  file?: string                // 输出的日志文件名，默认为 'CHANGELOG.md'
+  showTypes?: string[]         // 显示的 commit 类型，默认 ['feat', 'fix', 'perf', 'revert', 'refactor']
+  outputUnreleased?: boolean   // 是否输出 unreleased 版本变更
+  writerOpt?: object           // conventional-changelog-writer 具体配置参数
+})
 ```
+
+---
+
+### commit-lint
+
+**作用**：校验 Git 提交信息格式。
+
+**使用场景**：结合 `git hooks` 一同工作，强制保障书写高质量的提交说明以保证 Changelog 质量。
+
+**核心流程**：读取提交文件，若是符合配置的正则格式则通过处理，否则打印具体的失败信息报错，并终止提交。
+
+**CMD 命令**：
+
+_标志参考_：
+
+```text
 用法: vr commit-lint [标志...]
 
 标志:
@@ -131,40 +236,93 @@ npx vr lockfile-sync-check -i
   -w, --warning-message <string>      验证失败时显示的警告信息
 ```
 
-#### lockfile-sync-check
+_使用示例_：
+
+```shell
+# 检测指路径的 commit message 是否符合规范
+npx vr commit-lint -p .git/COMMIT_EDITMSG
 
+# 定制指定的校验正则表达式和提示信息
+npx vr commit-lint -p .git/COMMIT_EDITMSG -r "^feat: .*" -e "提交校验失败"
 ```
-用法: vr lockfile-sync-check [标志...]
+
+_建议配合并在 `package.json` 中的 `simple-git-hooks` 或 `husky` 一同集成运作：_
+
+```json
+{
+  "simple-git-hooks": {
+    "commit-msg": "npx vr commit-lint -p $1"
+  }
+}
+```
+
+**Node 调用**：
+
+```typescript
+import { commitLint } from '@varlet/release'
+
+commitLint({
+  commitMessagePath: string            // 必选：Git commit message 文件路径
+  commitMessageRe?: string | RegExp    // 验证 msg 格式的正则表达式
+  errorMessage?: string                // 验证失败时打印的提示文本
+  warningMessage?: string              // 验证失败时打印的补充警告文档链接
+})
+```
+
+---
+
+### lockfile-check
+
+**作用**：检测并在控制台直观地输出前端依赖包的 lockfile 文件是否发生变更。
+
+**使用场景**：通常在进行 `git 操作` (如 `git pull`拉取最新代码、`git checkout`切换分支、或合并代码) 之后使用。它能帮助你检测上游的依赖锁文件（如 `pnpm-lock.yaml`）是否发生了变动。如果检测到有变更，可以通过可选操作直接执行 install 安装命令，从而确保本地环境快速与上游依赖保持一致，避免因依赖版本陈旧导致的疑难 bug。
+
+**核心流程**：比对项目原始游标的锁文件（如 pnpm-lock.yaml 或对应环境的 lockfile）的 Git diff，在控制台输出其是否存在变动；并根据指令决定是否随后触发包管理器的依赖重装程序以同步上游。
+
+**CMD 命令**：
+
+_标志参考_：
+
+```text
+用法: vr lockfile-check [标志...]
 
 标志:
   -m, --package-manager <string>    包管理器 (npm, yarn, pnpm)，默认 pnpm
   -i, --install                     如果 lockfile 发生变化则自动安装依赖
 ```
 
-### Node API 自定义处理
-
-除了命令行，你也可以使用 Node.js API 结合内部逻辑编写发布脚本。
+_使用示例_：
 
-#### 示例代码
+```shell
+# 检查当前 lockfile 的同步状态
+npx vr lockfile-check
 
-```js
-import { changelog, release } from '@varlet/release'
+# 检查当前状态，若存在更新则强制运行安装命令同步依赖
+npx vr lockfile-check -i
 
-// 执行默认发布流程
-release()
+# 指定其他包管理器进行检查（默认使用 pnpm）
+npx vr lockfile-check -m npm
 ```
 
-你可以传入一个 `task` 函数，在版本号变更之后、发布到 npm 等后续操作之前被调用。
-
-```js
-import { changelog, release } from '@varlet/release'
+_建议配合并在 `package.json` 中的 `simple-git-hooks` 或 `husky` 一同集成运作（例如在拉取代码的 `post-merge` 或 `post-checkout` 阶段自动触发检查与安装）：_
 
-async function task(newVersion, oldVersion) {
-  await doSomething1()
-  await doSomething2()
+```json
+{
+  "simple-git-hooks": {
+    "post-merge": "npx vr lockfile-check -i"
+  }
 }
+```
 
-release({ task })
+**Node 调用**：
+
+```typescript
+import { lockfileCheck } from '@varlet/release'
+
+lockfileCheck({
+  packageManager?: 'npm' | 'yarn' | 'pnpm' // 选择包管理器，默认为 'pnpm'
+  install?: boolean                        // 检测到 lock 不同步时是否自动运行对应的 install 重新安装
+})
 ```
 
 ## 许可证

package/dist/cli.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import { c as release, i as lockfileSyncCheck, p as commitLint, s as publish, u as changelog } from "./src-CVV7ij5v.js";
+import { c as release, i as lockfileCheck, p as commitLint, s as publish, u as changelog } from "./src-DJEBh4nv.js";
 import { cli, command } from "cleye";
 //#endregion
 //#region src/cli.ts
 cli({
 	name: "vr",
-	version: "2.0.1",
+	version: "2.1.1",
 	commands: [
 		command({
 			name: "release",
@@ -102,7 +102,7 @@ cli({
 			help: { description: "Lint commit message" }
 		}, (argv) => commitLint(argv.flags)),
 		command({
-			name: "lockfile-sync-check",
+			name: "lockfile-check",
 			flags: {
 				packageManager: {
 					type: String,
@@ -117,7 +117,7 @@ cli({
 				}
 			},
 			help: { description: "Check if lockfile has been updated and optionally install dependencies" }
-		}, (argv) => lockfileSyncCheck(argv.flags))
+		}, (argv) => lockfileCheck(argv.flags))
 	]
 });
 //#endregion

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Commit, Params } from "conventional-changelog";
+import { ConventionalChangelog } from "standard-changelog";
 
 //#region src/release.d.ts
 interface PackageJsonConfig {
@@ -38,20 +38,34 @@ interface ReleaseCommandOptions {
 declare function release(options: ReleaseCommandOptions): Promise<void>;
 //#endregion
 //#region src/changelog.d.ts
-interface ChangelogCommandOptions {
+declare const COMMIT_TYPE_MAP: {
+  readonly feat: "Features";
+  readonly fix: "Bug Fixes";
+  readonly perf: "Performance Improvements";
+  readonly revert: "Reverts";
+  readonly refactor: "Refactoring";
+  readonly docs: "Documentation";
+  readonly style: "Styles";
+  readonly test: "Tests";
+  readonly build: "Build System";
+  readonly ci: "Continuous Integration";
+};
+interface ChangelogOptions {
   cwd?: string;
-  file?: string;
   releaseCount?: number;
-  mainTemplate?: string;
-  transformCommit?: (commit: Commit, params: Params) => Partial<Commit> | Promise<Partial<Commit> | null> | null;
+  file?: string;
+  showTypes?: (keyof typeof COMMIT_TYPE_MAP)[];
+  outputUnreleased?: boolean;
+  writerOpt?: Parameters<ConventionalChangelog["writer"]>[0];
 }
 declare function changelog({
   cwd,
   releaseCount,
   file,
-  mainTemplate,
-  transformCommit
-}?: ChangelogCommandOptions): Promise<void>;
+  showTypes,
+  outputUnreleased,
+  writerOpt
+}?: ChangelogOptions): Promise<void>;
 //#endregion
 //#region src/commitLint.d.ts
 declare const COMMIT_HEADER_RE: RegExp;
@@ -66,15 +80,15 @@ interface CommitLintCommandOptions {
 }
 declare function commitLint(options: CommitLintCommandOptions): void;
 //#endregion
-//#region src/lockfileSyncCheck.d.ts
+//#region src/lockfileCheck.d.ts
 type PackageManager = "npm" | "yarn" | "pnpm";
-interface LockfileSyncCheckOptions {
+interface LockfileCheckOptions {
   packageManager?: PackageManager;
   install?: boolean;
 }
 declare function getLockfilePath(packageManager: PackageManager): string;
 declare function checkLockfileSync(packageManager: PackageManager): Promise<boolean>;
 declare function installDependencies(packageManager: PackageManager): Promise<void>;
-declare function lockfileSyncCheck(options?: LockfileSyncCheckOptions): Promise<void>;
+declare function lockfileCheck(options?: LockfileCheckOptions): Promise<void>;
 //#endregion
-export { COMMIT_HEADER_RE, COMMIT_MESSAGE_RE, ChangelogCommandOptions, CommitLintCommandOptions, LockfileSyncCheckOptions, PackageManager, PublishCommandOptions, ReleaseCommandOptions, changelog, checkLockfileSync, commitLint, getCommitMessage, getLockfilePath, getPackageJsons, installDependencies, isSameVersion, isVersionCommitMessage, lockfileSyncCheck, publish, release, updateVersion };
+export { COMMIT_HEADER_RE, COMMIT_MESSAGE_RE, ChangelogOptions, CommitLintCommandOptions, LockfileCheckOptions, PackageManager, PublishCommandOptions, ReleaseCommandOptions, changelog, checkLockfileSync, commitLint, getCommitMessage, getLockfilePath, getPackageJsons, installDependencies, isSameVersion, isVersionCommitMessage, lockfileCheck, publish, release, updateVersion };

package/dist/index.js

@@ -1,2 +1,2 @@
-import { a as getPackageJsons, c as release, d as COMMIT_HEADER_RE, f as COMMIT_MESSAGE_RE, h as isVersionCommitMessage, i as lockfileSyncCheck, l as updateVersion, m as getCommitMessage, n as getLockfilePath, o as isSameVersion, p as commitLint, r as installDependencies, s as publish, t as checkLockfileSync, u as changelog } from "./src-CVV7ij5v.js";
-export { COMMIT_HEADER_RE, COMMIT_MESSAGE_RE, changelog, checkLockfileSync, commitLint, getCommitMessage, getLockfilePath, getPackageJsons, installDependencies, isSameVersion, isVersionCommitMessage, lockfileSyncCheck, publish, release, updateVersion };
+import { a as getPackageJsons, c as release, d as COMMIT_HEADER_RE, f as COMMIT_MESSAGE_RE, h as isVersionCommitMessage, i as lockfileCheck, l as updateVersion, m as getCommitMessage, n as getLockfilePath, o as isSameVersion, p as commitLint, r as installDependencies, s as publish, t as checkLockfileSync, u as changelog } from "./src-DJEBh4nv.js";
+export { COMMIT_HEADER_RE, COMMIT_MESSAGE_RE, changelog, checkLockfileSync, commitLint, getCommitMessage, getLockfilePath, getPackageJsons, installDependencies, isSameVersion, isVersionCommitMessage, lockfileCheck, publish, release, updateVersion };

package/dist/{src-CVV7ij5v.js → src-DJEBh4nv.js}

@@ -5,7 +5,7 @@ import { cancel, confirm, isCancel, select, spinner } from "@clack/prompts";
 import { logger } from "rslog";
 import semver from "semver";
 import { x } from "tinyexec";
-import { ConventionalChangelog } from "conventional-changelog";
+import { StandardChangelog } from "standard-changelog";
 //#region src/commitLint.ts
 const COMMIT_HEADER_RE = /^(revert|fix|feat|docs|perf|test|types|style|build|chore|release|refactor|merge|wip)(?:\(([^)]+)\))?(!)?:\s(.+)$/;
 const COMMIT_MESSAGE_RE = new RegExp(COMMIT_HEADER_RE.source.replace(/\$$/, "") + "(?:\\n[\\s\\S]+)?$");
@@ -39,9 +39,7 @@ Allowed types:
 - revert
 - merge
 - wip
-
-Commit message reference: https://docs.google.com/document/d/1QrDFcIiPjSLDn3EL15IJygNPiHORgU1_OOAqWjiDU5Y
-参考阮一峰Commit message编写指南: https://www.ruanyifeng.com/blog/2016/01/commit_message_change_log.html`;
+`;
 function isVersionCommitMessage(message) {
 	return Boolean(message.startsWith("v") && semver.valid(message.slice(1)));
 }
@@ -76,13 +74,14 @@ const COMMIT_TYPE_MAP = {
 	build: "Build System",
 	ci: "Continuous Integration"
 };
-const ALWAYS_SHOW_TYPES = new Set([
+const ALWAYS_SHOW_TYPES = [
 	"feat",
 	"fix",
 	"perf",
 	"revert",
 	"refactor"
-]);
+];
+const BREAKING_CHANGE_RE = /BREAKING CHANGES?:\s*([\s\S]+)/;
 const MAIN_TEMPLATE = `{{> header}}
 
 {{> footer}}
@@ -111,6 +110,15 @@ function linkify(text, context, issues) {
 	if (context.host) result = result.replace(/\B@([a-z0-9](?:-?[a-z0-9/]){0,38})/g, (_, username) => username.includes("/") ? `@${username}` : `[@${username}](${context.host}/${username})`);
 	return result;
 }
+function extractBreakingText(commit) {
+	const body = typeof commit.body === "string" ? commit.body : "";
+	const footer = typeof commit.footer === "string" ? commit.footer : "";
+	const match = BREAKING_CHANGE_RE.exec(`${footer}\n${body}`);
+	if (match?.[1]) return match[1].trim();
+	if (typeof commit.subject === "string" && commit.subject) return commit.subject;
+	if (typeof commit.header === "string" && commit.header) return commit.header;
+	return "";
+}
 function tryParseHeader(commit) {
 	if (typeof commit.header !== "string") return null;
 	const match = COMMIT_HEADER_RE.exec(commit.header.trim());
@@ -124,24 +132,19 @@ function tryParseHeader(commit) {
 }
 function processBreakingChanges(commit, context, issues) {
 	let discard = true;
-	commit.notes = [];
-	const getCommitHashLink = () => {
-		if (!commit.hash) return "";
-		const shortHash = commit.hash.substring(0, 7);
-		const repoUrl = context.repository ? `${context.host}/${context.owner}/${context.repository}` : context.repoUrl;
-		return repoUrl ? ` ([${shortHash}](${repoUrl}/commit/${commit.hash}))` : ` (${shortHash})`;
-	};
-	const hashLink = getCommitHashLink();
+	commit.notes.forEach((note) => {
+		note.title = "BREAKING CHANGES";
+		discard = false;
+	});
+	const hadBreakingNotes = commit.notes.length > 0;
 	const addBreakingNote = () => {
-		let text = linkify(typeof commit.subject === "string" && commit.subject ? commit.subject : typeof commit.header === "string" && commit.header ? commit.header : "", context, issues) + hashLink;
-		if (commit.body) {
-			const indentedBody = linkify(commit.body, context, issues).split("\n").map((line) => line.trim() ? `  ${line}` : "").join("\n");
-			text += `\n\n${indentedBody}`;
+		if (!hadBreakingNotes) {
+			const text = linkify(extractBreakingText(commit), context, issues);
+			commit.notes.push({
+				title: "BREAKING CHANGES",
+				text
+			});
 		}
-		commit.notes.push({
-			title: "BREAKING CHANGES",
-			text
-		});
 		discard = false;
 	};
 	const parsed = tryParseHeader(commit);
@@ -157,51 +160,42 @@ function processBreakingChanges(commit, context, issues) {
 	}
 	return discard;
 }
-function mapCommitType(commit, discard) {
-	if (commit.revert) {
-		commit.type = "Reverts";
-		return true;
-	}
+function mapCommitType(commit, discard, showTypes) {
+	if (commit.revert) commit.type = "revert";
+	if (!commit.type) return false;
 	const mapped = COMMIT_TYPE_MAP[commit.type];
 	if (mapped) {
-		if (ALWAYS_SHOW_TYPES.has(commit.type) || !discard) {
+		if (showTypes.includes(commit.type) || !discard) {
 			commit.type = mapped;
 			return true;
 		}
 	}
 	return !discard;
 }
-function createDefaultTransformCommit() {
-	return (commit, params) => {
-		const context = {
-			host: params.context?.host,
-			owner: params.context?.owner,
-			repository: typeof params.repository === "object" && params.repository !== null ? params.repository.project : void 0,
-			repoUrl: params.context?.repoUrl
-		};
-		const issues = [];
-		const mutableCommit = { ...commit };
-		if (mutableCommit.notes) mutableCommit.notes = [...mutableCommit.notes];
-		if (!mapCommitType(mutableCommit, processBreakingChanges(mutableCommit, context, issues))) return null;
-		if (mutableCommit.scope === "*") mutableCommit.scope = "";
-		if (typeof mutableCommit.hash === "string") mutableCommit.shortHash = mutableCommit.hash.substring(0, 7);
-		if (typeof mutableCommit.subject === "string") mutableCommit.subject = linkify(mutableCommit.subject, context, issues);
-		if (mutableCommit.references) mutableCommit.references = mutableCommit.references.filter((ref) => !issues.includes(ref.issue));
-		return mutableCommit;
+function createDefaultWriterOpts({ showTypes }) {
+	return {
+		mainTemplate: MAIN_TEMPLATE,
+		transform(_commit, context) {
+			const commit = JSON.parse(JSON.stringify(_commit));
+			const issues = [];
+			if (!mapCommitType(commit, processBreakingChanges(commit, context, issues), showTypes)) return null;
+			if (commit.scope === "*") commit.scope = "";
+			if (typeof commit.hash === "string") commit.shortHash = commit.hash.substring(0, 7);
+			if (typeof commit.subject === "string") commit.subject = linkify(commit.subject, context, issues);
+			commit.references = commit.references.filter((ref) => !issues.includes(ref.issue));
+			return commit;
+		}
 	};
 }
-function changelog({ cwd = process.cwd(), releaseCount = 0, file = "CHANGELOG.md", mainTemplate = MAIN_TEMPLATE, transformCommit = createDefaultTransformCommit() } = {}) {
+function changelog({ cwd = process.cwd(), releaseCount = 0, file = "CHANGELOG.md", showTypes = ALWAYS_SHOW_TYPES, outputUnreleased, writerOpt } = {}) {
 	const s = spinner();
 	s.start("Generating changelog");
+	const defaultWriterOpts = writerOpt || createDefaultWriterOpts({ showTypes });
 	return new Promise((resolve$1) => {
-		new ConventionalChangelog(cwd).readPackage().loadPreset("angular").options({
+		new StandardChangelog(cwd).readPackage().options({
 			releaseCount,
-			transformCommit,
-			outputUnreleased: true
-		}).writer({
-			mainTemplate,
-			transform: (commit) => commit
-		}).writeStream().pipe(createWriteStream(resolve(cwd, file))).on("close", () => {
+			outputUnreleased
+		}).writer(defaultWriterOpts).writeStream().pipe(createWriteStream(resolve(cwd, file))).on("close", () => {
 			s.stop("Changelog generated successfully!");
 			resolve$1();
 		});
@@ -357,10 +351,10 @@ function computeExpectVersion(currentVersion, type) {
 }
 async function getReleaseType(currentVersion) {
 	return unwrapPromptResult(await select({
-		message: "Please select release type",
+		message: `Please select release type, current version ${currentVersion}`,
 		options: RELEASE_TYPES.map((type) => {
 			return {
-				label: `${type} (${currentVersion} → ${computeExpectVersion(currentVersion, type)})`,
+				label: `${type} (${computeExpectVersion(currentVersion, type)})`,
 				value: type
 			};
 		})
@@ -420,7 +414,7 @@ async function release(options) {
 	}
 }
 //#endregion
-//#region src/lockfileSyncCheck.ts
+//#region src/lockfileCheck.ts
 function getLockfilePath(packageManager) {
 	switch (packageManager) {
 		case "pnpm": return "pnpm-lock.yaml";
@@ -461,10 +455,18 @@ async function installDependencies(packageManager) {
 		throw error;
 	}
 }
-async function lockfileSyncCheck(options = {}) {
+async function lockfileCheck(options = {}) {
 	try {
 		const pkgManager = options.packageManager || "pnpm";
 		const installFlag = options.install || false;
+		if (![
+			"npm",
+			"yarn",
+			"pnpm"
+		].includes(pkgManager)) {
+			logger.error(`Unsupported package manager: ${pkgManager}`);
+			return;
+		}
 		if (await checkLockfileSync(pkgManager)) {
 			logger.warn("Lockfile has been updated!");
 			if (installFlag) await installDependencies(pkgManager);
@@ -474,4 +476,4 @@ async function lockfileSyncCheck(options = {}) {
 	}
 }
 //#endregion
-export { getPackageJsons as a, release as c, COMMIT_HEADER_RE as d, COMMIT_MESSAGE_RE as f, isVersionCommitMessage as h, lockfileSyncCheck as i, updateVersion as l, getCommitMessage as m, getLockfilePath as n, isSameVersion as o, commitLint as p, installDependencies as r, publish as s, checkLockfileSync as t, changelog as u };
+export { getPackageJsons as a, release as c, COMMIT_HEADER_RE as d, COMMIT_MESSAGE_RE as f, isVersionCommitMessage as h, lockfileCheck as i, updateVersion as l, getCommitMessage as m, getLockfilePath as n, isSameVersion as o, commitLint as p, installDependencies as r, publish as s, checkLockfileSync as t, changelog as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@varlet/release",
-  "version": "2.0.1",
+  "version": "2.1.1",
   "description": "publish all packages, generate changelogs and check commit messages",
   "keywords": [
     "changelog",
@@ -32,9 +32,9 @@
   "dependencies": {
     "@clack/prompts": "^1.2.0",
     "cleye": "^2.3.0",
-    "conventional-changelog": "^7.2.0",
     "rslog": "^2.1.1",
     "semver": "^7.7.4",
+    "standard-changelog": "^7.0.1",
     "tinyexec": "^1.1.1"
   },
   "devDependencies": {