@storm-software/git-tools 2.123.18 → 2.124.1

package/bin/git.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import './chunk-Q3DQKTOI.js';
 import { run } from './chunk-G3YPGVPS.js';
 import { getConfig, handleProcess, writeSuccess, exitWithSuccess, exitWithError, writeInfo, findWorkspaceRootSafe, writeFatal, getWorkspaceConfig, joinPaths, writeDebug, isVerbose, writeWarning, defu, writeTrace, STORM_DEFAULT_RELEASE_BANNER } from './chunk-VBJB46HW.js';
 import TOML from '@ltd/j-toml';
@@ -26,23 +27,23 @@ import _ from 'underscore';
 import updateSection from 'update-section';
 import { readCachedProjectGraph as readCachedProjectGraph$1, createProjectGraphAsync as createProjectGraphAsync$2, readProjectsConfigurationFromProjectGraph as readProjectsConfigurationFromProjectGraph$2, output, joinPathFragments } from '@nx/devkit';
 import axios from 'axios';
-import 'enquirer';
 import { homedir } from 'node:os';
-import { printAndFlushChanges } from 'nx/src/command-line/release/utils/print-changes';
 import { defaultCreateReleaseProvider, GithubRemoteReleaseClient } from 'nx/src/command-line/release/utils/remote-release-clients/github';
-import { noDiffInChangelogMessage, handleDuplicateGitTags, createCommitMessageValues } from 'nx/src/command-line/release/utils/shared';
 import { parse } from 'yaml';
+import chalk from 'chalk';
+import { printAndFlushChanges } from 'nx/src/command-line/release/utils/print-changes';
+import { createGitTagValues, handleDuplicateGitTags, createCommitMessageValues, isPrerelease, shouldPreferDockerVersionForReleaseGroup, ReleaseVersion, noDiffInChangelogMessage } from 'nx/src/command-line/release/utils/shared';
+import { interpolate } from 'nx/src/tasks-runner/utils';
 import { resolveConfig, format } from 'prettier';
+import { execCommand } from 'nx/src/command-line/release/utils/exec-command.js';
+import { getCommitHash, getLatestGitTagForPattern, getFirstGitCommit, gitPush, getGitDiff, parseCommits, gitAdd } from 'nx/src/command-line/release/utils/git';
+import { prerelease, major } from 'semver';
 import { ReleaseClient } from 'nx/release';
-import { createAPI } from 'nx/src/command-line/release/changelog';
-import { getCommitHash, gitPush, gitAdd } from 'nx/src/command-line/release/utils/git';
 import { readNxJson } from 'nx/src/config/nx-json';
 import { FsTree } from 'nx/src/generators/tree';
-import { execCommand } from 'nx/src/command-line/release/utils/exec-command.js';
-import { interpolate } from 'nx/src/tasks-runner/utils';
+import { createFileMapUsingProjectGraph } from 'nx/src/project-graph/file-map-utils';
 import DefaultChangelogRenderer from 'nx/release/changelog-renderer';
 import { DEFAULT_CONVENTIONAL_COMMITS_CONFIG } from 'nx/src/command-line/release/config/conventional-commits';
