@storm-software/git-tools 2.111.25 → 2.111.26

package/bin/git.cjs

@@ -71861,10 +71861,7 @@ var runCommit = async (commitizenFile = "@storm-software/git-tools/commit/config
 
     `);
   await runCommitLint(config, { message: message2 });
-  const commandItems = ["git", "commit"];
-  if (!process.env.CI && !process.env.STORM_CI) {
-    commandItems.push("-S");
-  }
+  const commandItems = ["git", "commit", "-S"];
   commandItems.push(...["--file", commitMsgFile]);
   const command = (0, import_any_shell_escape.default)(commandItems);
   if (dryRun) {
@@ -77687,7 +77684,6 @@ var _launcheditor = require('nx/src/command-line/release/utils/launch-editor');
 var _printchanges = require('nx/src/command-line/release/utils/print-changes');
 var _printconfig = require('nx/src/command-line/release/utils/print-config');
 var _github = require('nx/src/command-line/release/utils/remote-release-clients/github');
-var _remotereleaseclient = require('nx/src/command-line/release/utils/remote-release-clients/remote-release-client');
 var _resolvenxjsonerrormessage = require('nx/src/command-line/release/utils/resolve-nx-json-error-message');
 
 
@@ -77695,7 +77691,6 @@ var _resolvenxjsonerrormessage = require('nx/src/command-line/release/utils/reso
 
 
 
-
 var _shared = require('nx/src/command-line/release/utils/shared');
 
 
@@ -77794,6 +77789,7 @@ function parseChangelogMarkdown(contents) {
 // src/utilities/git-utils.ts
 _chunkIG6EXAQUcjs.init_cjs_shims.call(void 0, );
 var _execcommandjs = require('nx/src/command-line/release/utils/exec-command.js');
+
 async function gitTag({
   tag,
   message: message2,
@@ -77836,6 +77832,76 @@ async function gitTag({
 ${err}`);
   }
 }
+async function gitCommit({
+  messages,
+  additionalArgs,
+  dryRun,
+  verbose,
+  logFn
+}) {
+  logFn = logFn || console.log;
+  const commandArgs = ["commit", "-S"];
+  for (const message2 of messages) {
+    commandArgs.push("--message", message2);
+  }
+  if (additionalArgs) {
+    if (Array.isArray(additionalArgs)) {
+      commandArgs.push(...additionalArgs);
+    } else {
+      commandArgs.push(...additionalArgs.split(" "));
+    }
+  }
+  if (verbose) {
+    logFn(
+      dryRun ? `Would commit all previously staged files in git with the following command, but --dry-run was set:` : `Committing files in git with the following command:`
+    );
+    logFn(`git ${commandArgs.join(" ")}`);
+  }
+  if (dryRun) {
+    return;
+  }
+  let hasStagedFiles = false;
+  try {
+    await _execcommandjs.execCommand.call(void 0, "git", ["diff-index", "--quiet", "HEAD", "--cached"]);
+  } catch (e16) {
+    hasStagedFiles = true;
+  }
+  if (!hasStagedFiles) {
+    logFn("\nNo staged files found. Skipping commit.");
+    return;
+  }
+  return _execcommandjs.execCommand.call(void 0, "git", commandArgs);
+}
+async function commitChanges({
+  changedFiles,
+  deletedFiles,
+  isDryRun,
+  isVerbose: isVerbose2,
+  gitCommitMessages,
+  gitCommitArgs,
+  logFn
+}) {
+  logFn = logFn || console.log;
+  if (!_optionalChain([changedFiles, 'optionalAccess', _189 => _189.length]) && !_optionalChain([deletedFiles, 'optionalAccess', _190 => _190.length])) {
+    throw new Error("Error: No changed files to commit");
+  }
+  logFn(`Committing changes with git`);
+  await _git.gitAdd.call(void 0, {
+    changedFiles,
+    deletedFiles,
+    dryRun: isDryRun,
+    verbose: isVerbose2
+  });
+  if (isVerbose2) {
+    console.log("");
+  }
+  await gitCommit({
+    messages: gitCommitMessages || [],
+    additionalArgs: gitCommitArgs,
+    dryRun: isDryRun,
+    verbose: isVerbose2
+  });
+}
 
 // src/release/changelog-renderer.ts
 _chunkIG6EXAQUcjs.init_cjs_shims.call(void 0, );
