@picgo/bump-version 2.1.0 → 3.0.0

package/CHANGELOG.md

@@ -1,3 +1,42 @@
+# :tada: 3.0.0 (2026-08-22)
+
+
+### :sparkles: Features
+
+* convert the CLI to ESM and upgrade its dependencies ([9165570](https://github.com/PicGo/bump-version/commit/9165570))
+
+
+### :bug: Bug Fixes
+
+* stop dropping Upgrade, Style, Refactor and Test from changelogs ([cd252e2](https://github.com/PicGo/bump-version/commit/cd252e2))
+
+
+### :arrow_up: Dependencies Upgrade
+
+* clear the remaining dev vulnerabilities ([bdd1fb2](https://github.com/PicGo/bump-version/commit/bdd1fb2))
+* move contributor tooling out of dependencies ([08093ca](https://github.com/PicGo/bump-version/commit/08093ca))
+
+
+### :package: Chore
+
+* update actions and run tests before publishing ([3317c25](https://github.com/PicGo/bump-version/commit/3317c25))
+
+
+### :white_check_mark: Tests
+
+* cover version resolution and the version write ([4b98e2a](https://github.com/PicGo/bump-version/commit/4b98e2a))
+
+
+### BREAKING CHANGES
+
+* note — otherwise it was silently discarded. Four of the
+PicGo convention's own types never appeared in a changelog.
+
+Moved the discard branch below them, where it now only catches genuinely
+unrecognised types, and kept WIP and Release excluded explicitly.
+
+
+
 # :tada: 2.1.0 (2026-08-22)
 
 

package/README.md

@@ -4,7 +4,7 @@ A full `git commit` -> `changelog` -> `release` workflow & convention.
 
 It's now only available for Node.js projects. Thanks [standard-version](https://github.com/conventional-changelog/standard-version) for the inspiration.
 
-> Starting from v1.2.0, bump-version requires Node.js 20 or higher.
+> Starting from v3.0.0, bump-version is an ESM package and requires Node.js 22 or higher. The configs it ships for `commitlint` and `cz-customizable` remain CommonJS, so those tools keep loading them as before.
 
 <p align="center">
   <img src="https://raw.githubusercontent.com/Molunerfinn/test/master/picgo/New%20LOGO-150.png" alt="">
@@ -24,17 +24,19 @@ It's now only available for Node.js projects. Thanks [standard-version](https://
 ## Installation
 
 ```bash
-npm install -D  @picgo/bump-version commitizen cz-customizable
+npm install -D  @picgo/bump-version commitizen cz-customizable @commitlint/cli husky
 
 #or
 
-yarn add -D  @picgo/bump-version commitizen cz-customizable
+yarn add -D  @picgo/bump-version commitizen cz-customizable @commitlint/cli husky
 
 #or
 
-pnpm add -D  @picgo/bump-version commitizen cz-customizable
+pnpm add -D  @picgo/bump-version commitizen cz-customizable @commitlint/cli husky
 ```
 
+> `commitizen`, `cz-customizable`, `@commitlint/cli` and `husky` are the tools that provide the `git-cz` and `commitlint` commands and the git hooks. They are peer tooling rather than dependencies of `bump-version` itself, so install the ones you actually use — if you only want `bump-version` to bump versions and write changelogs, `@picgo/bump-version` alone is enough.
+
 Also, add the following data at the top level in your `package.json` to properly config `bump-version` (replace old `config` if you have already configured `commitizen` or `cz-customizable` before):
 
 ```json
@@ -48,11 +50,11 @@ Also, add the following data at the top level in your `package.json` to properly
     "path": "./node_modules/cz-customizable"
   },
   "cz-customizable": {
-    "config": "./node_modules/@picgo/bump-version/.cz-config.js"
+    "config": "./node_modules/@picgo/bump-version/.cz-config.cjs"
   }
 },
 "commitlint": {
-  "extends": ["./node_modules/@picgo/bump-version/commitlint-picgo"]
+  "extends": ["./node_modules/@picgo/bump-version/commitlint-picgo/index.cjs"]
 }
 ```
 

package/bin/bump-version

@@ -1,15 +1,18 @@
 #!/usr/bin/env node
-const minimist = require('minimist')
-const semver = require('semver')
-const path = require('path')
-const inquirer = require('inquirer').default
-const logger = require('../src/logger')
-const mainLifeCycle = require('../src/mainLifeCycle')
-const utils = require('../src/utils')
+import minimist from 'minimist'
+import semver from 'semver'
+import path from 'node:path'
+import fs from 'node:fs'
+import { Separator } from '@inquirer/prompts'
+import inquirer from 'inquirer'
+import logger from '../src/logger.js'
+import mainLifeCycle from '../src/mainLifeCycle.js'
+import resolveVersion, { releaseTypes } from '../src/resolveVersion.js'
+import * as utils from '../src/utils.js'
 
 let pkg
 try {
-  pkg = require(path.join(process.cwd(), 'package.json'))
+  pkg = JSON.parse(fs.readFileSync(path.join(process.cwd(), 'package.json'), 'utf8'))
 } catch (e) {
   logger('package.json not found!', 'error')
   process.exit(0)
@@ -35,38 +38,19 @@ if (argv.h) {
   process.exit(0)
 }
 
-let releaseType = typeof argv.t === 'string' ? argv.t : 'patch'
 let currentVersion = pkg.version
 if (currentVersion === undefined) {
   logger('Version field is not found in package.json!', 'error')
   process.exit(0)
 }
 let preid = argv.a ? 'alpha' : argv.b ? 'beta' : ''
-let releaseTypes = ['major', 'minor', 'patch', 'premajor', 'preminor', 'prepatch', 'prerelease']
 
-// An explicit --version wins over --type: naming a version is unambiguous,
-// so silently deriving a different one from the type would be surprising.
-let explicitVersion = typeof argv.version === 'string' ? argv.version.trim() : ''
-let nextVersion
-if (explicitVersion !== '') {
-  // Accept a leading `v` because that is how the tag is written and how
-  // people say it out loud.
-  nextVersion = semver.valid(explicitVersion.replace(/^v/, ''))
-  if (nextVersion === null) {
-    logger(`Invalid version: ${explicitVersion}`, 'error')
-    process.exit(1)
-  }
-  if (semver.lte(nextVersion, currentVersion)) {
-    logger(`Version ${nextVersion} is not greater than the current ${currentVersion}!`, 'error')
-    process.exit(1)
-  }
-} else {
-  if (!releaseTypes.includes(releaseType)) {
-    logger(`Invalid release type: ${releaseType}. Expected one of ${releaseTypes.join(', ')}`, 'error')
-    process.exit(1)
-  }
-  nextVersion = semver.inc(currentVersion, releaseType, preid)
+let resolved = resolveVersion(argv, currentVersion)
+if (resolved.error) {
+  logger(resolved.error, 'error')
+  process.exit(1)
 }
+let nextVersion = resolved.version
 
 function generateReleaseTypes (types) {
   return types.map(item => {
@@ -117,7 +101,7 @@ BumpVersion -- By PicGo Group
         message: `The current version is ${currentVersion}\n Which version would you like to bump it?`,
         choices: [
           ...generateReleaseTypes(releaseTypes),
-          new inquirer.Separator(),
+          new Separator(),
           'custom version',
           'never mind~'
         ],
@@ -136,11 +120,13 @@ BumpVersion -- By PicGo Group
         }
       ]
       let result = await inquirer.prompt(promptList)
-      if (semver.valid(result.version) && semver.gte(result.version, currentVersion)) {
-        await mainLifeCycle(argv, currentVersion, result.version)
-      } else {
-        return logger('Invalid version!', 'error')
+      // Same validator as --version, so a typed version and a flagged one are
+      // held to one rule.
+      let custom = resolveVersion({ version: result.version }, currentVersion)
+      if (custom.error) {
+        return logger(custom.error, 'error')
       }
+      await mainLifeCycle(argv, currentVersion, custom.version)
     } else {
       await mainLifeCycle(argv, currentVersion, answer.version)
     }

package/commitlint-picgo/{index.js → index.cjs}

@@ -1,7 +1,7 @@
-const typeEnum = require('./types')
+const typeEnum = require('./types.cjs')
 
 module.exports = {
-  parserPreset: '../conventional-changelog-picgo/parser-opts',
+  parserPreset: '../conventional-changelog-picgo/parser-opts.cjs',
   rules: {
     'body-leading-blank': [1, 'always'],
     'footer-leading-blank': [1, 'always'],

package/conventional-changelog-picgo/conventional-changelog.cjs

@@ -0,0 +1,9 @@
+'use strict'
+
+const parserOpts = require(`./parser-opts.cjs`)
+const writerOpts = require(`./writer-opts.cjs`)
+
+module.exports = Promise.all([parserOpts, writerOpts])
+  .then(([parserOpts, writerOpts]) => {
+    return { parserOpts, writerOpts }
+  })

package/conventional-changelog-picgo/{conventional-recommended-bump.js → conventional-recommended-bump.cjs}

@@ -1,6 +1,6 @@
 'use strict'
 
-const parserOpts = require(`./parser-opts`)
+const parserOpts = require(`./parser-opts.cjs`)
 
 module.exports = {
   parserOpts,

package/conventional-changelog-picgo/index.cjs

@@ -0,0 +1,10 @@
+'use strict'
+const conventionalChangelog = require(`./conventional-changelog.cjs`)
+const parserOpts = require(`./parser-opts.cjs`)
+const recommendedBumpOpts = require(`./conventional-recommended-bump.cjs`)
+const writerOpts = require(`./writer-opts.cjs`)
+
+module.exports = Promise.all([conventionalChangelog, parserOpts, recommendedBumpOpts, writerOpts])
+  .then(([conventionalChangelog, parserOpts, recommendedBumpOpts, writerOpts]) => {
+    return { conventionalChangelog, parserOpts, recommendedBumpOpts, writerOpts }
+  })

package/conventional-changelog-picgo/{writer-opts.js → writer-opts.cjs}

@@ -1,8 +1,7 @@
 'use strict'
 
 const compareFunc = require(`compare-func`)
-const Q = require(`q`)
-const readFile = Q.denodeify(require(`fs`).readFile)
+const readFile = require(`fs`).promises.readFile
 const resolve = require(`path`).resolve
 const headerPattern = /^(:.*: (.*))$/
 
@@ -18,13 +17,13 @@ const compareTitleFunc = (a, b) => {
   return (sortMap[typeB] || 0) - (sortMap[typeA] || 0)
 }
 
-module.exports = Q.all([
+module.exports = Promise.all([
   readFile(resolve(__dirname, `./templates/template.hbs`), `utf-8`),
   readFile(resolve(__dirname, `./templates/header.hbs`), `utf-8`),
   readFile(resolve(__dirname, `./templates/commit.hbs`), `utf-8`),
   readFile(resolve(__dirname, `./templates/footer.hbs`), `utf-8`)
 ])
-  .spread((template, header, commit, footer) => {
+  .then(([template, header, commit, footer]) => {
     const writerOpts = getWriterOpts()
 
     writerOpts.mainTemplate = template
@@ -60,8 +59,6 @@ function getWriterOpts () {
         commit.type = `:package: Chore`
       } else if (commit.type === `:pushpin: Init`) {
         commit.type = `:pushpin: Init`
-      } else if (discard) {
-        return
       } else if (commit.type === `:arrow_up: Upgrade`) {
         commit.type = `:arrow_up: Dependencies Upgrade`
       } else if (commit.type === `:art: Style`) {
@@ -71,6 +68,10 @@ function getWriterOpts () {
       } else if (commit.type === `:white_check_mark: Test`) {
         commit.type = `:white_check_mark: Tests`
       } else if (commit.type === `:construction: WIP` || commit.type === ':tada: Release') {
+        // WIP is noise and Release is this tool's own commit.
+        return
+      } else if (discard) {
+        // Anything unrecognised, unless it carries a BREAKING CHANGE note.
         return
       }
 

package/eslint.config.js

@@ -1,5 +1,9 @@
-const { FlatCompat } = require('@eslint/eslintrc')
-const js = require('@eslint/js')
+import { FlatCompat } from '@eslint/eslintrc'
+import js from '@eslint/js'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
 
 const compat = new FlatCompat({
   baseDirectory: __dirname,
@@ -7,7 +11,7 @@ const compat = new FlatCompat({
   allConfig: js.configs.all
 })
 
-module.exports = [
+export default [
   {
     ignores: ['node_modules', 'dist']
   },
@@ -18,15 +22,38 @@ module.exports = [
     'plugin:promise/recommended'
   ),
   {
+    // The CLI and its src/ modules are ESM, as is this config.
     languageOptions: {
       ecmaVersion: 2022,
-      sourceType: 'script'
+      sourceType: 'module'
+    },
+    rules: {
+      // Resolution of bare ESM specifiers is handled by Node, not the plugin.
+      'import/no-unresolved': 'off'
+    }
+  },
+  {
+    // Configs consumed by other tools' CommonJS loaders stay CJS.
+    files: ['**/*.cjs'],
+    languageOptions: {
+      sourceType: 'commonjs',
+      globals: {
+        module: 'writable',
+        require: 'readonly',
+        __dirname: 'readonly'
+      }
     }
   },
   {
     files: ['eslint.config.js'],
     rules: {
-      'n/no-unpublished-require': 'off'
+      'n/no-unpublished-import': 'off'
+    }
+  },
+  {
+    files: ['test/**/*.js'],
+    rules: {
+      'n/no-unpublished-import': 'off'
     }
   }
 ]

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "@picgo/bump-version",
-  "version": "2.1.0",
+  "version": "3.0.0",
   "description": "",
-  "main": "index.js",
   "bin": {
     "bump-version": "./bin/bump-version"
   },
@@ -10,17 +9,13 @@
     "access": "public"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\"",
+    "test": "vitest run",
     "cz": "git-cz",
     "release": "node ./bin/bump-version",
     "lint": "eslint --ext .js .",
-    "lint:fix": "eslint --ext .js --fix ."
-  },
-  "husky": {
-    "hooks": {
-      "pre-commit": "npm run lint",
-      "commit-msg": "commitlint -E HUSKY_GIT_PARAMS"
-    }
+    "lint:fix": "eslint --ext .js --fix .",
+    "test:watch": "vitest",
+    "prepare": "husky || true"
   },
   "repository": {
     "type": "git",
@@ -33,41 +28,48 @@
   },
   "homepage": "https://github.com/PicGo/bump-version#readme",
   "devDependencies": {
+    "@commitlint/cli": "^21.2.2",
     "@eslint/eslintrc": "^3.3.3",
     "@eslint/js": "^9.39.1",
+    "commitizen": "^4.3.2",
+    "cz-customizable": "^7.5.4",
     "eslint": "^9.39.1",
     "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-n": "^17.23.1",
-    "eslint-plugin-promise": "^7.2.1"
+    "eslint-plugin-promise": "^7.2.1",
+    "husky": "^9.1.7",
+    "vitest": "^4.1.11"
   },
   "config": {
     "commitizen": {
       "path": "node_modules/cz-customizable"
     },
     "cz-customizable": {
-      "config": ".cz-config.js"
+      "config": ".cz-config.cjs"
     }
   },
   "commitlint": {
     "extends": [
-      "./commitlint-picgo"
+      "./commitlint-picgo/index.cjs"
     ]
   },
   "dependencies": {
-    "@commitlint/cli": "^7.5.2",
-    "chalk": "^4.1.2",
-    "commitizen": "^4.2.3",
+    "@inquirer/prompts": "^8.6.0",
+    "chalk": "^6.0.0",
     "compare-func": "^2.0.0",
     "conventional-changelog": "^3.0.6",
-    "cz-customizable": "^7.5.1",
-    "husky": "^1.3.1",
-    "inquirer": "^13.0.2",
+    "inquirer": "^14.1.0",
     "minimist": "^1.2.8",
-    "ora": "^3.4.0",
-    "q": "^1.5.1",
+    "ora": "^6.3.1",
     "semver": "^7.7.3"
   },
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=22.0.0"
+  },
+  "type": "module",
+  "pnpm": {
+    "overrides": {
+      "tmp": "^0.2.5"
+    }
   }
 }

package/src/bumpVersion.js

@@ -1,13 +1,18 @@
-const fs = require('fs')
-const checkFileAndGetPath = require('./utils').checkFileAndGetPath
-let versionFiles = ['package.json', 'package-lock.json']
-module.exports = (argv, version) => {
+import fs from 'node:fs'
+import { checkFileAndGetPath } from './utils.js'
+
+// Resolved per call rather than cached at module scope: the resolved list is
+// absolute and tied to one `argv.path`, so reusing it across calls would
+// silently target the previous directory.
+const VERSION_FILES = ['package.json', 'package-lock.json']
+
+export default (argv, version) => {
   // No early return for `dry` here: the write itself is guarded below, so
   // bailing out would also skip it for `--no-dry`, leaving commit and tag to
   // run against an unchanged version.
-  versionFiles = checkFileAndGetPath(argv, versionFiles)
+  const versionFiles = checkFileAndGetPath(argv, VERSION_FILES)
 
-  for (let file of versionFiles) {
+  for (const file of versionFiles) {
     let content = fs.readFileSync(file, 'utf8')
     try {
       content = JSON.parse(content)

package/src/changelog.js

@@ -1,8 +1,8 @@
-const cc = require('conventional-changelog')
-const config = require('../conventional-changelog-picgo')
-const fs = require('fs')
+import cc from 'conventional-changelog'
+import fs from 'node:fs'
+import config from '../conventional-changelog-picgo/index.cjs'
 
-module.exports = (argv, newVersion) => {
+export default (argv, newVersion) => {
   if (argv.changelog === false) {
     return Promise.resolve()
   }

package/src/commit.js

@@ -1,16 +1,16 @@
-const utils = require('./utils')
-const exec = require('./exec')
-let changedFiles = [
+import { checkFileAndGetPath } from './utils.js'
+import exec from './exec.js'
+const VERSION_FILES = [
   'package.json',
   'package-lock.json'
 ]
-module.exports = (argv, newVersion) => {
-  if (argv.changelog !== false) {
-    changedFiles.push(argv.file)
-  }
+export default (argv, newVersion) => {
+  // Built per call: reassigning a module-level array leaks the previous
+  // run's resolved paths into the next one.
+  const files = argv.changelog !== false ? [...VERSION_FILES, argv.file] : [...VERSION_FILES]
   const releaseMsg = `:tada: Release: v${newVersion}`
   if (argv.skipCommit) return Promise.resolve()
-  changedFiles = utils.checkFileAndGetPath(argv, changedFiles).join(' ')
+  const changedFiles = checkFileAndGetPath(argv, files).join(' ')
   if (changedFiles === '' || argv.dry) {
     return Promise.resolve()
   }

package/src/exec.js

@@ -1,7 +1,7 @@
-const exec = require('child_process').exec
-const logger = require('./logger')
+import { exec } from 'node:child_process'
+import logger from './logger.js'
 
-module.exports = (argv, cmd) => {
+export default (argv, cmd) => {
   return new Promise((resolve, reject) => {
     // Exec given cmd and handle possible errors
     exec(cmd, { cwd: argv.path }, function (err, stdout, stderr) {

package/src/logger.js

@@ -1,12 +1,14 @@
-const ora = require('./ora')
-const chalk = require('chalk')
+import chalk from 'chalk'
+import ora from './ora.js'
+
 const level = {
   success: 'green',
   info: 'blue',
   warn: 'yellow',
   error: 'red'
 }
-module.exports = (msg, type) => {
+
+export default (msg, type) => {
   let log = chalk[level[type]](`[Bump ${type.toUpperCase()}]: `)
   log += msg
   ora.clear()

package/src/mainLifeCycle.js

@@ -1,9 +1,9 @@
-const bumpVersion = require('./bumpVersion')
-const commit = require('./commit')
-const changeLog = require('./changelog')
-const tag = require('./tag')
-const spinner = require('./ora')
-module.exports = (argv, currentVersion, newVersion) => {
+import bumpVersion from './bumpVersion.js'
+import commit from './commit.js'
+import changeLog from './changelog.js'
+import tag from './tag.js'
+import spinner from './ora.js'
+export default (argv, currentVersion, newVersion) => {
   spinner.start()
   return Promise.resolve()
     .then(() => {

package/src/ora.js

@@ -1,4 +1,11 @@
-const Ora = require('ora')
-module.exports = new Ora({
+import Ora from 'ora'
+
+// Pinned to ora 6.x in package.json on purpose. From ora 7 onwards the spinner
+// kills the process when it is started after an inquirer prompt has restored
+// the TTY: the confirm is answered, the spinner draws one frame, and the
+// process exits before the release finishes — leaving a bumped package.json
+// with no commit and no tag. Verified against ora 3/4/5/6 (fine) and 7/8/9
+// (broken), with inquirer 13 and 14 alike.
+export default new Ora({
   text: ''
 })

package/src/resolveVersion.js

@@ -0,0 +1,48 @@
+import semver from 'semver'
+
+const RELEASE_TYPES = ['major', 'minor', 'patch', 'premajor', 'preminor', 'prepatch', 'prerelease']
+
+export const releaseTypes = RELEASE_TYPES
+
+/**
+ * Work out which version to bump to.
+ *
+ * Pure on purpose: the CLI turns the result into either an error exit or a
+ * lifecycle run, and keeping the decision separate is what makes it testable
+ * without spawning a process or touching a git repo.
+ *
+ * @param {object} argv parsed arguments; reads `version`, `t`/`type`, `a`, `b`
+ * @param {string} currentVersion the version currently in package.json
+ * @returns {{ version: string } | { error: string }}
+ */
+export default (argv, currentVersion) => {
+  // An explicit --version wins over --type: naming a version is unambiguous,
+  // so silently deriving a different one from the type would be surprising.
+  const explicit = typeof argv.version === 'string' ? argv.version.trim() : ''
+
+  if (explicit !== '') {
+    // Accept a leading `v` because that is how the tag is written and how
+    // people say it out loud.
+    const version = semver.valid(explicit.replace(/^v/, ''))
+    if (version === null) {
+      return { error: `Invalid version: ${explicit}` }
+    }
+    if (semver.lte(version, currentVersion)) {
+      return { error: `Version ${version} is not greater than the current ${currentVersion}!` }
+    }
+    return { version }
+  }
+
+  const releaseType = typeof argv.t === 'string' ? argv.t : 'patch'
+  if (!RELEASE_TYPES.includes(releaseType)) {
+    return { error: `Invalid release type: ${releaseType}. Expected one of ${RELEASE_TYPES.join(', ')}` }
+  }
+
+  const preid = argv.a ? 'alpha' : argv.b ? 'beta' : ''
+  const version = semver.inc(currentVersion, releaseType, preid)
+  if (version === null) {
+    return { error: `Cannot bump ${currentVersion} with release type ${releaseType}` }
+  }
+  return { version }
+}
+

package/src/tag.js

@@ -1,5 +1,5 @@
-const exec = require('./exec')
-module.exports = (argv, newVersion) => {
+import exec from './exec.js'
+export default (argv, newVersion) => {
   if (argv.dry) {
     return Promise.resolve()
   }
@@ -11,7 +11,7 @@ module.exports = (argv, newVersion) => {
   }
   return flow.then(async () => {
     if (argv.push) {
-      await exec(`git push --follow-tags origin master`)
+      await exec(argv, `git push --follow-tags origin master`)
     }
     return null
   })

package/src/utils.js

@@ -1,6 +1,6 @@
-const path = require('path')
-const fs = require('fs')
-const checkFileAndGetPath = (argv, files) => {
+import path from 'node:path'
+import fs from 'node:fs'
+export const checkFileAndGetPath = (argv, files) => {
   return files.map(item => {
     if (path.isAbsolute(item)) {
       return item
@@ -10,7 +10,7 @@ const checkFileAndGetPath = (argv, files) => {
     return fs.existsSync(item)
   })
 }
-const helperMsg = `
+export const helperMsg = `
 BumpVersion -- By PicGo Group
 
 Usage
@@ -57,7 +57,3 @@ Options
                                 Default: changelog will be created
 `
 
-module.exports = {
-  checkFileAndGetPath,
-  helperMsg
-}

package/.github/workflows/publish.yml

@@ -1,42 +0,0 @@
-name: publish
-permissions:
-  contents: read
-  id-token: write
-
-on:
-  push:
-    branches:
-      - master
-  workflow_dispatch:
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          run_install: false
-          version: 10
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: 25
-          registry-url: https://registry.npmjs.org
-          cache: pnpm
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Lint
-        run: pnpm run lint
-
-      - name: Unset NODE_AUTH_TOKEN
-        run: unset NODE_AUTH_TOKEN
-
-      - name: Publish
-        run: npm publish --access public --provenance --no-git-checks

package/conventional-changelog-picgo/conventional-changelog.js

@@ -1,10 +0,0 @@
-'use strict'
-
-const Q = require(`q`)
-const parserOpts = require(`./parser-opts`)
-const writerOpts = require(`./writer-opts`)
-
-module.exports = Q.all([parserOpts, writerOpts])
-  .spread((parserOpts, writerOpts) => {
-    return { parserOpts, writerOpts }
-  })

package/conventional-changelog-picgo/index.js

@@ -1,11 +0,0 @@
-'use strict'
-const Q = require(`q`)
-const conventionalChangelog = require(`./conventional-changelog`)
-const parserOpts = require(`./parser-opts`)
-const recommendedBumpOpts = require(`./conventional-recommended-bump`)
-const writerOpts = require(`./writer-opts`)
-
-module.exports = Q.all([conventionalChangelog, parserOpts, recommendedBumpOpts, writerOpts])
-  .spread((conventionalChangelog, parserOpts, recommendedBumpOpts, writerOpts) => {
-    return { conventionalChangelog, parserOpts, recommendedBumpOpts, writerOpts }
-  })