fork-version 1.7.0 → 1.7.6

package/CHANGELOG.md

@@ -1,5 +1,53 @@
 # Fork Version
 
+## 1.7.6 (2024-11-09)
+
+
+### Refactor
+
+* remove git-semver-tags library in favour of vendoring it ([#80](https://github.com/eglavin/fork-version/issues/80)) ([5e1b9cb](https://github.com/eglavin/fork-version/commit/5e1b9cbe7c7d77479235fcdc6f1dbc182c10ecd3))
+
+
+## 1.7.5 (2024-11-09)
+
+
+### Refactor
+
+* rename strategies folder to files ([#79](https://github.com/eglavin/fork-version/issues/79)) ([9a06f63](https://github.com/eglavin/fork-version/commit/9a06f63c95d760fa0d729a839d2dc576c9c059e9))
+
+
+## 1.7.4 (2024-11-08)
+
+
+### Bug Fixes
+
+* match casing of logs between steps ([df88a60](https://github.com/eglavin/fork-version/commit/df88a60429b508dcbaa55aff34ff816e745b26f5))
+
+
+## 1.7.3 (2024-11-03)
+
+
+### Refactor
+
+* general cleanup of error message handling ([#78](https://github.com/eglavin/fork-version/issues/78)) ([a83ff13](https://github.com/eglavin/fork-version/commit/a83ff13443d50edfba18c5502d9c38e834e3236d))
+
+
+## 1.7.2 (2024-11-02)
+
+
+### Chore
+
+* bump pnpm dependency ([#77](https://github.com/eglavin/fork-version/issues/77)) ([158c70c](https://github.com/eglavin/fork-version/commit/158c70c06311fb624be03b522c06730f8f314d37))
+
+
+## 1.7.1 (2024-11-01)
+
+
+### Docs
+
+* update using npx section of readme ([737a72a](https://github.com/eglavin/fork-version/commit/737a72a8485a5e1035543245c498e9f76ce1050b))
+
+
 ## 1.7.0 (2024-10-31)
 
 

package/README.md

@@ -14,7 +14,7 @@ Fork-Version automates version control tasks such as determining, updating, and
 </p>
 
 <details>
-<summary>This project is essentially a complete re-write of standard-version following on from its deprecation in May 2022.</summary>
+<summary>This project is essentially a complete re-write of <a href=https://github.com/conventional-changelog/standard-version>standard-version</a> following on from its deprecation in May 2022.</summary>
 Although there are many alternatives such as <a href=https://github.com/googleapis/release-please>release-please</a>. This project aims to continue focusing on just the versioning and changelog generation aspect of the process for use in other Git hosts outside of Github.
 </details>
 
@@ -23,7 +23,7 @@ Although there are many alternatives such as <a href=https://github.com/googleap
 By following the [conventional commit](https://www.conventionalcommits.org) standard Fork-Version can automate the following tasks for you:
 
 1. Determine the current and next version
-1. Update the version in the selected files
+1. Update the version in the selected files [(View the supported files)](#supported-file-types)
 1. Update your changelog
 1. Commit the changed files
 1. Create a tag for the new version
@@ -41,19 +41,28 @@ Fork-Version can be configured either through a config file or by passing option
 
 ### Using `npx` (Recommended)
 
-To use Fork-Version with `npx` you can use the following command, by using `npx` you can also use Fork-Version without installation and on other projects including non node projects.
+To use Fork-Version without installation you can use `npx`:
 
 ```sh
 npx fork-version
 ```
 
+`npx` is a package runner which allows you to execute npm packages without installation, this can be useful when working on projects outside of the Node ecosystem.
+
 > [!NOTE]
-> If you want to use a specific version you can add a version tag to the end of the name.
+> By default `npx` will use the latest release, if you want to use a specific version you can add a version tag to the end of the name.
 >
-> Example: `npx fork-version@1.4.67`
+> Example: `npx fork-version@1.7.0`
 >
 > The version tag needs to match against one of the [published versions on npm](https://www.npmjs.com/package/fork-version?activeTab=versions).
 
+Alternatively you can use other npm compatible javascript runtime's:
+
+| Runner | Command                    |
+| ------ | -------------------------- |
+| bun    | `bunx fork-version`        |
+| deno   | `deno -A npm:fork-version` |
+
 ### Install Locally
 
 To install the package locally to your project you can use one of the following commands:
@@ -63,10 +72,12 @@ To install the package locally to your project you can use one of the following
 | npm             | `npm install fork-version --save-dev` |
 | yarn            | `yarn add fork-version --dev`         |
 | pnpm            | `pnpm add fork-version --save-dev`    |
+| bun             | `bun install fork-version --dev`      |
 
 You can then add the following entry to your package.json scripts section and use it like any other script you already use in your project.
 
 ```json
+// package.json
 {
   "scripts": {
     "release": "fork-version"
@@ -76,8 +87,20 @@ You can then add the following entry to your package.json scripts section and us
 
 For example if you use npm you can now use `npm run release` to run Fork-Version.
 
+### Exit Codes
+
+When ran as a cli tool Fork-Version will exit with one of the following exit codes:
+
+| Exit Code | Description                  |
+| --------- | ---------------------------- |
+| 0         | Success                      |
+| 1         | General Error                |
+| 3         | Config File Validation Error |
+
 ### Command Line Options
 
+The following help text can be viewed by running the following command: `npx fork-version --help`
+
 <!-- START COMMAND LINE OPTIONS -->
 
 ```text
@@ -129,6 +152,11 @@ Conventional Changelog Overrides:
   --release-commit-message-format  Override the default release commit message format.
   --release-message-suffix         Add a suffix to the end of the release message.
 
+Exit Codes:
+  0: Success
+  1: General Error
+  3: Config File Validation Error
+
 Examples:
   $ fork-version
     Run fork-version in the current directory with default options.
@@ -163,6 +191,7 @@ You can configure Fork-Version using one of the following files:
 Configuring using a javascript file is the most flexible option. You can use any javascript file type you prefer including typescript. Both commonjs and esm exports styles are supported. The `defineConfig` function in the following snippet is optional, using it will give you intellisense information in your code editor of choice.
 
 ```js
+// fork.config.ts
 import { defineConfig } from 'fork-version';
 
 export default defineConfig({
@@ -174,6 +203,7 @@ export default defineConfig({
 Alternatively you can use typescript type annotations in a typescript file:
 
 ```ts
+// fork.config.ts
 import type { Config } from 'fork-version';
 
 const config: Config = {
@@ -187,6 +217,7 @@ export default config;
 Or jsdocs in a javascript file:
 
 ```js
+// fork.config.js
 /** @type {import("fork-version").Config} */
 export default {
   header: `# My Changelog`,
@@ -203,6 +234,7 @@ Another way you can configure Fork-Version is by using a json file called `fork.
 If you still want intellisense information you can use the following schema in your json file, otherwise `$schema` is an optional key.
 
 ```json
+// fork.config.json
 {
   "$schema": "https://raw.githubusercontent.com/eglavin/fork-version/main/schema/latest.json",
   "header": "# My Changelog",
@@ -218,6 +250,7 @@ Internally we're using [zod-to-json-schema](https://github.com/StefanTerdell/zod
 Alternatively you can define your config using a key in your `package.json` file called `fork-version`:
 
 ```json
+// package.json
 {
   "name": "my-js-project",
   "version": "1.2.3",
@@ -318,14 +351,14 @@ Marking a release as a pre-release allows you to define a change as a patch to a
 | Example Value | Version Created |
 |:--------------|:----------------|
 | `true`        | `1.2.3-0`       |
-| `alpha`       | `1.2.3-alpha-0` |
+| `alpha`       | `1.2.3-alpha.0` |
 
 Fork-Version uses [meow](https://github.com/sindresorhus/meow) to parse cli arguments which is unable to take a single argument and parse it as either a string and or a boolean. So to do the above through the cli interface you'll need to use two different arguments:
 
 | Example CLI Usage                      | Version Created |
 |:---------------------------------------|:----------------|
 | `fork-version --pre-release`           | `1.2.3-0`       |
-| `fork-version --pre-release-tag alpha` | `1.2.3-alpha-0` |
+| `fork-version --pre-release-tag alpha` | `1.2.3-alpha.0` |
 
 ##### config.releaseAs
 
@@ -364,7 +397,7 @@ Checkout the `fork.config.js` file [here](./fork.config.js) to see an example of
 | section  | string  | The name of the section in the `CHANGELOG` the commit should show up in. |
 | hidden   | boolean | Should show in the generated changelog message?                          |
 
-###### config.releaseMessageSuffix
+##### config.releaseMessageSuffix
 
 Adds a suffix to the end of the release message, useful to add a `[skip ci]` message to the end of the created commit.
 
@@ -406,7 +439,7 @@ version: 1.2.3
 
 #### Plain Text
 
-A plain text file will have just the version as the content.
+A plain text file is a file which contains just the version as the content. Files that end with `version.txt` will be treated as a plain text version file.
 
 ```text
 1.2.3

package/dist/{chunk-D7324DNL.js → chunk-4M7BP5DG.js}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { readFileSync, writeFileSync } from 'node:fs';
+import { readFileSync, writeFileSync, lstatSync } from 'node:fs';
 import { resolve, parse } from 'node:path';
 import JoyCon from 'joycon';
 import { bundleRequire } from 'bundle-require';
@@ -7,13 +7,11 @@ import { glob } from 'glob';
 import meow from 'meow';
 import conventionalChangelogConfigSpec from 'conventional-changelog-config-spec';
 import { execFile } from 'node:child_process';
-import { parse as parse$1, modify, applyEdits } from 'jsonc-parser';
-import { lstatSync } from 'fs';
+import { modify, applyEdits, parse as parse$1 } from 'jsonc-parser';
 import { parse as parse$2, parseDocument } from 'yaml';
 import * as cheerio from 'cheerio/slim';
-import semver3 from 'semver';
+import semver2 from 'semver';
 import conventionalRecommendedBump from 'conventional-recommended-bump';
-import gitSemverTags from 'git-semver-tags';
 import conventionalChangelog from 'conventional-changelog';
 
 // src/config/schema.js
@@ -359,6 +357,11 @@ Conventional Changelog Overrides:
   --release-commit-message-format  Override the default release commit message format.
   --release-message-suffix         Add a suffix to the end of the release message.
 
+Exit Codes:
+  0: Success
+  1: General Error
+  3: Config File Validation Error
+
 Examples:
   $ fork-version
     Run fork-version in the current directory with default options.
@@ -571,7 +574,7 @@ async function loadConfigFile(configFilePath) {
       if (fileContent2[PACKAGE_JSON_CONFIG_KEY] && typeof fileContent2[PACKAGE_JSON_CONFIG_KEY] === "object") {
         const parsed3 = ForkConfigSchema.partial().safeParse(fileContent2[PACKAGE_JSON_CONFIG_KEY]);
         if (!parsed3.success) {
-          throw parsed3.error;
+          throw new Error(`Validation error in: ${configFilePath}`, { cause: parsed3.error });
         }
         return parsed3.data;
       }
@@ -579,14 +582,14 @@ async function loadConfigFile(configFilePath) {
     }
     const parsed2 = ForkConfigSchema.partial().safeParse(fileContent2);
     if (!parsed2.success) {
-      throw parsed2.error;
+      throw new Error(`Validation error in: ${configFilePath}`, { cause: parsed2.error });
     }
     return parsed2.data;
   }
   const fileContent = await bundleRequire({ filepath: configFilePath });
   const parsed = ForkConfigSchema.partial().safeParse(fileContent.mod.default || fileContent.mod);
   if (!parsed.success) {
-    throw parsed.error;
+    throw new Error(`Validation error in: ${configFilePath}`, { cause: parsed.error });
   }
   return parsed.data;
 }
@@ -648,23 +651,35 @@ function fileExists(filePath) {
   }
 }
 
-// src/strategies/json-package.ts
-var PARSE_OPTIONS = {
-  allowTrailingComma: true,
-  allowEmptyContent: false,
-  disallowComments: false
-};
+// src/files/json-package.ts
 var JSONPackage = class {
   constructor(config, logger) {
     this.config = config;
     this.logger = logger;
   }
+  /** Options for parsing JSON and JSONC files. */
+  PARSE_OPTIONS = {
+    allowEmptyContent: false,
+    allowTrailingComma: true,
+    disallowComments: false
+  };
+  /**
+   * Sets a new string value at the given path in a JSON or JSONC string.
+   * @param jsonc the JSON or JSONC string (the contents of a file)
+   * @param jsonPath path to the value to set, as an array of segments
+   * @param newString string to set the value to
+   * @returns the JSON or JSONC string with the value set
+   */
+  setStringInJsonc(jsonc, jsonPath, newString) {
+    const edits = modify(jsonc, jsonPath, newString, {});
+    return applyEdits(jsonc, edits);
+  }
   read(fileName) {
     const filePath = resolve(this.config.path, fileName);
     if (fileExists(filePath)) {
       const fileContents = readFileSync(filePath, "utf8");
       const parseErrors = [];
-      const parsedJson = parse$1(fileContents, parseErrors, PARSE_OPTIONS);
+      const parsedJson = parse$1(fileContents, parseErrors, this.PARSE_OPTIONS);
       if (parseErrors.length) {
         this.logger.warn(`[File Manager] Unable to parse JSON: ${fileName}`, parseErrors);
         return void 0;
@@ -677,20 +692,20 @@ var JSONPackage = class {
           isPrivate: typeof parsedJson?.private === "boolean" ? parsedJson.private : true
         };
       }
-      this.logger.warn(`[File Manager] Unable to determine json package: ${fileName}`);
+      this.logger.warn(`[File Manager] Unable to determine json version: ${fileName}`);
     }
   }
   write(fileState, newVersion) {
     let fileContents = readFileSync(fileState.path, "utf8");
     const parseErrors = [];
-    const parsedJson = parse$1(fileContents, parseErrors, PARSE_OPTIONS);
+    const parsedJson = parse$1(fileContents, parseErrors, this.PARSE_OPTIONS);
     if (parseErrors.length) {
       this.logger.warn(`[File Manager] Unable to parse JSON: ${fileState.path}`, parseErrors);
       return;
     }
-    fileContents = setStringInJsonc(fileContents, ["version"], newVersion);
+    fileContents = this.setStringInJsonc(fileContents, ["version"], newVersion);
     if (parsedJson?.packages?.[""]) {
-      fileContents = setStringInJsonc(fileContents, ["packages", "", "version"], newVersion);
+      fileContents = this.setStringInJsonc(fileContents, ["packages", "", "version"], newVersion);
     }
     writeFileSync(fileState.path, fileContents, "utf8");
   }
@@ -698,10 +713,6 @@ var JSONPackage = class {
     return fileName.endsWith(".json") || fileName.endsWith(".jsonc");
   }
 };
-function setStringInJsonc(jsonc, jsonPath, newString) {
-  const edits = modify(jsonc, jsonPath, newString, {});
-  return applyEdits(jsonc, edits);
-}
 var YAMLPackage = class {
   constructor(config, logger) {
     this.config = config;
@@ -739,7 +750,7 @@ var YAMLPackage = class {
         };
       }
     }
-    this.logger.warn(`[File Manager] Unable to determine PubSpec file: ${fileName}`);
+    this.logger.warn(`[File Manager] Unable to determine yaml version: ${fileName}`);
   }
   write(fileState, newVersion) {
     const fileContents = readFileSync(fileState.path, "utf8");
@@ -770,7 +781,7 @@ var PlainText = class {
         version: fileContents || ""
       };
     }
-    this.logger.warn(`[File Manager] Unable to determine plain text: ${fileName}`);
+    this.logger.warn(`[File Manager] Unable to determine plain text version: ${fileName}`);
   }
   write(fileState, newVersion) {
     writeFileSync(fileState.path, newVersion, "utf8");
@@ -800,7 +811,7 @@ var MSBuildProject = class {
           version
         };
       }
-      this.logger.warn(`[File Manager] Unable to determine ms-build package: ${fileName}`);
+      this.logger.warn(`[File Manager] Unable to determine ms-build version: ${fileName}`);
     }
   }
   write(fileState, newVersion) {
@@ -820,7 +831,7 @@ var MSBuildProject = class {
   }
 };
 
-// src/strategies/file-manager.ts
+// src/files/file-manager.ts
 var FileManager = class {
   constructor(config, logger) {
     this.config = config;
@@ -894,25 +905,11 @@ var FileManager = class {
     this.logger.error(`[File Manager] Unsupported file: ${fileState.path}`);
   }
 };
-async function getLatestGitTagVersion(tagPrefix) {
-  const gitTags = await gitSemverTags({ tagPrefix });
-  if (!gitTags.length) {
-    return "";
-  }
-  const cleanedTags = [];
-  for (const tag of gitTags) {
-    const cleanedTag = semver3.clean(tag.replace(new RegExp(`^${tagPrefix}`), ""));
-    if (cleanedTag) {
-      cleanedTags.push(cleanedTag);
-    }
-  }
-  return cleanedTags.sort(semver3.rcompare)[0];
-}
 function getPriority(type) {
   return ["patch", "minor", "major"].indexOf(type ?? "");
 }
 function getVersionType(version) {
-  const parseVersion = semver3.parse(version);
+  const parseVersion = semver2.parse(version);
   if (parseVersion?.major) {
     return "major";
   } else if (parseVersion?.minor) {
@@ -926,7 +923,7 @@ function getReleaseType(releaseType, currentVersion, preReleaseTag) {
   if (!preReleaseTag) {
     return releaseType;
   }
-  const currentVersionsIsPreRelease = Array.isArray(semver3.prerelease(currentVersion));
+  const currentVersionsIsPreRelease = Array.isArray(semver2.prerelease(currentVersion));
   if (currentVersionsIsPreRelease) {
     const currentReleaseType = getVersionType(currentVersion);
     if (currentReleaseType === releaseType || getPriority(currentReleaseType) > getPriority(releaseType)) {
@@ -937,26 +934,29 @@ function getReleaseType(releaseType, currentVersion, preReleaseTag) {
 }
 
 // src/process/version.ts
-async function getCurrentVersion(config, logger, fileManager, filesToUpdate) {
+async function getCurrentVersion(config, logger, git, fileManager, filesToUpdate) {
   const files = [];
   const versions = /* @__PURE__ */ new Set();
   for (const file of filesToUpdate) {
+    if (await git.isIgnored(file)) {
+      logger.debug(`[Git Ignored] ${file}`);
+      continue;
+    }
     const fileState = fileManager.read(file);
     if (fileState) {
       files.push(fileState);
-      if (config.currentVersion) {
-        continue;
+      if (!config.currentVersion) {
+        versions.add(fileState.version);
       }
-      versions.add(fileState.version);
     }
   }
   if (config.currentVersion) {
     versions.add(config.currentVersion);
   }
   if (versions.size === 0 && config.gitTagFallback) {
-    const version = await getLatestGitTagVersion(config.tagPrefix);
+    const version = await git.getLatestTag(config.tagPrefix);
     if (version) {
-      logger.log(`[Version] Using git tag fallback.`);
+      logger.warn(`Using latest git tag as fallback`);
       versions.add(version);
     }
   }
@@ -966,10 +966,11 @@ async function getCurrentVersion(config, logger, fileManager, filesToUpdate) {
     if (!config.allowMultipleVersions) {
       throw new Error("Found multiple versions");
     }
-    logger.warn("[WARNING] Found multiple versions, using the first one.");
-    logger.log(`Versions: ${Array.from(versions).join(", ")}`);
+    logger.warn(
+      `Found multiple versions (${Array.from(versions).join(", ")}), using the higher semver version`
+    );
   }
-  const currentVersion = semver3.rsort(Array.from(versions))[0];
+  const currentVersion = semver2.rsort(Array.from(versions))[0];
   if (config.inspectVersion) {
     console.log(currentVersion);
     process.exit(0);
@@ -982,27 +983,27 @@ async function getCurrentVersion(config, logger, fileManager, filesToUpdate) {
 }
 async function getNextVersion(config, logger, currentVersion) {
   if (config.skipBump) {
-    logger.log("Skip bump, using current version as next version");
+    logger.warn(`Skip bump, using ${currentVersion} as the next version`);
     return {
       version: currentVersion
     };
   }
-  if (config.nextVersion && semver3.valid(config.nextVersion)) {
+  if (config.nextVersion && semver2.valid(config.nextVersion)) {
     logger.log(`Next version: ${config.nextVersion}`);
     return {
       version: config.nextVersion
     };
   }
-  const isPreMajor = semver3.lt(currentVersion, "1.0.0");
+  const isPreMajor = semver2.lt(currentVersion, "1.0.0");
   let recommendedBump;
-  try {
-    if (config.releaseAs) {
-      recommendedBump = {
-        releaseType: config.releaseAs,
-        level: -1,
-        reason: "User defined"
-      };
-    } else {
+  if (config.releaseAs) {
+    recommendedBump = {
+      releaseType: config.releaseAs,
+      level: -1,
+      reason: "User defined"
+    };
+  } else {
+    try {
       recommendedBump = await conventionalRecommendedBump({
         preset: {
           name: "conventionalcommits",
@@ -1013,9 +1014,11 @@ async function getNextVersion(config, logger, currentVersion) {
         tagPrefix: config.tagPrefix,
         cwd: config.path
       });
+    } catch (cause) {
+      throw new Error(`[conventional-recommended-bump] Unable to determine next version`, {
+        cause
+      });
     }
-  } catch (_error) {
-    throw new Error(`[conventional-recommended-bump] Unable to determine next version`);
   }
   if (recommendedBump.releaseType) {
     const releaseType = getReleaseType(
@@ -1023,18 +1026,18 @@ async function getNextVersion(config, logger, currentVersion) {
       currentVersion,
       config.preRelease
     );
-    const state = {
+    const nextVersion = semver2.inc(
+      currentVersion,
+      releaseType,
+      typeof config.preRelease === "string" ? config.preRelease : void 0
+    ) ?? "";
+    logger.log(`Next version: ${nextVersion} (${releaseType})`);
+    return {
       ...recommendedBump,
       preMajor: isPreMajor,
       releaseType,
-      version: semver3.inc(
-        currentVersion,
-        releaseType,
-        typeof config.preRelease === "string" ? config.preRelease : void 0
-      ) ?? ""
+      version: nextVersion
     };
-    logger.log(`Next version: ${state.version} (${state.releaseType})`);
-    return state;
   }
   throw new Error("Unable to find next version");
 }
@@ -1069,9 +1072,8 @@ function getNewReleaseContent(config, logger, nextVersion) {
         merges: null,
         path: config.path
       }
-    ).on("error", (error) => {
-      logger.error("[conventional-changelog] Unable to parse changes");
-      throw error;
+    ).on("error", (cause) => {
+      throw new Error("[conventional-changelog] Unable to parse changes", { cause });
     }).on("data", (chunk) => {
       newContent += chunk.toString();
     }).on("end", () => {
@@ -1081,7 +1083,7 @@ function getNewReleaseContent(config, logger, nextVersion) {
 }
 async function updateChangelog(config, logger, nextVersion) {
   if (config.skipChangelog) {
-    logger.log("Skip changelog update");
+    logger.warn("Skip changelog update");
     return;
   }
   if (config.header.search(RELEASE_PATTERN) !== -1) {
@@ -1089,12 +1091,13 @@ async function updateChangelog(config, logger, nextVersion) {
   }
   const changelogPath = resolve(config.path, config.changelog);
   if (!config.dryRun && !fileExists(changelogPath)) {
-    logger.log(`Creating Changelog file: ${changelogPath}`);
+    logger.log(`Creating changelog: ${changelogPath}`);
     writeFileSync(changelogPath, "\n", "utf8");
+  } else {
+    logger.log(`Updating changelog: ${changelogPath}`);
   }
   const oldContent = getOldReleaseContent(changelogPath, fileExists(changelogPath));
   const newContent = await getNewReleaseContent(config, logger, nextVersion);
-  logger.log(`Updating Changelog: ${changelogPath}`);
   if (!config.dryRun && newContent) {
     writeFileSync(
       changelogPath,
@@ -1118,7 +1121,7 @@ function formatCommitMessage(message, version) {
 // src/process/commit.ts
 async function commitChanges(config, logger, git, files, nextVersion) {
   if (config.skipCommit) {
-    logger.log("Skip commit");
+    logger.warn("Skip commit");
     return;
   }
   logger.log("Committing changes");
@@ -1150,11 +1153,11 @@ async function commitChanges(config, logger, git, files, nextVersion) {
 // src/process/tag.ts
 async function tagChanges(config, logger, git, nextVersion) {
   if (config.skipTag) {
-    logger.log("Skip tag creation");
+    logger.warn("Skip tag creation");
     return;
   }
   const tag = `${config.tagPrefix}${nextVersion}`;
-  logger.log(`Creating Tag: ${tag}`);
+  logger.log(`Creating tag: ${tag}`);
   await git.tag(
     config.sign ? "--sign" : "--annotate",
     tag,
@@ -1164,5 +1167,5 @@ async function tagChanges(config, logger, git, nextVersion) {
 }
 
 export { FileManager, ForkConfigSchema, Logger, commitChanges, defineConfig, getCurrentVersion, getNextVersion, getUserConfig, tagChanges, updateChangelog };
-//# sourceMappingURL=chunk-D7324DNL.js.map
-//# sourceMappingURL=chunk-D7324DNL.js.map
+//# sourceMappingURL=chunk-4M7BP5DG.js.map
+//# sourceMappingURL=chunk-4M7BP5DG.js.map