@storm-software/git-tools 2.123.18 → 2.124.0

package/bin/git.js

@@ -30,19 +30,20 @@ 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 { noDiffInChangelogMessage, handleDuplicateGitTags, createCommitMessageValues, isPrerelease, shouldPreferDockerVersionForReleaseGroup, ReleaseVersion } from 'nx/src/command-line/release/utils/shared';
 import { parse } from 'yaml';
+import chalk from 'chalk';
+import { interpolate } from 'nx/src/tasks-runner/utils';
 import { resolveConfig, format } from 'prettier';
 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 { getCommitHash, getLatestGitTagForPattern, getFirstGitCommit, gitPush, getGitDiff, parseCommits, gitAdd } from 'nx/src/command-line/release/utils/git';
 import { readNxJson } from 'nx/src/config/nx-json';
 import { FsTree } from 'nx/src/generators/tree';
+import { createFileMapUsingProjectGraph } from 'nx/src/project-graph/file-map-utils';
 import { execCommand } from 'nx/src/command-line/release/utils/exec-command.js';
-import { interpolate } from 'nx/src/tasks-runner/utils';
+import { prerelease, major } from 'semver';
 import DefaultChangelogRenderer from 'nx/release/changelog-renderer';
 import { DEFAULT_CONVENTIONAL_COMMITS_CONFIG } from 'nx/src/command-line/release/config/conventional-commits';
