@storm-software/git-tools 2.123.16 → 2.124.0

package/bin/git.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { run } from './chunk-S5PS23TL.js';
-import { getConfig, handleProcess, writeSuccess, exitWithSuccess, exitWithError, writeInfo, findWorkspaceRootSafe, writeFatal, getWorkspaceConfig, joinPaths, writeDebug, defu, isVerbose, writeWarning, writeTrace, STORM_DEFAULT_RELEASE_BANNER, __require } from './chunk-K3LWFM6S.js';
+import { run } from './chunk-G3YPGVPS.js';
+import { getConfig, handleProcess, writeSuccess, exitWithSuccess, exitWithError, writeInfo, findWorkspaceRootSafe, writeFatal, getWorkspaceConfig, joinPaths, writeDebug, isVerbose, writeWarning, defu, writeTrace, STORM_DEFAULT_RELEASE_BANNER } from './chunk-VBJB46HW.js';
 import TOML from '@ltd/j-toml';
 import { Command } from 'commander';
 import { select, confirm, input } from '@inquirer/prompts';
@@ -24,39 +24,26 @@ import anchor from 'anchor-markdown-header';
 import { Parser } from 'htmlparser2';
 import _ from 'underscore';
 import updateSection from 'update-section';
-import { readCachedProjectGraph as readCachedProjectGraph$1, createProjectGraphAsync as createProjectGraphAsync$2, output as output$1, joinPathFragments } from '@nx/devkit';
-import { createAPI as createAPI$2 } from 'nx/src/command-line/release/publish.js';
-import { createAPI as createAPI$1 } from 'nx/src/command-line/release/version.js';
-import { readNxJson } from 'nx/src/config/nx-json.js';
-import { prompt } from 'enquirer';
-import { createNxReleaseConfig, handleNxReleaseConfigError } from 'nx/src/command-line/release/config/config';
-import { deepMergeJson } from 'nx/src/command-line/release/config/deep-merge-json';
-import { filterReleaseGroups } from 'nx/src/command-line/release/config/filter-release-groups';
-import { readRawVersionPlans, setResolvedVersionPlansOnGroups } from 'nx/src/command-line/release/config/version-plans';
-import { getCommitHash, parseGitCommit, getLatestGitTagForPattern, getFirstGitCommit, getGitDiff, parseCommits, gitAdd, gitPush } from 'nx/src/command-line/release/utils/git';
-import { launchEditor } from 'nx/src/command-line/release/utils/launch-editor';
-import { printAndFlushChanges, printDiff } from 'nx/src/command-line/release/utils/print-changes';
-import { printConfigAndExit } from 'nx/src/command-line/release/utils/print-config';
+import { readCachedProjectGraph as readCachedProjectGraph$1, createProjectGraphAsync as createProjectGraphAsync$2, readProjectsConfigurationFromProjectGraph as readProjectsConfigurationFromProjectGraph$2, output, joinPathFragments } from '@nx/devkit';
+import axios from 'axios';
+import 'enquirer';
+import { homedir } from 'node:os';
+import { printAndFlushChanges } from 'nx/src/command-line/release/utils/print-changes';
 import { defaultCreateReleaseProvider, GithubRemoteReleaseClient } from 'nx/src/command-line/release/utils/remote-release-clients/github';
-import { resolveNxJsonConfigErrorMessage } from 'nx/src/command-line/release/utils/resolve-nx-json-error-message';
-import { createCommitMessageValues, handleDuplicateGitTags, ReleaseVersion, noDiffInChangelogMessage } from 'nx/src/command-line/release/utils/shared';
-import { readNxJson as readNxJson$1 } from 'nx/src/config/nx-json';
-import { FsTree } from 'nx/src/generators/tree';
-import { createProjectFileMapUsingProjectGraph, createFileMapUsingProjectGraph } from 'nx/src/project-graph/file-map-utils';
+import { noDiffInChangelogMessage, handleDuplicateGitTags, createCommitMessageValues, isPrerelease, shouldPreferDockerVersionForReleaseGroup, ReleaseVersion } from 'nx/src/command-line/release/utils/shared';
+import { parse } from 'yaml';
+import chalk from 'chalk';
 import { interpolate } from 'nx/src/tasks-runner/utils';
-import { isCI } from 'nx/src/utils/is-ci';
-import { output } from 'nx/src/utils/output';
-import { joinPathFragments as joinPathFragments$1 } from 'nx/src/utils/path';
-import { workspaceRoot } from 'nx/src/utils/workspace-root';
-import { valid, major } from 'semver';
-import { dirSync } from 'tmp';
 import { resolveConfig, format } from 'prettier';
+import { ReleaseClient } from 'nx/release';
+import { getCommitHash, getLatestGitTagForPattern, getFirstGitCommit, gitPush, getGitDiff, parseCommits, gitAdd } from 'nx/src/command-line/release/utils/git';
+import { readNxJson } from 'nx/src/config/nx-json';
+import { FsTree } from 'nx/src/generators/tree';
+import { createFileMapUsingProjectGraph } from 'nx/src/project-graph/file-map-utils';
 import { execCommand } from 'nx/src/command-line/release/utils/exec-command.js';
-import axios from 'axios';
+import { prerelease, major } from 'semver';
 import DefaultChangelogRenderer from 'nx/release/changelog-renderer';
 import { DEFAULT_CONVENTIONAL_COMMITS_CONFIG } from 'nx/src/command-line/release/config/conventional-commits';