-import { major } from 'semver';
 
 function parseCargoToml(cargoString) {
   if (!cargoString) {
@@ -1373,6 +1374,15 @@ function findFileName(filePath) {
 function findFilePath(filePath) {
   return filePath.replace(findFileName(filePath), "");
 }
+function createFileToProjectMap(projectFileMap) {
+  const fileToProjectMap = {};
+  for (const [projectName, projectFiles] of Object.entries(projectFileMap)) {
+    for (const file of projectFiles) {
+      fileToProjectMap[file.file] = projectName;
+    }
+  }
+  return fileToProjectMap;
+}
 var start = "<!-- START doctoc -->\n<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->";
 var end = "<!-- END doctoc -->";
 var skipTag = "<!-- DOCTOC SKIP -->";
@@ -2381,7 +2391,7 @@ function generateChangelogTitle(version, project, workspaceConfig) {
   if (!workspaceConfig?.name || !project) {
     return version;
   }
-  return `[${version}](https://github.com/${typeof workspaceConfig.organization === "string" ? workspaceConfig.organization : workspaceConfig.organization?.name}/${workspaceConfig.name}/releases/tag/${project}%40${version}) (${(/* @__PURE__ */ new Date()).getMonth() + 1}/${(/* @__PURE__ */ new Date()).getDate()}/${(/* @__PURE__ */ new Date()).getFullYear()})`;
+  return `[${version}](https://github.com/${typeof workspaceConfig.organization === "string" ? workspaceConfig.organization : workspaceConfig.organization?.name}/${workspaceConfig.name}/releases/tag/${project}%40${version}) (${(/* @__PURE__ */ new Date()).getMonth() + 1 < 10 ? `0${(/* @__PURE__ */ new Date()).getMonth() + 1}` : (/* @__PURE__ */ new Date()).getMonth() + 1}/${(/* @__PURE__ */ new Date()).getDate() < 10 ? `0${(/* @__PURE__ */ new Date()).getDate()}` : (/* @__PURE__ */ new Date()).getDate()}/${(/* @__PURE__ */ new Date()).getFullYear()})`;
 }
 function parseChangelogMarkdown(contents) {
   const CHANGELOG_RELEASE_HEAD_RE = new RegExp(
@@ -2410,11 +2420,321 @@ function parseChangelogMarkdown(contents) {
     releases
   };
 }
+function filterHiddenChanges(changes, conventionalCommitsConfig) {
+  return changes.filter((change) => {
+    const type = change.type;
+    const typeConfig = conventionalCommitsConfig.types[type];
+    if (!typeConfig) {
+      return false;
+    }
+    return !typeConfig.changelog.hidden;
+  });
+}
+async function generateChangelogForProjects({
+  tree,
+  args,
+  changes,
+  projectGraph,
+  projectsVersionData,
+  releaseGroup,
+  projects,
+  releaseConfig,
+  projectToAdditionalDependencyBumps,
+  workspaceConfig,
+  ChangelogRendererClass
+}) {
+  const config5 = releaseGroup.changelog;
+  if (config5 === false) {
+    return;
+  }
+  const dryRun = !!args.dryRun;
+  const repoData = getGitHubRepoData(args.gitRemote, "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.`
+    );
+  }
+  const remoteReleaseClient = new StormGithubRemoteReleaseClient(
+    repoData,
+    {
+      provider: "github",
+      hostname: repoData.hostname,
+      apiBaseUrl: repoData.apiBaseUrl
+    },
+    await resolveTokenData(repoData.hostname),
+    workspaceConfig
+  );
+  const projectChangelogs = {};
+  for (const project of projects) {
+    let interpolatedTreePath = config5.file || "";
+    if (interpolatedTreePath) {
+      interpolatedTreePath = interpolate(interpolatedTreePath, {
+        projectName: project.name,
+        projectRoot: project.data.root,
+        workspaceRoot: ""
+        // within the tree, workspaceRoot is the root
+      });
+    }
+    if (!projectsVersionData[project.name] || projectsVersionData[project.name]?.newVersion === null && !projectsVersionData[project.name]?.dockerVersion) {
+      continue;
+    }
+    const preferDockerVersion = shouldPreferDockerVersionForReleaseGroup(releaseGroup);
+    const releaseVersion = new ReleaseVersion({
+      version: (preferDockerVersion === true || preferDockerVersion === "both") && projectsVersionData[project.name]?.dockerVersion ? projectsVersionData[project.name]?.dockerVersion : projectsVersionData[project.name]?.newVersion,
+      releaseTagPattern: releaseGroup.releaseTag.pattern,
+      projectName: project.name
+    });
+    if (interpolatedTreePath) {
+      const prefix = dryRun ? "Previewing" : "Generating";
+      output.log({
+        title: `${prefix} an entry in ${interpolatedTreePath} for ${chalk.white(
+          releaseVersion.gitTag
+        )}`
+      });
+    }
+    const changelogRenderer = new ChangelogRendererClass({
+      changes,
+      changelogEntryVersion: releaseVersion.rawVersion,
+      project: project.name,
+      entryWhenNoChanges: typeof config5.entryWhenNoChanges === "string" ? interpolate(config5.entryWhenNoChanges, {
+        projectName: project.name,
+        projectRoot: project.data.root,
+        workspaceRoot: ""
+        // within the tree, workspaceRoot is the root
+      }) : false,
+      changelogRenderOptions: config5.renderOptions,
+      isVersionPlans: !!releaseGroup.versionPlans,
+      conventionalCommitsConfig: releaseConfig.conventionalCommits,
+      dependencyBumps: projectToAdditionalDependencyBumps.get(project.name),
+      remoteReleaseClient,
+      workspaceConfig
+    });
+    const contents = await changelogRenderer.render();
+    const postGitTask = args.createRelease !== false && config5.createRelease ? remoteReleaseClient.createPostGitTask(
+      releaseVersion,
+      contents,
+      dryRun
+    ) : null;
+    projectChangelogs[project.name] = {
+      releaseVersion,
+      contents,
+      postGitTask
+    };
+  }
+  for (const [projectName, projectChangelog] of Object.entries(
+    projectChangelogs
+  )) {
+    if (!projectGraph.nodes[projectName]?.data.root) {
+      writeWarning(
+        `A changelog was generated for ${projectName}, but it could not be found in the project graph. Skipping writing changelog file.`,
+        workspaceConfig
+      );
+    } else if (projectChangelog.contents) {
+      const filePath = joinPaths(
+        projectGraph.nodes[projectName].data.root,
+        "CHANGELOG.md"
+      );
+      let currentContent;
+      if (existsSync$1(filePath)) {
+        currentContent = await readFile$1(filePath, "utf8");
+      }
+      writeDebug(
+        `\u270D\uFE0F  Writing changelog for project ${projectName} to ${filePath}`,
+        workspaceConfig
+      );
+      const content = await generateChangelogContent(
+        projectChangelog.releaseVersion,
+        filePath,
+        projectChangelog.contents,
+        currentContent,
+        projectName,
+        workspaceConfig
+      );
+      tree.write(filePath, content);
+      printAndFlushChanges(
+        tree,
+        !!args.dryRun,
+        3,
+        false,
+        noDiffInChangelogMessage,
+        // Only print the change for the current changelog file at this point
+        (f) => f.path === filePath
+      );
+    }
+  }
+  return projectChangelogs;
+}
+async function getCommits(fromSHA, toSHA) {
+  const rawCommits = await getGitDiff(fromSHA, toSHA);
+  return parseCommits(rawCommits);
+}
+async function filterProjectCommits({
+  fromSHA,
+  toSHA,
+  projectPath
+}) {
+  const allCommits = await getCommits(fromSHA, toSHA);
+  return allCommits.filter(
+    (c) => c.affectedFiles.find((f) => f.startsWith(projectPath))
+  );
+}
+function commitChangesNonProjectFiles(commit, nonProjectFiles) {
+  return nonProjectFiles.some(
+    (fileData) => commit.affectedFiles.includes(fileData.file)
+  );
+}
+function getProjectsAffectedByCommit(commit, fileToProjectMap) {
+  const affectedProjects = /* @__PURE__ */ new Set();
+  for (const file of commit.affectedFiles) {
+    affectedProjects.add(fileToProjectMap[file]);
+  }
+  return Array.from(affectedProjects);
+}
+function extractPreid(version) {
+  if (!isPrerelease(version)) {
+    return void 0;
+  }
+  const preid = prerelease(version)?.[0];
+  if (typeof preid === "string") {
+    if (preid.trim() === "") {
+      return void 0;
+    }
+    return preid;
+  }
+  if (typeof preid === "number") {
+    return preid.toString();
+  }
+  return void 0;
+}
+async function gitTag({
+  tag,
+  message,
+  additionalArgs,
+  dryRun,
+  verbose,
+  logFn
+}) {
+  logFn = logFn || console.log;
+  const commandArgs = [
+    "tag",
+    // Create an annotated tag (recommended for releases here: https://git-scm.com/docs/git-tag)
+    "--annotate",
+    "--sign",
+    tag,
+    "--message",
+    message || tag
+  ];
+  if (additionalArgs) {
+    if (Array.isArray(additionalArgs)) {
+      commandArgs.push(...additionalArgs);
+    } else {
+      commandArgs.push(...additionalArgs.split(" "));
+    }
+  }
+  if (verbose) {
+    logFn(
+      dryRun ? `Would tag the current commit in git with the following command, but --dry-run was set:` : `Tagging the current commit in git with the following command:`
+    );
+    logFn(`git ${commandArgs.join(" ")}`);
+  }
+  if (dryRun) {
+    return "";
+  }
+  try {
+    return await execCommand("git", commandArgs);
+  } catch (err) {
+    throw new Error(`Unexpected error when creating tag ${tag}:
+
+${err}`);
+  }
+}
+async function gitCommit({
+  messages,
+  additionalArgs,
+  dryRun,
+  verbose,
+  logFn
+}) {
+  logFn = logFn || console.log;
+  const commandArgs = ["commit", "-S"];
+  for (const message of messages) {
+    commandArgs.push("--message", message);
+  }
+  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 execCommand("git", ["diff-index", "--quiet", "HEAD", "--cached"]);
+  } catch {
+    hasStagedFiles = true;
+  }
+  if (!hasStagedFiles) {
+    logFn("\nNo staged files found. Skipping commit.");
+    return;
+  }
+  return execCommand("git", commandArgs);
+}
+async function commitChanges({
+  changedFiles,
+  deletedFiles,
+  isDryRun,
+  isVerbose: isVerbose2,
+  gitCommitMessages,
+  gitCommitArgs,
+  logFn
+}) {
+  logFn = logFn || console.log;
+  if (!changedFiles?.length && !deletedFiles?.length) {
+    throw new Error("Error: No changed files to commit");
+  }
+  logFn(`Committing changes with git`);
+  await gitAdd({
+    changedFiles,
+    deletedFiles,
+    dryRun: isDryRun,
+    verbose: isVerbose2
+  });
+  if (isVerbose2) {
+    console.log("");
+  }
+  await gitCommit({
+    messages: gitCommitMessages || [],
+    additionalArgs: gitCommitArgs,
+    dryRun: isDryRun,
+    verbose: isVerbose2
+  });
+}
+
+// src/utilities/omit.ts
+function omit(obj, keys) {
+  const result = { ...obj };
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (key && key in result) {
+      delete result[key];
+    }
+  }
+  return result;
+}
 
 // src/release/github.ts
 var StormGithubRemoteReleaseClient = class extends GithubRemoteReleaseClient {
-  #remoteRepoData;
-  #workspaceConfig;
+  repoData;
+  workspaceConfig;
   /**
    * Creates an instance of {@link StormGithubRemoteReleaseClient}.
    *
@@ -2423,63 +2743,71 @@ var StormGithubRemoteReleaseClient = class extends GithubRemoteReleaseClient {
    * @param tokenData - Token data for authentication
    * @param workspaceConfig - The Storm workspace configuration object, which is loaded from the storm-workspace.json file.
    */
-  constructor(remoteRepoData, createReleaseConfig, tokenData, workspaceConfig) {
-    super(remoteRepoData, createReleaseConfig, tokenData);
-    this.#remoteRepoData = remoteRepoData;
-    this.#workspaceConfig = workspaceConfig;
+  constructor(repoData, createReleaseConfig, tokenData, workspaceConfig) {
+    super(repoData, createReleaseConfig, tokenData);
+    this.repoData = repoData;
+    this.workspaceConfig = workspaceConfig;
   }
   createPostGitTask(releaseVersion, changelogContents, dryRun) {
     return async (latestCommit) => {
-      if (!this.#workspaceConfig) {
-        this.#workspaceConfig = await getWorkspaceConfig();
-      }
       output.logSingleLine(`Creating GitHub Release`);
-      const name = releaseVersion.gitTag.includes("@") ? releaseVersion.gitTag.replace(new RegExp(`^@${this.#workspaceConfig.name}/`), "").replace(/@.*$/, "") : releaseVersion.gitTag;
       await this.createOrUpdateRelease(
         releaseVersion,
-        `![${(typeof this.#workspaceConfig.release.banner === "string" ? this.#workspaceConfig.organization ? titleCase(
-          typeof this.#workspaceConfig.organization === "string" ? this.#workspaceConfig.organization : this.#workspaceConfig.organization.name
-        ) : void 0 : this.#workspaceConfig.release.banner.alt) || "Release banner header"}](${typeof this.#workspaceConfig.release.banner === "string" ? this.#workspaceConfig.release.banner : this.#workspaceConfig.release.banner?.url})
-${this.#workspaceConfig.release.header || ""}
+        changelogContents,
+        latestCommit,
+        { dryRun }
+      );
+    };
+  }
+  async createOrUpdateRelease(releaseVersion, changelogContents, latestCommit, { dryRun }) {
+    if (!this.workspaceConfig) {
+      this.workspaceConfig = await getWorkspaceConfig();
+    }
+    const name = releaseVersion.gitTag.includes("@") ? releaseVersion.gitTag.replace(new RegExp(`^@${this.workspaceConfig.name}/`), "").replace(/@.*$/, "") : releaseVersion.gitTag;
+    return super.createOrUpdateRelease(
+      releaseVersion,
+      `![${(typeof this.workspaceConfig.release.banner === "string" ? this.workspaceConfig.organization ? titleCase(
+        typeof this.workspaceConfig.organization === "string" ? this.workspaceConfig.organization : this.workspaceConfig.organization.name
+      ) : void 0 : this.workspaceConfig.release.banner.alt) || "Release banner header"}](${typeof this.workspaceConfig.release.banner === "string" ? this.workspaceConfig.release.banner : this.workspaceConfig.release.banner?.url})
+${this.workspaceConfig.release.header || ""}
 
 # ${name ? `${titleCase(name)} ` : ""}v${releaseVersion.rawVersion}
 
-We at [${this.#workspaceConfig.organization ? titleCase(
-          typeof this.#workspaceConfig.organization === "string" ? this.#workspaceConfig.organization : this.#workspaceConfig.organization.name
-        ) : ""}](${this.#workspaceConfig.homepage}) are very excited to announce the v${releaseVersion.rawVersion} release of the ${name ? this.#workspaceConfig.name ? `${titleCase(this.#workspaceConfig.name)} - ${titleCase(name)}` : titleCase(name) : this.#workspaceConfig.name ? titleCase(this.#workspaceConfig.name) : "Storm Software"} project! \u{1F680}
+We at [${this.workspaceConfig.organization ? titleCase(
+        typeof this.workspaceConfig.organization === "string" ? this.workspaceConfig.organization : this.workspaceConfig.organization.name
+      ) : ""}](${this.workspaceConfig.homepage}) are very excited to announce the v${releaseVersion.rawVersion} release of the ${name ? this.workspaceConfig.name ? `${titleCase(this.workspaceConfig.name)} - ${titleCase(name)}` : titleCase(name) : this.workspaceConfig.name ? titleCase(this.workspaceConfig.name) : "Storm Software"} project! \u{1F680}
 
-These changes are released under the ${this.#workspaceConfig.license.includes("license") ? this.#workspaceConfig.license : `${this.#workspaceConfig.license} license`}. You can find more details on [our licensing page](${this.#workspaceConfig.licensing}). You can find guides, API references, and other documentation around this release (and much more) on [our documentation site](${this.#workspaceConfig.docs}).
+These changes are released under the ${this.workspaceConfig.license.includes("license") ? this.workspaceConfig.license : `${this.workspaceConfig.license} license`}. You can find more details on [our licensing page](${this.workspaceConfig.licensing}). You can find guides, API references, and other documentation around this release (and much more) on [our documentation site](${this.workspaceConfig.docs}).
 
-If you have any questions or comments, feel free to reach out to the team on [Discord](${this.#workspaceConfig.socials.discord}) or [our contact page](${this.#workspaceConfig.contact}). Please help us spread the word by giving [this repository](https://github.com/${typeof this.#workspaceConfig.organization === "string" ? this.#workspaceConfig.organization : this.#workspaceConfig.organization?.name}/${this.#workspaceConfig.name}) a star \u2B50 on GitHub or [posting on X (Twitter)](https://x.com/intent/tweet?text=Check%20out%20the%20latest%20@${this.#workspaceConfig.socials.twitter}%20release%20${name ? `${titleCase(name)?.replaceAll(" ", "%20")}%20` : ""}v${releaseVersion.rawVersion}%20%F0%9F%9A%80%0D%0A%0D%0Ahttps://github.com/${typeof this.#workspaceConfig.organization === "string" ? this.#workspaceConfig.organization : this.#workspaceConfig.organization?.name}/${this.#workspaceConfig.name}/releases/tag/${releaseVersion.gitTag}) about this release!
+If you have any questions or comments, feel free to reach out to the team on [Discord](${this.workspaceConfig.socials.discord}) or [our contact page](${this.workspaceConfig.contact}). Please help us spread the word by giving [this repository](https://github.com/${typeof this.workspaceConfig.organization === "string" ? this.workspaceConfig.organization : this.workspaceConfig.organization?.name}/${this.workspaceConfig.name}) a star \u2B50 on GitHub or [posting on X (Twitter)](https://x.com/intent/tweet?text=Check%20out%20the%20latest%20@${this.workspaceConfig.socials.twitter}%20release%20${name ? `${titleCase(name)?.replaceAll(" ", "%20")}%20` : ""}v${releaseVersion.rawVersion}%20%F0%9F%9A%80%0D%0A%0D%0Ahttps://github.com/${typeof this.workspaceConfig.organization === "string" ? this.workspaceConfig.organization : this.workspaceConfig.organization?.name}/${this.workspaceConfig.name}/releases/tag/${releaseVersion.gitTag}) about this release!
 
 ## Release Notes
 
 ${changelogContents.replaceAll(
-          `## ${generateChangelogTitle(
-            releaseVersion.rawVersion,
-            name,
-            this.#workspaceConfig
-          )}`,
-          ""
-        ).replaceAll(
-          `# ${generateChangelogTitle(releaseVersion.rawVersion, name, this.#workspaceConfig)}`,
-          ""
-        )}
+        `## ${generateChangelogTitle(
+          releaseVersion.rawVersion,
+          name,
+          this.workspaceConfig
+        )}`,
+        ""
+      ).replaceAll(
+        `# ${generateChangelogTitle(releaseVersion.rawVersion, name, this.workspaceConfig)}`,
+        ""
+      )}
 
 ---
 
-${this.#workspaceConfig.release.footer}
+${this.workspaceConfig.release.footer}
 `,
-        latestCommit,
-        { dryRun }
-      );
-    };
+      latestCommit,
+      { dryRun }
+    );
   }
   /**
    * Get remote repository data, attempting to resolve it if not already set.
    */
   getRemoteRepoData() {
-    if (!this.#remoteRepoData) {
+    if (!this.repoData) {
       let githubRepoData = super.getRemoteRepoData();
       if (!githubRepoData) {
         githubRepoData = getGitHubRepoData();
@@ -2493,9 +2821,9 @@ ${this.#workspaceConfig.release.footer}
           process.exit(1);
         }
       }
-      this.#remoteRepoData = githubRepoData;
+      this.repoData = githubRepoData;
     }
-    return this.#remoteRepoData;
+    return this.repoData;
   }
 };
 function getGitHubRepoData(remoteName = "origin", createReleaseConfig = "github") {
@@ -2580,24 +2908,6 @@ async function makeGithubRequest(config5, url, opts = {}) {
     }
   });
 }
-async function createGithubRemoteReleaseClient(workspaceConfig, remoteName = "origin") {
-  const repoData = getGitHubRepoData(remoteName, "github");
-  if (!repoData) {
-    throw new Error(
-      `Unable to create a remote release client because the GitHub repo slug could not be determined. Please ensure you have a valid GitHub remote configured.`
-    );
-  }
-  return new StormGithubRemoteReleaseClient(
-    repoData,
-    {
-      provider: "github",
-      hostname: repoData.hostname,
-      apiBaseUrl: repoData.apiBaseUrl
-    },
-    await resolveTokenData(repoData.hostname),
-    workspaceConfig
-  );
-}
 async function isUserAnOrganizationMember(userId, config5, remoteName = "origin") {
   try {
     const repoData = getGitHubRepoData(remoteName, "github");
@@ -2630,164 +2940,6 @@ async function isUserAnOrganizationMember(userId, config5, remoteName = "origin"
     return false;
   }
 }
-function createGitTagValues(releaseGroups, releaseGroupToFilteredProjects, versionData) {
-  const tags = [];
-  for (const releaseGroup of releaseGroups) {
-    const releaseGroupProjectNames = Array.from(
-      releaseGroupToFilteredProjects.get(releaseGroup) ?? []
-    );
-    if (releaseGroup.projectsRelationship === "independent") {
-      for (const project of releaseGroupProjectNames) {
-        const projectVersionData = versionData[project];
-        if (projectVersionData?.newVersion) {
-          tags.push(
-            interpolate(releaseGroup.releaseTagPattern, {
-              version: projectVersionData.newVersion,
-              projectName: project
-            })
-          );
-        }
-      }
-      continue;
-    }
-    if (releaseGroupProjectNames.length > 0 && releaseGroupProjectNames[0]) {
-      const projectVersionData = versionData[releaseGroupProjectNames[0]];
-      if (projectVersionData?.newVersion) {
-        tags.push(
-          interpolate(releaseGroup.releaseTagPattern, {
-            version: projectVersionData.newVersion,
-            releaseGroupName: releaseGroup.name
-          })
-        );
-      }
-    }
-  }
-  return tags;
-}
-async function gitTag({
-  tag,
-  message,
-  additionalArgs,
-  dryRun,
-  verbose,
-  logFn
-}) {
-  logFn = logFn || console.log;
-  const commandArgs = [
-    "tag",
-    // Create an annotated tag (recommended for releases here: https://git-scm.com/docs/git-tag)
-    "--annotate",
-    "--sign",
-    tag,
-    "--message",
-    message || tag
-  ];
-  if (additionalArgs) {
-    if (Array.isArray(additionalArgs)) {
-      commandArgs.push(...additionalArgs);
-    } else {
-      commandArgs.push(...additionalArgs.split(" "));
-    }
-  }
-  if (verbose) {
-    logFn(
-      dryRun ? `Would tag the current commit in git with the following command, but --dry-run was set:` : `Tagging the current commit in git with the following command:`
-    );
-    logFn(`git ${commandArgs.join(" ")}`);
-  }
-  if (dryRun) {
-    return "";
-  }
-  try {
-    return await execCommand("git", commandArgs);
-  } catch (err) {
-    throw new Error(`Unexpected error when creating tag ${tag}:
-
-${err}`);
-  }
-}
-async function gitCommit({
-  messages,
-  additionalArgs,
-  dryRun,
-  verbose,
-  logFn
-}) {
-  logFn = logFn || console.log;
-  const commandArgs = ["commit", "-S"];
-  for (const message of messages) {
-    commandArgs.push("--message", message);
-  }
-  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 execCommand("git", ["diff-index", "--quiet", "HEAD", "--cached"]);
-  } catch {
-    hasStagedFiles = true;
-  }
-  if (!hasStagedFiles) {
-    logFn("\nNo staged files found. Skipping commit.");
-    return;
-  }
-  return execCommand("git", commandArgs);
-}
-async function commitChanges({
-  changedFiles,
-  deletedFiles,
-  isDryRun,
-  isVerbose: isVerbose2,
-  gitCommitMessages,
-  gitCommitArgs,
-  logFn
-}) {
-  logFn = logFn || console.log;
-  if (!changedFiles?.length && !deletedFiles?.length) {
-    throw new Error("Error: No changed files to commit");
-  }
-  logFn(`Committing changes with git`);
-  await gitAdd({
-    changedFiles,
-    deletedFiles,
-    dryRun: isDryRun,
-    verbose: isVerbose2
-  });
-  if (isVerbose2) {
-    console.log("");
-  }
-  await gitCommit({
-    messages: gitCommitMessages || [],
-    additionalArgs: gitCommitArgs,
-    dryRun: isDryRun,
-    verbose: isVerbose2
-  });
-}
-
-// src/utilities/omit.ts
-function omit(obj, keys) {
-  const result = { ...obj };
-  for (let i = 0; i < keys.length; i++) {
-    const key = keys[i];
-    if (key && key in result) {
-      delete result[key];
-    }
-  }
-  return result;
-}
 var StormChangelogRenderer = class extends DefaultChangelogRenderer {
   /**
    * The Storm workspace configuration object, which is loaded from the storm-workspace.json file.
@@ -2805,15 +2957,13 @@ var StormChangelogRenderer = class extends DefaultChangelogRenderer {
       ...config5
     };
     super(resolvedConfig);
-    this.workspaceConfig = config5.changelogRenderOptions.workspaceConfig;
+    this.workspaceConfig = config5.workspaceConfig;
+    this.remoteReleaseClient = resolvedConfig.remoteReleaseClient;
   }
   async render() {
     if (!this.workspaceConfig) {
       this.workspaceConfig = await getWorkspaceConfig();
     }
-    this.remoteReleaseClient = await createGithubRemoteReleaseClient(
-      this.workspaceConfig
-    );
     return super.render();
   }
   preprocessChanges() {
@@ -3062,8 +3212,6 @@ var DEFAULT_RELEASE_CONFIG = {
   },
   releaseTag: { pattern: DEFAULT_RELEASE_TAG_PATTERN }
 };
-
-// src/release/release-client.ts
 function getReleaseGroupConfig(releaseConfig, workspaceConfig) {
   return !releaseConfig?.groups || Object.keys(releaseConfig.groups).length === 0 ? {} : Object.fromEntries(
     Object.entries(releaseConfig.groups).map(([name, group]) => {
@@ -3101,6 +3249,8 @@ function getReleaseGroupConfig(releaseConfig, workspaceConfig) {
     })
   );
 }
+
+// src/release/release-client.ts
 var StormReleaseClient = class _StormReleaseClient extends ReleaseClient {
   static async create(releaseConfig = {}, ignoreNxJsonConfig = false, workspaceConfig) {
     if (!workspaceConfig) {
@@ -3127,7 +3277,6 @@ var StormReleaseClient = class _StormReleaseClient extends ReleaseClient {
       workspaceConfig
     );
   }
-  #releaseChangelog;
   /**
    * The release configuration used by this release client.
    */
@@ -3173,7 +3322,10 @@ var StormReleaseClient = class _StormReleaseClient extends ReleaseClient {
         groups: getReleaseGroupConfig(releaseConfig, workspaceConfig)
       },
       {
-        groups: getReleaseGroupConfig(nxJson.release ?? {}, workspaceConfig)
+        groups: getReleaseGroupConfig(
+          nxJson.release ?? {},
+          workspaceConfig
+        )
       },
       omit(releaseConfig, ["groups"]),
       nxJson.release ? omit(nxJson.release, ["groups"]) : {},
@@ -3189,89 +3341,265 @@ var StormReleaseClient = class _StormReleaseClient extends ReleaseClient {
     this.config = config5;
     this.workspaceConfig = workspaceConfig;
     this.tree = new FsTree(workspaceConfig.workspaceRoot, false);
-    this.#releaseChangelog = createAPI(config5, true);
     this.projectConfigurations = readProjectsConfigurationFromProjectGraph$2(projectGraph);
   }
   releaseChangelog = async (options) => {
-    const result = await this.#releaseChangelog({
-      ...options,
-      gitCommit: false,
-      gitTag: false
-    });
-    if (result.projectChangelogs) {
-      await Promise.all(
-        Object.entries(result.projectChangelogs).map(
-          async ([project, changelog]) => {
-            if (!this.projectGraph.nodes[project]?.data.root) {
-              writeWarning(
-                `A changelog was generated for ${project}, but it could not be found in the project graph. Skipping writing changelog file.`,
-                this.workspaceConfig
-              );
-            } else if (changelog.contents) {
-              const filePath = joinPaths(
-                this.projectGraph.nodes[project].data.root,
-                "CHANGELOG.md"
+    const to = options.to || "HEAD";
+    const toSHA = await getCommitHash(to);
+    const postGitTasks = [];
+    let projectChangelogs = {};
+    const projectsPreid = Object.fromEntries(
+      Object.entries(options.versionData).map(([projectName, v]) => [
+        projectName,
+        v.newVersion ? extractPreid(v.newVersion) : void 0
+      ])
+    );
+    const projectToAdditionalDependencyBumps = /* @__PURE__ */ new Map();
+    for (const releaseGroup of options.releaseGraph.releaseGroups) {
+      if (releaseGroup.projectsRelationship !== "independent") {
+        continue;
+      }
+      for (const project of releaseGroup.projects) {
+        if (!options.versionData[project] || options.versionData[project].newVersion === null) {
+          continue;
+        }
+        const dependentProjects = (options.versionData[project].dependentProjects || []).map((dep) => {
+          return {
+            dependencyName: dep.source,
+            newVersion: options.versionData[dep.source]?.newVersion ?? null
+          };
+        }).filter((b) => b.newVersion !== null);
+        for (const dependent of dependentProjects) {
+          const additionalDependencyBumpsForProject = projectToAdditionalDependencyBumps.has(dependent.dependencyName) ? projectToAdditionalDependencyBumps.get(dependent.dependencyName) : [];
+          additionalDependencyBumpsForProject.push({
+            dependencyName: project,
+            newVersion: options.versionData[project].newVersion
+          });
+          projectToAdditionalDependencyBumps.set(
+            dependent.dependencyName,
+            additionalDependencyBumpsForProject
+          );
+        }
+      }
+    }
+    const allProjectChangelogs = {};
+    for (const releaseGroup of options.releaseGraph.releaseGroups) {
+      const config5 = releaseGroup.changelog;
+      if (config5 === false) {
+        continue;
+      }
+      if (!options.releaseGraph.releaseGroupToFilteredProjects.has(releaseGroup)) {
+        throw new Error(
+          `No filtered projects found for release group ${releaseGroup.name}`
+        );
+      }
+      const projects = options.projects?.length ? (
+        // If the user has passed a list of projects, we need to use the filtered list of projects within the release group, plus any dependents
+        Array.from(
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          options.releaseGraph.releaseGroupToFilteredProjects.get(
+            releaseGroup
+          )
+        ).flatMap((project) => {
+          return [
+            project,
+            ...options.versionData[project]?.dependentProjects.map(
+              (dep) => dep.source
+            ) || []
+          ];
+        })
+      ) : (
+        // Otherwise, we use the full list of projects within the release group
+        releaseGroup.projects
+      );
+      const projectNodes = projects.map((name) => this.projectGraph.nodes[name]);
+      if (releaseGroup.projectsRelationship === "independent") {
+        for (const project of projectNodes) {
+          let changes = null;
+          let fromRef = options.from || (await getLatestGitTagForPattern(
+            releaseGroup.releaseTag.pattern,
+            {
+              projectName: project.name,
+              releaseGroupName: releaseGroup.name
+            },
+            {
+              checkAllBranchesWhen: releaseGroup.releaseTag.checkAllBranchesWhen,
+              preid: projectsPreid[project.name],
+              requireSemver: releaseGroup.releaseTag.requireSemver,
+              strictPreid: releaseGroup.releaseTag.strictPreid
+            }
+          ))?.tag;
+          let commits = void 0;
+          if (!fromRef) {
+            const firstCommit = await getFirstGitCommit();
+            commits = await filterProjectCommits({
+              fromSHA: firstCommit,
+              toSHA,
+              projectPath: project.data.root
+            });
+            fromRef = commits[0]?.shortHash;
+            if (options.verbose) {
+              console.log(
+                `Determined --from ref for ${project.name} from the first commit in which it exists: ${fromRef}`
               );
-              let currentContent;
-              if (existsSync$1(filePath)) {
-                currentContent = await readFile$1(filePath, "utf8");
+            }
+          }
+          if (!fromRef && !commits) {
+            throw new Error(
+              `Unable to determine the previous git tag. If this is the first release of your workspace, use the --first-release option or set the "release.changelog.automaticFromRef" config property in nx.json to generate a changelog from the first commit. Otherwise, be sure to configure the "release.releaseTag.pattern" property in nx.json to match the structure of your repository's git tags.`
+            );
+          }
+          if (!commits) {
+            commits = await filterProjectCommits({
+              fromSHA: fromRef,
+              toSHA,
+              projectPath: project.data.root
+            });
+          }
+          const { fileMap } = await createFileMapUsingProjectGraph(
+            this.projectGraph
+          );
+          const fileToProjectMap = createFileToProjectMap(
+            fileMap.projectFileMap
+          );
+          changes = filterHiddenChanges(
+            commits.map((c) => ({
+              type: c.type,
+              scope: c.scope,
+              description: c.description,
+              body: c.body,
+              isBreaking: c.isBreaking,
+              githubReferences: c.references,
+              authors: c.authors,
+              shortHash: c.shortHash,
+              revertedHashes: c.revertedHashes,
+              affectedProjects: commitChangesNonProjectFiles(
+                c,
+                fileMap.nonProjectFiles
+              ) ? "*" : getProjectsAffectedByCommit(c, fileToProjectMap)
+            })),
+            this.config.conventionalCommits
+          );
+          writeDebug(
+            `Running changelog generation for the ${releaseGroup.name} release group`,
+            this.workspaceConfig
+          );
+          projectChangelogs = await generateChangelogForProjects({
+            tree: this.tree,
+            args: options,
+            changes,
+            projectGraph: this.projectGraph,
+            projectsVersionData: options.versionData,
+            releaseGroup,
+            projects: [project],
+            releaseConfig: this.config,
+            projectToAdditionalDependencyBumps,
+            workspaceConfig: this.workspaceConfig,
+            ChangelogRendererClass: StormChangelogRenderer
+          });
+          if (projectChangelogs) {
+            for (const [projectName, projectChangelog] of Object.entries(
+              projectChangelogs
+            )) {
+              if (projectChangelog.postGitTask) {
+                postGitTasks.push(projectChangelog.postGitTask);
               }
-              writeDebug(
-                `\u270D\uFE0F  Writing changelog for project ${project} to ${filePath}`,
-                this.workspaceConfig
-              );
-              const content = await generateChangelogContent(
-                changelog.releaseVersion,
-                filePath,
-                changelog.contents,
-                currentContent,
-                project,
-                this.workspaceConfig
-              );
-              this.tree.write(filePath, content);
-              printAndFlushChanges(
-                this.tree,
-                !!options.dryRun,
-                3,
-                false,
-                noDiffInChangelogMessage,
-                // Only print the change for the current changelog file at this point
-                (f) => f.path === filePath
-              );
+              allProjectChangelogs[projectName] = projectChangelog;
             }
           }
-        )
-      );
-      this.applyChangesAndExit(options, result);
-    }
-    return result;
-  };
-  checkChangelogFilesEnabled() {
-    if (this.config.changelog?.workspaceChangelog && (this.config.changelog?.workspaceChangelog === true || this.config.changelog?.workspaceChangelog.file)) {
-      return true;
-    }
-    for (const releaseGroup of Object.values(this.config.groups)) {
-      if (releaseGroup.changelog && releaseGroup.changelog !== true && releaseGroup.changelog.file) {
-        return true;
+        }
+      } else {
+        let changes = [];
+        let fromRef = options.from || (await getLatestGitTagForPattern(
+          releaseGroup.releaseTag.pattern,
+          {},
+          {
+            checkAllBranchesWhen: releaseGroup.releaseTag.checkAllBranchesWhen,
+            preid: Object.keys(projectsPreid)[0] ? projectsPreid?.[Object.keys(projectsPreid)[0]] : void 0,
+            requireSemver: releaseGroup.releaseTag.requireSemver,
+            strictPreid: releaseGroup.releaseTag.strictPreid
+          }
+        ))?.tag;
+        if (!fromRef) {
+          fromRef = await getFirstGitCommit();
+          if (options.verbose) {
+            console.log(
+              `Determined release group --from ref from the first commit in the workspace: ${fromRef}`
+            );
+          }
+        }
+        const fromSHA = await getCommitHash(fromRef);
+        const { fileMap } = await createFileMapUsingProjectGraph(
+          this.projectGraph
+        );
+        const fileToProjectMap = createFileToProjectMap(fileMap.projectFileMap);
+        changes = filterHiddenChanges(
+          (await getCommits(fromSHA, toSHA)).map((c) => ({
+            type: c.type,
+            scope: c.scope,
+            description: c.description,
+            body: c.body,
+            isBreaking: c.isBreaking,
+            githubReferences: c.references,
+            authors: c.authors,
+            shortHash: c.shortHash,
+            revertedHashes: c.revertedHashes,
+            affectedProjects: commitChangesNonProjectFiles(
+              c,
+              fileMap.nonProjectFiles
+            ) ? "*" : getProjectsAffectedByCommit(c, fileToProjectMap)
+          })),
+          this.config.conventionalCommits
+        );
+        writeDebug(
+          `Running changelog generation for the ${releaseGroup.name} release group`,
+          this.workspaceConfig
+        );
+        projectChangelogs = await generateChangelogForProjects({
+          tree: this.tree,
+          args: options,
+          changes,
+          projectGraph: this.projectGraph,
+          projectsVersionData: options.versionData,
+          releaseGroup,
+          projects: projectNodes,
+          releaseConfig: this.config,
+          projectToAdditionalDependencyBumps,
+          workspaceConfig: this.workspaceConfig,
+          ChangelogRendererClass: StormChangelogRenderer
+        });
+        if (projectChangelogs) {
+          for (const [projectName, projectChangelog] of Object.entries(
+            projectChangelogs
+          )) {
+            if (projectChangelog.postGitTask) {
+              postGitTasks.push(projectChangelog.postGitTask);
+            }
+            allProjectChangelogs[projectName] = projectChangelog;
+          }
+        }
       }
     }
-    return false;
-  }
-  isCI = () => {
-    if (process.env.CI === "false") {
-      return false;
-    }
-    return process.env.CI || process.env.TF_BUILD === "true" || process.env.GITHUB_ACTIONS === "true" || process.env.BUILDKITE === "true" || process.env.CIRCLECI === "true" || process.env.CIRRUS_CI === "true" || process.env.TRAVIS === "true" || !!process.env["bamboo.buildKey"] || !!process.env["bamboo_buildKey"] || !!process.env.CODEBUILD_BUILD_ID || !!process.env.GITLAB_CI || !!process.env.HEROKU_TEST_RUN_ID || !!process.env.BUILD_ID || !!process.env.BUILD_NUMBER || !!process.env.BUILD_BUILDID || !!process.env.TEAMCITY_VERSION || !!process.env.JENKINS_URL || !!process.env.HUDSON_URL;
+    writeDebug(
+      `Generated changelogs for ${Object.keys(allProjectChangelogs).length} projects:
+${Object.keys(allProjectChangelogs).map((p) => `  - ${p}`).join("\n")}
+`,
+      this.workspaceConfig
+    );
+    await this.applyChangesAndExit(options, postGitTasks);
+    return {
+      workspaceChangelog: void 0,
+      projectChangelogs: allProjectChangelogs
+    };
   };
-  applyChangesAndExit = async (options, result) => {
-    const postGitTasks = Object.values(result.projectChangelogs || {}).map((project) => project.postGitTask).filter(Boolean);
+  applyChangesAndExit = async (options, postGitTasks) => {
     const to = options.to || "HEAD";
     let latestCommit = await getCommitHash(to);
-    const gitTagValues = options.gitTag ?? this.config.changelog?.git?.tag ? createGitTagValues(
+    const gitTagValues = createGitTagValues(
       options.releaseGraph.releaseGroups,
       options.releaseGraph.releaseGroupToFilteredProjects,
       options.versionData
-    ) : [];
+    );
     handleDuplicateGitTags(gitTagValues);
     const commitMessageValues = createCommitMessageValues(
       options.releaseGraph.releaseGroups,
@@ -3280,13 +3608,11 @@ var StormReleaseClient = class _StormReleaseClient extends ReleaseClient {
       options.gitCommitMessage || this.config.changelog?.git?.commitMessage || "release(monorepo): Publish workspace release updates"
     );
     const changes = this.tree.listChanges();
-    if (this.checkChangelogFilesEnabled() && !changes.length) {
-      output.warn({
-        title: `No changes detected for changelogs`,
-        bodyLines: [
-          `No changes were detected for any changelog files, so no changelog entries will be generated.`
-        ]
-      });
+    if (!changes.length) {
+      writeWarning(
+        "No changes were detected for any changelog files, so no changelog entries will be generated.",
+        this.workspaceConfig
+      );
       if (!postGitTasks.length) {
         return;
       }
@@ -3305,7 +3631,10 @@ var StormReleaseClient = class _StormReleaseClient extends ReleaseClient {
       gitCommitArgs: options.gitCommitArgs || this.config.changelog?.git?.commitArgs
     });
     latestCommit = await getCommitHash("HEAD");
-    output.logSingleLine(`Tagging commit with git`);
+    writeDebug(
+      `Creating git tags: ${gitTagValues.join(", ")}`,
+      this.workspaceConfig
+    );
     for (const tag of gitTagValues) {
       await gitTag({
         tag,
@@ -3315,17 +3644,16 @@ var StormReleaseClient = class _StormReleaseClient extends ReleaseClient {
         verbose: options.verbose
       });
     }
-    if (options.gitPush ?? this.config.changelog?.git?.push) {
-      output.logSingleLine(
-        `Pushing to git remote "${options.gitRemote ?? "origin"}"`
-      );
-      await gitPush({
-        gitRemote: options.gitRemote,
-        dryRun: options.dryRun,
-        verbose: options.verbose,
-        additionalArgs: options.gitPushArgs || this.config.changelog?.git?.pushArgs
-      });
-    }
+    writeDebug(
+      `Pushing to git remote "${options.gitRemote ?? "origin"}"`,
+      this.workspaceConfig
+    );
+    await gitPush({
+      gitRemote: options.gitRemote,
+      dryRun: options.dryRun,
+      verbose: options.verbose,
+      additionalArgs: options.gitPushArgs || this.config.changelog?.git?.pushArgs
+    });
     for (const postGitTask of postGitTasks) {
       await postGitTask(latestCommit);
     }