-import { 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 -->";
@@ -1937,7 +1947,7 @@ var createRegExp = (sectionName) => {
 var runReadme = async ({
   templates = "./tools/readme-templates",
   project,
-  output: output3,
+  output: output4,
   clean = true,
   prettier = true
 }) => {
@@ -1948,7 +1958,7 @@ var runReadme = async ({
   if (project) {
     await runProjectReadme(project, {
       templates,
-      output: output3,
+      output: output4,
       clean,
       prettier
     });
@@ -1956,14 +1966,14 @@ var runReadme = async ({
     for (const projectName of Object.keys(projectConfigs.projects)) {
       await runProjectReadme(projectName, {
         templates,
-        output: output3,
+        output: output4,
         clean,
         prettier
       });
     }
   }
 };
-var runProjectReadme = async (projectName, { templates, output: output3, clean = true, prettier = true }) => {
+var runProjectReadme = async (projectName, { templates, output: output4, clean = true, prettier = true }) => {
   const projectGraph = await createProjectGraphAsync({
     exitOnError: true
   });
@@ -1972,7 +1982,7 @@ var runProjectReadme = async (projectName, { templates, output: output3, clean =
   const inputFile = join$1(project?.root ?? "./", "README.md");
   if (existsSync$1(inputFile)) {
     console.info(`Formatting ${projectName}'s README file at "${inputFile}"`);
-    const outputFilePath = output3 ? output3.includes("README.md") ? output3 : join$1(findFilePath(output3), "README.md") : inputFile;
+    const outputFilePath = output4 ? output4.includes("README.md") ? output4 : join$1(findFilePath(output4), "README.md") : inputFile;
     if (clean && existsSync$1(outputFilePath)) {
       if (outputFilePath === inputFile) {
         console.warn(
@@ -2410,6 +2420,95 @@ function parseChangelogMarkdown(contents) {
     releases
   };
 }
+function filterHiddenChanges(changes, conventionalCommitsConfig) {
+  return changes.filter((change) => {
+    const type = change.type;
+    const typeConfig = conventionalCommitsConfig.types[type];
+    if (!typeConfig) {
+      return false;
+    }
+    return !typeConfig.changelog.hidden;
+  });
+}
+async function generateChangelogForProjects({
+  args,
+  changes,
+  projectsVersionData,
+  releaseGroup,
+  projects,
+  releaseConfig,
+  projectToAdditionalDependencyBumps,
+  workspaceConfig,
+  ChangelogRendererClass
+}) {
+  const config5 = releaseGroup.changelog;
+  if (config5 === false) {
+    return;
+  }
+  const dryRun = !!args.dryRun;
+  const remoteReleaseClient = await createGithubRemoteReleaseClient(
+    workspaceConfig,
+    args.gitRemote
+  );
+  const projectChangelogs = {};
+  for (const project of projects) {
+    let interpolatedTreePath = config5.file || "";
+    if (interpolatedTreePath) {
+      interpolatedTreePath = interpolate(interpolatedTreePath, {
+        projectName: project.name,
+        projectRoot: project.data.root,
+        workspaceRoot: ""
+        // within the tree, workspaceRoot is the root
+      });
+    }
+    if (!projectsVersionData[project.name] || projectsVersionData[project.name]?.newVersion === null && !projectsVersionData[project.name]?.dockerVersion) {
+      continue;
+    }
+    const preferDockerVersion = shouldPreferDockerVersionForReleaseGroup(releaseGroup);
+    const releaseVersion = new ReleaseVersion({
+      version: (preferDockerVersion === true || preferDockerVersion === "both") && projectsVersionData[project.name]?.dockerVersion ? projectsVersionData[project.name]?.dockerVersion : projectsVersionData[project.name]?.newVersion,
+      releaseTagPattern: releaseGroup.releaseTag.pattern,
+      projectName: project.name
+    });
+    if (interpolatedTreePath) {
+      const prefix = dryRun ? "Previewing" : "Generating";
+      output.log({
+        title: `${prefix} an entry in ${interpolatedTreePath} for ${chalk.white(
+          releaseVersion.gitTag
+        )}`
+      });
+    }
+    const changelogRenderer = new ChangelogRendererClass({
+      changes,
+      changelogEntryVersion: releaseVersion.rawVersion,
+      project: project.name,
+      entryWhenNoChanges: typeof config5.entryWhenNoChanges === "string" ? interpolate(config5.entryWhenNoChanges, {
+        projectName: project.name,
+        projectRoot: project.data.root,
+        workspaceRoot: ""
+        // within the tree, workspaceRoot is the root
+      }) : false,
+      changelogRenderOptions: config5.renderOptions,
+      isVersionPlans: !!releaseGroup.versionPlans,
+      conventionalCommitsConfig: releaseConfig.conventionalCommits,
+      dependencyBumps: projectToAdditionalDependencyBumps.get(project.name),
+      remoteReleaseClient,
+      workspaceConfig
+    });
+    const contents = await changelogRenderer.render();
+    const postGitTask = args.createRelease !== false && config5.createRelease ? remoteReleaseClient.createPostGitTask(
+      releaseVersion,
+      contents,
+      dryRun
+    ) : null;
+    projectChangelogs[project.name] = {
+      releaseVersion,
+      contents,
+      postGitTask
+    };
+  }
+  return projectChangelogs;
+}
 
 // src/release/github.ts
 var StormGithubRemoteReleaseClient = class extends GithubRemoteReleaseClient {
@@ -2630,6 +2729,48 @@ async function isUserAnOrganizationMember(userId, config5, remoteName = "origin"
     return false;
   }
 }
+async function getCommits(fromSHA, toSHA) {
+  const rawCommits = await getGitDiff(fromSHA, toSHA);
+  return parseCommits(rawCommits);
+}
+async function filterProjectCommits({
+  fromSHA,
+  toSHA,
+  projectPath
+}) {
+  const allCommits = await getCommits(fromSHA, toSHA);
+  return allCommits.filter(
+    (c) => c.affectedFiles.find((f) => f.startsWith(projectPath))
+  );
+}
+function commitChangesNonProjectFiles(commit, nonProjectFiles) {
+  return nonProjectFiles.some(
+    (fileData) => commit.affectedFiles.includes(fileData.file)
+  );
+}
+function getProjectsAffectedByCommit(commit, fileToProjectMap) {
+  const affectedProjects = /* @__PURE__ */ new Set();
+  for (const file of commit.affectedFiles) {
+    affectedProjects.add(fileToProjectMap[file]);
+  }
+  return Array.from(affectedProjects);
+}
+function extractPreid(version) {
+  if (!isPrerelease(version)) {
+    return void 0;
+  }
+  const preid = prerelease(version)?.[0];
+  if (typeof preid === "string") {
+    if (preid.trim() === "") {
+      return void 0;
+    }
+    return preid;
+  }
+  if (typeof preid === "number") {
+    return preid.toString();
+  }
+  return void 0;
+}
 function createGitTagValues(releaseGroups, releaseGroupToFilteredProjects, versionData) {
   const tags = [];
   for (const releaseGroup of releaseGroups) {
@@ -2805,15 +2946,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 +3201,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 +3238,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 +3266,6 @@ var StormReleaseClient = class _StormReleaseClient extends ReleaseClient {
       workspaceConfig
     );
   }
-  #releaseChangelog;
   /**
    * The release configuration used by this release client.
    */
@@ -3173,7 +3311,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,62 +3330,283 @@ 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
+          );
+          projectChangelogs = await generateChangelogForProjects({
+            tree: this.tree,
+            args: options,
+            changes,
+            projectsVersionData: options.versionData,
+            releaseGroup,
+            projects: [project],
+            releaseConfig: this.config,
+            projectToAdditionalDependencyBumps,
+            workspaceConfig: this.workspaceConfig,
+            ChangelogRendererClass: StormChangelogRenderer
+          });
+          if (projectChangelogs) {
+            for (const [projectName, projectChangelog] of Object.entries(
+              projectChangelogs
+            )) {
+              if (projectChangelog.postGitTask) {
+                postGitTasks.push(projectChangelog.postGitTask);
               }
-              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;
             }
           }
-        )
+        }
+      } 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
+        );
+        projectChangelogs = await generateChangelogForProjects({
+          tree: this.tree,
+          args: options,
+          changes,
+          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;
+          }
+        }
+      }
+    }
+    if (projectChangelogs) {
+      await Promise.all(
+        Object.entries(projectChangelogs).map(async ([project, changelog]) => {
+          if (!this.projectGraph.nodes[project]?.data.root) {
+            writeWarning(
+              `A changelog was generated for ${project}, but it could not be found in the project graph. Skipping writing changelog file.`,
+              this.workspaceConfig
+            );
+          } else if (changelog.contents) {
+            const filePath = joinPaths(
+              this.projectGraph.nodes[project].data.root,
+              "CHANGELOG.md"
+            );
+            let currentContent;
+            if (existsSync$1(filePath)) {
+              currentContent = await readFile$1(filePath, "utf8");
+            }
+            writeDebug(
+              `\u270D\uFE0F  Writing changelog for project ${project} to ${filePath}`,
+              this.workspaceConfig
+            );
+            const content = await generateChangelogContent(
+              changelog.releaseVersion,
+              filePath,
+              changelog.contents,
+              currentContent,
+              project,
+              this.workspaceConfig
+            );
+            this.tree.write(filePath, content);
+            printAndFlushChanges(
+              this.tree,
+              !!options.dryRun,
+              3,
+              false,
+              noDiffInChangelogMessage,
+              // Only print the change for the current changelog file at this point
+              (f) => f.path === filePath
+            );
+          }
+        })
       );
-      this.applyChangesAndExit(options, result);
+      this.applyChangesAndExit(options, postGitTasks);
     }
-    return result;
+    return {
+      workspaceChangelog: void 0,
+      projectChangelogs: allProjectChangelogs
+    };
   };
   checkChangelogFilesEnabled() {
     if (this.config.changelog?.workspaceChangelog && (this.config.changelog?.workspaceChangelog === true || this.config.changelog?.workspaceChangelog.file)) {
@@ -3263,8 +3625,7 @@ var StormReleaseClient = class _StormReleaseClient extends ReleaseClient {
     }
     return process.env.CI || process.env.TF_BUILD === "true" || process.env.GITHUB_ACTIONS === "true" || process.env.BUILDKITE === "true" || process.env.CIRCLECI === "true" || process.env.CIRRUS_CI === "true" || process.env.TRAVIS === "true" || !!process.env["bamboo.buildKey"] || !!process.env["bamboo_buildKey"] || !!process.env.CODEBUILD_BUILD_ID || !!process.env.GITLAB_CI || !!process.env.HEROKU_TEST_RUN_ID || !!process.env.BUILD_ID || !!process.env.BUILD_NUMBER || !!process.env.BUILD_BUILDID || !!process.env.TEAMCITY_VERSION || !!process.env.JENKINS_URL || !!process.env.HUDSON_URL;
   };
-  applyChangesAndExit = async (options, 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(