@storm-software/git-tools 2.97.2 → 2.99.0

package/bin/git.cjs

@@ -21,7 +21,7 @@ var _chunkFNIN2HF7cjs = require('./chunk-FNIN2HF7.cjs');
 
 
 
-var _chunkLFH4CIZMcjs = require('./chunk-LFH4CIZM.cjs');
+var _chunkSBZRK235cjs = require('./chunk-SBZRK235.cjs');
 
 
 var _chunkP2CHIYIKcjs = require('./chunk-P2CHIYIK.cjs');
@@ -3264,7 +3264,7 @@ var require_wrap_ansi = _chunkKK4YC43Scjs.__commonJS.call(void 0, {
     _chunkKK4YC43Scjs.init_cjs_shims.call(void 0, );
     var stringWidth = require_string_width();
     var stripAnsi2 = require_strip_ansi();
-    var ansiStyles2 = _chunkLFH4CIZMcjs.require_ansi_styles.call(void 0, );
+    var ansiStyles2 = _chunkSBZRK235cjs.require_ansi_styles.call(void 0, );
     var ESCAPES2 = /* @__PURE__ */ new Set([
       "\x1B",
       "\x9B"
@@ -15606,7 +15606,7 @@ var require_node = _chunkKK4YC43Scjs.__commonJS.call(void 0, {
       1
     ];
     try {
-      const supportsColor2 = _chunkLFH4CIZMcjs.require_supports_color.call(void 0, );
+      const supportsColor2 = _chunkSBZRK235cjs.require_supports_color.call(void 0, );
       if (supportsColor2 && (supportsColor2.stderr || supportsColor2).level >= 2) {
         exports.colors = [
           20,
@@ -67098,12 +67098,12 @@ var getRuleFromScopeEnum = /* @__PURE__ */ _chunkKK4YC43Scjs.__name.call(void 0,
 // src/commitlint/run.ts
 var COMMIT_EDITMSG_PATH = ".git/COMMIT_EDITMSG";
 var runCommitLint = /* @__PURE__ */ _chunkKK4YC43Scjs.__name.call(void 0, async (config, params) => {
-  _chunkLFH4CIZMcjs.writeInfo.call(void 0, "\u{1F4DD} Validating git commit message aligns with the Storm Software specification", config);
+  _chunkSBZRK235cjs.writeInfo.call(void 0, "\u{1F4DD} Validating git commit message aligns with the Storm Software specification", config);
   let commitMessage;
   if (params.message && params.message !== COMMIT_EDITMSG_PATH) {
     commitMessage = params.message;
   } else {
-    const commitFile = _chunkLFH4CIZMcjs.joinPaths.call(void 0, config.workspaceRoot, params.file || params.message || COMMIT_EDITMSG_PATH);
+    const commitFile = _chunkSBZRK235cjs.joinPaths.call(void 0, config.workspaceRoot, params.file || params.message || COMMIT_EDITMSG_PATH);
     if (_fs.existsSync.call(void 0, commitFile)) {
       commitMessage = await _asyncOptionalChain([(await _promises.readFile.call(void 0, commitFile, "utf8")), 'optionalAccess', async _81 => _81.trim, 'call', async _82 => _82()]);
     }
@@ -67115,19 +67115,19 @@ var runCommitLint = /* @__PURE__ */ _chunkKK4YC43Scjs.__name.call(void 0, async
     if (upstreamRemote) {
       const upstreamRemoteIdentifier = _optionalChain([upstreamRemote, 'access', _83 => _83.split, 'call', _84 => _84("	"), 'access', _85 => _85[0], 'optionalAccess', _86 => _86.trim, 'call', _87 => _87()]);
       if (!upstreamRemoteIdentifier) {
-        _chunkLFH4CIZMcjs.writeWarning.call(void 0, `No upstream remote found for ${config.name}.git. Skipping comparison.`, config);
+        _chunkSBZRK235cjs.writeWarning.call(void 0, `No upstream remote found for ${config.name}.git. Skipping comparison.`, config);
         return;
       }
-      _chunkLFH4CIZMcjs.writeDebug.call(void 0, `Comparing against remote ${upstreamRemoteIdentifier}`);
+      _chunkSBZRK235cjs.writeDebug.call(void 0, `Comparing against remote ${upstreamRemoteIdentifier}`);
       const currentBranch = _child_process2.default.execSync("git branch --show-current").toString().trim();
       gitLogCmd = gitLogCmd + ` ${currentBranch} ^${upstreamRemoteIdentifier}/main`;
     } else {
-      _chunkLFH4CIZMcjs.writeWarning.call(void 0, `No upstream remote found for ${config.name}.git. Skipping comparison against upstream main.`, config);
+      _chunkSBZRK235cjs.writeWarning.call(void 0, `No upstream remote found for ${config.name}.git. Skipping comparison against upstream main.`, config);
       return;
     }
     commitMessage = _child_process2.default.execSync(gitLogCmd).toString().trim();
     if (!commitMessage) {
-      _chunkLFH4CIZMcjs.writeWarning.call(void 0, "No commits found. Skipping commit message validation.", config);
+      _chunkSBZRK235cjs.writeWarning.call(void 0, "No commits found. Skipping commit message validation.", config);
       return;
     }
   }
@@ -67145,7 +67145,7 @@ var runCommitLint = /* @__PURE__ */ _chunkKK4YC43Scjs.__name.call(void 0, async
     helpUrl: commitlintConfig.helpUrl
   });
   if (!matchCommit || report.errors.length || report.warnings.length) {
-    _chunkLFH4CIZMcjs.writeSuccess.call(void 0, `Commit was processing completed successfully!`, config);
+    _chunkSBZRK235cjs.writeSuccess.call(void 0, `Commit was processing completed successfully!`, config);
   } else {
     let errorMessage = " Oh no! Your commit message: \n-------------------------------------------------------------------\n" + commitMessage + "\n-------------------------------------------------------------------\n\n Does not follow the commit message convention specified by Storm Software.";
     errorMessage += "\ntype(scope): subject \n BLANK LINE \n body";
@@ -68339,7 +68339,7 @@ var createState = /* @__PURE__ */ _chunkKK4YC43Scjs.__name.call(void 0, async (c
       answers: {}
     };
   } else {
-    _chunkLFH4CIZMcjs.writeInfo.call(void 0, `Using custom commit config file: ${commitizenFile}`, config);
+    _chunkSBZRK235cjs.writeInfo.call(void 0, `Using custom commit config file: ${commitizenFile}`, config);
     let commitizenConfig = await Promise.resolve().then(() => _interopRequireWildcard(require(commitizenFile)));
     if (_optionalChain([commitizenConfig, 'optionalAccess', _93 => _93.default])) {
       commitizenConfig = _optionalChain([commitizenConfig, 'optionalAccess', _94 => _94.default]);
@@ -68380,7 +68380,7 @@ var createState = /* @__PURE__ */ _chunkKK4YC43Scjs.__name.call(void 0, async (c
         }
         if (project) {
           let description = `${project.name} - ${project.root}`;
-          const packageJsonPath = _chunkLFH4CIZMcjs.joinPaths.call(void 0, project.root, "package.json");
+          const packageJsonPath = _chunkSBZRK235cjs.joinPaths.call(void 0, project.root, "package.json");
           if (await hfs.isFile(packageJsonPath)) {
             const packageJson = await hfs.json(packageJsonPath);
             description = packageJson.description || description;
@@ -68454,10 +68454,10 @@ ${closedIssueEmoji}${config.prompt.settings.closedIssueMessage}${issues}`;
 
 // src/commit/run.ts
 var runCommit = /* @__PURE__ */ _chunkKK4YC43Scjs.__name.call(void 0, async (commitizenFile = "@storm-software/git-tools/commit/config", dryRun = false) => {
-  const config = await _chunkLFH4CIZMcjs.getConfig.call(void 0, );
+  const config = await _chunkSBZRK235cjs.getConfig.call(void 0, );
   const state = await createState(config, commitizenFile);
   if (dryRun) {
-    _chunkLFH4CIZMcjs.writeInfo.call(void 0, "Running in dry mode.", config);
+    _chunkSBZRK235cjs.writeInfo.call(void 0, "Running in dry mode.", config);
   }
   console.log(chalk_template_default`
 {bold.#999999 ----------------------------------------}
@@ -68467,7 +68467,7 @@ var runCommit = /* @__PURE__ */ _chunkKK4YC43Scjs.__name.call(void 0, async (com
 `);
   state.answers = await askQuestions(state);
   const message2 = formatCommitMessage(state);
-  const commitMsgFile = _chunkLFH4CIZMcjs.joinPaths.call(void 0, getGitDir(), "COMMIT_EDITMSG");
+  const commitMsgFile = _chunkSBZRK235cjs.joinPaths.call(void 0, getGitDir(), "COMMIT_EDITMSG");
   console.log(chalk_template_default`
 {bold.#999999 ----------------------------------------}
 
@@ -68491,8 +68491,8 @@ var runCommit = /* @__PURE__ */ _chunkKK4YC43Scjs.__name.call(void 0, async (com
   ]);
   const command = (0, import_any_shell_escape.default)(commandItems);
   if (dryRun) {
-    _chunkLFH4CIZMcjs.writeDebug.call(void 0, `Skipping execution [dry-run]: ${command.replace(commitMsgFile, ".git/COMMIT_EDITMSG")}`, config);
-    _chunkLFH4CIZMcjs.writeDebug.call(void 0, `Message [dry-run]: ${message2}`, config);
+    _chunkSBZRK235cjs.writeDebug.call(void 0, `Skipping execution [dry-run]: ${command.replace(commitMsgFile, ".git/COMMIT_EDITMSG")}`, config);
+    _chunkSBZRK235cjs.writeDebug.call(void 0, `Message [dry-run]: ${message2}`, config);
   } else {
     await _promises2.default.writeFile(commitMsgFile, message2);
     _chunkFNIN2HF7cjs.run.call(void 0, config, command);
@@ -80885,7 +80885,7 @@ var _nxjsonjs = require('nx/src/config/nx-json.js');
 
 // src/release/changelog.ts
 _chunkKK4YC43Scjs.init_cjs_shims.call(void 0, );
-var chalk2 = _chunkKK4YC43Scjs.__toESM.call(void 0, _chunkLFH4CIZMcjs.require_source.call(void 0, ), 1);
+var chalk2 = _chunkKK4YC43Scjs.__toESM.call(void 0, _chunkSBZRK235cjs.require_source.call(void 0, ), 1);
 var import_enquirer = _chunkKK4YC43Scjs.__toESM.call(void 0, require_enquirer(), 1);
 var import_semver2 = _chunkKK4YC43Scjs.__toESM.call(void 0, require_semver2(), 1);
 var import_tmp = _chunkKK4YC43Scjs.__toESM.call(void 0, require_tmp2(), 1);
@@ -80928,7 +80928,7 @@ async function generateChangelogContent(releaseVersion2, filepath, newContent, c
   const changelogReleases = parseChangelogMarkdown(changelogContents).releases;
   const existingVersionToUpdate = changelogReleases.find((r) => r.version === releaseVersion2.rawVersion);
   if (existingVersionToUpdate) {
-    changelogContents = changelogContents.replace(`## ${generateChangelogTitle(releaseVersion2.rawVersion, project, false, workspaceConfig)}
+    changelogContents = changelogContents.replace(`## ${generateChangelogTitle(releaseVersion2.rawVersion, project, workspaceConfig)}
 
 
 ${existingVersionToUpdate.body}`, newContent);
@@ -80951,16 +80951,11 @@ var titleCase = /* @__PURE__ */ _chunkKK4YC43Scjs.__name.call(void 0, (input) =>
   }
   return input.split(/(?=[A-Z])|[\.\-\s_]/).map((s) => s.trim()).filter((s) => !!s).map((s) => s ? s.toLowerCase().charAt(0).toUpperCase() + s.toLowerCase().slice(1) : s).join(" ");
 }, "titleCase");
-function generateChangelogTitle(version, project, excludeDate = false, workspaceConfig) {
-  if (!_optionalChain([workspaceConfig, 'optionalAccess', _185 => _185.repository]) || !project) {
+function generateChangelogTitle(version, project, workspaceConfig) {
+  if (!_optionalChain([workspaceConfig, 'optionalAccess', _185 => _185.name]) || !project) {
     return version;
   }
-  let maybeDateStr = "";
-  if (excludeDate !== false) {
-    const dateStr = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    maybeDateStr = ` (${dateStr})`;
-  }
-  return `[${version}](${workspaceConfig.repository}/releases/tag/${project}%40${version})${maybeDateStr}`;
+  return `[${version}](https://github.com/${workspaceConfig.organization}/${workspaceConfig.name}/releases/tag/${project}%40${version}) (${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)})`;
 }
 _chunkKK4YC43Scjs.__name.call(void 0, generateChangelogTitle, "generateChangelogTitle");
 function parseChangelogMarkdown(contents) {
@@ -80971,7 +80966,7 @@ function parseChangelogMarkdown(contents) {
   const releases = [];
   for (let i = 0; i < headings.length; i++) {
     const heading = headings[i];
-    if (!heading || heading.length < 2) {
+    if (!heading) {
       continue;
     }
     const nextHeading = headings[i + 1];
@@ -84460,8 +84455,8 @@ var StormChangelogRenderer = (_class13 = class extends _changelogrenderer2.defau
     super(config);_class13.prototype.__init27.call(this);;
   }
   async render() {
-    this.workspaceConfig = await _chunkLFH4CIZMcjs.getWorkspaceConfig.call(void 0, );
-    return super.render();
+    this.workspaceConfig = await _chunkSBZRK235cjs.getWorkspaceConfig.call(void 0, );
+    return await super.render();
   }
   preprocessChanges() {
     this.relevantChanges = [
@@ -84511,23 +84506,20 @@ var StormChangelogRenderer = (_class13 = class extends _changelogrenderer2.defau
     }
   }
   /**
-  * 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.
+  * 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.
   */
-  shouldRenderEmptyEntry() {
-    return true;
-  }
+  // 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, false, this.workspaceConfig)}` : `## ${generateChangelogTitle(this.changelogEntryVersion, this.project, false, this.workspaceConfig)}`;
+    return isMajorVersion ? `# ${generateChangelogTitle(this.changelogEntryVersion, this.project, this.workspaceConfig)}` : `## ${generateChangelogTitle(this.changelogEntryVersion, this.project, this.workspaceConfig)}`;
   }
   renderBreakingChanges() {
-    const uniqueBreakingChanges = Array.from(new Set(this.breakingChanges));
     return [
       "### Breaking Changes",
       "",
-      ...uniqueBreakingChanges
+      ...Array.from(new Set(this.breakingChanges))
     ];
   }
   renderDependencyBumps() {
@@ -84637,7 +84629,7 @@ var StormChangelogRenderer = (_class13 = class extends _changelogrenderer2.defau
 // src/release/changelog.ts
 function createAPI(overrideReleaseConfig) {
   return /* @__PURE__ */ _chunkKK4YC43Scjs.__name.call(void 0, async function releaseChangelog(args) {
-    const workspaceConfig = await _chunkLFH4CIZMcjs.getWorkspaceConfig.call(void 0, );
+    const workspaceConfig = await _chunkSBZRK235cjs.getWorkspaceConfig.call(void 0, );
     const projectGraph = await _projectgraph.createProjectGraphAsync.call(void 0, {
       exitOnError: true
     });
@@ -84801,11 +84793,16 @@ function createAPI(overrideReleaseConfig) {
     });
     if (workspaceChangelog && shouldCreateGitHubRelease(nxReleaseConfig.changelog.workspaceChangelog, args.createRelease)) {
       postGitTasks.push(async (latestCommit) => {
-        _output.output.logSingleLine(`Creating GitHub Release`);
-        await _github.createOrUpdateGithubRelease.call(void 0, nxReleaseConfig.changelog.workspaceChangelog ? nxReleaseConfig.changelog.workspaceChangelog.createRelease : _config3.defaultCreateReleaseProvider, workspaceChangelog.releaseVersion, formatGithubReleaseNotes(workspaceChangelog.contents, workspaceConfig), latestCommit, {
+        const contents = formatGithubReleaseNotes(workspaceChangelog.releaseVersion, workspaceChangelog.contents, null, workspaceConfig);
+        _output.output.logSingleLine(`Creating GitHub Release 
+
+${contents}`);
+        await _github.createOrUpdateGithubRelease.call(void 0, nxReleaseConfig.changelog.workspaceChangelog ? nxReleaseConfig.changelog.workspaceChangelog.createRelease : _config3.defaultCreateReleaseProvider, workspaceChangelog.releaseVersion, contents, latestCommit, {
           dryRun: !!args.dryRun
         });
       });
+    } else {
+      _output.output.logSingleLine(`Skipping GitHub Release for workspace changelog as it is disabled in the release group configuration`);
     }
     const projectToAdditionalDependencyBumps = /* @__PURE__ */ new Map();
     for (const releaseGroup of releaseGroups) {
@@ -84813,13 +84810,13 @@ function createAPI(overrideReleaseConfig) {
         continue;
       }
       for (const project of releaseGroup.projects) {
-        if (!projectsVersionData[project] || projectsVersionData[project].newVersion === null) {
+        if (!_optionalChain([projectsVersionData, 'access', _206 => _206[project], 'optionalAccess', _207 => _207.newVersion])) {
           continue;
         }
         const dependentProjects = (projectsVersionData[project].dependentProjects || []).map((dep) => {
           return {
             dependencyName: dep.source,
-            newVersion: _optionalChain([projectsVersionData, 'access', _206 => _206[dep.source], 'optionalAccess', _207 => _207.newVersion])
+            newVersion: _optionalChain([projectsVersionData, 'access', _208 => _208[dep.source], 'optionalAccess', _209 => _209.newVersion])
           };
         }).filter((b) => b.newVersion !== null);
         for (const dependent of dependentProjects) {
@@ -84838,10 +84835,10 @@ function createAPI(overrideReleaseConfig) {
       if (config === false) {
         continue;
       }
-      const projects = _optionalChain([args, 'access', _208 => _208.projects, 'optionalAccess', _209 => _209.length]) ? Array.from(releaseGroupToFilteredProjects.get(releaseGroup)).flatMap((project) => {
+      const projects = _optionalChain([args, 'access', _210 => _210.projects, 'optionalAccess', _211 => _211.length]) ? Array.from(releaseGroupToFilteredProjects.get(releaseGroup)).flatMap((project) => {
         return [
           project,
-          ..._optionalChain([projectsVersionData, 'access', _210 => _210[project], 'optionalAccess', _211 => _211.dependentProjects, 'access', _212 => _212.map, 'call', _213 => _213((dep) => dep.source)]) || []
+          ..._optionalChain([projectsVersionData, 'access', _212 => _212[project], 'optionalAccess', _213 => _213.dependentProjects, 'access', _214 => _214.map, 'call', _215 => _215((dep) => dep.source)]) || []
         ];
       }) : releaseGroup.projects;
       const projectNodes = projects.map((name) => projectGraph.nodes[name]);
@@ -84877,12 +84874,12 @@ function createAPI(overrideReleaseConfig) {
             let fromRef = args.from || await _asyncOptionalChain([(await _git.getLatestGitTagForPattern.call(void 0, releaseGroup.releaseTagPattern, {
               projectName: project.name,
               releaseGroupName: releaseGroup.name
-            }, releaseGroup.releaseTagPatternCheckAllBranchesWhen)), 'optionalAccess', async _214 => _214.tag]);
+            }, releaseGroup.releaseTagPatternCheckAllBranchesWhen)), 'optionalAccess', async _216 => _216.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', _215 => _215[0], 'optionalAccess', _216 => _216.shortHash]);
+              fromRef = _optionalChain([commitsForProject, 'access', _217 => _217[0], 'optionalAccess', _218 => _218.shortHash]);
               if (args.verbose) {
                 console.log(`Determined --from ref for ${project.name} from the first commit in which it exists: ${fromRef}`);
               }
@@ -84927,11 +84924,16 @@ function createAPI(overrideReleaseConfig) {
           for (const [projectName, projectChangelog] of Object.entries(projectChangelogs)) {
             if (projectChangelogs && shouldCreateGitHubRelease(releaseGroup.changelog, args.createRelease)) {
               postGitTasks.push(async (latestCommit) => {
-                _output.output.logSingleLine(`Creating GitHub Release`);
-                await _github.createOrUpdateGithubRelease.call(void 0, releaseGroup.changelog ? releaseGroup.changelog.createRelease : _config3.defaultCreateReleaseProvider, projectChangelog.releaseVersion, formatGithubReleaseNotes(projectChangelog.contents, workspaceConfig), latestCommit, {
+                const contents = formatGithubReleaseNotes(projectChangelog.releaseVersion, projectChangelog.contents, projectName, workspaceConfig);
+                _output.output.logSingleLine(`Creating GitHub Release 
+
+${contents}`);
+                await _github.createOrUpdateGithubRelease.call(void 0, releaseGroup.changelog ? releaseGroup.changelog.createRelease : _config3.defaultCreateReleaseProvider, projectChangelog.releaseVersion, contents, latestCommit, {
                   dryRun: !!args.dryRun
                 });
               });
+            } else {
+              _output.output.logSingleLine(`Skipping GitHub Release for ${projectName} as it is disabled in the release group configuration`);
             }
             allProjectChangelogs[projectName] = projectChangelog;
           }
@@ -84981,7 +84983,7 @@ function createAPI(overrideReleaseConfig) {
             return changes2;
           }).filter(Boolean);
         } else {
-          let fromRef = args.from || await _asyncOptionalChain([(await _git.getLatestGitTagForPattern.call(void 0, releaseGroup.releaseTagPattern, {}, releaseGroup.releaseTagPatternCheckAllBranchesWhen)), 'optionalAccess', async _217 => _217.tag]);
+          let fromRef = args.from || await _asyncOptionalChain([(await _git.getLatestGitTagForPattern.call(void 0, releaseGroup.releaseTagPattern, {}, releaseGroup.releaseTagPatternCheckAllBranchesWhen)), 'optionalAccess', async _219 => _219.tag]);
           if (!fromRef) {
             if (useAutomaticFromRef) {
               fromRef = await _git.getFirstGitCommit.call(void 0, );
@@ -85030,6 +85032,8 @@ function createAPI(overrideReleaseConfig) {
                 dryRun: !!args.dryRun
               });
             });
+          } else {
+            _output.output.logSingleLine(`Skipping GitHub Release for ${projectName} as it is disabled in the release group configuration`);
           }
           allProjectChangelogs[projectName] = projectChangelog;
         }
@@ -85175,7 +85179,7 @@ async function applyChangesAndExit(args, nxReleaseConfig, tree, toSHA, postGitTa
 }
 _chunkKK4YC43Scjs.__name.call(void 0, applyChangesAndExit, "applyChangesAndExit");
 async function generateChangelogForWorkspace({ tree, args, projectGraph, nxReleaseConfig, workspaceChangelogVersion, changes, commits }) {
-  const workspaceConfig = await _chunkLFH4CIZMcjs.getWorkspaceConfig.call(void 0, );
+  const workspaceConfig = await _chunkSBZRK235cjs.getWorkspaceConfig.call(void 0, );
   if (!workspaceConfig) {
     throw new Error(`Unable to determine the Storm workspace config. Please ensure that your storm-workspace.json file is present and valid.`);
   }
@@ -85199,7 +85203,7 @@ async function generateChangelogForWorkspace({ tree, args, projectGraph, nxRelea
     });
     return;
   }
-  if (_optionalChain([Object, 'access', _218 => _218.values, 'call', _219 => _219(nxReleaseConfig.groups), 'access', _220 => _220[0], 'optionalAccess', _221 => _221.projectsRelationship]) === "independent") {
+  if (_optionalChain([Object, 'access', _220 => _220.values, 'call', _221 => _221(nxReleaseConfig.groups), 'access', _222 => _222[0], 'optionalAccess', _223 => _223.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: [
@@ -85255,8 +85259,7 @@ async function generateChangelogForWorkspace({ tree, args, projectGraph, nxRelea
     contents = _fs.readFileSync.call(void 0, changelogPath, "utf8");
   }
   if (interpolatedTreePath) {
-    const rootChangelogContents = tree.exists(interpolatedTreePath) ? _optionalChain([tree, 'access', _222 => _222.read, 'call', _223 => _223(interpolatedTreePath), 'optionalAccess', _224 => _224.toString, 'call', _225 => _225()]) : "";
-    tree.write(interpolatedTreePath, await generateChangelogContent(releaseVersion2, interpolatedTreePath, contents, rootChangelogContents, null, workspaceConfig));
+    tree.write(interpolatedTreePath, await generateChangelogContent(releaseVersion2, interpolatedTreePath, contents, tree.exists(interpolatedTreePath) ? _optionalChain([tree, 'access', _224 => _224.read, 'call', _225 => _225(interpolatedTreePath), 'optionalAccess', _226 => _226.toString, 'call', _227 => _227()]) : "", null, workspaceConfig));
     _printchanges.printAndFlushChanges.call(void 0, tree, !!dryRun, 3, false, _shared.noDiffInChangelogMessage);
   }
   return {
@@ -85266,7 +85269,7 @@ async function generateChangelogForWorkspace({ tree, args, projectGraph, nxRelea
 }
 _chunkKK4YC43Scjs.__name.call(void 0, generateChangelogForWorkspace, "generateChangelogForWorkspace");
 async function generateChangelogForProjects({ tree, args, changes, projectsVersionData, releaseGroup, projects, nxReleaseConfig, projectToAdditionalDependencyBumps }) {
-  const workspaceConfig = await _chunkLFH4CIZMcjs.getWorkspaceConfig.call(void 0, );
+  const workspaceConfig = await _chunkSBZRK235cjs.getWorkspaceConfig.call(void 0, );
   if (!workspaceConfig) {
     throw new Error(`Unable to determine the Storm workspace config. Please ensure that your storm-workspace.json file is present and valid.`);
   }
@@ -85285,10 +85288,9 @@ async function generateChangelogForProjects({ tree, args, changes, projectsVersi
         projectName: project.name,
         projectRoot: project.data.root,
         workspaceRoot: ""
-        // within the tree, workspaceRoot is the root
       });
     }
-    if (!_optionalChain([projectsVersionData, 'access', _226 => _226[project.name], 'optionalAccess', _227 => _227.newVersion])) {
+    if (!_optionalChain([projectsVersionData, 'access', _228 => _228[project.name], 'optionalAccess', _229 => _229.newVersion])) {
       continue;
     }
     const releaseVersion2 = new (0, _shared.ReleaseVersion)({
@@ -85301,53 +85303,56 @@ async function generateChangelogForProjects({ tree, args, changes, projectsVersi
       _output.output.log({
         title: `${prefix} an entry in ${interpolatedTreePath} for ${chalk2.white(releaseVersion2.gitTag)}`
       });
+      const githubRepoData = _github.getGitHubRepoData.call(void 0, gitRemote, config.createRelease);
+      const changelogRenderer = new StormChangelogRenderer({
+        changes,
+        changelogEntryVersion: releaseVersion2.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,
+          workspaceRoot: ""
+        }) : false,
+        changelogRenderOptions: config.renderOptions,
+        isVersionPlans: !!releaseGroup.versionPlans,
+        conventionalCommitsConfig: releaseGroup.versionPlans ? null : nxReleaseConfig.conventionalCommits,
+        dependencyBumps: projectToAdditionalDependencyBumps.get(project.name)
+      });
+      let contents = await changelogRenderer.render();
+      _output.output.log({
+        title: `Changelog renderer for ${project.name} rendered the following content: 
+
+${contents}`.trim()
+      });
+      if (interactive) {
+        const tmpDir = (0, import_tmp.dirSync)().name;
+        const changelogPath = _path3.joinPathFragments.call(void 0, 
+          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, "_")}`
+        );
+        _fs.writeFileSync.call(void 0, changelogPath, contents);
+        await _launcheditor.launchEditor.call(void 0, changelogPath);
+        contents = _fs.readFileSync.call(void 0, changelogPath, "utf8");
+      }
+      if (interpolatedTreePath) {
+        tree.write(interpolatedTreePath, await generateChangelogContent(releaseVersion2, interpolatedTreePath, contents, tree.exists(interpolatedTreePath) ? _optionalChain([tree, 'access', _230 => _230.read, 'call', _231 => _231(interpolatedTreePath), 'optionalAccess', _232 => _232.toString, 'call', _233 => _233()]) : "", project.name, workspaceConfig));
+        _printchanges.printAndFlushChanges.call(void 0, 
+          tree,
+          !!dryRun,
+          3,
+          false,
+          _shared.noDiffInChangelogMessage,
+          // Only print the change for the current changelog file at this point
+          (f) => f.path === interpolatedTreePath
+        );
+      }
+      projectChangelogs[project.name] = {
+        releaseVersion: releaseVersion2,
+        contents
+      };
     }
-    const githubRepoData = _github.getGitHubRepoData.call(void 0, gitRemote, config.createRelease);
-    const changelogRenderer = new StormChangelogRenderer({
-      changes,
-      changelogEntryVersion: releaseVersion2.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,
-        workspaceRoot: ""
-        // within the tree, workspaceRoot is the root
-      }) : false,
-      changelogRenderOptions: config.renderOptions,
-      isVersionPlans: !!releaseGroup.versionPlans,
-      conventionalCommitsConfig: releaseGroup.versionPlans ? null : nxReleaseConfig.conventionalCommits,
-      dependencyBumps: projectToAdditionalDependencyBumps.get(project.name)
-    });
-    let contents = await changelogRenderer.render();
-    if (interactive) {
-      const tmpDir = (0, import_tmp.dirSync)().name;
-      const changelogPath = _path3.joinPathFragments.call(void 0, 
-        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, "_")}`
-      );
-      _fs.writeFileSync.call(void 0, changelogPath, contents);
-      await _launcheditor.launchEditor.call(void 0, changelogPath);
-      contents = _fs.readFileSync.call(void 0, changelogPath, "utf8");
-    }
-    if (interpolatedTreePath) {
-      const changelogContents = tree.exists(interpolatedTreePath) ? _optionalChain([tree, 'access', _228 => _228.read, 'call', _229 => _229(interpolatedTreePath), 'optionalAccess', _230 => _230.toString, 'call', _231 => _231()]) : "";
-      tree.write(interpolatedTreePath, await generateChangelogContent(releaseVersion2, interpolatedTreePath, contents, changelogContents, project.name, workspaceConfig));
-      _printchanges.printAndFlushChanges.call(void 0, 
-        tree,
-        !!dryRun,
-        3,
-        false,
-        _shared.noDiffInChangelogMessage,
-        // Only print the change for the current changelog file at this point
-        (f) => f.path === interpolatedTreePath
-      );
-    }
-    projectChangelogs[project.name] = {
-      releaseVersion: releaseVersion2,
-      contents
-    };
   }
   return projectChangelogs;
 }
@@ -85356,12 +85361,7 @@ function checkChangelogFilesEnabled(nxReleaseConfig) {
   if (nxReleaseConfig.changelog.workspaceChangelog && nxReleaseConfig.changelog.workspaceChangelog.file) {
     return true;
   }
-  for (const releaseGroup of Object.values(nxReleaseConfig.groups)) {
-    if (releaseGroup.changelog && releaseGroup.changelog.file) {
-      return true;
-    }
-  }
-  return false;
+  return Object.values(nxReleaseConfig.groups).some((releaseGroup) => _optionalChain([releaseGroup, 'optionalAccess', _234 => _234.changelog, 'optionalAccess', _235 => _235.file]));
 }
 _chunkKK4YC43Scjs.__name.call(void 0, checkChangelogFilesEnabled, "checkChangelogFilesEnabled");
 async function getCommits(fromSHA, toSHA) {
@@ -85467,13 +85467,26 @@ function versionPlanSemverReleaseTypeToChangelogType(bump) {
   }
 }
 _chunkKK4YC43Scjs.__name.call(void 0, versionPlanSemverReleaseTypeToChangelogType, "versionPlanSemverReleaseTypeToChangelogType");
-function formatGithubReleaseNotes(content, workspaceConfig) {
+function formatGithubReleaseNotes(releaseVersion2, content, projectName, workspaceConfig) {
   if (!workspaceConfig) {
     return content;
   }
-  return `![Storm Software](${workspaceConfig.release.banner})
+  return `![${titleCase(workspaceConfig.organization)}](${workspaceConfig.release.banner})
 ${workspaceConfig.release.header || ""}
-${content}
+
+# ${projectName ? `${titleCase(projectName)} ` : ""}v${releaseVersion2.rawVersion}
+
+We at ${titleCase(workspaceConfig.organization)} are very excited to announce the v${releaseVersion2.rawVersion} release of the ${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}).
+
+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 [tweeting](https://twitter.com/intent/tweet?text=Check%20out%20the%20latest%20@${workspaceConfig.account.twitter}%20release%20${projectName ? `${_optionalChain([titleCase, 'call', _236 => _236(projectName), 'optionalAccess', _237 => _237.replaceAll, 'call', _238 => _238(" ", "%20")])}%20` : ""}v${releaseVersion2.rawVersion}%20%F0%9F%9A%80%0D%0A%0D%0Ahttps://github.com/${workspaceConfig.organization}/${workspaceConfig.name}/releases/tag/${releaseVersion2.gitTag}) about this release!
+
+## Release Notes
+
+${content.replaceAll(`## ${generateChangelogTitle(releaseVersion2.rawVersion, projectName, workspaceConfig)}`, "").replaceAll(`# ${generateChangelogTitle(releaseVersion2.rawVersion, projectName, workspaceConfig)}`, "")}
+
+---
 
 ${workspaceConfig.release.footer}
 `;
@@ -85556,13 +85569,13 @@ var _filemaputilsjs = require('nx/src/project-graph/file-map-utils.js');
 var _paramsjs = require('nx/src/utils/params.js');
 async function releaseVersion(config, args) {
   try {
-    _chunkLFH4CIZMcjs.writeInfo.call(void 0, "Running release version command", config);
+    _chunkSBZRK235cjs.writeInfo.call(void 0, "Running release version command", config);
     const projectGraph = await _projectgraphjs.createProjectGraphAsync.call(void 0, {
       exitOnError: true
     });
     const { projects } = _projectgraphjs.readProjectsConfigurationFromProjectGraph.call(void 0, projectGraph);
     const nxJson = _nxjsonjs.readNxJson.call(void 0, );
-    const workspaceRoot3 = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _232 => _232.workspaceRoot]), () => ( _chunkLFH4CIZMcjs.findWorkspaceRoot.call(void 0, )));
+    const workspaceRoot3 = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _239 => _239.workspaceRoot]), () => ( _chunkSBZRK235cjs.findWorkspaceRoot.call(void 0, )));
     if (args.verbose) {
       process.env.NX_VERBOSE_LOGGING = "true";
     }
@@ -85570,29 +85583,29 @@ async function releaseVersion(config, args) {
     if (configError) {
       return await _configjs.handleNxReleaseConfigError.call(void 0, configError);
     }
-    if ((args.gitCommit === void 0 || args.gitTag === void 0 || args.stageChanges === void 0) && _optionalChain([nxJson, 'access', _233 => _233.release, 'optionalAccess', _234 => _234.git])) {
+    if ((args.gitCommit === void 0 || args.gitTag === void 0 || args.stageChanges === void 0) && _optionalChain([nxJson, 'access', _240 => _240.release, 'optionalAccess', _241 => _241.git])) {
       await _resolvenxjsonerrormessagejs.resolveNxJsonConfigErrorMessage.call(void 0, [
         "release",
         "git"
       ]);
       throw new Error(`The "release.git" property in nx.json may not be used with the "nx release version" subcommand or programmatic API. Instead, configure git options for subcommands directly with "release.version.git" and "release.changelog.git".`);
     }
-    _chunkLFH4CIZMcjs.writeInfo.call(void 0, "Filtering projects and release groups", config);
+    _chunkSBZRK235cjs.writeInfo.call(void 0, "Filtering projects and release groups", config);
     const { error: filterError, releaseGroups, releaseGroupToFilteredProjects } = _filterreleasegroupsjs.filterReleaseGroups.call(void 0, projectGraph, nxReleaseConfig, args.projects, args.groups);
     if (filterError) {
-      _chunkLFH4CIZMcjs.writeError.call(void 0, filterError.title, config);
+      _chunkSBZRK235cjs.writeError.call(void 0, filterError.title, config);
       throw new Error(filterError.title);
     }
     const tree = new (0, _treejs.FsTree)(workspaceRoot3, true);
     const versionData = {};
-    const commitMessage = args.gitCommitMessage || _optionalChain([nxReleaseConfig, 'optionalAccess', _235 => _235.version, 'access', _236 => _236.git, 'access', _237 => _237.commitMessage]);
+    const commitMessage = args.gitCommitMessage || _optionalChain([nxReleaseConfig, 'optionalAccess', _242 => _242.version, 'access', _243 => _243.git, 'access', _244 => _244.commitMessage]);
     const additionalChangedFiles = /* @__PURE__ */ new Set();
     const generatorCallbacks = [];
-    if (_optionalChain([args, 'access', _238 => _238.projects, 'optionalAccess', _239 => _239.length])) {
-      _chunkLFH4CIZMcjs.writeInfo.call(void 0, "Run versioning for all remaining release groups and filtered projects within them", config);
+    if (_optionalChain([args, 'access', _245 => _245.projects, 'optionalAccess', _246 => _246.length])) {
+      _chunkSBZRK235cjs.writeInfo.call(void 0, "Run versioning for all remaining release groups and filtered projects within them", config);
       for (const releaseGroup of releaseGroups) {
         const releaseGroupName = releaseGroup.name;
-        _chunkLFH4CIZMcjs.writeInfo.call(void 0, `Running versioning for release group "${releaseGroupName}" and filtered projects within it`, config);
+        _chunkSBZRK235cjs.writeInfo.call(void 0, `Running versioning for release group "${releaseGroupName}" and filtered projects within it`, config);
         const releaseGroupProjectNames = Array.from(_nullishCoalesce(releaseGroupToFilteredProjects.get(releaseGroup), () => ( [])));
         const projectBatches = _batchprojectsbygeneratorconfigjs.batchProjectsByGeneratorConfig.call(void 0, 
           projectGraph,
@@ -85601,7 +85614,7 @@ async function releaseVersion(config, args) {
           releaseGroupProjectNames
         );
         for (const [generatorConfigString, projectNames] of projectBatches.entries()) {
-          _chunkLFH4CIZMcjs.writeInfo.call(void 0, `Running versioning for batch "${JSON.stringify(projectNames)}" for release-group "${releaseGroupName}"`, config);
+          _chunkSBZRK235cjs.writeInfo.call(void 0, `Running versioning for batch "${JSON.stringify(projectNames)}" for release-group "${releaseGroupName}"`, config);
           const [generatorName, generatorOptions] = JSON.parse(generatorConfigString);
           const generatorData = resolveGeneratorData({
             ...extractGeneratorCollectionAndName(`batch "${JSON.stringify(projectNames)}" for release-group "${releaseGroupName}"`, generatorName),
@@ -85628,7 +85641,7 @@ async function releaseVersion(config, args) {
           });
         }
       }
-      const gitTagValues2 = _nullishCoalesce(args.gitTag, () => ( _optionalChain([nxReleaseConfig, 'optionalAccess', _240 => _240.version, 'access', _241 => _241.git, 'access', _242 => _242.tag]))) ? _sharedjs.createGitTagValues.call(void 0, releaseGroups, releaseGroupToFilteredProjects, versionData) : [];
+      const gitTagValues2 = _nullishCoalesce(args.gitTag, () => ( _optionalChain([nxReleaseConfig, 'optionalAccess', _247 => _247.version, 'access', _248 => _248.git, 'access', _249 => _249.tag]))) ? _sharedjs.createGitTagValues.call(void 0, releaseGroups, releaseGroupToFilteredProjects, versionData) : [];
       _sharedjs.handleDuplicateGitTags.call(void 0, gitTagValues2);
       printAndFlushChanges2(config, tree, !!args.dryRun);
       for (const generatorCallback of generatorCallbacks) {
@@ -85645,29 +85658,29 @@ async function releaseVersion(config, args) {
           projectsVersionData: versionData
         };
       }
-      if (_nullishCoalesce(args.gitCommit, () => ( _optionalChain([nxReleaseConfig, 'optionalAccess', _243 => _243.version, 'access', _244 => _244.git, 'access', _245 => _245.commit])))) {
+      if (_nullishCoalesce(args.gitCommit, () => ( _optionalChain([nxReleaseConfig, 'optionalAccess', _250 => _250.version, 'access', _251 => _251.git, 'access', _252 => _252.commit])))) {
         await _sharedjs.commitChanges.call(void 0, {
           changedFiles: changedFiles2,
           isDryRun: !!args.dryRun,
           isVerbose: !!args.verbose,
           gitCommitMessages: _sharedjs.createCommitMessageValues.call(void 0, releaseGroups, releaseGroupToFilteredProjects, versionData, commitMessage),
-          gitCommitArgs: args.gitCommitArgs || _optionalChain([nxReleaseConfig, 'optionalAccess', _246 => _246.version, 'access', _247 => _247.git, 'access', _248 => _248.commitArgs])
+          gitCommitArgs: args.gitCommitArgs || _optionalChain([nxReleaseConfig, 'optionalAccess', _253 => _253.version, 'access', _254 => _254.git, 'access', _255 => _255.commitArgs])
         });
-      } else if (_nullishCoalesce(args.stageChanges, () => ( _optionalChain([nxReleaseConfig, 'optionalAccess', _249 => _249.version, 'access', _250 => _250.git, 'access', _251 => _251.stageChanges])))) {
-        _chunkLFH4CIZMcjs.writeInfo.call(void 0, "Staging changed files with git", config);
+      } else if (_nullishCoalesce(args.stageChanges, () => ( _optionalChain([nxReleaseConfig, 'optionalAccess', _256 => _256.version, 'access', _257 => _257.git, 'access', _258 => _258.stageChanges])))) {
+        _chunkSBZRK235cjs.writeInfo.call(void 0, "Staging changed files with git", config);
         await _gitjs.gitAdd.call(void 0, {
           changedFiles: changedFiles2,
           dryRun: args.dryRun,
           verbose: args.verbose
         });
       }
-      if (_nullishCoalesce(args.gitTag, () => ( _optionalChain([nxReleaseConfig, 'optionalAccess', _252 => _252.version, 'access', _253 => _253.git, 'access', _254 => _254.tag])))) {
-        _chunkLFH4CIZMcjs.writeInfo.call(void 0, "Tagging commit with git", config);
+      if (_nullishCoalesce(args.gitTag, () => ( _optionalChain([nxReleaseConfig, 'optionalAccess', _259 => _259.version, 'access', _260 => _260.git, 'access', _261 => _261.tag])))) {
+        _chunkSBZRK235cjs.writeInfo.call(void 0, "Tagging commit with git", config);
         for (const tag of gitTagValues2) {
           await _gitjs.gitTag.call(void 0, {
             tag,
-            message: args.gitTagMessage || _optionalChain([nxReleaseConfig, 'optionalAccess', _255 => _255.version, 'access', _256 => _256.git, 'access', _257 => _257.tagMessage]),
-            additionalArgs: args.gitTagArgs || _optionalChain([nxReleaseConfig, 'optionalAccess', _258 => _258.version, 'access', _259 => _259.git, 'access', _260 => _260.tagArgs]),
+            message: args.gitTagMessage || _optionalChain([nxReleaseConfig, 'optionalAccess', _262 => _262.version, 'access', _263 => _263.git, 'access', _264 => _264.tagMessage]),
+            additionalArgs: args.gitTagArgs || _optionalChain([nxReleaseConfig, 'optionalAccess', _265 => _265.version, 'access', _266 => _266.git, 'access', _267 => _267.tagArgs]),
             dryRun: args.dryRun,
             verbose: args.verbose
           });
@@ -85714,7 +85727,7 @@ async function releaseVersion(config, args) {
         });
       }
     }
-    const gitTagValues = _nullishCoalesce(args.gitTag, () => ( _optionalChain([nxReleaseConfig, 'optionalAccess', _261 => _261.version, 'access', _262 => _262.git, 'access', _263 => _263.tag]))) ? _sharedjs.createGitTagValues.call(void 0, releaseGroups, releaseGroupToFilteredProjects, versionData) : [];
+    const gitTagValues = _nullishCoalesce(args.gitTag, () => ( _optionalChain([nxReleaseConfig, 'optionalAccess', _268 => _268.version, 'access', _269 => _269.git, 'access', _270 => _270.tag]))) ? _sharedjs.createGitTagValues.call(void 0, releaseGroups, releaseGroupToFilteredProjects, versionData) : [];
     _sharedjs.handleDuplicateGitTags.call(void 0, gitTagValues);
     printAndFlushChanges2(config, tree, !!args.dryRun);
     for (const generatorCallback of generatorCallbacks) {
@@ -85723,10 +85736,10 @@ async function releaseVersion(config, args) {
     let workspaceVersion = void 0;
     if (releaseGroups.length === 1) {
       const releaseGroup = releaseGroups[0];
-      if (_optionalChain([releaseGroup, 'optionalAccess', _264 => _264.projectsRelationship]) === "fixed") {
+      if (_optionalChain([releaseGroup, 'optionalAccess', _271 => _271.projectsRelationship]) === "fixed") {
         const releaseGroupProjectNames = Array.from(_nullishCoalesce(releaseGroupToFilteredProjects.get(releaseGroup), () => ( [])));
         if (releaseGroupProjectNames.length > 0 && releaseGroupProjectNames[0]) {
-          workspaceVersion = _optionalChain([versionData, 'access', _265 => _265[releaseGroupProjectNames[0]], 'optionalAccess', _266 => _266.newVersion]);
+          workspaceVersion = _optionalChain([versionData, 'access', _272 => _272[releaseGroupProjectNames[0]], 'optionalAccess', _273 => _273.newVersion]);
         }
       }
     }
@@ -85740,29 +85753,29 @@ async function releaseVersion(config, args) {
         projectsVersionData: versionData
       };
     }
-    if (_nullishCoalesce(args.gitCommit, () => ( _optionalChain([nxReleaseConfig, 'optionalAccess', _267 => _267.version, 'access', _268 => _268.git, 'access', _269 => _269.commit])))) {
+    if (_nullishCoalesce(args.gitCommit, () => ( _optionalChain([nxReleaseConfig, 'optionalAccess', _274 => _274.version, 'access', _275 => _275.git, 'access', _276 => _276.commit])))) {
       await _sharedjs.commitChanges.call(void 0, {
         changedFiles,
         isDryRun: !!args.dryRun,
         isVerbose: !!args.verbose,
         gitCommitMessages: _sharedjs.createCommitMessageValues.call(void 0, releaseGroups, releaseGroupToFilteredProjects, versionData, commitMessage),
-        gitCommitArgs: args.gitCommitArgs || _optionalChain([nxReleaseConfig, 'optionalAccess', _270 => _270.version, 'access', _271 => _271.git, 'access', _272 => _272.commitArgs])
+        gitCommitArgs: args.gitCommitArgs || _optionalChain([nxReleaseConfig, 'optionalAccess', _277 => _277.version, 'access', _278 => _278.git, 'access', _279 => _279.commitArgs])
       });
-    } else if (_nullishCoalesce(args.stageChanges, () => ( _optionalChain([nxReleaseConfig, 'optionalAccess', _273 => _273.version, 'access', _274 => _274.git, 'access', _275 => _275.stageChanges])))) {
-      _chunkLFH4CIZMcjs.writeInfo.call(void 0, "Staging changed files with git", config);
+    } else if (_nullishCoalesce(args.stageChanges, () => ( _optionalChain([nxReleaseConfig, 'optionalAccess', _280 => _280.version, 'access', _281 => _281.git, 'access', _282 => _282.stageChanges])))) {
+      _chunkSBZRK235cjs.writeInfo.call(void 0, "Staging changed files with git", config);
       await _gitjs.gitAdd.call(void 0, {
         changedFiles,
         dryRun: args.dryRun,
         verbose: args.verbose
       });
     }
-    if (_nullishCoalesce(args.gitTag, () => ( _optionalChain([nxReleaseConfig, 'optionalAccess', _276 => _276.version, 'access', _277 => _277.git, 'access', _278 => _278.tag])))) {
-      _chunkLFH4CIZMcjs.writeInfo.call(void 0, "Tagging commit with git", config);
+    if (_nullishCoalesce(args.gitTag, () => ( _optionalChain([nxReleaseConfig, 'optionalAccess', _283 => _283.version, 'access', _284 => _284.git, 'access', _285 => _285.tag])))) {
+      _chunkSBZRK235cjs.writeInfo.call(void 0, "Tagging commit with git", config);
       for (const tag of gitTagValues) {
         await _gitjs.gitTag.call(void 0, {
           tag,
-          message: args.gitTagMessage || _optionalChain([nxReleaseConfig, 'optionalAccess', _279 => _279.version, 'access', _280 => _280.git, 'access', _281 => _281.tagMessage]),
-          additionalArgs: args.gitTagArgs || _optionalChain([nxReleaseConfig, 'optionalAccess', _282 => _282.version, 'access', _283 => _283.git, 'access', _284 => _284.tagArgs]),
+          message: args.gitTagMessage || _optionalChain([nxReleaseConfig, 'optionalAccess', _286 => _286.version, 'access', _287 => _287.git, 'access', _288 => _288.tagMessage]),
+          additionalArgs: args.gitTagArgs || _optionalChain([nxReleaseConfig, 'optionalAccess', _289 => _289.version, 'access', _290 => _290.git, 'access', _291 => _291.tagArgs]),
           dryRun: args.dryRun,
           verbose: args.verbose
         });
@@ -85773,8 +85786,8 @@ async function releaseVersion(config, args) {
       projectsVersionData: versionData
     };
   } catch (error) {
-    _chunkLFH4CIZMcjs.writeFatal.call(void 0, "A fatal error occurred while determining the Storm Release Version - the process was forced to terminate", config);
-    _chunkLFH4CIZMcjs.writeError.call(void 0, `An exception was thrown while determining the Storm Release Version 
+    _chunkSBZRK235cjs.writeFatal.call(void 0, "A fatal error occurred while determining the Storm Release Version - the process was forced to terminate", config);
+    _chunkSBZRK235cjs.writeError.call(void 0, `An exception was thrown while determining the Storm Release Version 
  - Details: ${error.message}
  - Stacktrace: ${error.stack}`, config);
     throw new Error(`An exception was thrown in the Storm Release Version generator's process 
@@ -85785,7 +85798,7 @@ async function releaseVersion(config, args) {
 }
 _chunkKK4YC43Scjs.__name.call(void 0, releaseVersion, "releaseVersion");
 async function runVersionOnProjects(config, projectGraph, nxJson, args, tree, generatorData, projectNames, releaseGroup, versionData) {
-  const workspaceRoot3 = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _285 => _285.workspaceRoot]), () => ( _chunkLFH4CIZMcjs.findWorkspaceRoot.call(void 0, )));
+  const workspaceRoot3 = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _292 => _292.workspaceRoot]), () => ( _chunkSBZRK235cjs.findWorkspaceRoot.call(void 0, )));
   const generatorOptions = {
     // Always ensure a string to avoid generator schema validation errors
     specifier: _nullishCoalesce(args.specifier, () => ( "")),
@@ -85804,7 +85817,7 @@ async function runVersionOnProjects(config, projectGraph, nxJson, args, tree, ge
     throw new Error(`The version generator ${generatorData.collectionName}:${generatorData.normalizedGeneratorName} returned a function instead of an expected ReleaseVersionGeneratorResult`);
   }
   appendVersionData(versionData, versionResult.data);
-  _chunkLFH4CIZMcjs.writeDebug.call(void 0, `Updated version data: ${JSON.stringify(versionData, null, 2)}`, config);
+  _chunkSBZRK235cjs.writeDebug.call(void 0, `Updated version data: ${JSON.stringify(versionData, null, 2)}`, config);
   return versionResult.callback;
 }
 _chunkKK4YC43Scjs.__name.call(void 0, runVersionOnProjects, "runVersionOnProjects");
@@ -85812,12 +85825,12 @@ function printAndFlushChanges2(config, tree, isDryRun) {
   const changes = tree.listChanges();
   for (const f of changes) {
     if (f.type === "CREATE") {
-      _chunkLFH4CIZMcjs.writeInfo.call(void 0, `CREATE ${f.path}${isDryRun ? " [dry-run]" : ""}`, config);
-      _printchangesjs.printDiff.call(void 0, "", _optionalChain([f, 'access', _286 => _286.content, 'optionalAccess', _287 => _287.toString, 'call', _288 => _288()]) || "");
+      _chunkSBZRK235cjs.writeInfo.call(void 0, `CREATE ${f.path}${isDryRun ? " [dry-run]" : ""}`, config);
+      _printchangesjs.printDiff.call(void 0, "", _optionalChain([f, 'access', _293 => _293.content, 'optionalAccess', _294 => _294.toString, 'call', _295 => _295()]) || "");
     } else if (f.type === "UPDATE") {
-      _chunkLFH4CIZMcjs.writeInfo.call(void 0, `UPDATE ${f.path}${isDryRun ? " [dry-run]" : ""}`, config);
+      _chunkSBZRK235cjs.writeInfo.call(void 0, `UPDATE ${f.path}${isDryRun ? " [dry-run]" : ""}`, config);
       const currentContentsOnDisk = _fs.readFileSync.call(void 0, (0, import_devkit.joinPathFragments)(tree.root, f.path)).toString();
-      _printchangesjs.printDiff.call(void 0, currentContentsOnDisk, _optionalChain([f, 'access', _289 => _289.content, 'optionalAccess', _290 => _290.toString, 'call', _291 => _291()]) || "");
+      _printchangesjs.printDiff.call(void 0, currentContentsOnDisk, _optionalChain([f, 'access', _296 => _296.content, 'optionalAccess', _297 => _297.toString, 'call', _298 => _298()]) || "");
     } else if (f.type === "DELETE") {
       throw new Error("Unexpected DELETE change, please report this as an issue");
     }
@@ -85887,31 +85900,31 @@ var runRelease = /* @__PURE__ */ _chunkKK4YC43Scjs.__name.call(void 0, async (co
   process.env.NODE_AUTH_TOKEN = process.env.NPM_TOKEN;
   process.env.NPM_AUTH_TOKEN = process.env.NPM_TOKEN;
   process.env.NPM_CONFIG_PROVENANCE = "true";
-  _chunkLFH4CIZMcjs.writeDebug.call(void 0, "Creating workspace Project Graph data...", config);
+  _chunkSBZRK235cjs.writeDebug.call(void 0, "Creating workspace Project Graph data...", config);
   const nxJson = _nxjsonjs.readNxJson.call(void 0, );
-  _chunkLFH4CIZMcjs.writeDebug.call(void 0, "Reading in the workspaces release configuration", config);
+  _chunkSBZRK235cjs.writeDebug.call(void 0, "Reading in the workspaces release configuration", config);
   const to = options.head || process.env.NX_HEAD;
   const from = options.base || process.env.NX_BASE;
-  _chunkLFH4CIZMcjs.writeDebug.call(void 0, `Using the following Git SHAs to determine the release content:
+  _chunkSBZRK235cjs.writeDebug.call(void 0, `Using the following Git SHAs to determine the release content:
  - From: ${from}
  - To: ${to}
 `, config);
-  if (_optionalChain([nxJson, 'access', _292 => _292.release, 'optionalAccess', _293 => _293.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', _294 => _294.release, 'optionalAccess', _295 => _295.groups, 'optionalAccess', _296 => _296[groupName]]);
+      const groupConfig = _optionalChain([nxJson, 'access', _301 => _301.release, 'optionalAccess', _302 => _302.groups, 'optionalAccess', _303 => _303[groupName]]);
       ret[groupName] = _chunkP2CHIYIKcjs.defu.call(void 0, groupConfig, DEFAULT_RELEASE_GROUP_CONFIG);
       return ret;
     }, {});
   }
   const nxReleaseConfig = _chunkP2CHIYIKcjs.defu.call(void 0, nxJson.release, DEFAULT_RELEASE_CONFIG);
-  _chunkLFH4CIZMcjs.writeInfo.call(void 0, "Using the following `nx.json` release configuration values", config);
-  _chunkLFH4CIZMcjs.writeInfo.call(void 0, nxReleaseConfig, config);
+  _chunkSBZRK235cjs.writeInfo.call(void 0, "Using the following `nx.json` release configuration values", config);
+  _chunkSBZRK235cjs.writeInfo.call(void 0, nxReleaseConfig, config);
   const releaseChangelog = createAPI(nxReleaseConfig);
   const releasePublish = _publishjs.createAPI.call(void 0, nxReleaseConfig);
-  _chunkLFH4CIZMcjs.writeDebug.call(void 0, "Determining the current release versions...", config);
+  _chunkSBZRK235cjs.writeDebug.call(void 0, "Determining the current release versions...", config);
   const { workspaceVersion, projectsVersionData } = await releaseVersion(config, {
     dryRun: false,
-    verbose: _chunkLFH4CIZMcjs.isVerbose.call(void 0, config.logLevel),
+    verbose: _chunkSBZRK235cjs.isVerbose.call(void 0, config.logLevel),
     preid: config.preid,
     deleteVersionPlans: false,
     stageChanges: true,
@@ -85921,50 +85934,50 @@ var runRelease = /* @__PURE__ */ _chunkKK4YC43Scjs.__name.call(void 0, async (co
   });
   await releaseChangelog({
     ...options,
-    version: _optionalChain([nxReleaseConfig, 'optionalAccess', _297 => _297.projectsRelationship]) !== "fixed" ? void 0 : workspaceVersion,
+    version: _optionalChain([nxReleaseConfig, 'optionalAccess', _304 => _304.projectsRelationship]) !== "fixed" ? void 0 : workspaceVersion,
     versionData: projectsVersionData,
     dryRun: false,
-    verbose: _chunkLFH4CIZMcjs.isVerbose.call(void 0, config.logLevel),
+    verbose: _chunkSBZRK235cjs.isVerbose.call(void 0, config.logLevel),
     to,
     from,
     gitCommit: true,
     gitCommitMessage: "release(monorepo): Publish workspace release updates"
   });
-  _chunkLFH4CIZMcjs.writeDebug.call(void 0, "Tagging commit with git", config);
+  _chunkSBZRK235cjs.writeDebug.call(void 0, "Tagging commit with git", config);
   if (options.skipPublish) {
-    _chunkLFH4CIZMcjs.writeWarning.call(void 0, "Skipping publishing packages since `skipPublish` was provided as `true` in the release options.", config);
+    _chunkSBZRK235cjs.writeWarning.call(void 0, "Skipping publishing packages since `skipPublish` was provided as `true` in the release options.", config);
   } else {
-    const changedProjects = Object.keys(projectsVersionData).filter((key) => _optionalChain([projectsVersionData, 'access', _298 => _298[key], 'optionalAccess', _299 => _299.newVersion]));
+    const changedProjects = Object.keys(projectsVersionData).filter((key) => _optionalChain([projectsVersionData, 'access', _305 => _305[key], 'optionalAccess', _306 => _306.newVersion]));
     if (changedProjects.length > 0) {
-      _chunkLFH4CIZMcjs.writeInfo.call(void 0, `Publishing release for ${changedProjects.length} ${changedProjects.length === 1 ? "project" : "projects"}:
+      _chunkSBZRK235cjs.writeInfo.call(void 0, `Publishing release for ${changedProjects.length} ${changedProjects.length === 1 ? "project" : "projects"}:
 ${changedProjects.map((changedProject) => `  - ${changedProject}`).join("\n")}
 `, config);
       const result2 = await releasePublish({
         ...options,
         dryRun: !!options.dryRun,
-        verbose: _chunkLFH4CIZMcjs.isVerbose.call(void 0, config.logLevel)
+        verbose: _chunkSBZRK235cjs.isVerbose.call(void 0, config.logLevel)
       });
-      const failedProjects = Object.keys(result2).filter((key) => _optionalChain([result2, 'access', _300 => _300[key], 'optionalAccess', _301 => _301.code]) && _optionalChain([result2, 'access', _302 => _302[key], 'optionalAccess', _303 => _303.code]) > 0);
+      const failedProjects = Object.keys(result2).filter((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', _304 => _304[failedProject], 'optionalAccess', _305 => _305.code])})`).join("\n")}
+${failedProjects.map((failedProject) => `  - ${failedProject} (Error Code: ${_optionalChain([result2, 'access', _311 => _311[failedProject], 'optionalAccess', _312 => _312.code])})`).join("\n")}
 `);
       }
     } else {
-      _chunkLFH4CIZMcjs.writeWarning.call(void 0, "Skipped publishing packages.", config);
+      _chunkSBZRK235cjs.writeWarning.call(void 0, "Skipped publishing packages.", config);
     }
   }
-  _chunkLFH4CIZMcjs.writeSuccess.call(void 0, "Completed the Storm workspace release process!", config);
+  _chunkSBZRK235cjs.writeSuccess.call(void 0, "Completed the Storm workspace release process!", config);
 }, "runRelease");
 
 // src/cli/index.ts
 var _config = {};
 function createProgram(config) {
   _config = config;
-  _chunkLFH4CIZMcjs.writeInfo.call(void 0, "\u26A1 Running Storm Git Tools", config);
-  const root2 = _chunkLFH4CIZMcjs.findWorkspaceRootSafe.call(void 0, process.cwd());
+  _chunkSBZRK235cjs.writeInfo.call(void 0, "\u26A1 Running Storm Git Tools", config);
+  const root2 = _chunkSBZRK235cjs.findWorkspaceRootSafe.call(void 0, process.cwd());
   process.env.STORM_WORKSPACE_ROOT ??= root2;
   process.env.NX_WORKSPACE_ROOT_PATH ??= root2;
   root2 && process.chdir(root2);
@@ -85992,14 +86005,14 @@ function createProgram(config) {
 _chunkKK4YC43Scjs.__name.call(void 0, createProgram, "createProgram");
 async function commitAction({ config = "@storm-software/git-tools/commit/config.js", dryRun = false }) {
   try {
-    _chunkLFH4CIZMcjs.writeInfo.call(void 0, `\u26A1 Preparing to commit your changes. Please provide the requested details below...`, _config);
+    _chunkSBZRK235cjs.writeInfo.call(void 0, `\u26A1 Preparing to commit your changes. Please provide the requested details below...`, _config);
     await runCommit(config, dryRun);
-    _chunkLFH4CIZMcjs.writeSuccess.call(void 0, `\u{1F389} Storm Commit processing completed successfully!
+    _chunkSBZRK235cjs.writeSuccess.call(void 0, `\u{1F389} Storm Commit processing completed successfully!
 
 Note: Please run "pnpm push" to upload these changes to the remote ${_config.name ? _config.name : _config.namespace ? _config.namespace : _config.organization ? _config.organization : "Storm-Software"} Git repository at ${_config.repository}
 `, _config);
   } catch (error) {
-    _chunkLFH4CIZMcjs.writeFatal.call(void 0, `A fatal error occurred while running commit action: 
+    _chunkSBZRK235cjs.writeFatal.call(void 0, `A fatal error occurred while running commit action: 
 
 ${error.message}`, _config);
     throw new Error(error.message, {
@@ -86010,11 +86023,11 @@ ${error.message}`, _config);
 _chunkKK4YC43Scjs.__name.call(void 0, commitAction, "commitAction");
 async function readmeAction(options) {
   try {
-    _chunkLFH4CIZMcjs.writeInfo.call(void 0, "\u26A1 Formatting the workspace's README.md files", _config);
+    _chunkSBZRK235cjs.writeInfo.call(void 0, "\u26A1 Formatting the workspace's README.md files", _config);
     await runReadme(options);
-    _chunkLFH4CIZMcjs.writeSuccess.call(void 0, "Formatting of the workspace's README.md files is complete\n", _config);
+    _chunkSBZRK235cjs.writeSuccess.call(void 0, "Formatting of the workspace's README.md files is complete\n", _config);
   } catch (error) {
-    _chunkLFH4CIZMcjs.writeFatal.call(void 0, `A fatal error occurred while running README format action: 
+    _chunkSBZRK235cjs.writeFatal.call(void 0, `A fatal error occurred while running README format action: 
 
 ${error.message}`);
     throw new Error(error.message, {
@@ -86025,16 +86038,16 @@ ${error.message}`);
 _chunkKK4YC43Scjs.__name.call(void 0, readmeAction, "readmeAction");
 async function releaseAction({ project, base, head, dryRun }) {
   try {
-    _chunkLFH4CIZMcjs.writeInfo.call(void 0, "\u26A1 Running the Storm Release and Publish process on the workspace", _config);
+    _chunkSBZRK235cjs.writeInfo.call(void 0, "\u26A1 Running the Storm Release and Publish process on the workspace", _config);
     await runRelease(_config, {
       dryRun,
       project,
       base,
       head
     });
-    _chunkLFH4CIZMcjs.writeSuccess.call(void 0, "Release completed successfully!\n", _config);
+    _chunkSBZRK235cjs.writeSuccess.call(void 0, "Release completed successfully!\n", _config);
   } catch (error) {
-    _chunkLFH4CIZMcjs.writeFatal.call(void 0, `A fatal error occurred while running release action: 
+    _chunkSBZRK235cjs.writeFatal.call(void 0, `A fatal error occurred while running release action: 
 
 ${error.message} ${error.stack ? `
 
@@ -86048,15 +86061,15 @@ Stacktrace: ${error.stack}` : ""}`, _config);
 _chunkKK4YC43Scjs.__name.call(void 0, releaseAction, "releaseAction");
 async function commitLintAction({ config, message: message2, file }) {
   try {
-    _chunkLFH4CIZMcjs.writeInfo.call(void 0, `\u26A1 Linting the ${_config.repository ? _config.repository : _config.namespace ? _config.namespace : _config.name ? _config.name : _config.organization ? _config.organization : "Storm-Software"} repository's commit messages.`, _config);
+    _chunkSBZRK235cjs.writeInfo.call(void 0, `\u26A1 Linting the ${_config.repository ? _config.repository : _config.namespace ? _config.namespace : _config.name ? _config.name : _config.organization ? _config.organization : "Storm-Software"} repository's commit messages.`, _config);
     await runCommitLint(_config, {
       config,
       message: message2,
       file
     });
-    _chunkLFH4CIZMcjs.writeSuccess.call(void 0, "Linting the commit messages completed successfully!\n", _config);
+    _chunkSBZRK235cjs.writeSuccess.call(void 0, "Linting the commit messages completed successfully!\n", _config);
   } catch (error) {
-    _chunkLFH4CIZMcjs.writeFatal.call(void 0, `A fatal error occurred while linting the commit messages: 
+    _chunkSBZRK235cjs.writeFatal.call(void 0, `A fatal error occurred while linting the commit messages: 
 
 ${error.message}`, _config);
     throw new Error(error.message, {
@@ -86068,15 +86081,15 @@ _chunkKK4YC43Scjs.__name.call(void 0, commitLintAction, "commitLintAction");
 
 // bin/git.ts
 void (async () => {
-  const config = await _chunkLFH4CIZMcjs.getConfig.call(void 0, );
+  const config = await _chunkSBZRK235cjs.getConfig.call(void 0, );
   try {
-    _chunkLFH4CIZMcjs.handleProcess.call(void 0, config);
+    _chunkSBZRK235cjs.handleProcess.call(void 0, config);
     const program2 = createProgram(config);
     await program2.parseAsync(process.argv);
-    _chunkLFH4CIZMcjs.writeSuccess.call(void 0, `\u{1F389}  Git ${process.argv && process.argv.length >= 3 && process.argv[2] ? process.argv[2] : "tool"} processing completed successfully!`, config);
-    _chunkLFH4CIZMcjs.exitWithSuccess.call(void 0, config);
+    _chunkSBZRK235cjs.writeSuccess.call(void 0, `\u{1F389}  Git ${process.argv && process.argv.length >= 3 && process.argv[2] ? process.argv[2] : "tool"} processing completed successfully!`, config);
+    _chunkSBZRK235cjs.exitWithSuccess.call(void 0, config);
   } catch (error) {
-    _chunkLFH4CIZMcjs.exitWithError.call(void 0, config);
+    _chunkSBZRK235cjs.exitWithError.call(void 0, config);
     process.exit(1);
   }
 })();