@@ -81239,6 +81305,195 @@ var {
 var import_semver = _chunkIG6EXAQUcjs.__toESM.call(void 0, require_semver4(), 1);
 var _changelogrenderer = require('nx/release/changelog-renderer'); var _changelogrenderer2 = _interopRequireDefault(_changelogrenderer);
 var _conventionalcommits = require('nx/src/command-line/release/config/conventional-commits');
+var StormChangelogRenderer = (_class16 = class extends _changelogrenderer2.default {
+  /**
+   * The Storm workspace configuration object, which is loaded from the storm-workspace.json file.
+   */
+  __init43() {this.workspaceConfig = null}
+  /**
+   * The configuration object for the ChangelogRenderer, which includes the changes, version, project, and other options.
+   */
+  
+  /**
+   * 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(config) {
+    super(config);_class16.prototype.__init43.call(this);;
+    this.config = {
+      ...config,
+      repoData: config.remoteReleaseClient.getRemoteRepoData()
+    };
+  }
+  async render() {
+    this.workspaceConfig = await _chunkXE275LJTcjs.getWorkspaceConfig.call(void 0, );
+    return await super.render();
+  }
+  preprocessChanges() {
+    this.relevantChanges = [...this.changes];
+    this.breakingChanges = [];
+    this.additionalChangesForAuthorsSection = [];
+    for (let i = this.relevantChanges.length - 1; i >= 0; i--) {
+      const change = this.relevantChanges[i];
+      if (change && change.type === "revert" && change.revertedHashes) {
+        for (const revertedHash of change.revertedHashes) {
+          const revertedCommitIndex = this.relevantChanges.findIndex(
+            (c) => c.shortHash && revertedHash.startsWith(c.shortHash)
+          );
+          if (revertedCommitIndex !== -1) {
+            this.relevantChanges.splice(revertedCommitIndex, 1);
+            this.relevantChanges.splice(i, 1);
+            i--;
+            break;
+          }
+        }
+      }
+    }
+    if (this.isVersionPlans) {
+      this.conventionalCommitsConfig = {
+        types: {
+          feat: _conventionalcommits.DEFAULT_CONVENTIONAL_COMMITS_CONFIG.types.feat,
+          fix: _conventionalcommits.DEFAULT_CONVENTIONAL_COMMITS_CONFIG.types.fix
+        }
+      };
+      for (let i = this.relevantChanges.length - 1; i >= 0; i--) {
+        if (_optionalChain([this, 'access', _191 => _191.relevantChanges, 'access', _192 => _192[i], 'optionalAccess', _193 => _193.isBreaking])) {
+          const change = this.relevantChanges[i];
+          if (change) {
+            this.additionalChangesForAuthorsSection.push(change);
+            const line = this.formatChange(change);
+            this.breakingChanges.push(line);
+            this.relevantChanges.splice(i, 1);
+          }
+        }
+      }
+    } else {
+      for (const change of this.relevantChanges) {
+        if (change.isBreaking) {
+          const breakingChangeExplanation = change.body ? this.extractBreakingChangeExplanation(change.body) : "";
+          this.breakingChanges.push(
+            breakingChangeExplanation ? `- ${change.scope ? `**${change.scope.trim()}:** ` : ""}${breakingChangeExplanation}` : this.formatChange(change)
+          );
+        }
+      }
+    }
+  }
+  /**
+   * Determines if the changelog entry should be rendered as empty. This is the case when there are no relevant changes, breaking changes, or dependency bumps.
+   */
+  // protected override shouldRenderEmptyEntry(): boolean {
+  //   return true;
+  // }
+  renderVersionTitle() {
+    const isMajorVersion = `${(0, import_semver.major)(this.changelogEntryVersion)}.0.0` === this.changelogEntryVersion.replace(/^v/, "");
+    return isMajorVersion ? `# ${generateChangelogTitle(this.changelogEntryVersion, this.project, this.workspaceConfig)}` : `## ${generateChangelogTitle(this.changelogEntryVersion, this.project, this.workspaceConfig)}`;
+  }
+  renderBreakingChanges() {
+    return [
+      "### Breaking Changes",
+      "",
+      ...Array.from(new Set(this.breakingChanges))
+    ];
+  }
+  renderDependencyBumps() {
+    const markdownLines = ["", "### Updated Dependencies", ""];
+    _optionalChain([this, 'access', _194 => _194.dependencyBumps, 'optionalAccess', _195 => _195.forEach, 'call', _196 => _196(({ dependencyName, newVersion }) => {
+      markdownLines.push(`- Updated ${dependencyName} to ${newVersion}`);
+    })]);
+    return markdownLines;
+  }
+  async renderAuthors() {
+    const markdownLines = [];
+    const _authors = /* @__PURE__ */ new Map();
+    for (const change of [
+      ...this.relevantChanges,
+      ...this.additionalChangesForAuthorsSection
+    ]) {
+      if (!change.authors) {
+        continue;
+      }
+      for (const author of change.authors) {
+        const name = this.formatName(author.name);
+        if (!name || name.includes("[bot]") || name === _optionalChain([this, 'access', _197 => _197.workspaceConfig, 'optionalAccess', _198 => _198.bot, 'access', _199 => _199.name])) {
+          continue;
+        }
+        if (_authors.has(name)) {
+          const entry = _authors.get(name);
+          _optionalChain([entry, 'optionalAccess', _200 => _200.email, 'access', _201 => _201.add, 'call', _202 => _202(author.email)]);
+        } else {
+          _authors.set(name, { email: /* @__PURE__ */ new Set([author.email]) });
+        }
+      }
+    }
+    if (this.config.repoData && this.changelogRenderOptions.mapAuthorsToGitHubUsernames) {
+      await Promise.all(
+        [..._authors.keys()].map(async (authorName) => {
+          const meta = _authors.get(authorName);
+          if (!meta) {
+            return;
+          }
+          for (const email of meta.email) {
+            if (email.endsWith("@users.noreply.github.com")) {
+              const match = email.match(
+                /^(\d+\+)?([^@]+)@users\.noreply\.github\.com$/
+              );
+              if (match && match[2]) {
+                meta.github = match[2];
+                break;
+              }
+            }
+            const { data } = await axios_default.get(`https://ungh.cc/users/find/${email}`).catch(() => ({ data: { user: null } }));
+            if (_optionalChain([data, 'optionalAccess', _203 => _203.user])) {
+              meta.github = data.user.username;
+              break;
+            }
+          }
+        })
+      );
+    }
+    const authors = [..._authors.entries()].map((e) => ({
+      name: e[0],
+      ...e[1]
+    }));
+    if (authors.length > 0) {
+      markdownLines.push(
+        "",
+        "### \u2764\uFE0F Thank You",
+        "",
+        ...authors.sort((a, b) => a.name.localeCompare(b.name)).map((i) => {
+          const github = i.github ? ` @${i.github}` : "";
+          return `- ${i.name}${github}`;
+        })
+      );
+    }
+    return markdownLines;
+  }
+  formatChange(change) {
+    let description = change.description || "";
+    let extraLines = [];
+    let extraLinesStr = "";
+    if (description.includes("\n")) {
+      const lines2 = description.split("\n");
+      if (lines2.length > 1) {
+        description = lines2[0];
+        extraLines = lines2.slice(1);
+      }
+      const indentation = "  ";
+      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) {
+      changeLine += this.remoteReleaseClient.formatReferences(
+        change.githubReferences
+      );
+    }
+    if (extraLinesStr) {
+      changeLine += "\n\n" + extraLinesStr;
+    }
+    return changeLine;
+  }
+}, _class16);
 
 // src/release/github.ts
 _chunkIG6EXAQUcjs.init_cjs_shims.call(void 0, );
@@ -81253,6 +81508,9 @@ var import_enquirer = _chunkIG6EXAQUcjs.__toESM.call(void 0, require_enquirer(),
 
 
 
+
+
+
 function getGitHubRepoData(remoteName = "origin", createReleaseConfig) {
   try {
     const remoteUrl = _child_process.execSync.call(void 0, `git remote get-url ${remoteName}`, {
@@ -81282,7 +81540,11 @@ function getGitHubRepoData(remoteName = "origin", createReleaseConfig) {
       );
     }
   } catch (error) {
-    return null;
+    import_devkit.output.error({
+      title: `Failed to get GitHub repo data`,
+      bodyLines: [error.message]
+    });
+    return void 0;
   }
 }
 async function createOrUpdateGithubRelease(createReleaseConfig, releaseVersion, changelogContents, latestCommit, { dryRun }) {
@@ -81296,12 +81558,12 @@ async function createOrUpdateGithubRelease(createReleaseConfig, releaseVersion,
     });
     process.exit(1);
   }
-  const token = await resolveGithubToken(githubRepoData.hostname);
+  const tokenData = await resolveTokenData(githubRepoData.hostname);
   const githubRequestConfig = {
     repo: githubRepoData.slug,
     hostname: githubRepoData.hostname,
     apiBaseUrl: githubRepoData.apiBaseUrl,
-    token
+    token: _optionalChain([tokenData, 'optionalAccess', _204 => _204.token]) || null
   };
   let existingGithubReleaseForVersion;
   try {
@@ -81310,7 +81572,7 @@ async function createOrUpdateGithubRelease(createReleaseConfig, releaseVersion,
       releaseVersion.gitTag
     );
   } catch (err) {
-    if (_optionalChain([err, 'access', _189 => _189.response, 'optionalAccess', _190 => _190.status]) === 401) {
+    if (_optionalChain([err, 'access', _205 => _205.response, 'optionalAccess', _206 => _206.status]) === 401) {
       import_devkit.output.error({
         title: `Unable to resolve data via the GitHub API. You can use any of the following options to resolve this:`,
         bodyLines: [
@@ -81320,7 +81582,7 @@ async function createOrUpdateGithubRelease(createReleaseConfig, releaseVersion,
       });
       process.exit(1);
     }
-    if (_optionalChain([err, 'access', _191 => _191.response, 'optionalAccess', _192 => _192.status]) === 404) {
+    if (_optionalChain([err, 'access', _207 => _207.response, 'optionalAccess', _208 => _208.status]) === 404) {
     } else {
       throw err;
     }
@@ -81337,7 +81599,7 @@ async function createOrUpdateGithubRelease(createReleaseConfig, releaseVersion,
   }
   console.log("");
   _printchanges.printDiff.call(void 0, 
-    _optionalChain([existingGithubReleaseForVersion, 'optionalAccess', _193 => _193.body]) ? existingGithubReleaseForVersion.body : "",
+    _optionalChain([existingGithubReleaseForVersion, 'optionalAccess', _209 => _209.body]) ? existingGithubReleaseForVersion.body : "",
     changelogContents,
     3,
     _shared.noDiffInChangelogMessage
@@ -81364,7 +81626,7 @@ async function createOrUpdateGithubReleaseInternal(githubRequestConfig, release,
   if (result2.status === "manual") {
     if (result2.error) {
       process.exitCode = 1;
-      if (_optionalChain([result2, 'access', _194 => _194.error, 'access', _195 => _195.response, 'optionalAccess', _196 => _196.data])) {
+      if (_optionalChain([result2, 'access', _210 => _210.error, 'access', _211 => _211.response, 'optionalAccess', _212 => _212.data])) {
         import_devkit.output.error({
           title: `A GitHub API Error occurred when creating/updating the release`,
           bodyLines: [
@@ -81438,7 +81700,7 @@ async function promptForContinueInGitHub() {
       }
     ]);
     return reply.open === "Yes";
-  } catch (e16) {
+  } catch (e17) {
     process.stdout.write("\x1B[?25h");
     process.exit(1);
   }
@@ -81475,13 +81737,13 @@ async function syncGithubRelease(githubRequestConfig, release, existingGithubRel
     };
   }
 }
-async function resolveGithubToken(hostname) {
-  const tokenFromEnv = process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
+async function resolveTokenData(hostname) {
+  const tokenFromEnv = process.env.STORM_BOT_GITHUB_TOKEN || process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
   if (tokenFromEnv) {
-    return tokenFromEnv;
+    return { token: tokenFromEnv, headerName: "Authorization" };
   }
-  const ghCLIPath = _chunkXE275LJTcjs.joinPaths.call(void 0, 
-    process.env.XDG_CONFIG_HOME || _chunkXE275LJTcjs.joinPaths.call(void 0, _os.homedir.call(void 0, ), ".config"),
+  const ghCLIPath = (0, import_devkit.joinPathFragments)(
+    process.env.XDG_CONFIG_HOME || (0, import_devkit.joinPathFragments)(_os.homedir.call(void 0, ), ".config"),
     "gh",
     "hosts.yml"
   );
@@ -81494,11 +81756,12 @@ async function resolveGithubToken(hostname) {
         return ghCLIConfig[hostname].oauth_token;
       }
       if (ghCLIConfig[hostname].user && ghCLIConfig[hostname].git_protocol === "ssh") {
-        return _child_process.execSync.call(void 0, `gh auth token`, {
+        const token = _child_process.execSync.call(void 0, `gh auth token`, {
           encoding: "utf8",
           stdio: "pipe",
           windowsHide: false
         }).trim();
+        return { token, headerName: "Authorization" };
       }
     }
   }
@@ -81507,7 +81770,9 @@ async function resolveGithubToken(hostname) {
       `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.`
     );
   }
-  return null;
+  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 getGithubReleaseByTag(config, tag) {
   return await makeGithubRequest(
@@ -81549,210 +81814,24 @@ function githubNewReleaseURL(config, release) {
   }
   return url2;
 }
-var providerToRefSpec = {
-  github: { "pull-request": "pull", hash: "commit", issue: "issues" }
-};
-function formatReference(ref, repoData) {
-  const refSpec = providerToRefSpec["github"];
-  return `[${ref.value}](https://${repoData.hostname}/${repoData.slug}/${refSpec[ref.type]}/${ref.value.replace(/^#/, "")})`;
-}
-function formatReferences(references, repoData) {
-  const pr = references.filter((ref) => ref.type === "pull-request");
-  const issue = references.filter((ref) => ref.type === "issue");
-  if (pr.length > 0 || issue.length > 0) {
-    return " (" + [...pr, ...issue].map((ref) => formatReference(ref, repoData)).join(", ") + ")";
-  }
-  if (references.length > 0) {
-    return " (" + formatReference(references[0], repoData) + ")";
+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 "";
+  return new (0, _github.GithubRemoteReleaseClient)(
+    repoData,
+    {
+      provider: "github",
+      hostname: repoData.hostname,
+      apiBaseUrl: repoData.apiBaseUrl
+    },
+    await resolveTokenData(repoData.hostname)
+  );
 }
 
-// src/release/changelog-renderer.ts
-var StormChangelogRenderer = (_class16 = class extends _changelogrenderer2.default {
-  /**
-   * 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(config) {
-    super(config);_class16.prototype.__init43.call(this);;
-    this.config = config;
-  }
-  /**
-   * The Storm workspace configuration object, which is loaded from the storm-workspace.json file.
-   */
-  __init43() {this.workspaceConfig = null}
-  async render() {
-    this.workspaceConfig = await _chunkXE275LJTcjs.getWorkspaceConfig.call(void 0, );
-    return await super.render();
-  }
-  preprocessChanges() {
-    this.relevantChanges = [...this.changes];
-    this.breakingChanges = [];
-    this.additionalChangesForAuthorsSection = [];
-    for (let i = this.relevantChanges.length - 1; i >= 0; i--) {
-      const change = this.relevantChanges[i];
-      if (change && change.type === "revert" && change.revertedHashes) {
-        for (const revertedHash of change.revertedHashes) {
-          const revertedCommitIndex = this.relevantChanges.findIndex(
-            (c) => c.shortHash && revertedHash.startsWith(c.shortHash)
-          );
-          if (revertedCommitIndex !== -1) {
-            this.relevantChanges.splice(revertedCommitIndex, 1);
-            this.relevantChanges.splice(i, 1);
-            i--;
-            break;
-          }
-        }
-      }
-    }
-    if (this.isVersionPlans) {
-      this.conventionalCommitsConfig = {
-        types: {
-          feat: _conventionalcommits.DEFAULT_CONVENTIONAL_COMMITS_CONFIG.types.feat,
-          fix: _conventionalcommits.DEFAULT_CONVENTIONAL_COMMITS_CONFIG.types.fix
-        }
-      };
-      for (let i = this.relevantChanges.length - 1; i >= 0; i--) {
-        if (_optionalChain([this, 'access', _197 => _197.relevantChanges, 'access', _198 => _198[i], 'optionalAccess', _199 => _199.isBreaking])) {
-          const change = this.relevantChanges[i];
-          if (change) {
-            this.additionalChangesForAuthorsSection.push(change);
-            const line = this.formatChange(change);
-            this.breakingChanges.push(line);
-            this.relevantChanges.splice(i, 1);
-          }
-        }
-      }
-    } else {
-      for (const change of this.relevantChanges) {
-        if (change.isBreaking) {
-          const breakingChangeExplanation = change.body ? this.extractBreakingChangeExplanation(change.body) : "";
-          this.breakingChanges.push(
-            breakingChangeExplanation ? `- ${change.scope ? `**${change.scope.trim()}:** ` : ""}${breakingChangeExplanation}` : this.formatChange(change)
-          );
-        }
-      }
-    }
-  }
-  /**
-   * Determines if the changelog entry should be rendered as empty. This is the case when there are no relevant changes, breaking changes, or dependency bumps.
-   */
-  // protected override shouldRenderEmptyEntry(): boolean {
-  //   return true;
-  // }
-  renderVersionTitle() {
-    const isMajorVersion = `${(0, import_semver.major)(this.changelogEntryVersion)}.0.0` === this.changelogEntryVersion.replace(/^v/, "");
-    return isMajorVersion ? `# ${generateChangelogTitle(this.changelogEntryVersion, this.project, this.workspaceConfig)}` : `## ${generateChangelogTitle(this.changelogEntryVersion, this.project, this.workspaceConfig)}`;
-  }
-  renderBreakingChanges() {
-    return [
-      "### Breaking Changes",
-      "",
-      ...Array.from(new Set(this.breakingChanges))
-    ];
-  }
-  renderDependencyBumps() {
-    const markdownLines = ["", "### Updated Dependencies", ""];
-    _optionalChain([this, 'access', _200 => _200.dependencyBumps, 'optionalAccess', _201 => _201.forEach, 'call', _202 => _202(({ dependencyName, newVersion }) => {
-      markdownLines.push(`- Updated ${dependencyName} to ${newVersion}`);
-    })]);
-    return markdownLines;
-  }
-  async renderAuthors() {
-    const markdownLines = [];
-    const _authors = /* @__PURE__ */ new Map();
-    for (const change of [
-      ...this.relevantChanges,
-      ...this.additionalChangesForAuthorsSection
-    ]) {
-      if (!change.authors) {
-        continue;
-      }
-      for (const author of change.authors) {
-        const name = this.formatName(author.name);
-        if (!name || name.includes("[bot]") || name === _optionalChain([this, 'access', _203 => _203.workspaceConfig, 'optionalAccess', _204 => _204.bot, 'access', _205 => _205.name])) {
-          continue;
-        }
-        if (_authors.has(name)) {
-          const entry = _authors.get(name);
-          _optionalChain([entry, 'optionalAccess', _206 => _206.email, 'access', _207 => _207.add, 'call', _208 => _208(author.email)]);
-        } else {
-          _authors.set(name, { email: /* @__PURE__ */ new Set([author.email]) });
-        }
-      }
-    }
-    if (this.config.repoData && this.changelogRenderOptions.mapAuthorsToGitHubUsernames) {
-      await Promise.all(
-        [..._authors.keys()].map(async (authorName) => {
-          const meta = _authors.get(authorName);
-          if (!meta) {
-            return;
-          }
-          for (const email of meta.email) {
-            if (email.endsWith("@users.noreply.github.com")) {
-              const match = email.match(
-                /^(\d+\+)?([^@]+)@users\.noreply\.github\.com$/
-              );
-              if (match && match[2]) {
-                meta.github = match[2];
-                break;
-              }
-            }
-            const { data } = await axios_default.get(`https://ungh.cc/users/find/${email}`).catch(() => ({ data: { user: null } }));
-            if (_optionalChain([data, 'optionalAccess', _209 => _209.user])) {
-              meta.github = data.user.username;
-              break;
-            }
-          }
-        })
-      );
-    }
-    const authors = [..._authors.entries()].map((e) => ({
-      name: e[0],
-      ...e[1]
-    }));
-    if (authors.length > 0) {
-      markdownLines.push(
-        "",
-        "### \u2764\uFE0F Thank You",
-        "",
-        ...authors.sort((a, b) => a.name.localeCompare(b.name)).map((i) => {
-          const github = i.github ? ` @${i.github}` : "";
-          return `- ${i.name}${github}`;
-        })
-      );
-    }
-    return markdownLines;
-  }
-  formatChange(change) {
-    let description = change.description || "";
-    let extraLines = [];
-    let extraLinesStr = "";
-    if (description.includes("\n")) {
-      const lines2 = description.split("\n");
-      if (lines2.length > 1) {
-        description = lines2[0];
-        extraLines = lines2.slice(1);
-      }
-      const indentation = "  ";
-      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 && this.changelogRenderOptions.commitReferences && change.githubReferences) {
-      changeLine += formatReferences(
-        change.githubReferences,
-        this.config.repoData
-      );
-    }
-    if (extraLinesStr) {
-      changeLine += "\n\n" + extraLinesStr;
-    }
-    return changeLine;
-  }
-}, _class16);
-
 // src/release/changelog.ts
 function createAPI(overrideReleaseConfig) {
   return async function releaseChangelog(args) {
@@ -81817,7 +81896,7 @@ function createAPI(overrideReleaseConfig) {
     if (args.deleteVersionPlans === void 0) {
       args.deleteVersionPlans = true;
     }
-    const changelogGenerationEnabled = !!_optionalChain([nxReleaseConfig, 'optionalAccess', _210 => _210.changelog, 'optionalAccess', _211 => _211.workspaceChangelog]) || _optionalChain([nxReleaseConfig, 'optionalAccess', _212 => _212.groups]) && Object.values(_optionalChain([nxReleaseConfig, 'optionalAccess', _213 => _213.groups])).some((g) => g.changelog);
+    const changelogGenerationEnabled = !!_optionalChain([nxReleaseConfig, 'optionalAccess', _213 => _213.changelog, 'optionalAccess', _214 => _214.workspaceChangelog]) || _optionalChain([nxReleaseConfig, 'optionalAccess', _215 => _215.groups]) && Object.values(_optionalChain([nxReleaseConfig, 'optionalAccess', _216 => _216.groups])).some((g) => g.changelog);
     if (!changelogGenerationEnabled) {
       _output.output.warn({
         title: `Changelogs are disabled. No changelog entries will be generated`,
@@ -81828,7 +81907,7 @@ function createAPI(overrideReleaseConfig) {
       return {};
     }
     const tree = new (0, _tree.FsTree)(_workspaceroot.workspaceRoot, !!args.verbose);
-    const useAutomaticFromRef = _optionalChain([nxReleaseConfig, 'optionalAccess', _214 => _214.changelog, 'optionalAccess', _215 => _215.automaticFromRef]) || args.firstRelease;
+    const useAutomaticFromRef = _optionalChain([nxReleaseConfig, 'optionalAccess', _217 => _217.changelog, 'optionalAccess', _218 => _218.automaticFromRef]) || args.firstRelease;
     const { workspaceChangelogVersion, projectsVersionData } = resolveChangelogVersions(
       args,
       releaseGroups,
@@ -81837,20 +81916,20 @@ function createAPI(overrideReleaseConfig) {
     const to = args.to || "HEAD";
     const toSHA = await _git.getCommitHash.call(void 0, to);
     const headSHA = to === "HEAD" ? toSHA : await _git.getCommitHash.call(void 0, "HEAD");
-    const autoCommitEnabled = _nullishCoalesce(args.gitCommit, () => ( _optionalChain([nxReleaseConfig, 'access', _216 => _216.changelog, 'optionalAccess', _217 => _217.git, 'access', _218 => _218.commit])));
+    const autoCommitEnabled = _nullishCoalesce(args.gitCommit, () => ( _optionalChain([nxReleaseConfig, 'access', _219 => _219.changelog, 'optionalAccess', _220 => _220.git, 'access', _221 => _221.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 || _optionalChain([nxReleaseConfig, 'access', _219 => _219.changelog, 'optionalAccess', _220 => _220.git, 'optionalAccess', _221 => _221.commitMessage]);
+    const commitMessage = args.gitCommitMessage || _optionalChain([nxReleaseConfig, 'access', _222 => _222.changelog, 'optionalAccess', _223 => _223.git, 'optionalAccess', _224 => _224.commitMessage]);
     const commitMessageValues = _shared.createCommitMessageValues.call(void 0, 
       releaseGroups,
       releaseGroupToFilteredProjects,
       projectsVersionData,
       commitMessage
     );
-    const gitTagValues = _nullishCoalesce(args.gitTag, () => ( _optionalChain([nxReleaseConfig, 'access', _222 => _222.changelog, 'optionalAccess', _223 => _223.git, 'access', _224 => _224.tag]))) ? _shared.createGitTagValues.call(void 0, 
+    const gitTagValues = _nullishCoalesce(args.gitTag, () => ( _optionalChain([nxReleaseConfig, 'access', _225 => _225.changelog, 'optionalAccess', _226 => _226.git, 'access', _227 => _227.tag]))) ? _shared.createGitTagValues.call(void 0, 
       releaseGroups,
       releaseGroupToFilteredProjects,
       projectsVersionData
@@ -81911,7 +81990,7 @@ function createAPI(overrideReleaseConfig) {
         nxReleaseConfig.releaseTagPattern,
         {},
         nxReleaseConfig.releaseTagPatternCheckAllBranchesWhen
-      )), 'optionalAccess', async _225 => _225.tag]);
+      )), 'optionalAccess', async _228 => _228.tag]);
       if (!workspaceChangelogFromRef) {
         if (useAutomaticFromRef) {
           workspaceChangelogFromRef = await _git.getFirstGitCommit.call(void 0, );
@@ -81965,7 +82044,7 @@ function createAPI(overrideReleaseConfig) {
       )
     });
     if (workspaceChangelog && shouldCreateGitHubRelease(
-      _optionalChain([nxReleaseConfig, 'access', _226 => _226.changelog, 'optionalAccess', _227 => _227.workspaceChangelog]),
+      _optionalChain([nxReleaseConfig, 'access', _229 => _229.changelog, 'optionalAccess', _230 => _230.workspaceChangelog]),
       args.createRelease
     )) {
       postGitTasks.push(async (latestCommit) => {
@@ -81979,7 +82058,7 @@ function createAPI(overrideReleaseConfig) {
 
 ${contents}`);
         await createOrUpdateGithubRelease(
-          _optionalChain([nxReleaseConfig, 'access', _228 => _228.changelog, 'optionalAccess', _229 => _229.workspaceChangelog]) ? _optionalChain([nxReleaseConfig, 'access', _230 => _230.changelog, 'optionalAccess', _231 => _231.workspaceChangelog, 'access', _232 => _232.createRelease]) : _github.defaultCreateReleaseProvider,
+          _optionalChain([nxReleaseConfig, 'access', _231 => _231.changelog, 'optionalAccess', _232 => _232.workspaceChangelog]) ? _optionalChain([nxReleaseConfig, 'access', _233 => _233.changelog, 'optionalAccess', _234 => _234.workspaceChangelog, 'access', _235 => _235.createRelease]) : _github.defaultCreateReleaseProvider,
           workspaceChangelog.releaseVersion,
           contents,
           latestCommit,
@@ -81997,13 +82076,13 @@ ${contents}`);
         continue;
       }
       for (const project of releaseGroup.projects) {
-        if (!_optionalChain([projectsVersionData, 'access', _233 => _233[project], 'optionalAccess', _234 => _234.newVersion])) {
+        if (!_optionalChain([projectsVersionData, 'access', _236 => _236[project], 'optionalAccess', _237 => _237.newVersion])) {
           continue;
         }
         const dependentProjects = (projectsVersionData[project].dependentProjects || []).map((dep) => {
           return {
             dependencyName: dep.source,
-            newVersion: _optionalChain([projectsVersionData, 'access', _235 => _235[dep.source], 'optionalAccess', _236 => _236.newVersion])
+            newVersion: _optionalChain([projectsVersionData, 'access', _238 => _238[dep.source], 'optionalAccess', _239 => _239.newVersion])
           };
         }).filter((b) => b.newVersion !== null);
         for (const dependent of dependentProjects) {
@@ -82025,13 +82104,13 @@ ${contents}`);
       if (config === false) {
         continue;
       }
-      const projects = _optionalChain([args, 'access', _237 => _237.projects, 'optionalAccess', _238 => _238.length]) ? (
+      const projects = _optionalChain([args, 'access', _240 => _240.projects, 'optionalAccess', _241 => _241.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,
-              ..._optionalChain([projectsVersionData, 'access', _239 => _239[project], 'optionalAccess', _240 => _240.dependentProjects, 'access', _241 => _241.map, 'call', _242 => _242(
+              ..._optionalChain([projectsVersionData, 'access', _242 => _242[project], 'optionalAccess', _243 => _243.dependentProjects, 'access', _244 => _244.map, 'call', _245 => _245(
                 (dep) => dep.source
               )]) || []
             ];
@@ -82076,14 +82155,14 @@ ${contents}`);
                 releaseGroupName: releaseGroup.name
               },
               releaseGroup.releaseTagPatternCheckAllBranchesWhen
-            )), 'optionalAccess', async _243 => _243.tag]);
+            )), 'optionalAccess', async _246 => _246.tag]);
             if (!fromRef && useAutomaticFromRef) {
               const firstCommit = await _git.getFirstGitCommit.call(void 0, );
               const allCommits = await getCommits(firstCommit, toSHA);
               const commitsForProject = allCommits.filter(
                 (c) => c.affectedFiles.find((f) => f.startsWith(project.data.root))
               );
-              fromRef = _optionalChain([commitsForProject, 'access', _244 => _244[0], 'optionalAccess', _245 => _245.shortHash]);
+              fromRef = _optionalChain([commitsForProject, 'access', _247 => _247[0], 'optionalAccess', _248 => _248.shortHash]);
               if (args.verbose) {
                 console.log(
                   `Determined --from ref for ${project.name} from the first commit in which it exists: ${fromRef}`
@@ -82111,7 +82190,7 @@ ${contents}`);
                 body: c.body,
                 isBreaking: c.isBreaking,
                 githubReferences: c.references,
-                // TODO(JamesHenry): Implement support for Co-authored-by and adding multiple authors
+                // TODO: Implement support for Co-authored-by and adding multiple authors
                 authors: [c.author],
                 shortHash: c.shortHash,
                 revertedHashes: c.revertedHashes,
@@ -82211,7 +82290,7 @@ ${contents}`);
             releaseGroup.releaseTagPattern,
             {},
             releaseGroup.releaseTagPatternCheckAllBranchesWhen
-          )), 'optionalAccess', async _246 => _246.tag]);
+          )), 'optionalAccess', async _249 => _249.tag]);
           if (!fromRef) {
             if (useAutomaticFromRef) {
               fromRef = await _git.getFirstGitCommit.call(void 0, );
@@ -82240,7 +82319,7 @@ ${contents}`);
               body: c.body,
               isBreaking: c.isBreaking,
               githubReferences: c.references,
-              // TODO(JamesHenry): Implement support for Co-authored-by and adding multiple authors
+              // TODO: Implement support for Co-authored-by and adding multiple authors
               authors: [c.author],
               shortHash: c.shortHash,
               revertedHashes: c.revertedHashes,
@@ -82400,17 +82479,17 @@ async function applyChangesAndExit(args, nxReleaseConfig, tree, toSHA, postGitTa
     });
     deletedFiles = Array.from(planFiles);
   }
-  if (_nullishCoalesce(args.gitCommit, () => ( _optionalChain([nxReleaseConfig, 'access', _247 => _247.changelog, 'optionalAccess', _248 => _248.git, 'access', _249 => _249.commit])))) {
-    await _shared.commitChanges.call(void 0, {
+  if (_nullishCoalesce(args.gitCommit, () => ( _optionalChain([nxReleaseConfig, 'access', _250 => _250.changelog, 'optionalAccess', _251 => _251.git, 'access', _252 => _252.commit])))) {
+    await commitChanges({
       changedFiles,
       deletedFiles,
       isDryRun: !!args.dryRun,
       isVerbose: !!args.verbose,
       gitCommitMessages: commitMessageValues,
-      gitCommitArgs: args.gitCommitArgs || _optionalChain([nxReleaseConfig, 'access', _250 => _250.changelog, 'optionalAccess', _251 => _251.git, 'access', _252 => _252.commitArgs])
+      gitCommitArgs: _nullishCoalesce(args.gitCommitArgs, () => ( _optionalChain([nxReleaseConfig, 'access', _253 => _253.changelog, 'optionalAccess', _254 => _254.git, 'access', _255 => _255.commitArgs])))
     });
     latestCommit = await _git.getCommitHash.call(void 0, "HEAD");
-  } else if ((_nullishCoalesce(args.stageChanges, () => ( _optionalChain([nxReleaseConfig, 'access', _253 => _253.changelog, 'optionalAccess', _254 => _254.git, 'access', _255 => _255.stageChanges])))) && changes.length) {
+  } else if ((_nullishCoalesce(args.stageChanges, () => ( _optionalChain([nxReleaseConfig, 'access', _256 => _256.changelog, 'optionalAccess', _257 => _257.git, 'access', _258 => _258.stageChanges])))) && changes.length) {
     _output.output.logSingleLine(`Staging changed files with git`);
     await _git.gitAdd.call(void 0, {
       changedFiles,
@@ -82419,25 +82498,24 @@ async function applyChangesAndExit(args, nxReleaseConfig, tree, toSHA, postGitTa
       verbose: args.verbose
     });
   }
-  if (_nullishCoalesce(args.gitTag, () => ( _optionalChain([nxReleaseConfig, 'access', _256 => _256.changelog, 'optionalAccess', _257 => _257.git, 'access', _258 => _258.tag])))) {
+  if (_nullishCoalesce(args.gitTag, () => ( _optionalChain([nxReleaseConfig, 'access', _259 => _259.changelog, 'optionalAccess', _260 => _260.git, 'access', _261 => _261.tag])))) {
     _output.output.logSingleLine(`Tagging commit with git`);
     for (const tag of gitTagValues) {
       await gitTag({
         tag,
-        message: args.gitTagMessage || _optionalChain([nxReleaseConfig, 'access', _259 => _259.changelog, 'optionalAccess', _260 => _260.git, 'access', _261 => _261.tagMessage]),
-        additionalArgs: args.gitTagArgs || _optionalChain([nxReleaseConfig, 'access', _262 => _262.changelog, 'optionalAccess', _263 => _263.git, 'access', _264 => _264.tagArgs]),
+        message: args.gitTagMessage || _optionalChain([nxReleaseConfig, 'access', _262 => _262.changelog, 'optionalAccess', _263 => _263.git, 'access', _264 => _264.tagMessage]),
+        additionalArgs: args.gitTagArgs || _optionalChain([nxReleaseConfig, 'access', _265 => _265.changelog, 'optionalAccess', _266 => _266.git, 'access', _267 => _267.tagArgs]),
         dryRun: args.dryRun,
         verbose: args.verbose
       });
     }
   }
-  if (_nullishCoalesce(args.gitPush, () => ( _optionalChain([nxReleaseConfig, 'access', _265 => _265.changelog, 'optionalAccess', _266 => _266.git, 'access', _267 => _267.push])))) {
+  if (_nullishCoalesce(args.gitPush, () => ( _optionalChain([nxReleaseConfig, 'access', _268 => _268.changelog, 'optionalAccess', _269 => _269.git, 'access', _270 => _270.push])))) {
     _output.output.logSingleLine(`Pushing to git remote "${args.gitRemote}"`);
     await _git.gitPush.call(void 0, {
       gitRemote: args.gitRemote,
       dryRun: args.dryRun,
       verbose: args.verbose
-      // additionalArgs: ["--signed=if-asked"]
     });
   }
   for (const postGitTask of postGitTasks) {
@@ -82458,7 +82536,7 @@ async function generateChangelogForWorkspace({
       `Unable to determine the Storm workspace config. Please ensure that your storm-workspace.json file is present and valid.`
     );
   }
-  const config = _optionalChain([nxReleaseConfig, 'access', _268 => _268.changelog, 'optionalAccess', _269 => _269.workspaceChangelog]);
+  const config = _optionalChain([nxReleaseConfig, 'access', _271 => _271.changelog, 'optionalAccess', _272 => _272.workspaceChangelog]);
   if (config === false) {
     return;
   }
@@ -82480,7 +82558,7 @@ async function generateChangelogForWorkspace({
     });
     return;
   }
-  if (_optionalChain([Object, 'access', _270 => _270.values, 'call', _271 => _271(_nullishCoalesce(nxReleaseConfig.groups, () => ( {}))), 'access', _272 => _272[0], 'optionalAccess', _273 => _273.projectsRelationship]) === "independent") {
+  if (_optionalChain([Object, 'access', _273 => _273.values, 'call', _274 => _274(_nullishCoalesce(nxReleaseConfig.groups, () => ( {}))), 'access', _275 => _275[0], 'optionalAccess', _276 => _276.projectsRelationship]) === "independent") {
     _output.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: [
@@ -82516,17 +82594,12 @@ async function generateChangelogForWorkspace({
       )}`
     });
   }
-  const githubRepoData = getGitHubRepoData(gitRemote, config.createRelease);
-  const remoteReleaseClient = await _remotereleaseclient.createRemoteReleaseClient.call(void 0, 
-    config.createRelease,
-    gitRemote
-  );
+  const remoteReleaseClient = await createGithubRemoteReleaseClient(gitRemote);
   const changelogRenderer = new StormChangelogRenderer({
     changes,
     changelogEntryVersion: releaseVersion.rawVersion,
     project: null,
     isVersionPlans: false,
-    repoData: githubRepoData,
     entryWhenNoChanges: config.entryWhenNoChanges,
     changelogRenderOptions: config.renderOptions,
     conventionalCommitsConfig: nxReleaseConfig.conventionalCommits,
@@ -82551,7 +82624,7 @@ async function generateChangelogForWorkspace({
         releaseVersion,
         interpolatedTreePath,
         contents,
-        tree.exists(interpolatedTreePath) ? _optionalChain([tree, 'access', _274 => _274.read, 'call', _275 => _275(interpolatedTreePath), 'optionalAccess', _276 => _276.toString, 'call', _277 => _277()]) : "",
+        tree.exists(interpolatedTreePath) ? _optionalChain([tree, 'access', _277 => _277.read, 'call', _278 => _278(interpolatedTreePath), 'optionalAccess', _279 => _279.toString, 'call', _280 => _280()]) : "",
         null,
         workspaceConfig
       )
@@ -82596,11 +82669,12 @@ async function generateChangelogForProjects({
         workspaceRoot: ""
       });
     }
-    if (!_optionalChain([projectsVersionData, 'access', _278 => _278[project.name], 'optionalAccess', _279 => _279.newVersion])) {
+    const newVersion = _optionalChain([projectsVersionData, 'access', _281 => _281[project.name], 'optionalAccess', _282 => _282.newVersion]);
+    if (!newVersion) {
       continue;
     }
     const releaseVersion = new (0, _shared.ReleaseVersion)({
-      version: projectsVersionData[project.name].newVersion,
+      version: newVersion,
       releaseTagPattern: releaseGroup.releaseTagPattern,
       projectName: project.name
     });
@@ -82611,19 +82685,11 @@ async function generateChangelogForProjects({
           releaseVersion.gitTag
         )}`
       });
-      const githubRepoData = getGitHubRepoData(
-        gitRemote,
-        config.createRelease
-      );
-      const remoteReleaseClient = await _remotereleaseclient.createRemoteReleaseClient.call(void 0, 
-        config.createRelease,
-        gitRemote
-      );
+      const remoteReleaseClient = await createGithubRemoteReleaseClient(gitRemote);
       const changelogRenderer = new StormChangelogRenderer({
         changes,
         changelogEntryVersion: releaseVersion.rawVersion,
         project: project.name,
-        repoData: githubRepoData,
         entryWhenNoChanges: typeof config.entryWhenNoChanges === "string" ? _utils.interpolate.call(void 0, config.entryWhenNoChanges, {
           projectName: project.name,
           projectRoot: project.data.root,
@@ -82659,7 +82725,7 @@ ${contents}`.trim()
             releaseVersion,
             interpolatedTreePath,
             contents,
-            tree.exists(interpolatedTreePath) ? _optionalChain([tree, 'access', _280 => _280.read, 'call', _281 => _281(interpolatedTreePath), 'optionalAccess', _282 => _282.toString, 'call', _283 => _283()]) : "",
+            tree.exists(interpolatedTreePath) ? _optionalChain([tree, 'access', _283 => _283.read, 'call', _284 => _284(interpolatedTreePath), 'optionalAccess', _285 => _285.toString, 'call', _286 => _286()]) : "",
             project.name,
             workspaceConfig
           )
@@ -82683,11 +82749,11 @@ ${contents}`.trim()
   return projectChangelogs;
 }
 function checkChangelogFilesEnabled(nxReleaseConfig) {
-  if (_optionalChain([nxReleaseConfig, 'access', _284 => _284.changelog, 'optionalAccess', _285 => _285.workspaceChangelog]) && _optionalChain([nxReleaseConfig, 'access', _286 => _286.changelog, 'optionalAccess', _287 => _287.workspaceChangelog, 'access', _288 => _288.file])) {
+  if (_optionalChain([nxReleaseConfig, 'access', _287 => _287.changelog, 'optionalAccess', _288 => _288.workspaceChangelog]) && _optionalChain([nxReleaseConfig, 'access', _289 => _289.changelog, 'optionalAccess', _290 => _290.workspaceChangelog, 'access', _291 => _291.file])) {
     return true;
   }
   return Object.values(_nullishCoalesce(nxReleaseConfig.groups, () => ( {}))).some(
-    (releaseGroup) => typeof _optionalChain([releaseGroup, 'optionalAccess', _289 => _289.changelog]) === "boolean" && releaseGroup.changelog || _optionalChain([releaseGroup, 'optionalAccess', _290 => _290.changelog, 'optionalAccess', _291 => _291.file])
+    (releaseGroup) => typeof _optionalChain([releaseGroup, 'optionalAccess', _292 => _292.changelog]) === "boolean" && releaseGroup.changelog || _optionalChain([releaseGroup, 'optionalAccess', _293 => _293.changelog, 'optionalAccess', _294 => _294.file])
   );
 }
 async function getCommits(fromSHA, toSHA) {
@@ -82781,7 +82847,7 @@ function formatGithubReleaseNotes(releaseVersion, content, projectName, workspac
   if (!workspaceConfig) {
     return content;
   }
-  return `![${_optionalChain([_titlecase.titleCase.call(void 0, workspaceConfig.organization), 'optionalAccess', _292 => _292.replaceAll, 'call', _293 => _293(" ", "-")])}](${workspaceConfig.release.banner})
+  return `![${_optionalChain([_titlecase.titleCase.call(void 0, workspaceConfig.organization), 'optionalAccess', _295 => _295.replaceAll, 'call', _296 => _296(" ", "-")])}](${workspaceConfig.release.banner})
 ${workspaceConfig.release.header || ""}
 
 # ${projectName ? `${_titlecase.titleCase.call(void 0, projectName)} ` : ""}v${releaseVersion.rawVersion}
@@ -82790,7 +82856,7 @@ We at [${_titlecase.titleCase.call(void 0, workspaceConfig.organization)}](${wor
 
 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.account.discord}) or [our contact page](${workspaceConfig.contact}). Please help us spread the word by giving [this repository](https://github.com/${workspaceConfig.organization}/${workspaceConfig.name}) a star \u2B50 on GitHub or [posting on X (Twitter)](https://x.com/intent/tweet?text=Check%20out%20the%20latest%20@${workspaceConfig.account.twitter}%20release%20${projectName ? `${_optionalChain([_titlecase.titleCase.call(void 0, projectName), 'optionalAccess', _294 => _294.replaceAll, 'call', _295 => _295(" ", "%20")])}%20` : ""}v${releaseVersion.rawVersion}%20%F0%9F%9A%80%0D%0A%0D%0Ahttps://github.com/${workspaceConfig.organization}/${workspaceConfig.name}/releases/tag/${releaseVersion.gitTag}) about this release!
+If you have any questions or comments, feel free to reach out to the team on [Discord](${workspaceConfig.account.discord}) or [our contact page](${workspaceConfig.contact}). Please help us spread the word by giving [this repository](https://github.com/${workspaceConfig.organization}/${workspaceConfig.name}) a star \u2B50 on GitHub or [posting on X (Twitter)](https://x.com/intent/tweet?text=Check%20out%20the%20latest%20@${workspaceConfig.account.twitter}%20release%20${projectName ? `${_optionalChain([_titlecase.titleCase.call(void 0, projectName), 'optionalAccess', _297 => _297.replaceAll, 'call', _298 => _298(" ", "%20")])}%20` : ""}v${releaseVersion.rawVersion}%20%F0%9F%9A%80%0D%0A%0D%0Ahttps://github.com/${workspaceConfig.organization}/${workspaceConfig.name}/releases/tag/${releaseVersion.gitTag}) about this release!
 
 ## Release Notes
 
@@ -82871,10 +82937,12 @@ var DEFAULT_RELEASE_CONFIG = {
 
 // src/release/run.ts
 var runRelease = async (config, options) => {
-  process.env.GIT_AUTHOR_NAME = process.env.GITHUB_ACTOR;
-  process.env.GIT_AUTHOR_EMAIL = `${process.env.GITHUB_ACTOR}@users.noreply.github.com`;
-  process.env.GIT_COMMITTER_NAME = config.bot.name;
-  process.env.GIT_COMMITTER_EMAIL = config.bot.email || config.bot.name ? `${config.bot.name}@users.noreply.github.com` : "bot@stormsoftware.com";
+  const name = config.bot.name;
+  const email = config.bot.email ? config.bot.email : config.bot.name ? `${config.bot.name}@users.noreply.github.com` : "bot@stormsoftware.com";
+  process.env.GIT_AUTHOR_NAME = name;
+  process.env.GIT_AUTHOR_EMAIL = email;
+  process.env.GIT_COMMITTER_NAME = name;
+  process.env.GIT_COMMITTER_EMAIL = email;
   process.env.NODE_AUTH_TOKEN = process.env.NPM_TOKEN;
   process.env.NPM_AUTH_TOKEN = process.env.NPM_TOKEN;
   process.env.NPM_CONFIG_PROVENANCE = "true";
@@ -82890,10 +82958,10 @@ var runRelease = async (config, options) => {
 `,
     config
   );
-  if (_optionalChain([nxJson, 'access', _296 => _296.release, 'optionalAccess', _297 => _297.groups])) {
+  if (_optionalChain([nxJson, 'access', _299 => _299.release, 'optionalAccess', _300 => _300.groups])) {
     nxJson.release.groups = Object.keys(nxJson.release.groups).reduce(
       (ret, groupName) => {
-        const groupConfig = _optionalChain([nxJson, 'access', _298 => _298.release, 'optionalAccess', _299 => _299.groups, 'optionalAccess', _300 => _300[groupName]]);
+        const groupConfig = _optionalChain([nxJson, 'access', _301 => _301.release, 'optionalAccess', _302 => _302.groups, 'optionalAccess', _303 => _303[groupName]]);
         ret[groupName] = _chunkFMYKTN2Zcjs.defu.call(void 0, groupConfig, DEFAULT_RELEASE_GROUP_CONFIG);
         return ret;
       },
@@ -82923,7 +82991,7 @@ var runRelease = async (config, options) => {
   });
   await releaseChangelog({
     ...options,
-    version: _optionalChain([nxReleaseConfig, 'optionalAccess', _301 => _301.projectsRelationship]) !== "fixed" ? void 0 : workspaceVersion,
+    version: _optionalChain([nxReleaseConfig, 'optionalAccess', _304 => _304.projectsRelationship]) !== "fixed" ? void 0 : workspaceVersion,
     versionData: projectsVersionData,
     dryRun: false,
     verbose: _chunkXE275LJTcjs.isVerbose.call(void 0, config.logLevel),
@@ -82940,7 +83008,7 @@ var runRelease = async (config, options) => {
     );
   } else {
     const changedProjects = Object.keys(projectsVersionData).filter(
-      (key) => _optionalChain([projectsVersionData, 'access', _302 => _302[key], 'optionalAccess', _303 => _303.newVersion])
+      (key) => _optionalChain([projectsVersionData, 'access', _305 => _305[key], 'optionalAccess', _306 => _306.newVersion])
     );
     if (changedProjects.length > 0) {
       _chunkXE275LJTcjs.writeInfo.call(void 0, 
@@ -82956,14 +83024,14 @@ ${changedProjects.map((changedProject) => `  - ${changedProject}`).join("\n")}
         verbose: _chunkXE275LJTcjs.isVerbose.call(void 0, config.logLevel)
       });
       const failedProjects = Object.keys(result2).filter(
-        (key) => _optionalChain([result2, 'access', _304 => _304[key], 'optionalAccess', _305 => _305.code]) && _optionalChain([result2, 'access', _306 => _306[key], 'optionalAccess', _307 => _307.code]) > 0
+        (key) => _optionalChain([result2, 'access', _307 => _307[key], 'optionalAccess', _308 => _308.code]) && _optionalChain([result2, 'access', _309 => _309[key], 'optionalAccess', _310 => _310.code]) > 0
       );
       if (failedProjects.length > 0) {
         throw new Error(
           `The Storm release process was not completed successfully! One or more errors occured while running the \`nx-release-publish\` executor tasks.
 
 Please review the workflow details for the following project(s):
-${failedProjects.map((failedProject) => `  - ${failedProject} (Error Code: ${_optionalChain([result2, 'access', _308 => _308[failedProject], 'optionalAccess', _309 => _309.code])})`).join("\n")}
+${failedProjects.map((failedProject) => `  - ${failedProject} (Error Code: ${_optionalChain([result2, 'access', _311 => _311[failedProject], 'optionalAccess', _312 => _312.code])})`).join("\n")}
 `
         );
       }
@@ -82977,7 +83045,7 @@ async function updatePackageManifests(projectsVersionData, config) {
   let projectGraph;
   try {
     projectGraph = (0, import_devkit2.readCachedProjectGraph)();
-  } catch (e17) {
+  } catch (e18) {
     await (0, import_devkit2.createProjectGraphAsync)();
     projectGraph = (0, import_devkit2.readCachedProjectGraph)();
   }
@@ -82985,7 +83053,7 @@ async function updatePackageManifests(projectsVersionData, config) {
     await Promise.all(
       Object.keys(projectsVersionData).map(async (node) => {
         const projectNode = projectGraph.nodes[node];
-        if (!_optionalChain([projectNode, 'optionalAccess', _310 => _310.data, 'access', _311 => _311.root])) {
+        if (!_optionalChain([projectNode, 'optionalAccess', _313 => _313.data, 'access', _314 => _314.root])) {
           _chunkXE275LJTcjs.writeWarning.call(void 0, 
             `Project node ${node} not found in the project graph. Skipping manifest update.`,
             config
@@ -82993,7 +83061,7 @@ async function updatePackageManifests(projectsVersionData, config) {
           return;
         }
         const versionData = projectsVersionData[node];
-        if (_optionalChain([projectNode, 'optionalAccess', _312 => _312.data, 'access', _313 => _313.root]) && versionData && versionData.newVersion !== null) {
+        if (_optionalChain([projectNode, 'optionalAccess', _315 => _315.data, 'access', _316 => _316.root]) && versionData && versionData.newVersion !== null) {
           _chunkXE275LJTcjs.writeTrace.call(void 0, 
             `Writing version ${versionData.newVersion} update to manifest file for ${node}
         `,