-import { homedir } from 'node:os';
-import { parse } from 'yaml';
 
 function parseCargoToml(cargoString) {
   if (!cargoString) {
@@ -923,10 +910,10 @@ async function lint(message, config5) {
       throw new Error(`Could not find rule implementation for ${name}`);
     }
     const executableRule = rule;
-    const [valid3, message2] = await executableRule(parsed, when, value);
+    const [valid2, message2] = await executableRule(parsed, when, value);
     return {
       level,
-      valid: valid3,
+      valid: valid2,
       name,
       message: message2
     };
@@ -940,9 +927,9 @@ async function lint(message, config5) {
   const warnings = results.filter(
     (result) => result.level === 1 /* Warning */ && !result.valid
   );
-  const valid2 = errors.length === 0;
+  const valid = errors.length === 0;
   return {
-    valid: valid2,
+    valid,
     errors,
     warnings,
     input: buildCommitMessage(parsed)
@@ -1387,6 +1374,15 @@ function findFileName(filePath) {
 function findFilePath(filePath) {
   return filePath.replace(findFileName(filePath), "");
 }
+function createFileToProjectMap(projectFileMap) {
+  const fileToProjectMap = {};
+  for (const [projectName, projectFiles] of Object.entries(projectFileMap)) {
+    for (const file of projectFiles) {
+      fileToProjectMap[file.file] = projectName;
+    }
+  }
+  return fileToProjectMap;
+}
 var start = "<!-- START doctoc -->\n<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->";
 var end = "<!-- END doctoc -->";
 var skipTag = "<!-- DOCTOC SKIP -->";
@@ -1951,7 +1947,7 @@ var createRegExp = (sectionName) => {
 var runReadme = async ({
   templates = "./tools/readme-templates",
   project,
-  output: output3,
+  output: output4,
   clean = true,
   prettier = true
 }) => {
@@ -1962,7 +1958,7 @@ var runReadme = async ({
   if (project) {
     await runProjectReadme(project, {
       templates,
-      output: output3,
+      output: output4,
       clean,
       prettier
     });
@@ -1970,14 +1966,14 @@ var runReadme = async ({
     for (const projectName of Object.keys(projectConfigs.projects)) {
       await runProjectReadme(projectName, {
         templates,
-        output: output3,
+        output: output4,
         clean,
         prettier
       });
     }
   }
 };
-var runProjectReadme = async (projectName, { templates, output: output3, clean = true, prettier = true }) => {
+var runProjectReadme = async (projectName, { templates, output: output4, clean = true, prettier = true }) => {
   const projectGraph = await createProjectGraphAsync({
     exitOnError: true
   });
@@ -1986,7 +1982,7 @@ var runProjectReadme = async (projectName, { templates, output: output3, clean =
   const inputFile = join$1(project?.root ?? "./", "README.md");
   if (existsSync$1(inputFile)) {
     console.info(`Formatting ${projectName}'s README file at "${inputFile}"`);
-    const outputFilePath = output3 ? output3.includes("README.md") ? output3 : join$1(findFilePath(output3), "README.md") : inputFile;
+    const outputFilePath = output4 ? output4.includes("README.md") ? output4 : join$1(findFilePath(output4), "README.md") : inputFile;
     if (clean && existsSync$1(outputFilePath)) {
       if (outputFilePath === inputFile) {
         console.warn(
@@ -2395,7 +2391,7 @@ function generateChangelogTitle(version, project, workspaceConfig) {
   if (!workspaceConfig?.name || !project) {
     return version;
   }
-  return `[${version}](https://github.com/${typeof workspaceConfig.organization === "string" ? workspaceConfig.organization : workspaceConfig.organization?.name}/${workspaceConfig.name}/releases/tag/${project}%40${version}) (${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)})`;
+  return `[${version}](https://github.com/${typeof workspaceConfig.organization === "string" ? workspaceConfig.organization : workspaceConfig.organization?.name}/${workspaceConfig.name}/releases/tag/${project}%40${version}) (${(/* @__PURE__ */ new Date()).getMonth() + 1}/${(/* @__PURE__ */ new Date()).getDate()}/${(/* @__PURE__ */ new Date()).getFullYear()})`;
 }
 function parseChangelogMarkdown(contents) {
   const CHANGELOG_RELEASE_HEAD_RE = new RegExp(
@@ -2424,6 +2420,357 @@ function parseChangelogMarkdown(contents) {
     releases
   };
 }
+function filterHiddenChanges(changes, conventionalCommitsConfig) {
+  return changes.filter((change) => {
+    const type = change.type;
+    const typeConfig = conventionalCommitsConfig.types[type];
+    if (!typeConfig) {
+      return false;
+    }
+    return !typeConfig.changelog.hidden;
+  });
+}
+async function generateChangelogForProjects({
+  args,
+  changes,
+  projectsVersionData,
+  releaseGroup,
+  projects,
+  releaseConfig,
+  projectToAdditionalDependencyBumps,
+  workspaceConfig,
+  ChangelogRendererClass
+}) {
+  const config5 = releaseGroup.changelog;
+  if (config5 === false) {
+    return;
+  }
+  const dryRun = !!args.dryRun;
+  const remoteReleaseClient = await createGithubRemoteReleaseClient(
+    workspaceConfig,
+    args.gitRemote
+  );
+  const projectChangelogs = {};
+  for (const project of projects) {
+    let interpolatedTreePath = config5.file || "";
+    if (interpolatedTreePath) {
+      interpolatedTreePath = interpolate(interpolatedTreePath, {
+        projectName: project.name,
+        projectRoot: project.data.root,
+        workspaceRoot: ""
+        // within the tree, workspaceRoot is the root
+      });
+    }
+    if (!projectsVersionData[project.name] || projectsVersionData[project.name]?.newVersion === null && !projectsVersionData[project.name]?.dockerVersion) {
+      continue;
+    }
+    const preferDockerVersion = shouldPreferDockerVersionForReleaseGroup(releaseGroup);
+    const releaseVersion = new ReleaseVersion({
+      version: (preferDockerVersion === true || preferDockerVersion === "both") && projectsVersionData[project.name]?.dockerVersion ? projectsVersionData[project.name]?.dockerVersion : projectsVersionData[project.name]?.newVersion,
+      releaseTagPattern: releaseGroup.releaseTag.pattern,
+      projectName: project.name
+    });
+    if (interpolatedTreePath) {
+      const prefix = dryRun ? "Previewing" : "Generating";
+      output.log({
+        title: `${prefix} an entry in ${interpolatedTreePath} for ${chalk.white(
+          releaseVersion.gitTag
+        )}`
+      });
+    }
+    const changelogRenderer = new ChangelogRendererClass({
+      changes,
+      changelogEntryVersion: releaseVersion.rawVersion,
+      project: project.name,
+      entryWhenNoChanges: typeof config5.entryWhenNoChanges === "string" ? interpolate(config5.entryWhenNoChanges, {
+        projectName: project.name,
+        projectRoot: project.data.root,
+        workspaceRoot: ""
+        // within the tree, workspaceRoot is the root
+      }) : false,
+      changelogRenderOptions: config5.renderOptions,
+      isVersionPlans: !!releaseGroup.versionPlans,
+      conventionalCommitsConfig: releaseConfig.conventionalCommits,
+      dependencyBumps: projectToAdditionalDependencyBumps.get(project.name),
+      remoteReleaseClient,
+      workspaceConfig
+    });
+    const contents = await changelogRenderer.render();
+    const postGitTask = args.createRelease !== false && config5.createRelease ? remoteReleaseClient.createPostGitTask(
+      releaseVersion,
+      contents,
+      dryRun
+    ) : null;
+    projectChangelogs[project.name] = {
+      releaseVersion,
+      contents,
+      postGitTask
+    };
+  }
+  return projectChangelogs;
+}
+
+// src/release/github.ts
+var StormGithubRemoteReleaseClient = class extends GithubRemoteReleaseClient {
+  #remoteRepoData;
+  #workspaceConfig;
+  /**
+   * Creates an instance of {@link StormGithubRemoteReleaseClient}.
+   *
+   * @param remoteRepoData - Data about the remote repository
+   * @param createReleaseConfig - Configuration for creating releases
+   * @param tokenData - Token data for authentication
+   * @param workspaceConfig - The Storm workspace configuration object, which is loaded from the storm-workspace.json file.
+   */
+  constructor(remoteRepoData, createReleaseConfig, tokenData, workspaceConfig) {
+    super(remoteRepoData, createReleaseConfig, tokenData);
+    this.#remoteRepoData = remoteRepoData;
+    this.#workspaceConfig = workspaceConfig;
+  }
+  createPostGitTask(releaseVersion, changelogContents, dryRun) {
+    return async (latestCommit) => {
+      if (!this.#workspaceConfig) {
+        this.#workspaceConfig = await getWorkspaceConfig();
+      }
+      output.logSingleLine(`Creating GitHub Release`);
+      const name = releaseVersion.gitTag.includes("@") ? releaseVersion.gitTag.replace(new RegExp(`^@${this.#workspaceConfig.name}/`), "").replace(/@.*$/, "") : releaseVersion.gitTag;
+      await this.createOrUpdateRelease(
+        releaseVersion,
+        `![${(typeof this.#workspaceConfig.release.banner === "string" ? this.#workspaceConfig.organization ? titleCase(
+          typeof this.#workspaceConfig.organization === "string" ? this.#workspaceConfig.organization : this.#workspaceConfig.organization.name
+        ) : void 0 : this.#workspaceConfig.release.banner.alt) || "Release banner header"}](${typeof this.#workspaceConfig.release.banner === "string" ? this.#workspaceConfig.release.banner : this.#workspaceConfig.release.banner?.url})
+${this.#workspaceConfig.release.header || ""}
+
+# ${name ? `${titleCase(name)} ` : ""}v${releaseVersion.rawVersion}
+
+We at [${this.#workspaceConfig.organization ? titleCase(
+          typeof this.#workspaceConfig.organization === "string" ? this.#workspaceConfig.organization : this.#workspaceConfig.organization.name
+        ) : ""}](${this.#workspaceConfig.homepage}) are very excited to announce the v${releaseVersion.rawVersion} release of the ${name ? this.#workspaceConfig.name ? `${titleCase(this.#workspaceConfig.name)} - ${titleCase(name)}` : titleCase(name) : this.#workspaceConfig.name ? titleCase(this.#workspaceConfig.name) : "Storm Software"} project! \u{1F680}
+
+These changes are released under the ${this.#workspaceConfig.license.includes("license") ? this.#workspaceConfig.license : `${this.#workspaceConfig.license} license`}. You can find more details on [our licensing page](${this.#workspaceConfig.licensing}). You can find guides, API references, and other documentation around this release (and much more) on [our documentation site](${this.#workspaceConfig.docs}).
+
+If you have any questions or comments, feel free to reach out to the team on [Discord](${this.#workspaceConfig.socials.discord}) or [our contact page](${this.#workspaceConfig.contact}). Please help us spread the word by giving [this repository](https://github.com/${typeof this.#workspaceConfig.organization === "string" ? this.#workspaceConfig.organization : this.#workspaceConfig.organization?.name}/${this.#workspaceConfig.name}) a star \u2B50 on GitHub or [posting on X (Twitter)](https://x.com/intent/tweet?text=Check%20out%20the%20latest%20@${this.#workspaceConfig.socials.twitter}%20release%20${name ? `${titleCase(name)?.replaceAll(" ", "%20")}%20` : ""}v${releaseVersion.rawVersion}%20%F0%9F%9A%80%0D%0A%0D%0Ahttps://github.com/${typeof this.#workspaceConfig.organization === "string" ? this.#workspaceConfig.organization : this.#workspaceConfig.organization?.name}/${this.#workspaceConfig.name}/releases/tag/${releaseVersion.gitTag}) about this release!
+
+## Release Notes
+
+${changelogContents.replaceAll(
+          `## ${generateChangelogTitle(
+            releaseVersion.rawVersion,
+            name,
+            this.#workspaceConfig
+          )}`,
+          ""
+        ).replaceAll(
+          `# ${generateChangelogTitle(releaseVersion.rawVersion, name, this.#workspaceConfig)}`,
+          ""
+        )}
+
+---
+
+${this.#workspaceConfig.release.footer}
+`,
+        latestCommit,
+        { dryRun }
+      );
+    };
+  }
+  /**
+   * Get remote repository data, attempting to resolve it if not already set.
+   */
+  getRemoteRepoData() {
+    if (!this.#remoteRepoData) {
+      let githubRepoData = super.getRemoteRepoData();
+      if (!githubRepoData) {
+        githubRepoData = getGitHubRepoData();
+        if (!githubRepoData) {
+          output.error({
+            title: `Unable to create a GitHub release because the GitHub repo slug could not be determined.`,
+            bodyLines: [
+              `Please ensure you have a valid GitHub remote configured. You can run \`git remote -v\` to list your current remotes.`
+            ]
+          });
+          process.exit(1);
+        }
+      }
+      this.#remoteRepoData = githubRepoData;
+    }
+    return this.#remoteRepoData;
+  }
+};
+function getGitHubRepoData(remoteName = "origin", createReleaseConfig = "github") {
+  try {
+    const remoteUrl = execSync(`git remote get-url ${remoteName}`, {
+      encoding: "utf8",
+      stdio: "pipe"
+    }).trim();
+    let hostname = defaultCreateReleaseProvider.hostname;
+    let apiBaseUrl = defaultCreateReleaseProvider.apiBaseUrl;
+    if (createReleaseConfig && typeof createReleaseConfig !== "string") {
+      hostname = createReleaseConfig.hostname;
+      apiBaseUrl = createReleaseConfig.apiBaseUrl;
+    }
+    const escapedHostname = hostname.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regexString = `${escapedHostname}[/:]([\\w.-]+/[\\w.-]+)(\\.git)?`;
+    const regex = new RegExp(regexString);
+    const match = remoteUrl?.match(regex);
+    if (match && match[1]) {
+      return {
+        hostname,
+        apiBaseUrl,
+        // Ensure any trailing .git is stripped
+        slug: match[1].replace(/\.git$/, "")
+      };
+    } else {
+      throw new Error(
+        `Could not extract "user/repo" data from the resolved remote URL: ${remoteUrl}`
+      );
+    }
+  } catch (error) {
+    output.error({
+      title: `Failed to get GitHub repo data`,
+      bodyLines: [error.message]
+    });
+    return void 0;
+  }
+}
+async function resolveTokenData(hostname) {
+  const tokenFromEnv = process.env.STORM_BOT_GITHUB_TOKEN || process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
+  if (tokenFromEnv) {
+    return { token: tokenFromEnv, headerName: "Authorization" };
+  }
+  const ghCLIPath = joinPathFragments(
+    process.env.XDG_CONFIG_HOME || joinPathFragments(homedir(), ".config"),
+    "gh",
+    "hosts.yml"
+  );
+  if (existsSync$1(ghCLIPath)) {
+    const yamlContents = await promises.readFile(ghCLIPath, "utf8");
+    const ghCLIConfig = parse(yamlContents);
+    if (ghCLIConfig[hostname]) {
+      if (ghCLIConfig[hostname].oauth_token) {
+        return ghCLIConfig[hostname].oauth_token;
+      }
+      if (ghCLIConfig[hostname].user && ghCLIConfig[hostname].git_protocol === "ssh") {
+        const token = execSync(`gh auth token`, {
+          encoding: "utf8",
+          stdio: "pipe",
+          windowsHide: false
+        }).trim();
+        return { token, headerName: "Authorization" };
+      }
+    }
+  }
+  if (hostname !== "github.com") {
+    console.log(
+      `Warning: It was not possible to automatically resolve a GitHub token from your environment for hostname ${hostname}. If you set the GITHUB_TOKEN or GH_TOKEN environment variable, that will be used for GitHub API requests.`
+    );
+  }
+  throw new Error(
+    `Unable to resolve a GitHub token for hostname ${hostname}. Please set the GITHUB_TOKEN or GH_TOKEN environment variable, or ensure you have an active session via the official gh CLI tool (https://cli.github.com).`
+  );
+}
+async function makeGithubRequest(config5, url, opts = {}) {
+  return await axios(url, {
+    ...opts,
+    baseURL: config5.apiBaseUrl,
+    headers: {
+      ...opts.headers,
+      Authorization: config5.token ? `Bearer ${config5.token}` : void 0
+    }
+  });
+}
+async function createGithubRemoteReleaseClient(workspaceConfig, remoteName = "origin") {
+  const repoData = getGitHubRepoData(remoteName, "github");
+  if (!repoData) {
+    throw new Error(
+      `Unable to create a remote release client because the GitHub repo slug could not be determined. Please ensure you have a valid GitHub remote configured.`
+    );
+  }
+  return new StormGithubRemoteReleaseClient(
+    repoData,
+    {
+      provider: "github",
+      hostname: repoData.hostname,
+      apiBaseUrl: repoData.apiBaseUrl
+    },
+    await resolveTokenData(repoData.hostname),
+    workspaceConfig
+  );
+}
+async function isUserAnOrganizationMember(userId, config5, remoteName = "origin") {
+  try {
+    const repoData = getGitHubRepoData(remoteName, "github");
+    if (!repoData) {
+      throw new Error(
+        `Unable to validate GitHub actor because the GitHub repo slug could not be determined. Please ensure you have a valid GitHub remote configured.`
+      );
+    }
+    const tokenData = await resolveTokenData(repoData.hostname);
+    if (!tokenData.token) {
+      throw new Error(
+        `Unable to validate GitHub actor because no token was provided. Please set the GITHUB_TOKEN or GH_TOKEN environment variable, or ensure you have an active session via the official gh CLI tool (https://cli.github.com).`
+      );
+    }
+    const result = await makeGithubRequest(
+      {
+        repo: repoData.slug,
+        hostname: repoData.hostname,
+        apiBaseUrl: repoData.apiBaseUrl,
+        token: tokenData?.token || null
+      },
+      `/orgs/${typeof config5.organization === "string" ? config5.organization : config5.organization?.name}/members/${userId}`,
+      {}
+    );
+    if (result.status !== 204) {
+      return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getCommits(fromSHA, toSHA) {
+  const rawCommits = await getGitDiff(fromSHA, toSHA);
+  return parseCommits(rawCommits);
+}
+async function filterProjectCommits({
+  fromSHA,
+  toSHA,
+  projectPath
+}) {
+  const allCommits = await getCommits(fromSHA, toSHA);
+  return allCommits.filter(
+    (c) => c.affectedFiles.find((f) => f.startsWith(projectPath))
+  );
+}
+function commitChangesNonProjectFiles(commit, nonProjectFiles) {
+  return nonProjectFiles.some(
+    (fileData) => commit.affectedFiles.includes(fileData.file)
+  );
+}
+function getProjectsAffectedByCommit(commit, fileToProjectMap) {
+  const affectedProjects = /* @__PURE__ */ new Set();
+  for (const file of commit.affectedFiles) {
+    affectedProjects.add(fileToProjectMap[file]);
+  }
+  return Array.from(affectedProjects);
+}
+function extractPreid(version) {
+  if (!isPrerelease(version)) {
+    return void 0;
+  }
+  const preid = prerelease(version)?.[0];
+  if (typeof preid === "string") {
+    if (preid.trim() === "") {
+      return void 0;
+    }
+    return preid;
+  }
+  if (typeof preid === "number") {
+    return preid.toString();
+  }
+  return void 0;
+}
 function createGitTagValues(releaseGroups, releaseGroupToFilteredProjects, versionData) {
   const tags = [];
   for (const releaseGroup of releaseGroups) {
@@ -2570,30 +2917,43 @@ async function commitChanges({
     verbose: isVerbose2
   });
 }
+
+// src/utilities/omit.ts
+function omit(obj, keys) {
+  const result = { ...obj };
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (key && key in result) {
+      delete result[key];
+    }
+  }
+  return result;
+}
 var StormChangelogRenderer = class extends DefaultChangelogRenderer {
   /**
    * The Storm workspace configuration object, which is loaded from the storm-workspace.json file.
    */
-  workspaceConfig = null;
-  /**
-   * The configuration object for the ChangelogRenderer, which includes the changes, version, project, and other options.
-   */
-  config;
+  workspaceConfig;
   /**
    * A ChangelogRenderer class takes in the determined changes and other relevant metadata and returns a string, or a Promise of a string of changelog contents (usually markdown).
    *
    * @param config - The configuration object for the ChangelogRenderer
    */
   constructor(config5) {
-    super(config5);
-    this.config = {
-      ...config5,
-      repoData: config5.remoteReleaseClient.getRemoteRepoData()
+    const resolvedConfig = {
+      entryWhenNoChanges: false,
+      conventionalCommitsConfig: DEFAULT_CONVENTIONAL_COMMITS_CONFIG,
+      ...config5
     };
+    super(resolvedConfig);
+    this.workspaceConfig = config5.workspaceConfig;
+    this.remoteReleaseClient = resolvedConfig.remoteReleaseClient;
   }
   async render() {
-    this.workspaceConfig = await getWorkspaceConfig();
-    return await super.render();
+    if (!this.workspaceConfig) {
+      this.workspaceConfig = await getWorkspaceConfig();
+    }
+    return super.render();
   }
   preprocessChanges() {
     this.relevantChanges = [...this.changes];
@@ -2672,7 +3032,7 @@ var StormChangelogRenderer = class extends DefaultChangelogRenderer {
   renderDependencyBumps() {
     const markdownLines = ["", "### Updated Dependencies", ""];
     this.dependencyBumps?.forEach(({ dependencyName, newVersion }) => {
-      const markdownLine = `- Updated ${dependencyName} to ${newVersion}`;
+      const markdownLine = `- Updated **${dependencyName}** to **v${newVersion}**`;
       if (!markdownLines.includes(markdownLine)) {
         markdownLines.push(markdownLine);
       }
@@ -2702,7 +3062,7 @@ var StormChangelogRenderer = class extends DefaultChangelogRenderer {
         }
       }
     }
-    if (this.config.repoData && this.changelogRenderOptions.mapAuthorsToGitHubUsernames) {
+    if (this.changelogRenderOptions.mapAuthorsToGitHubUsernames) {
       await Promise.all(
         [..._authors.keys()].map(async (authorName) => {
           const meta = _authors.get(authorName);
@@ -2759,7 +3119,7 @@ var StormChangelogRenderer = class extends DefaultChangelogRenderer {
       extraLinesStr = extraLines.filter((l) => l.trim().length > 0).map((l) => `${indentation}${l}`).join("\n");
     }
     let changeLine = "- " + (!this.isVersionPlans && change.scope ? `**${change.scope.trim()}:** ` : "") + description;
-    if (this.config.repoData && change.githubReferences) {
+    if (change.githubReferences) {
       changeLine += this.remoteReleaseClient.formatReferences(
         change.githubReferences
       );
@@ -2770,626 +3130,239 @@ var StormChangelogRenderer = class extends DefaultChangelogRenderer {
     return changeLine;
   }
 };
-function getGitHubRepoData(remoteName = "origin", createReleaseConfig) {
-  try {
-    const remoteUrl = execSync(`git remote get-url ${remoteName}`, {
-      encoding: "utf8",
-      stdio: "pipe"
-    }).trim();
-    let hostname = defaultCreateReleaseProvider.hostname;
-    let apiBaseUrl = defaultCreateReleaseProvider.apiBaseUrl;
-    if (createReleaseConfig && typeof createReleaseConfig !== "string") {
-      hostname = createReleaseConfig.hostname;
-      apiBaseUrl = createReleaseConfig.apiBaseUrl;
-    }
-    const escapedHostname = hostname.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const regexString = `${escapedHostname}[/:]([\\w.-]+/[\\w.-]+)(\\.git)?`;
-    const regex = new RegExp(regexString);
-    const match = remoteUrl?.match(regex);
-    if (match && match[1]) {
-      return {
-        hostname,
-        apiBaseUrl,
-        // Ensure any trailing .git is stripped
-        slug: match[1].replace(/\.git$/, "")
-      };
-    } else {
-      throw new Error(
-        `Could not extract "user/repo" data from the resolved remote URL: ${remoteUrl}`
-      );
-    }
-  } catch (error) {
-    output$1.error({
-      title: `Failed to get GitHub repo data`,
-      bodyLines: [error.message]
-    });
-    return void 0;
-  }
-}
-async function createOrUpdateGithubRelease(createReleaseConfig, releaseVersion, changelogContents, latestCommit, { dryRun }) {
-  const githubRepoData = getGitHubRepoData(void 0, createReleaseConfig);
-  if (!githubRepoData) {
-    output$1.error({
-      title: `Unable to create a GitHub release because the GitHub repo slug could not be determined.`,
-      bodyLines: [
-        `Please ensure you have a valid GitHub remote configured. You can run \`git remote -v\` to list your current remotes.`
-      ]
-    });
-    process.exit(1);
-  }
-  const tokenData = await resolveTokenData(githubRepoData.hostname);
-  const githubRequestConfig = {
-    repo: githubRepoData.slug,
-    hostname: githubRepoData.hostname,
-    apiBaseUrl: githubRepoData.apiBaseUrl,
-    token: tokenData?.token || null
-  };
-  let existingGithubReleaseForVersion;
-  try {
-    existingGithubReleaseForVersion = await getGithubReleaseByTag(
-      githubRequestConfig,
-      releaseVersion.gitTag
-    );
-  } catch (err) {
-    if (err.response?.status === 401) {
-      output$1.error({
-        title: `Unable to resolve data via the GitHub API. You can use any of the following options to resolve this:`,
-        bodyLines: [
-          "- Set the `GITHUB_TOKEN` or `GH_TOKEN` environment variable to a valid GitHub token with `repo` scope",
-          "- Have an active session via the official gh CLI tool (https://cli.github.com) in your current terminal"
-        ]
-      });
-      process.exit(1);
-    }
-    if (err.response?.status === 404) ; else {
-      throw err;
-    }
-  }
-  const logTitle = `https://${githubRepoData.hostname}/${githubRepoData.slug}/releases/tag/${releaseVersion.gitTag}`;
-  if (existingGithubReleaseForVersion) {
-    console.error(`UPDATE ${logTitle}${dryRun ? " [dry-run]" : ""}`);
-  } else {
-    console.error(`CREATE ${logTitle}${dryRun ? " [dry-run]" : ""}`);
-  }
-  console.log("");
-  printDiff(
-    existingGithubReleaseForVersion?.body ? existingGithubReleaseForVersion.body : "",
-    changelogContents,
-    3,
-    noDiffInChangelogMessage
-  );
-  if (!dryRun) {
-    await createOrUpdateGithubReleaseInternal(
-      githubRequestConfig,
-      {
-        version: releaseVersion.gitTag,
-        prerelease: releaseVersion.isPrerelease,
-        body: changelogContents,
-        commit: latestCommit
-      },
-      existingGithubReleaseForVersion
-    );
-  }
-}
-async function createOrUpdateGithubReleaseInternal(githubRequestConfig, release, existingGithubReleaseForVersion) {
-  const result = await syncGithubRelease(
-    githubRequestConfig,
-    release,
-    existingGithubReleaseForVersion
-  );
-  if (result.status === "manual") {
-    if (result.error) {
-      process.exitCode = 1;
-      if (result.error.response?.data) {
-        output$1.error({
-          title: `A GitHub API Error occurred when creating/updating the release`,
-          bodyLines: [
-            `GitHub Error: ${JSON.stringify(result.error.response.data)}`,
-            `---`,
-            `Request Data:`,
-            `Repo: ${githubRequestConfig.repo}`,
-            `Token: ${githubRequestConfig.token}`,
-            `Body: ${JSON.stringify(result.requestData)}`
-          ]
-        });
-      } else {
-        console.log(result.error);
-        console.error(
-          `An unknown error occurred while trying to create a release on GitHub, please report this on https://github.com/nrwl/nx (NOTE: make sure to redact your GitHub token from the error message!)`
-        );
-      }
-    }
-    const shouldContinueInGitHub = await promptForContinueInGitHub();
-    if (!shouldContinueInGitHub) {
-      return;
-    }
-    const open = __require("open");
-    await open(result.url).then(() => {
-      console.info(
-        `
-Follow up in the browser to manually create the release:
 
-` + result.url + `
-`
-      );
-    }).catch(() => {
-      console.info(
-        `Open this link to manually create a release: 
-` + result.url + "\n"
-      );
-    });
-    if (result.error) {
-      console.error(result.error);
-      process.exitCode = 1;
+// src/release/config.ts
+var DEFAULT_CONVENTIONAL_COMMITS_CONFIG2 = {
+  questions: DEFAULT_MONOREPO_COMMIT_QUESTIONS,
+  types: DEFAULT_COMMIT_TYPES
+};
+var DEFAULT_RELEASE_TAG_PATTERN = "{projectName}@{version}";
+var DEFAULT_RELEASE_GROUP_CONFIG = {
+  projectsRelationship: "independent",
+  changelog: {
+    createRelease: "github",
+    entryWhenNoChanges: false,
+    file: false,
+    renderOptions: {
+      authors: false,
+      commitReferences: true,
+      versionTitleDate: true
     }
-    await open(result.url).then(() => {
-      console.info(
-        `Follow up in the browser to manually create the release.`
-      );
-    }).catch(() => {
-      console.info(
-        `Open this link to manually create a release: 
-` + result.url + "\n"
-      );
-    });
-  }
-}
-async function promptForContinueInGitHub() {
-  try {
-    const reply = await prompt([
+  },
+  version: {
+    currentVersionResolver: "git-tag",
+    specifierSource: "conventional-commits",
+    groupPreVersionCommand: "pnpm build"
+  },
+  releaseTag: { pattern: DEFAULT_RELEASE_TAG_PATTERN }
+};
+var DEFAULT_JS_RELEASE_GROUP_CONFIG = {
+  ...DEFAULT_RELEASE_GROUP_CONFIG,
+  projects: ["packages/*"],
+  version: {
+    ...DEFAULT_RELEASE_GROUP_CONFIG.version,
+    versionActions: "@storm-software/workspace-tools/release/js-version-actions",
+    versionActionsOptions: {
+      currentVersionResolver: "git-tag",
+      specifierSource: "conventional-commits"
+    },
+    manifestRootsToUpdate: [
+      "{projectRoot}",
       {
-        name: "open",
-        message: "Do you want to finish creating the release manually in your browser?",
-        type: "autocomplete",
-        choices: [
-          {
-            name: "Yes",
-            hint: "It will pre-populate the form for you"
-          },
-          {
-            name: "No"
-          }
-        ],
-        initial: 0
+        path: "dist/{projectRoot}",
+        preserveLocalDependencyProtocols: false
       }
-    ]);
-    return reply.open === "Yes";
-  } catch {
-    process.stdout.write("\x1B[?25h");
-    process.exit(1);
+    ]
   }
-}
-async function syncGithubRelease(githubRequestConfig, release, existingGithubReleaseForVersion) {
-  const ghRelease = {
-    tag_name: release.version,
-    name: release.version,
-    body: release.body,
-    prerelease: release.prerelease,
-    // legacy specifies that the latest release should be determined based on the release creation date and higher semantic version.
-    make_latest: "legacy"
-  };
-  try {
-    const newGhRelease = await (existingGithubReleaseForVersion ? updateGithubRelease(
-      githubRequestConfig,
-      existingGithubReleaseForVersion.id,
-      ghRelease
-    ) : createGithubRelease(githubRequestConfig, {
-      ...ghRelease,
-      target_commitish: release.commit
-    }));
-    return {
-      status: existingGithubReleaseForVersion ? "updated" : "created",
-      id: newGhRelease.id,
-      url: newGhRelease.html_url
-    };
-  } catch (error) {
-    if (process.env.CI) {
-      console.error(
-        `An error occurred while trying to create a release on GitHub, please report this on https://github.com/storm-software/storm-ops (NOTE: make sure to redact your GitHub token from the error message!): ${typeof error?.message === "string" ? error?.message : `
-
-${error}`}`
-      );
-      throw new Error(
-        "`An error occurred while trying to create a release on GitHub in a CI environment",
+};
+var DEFAULT_RUST_RELEASE_GROUP_CONFIG = {
+  ...DEFAULT_RELEASE_GROUP_CONFIG,
+  projects: ["crates/*"],
+  version: {
+    ...DEFAULT_RELEASE_GROUP_CONFIG.version,
+    versionActions: "@storm-software/workspace-tools/release/rust-version-actions",
+    versionActionsOptions: {
+      currentVersionResolver: "git-tag",
+      specifierSource: "conventional-commits"
+    },
+    manifestRootsToUpdate: ["{projectRoot}"]
+  }
+};
+var DEFAULT_RELEASE_CONFIG = {
+  conventionalCommits: DEFAULT_CONVENTIONAL_COMMITS_CONFIG2,
+  groups: {
+    packages: DEFAULT_JS_RELEASE_GROUP_CONFIG,
+    crates: DEFAULT_RUST_RELEASE_GROUP_CONFIG
+  },
+  changelog: {
+    automaticFromRef: true,
+    workspaceChangelog: false,
+    projectChangelogs: true
+  },
+  releaseTag: { pattern: DEFAULT_RELEASE_TAG_PATTERN }
+};
+function getReleaseGroupConfig(releaseConfig, workspaceConfig) {
+  return !releaseConfig?.groups || Object.keys(releaseConfig.groups).length === 0 ? {} : Object.fromEntries(
+    Object.entries(releaseConfig.groups).map(([name, group]) => {
+      const config5 = defu(
+        {
+          ...omit(DEFAULT_RELEASE_GROUP_CONFIG, ["changelog"]),
+          ...group
+        },
         {
-          cause: error
+          changelog: {
+            ...DEFAULT_RELEASE_GROUP_CONFIG.changelog,
+            renderer: StormChangelogRenderer,
+            renderOptions: {
+              ...DEFAULT_RELEASE_GROUP_CONFIG.changelog.renderOptions,
+              workspaceConfig
+            }
+          }
         }
       );
-    }
-    return {
-      status: "manual",
-      error,
-      url: githubNewReleaseURL(githubRequestConfig, release),
-      requestData: ghRelease
-    };
-  }
-}
-async function resolveTokenData(hostname) {
-  const tokenFromEnv = process.env.STORM_BOT_GITHUB_TOKEN || process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
-  if (tokenFromEnv) {
-    return { token: tokenFromEnv, headerName: "Authorization" };
-  }
-  const ghCLIPath = joinPathFragments(
-    process.env.XDG_CONFIG_HOME || joinPathFragments(homedir(), ".config"),
-    "gh",
-    "hosts.yml"
-  );
-  if (existsSync$1(ghCLIPath)) {
-    const yamlContents = await promises.readFile(ghCLIPath, "utf8");
-    const ghCLIConfig = parse(yamlContents);
-    if (ghCLIConfig[hostname]) {
-      if (ghCLIConfig[hostname].oauth_token) {
-        return ghCLIConfig[hostname].oauth_token;
-      }
-      if (ghCLIConfig[hostname].user && ghCLIConfig[hostname].git_protocol === "ssh") {
-        const token = execSync(`gh auth token`, {
-          encoding: "utf8",
-          stdio: "pipe",
-          windowsHide: false
-        }).trim();
-        return { token, headerName: "Authorization" };
+      if (workspaceConfig?.workspaceRoot) {
+        if (config5.changelog?.renderer && typeof config5.changelog?.renderer === "string" && config5.changelog?.renderer?.toString().startsWith("./")) {
+          config5.changelog.renderer = joinPaths(
+            workspaceConfig.workspaceRoot,
+            config5.changelog.renderer
+          );
+        }
+        if (config5.version?.versionActions && config5.version.versionActions.startsWith("./")) {
+          config5.version.versionActions = joinPaths(
+            workspaceConfig.workspaceRoot,
+            config5.version?.versionActions
+          );
+        }
       }
-    }
-  }
-  if (hostname !== "github.com") {
-    console.log(
-      `Warning: It was not possible to automatically resolve a GitHub token from your environment for hostname ${hostname}. If you set the GITHUB_TOKEN or GH_TOKEN environment variable, that will be used for GitHub API requests.`
-    );
-  }
-  throw new Error(
-    `Unable to resolve a GitHub token for hostname ${hostname}. Please set the GITHUB_TOKEN or GH_TOKEN environment variable, or ensure you have an active session via the official gh CLI tool (https://cli.github.com).`
+      return [name, config5];
+    })
   );
 }
-async function getGithubReleaseByTag(config5, tag) {
-  return (await makeGithubRequest(
-    config5,
-    `/repos/${config5.repo}/releases/tags/${tag}`,
-    {}
-  )).data;
-}
-async function makeGithubRequest(config5, url, opts = {}) {
-  return await axios(url, {
-    ...opts,
-    baseURL: config5.apiBaseUrl,
-    headers: {
-      ...opts.headers,
-      Authorization: config5.token ? `Bearer ${config5.token}` : void 0
+
+// src/release/release-client.ts
+var StormReleaseClient = class _StormReleaseClient extends ReleaseClient {
+  static async create(releaseConfig = {}, ignoreNxJsonConfig = false, workspaceConfig) {
+    if (!workspaceConfig) {
+      workspaceConfig = await getWorkspaceConfig();
     }
-  });
-}
-async function createGithubRelease(config5, body) {
-  return (await makeGithubRequest(config5, `/repos/${config5.repo}/releases`, {
-    method: "POST",
-    data: body
-  })).data;
-}
-async function updateGithubRelease(config5, id, body) {
-  return (await makeGithubRequest(config5, `/repos/${config5.repo}/releases/${id}`, {
-    method: "PATCH",
-    data: body
-  })).data;
-}
-function githubNewReleaseURL(config5, release) {
-  let url = `https://${config5.hostname}/${config5.repo}/releases/new?tag=${release.version}&title=${release.version}&body=${encodeURIComponent(release.body)}&target=${release.commit}`;
-  if (release.prerelease) {
-    url += "&prerelease=true";
-  }
-  return url;
-}
-async function createGithubRemoteReleaseClient(remoteName = "origin") {
-  const repoData = getGitHubRepoData(remoteName, "github");
-  if (!repoData) {
-    throw new Error(
-      `Unable to create a remote release client because the GitHub repo slug could not be determined. Please ensure you have a valid GitHub remote configured.`
-    );
-  }
-  return new GithubRemoteReleaseClient(
-    repoData,
-    {
-      provider: "github",
-      hostname: repoData.hostname,
-      apiBaseUrl: repoData.apiBaseUrl
-    },
-    await resolveTokenData(repoData.hostname)
-  );
-}
-async function isUserAnOrganizationMember(userId, config5, remoteName = "origin") {
-  try {
-    const repoData = getGitHubRepoData(remoteName, "github");
-    if (!repoData) {
-      throw new Error(
-        `Unable to validate GitHub actor because the GitHub repo slug could not be determined. Please ensure you have a valid GitHub remote configured.`
-      );
+    let projectGraph;
+    try {
+      projectGraph = readCachedProjectGraph$1();
+    } catch {
+      projectGraph = await createProjectGraphAsync$2({
+        exitOnError: true,
+        resetDaemonClient: true
+      });
     }
-    const tokenData = await resolveTokenData(repoData.hostname);
-    if (!tokenData.token) {
+    if (!projectGraph) {
       throw new Error(
-        `Unable to validate GitHub actor because no token was provided. Please set the GITHUB_TOKEN or GH_TOKEN environment variable, or ensure you have an active session via the official gh CLI tool (https://cli.github.com).`
+        "Failed to load the project graph. Please run `nx reset`, then run the `storm-git commit` command again."
       );
     }
-    const result = await makeGithubRequest(
-      {
-        repo: repoData.slug,
-        hostname: repoData.hostname,
-        apiBaseUrl: repoData.apiBaseUrl,
-        token: tokenData?.token || null
-      },
-      `/orgs/${typeof config5.organization === "string" ? config5.organization : config5.organization?.name}/members/${userId}`,
-      {}
-    );
-    if (result.status !== 204) {
-      return false;
-    }
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/release/changelog.ts
-function createAPI(overrideReleaseConfig) {
-  return async function releaseChangelog(args) {
-    const workspaceConfig = await getWorkspaceConfig();
-    const projectGraph = await createProjectGraphAsync$1({ exitOnError: true });
-    const nxJson = readNxJson$1();
-    const userProvidedReleaseConfig = deepMergeJson(
-      nxJson.release ?? {},
-      overrideReleaseConfig ?? {}
-    );
-    const { error: configError, nxReleaseConfig } = await createNxReleaseConfig(
+    return new _StormReleaseClient(
       projectGraph,
-      await createProjectFileMapUsingProjectGraph(projectGraph),
-      userProvidedReleaseConfig
+      releaseConfig,
+      ignoreNxJsonConfig,
+      workspaceConfig
     );
-    if (configError) {
-      return await handleNxReleaseConfigError(configError, false);
+  }
+  /**
+   * The release configuration used by this release client.
+   */
+  config;
+  /**
+   * The workspace configuration used by this release client.
+   */
+  workspaceConfig;
+  /**
+   * The project graph of the workspace.
+   */
+  projectGraph;
+  /**
+   * The project configurations of the workspace.
+   */
+  projectConfigurations;
+  /**
+   * The file system tree used by this release client.
+   */
+  tree;
+  /**
+   *  Creates an instance of {@link StormReleaseClient}.
+   *
+   * @param projectGraph - The project graph of the workspace.
+   * @param releaseConfig - Release configuration to use for the current release client. By default, it will be combined with any configuration in `nx.json`, but you can choose to use it as the sole source of truth by setting {@link ignoreNxJsonConfig} to true.
+   * @param ignoreNxJsonConfig - Whether to ignore the nx.json configuration and use only the provided {@link releaseConfig}. Default is false.
+   * @param workspaceConfig - Optional Storm workspace configuration object for logging purposes.
+   */
+  constructor(projectGraph, releaseConfig, ignoreNxJsonConfig, workspaceConfig) {
+    let nxJson;
+    if (!ignoreNxJsonConfig && existsSync$1(joinPaths(workspaceConfig.workspaceRoot, "nx.json"))) {
+      nxJson = readNxJson();
     }
-    if (args.printConfig) {
-      return printConfigAndExit({
-        userProvidedReleaseConfig,
-        nxReleaseConfig,
-        isDebug: args.printConfig === "debug"
-      });
-    }
-    if ((args.gitCommit === void 0 || args.gitTag === void 0 || args.stageChanges === void 0) && userProvidedReleaseConfig.git) {
-      const nxJsonMessage = await resolveNxJsonConfigErrorMessage([
-        "release",
-        "git"
-      ]);
-      output.error({
-        title: `The "release.git" property in nx.json may not be used with the "nx release changelog" subcommand or programmatic API. Instead, configure git options for subcommands directly with "release.version.git" and "release.changelog.git".`,
-        bodyLines: [nxJsonMessage]
-      });
-      process.exit(1);
-    }
-    const {
-      error: filterError,
-      filterLog,
-      releaseGroups,
-      releaseGroupToFilteredProjects
-    } = filterReleaseGroups(
-      projectGraph,
-      nxReleaseConfig,
-      args.projects,
-      args.groups
-    );
-    if (filterError) {
-      output.error(filterError);
-      process.exit(1);
-    }
-    if (filterLog && process.env.NX_RELEASE_INTERNAL_SUPPRESS_FILTER_LOG !== "true") {
-      output.note(filterLog);
-    }
-    const rawVersionPlans = await readRawVersionPlans();
-    await setResolvedVersionPlansOnGroups(
-      rawVersionPlans,
-      releaseGroups,
-      Object.keys(projectGraph.nodes),
-      !!args.verbose
+    const config5 = defu(
+      {
+        changelog: {
+          renderOptions: {
+            workspaceConfig
+          }
+        }
+      },
+      {
+        groups: getReleaseGroupConfig(releaseConfig, workspaceConfig)
+      },
+      {
+        groups: getReleaseGroupConfig(
+          nxJson.release ?? {},
+          workspaceConfig
+        )
+      },
+      omit(releaseConfig, ["groups"]),
+      nxJson.release ? omit(nxJson.release, ["groups"]) : {},
+      omit(DEFAULT_RELEASE_CONFIG, ["groups"])
     );
-    if (args.deleteVersionPlans === void 0) {
-      args.deleteVersionPlans = true;
-    }
-    const changelogGenerationEnabled = !!nxReleaseConfig?.changelog?.workspaceChangelog || nxReleaseConfig?.groups && Object.values(nxReleaseConfig?.groups).some((g) => g.changelog);
-    if (!changelogGenerationEnabled) {
-      output.warn({
-        title: `Changelogs are disabled. No changelog entries will be generated`,
-        bodyLines: [
-          `To explicitly enable changelog generation, configure "release.changelog.workspaceChangelog" or "release.changelog.projectChangelogs" in nx.json.`
-        ]
-      });
-      return {};
-    }
-    const tree = new FsTree(workspaceRoot, !!args.verbose);
-    const useAutomaticFromRef = nxReleaseConfig?.changelog?.automaticFromRef || args.firstRelease;
-    const { workspaceChangelogVersion, projectsVersionData } = resolveChangelogVersions(
-      args,
-      releaseGroups,
-      releaseGroupToFilteredProjects
+    super(config5, true);
+    writeDebug(
+      "Executing release with the following configuration",
+      workspaceConfig
     );
-    const to = args.to || "HEAD";
+    writeDebug(config5, workspaceConfig);
+    this.projectGraph = projectGraph;
+    this.config = config5;
+    this.workspaceConfig = workspaceConfig;
+    this.tree = new FsTree(workspaceConfig.workspaceRoot, false);
+    this.projectConfigurations = readProjectsConfigurationFromProjectGraph$2(projectGraph);
+  }
+  releaseChangelog = async (options) => {
+    const to = options.to || "HEAD";
     const toSHA = await getCommitHash(to);
-    const headSHA = to === "HEAD" ? toSHA : await getCommitHash("HEAD");
-    const autoCommitEnabled = args.gitCommit ?? nxReleaseConfig.changelog?.git.commit;
-    if (autoCommitEnabled && headSHA !== toSHA) {
-      throw new Error(
-        `You are attempting to recreate the changelog for an old release (Head: "${headSHA}", To: "${toSHA}", From: "${args.from}"), but you have enabled auto-commit mode. Please disable auto-commit mode by updating your nx.json, or passing --git-commit=false`
-      );
-    }
-    const commitMessage = args.gitCommitMessage || nxReleaseConfig.changelog?.git?.commitMessage;
-    const commitMessageValues = createCommitMessageValues(
-      releaseGroups,
-      releaseGroupToFilteredProjects,
-      projectsVersionData,
-      commitMessage
-    );
-    const gitTagValues = args.gitTag ?? nxReleaseConfig.changelog?.git.tag ? createGitTagValues(
-      releaseGroups,
-      releaseGroupToFilteredProjects,
-      projectsVersionData
-    ) : [];
-    handleDuplicateGitTags(gitTagValues);
     const postGitTasks = [];
-    let workspaceChangelogChanges = [];
-    let workspaceChangelogCommits = [];
-    const versionPlansEnabledForWorkspaceChangelog = releaseGroups[0]?.resolvedVersionPlans;
-    if (versionPlansEnabledForWorkspaceChangelog) {
-      if (releaseGroups.length === 1) {
-        const releaseGroup = releaseGroups[0];
-        if (releaseGroup?.projectsRelationship === "fixed") {
-          const versionPlans = releaseGroup?.resolvedVersionPlans;
-          workspaceChangelogChanges = versionPlans.flatMap((vp) => {
-            const releaseType = versionPlanSemverReleaseTypeToChangelogType(
-              vp.groupVersionBump
-            );
-            let githubReferences = [];
-            let author = void 0;
-            const parsedCommit = vp.commit ? parseGitCommit(vp.commit, true) : null;
-            if (parsedCommit) {
-              githubReferences = parsedCommit.references;
-              author = parsedCommit.author;
-            }
-            if (!author) {
-              return [];
-            }
-            const changes = !vp.triggeredByProjects ? {
-              type: releaseType.type,
-              scope: "",
-              description: vp.message,
-              body: "",
-              isBreaking: releaseType.isBreaking,
-              githubReferences,
-              // TODO(JamesHenry): Implement support for Co-authored-by and adding multiple authors
-              authors: [author],
-              affectedProjects: "*"
-            } : vp.triggeredByProjects.map((project) => {
-              return {
-                type: releaseType.type,
-                scope: project,
-                description: vp.message,
-                body: "",
-                isBreaking: releaseType.isBreaking,
-                githubReferences,
-                // TODO(JamesHenry): Implement support for Co-authored-by and adding multiple authors
-                authors: [author],
-                affectedProjects: [project]
-              };
-            });
-            return changes;
-          }).filter(Boolean);
-        }
-      }
-    } else {
-      let workspaceChangelogFromRef = args.from || (await getLatestGitTagForPattern(
-        nxReleaseConfig.releaseTagPattern,
-        {},
-        {
-          checkAllBranchesWhen: nxReleaseConfig.releaseTagPatternCheckAllBranchesWhen,
-          // preid:
-          //   workspacePreid ??
-          //   projectsPreid?.[Object.keys(projectsPreid)[0]],
-          releaseTagPatternRequireSemver: nxReleaseConfig.releaseTagPatternRequireSemver,
-          releaseTagPatternStrictPreid: nxReleaseConfig.releaseTagPatternStrictPreid
-        }
-      ))?.tag;
-      if (!workspaceChangelogFromRef) {
-        if (useAutomaticFromRef) {
-          workspaceChangelogFromRef = await getFirstGitCommit();
-          if (args.verbose) {
-            console.log(
-              `Determined workspace --from ref from the first commit in the workspace: ${workspaceChangelogFromRef}`
-            );
-          }
-        } else {
-          throw new Error(
-            `Unable to determine the previous git tag. If this is the first release of your workspace, use the --first-release option or set the "release.changelog.automaticFromRef" config property in nx.json to generate a changelog from the first commit. Otherwise, be sure to configure the "release.releaseTagPattern" property in nx.json to match the structure of your repository's git tags.`
-          );
-        }
-      }
-      const workspaceChangelogFromSHA = await getCommitHash(
-        workspaceChangelogFromRef
-      );
-      workspaceChangelogCommits = await getCommits(
-        workspaceChangelogFromSHA,
-        toSHA
-      );
-      workspaceChangelogChanges = filterHiddenChanges(
-        workspaceChangelogCommits.map((c) => {
-          return {
-            type: c.type,
-            scope: c.scope,
-            description: c.description,
-            body: c.body,
-            isBreaking: c.isBreaking,
-            githubReferences: c.references,
-            authors: [c.author],
-            shortHash: c.shortHash,
-            revertedHashes: c.revertedHashes,
-            affectedProjects: "*"
-          };
-        }),
-        nxReleaseConfig.conventionalCommits
-      );
-    }
-    const workspaceChangelog = await generateChangelogForWorkspace({
-      tree,
-      args,
-      nxReleaseConfig,
-      workspaceChangelogVersion,
-      changes: workspaceChangelogChanges,
-      // TODO: remove this after the changelog renderer is refactored to remove coupling with git commits
-      commits: filterHiddenCommits(
-        workspaceChangelogCommits,
-        nxReleaseConfig.conventionalCommits
-      )
-    });
-    if (workspaceChangelog && shouldCreateGitHubRelease(
-      nxReleaseConfig.changelog?.workspaceChangelog,
-      args.createRelease
-    )) {
-      postGitTasks.push(async (latestCommit) => {
-        const contents = formatGithubReleaseNotes(
-          workspaceChangelog.releaseVersion,
-          workspaceChangelog.contents,
-          null,
-          workspaceConfig
-        );
-        output.logSingleLine(`Creating GitHub Release 
-
-${contents}`);
-        await createOrUpdateGithubRelease(
-          nxReleaseConfig.changelog?.workspaceChangelog ? nxReleaseConfig.changelog?.workspaceChangelog.createRelease : defaultCreateReleaseProvider,
-          workspaceChangelog.releaseVersion,
-          contents,
-          latestCommit,
-          { dryRun: !!args.dryRun }
-        );
-      });
-    } else {
-      output.logSingleLine(
-        `Skipping GitHub Release for workspace changelog as it is disabled in the release group configuration`
-      );
-    }
+    let projectChangelogs = {};
+    const projectsPreid = Object.fromEntries(
+      Object.entries(options.versionData).map(([projectName, v]) => [
+        projectName,
+        v.newVersion ? extractPreid(v.newVersion) : void 0
+      ])
+    );
     const projectToAdditionalDependencyBumps = /* @__PURE__ */ new Map();
-    for (const releaseGroup of releaseGroups) {
+    for (const releaseGroup of options.releaseGraph.releaseGroups) {
       if (releaseGroup.projectsRelationship !== "independent") {
         continue;
       }
       for (const project of releaseGroup.projects) {
-        if (!projectsVersionData[project]?.newVersion) {
+        if (!options.versionData[project] || options.versionData[project].newVersion === null) {
           continue;
         }
-        const dependentProjects = (projectsVersionData[project].dependentProjects || []).map((dep) => {
+        const dependentProjects = (options.versionData[project].dependentProjects || []).map((dep) => {
           return {
             dependencyName: dep.source,
-            newVersion: projectsVersionData[dep.source]?.newVersion
+            newVersion: options.versionData[dep.source]?.newVersion ?? null
           };
         }).filter((b) => b.newVersion !== null);
         for (const dependent of dependentProjects) {
-          const additionalDependencyBumpsForProject = (projectToAdditionalDependencyBumps.has(dependent.dependencyName) ? projectToAdditionalDependencyBumps.get(dependent.dependencyName) : []) ?? [];
+          const additionalDependencyBumpsForProject = projectToAdditionalDependencyBumps.has(dependent.dependencyName) ? projectToAdditionalDependencyBumps.get(dependent.dependencyName) : [];
           additionalDependencyBumpsForProject.push({
             dependencyName: project,
-            newVersion: projectsVersionData[project].newVersion
+            newVersion: options.versionData[project].newVersion
           });
           projectToAdditionalDependencyBumps.set(
             dependent.dependencyName,
@@ -3399,218 +3372,85 @@ ${contents}`);
       }
     }
     const allProjectChangelogs = {};
-    for (const releaseGroup of releaseGroups) {
+    for (const releaseGroup of options.releaseGraph.releaseGroups) {
       const config5 = releaseGroup.changelog;
       if (config5 === false) {
         continue;
       }
-      const projects = args.projects?.length ? (
+      if (!options.releaseGraph.releaseGroupToFilteredProjects.has(releaseGroup)) {
+        throw new Error(
+          `No filtered projects found for release group ${releaseGroup.name}`
+        );
+      }
+      const projects = options.projects?.length ? (
         // If the user has passed a list of projects, we need to use the filtered list of projects within the release group, plus any dependents
-        Array.from(releaseGroupToFilteredProjects.get(releaseGroup)).flatMap(
-          (project) => {
-            return [
-              project,
-              ...projectsVersionData[project]?.dependentProjects.map(
-                (dep) => dep.source
-              ) || []
-            ];
-          }
-        )
+        Array.from(
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          options.releaseGraph.releaseGroupToFilteredProjects.get(
+            releaseGroup
+          )
+        ).flatMap((project) => {
+          return [
+            project,
+            ...options.versionData[project]?.dependentProjects.map(
+              (dep) => dep.source
+            ) || []
+          ];
+        })
       ) : (
         // Otherwise, we use the full list of projects within the release group
         releaseGroup.projects
       );
-      const projectNodes = projects.map((name) => projectGraph.nodes[name]);
+      const projectNodes = projects.map((name) => this.projectGraph.nodes[name]);
       if (releaseGroup.projectsRelationship === "independent") {
         for (const project of projectNodes) {
           let changes = null;
-          let commits = void 0;
-          if (releaseGroup.resolvedVersionPlans) {
-            changes = releaseGroup.resolvedVersionPlans.filter((vp) => vp.projectVersionBumps[project.name]).map((vp) => {
-              const bumpForProject = vp.projectVersionBumps[project.name];
-              const releaseType = versionPlanSemverReleaseTypeToChangelogType(bumpForProject);
-              let githubReferences = [];
-              let authors = [];
-              const parsedCommit = vp.commit ? parseGitCommit(vp.commit, true) : null;
-              if (parsedCommit) {
-                githubReferences = parsedCommit.references;
-                authors = [parsedCommit.author];
-              }
-              return {
-                type: releaseType.type,
-                scope: project.name,
-                description: vp.message,
-                body: "",
-                isBreaking: releaseType.isBreaking,
-                affectedProjects: Object.keys(vp.projectVersionBumps),
-                githubReferences,
-                authors
-              };
-            }).filter(Boolean);
-          } else {
-            let fromRef = args.from || (await getLatestGitTagForPattern(
-              releaseGroup.releaseTagPattern,
-              {
-                projectName: project.name,
-                releaseGroupName: releaseGroup.name
-              },
-              releaseGroup.releaseTagPatternCheckAllBranchesWhen
-            ))?.tag;
-            if (!fromRef && useAutomaticFromRef) {
-              const firstCommit = await getFirstGitCommit();
-              const allCommits = await getCommits(firstCommit, toSHA);
-              const commitsForProject = allCommits.filter(
-                (c) => c.affectedFiles.find((f) => f.startsWith(project.data.root))
-              );
-              fromRef = commitsForProject[0]?.shortHash;
-              if (args.verbose) {
-                console.log(
-                  `Determined --from ref for ${project.name} from the first commit in which it exists: ${fromRef}`
-                );
-              }
-              commits = commitsForProject;
+          let fromRef = options.from || (await getLatestGitTagForPattern(
+            releaseGroup.releaseTag.pattern,
+            {
+              projectName: project.name,
+              releaseGroupName: releaseGroup.name
+            },
+            {
+              checkAllBranchesWhen: releaseGroup.releaseTag.checkAllBranchesWhen,
+              preid: projectsPreid[project.name],
+              requireSemver: releaseGroup.releaseTag.requireSemver,
+              strictPreid: releaseGroup.releaseTag.strictPreid
             }
-            if (!fromRef && !commits) {
-              throw new Error(
-                `Unable to determine the previous git tag. If this is the first release of your workspace, use the --first-release option or set the "release.changelog.automaticFromRef" config property in nx.json to generate a changelog from the first commit. Otherwise, be sure to configure the "release.releaseTagPattern" property in nx.json to match the structure of your repository's git tags.`
-              );
-            }
-            if (!commits) {
-              commits = await getCommits(fromRef, toSHA);
-            }
-            const { fileMap } = await createFileMapUsingProjectGraph(projectGraph);
-            const fileToProjectMap = createFileToProjectMap(
-              fileMap.projectFileMap
-            );
-            changes = filterHiddenChanges(
-              commits.map((c) => ({
-                type: c.type,
-                scope: c.scope,
-                description: c.description,
-                body: c.body,
-                isBreaking: c.isBreaking,
-                githubReferences: c.references,
-                // TODO: Implement support for Co-authored-by and adding multiple authors
-                authors: [c.author],
-                shortHash: c.shortHash,
-                revertedHashes: c.revertedHashes,
-                affectedProjects: commitChangesNonProjectFiles(
-                  c,
-                  fileMap.nonProjectFiles
-                ) ? "*" : getProjectsAffectedByCommit(c, fileToProjectMap)
-              })),
-              nxReleaseConfig.conventionalCommits
-            );
-          }
-          const projectChangelogs = await generateChangelogForProjects({
-            tree,
-            args,
-            changes,
-            projectsVersionData,
-            releaseGroup,
-            projects: [project],
-            nxReleaseConfig,
-            projectToAdditionalDependencyBumps
-          });
-          for (const [projectName, projectChangelog] of Object.entries(
-            projectChangelogs
-          )) {
-            if (projectChangelogs && shouldCreateGitHubRelease(
-              releaseGroup.changelog,
-              args.createRelease
-            )) {
-              postGitTasks.push(async (latestCommit) => {
-                const contents = formatGithubReleaseNotes(
-                  projectChangelog.releaseVersion,
-                  projectChangelog.contents,
-                  projectName,
-                  workspaceConfig
-                );
-                output.logSingleLine(`Creating GitHub Release 
-
-${contents}`);
-                await createOrUpdateGithubRelease(
-                  releaseGroup.changelog ? releaseGroup.changelog.createRelease : defaultCreateReleaseProvider,
-                  projectChangelog.releaseVersion,
-                  contents,
-                  latestCommit,
-                  { dryRun: !!args.dryRun }
-                );
-              });
-            } else {
-              output.logSingleLine(
-                `Skipping GitHub Release for ${projectName} as it is disabled in the release group configuration`
+          ))?.tag;
+          let commits = void 0;
+          if (!fromRef) {
+            const firstCommit = await getFirstGitCommit();
+            commits = await filterProjectCommits({
+              fromSHA: firstCommit,
+              toSHA,
+              projectPath: project.data.root
+            });
+            fromRef = commits[0]?.shortHash;
+            if (options.verbose) {
+              console.log(
+                `Determined --from ref for ${project.name} from the first commit in which it exists: ${fromRef}`
               );
             }
-            allProjectChangelogs[projectName] = projectChangelog;
           }
-        }
-      } else {
-        let changes = [];
-        let commits = [];
-        if (releaseGroup.resolvedVersionPlans) {
-          changes = releaseGroup.resolvedVersionPlans.flatMap((vp) => {
-            const releaseType = versionPlanSemverReleaseTypeToChangelogType(
-              vp.groupVersionBump
+          if (!fromRef && !commits) {
+            throw new Error(
+              `Unable to determine the previous git tag. If this is the first release of your workspace, use the --first-release option or set the "release.changelog.automaticFromRef" config property in nx.json to generate a changelog from the first commit. Otherwise, be sure to configure the "release.releaseTag.pattern" property in nx.json to match the structure of your repository's git tags.`
             );
-            let githubReferences = [];
-            let author = void 0;
-            const parsedCommit = vp.commit ? parseGitCommit(vp.commit, true) : null;
-            if (parsedCommit) {
-              githubReferences = parsedCommit.references;
-              author = parsedCommit.author;
-            }
-            const changes2 = !vp.triggeredByProjects ? {
-              type: releaseType.type,
-              scope: "",
-              description: vp.message,
-              body: "",
-              isBreaking: releaseType.isBreaking,
-              githubReferences,
-              // TODO(JamesHenry): Implement support for Co-authored-by and adding multiple authors
-              authors: [author],
-              affectedProjects: "*"
-            } : vp.triggeredByProjects.map((project) => {
-              return {
-                type: releaseType.type,
-                scope: project,
-                description: vp.message,
-                body: "",
-                isBreaking: releaseType.isBreaking,
-                githubReferences,
-                // TODO(JamesHenry): Implement support for Co-authored-by and adding multiple authors
-                authors: [author],
-                affectedProjects: [project]
-              };
+          }
+          if (!commits) {
+            commits = await filterProjectCommits({
+              fromSHA: fromRef,
+              toSHA,
+              projectPath: project.data.root
             });
-            return changes2;
-          }).filter(Boolean);
-        } else {
-          let fromRef = args.from || (await getLatestGitTagForPattern(
-            releaseGroup.releaseTagPattern,
-            {},
-            releaseGroup.releaseTagPatternCheckAllBranchesWhen
-          ))?.tag;
-          if (!fromRef) {
-            if (useAutomaticFromRef) {
-              fromRef = await getFirstGitCommit();
-              if (args.verbose) {
-                console.log(
-                  `Determined release group --from ref from the first commit in the workspace: ${fromRef}`
-                );
-              }
-            } else {
-              throw new Error(
-                `Unable to determine the previous git tag. If this is the first release of your release group, use the --first-release option or set the "release.changelog.automaticFromRef" config property in nx.json to generate a changelog from the first commit. Otherwise, be sure to configure the "release.releaseTagPattern" property in nx.json to match the structure of your repository's git tags.`
-              );
-            }
           }
-          const fromSHA = await getCommitHash(fromRef);
-          const { fileMap } = await createFileMapUsingProjectGraph(projectGraph);
+          const { fileMap } = await createFileMapUsingProjectGraph(
+            this.projectGraph
+          );
           const fileToProjectMap = createFileToProjectMap(
             fileMap.projectFileMap
           );
-          commits = await getCommits(fromSHA, toSHA);
           changes = filterHiddenChanges(
             commits.map((c) => ({
               type: c.type,
@@ -3619,8 +3459,7 @@ ${contents}`);
               body: c.body,
               isBreaking: c.isBreaking,
               githubReferences: c.references,
-              // TODO: Implement support for Co-authored-by and adding multiple authors
-              authors: [c.author],
+              authors: c.authors,
               shortHash: c.shortHash,
               revertedHashes: c.revertedHashes,
               affectedProjects: commitChangesNonProjectFiles(
@@ -3628,623 +3467,244 @@ ${contents}`);
                 fileMap.nonProjectFiles
               ) ? "*" : getProjectsAffectedByCommit(c, fileToProjectMap)
             })),
-            nxReleaseConfig.conventionalCommits
+            this.config.conventionalCommits
           );
+          projectChangelogs = await generateChangelogForProjects({
+            tree: this.tree,
+            args: options,
+            changes,
+            projectsVersionData: options.versionData,
+            releaseGroup,
+            projects: [project],
+            releaseConfig: this.config,
+            projectToAdditionalDependencyBumps,
+            workspaceConfig: this.workspaceConfig,
+            ChangelogRendererClass: StormChangelogRenderer
+          });
+          if (projectChangelogs) {
+            for (const [projectName, projectChangelog] of Object.entries(
+              projectChangelogs
+            )) {
+              if (projectChangelog.postGitTask) {
+                postGitTasks.push(projectChangelog.postGitTask);
+              }
+              allProjectChangelogs[projectName] = projectChangelog;
+            }
+          }
+        }
+      } else {
+        let changes = [];
+        let fromRef = options.from || (await getLatestGitTagForPattern(
+          releaseGroup.releaseTag.pattern,
+          {},
+          {
+            checkAllBranchesWhen: releaseGroup.releaseTag.checkAllBranchesWhen,
+            preid: Object.keys(projectsPreid)[0] ? projectsPreid?.[Object.keys(projectsPreid)[0]] : void 0,
+            requireSemver: releaseGroup.releaseTag.requireSemver,
+            strictPreid: releaseGroup.releaseTag.strictPreid
+          }
+        ))?.tag;
+        if (!fromRef) {
+          fromRef = await getFirstGitCommit();
+          if (options.verbose) {
+            console.log(
+              `Determined release group --from ref from the first commit in the workspace: ${fromRef}`
+            );
+          }
         }
-        const projectChangelogs = await generateChangelogForProjects({
-          tree,
-          args,
+        const fromSHA = await getCommitHash(fromRef);
+        const { fileMap } = await createFileMapUsingProjectGraph(
+          this.projectGraph
+        );
+        const fileToProjectMap = createFileToProjectMap(fileMap.projectFileMap);
+        changes = filterHiddenChanges(
+          (await getCommits(fromSHA, toSHA)).map((c) => ({
+            type: c.type,
+            scope: c.scope,
+            description: c.description,
+            body: c.body,
+            isBreaking: c.isBreaking,
+            githubReferences: c.references,
+            authors: c.authors,
+            shortHash: c.shortHash,
+            revertedHashes: c.revertedHashes,
+            affectedProjects: commitChangesNonProjectFiles(
+              c,
+              fileMap.nonProjectFiles
+            ) ? "*" : getProjectsAffectedByCommit(c, fileToProjectMap)
+          })),
+          this.config.conventionalCommits
+        );
+        projectChangelogs = await generateChangelogForProjects({
+          tree: this.tree,
+          args: options,
           changes,
-          projectsVersionData,
+          projectsVersionData: options.versionData,
           releaseGroup,
           projects: projectNodes,
-          nxReleaseConfig,
-          projectToAdditionalDependencyBumps
+          releaseConfig: this.config,
+          projectToAdditionalDependencyBumps,
+          workspaceConfig: this.workspaceConfig,
+          ChangelogRendererClass: StormChangelogRenderer
         });
-        for (const [projectName, projectChangelog] of Object.entries(
-          projectChangelogs
-        )) {
-          if (projectChangelogs && shouldCreateGitHubRelease(
-            releaseGroup.changelog,
-            args.createRelease
+        if (projectChangelogs) {
+          for (const [projectName, projectChangelog] of Object.entries(
+            projectChangelogs
           )) {
-            postGitTasks.push(async (latestCommit) => {
-              output.logSingleLine(`Creating GitHub Release`);
-              await createOrUpdateGithubRelease(
-                releaseGroup.changelog ? releaseGroup.changelog.createRelease : defaultCreateReleaseProvider,
-                projectChangelog.releaseVersion,
-                projectChangelog.contents,
-                latestCommit,
-                { dryRun: !!args.dryRun }
-              );
-            });
-          } else {
-            output.logSingleLine(
-              `Skipping GitHub Release for ${projectName} as it is disabled in the release group configuration`
-            );
+            if (projectChangelog.postGitTask) {
+              postGitTasks.push(projectChangelog.postGitTask);
+            }
+            allProjectChangelogs[projectName] = projectChangelog;
           }
-          allProjectChangelogs[projectName] = projectChangelog;
         }
       }
     }
-    await applyChangesAndExit(
-      args,
-      nxReleaseConfig,
-      tree,
-      toSHA,
-      postGitTasks,
-      commitMessageValues,
-      gitTagValues,
-      releaseGroups
-    );
+    if (projectChangelogs) {
+      await Promise.all(
+        Object.entries(projectChangelogs).map(async ([project, changelog]) => {
+          if (!this.projectGraph.nodes[project]?.data.root) {
+            writeWarning(
+              `A changelog was generated for ${project}, but it could not be found in the project graph. Skipping writing changelog file.`,
+              this.workspaceConfig
+            );
+          } else if (changelog.contents) {
+            const filePath = joinPaths(
+              this.projectGraph.nodes[project].data.root,
+              "CHANGELOG.md"
+            );
+            let currentContent;
+            if (existsSync$1(filePath)) {
+              currentContent = await readFile$1(filePath, "utf8");
+            }
+            writeDebug(
+              `\u270D\uFE0F  Writing changelog for project ${project} to ${filePath}`,
+              this.workspaceConfig
+            );
+            const content = await generateChangelogContent(
+              changelog.releaseVersion,
+              filePath,
+              changelog.contents,
+              currentContent,
+              project,
+              this.workspaceConfig
+            );
+            this.tree.write(filePath, content);
+            printAndFlushChanges(
+              this.tree,
+              !!options.dryRun,
+              3,
+              false,
+              noDiffInChangelogMessage,
+              // Only print the change for the current changelog file at this point
+              (f) => f.path === filePath
+            );
+          }
+        })
+      );
+      this.applyChangesAndExit(options, postGitTasks);
+    }
     return {
-      workspaceChangelog,
+      workspaceChangelog: void 0,
       projectChangelogs: allProjectChangelogs
     };
   };
-}
-function resolveChangelogVersions(args, releaseGroups, releaseGroupToFilteredProjects) {
-  if (!args.version && !args.versionData) {
-    throw new Error(
-      `You must provide a version string and/or a versionData object.`
-    );
-  }
-  if (args.version && !valid(args.version)) {
-    throw new Error(
-      `The given version "${args.version}" is not a valid semver version. Please provide your version in the format "1.0.0", "1.0.0-beta.1" etc`
-    );
-  }
-  const versionData = releaseGroups.reduce(
-    (versionData2, releaseGroup) => {
-      const releaseGroupProjectNames = Array.from(
-        releaseGroupToFilteredProjects.get(releaseGroup)
-      );
-      for (const projectName of releaseGroupProjectNames) {
-        if (!args.versionData) {
-          versionData2[projectName] = {
-            newVersion: args.version,
-            currentVersion: "",
-            // not relevant within changelog/commit generation
-            dependentProjects: []
-            // not relevant within changelog/commit generation
-          };
-          continue;
-        }
-        if (!args.versionData[projectName]) {
-          throw new Error(
-            `The provided versionData object does not contain a version for project "${projectName}". This suggests a filtering mismatch between the version and changelog command invocations.`
-          );
-        }
+  checkChangelogFilesEnabled() {
+    if (this.config.changelog?.workspaceChangelog && (this.config.changelog?.workspaceChangelog === true || this.config.changelog?.workspaceChangelog.file)) {
+      return true;
+    }
+    for (const releaseGroup of Object.values(this.config.groups)) {
+      if (releaseGroup.changelog && releaseGroup.changelog !== true && releaseGroup.changelog.file) {
+        return true;
       }
-      return versionData2;
-    },
-    args.versionData || {}
-  );
-  return {
-    workspaceChangelogVersion: args.version,
-    projectsVersionData: versionData
-  };
-}
-async function applyChangesAndExit(args, nxReleaseConfig, tree, toSHA, postGitTasks, commitMessageValues, gitTagValues, releaseGroups) {
-  let latestCommit = toSHA;
-  const changes = tree.listChanges();
-  const changelogFilesEnabled = checkChangelogFilesEnabled(nxReleaseConfig);
-  if (changelogFilesEnabled && !changes.length) {
-    output.warn({
-      title: `No changes detected for changelogs`,
-      bodyLines: [
-        `No changes were detected for any changelog files, so no changelog entries will be generated.`
-      ]
-    });
-    if (!postGitTasks.length) {
-      return;
     }
-    if (isCI()) {
+    return false;
+  }
+  isCI = () => {
+    if (process.env.CI === "false") {
+      return false;
+    }
+    return process.env.CI || process.env.TF_BUILD === "true" || process.env.GITHUB_ACTIONS === "true" || process.env.BUILDKITE === "true" || process.env.CIRCLECI === "true" || process.env.CIRRUS_CI === "true" || process.env.TRAVIS === "true" || !!process.env["bamboo.buildKey"] || !!process.env["bamboo_buildKey"] || !!process.env.CODEBUILD_BUILD_ID || !!process.env.GITLAB_CI || !!process.env.HEROKU_TEST_RUN_ID || !!process.env.BUILD_ID || !!process.env.BUILD_NUMBER || !!process.env.BUILD_BUILDID || !!process.env.TEAMCITY_VERSION || !!process.env.JENKINS_URL || !!process.env.HUDSON_URL;
+  };
+  applyChangesAndExit = async (options, postGitTasks) => {
+    const to = options.to || "HEAD";
+    let latestCommit = await getCommitHash(to);
+    const gitTagValues = options.gitTag ?? this.config.changelog?.git?.tag ? createGitTagValues(
+      options.releaseGraph.releaseGroups,
+      options.releaseGraph.releaseGroupToFilteredProjects,
+      options.versionData
+    ) : [];
+    handleDuplicateGitTags(gitTagValues);
+    const commitMessageValues = createCommitMessageValues(
+      options.releaseGraph.releaseGroups,
+      options.releaseGraph.releaseGroupToFilteredProjects,
+      options.versionData,
+      options.gitCommitMessage || this.config.changelog?.git?.commitMessage || "release(monorepo): Publish workspace release updates"
+    );
+    const changes = this.tree.listChanges();
+    if (this.checkChangelogFilesEnabled() && !changes.length) {
       output.warn({
-        title: `Skipped GitHub release creation because no changes were detected for any changelog files.`
+        title: `No changes detected for changelogs`,
+        bodyLines: [
+          `No changes were detected for any changelog files, so no changelog entries will be generated.`
+        ]
       });
+      if (!postGitTasks.length) {
+        return;
+      }
+      for (const postGitTask of postGitTasks) {
+        await postGitTask(latestCommit);
+      }
       return;
     }
-    const shouldCreateGitHubReleaseAnyway = await promptForGitHubRelease();
-    if (!shouldCreateGitHubReleaseAnyway) {
-      return;
-    }
-    for (const postGitTask of postGitTasks) {
-      await postGitTask(latestCommit);
-    }
-    return;
-  }
-  const changedFiles = changes.map((f) => f.path);
-  let deletedFiles = [];
-  if (args.deleteVersionPlans) {
-    const planFiles = /* @__PURE__ */ new Set();
-    releaseGroups.forEach((group) => {
-      if (group.resolvedVersionPlans) {
-        group.resolvedVersionPlans.forEach((plan) => {
-          if (!args.dryRun) {
-            rmSync(plan.absolutePath, { recursive: true, force: true });
-            if (args.verbose) {
-              console.log(`Removing ${plan.relativePath}`);
-            }
-          } else {
-            if (args.verbose) {
-              console.log(
-                `Would remove ${plan.relativePath}, but --dry-run was set`
-              );
-            }
-          }
-          planFiles.add(plan.relativePath);
-        });
-      }
-    });
-    deletedFiles = Array.from(planFiles);
-  }
-  if (args.gitCommit ?? nxReleaseConfig.changelog?.git.commit) {
+    const changedFiles = changes.map((f) => f.path);
     await commitChanges({
       changedFiles,
-      deletedFiles,
-      isDryRun: !!args.dryRun,
-      isVerbose: !!args.verbose,
+      deletedFiles: [],
+      isDryRun: !!options.dryRun,
+      isVerbose: !!options.verbose,
       gitCommitMessages: commitMessageValues,
-      gitCommitArgs: args.gitCommitArgs ?? nxReleaseConfig.changelog?.git.commitArgs
+      gitCommitArgs: options.gitCommitArgs || this.config.changelog?.git?.commitArgs
     });
     latestCommit = await getCommitHash("HEAD");
-  } else if ((args.stageChanges ?? nxReleaseConfig.changelog?.git.stageChanges) && changes.length) {
-    writeDebug(`Staging changed files with git`);
-    await gitAdd({
-      changedFiles,
-      deletedFiles,
-      dryRun: args.dryRun,
-      verbose: args.verbose
-    });
-  }
-  if (args.gitTag ?? nxReleaseConfig.changelog?.git.tag) {
-    writeDebug(`Tagging commit with git`);
+    output.logSingleLine(`Tagging commit with git`);
     for (const tag of gitTagValues) {
       await gitTag({
         tag,
-        message: args.gitTagMessage || nxReleaseConfig.changelog?.git.tagMessage,
-        additionalArgs: args.gitTagArgs || nxReleaseConfig.changelog?.git.tagArgs,
-        dryRun: args.dryRun,
-        verbose: args.verbose
+        message: options.gitTagMessage || this.config.changelog?.git?.tagMessage,
+        additionalArgs: options.gitTagArgs || this.config.changelog?.git?.tagArgs,
+        dryRun: options.dryRun,
+        verbose: options.verbose
       });
     }
-  }
-  if (args.gitPush ?? nxReleaseConfig.changelog?.git.push) {
-    writeDebug(`Pushing to git remote "${args.gitRemote}"`);
-    await gitPush({
-      gitRemote: args.gitRemote,
-      dryRun: args.dryRun,
-      verbose: args.verbose
-    });
-  }
-  for (const postGitTask of postGitTasks) {
-    await postGitTask(latestCommit);
-  }
-  return;
-}
-async function generateChangelogForWorkspace({
-  tree,
-  args,
-  nxReleaseConfig,
-  workspaceChangelogVersion,
-  changes
-}) {
-  const workspaceConfig = await getWorkspaceConfig();
-  if (!workspaceConfig) {
-    throw new Error(
-      `Unable to determine the Storm workspace config. Please ensure that your storm-workspace.json file is present and valid.`
-    );
-  }
-  const config5 = nxReleaseConfig.changelog?.workspaceChangelog;
-  if (config5 === false) {
-    return;
-  }
-  if (workspaceChangelogVersion === null) {
-    return;
-  }
-  if (!config5) {
-    throw new Error(
-      `Workspace changelog is enabled but no configuration was provided. Please provide a workspaceChangelog object in your nx.json`
-    );
-  }
-  if (Object.entries(nxReleaseConfig.groups ?? {}).length > 1) {
-    output.warn({
-      title: `Workspace changelog is enabled, but you have multiple release groups configured. This is not supported, so workspace changelog will be disabled.`,
-      bodyLines: [
-        `A single workspace version cannot be determined when defining multiple release groups because versions can differ between each group.`,
-        `Project level changelogs can be enabled with the "release.changelog.projectChangelogs" property.`
-      ]
-    });
-    return;
-  }
-  if (Object.values(nxReleaseConfig.groups ?? {})[0]?.projectsRelationship === "independent") {
-    output.warn({
-      title: `Workspace changelog is enabled, but you have configured an independent projects relationship. This is not supported, so workspace changelog will be disabled.`,
-      bodyLines: [
-        `A single workspace version cannot be determined when using independent projects because versions can differ between each project.`,
-        `Project level changelogs can be enabled with the "release.changelog.projectChangelogs" property.`
-      ]
-    });
-    return;
-  }
-  const interactive = args.interactive === "all" || args.interactive === "workspace";
-  const dryRun = !!args.dryRun;
-  const gitRemote = args.gitRemote;
-  let interpolatedTreePath = config5.file || "";
-  if (interpolatedTreePath) {
-    interpolatedTreePath = interpolate(interpolatedTreePath, {
-      projectName: "",
-      // n/a for the workspace changelog
-      projectRoot: "",
-      // n/a for the workspace changelog
-      workspaceRoot: ""
-      // within the tree, workspaceRoot is the root
-    });
-  }
-  const releaseVersion = new ReleaseVersion({
-    version: workspaceChangelogVersion,
-    releaseTagPattern: nxReleaseConfig.releaseTagPattern
-  });
-  if (interpolatedTreePath) {
-    const prefix = dryRun ? "Previewing" : "Generating";
-    output.log({
-      title: `${prefix} an entry in ${interpolatedTreePath} for ${releaseVersion.gitTag}`
-    });
-  }
-  const remoteReleaseClient = await createGithubRemoteReleaseClient(gitRemote);
-  const changelogRenderer = new StormChangelogRenderer({
-    changes,
-    changelogEntryVersion: releaseVersion.rawVersion,
-    project: null,
-    isVersionPlans: false,
-    entryWhenNoChanges: config5.entryWhenNoChanges,
-    changelogRenderOptions: config5.renderOptions,
-    conventionalCommitsConfig: nxReleaseConfig.conventionalCommits,
-    remoteReleaseClient
-  });
-  let contents = await changelogRenderer.render();
-  if (interactive) {
-    const tmpDir = dirSync().name;
-    const changelogPath = joinPathFragments$1(
-      tmpDir,
-      // Include the tree path in the name so that it is easier to identify which changelog file is being edited
-      `PREVIEW__${interpolatedTreePath.replace(/\//g, "_")}`
-    );
-    writeFileSync(changelogPath, contents);
-    await launchEditor(changelogPath);
-    contents = readFileSync(changelogPath, "utf8");
-  }
-  if (interpolatedTreePath) {
-    tree.write(
-      interpolatedTreePath,
-      await generateChangelogContent(
-        releaseVersion,
-        interpolatedTreePath,
-        contents,
-        tree.exists(interpolatedTreePath) ? tree.read(interpolatedTreePath)?.toString() : "",
-        null,
-        workspaceConfig
-      )
-    );
-    printAndFlushChanges(tree, !!dryRun, 3, false, noDiffInChangelogMessage);
-  }
-  return {
-    releaseVersion,
-    contents
-  };
-}
-async function generateChangelogForProjects({
-  tree,
-  args,
-  changes,
-  projectsVersionData,
-  releaseGroup,
-  projects,
-  nxReleaseConfig,
-  projectToAdditionalDependencyBumps
-}) {
-  const workspaceConfig = await getWorkspaceConfig();
-  if (!workspaceConfig) {
-    throw new Error(
-      `Unable to determine the Storm workspace config. Please ensure that your storm-workspace.json file is present and valid.`
-    );
-  }
-  const config5 = releaseGroup.changelog;
-  if (config5 === false) {
-    return;
-  }
-  const interactive = args.interactive === "all" || args.interactive === "projects";
-  const dryRun = !!args.dryRun;
-  const gitRemote = args.gitRemote;
-  const projectChangelogs = {};
-  for (const project of projects) {
-    let interpolatedTreePath = config5.file || "";
-    if (interpolatedTreePath) {
-      interpolatedTreePath = interpolate(interpolatedTreePath, {
-        projectName: project.name,
-        projectRoot: project.data.root,
-        workspaceRoot: ""
-      });
-    }
-    const newVersion = projectsVersionData[project.name]?.newVersion;
-    if (!newVersion) {
-      continue;
-    }
-    const releaseVersion = new ReleaseVersion({
-      version: newVersion,
-      releaseTagPattern: releaseGroup.releaseTagPattern,
-      projectName: project.name
-    });
-    if (interpolatedTreePath) {
-      const prefix = dryRun ? "Previewing" : "Generating";
-      output.log({
-        title: `${prefix} an entry in ${interpolatedTreePath} for ${releaseVersion.gitTag}`
-      });
-      const remoteReleaseClient = await createGithubRemoteReleaseClient(gitRemote);
-      const changelogRenderer = new StormChangelogRenderer({
-        changes,
-        changelogEntryVersion: releaseVersion.rawVersion,
-        project: project.name,
-        entryWhenNoChanges: typeof config5.entryWhenNoChanges === "string" ? interpolate(config5.entryWhenNoChanges, {
-          projectName: project.name,
-          projectRoot: project.data.root,
-          workspaceRoot: ""
-        }) : false,
-        changelogRenderOptions: config5.renderOptions,
-        isVersionPlans: !!releaseGroup.versionPlans,
-        conventionalCommitsConfig: releaseGroup.versionPlans ? null : nxReleaseConfig.conventionalCommits,
-        dependencyBumps: projectToAdditionalDependencyBumps.get(project.name),
-        remoteReleaseClient
-      });
-      let contents = await changelogRenderer.render();
-      output.log({
-        title: `Changelog renderer for ${project.name} rendered the following content: 
-
-${contents}`.trim()
+    if (options.gitPush ?? this.config.changelog?.git?.push) {
+      output.logSingleLine(
+        `Pushing to git remote "${options.gitRemote ?? "origin"}"`
+      );
+      await gitPush({
+        gitRemote: options.gitRemote,
+        dryRun: options.dryRun,
+        verbose: options.verbose,
+        additionalArgs: options.gitPushArgs || this.config.changelog?.git?.pushArgs
       });
-      if (interactive) {
-        const tmpDir = dirSync().name;
-        const changelogPath = joinPathFragments$1(
-          tmpDir,
-          // Include the tree path in the name so that it is easier to identify which changelog file is being edited
-          `PREVIEW__${interpolatedTreePath.replace(/\//g, "_")}`
-        );
-        writeFileSync(changelogPath, contents);
-        await launchEditor(changelogPath);
-        contents = readFileSync(changelogPath, "utf8");
-      }
-      if (interpolatedTreePath) {
-        tree.write(
-          interpolatedTreePath,
-          await generateChangelogContent(
-            releaseVersion,
-            interpolatedTreePath,
-            contents,
-            tree.exists(interpolatedTreePath) ? tree.read(interpolatedTreePath)?.toString() : "",
-            project.name,
-            workspaceConfig
-          )
-        );
-        printAndFlushChanges(
-          tree,
-          !!dryRun,
-          3,
-          false,
-          noDiffInChangelogMessage,
-          // Only print the change for the current changelog file at this point
-          (f) => f.path === interpolatedTreePath
-        );
-      }
-      projectChangelogs[project.name] = {
-        releaseVersion,
-        contents
-      };
-    }
-  }
-  return projectChangelogs;
-}
-function checkChangelogFilesEnabled(nxReleaseConfig) {
-  if (nxReleaseConfig.changelog?.workspaceChangelog && nxReleaseConfig.changelog?.workspaceChangelog.file) {
-    return true;
-  }
-  return Object.values(nxReleaseConfig.groups ?? {}).some(
-    (releaseGroup) => typeof releaseGroup?.changelog === "boolean" && releaseGroup.changelog || releaseGroup?.changelog?.file
-  );
-}
-async function getCommits(fromSHA, toSHA) {
-  const rawCommits = await getGitDiff(fromSHA, toSHA);
-  return parseCommits(rawCommits);
-}
-function filterHiddenChanges(changes, conventionalCommitsConfig) {
-  return changes.filter((change) => {
-    const type = change.type;
-    const typeConfig = conventionalCommitsConfig.types[type];
-    if (!typeConfig) {
-      return false;
-    }
-    return !typeConfig.changelog.hidden;
-  });
-}
-function filterHiddenCommits(commits, conventionalCommitsConfig) {
-  if (!commits) {
-    return [];
-  }
-  return commits.filter((commit) => {
-    const type = commit.type;
-    const typeConfig = conventionalCommitsConfig.types[type];
-    if (!typeConfig) {
-      return false;
     }
-    return !typeConfig.changelog.hidden;
-  });
-}
-function shouldCreateGitHubRelease(changelogConfig, createReleaseArg = void 0) {
-  if (createReleaseArg !== void 0) {
-    return createReleaseArg === "github";
-  }
-  if (changelogConfig === false) {
-    return false;
-  }
-  return changelogConfig.createRelease !== false;
-}
-async function promptForGitHubRelease() {
-  try {
-    const result = await prompt([
-      {
-        name: "confirmation",
-        message: "Do you want to create a GitHub release anyway?",
-        type: "confirm"
-      }
-    ]);
-    return result.confirmation;
-  } catch (e) {
-    return false;
-  }
-}
-function getProjectsAffectedByCommit(commit, fileToProjectMap) {
-  const affectedProjects = /* @__PURE__ */ new Set();
-  for (const file of commit.affectedFiles) {
-    affectedProjects.add(fileToProjectMap[file]);
-  }
-  return Array.from(affectedProjects);
-}
-function commitChangesNonProjectFiles(commit, nonProjectFiles) {
-  return nonProjectFiles.some(
-    (fileData) => commit.affectedFiles.includes(fileData.file)
-  );
-}
-function createFileToProjectMap(projectFileMap) {
-  const fileToProjectMap = {};
-  for (const [projectName, projectFiles] of Object.entries(projectFileMap)) {
-    for (const file of projectFiles) {
-      fileToProjectMap[file.file] = projectName;
-    }
-  }
-  return fileToProjectMap;
-}
-function versionPlanSemverReleaseTypeToChangelogType(bump) {
-  switch (bump) {
-    case "premajor":
-    case "major":
-      return { type: "feat", isBreaking: true };
-    case "preminor":
-    case "minor":
-      return { type: "feat", isBreaking: false };
-    case "prerelease":
-    case "prepatch":
-    case "patch":
-      return { type: "fix", isBreaking: false };
-    default:
-      throw new Error(`Invalid semver bump type: ${bump}`);
-  }
-}
-function formatGithubReleaseNotes(releaseVersion, content, projectName, workspaceConfig) {
-  if (!workspaceConfig) {
-    return content;
-  }
-  return `![${(typeof workspaceConfig.release.banner === "string" ? workspaceConfig.organization ? titleCase(
-    typeof workspaceConfig.organization === "string" ? workspaceConfig.organization : workspaceConfig.organization.name
-  ) : void 0 : workspaceConfig.release.banner.alt) || "Release banner header"}](${typeof workspaceConfig.release.banner === "string" ? workspaceConfig.release.banner : workspaceConfig.release.banner?.url})
-${workspaceConfig.release.header || ""}
-
-# ${projectName ? `${titleCase(projectName)} ` : ""}v${releaseVersion.rawVersion}
-
-We at [${workspaceConfig.organization ? titleCase(
-    typeof workspaceConfig.organization === "string" ? workspaceConfig.organization : workspaceConfig.organization.name
-  ) : ""}](${workspaceConfig.homepage}) are very excited to announce the v${releaseVersion.rawVersion} release of the ${projectName ? workspaceConfig.name ? `${titleCase(workspaceConfig.name)} - ${titleCase(projectName)}` : titleCase(projectName) : workspaceConfig.name ? titleCase(workspaceConfig.name) : "Storm Software"} project! \u{1F680}
-
-These changes are released under the ${workspaceConfig.license.includes("license") ? workspaceConfig.license : `${workspaceConfig.license} license`}. You can find more details on [our licensing page](${workspaceConfig.licensing}). You can find guides, API references, and other documentation around this release (and much more) on [our documentation site](${workspaceConfig.docs}).
-
-If you have any questions or comments, feel free to reach out to the team on [Discord](${workspaceConfig.socials.discord}) or [our contact page](${workspaceConfig.contact}). Please help us spread the word by giving [this repository](https://github.com/${typeof workspaceConfig.organization === "string" ? workspaceConfig.organization : workspaceConfig.organization?.name}/${workspaceConfig.name}) a star \u2B50 on GitHub or [posting on X (Twitter)](https://x.com/intent/tweet?text=Check%20out%20the%20latest%20@${workspaceConfig.socials.twitter}%20release%20${projectName ? `${titleCase(projectName)?.replaceAll(" ", "%20")}%20` : ""}v${releaseVersion.rawVersion}%20%F0%9F%9A%80%0D%0A%0D%0Ahttps://github.com/${typeof workspaceConfig.organization === "string" ? workspaceConfig.organization : workspaceConfig.organization?.name}/${workspaceConfig.name}/releases/tag/${releaseVersion.gitTag}) about this release!
-
-## Release Notes
-
-${content.replaceAll(
-    `## ${generateChangelogTitle(
-      releaseVersion.rawVersion,
-      projectName,
-      workspaceConfig
-    )}`,
-    ""
-  ).replaceAll(
-    `# ${generateChangelogTitle(releaseVersion.rawVersion, projectName, workspaceConfig)}`,
-    ""
-  )}
-
----
-
-${workspaceConfig.release.footer}
-`;
-}
-
-// src/release/config.ts
-var DEFAULT_CONVENTIONAL_COMMITS_CONFIG2 = {
-  questions: DEFAULT_MONOREPO_COMMIT_QUESTIONS,
-  types: DEFAULT_COMMIT_TYPES
-};
-var DEFAULT_RELEASE_GROUP_CONFIG = {
-  projectsRelationship: "independent",
-  releaseTagPattern: "{projectName}@{version}",
-  changelog: {
-    git: {
-      tag: true
-    },
-    createRelease: "github",
-    entryWhenNoChanges: false,
-    file: "{projectRoot}/CHANGELOG.md",
-    renderOptions: {
-      authors: false,
-      commitReferences: true,
-      versionTitleDate: true
-    }
-  },
-  version: {
-    groupPreVersionCommand: "pnpm build",
-    useLegacyVersioning: true,
-    currentVersionResolver: "git-tag",
-    specifierSource: "conventional-commits",
-    generator: "@storm-software/workspace-tools:release-version",
-    generatorOptions: {
-      currentVersionResolver: "git-tag",
-      specifierSource: "conventional-commits"
-    }
-  }
-};
-var DEFAULT_RELEASE_CONFIG = {
-  conventionalCommits: DEFAULT_CONVENTIONAL_COMMITS_CONFIG2,
-  changelog: {
-    git: {
-      tag: true
-    },
-    automaticFromRef: true,
-    workspaceChangelog: false,
-    projectChangelogs: {
-      createRelease: "github",
-      entryWhenNoChanges: false,
-      file: "{projectRoot}/CHANGELOG.md",
-      renderOptions: {
-        authors: false,
-        commitReferences: true,
-        versionTitleDate: true
-      }
-    }
-  },
-  version: {
-    preVersionCommand: "pnpm build",
-    useLegacyVersioning: true,
-    currentVersionResolver: "git-tag",
-    specifierSource: "conventional-commits",
-    generator: "@storm-software/workspace-tools:release-version",
-    generatorOptions: {
-      currentVersionResolver: "git-tag",
-      specifierSource: "conventional-commits"
+    for (const postGitTask of postGitTasks) {
+      await postGitTask(latestCommit);
     }
-  }
+    return;
+  };
 };
 
 // src/release/run.ts
-var runRelease = async (config5, options) => {
+var runRelease = async (config5, {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  project,
+  head,
+  base,
+  dryRun = false,
+  skipPublish = false,
+  ignoreNxJsonConfig = false,
+  ...releaseConfig
+}) => {
   if (!process.env.GITHUB_ACTOR) {
     throw new Error("The `GITHUB_ACTOR` environment variable is not set.");
   }
@@ -4266,11 +3726,15 @@ var runRelease = async (config5, options) => {
   process.env.NODE_AUTH_TOKEN = process.env.NPM_TOKEN;
   process.env.NPM_AUTH_TOKEN = process.env.NPM_TOKEN;
   process.env.NPM_CONFIG_PROVENANCE = "true";
-  writeDebug("Creating workspace Project Graph data...", config5);
-  const nxJson = readNxJson();
+  writeDebug("Creating Storm release client...", config5);
+  const releaseClient = await StormReleaseClient.create(
+    releaseConfig,
+    ignoreNxJsonConfig,
+    config5
+  );
   writeDebug("Reading in the workspaces release configuration", config5);
-  const to = options.head || process.env.NX_HEAD;
-  const from = options.base || process.env.NX_BASE;
+  const to = head || process.env.NX_HEAD;
+  const from = base || process.env.NX_BASE;
   writeDebug(
     `Using the following Git SHAs to determine the release content:
  - From: ${from}
@@ -4278,50 +3742,25 @@ var runRelease = async (config5, options) => {
 `,
     config5
   );
-  if (nxJson.release?.groups) {
-    nxJson.release.groups = Object.keys(nxJson.release.groups).reduce(
-      (ret, groupName) => {
-        const groupConfig = nxJson.release?.groups?.[groupName];
-        ret[groupName] = defu(groupConfig, DEFAULT_RELEASE_GROUP_CONFIG);
-        return ret;
-      },
-      {}
-    );
-  }
-  const nxReleaseConfig = defu(
-    nxJson.release,
-    DEFAULT_RELEASE_CONFIG
-  );
-  writeInfo(
-    "Using the following `nx.json` release configuration values",
-    config5
-  );
-  writeInfo(nxReleaseConfig, config5);
-  const releaseVersion = createAPI$1(nxReleaseConfig);
-  const releaseChangelog = createAPI(nxReleaseConfig);
-  const releasePublish = createAPI$2(nxReleaseConfig);
   writeDebug("Determining the current release versions...", config5);
-  const { workspaceVersion, projectsVersionData } = await releaseVersion({
-    dryRun: false,
+  const { workspaceVersion, projectsVersionData, releaseGraph } = await releaseClient.releaseVersion({
+    dryRun,
     verbose: isVerbose(config5.logLevel),
     preid: config5.preid,
-    deleteVersionPlans: false,
     stageChanges: true,
     gitCommit: false
   });
-  await releaseChangelog({
-    ...options,
-    version: nxReleaseConfig?.projectsRelationship !== "fixed" ? void 0 : workspaceVersion,
+  await releaseClient.releaseChangelog({
+    version: releaseConfig?.projectsRelationship === "fixed" ? workspaceVersion : void 0,
     versionData: projectsVersionData,
-    dryRun: false,
+    dryRun,
     verbose: isVerbose(config5.logLevel),
     to,
     from,
-    gitCommit: true,
-    gitCommitMessage: "release(monorepo): Publish workspace release updates"
+    releaseGraph
   });
   writeDebug("Tagging commit with git", config5);
-  if (options.skipPublish) {
+  if (skipPublish) {
     writeWarning(
       "Skipping publishing packages since `skipPublish` was provided as `true` in the release options.",
       config5
@@ -4338,9 +3777,8 @@ ${changedProjects.map((changedProject) => `  - ${changedProject}`).join("\n")}
         config5
       );
       await updatePackageManifests(projectsVersionData, config5);
-      const result = await releasePublish({
-        ...options,
-        dryRun: !!options.dryRun,
+      const result = await releaseClient.releasePublish({
+        dryRun,
         verbose: isVerbose(config5.logLevel)
       });
       const failedProjects = Object.keys(result).filter(
@@ -4572,3 +4010,5 @@ void (async () => {
     process.exit(1);
   }
 })();
+//# sourceMappingURL=git.js.map
+//# sourceMappingURL=git.js.map