@storm-software/git-tools 2.131.17 → 2.131.18

package/bin/git.js

@@ -49,15 +49,14 @@ import { defaultCreateReleaseProvider, GithubRemoteReleaseClient } from 'nx/src/
 import { parse } from 'yaml';
 import chalk from 'chalk';
 import { printAndFlushChanges as printAndFlushChanges$1 } 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 { createGitTagValues, handleDuplicateGitTags, createCommitMessageValues, isPrerelease, shouldPreferDockerVersionForReleaseGroup, ReleaseVersion, noDiffInChangelogMessage, shouldSkipVersionActions } from 'nx/src/command-line/release/utils/shared';
 import { interpolate } from 'nx/src/tasks-runner/utils';
 import { execCommand } from 'nx/src/command-line/release/utils/exec-command.js';
-import { getCommitHash, getLatestGitTagForPattern, getFirstGitCommit, gitPush, gitAdd, getGitDiff, parseCommits } from 'nx/src/command-line/release/utils/git';
+import { getCommitHash, getLatestGitTagForPattern, getFirstGitCommit, gitPush, gitAdd, getGitDiff, parseCommits, sanitizeProjectNameForGitTag } from 'nx/src/command-line/release/utils/git';
 import semver, { prerelease, major } from 'semver';
 import { ReleaseClient } from 'nx/release';
 import { readRawVersionPlans, setResolvedVersionPlansOnGroups } from 'nx/src/command-line/release/config/version-plans';
 import { printAndFlushChanges } from 'nx/src/command-line/release/utils/print-changes.js';
-import { createReleaseGraph } from 'nx/src/command-line/release/utils/release-graph';
 import { validateResolvedVersionPlansAgainstFilter } from 'nx/src/command-line/release/utils/version-plan-utils';
 import { FsTree } from 'nx/src/generators/tree';
 import { createFileMapUsingProjectGraph } from 'nx/src/project-graph/file-map-utils';
@@ -66,7 +65,16 @@ import DefaultChangelogRenderer from 'nx/release/changelog-renderer';
 import { DEFAULT_CONVENTIONAL_COMMITS_CONFIG } from 'nx/src/command-line/release/config/conventional-commits';
 import { readNxJson } from 'nx/src/config/nx-json';
 import { findMatchingProjects } from 'nx/src/utils/find-matching-projects';
-import { IMPLICIT_DEFAULT_RELEASE_GROUP } from 'nx/src/command-line/release/config/config.js';
+import { IMPLICIT_DEFAULT_RELEASE_GROUP } from 'nx/src/command-line/release/config/config';
+import { RepoGitTags } from 'nx/src/command-line/release/utils/repository-git-tags';
+import { ProjectLogger } from 'nx/src/command-line/release/version/project-logger';
+import { resolveCurrentVersion } from 'nx/src/command-line/release/version/resolve-current-version';
+import { topologicalSort } from 'nx/src/command-line/release/version/topological-sort';
+import { resolveVersionActionsForProject, NOOP_VERSION_ACTIONS as NOOP_VERSION_ACTIONS$1 } from 'nx/src/command-line/release/version/version-actions';
+import { filterAffected } from 'nx/src/project-graph/affected/affected-project-graph';
+import { calculateFileChanges } from 'nx/src/project-graph/file-utils';
+import gte from 'semver/functions/gte';
+import { IMPLICIT_DEFAULT_RELEASE_GROUP as IMPLICIT_DEFAULT_RELEASE_GROUP$1 } from 'nx/src/command-line/release/config/config.js';
 import { deriveSpecifierFromConventionalCommits } from 'nx/src/command-line/release/version/derive-specifier-from-conventional-commits';
 import { deriveSpecifierFromVersionPlan } from 'nx/src/command-line/release/version/deriver-specifier-from-version-plans';
 import { ReleaseGroupProcessor } from 'nx/src/command-line/release/version/release-group-processor';
@@ -3588,6 +3596,685 @@ function formatConfigLog(config5) {
     { sort: true, skip: ["workspaceConfig"] }
   );
 }
+var validReleaseVersionPrefixes = ["auto", "", "~", "^", "="];
+var ReleaseGraph = class _ReleaseGraph {
+  constructor(releaseGroups, filters) {
+    this.releaseGroups = releaseGroups;
+    this.filters = filters;
+  }
+  projectToReleaseGroup = /* @__PURE__ */ new Map();
+  projectToDependents = /* @__PURE__ */ new Map();
+  projectToDependencies = /* @__PURE__ */ new Map();
+  projectToUpdateDependentsSetting = /* @__PURE__ */ new Map();
+  groupGraph = /* @__PURE__ */ new Map();
+  sortedReleaseGroups = [];
+  sortedProjects = /* @__PURE__ */ new Map();
+  allProjectsConfiguredForNxRelease = /* @__PURE__ */ new Set();
+  allProjectsToProcess = /* @__PURE__ */ new Set();
+  finalConfigsByProject = /* @__PURE__ */ new Map();
+  projectsToVersionActions = /* @__PURE__ */ new Map();
+  uniqueAfterAllProjectsVersioned = /* @__PURE__ */ new Map();
+  projectLoggers = /* @__PURE__ */ new Map();
+  cachedCurrentVersions = /* @__PURE__ */ new Map();
+  cachedLatestMatchingGitTag = /* @__PURE__ */ new Map();
+  currentVersionsPerFixedReleaseGroup = /* @__PURE__ */ new Map();
+  originalDependentProjectsPerProject = /* @__PURE__ */ new Map();
+  releaseGroupToFilteredProjects = /* @__PURE__ */ new Map();
+  originalFilteredProjects = /* @__PURE__ */ new Set();
+  /**
+   * Store the affected graph per commit per project
+   * to avoid recomputation of the graph on workspace
+   * with multiple projects
+   */
+  affectedGraphPerCommit = /* @__PURE__ */ new Map();
+  repositoryGitTags = RepoGitTags.create();
+  /**
+   * User-friendly log describing what the filter matched.
+   * Null if no filters were applied.
+   */
+  filterLog = null;
+  /**
+   * Initialize the graph by building all relationships and caches
+   * @internal - Called by createReleaseGraph(), not meant for external use
+   */
+  async init(options) {
+    this.setupProjectReleaseGroupMapping();
+    this.applyInitialFiltering();
+    await this.setupProjectsToProcess(options);
+    await this.precomputeDependencyRelationships(
+      options.tree,
+      options.projectGraph
+    );
+    this.applyDependencyAwareFiltering();
+    this.buildGroupGraphStructure();
+    if (!options.skipVersionResolution) {
+      await this.resolveCurrentVersionsForProjects(
+        options.tree,
+        options.projectGraph,
+        options.preid ?? ""
+      );
+    }
+    this.buildGroupDependencyGraph();
+    this.sortedReleaseGroups = this.topologicallySortReleaseGroups();
+    for (const group of this.releaseGroups) {
+      this.sortedProjects.set(
+        group.name,
+        this.topologicallySortProjects(group)
+      );
+    }
+    await this.populateDependentProjectsData(
+      options.tree,
+      options.projectGraph
+    );
+  }
+  /**
+   * Setup mapping from project to release group and cache updateDependents settings
+   */
+  setupProjectReleaseGroupMapping() {
+    for (const group of this.releaseGroups) {
+      for (const project of group.projects) {
+        this.projectToReleaseGroup.set(project, group);
+        const updateDependents = group.version?.updateDependents || "always";
+        this.projectToUpdateDependentsSetting.set(project, updateDependents);
+      }
+    }
+  }
+  /**
+   * Apply initial filtering to construct releaseGroupToFilteredProjects based on filters.
+   * This determines the base set of projects and groups before considering dependencies.
+   */
+  applyInitialFiltering() {
+    const matchedReleaseGroups = [];
+    for (const releaseGroup of this.releaseGroups) {
+      if (this.filters.groups?.length && !this.filters.groups.includes(releaseGroup.name)) {
+        continue;
+      }
+      if (this.filters.groups?.length && !this.filters.projects?.length) {
+        this.releaseGroupToFilteredProjects.set(
+          releaseGroup,
+          new Set(releaseGroup.projects)
+        );
+        matchedReleaseGroups.push(releaseGroup);
+        continue;
+      }
+      const filteredProjects = /* @__PURE__ */ new Set();
+      for (const project of releaseGroup.projects) {
+        if (this.filters.projects?.length && !this.filters.projects.includes(project)) {
+          continue;
+        }
+        filteredProjects.add(project);
+      }
+      if (filteredProjects.size > 0 || !this.hasAnyFilters()) {
+        const projectsToInclude = filteredProjects.size > 0 ? filteredProjects : new Set(releaseGroup.projects);
+        this.releaseGroupToFilteredProjects.set(
+          releaseGroup,
+          projectsToInclude
+        );
+        matchedReleaseGroups.push(releaseGroup);
+      }
+    }
+    if (this.hasAnyFilters()) {
+      this.releaseGroups = matchedReleaseGroups;
+    }
+  }
+  /**
+   * Check if any filters are applied
+   */
+  hasAnyFilters() {
+    return !!(this.filters.projects?.length || this.filters.groups?.length);
+  }
+  /**
+   * Setup projects to process and resolve version actions
+   */
+  async setupProjectsToProcess(options) {
+    const {
+      tree,
+      projectGraph,
+      nxReleaseConfig,
+      filters,
+      firstRelease,
+      versionActionsOptionsOverrides
+    } = options;
+    let projectsToProcess = /* @__PURE__ */ new Set();
+    const resolveVersionActionsForProjectCallbacks = [];
+    for (const [groupName, group] of Object.entries(nxReleaseConfig.groups)) {
+      for (const project of group.projects) {
+        this.allProjectsConfiguredForNxRelease.add(project);
+        this.projectLoggers.set(project, new ProjectLogger(project));
+        if (filters.groups?.includes(groupName)) {
+          projectsToProcess.add(project);
+        } else if (filters.projects?.includes(project)) {
+          projectsToProcess.add(project);
+        }
+        const projectGraphNode = projectGraph.nodes[project];
+        const releaseGroup = this.projectToReleaseGroup.get(project);
+        const finalConfigForProject = _ReleaseGraph.resolveFinalConfigForProject(
+          releaseGroup,
+          projectGraphNode,
+          firstRelease,
+          versionActionsOptionsOverrides
+        );
+        this.finalConfigsByProject.set(project, finalConfigForProject);
+        resolveVersionActionsForProjectCallbacks.push(async () => {
+          const {
+            versionActionsPath,
+            versionActions,
+            afterAllProjectsVersioned
+          } = await resolveVersionActionsForProject(
+            tree,
+            releaseGroup,
+            projectGraphNode,
+            finalConfigForProject
+          );
+          if (!this.uniqueAfterAllProjectsVersioned.has(versionActionsPath)) {
+            this.uniqueAfterAllProjectsVersioned.set(
+              versionActionsPath,
+              afterAllProjectsVersioned
+            );
+          }
+          let versionActionsToUse = versionActions;
+          const shouldSkip = shouldSkipVersionActions(
+            finalConfigForProject.dockerOptions,
+            project
+          );
+          if (shouldSkip) {
+            versionActionsToUse = new NOOP_VERSION_ACTIONS$1(
+              releaseGroup,
+              projectGraphNode,
+              finalConfigForProject
+            );
+          }
+          this.projectsToVersionActions.set(project, versionActionsToUse);
+        });
+      }
+    }
+    if (!filters.groups?.length && !filters.projects?.length) {
+      projectsToProcess = this.allProjectsConfiguredForNxRelease;
+    }
+    if (projectsToProcess.size === 0) {
+      throw new Error(
+        "No projects are set to be processed, please report this as a bug on https://github.com/nrwl/nx/issues"
+      );
+    }
+    this.allProjectsToProcess = new Set(projectsToProcess);
+    for (const cb of resolveVersionActionsForProjectCallbacks) {
+      await cb();
+    }
+  }
+  /**
+   * Precompute dependency relationships between all projects
+   */
+  async precomputeDependencyRelationships(tree, projectGraph) {
+    for (const projectName of this.allProjectsConfiguredForNxRelease) {
+      const versionActions = this.projectsToVersionActions.get(projectName);
+      if (!this.projectToDependencies.has(projectName)) {
+        this.projectToDependencies.set(projectName, /* @__PURE__ */ new Set());
+      }
+      const deps = await versionActions.readDependencies(tree, projectGraph);
+      for (const dep of deps) {
+        if (!this.allProjectsConfiguredForNxRelease.has(dep.target)) {
+          continue;
+        }
+        this.projectToDependencies.get(projectName).add(dep.target);
+        if (!this.projectToDependents.has(dep.target)) {
+          this.projectToDependents.set(dep.target, /* @__PURE__ */ new Set());
+        }
+        this.projectToDependents.get(dep.target).add(projectName);
+      }
+    }
+  }
+  /**
+   * Apply dependency-aware filtering that considers updateDependents configuration.
+   * This includes transitive dependents based on updateDependents setting ('always' by default, or 'auto').
+   */
+  applyDependencyAwareFiltering() {
+    this.originalFilteredProjects = new Set(this.allProjectsToProcess);
+    if (!this.hasAnyFilters()) {
+      return;
+    }
+    this.validateFilterAgainstFixedGroups();
+    this.findDependentsToProcess();
+    this.generateFilterLog();
+  }
+  /**
+   * Validate that the filter doesn't try to isolate projects in fixed release groups
+   */
+  validateFilterAgainstFixedGroups() {
+    if (!this.filters.projects?.length) {
+      return;
+    }
+    for (const releaseGroup of this.releaseGroups) {
+      if (releaseGroup.projectsRelationship !== "fixed") {
+        continue;
+      }
+      const filteredProjectsInGroup = releaseGroup.projects.filter(
+        (p) => this.releaseGroupToFilteredProjects.get(releaseGroup)?.has(p)
+      );
+      if (filteredProjectsInGroup.length > 0 && filteredProjectsInGroup.length < releaseGroup.projects.length) {
+        throw new Error(
+          `Cannot filter to a subset of projects within fixed release group "${releaseGroup.name}". Filtered projects: [${filteredProjectsInGroup.join(", ")}], All projects in group: [${releaseGroup.projects.join(", ")}]. Either filter to all projects in the group, use --groups to filter by group, or change the group to "independent".`
+        );
+      }
+    }
+  }
+  /**
+   * Find dependents that should be included in processing based on updateDependents configuration
+   */
+  findDependentsToProcess() {
+    const projectsToProcess = Array.from(this.allProjectsToProcess);
+    const allTrackedDependents = /* @__PURE__ */ new Set();
+    const dependentsToProcess = /* @__PURE__ */ new Set();
+    const additionalGroups = /* @__PURE__ */ new Map();
+    let currentLevel = [...projectsToProcess];
+    while (currentLevel.length > 0) {
+      const nextLevel = [];
+      const dependents = this.getAllNonImplicitDependents(currentLevel);
+      for (const dep of dependents) {
+        if (allTrackedDependents.has(dep) || this.allProjectsToProcess.has(dep)) {
+          continue;
+        }
+        allTrackedDependents.add(dep);
+        const depUpdateDependentsSetting = this.projectToUpdateDependentsSetting.get(dep);
+        if (depUpdateDependentsSetting !== "never") {
+          const shouldIncludeDependent = currentLevel.some((proj) => {
+            const projUpdateSetting = this.projectToUpdateDependentsSetting.get(proj);
+            const projDependents = this.getProjectDependents(proj);
+            if (!projDependents.has(dep)) {
+              return false;
+            }
+            if (projUpdateSetting === "always") {
+              return true;
+            }
+            if (projUpdateSetting === "auto") {
+              const projGroup = this.getReleaseGroupForProject(proj);
+              const depGroup = this.getReleaseGroupForProject(dep);
+              return projGroup && depGroup && projGroup.name === depGroup.name;
+            }
+            return false;
+          });
+          if (shouldIncludeDependent) {
+            dependentsToProcess.add(dep);
+            const depGroup = this.getReleaseGroupForProject(dep);
+            if (depGroup) {
+              const groupAlreadyExists = this.releaseGroups.some(
+                (g) => g.name === depGroup.name
+              );
+              if (!groupAlreadyExists) {
+                additionalGroups.set(depGroup.name, depGroup);
+              }
+            }
+          }
+        }
+        nextLevel.push(dep);
+      }
+      currentLevel = nextLevel;
+    }
+    dependentsToProcess.forEach((dep) => this.allProjectsToProcess.add(dep));
+    additionalGroups.forEach((group) => {
+      const groupForDependents = {
+        ...group,
+        versionPlans: false,
+        resolvedVersionPlans: false
+      };
+      this.releaseGroups.push(groupForDependents);
+      const projectsInGroup = new Set(
+        group.projects.filter((p) => dependentsToProcess.has(p))
+      );
+      this.releaseGroupToFilteredProjects.set(
+        groupForDependents,
+        projectsInGroup
+      );
+    });
+  }
+  /**
+   * Generate user-friendly log describing what the filter matched
+   */
+  generateFilterLog() {
+    if (this.filters.projects?.length) {
+      const matchedProjects = Array.from(this.originalFilteredProjects);
+      this.filterLog = {
+        title: `Your filter "${this.filters.projects.join(
+          ","
+        )}" matched the following projects:`,
+        bodyLines: matchedProjects.map((p) => {
+          const releaseGroupForProject = this.projectToReleaseGroup.get(p);
+          if (!releaseGroupForProject || releaseGroupForProject.name === IMPLICIT_DEFAULT_RELEASE_GROUP) {
+            return `- ${p}`;
+          }
+          return `- ${p} (release group "${releaseGroupForProject.name}")`;
+        })
+      };
+    }
+  }
+  /**
+   * Build the group graph structure
+   */
+  buildGroupGraphStructure() {
+    for (const group of this.releaseGroups) {
+      if (!this.groupGraph.has(group.name)) {
+        this.groupGraph.set(group.name, {
+          group,
+          dependencies: /* @__PURE__ */ new Set(),
+          dependents: /* @__PURE__ */ new Set()
+        });
+      }
+    }
+  }
+  /**
+   * Resolve current versions for all projects that will be processed
+   */
+  async resolveCurrentVersionsForProjects(tree, projectGraph, preid) {
+    for (const [, releaseGroupNode] of this.groupGraph) {
+      for (const projectName of releaseGroupNode.group.projects) {
+        const projectGraphNode = projectGraph.nodes[projectName];
+        if (!this.allProjectsToProcess.has(projectName)) {
+          continue;
+        }
+        const versionActions = this.projectsToVersionActions.get(projectName);
+        const finalConfigForProject = this.finalConfigsByProject.get(projectName);
+        let latestMatchingGitTag;
+        const releaseTagPattern = releaseGroupNode.group.releaseTag.pattern;
+        if (finalConfigForProject.currentVersionResolver === "git-tag") {
+          const additionalInterpolationData = {
+            projectName: sanitizeProjectNameForGitTag(projectGraphNode.name),
+            releaseGroupName: releaseGroupNode.group.name
+          };
+          const options = {
+            checkAllBranchesWhen: releaseGroupNode.group.releaseTag.checkAllBranchesWhen,
+            preid,
+            requireSemver: releaseGroupNode.group.releaseTag.requireSemver,
+            strictPreid: releaseGroupNode.group.releaseTag.strictPreid
+          };
+          if (releaseGroupNode.group.projectsRelationship === "fixed" && !releaseTagPattern.includes("{projectName}")) {
+            const groupReleaseTag = await getLatestGitTagForPattern(
+              releaseTagPattern,
+              additionalInterpolationData,
+              this.resolveRepositoryTags.bind(this),
+              options
+            );
+            const projectReleaseTag = await getLatestGitTagForPattern(
+              releaseTagPattern.includes("{releaseGroupName}") ? releaseTagPattern.replace(
+                /\{releaseGroupName\}/g,
+                "{projectName}"
+              ) : `{projectName}@${releaseTagPattern}`,
+              additionalInterpolationData,
+              this.resolveRepositoryTags.bind(this),
+              options
+            );
+            if (projectReleaseTag?.extractedVersion && groupReleaseTag?.extractedVersion && gte(
+              projectReleaseTag.extractedVersion,
+              groupReleaseTag.extractedVersion
+            )) {
+              latestMatchingGitTag = projectReleaseTag;
+            } else {
+              latestMatchingGitTag = groupReleaseTag;
+            }
+          } else {
+            latestMatchingGitTag = await getLatestGitTagForPattern(
+              releaseTagPattern,
+              additionalInterpolationData,
+              this.resolveRepositoryTags.bind(this),
+              options
+            );
+          }
+          this.cachedLatestMatchingGitTag.set(
+            projectName,
+            latestMatchingGitTag
+          );
+          const currentVersion = await resolveCurrentVersion(
+            tree,
+            projectGraphNode,
+            releaseGroupNode.group,
+            versionActions,
+            this.projectLoggers.get(projectName),
+            this.currentVersionsPerFixedReleaseGroup,
+            finalConfigForProject,
+            releaseTagPattern,
+            latestMatchingGitTag
+          );
+          this.cachedCurrentVersions.set(projectName, currentVersion);
+        }
+      }
+    }
+  }
+  /**
+   * Build dependency relationships between release groups
+   */
+  buildGroupDependencyGraph() {
+    for (const [releaseGroupName, releaseGroupNode] of this.groupGraph) {
+      for (const projectName of releaseGroupNode.group.projects) {
+        const projectDeps = this.getProjectDependencies(projectName);
+        for (const dep of projectDeps) {
+          const dependencyGroup = this.getReleaseGroupNameForProject(dep);
+          if (dependencyGroup && dependencyGroup !== releaseGroupName) {
+            releaseGroupNode.dependencies.add(dependencyGroup);
+            const dependencyGroupNode = this.groupGraph.get(dependencyGroup);
+            if (dependencyGroupNode) {
+              dependencyGroupNode.dependents.add(releaseGroupName);
+            }
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Topologically sort release groups
+   */
+  topologicallySortReleaseGroups() {
+    const groupNames = Array.from(this.groupGraph.keys());
+    const getGroupDependencies = (groupName) => {
+      const groupNode = this.groupGraph.get(groupName);
+      if (!groupNode) {
+        return [];
+      }
+      return Array.from(groupNode.dependencies);
+    };
+    return topologicalSort(groupNames, getGroupDependencies);
+  }
+  /**
+   * Topologically sort projects within a release group
+   */
+  topologicallySortProjects(releaseGroup) {
+    const projects = releaseGroup.projects.filter(
+      (p) => this.allProjectsToProcess.has(p)
+    );
+    const getProjectDependenciesInSameGroup = (project) => {
+      const deps = this.getProjectDependencies(project);
+      return Array.from(deps).filter(
+        (dep) => this.getReleaseGroupNameForProject(dep) === releaseGroup.name && this.allProjectsToProcess.has(dep)
+      );
+    };
+    return topologicalSort(projects, getProjectDependenciesInSameGroup);
+  }
+  async populateDependentProjectsData(tree, projectGraph) {
+    for (const projectName of this.allProjectsToProcess) {
+      const dependentProjectNames = Array.from(
+        this.getProjectDependents(projectName)
+      ).filter((dep) => this.allProjectsConfiguredForNxRelease.has(dep));
+      const dependentProjectsData = [];
+      for (const dependentProjectName of dependentProjectNames) {
+        const versionActions = this.projectsToVersionActions.get(dependentProjectName);
+        const { currentVersion, dependencyCollection } = await versionActions.readCurrentVersionOfDependency(
+          tree,
+          projectGraph,
+          projectName
+        );
+        dependentProjectsData.push({
+          source: dependentProjectName,
+          target: projectName,
+          type: "static",
+          dependencyCollection,
+          rawVersionSpec: currentVersion
+        });
+      }
+      this.originalDependentProjectsPerProject.set(
+        projectName,
+        dependentProjectsData
+      );
+    }
+  }
+  /**
+   * Get all non-implicit dependents for a set of projects
+   */
+  getAllNonImplicitDependents(projects) {
+    return projects.flatMap((project) => Array.from(this.getProjectDependents(project))).filter((dep) => !this.allProjectsToProcess.has(dep));
+  }
+  /**
+   * Resolve final configuration for a project
+   *
+   * NOTE: We are providing ultimate fallback values via ?? here mainly just to keep TypeScript happy.
+   * All default values should have been applied by this point by config.ts but the types can't know
+   * that for sure at this point.
+   */
+  static resolveFinalConfigForProject(releaseGroup, projectGraphNode, firstRelease, versionActionsOptionsOverrides) {
+    const releaseGroupVersionConfig = releaseGroup.version;
+    const projectVersionConfig = projectGraphNode.data.release?.version;
+    const projectDockerConfig = projectGraphNode.data.release?.docker;
+    const specifierSource = projectVersionConfig?.specifierSource ?? releaseGroupVersionConfig?.specifierSource ?? "prompt";
+    const versionPrefix = projectVersionConfig?.versionPrefix ?? releaseGroupVersionConfig?.versionPrefix ?? "auto";
+    if (versionPrefix && !validReleaseVersionPrefixes.includes(versionPrefix)) {
+      throw new Error(
+        `Invalid value for versionPrefix: "${versionPrefix}"
+
+Valid values are: ${validReleaseVersionPrefixes.map((s) => `"${s}"`).join(", ")}`
+      );
+    }
+    const dockerOptions = Object.assign(
+      {},
+      releaseGroup.docker || {},
+      projectDockerConfig || {}
+    );
+    let currentVersionResolver = projectVersionConfig?.currentVersionResolver ?? releaseGroupVersionConfig?.currentVersionResolver ?? "disk";
+    const shouldSkip = shouldSkipVersionActions(
+      dockerOptions,
+      projectGraphNode.name
+    );
+    if (shouldSkip) {
+      currentVersionResolver = "none";
+    } else if (specifierSource === "conventional-commits" && currentVersionResolver !== "git-tag") {
+      throw new Error(
+        `Invalid currentVersionResolver "${currentVersionResolver}" provided for project "${projectGraphNode.name}". Must be "git-tag" when "specifierSource" is "conventional-commits"`
+      );
+    }
+    const currentVersionResolverMetadata = projectVersionConfig?.currentVersionResolverMetadata ?? releaseGroupVersionConfig?.currentVersionResolverMetadata ?? {};
+    const preserveLocalDependencyProtocols = projectVersionConfig?.preserveLocalDependencyProtocols ?? releaseGroupVersionConfig?.preserveLocalDependencyProtocols ?? true;
+    const preserveMatchingDependencyRanges = projectVersionConfig?.preserveMatchingDependencyRanges ?? releaseGroupVersionConfig?.preserveMatchingDependencyRanges ?? true;
+    const adjustSemverBumpsForZeroMajorVersion = projectVersionConfig?.adjustSemverBumpsForZeroMajorVersion ?? releaseGroupVersionConfig?.adjustSemverBumpsForZeroMajorVersion ?? true;
+    const applyPreidToDependents = projectVersionConfig?.applyPreidToDependents ?? releaseGroupVersionConfig?.applyPreidToDependents ?? false;
+    const fallbackCurrentVersionResolver = projectVersionConfig?.fallbackCurrentVersionResolver ?? releaseGroupVersionConfig?.fallbackCurrentVersionResolver ?? (firstRelease ? "disk" : void 0);
+    let versionActionsOptions = projectVersionConfig?.versionActionsOptions ?? releaseGroupVersionConfig?.versionActionsOptions ?? {};
+    versionActionsOptions = {
+      ...versionActionsOptions,
+      ...versionActionsOptionsOverrides ?? {}
+    };
+    const manifestRootsToUpdate = (projectVersionConfig?.manifestRootsToUpdate ?? releaseGroupVersionConfig?.manifestRootsToUpdate ?? []).map((manifestRoot) => {
+      if (typeof manifestRoot === "string") {
+        return {
+          path: manifestRoot,
+          // Apply the project level preserveLocalDependencyProtocols setting that was already resolved
+          preserveLocalDependencyProtocols
+        };
+      }
+      return manifestRoot;
+    });
+    return {
+      specifierSource,
+      currentVersionResolver,
+      currentVersionResolverMetadata,
+      fallbackCurrentVersionResolver,
+      versionPrefix,
+      preserveLocalDependencyProtocols,
+      preserveMatchingDependencyRanges,
+      adjustSemverBumpsForZeroMajorVersion,
+      applyPreidToDependents,
+      versionActionsOptions,
+      manifestRootsToUpdate,
+      dockerOptions
+    };
+  }
+  /**
+   * Get the release group for a given project
+   */
+  getReleaseGroupForProject(projectName) {
+    return this.projectToReleaseGroup.get(projectName);
+  }
+  /**
+   * Get the release group name for a given project
+   */
+  getReleaseGroupNameForProject(projectName) {
+    const group = this.projectToReleaseGroup.get(projectName);
+    return group ? group.name : null;
+  }
+  /**
+   * Get the dependencies of a project
+   */
+  getProjectDependencies(projectName) {
+    return this.projectToDependencies.get(projectName) || /* @__PURE__ */ new Set();
+  }
+  /**
+   * Get the dependents of a project (projects that depend on it)
+   */
+  getProjectDependents(projectName) {
+    return this.projectToDependents.get(projectName) || /* @__PURE__ */ new Set();
+  }
+  /**
+   * Get the version actions for a project
+   */
+  getVersionActionsForProject(projectName) {
+    return this.projectsToVersionActions.get(projectName);
+  }
+  /**
+   * Check if a project will be processed
+   */
+  isProjectToProcess(projectName) {
+    return this.allProjectsToProcess.has(projectName);
+  }
+  async resolveAffectedFilesPerCommitInProjectGraph(commit, projectGraph) {
+    const { shortHash } = commit;
+    let affectedGraph = this.affectedGraphPerCommit.get(shortHash);
+    if (affectedGraph) {
+      return affectedGraph;
+    }
+    const touchedFiles = calculateFileChanges(commit.affectedFiles, {
+      base: `${commit.shortHash}^`,
+      head: commit.shortHash
+    });
+    affectedGraph = await filterAffected(projectGraph, touchedFiles);
+    this.affectedGraphPerCommit.set(shortHash, affectedGraph);
+    return affectedGraph;
+  }
+  async resolveRepositoryTags(resolveTagsWhen) {
+    return this.repositoryGitTags.resolveTags(resolveTagsWhen);
+  }
+  /**
+   * Runs validation on resolved VersionActions instances. E.g. check that manifest files exist for all projects that will be processed.
+   * This should be called after preVersionCommand has run, as those commands may create manifest files that are needed for versioning.
+   */
+  async validate(tree) {
+    const validationPromises = [];
+    for (const projectName of this.allProjectsToProcess) {
+      const versionActions = this.projectsToVersionActions.get(projectName);
+      if (versionActions) {
+        validationPromises.push(versionActions.validate(tree));
+      }
+    }
+    await Promise.all(validationPromises);
+  }
+};
+async function createReleaseGraph(options) {
+  const releaseGroups = Object.entries(
+    options.nxReleaseConfig.groups ?? {}
+  ).map(([name, group]) => {
+    return {
+      ...group,
+      name,
+      resolvedVersionPlans: group.versionPlans ? [] : false
+    };
+  });
+  const graph = new ReleaseGraph(releaseGroups, options.filters);
+  await graph.init(options);
+  return graph;
+}
 var StormReleaseGroupProcessor = class extends ReleaseGroupProcessor {
   constructor(tree, workspaceConfig, projectGraph, nxReleaseConfig, releaseGraph, versionOptions) {
     super(tree, projectGraph, nxReleaseConfig, releaseGraph, {
@@ -3793,45 +4480,48 @@ var StormReleaseGroupProcessor = class extends ReleaseGroupProcessor {
       return false;
     }
     let bumped = false;
-    const firstProject = releaseGroup.projects.reduce((ret, project) => {
+    const fixedGroup = {
+      firstProject: null,
+      newVersion: null,
+      currentVersion: null
+    };
+    for (const project of releaseGroup.projects) {
       const currentVersion = this.#getCurrentCachedVersionForProject(project);
       if (!currentVersion) {
         writeTrace(
           `No current version found for project ${project} in release group ${releaseGroup.name}, skipping version comparison.`,
           this.workspaceConfig
         );
-        return "";
-      }
-      if (!ret) {
-        writeTrace(
-          `Defaulting to first version ${currentVersion} (project: ${project})`,
-          this.workspaceConfig
-        );
-        return project;
-      }
-      const largestVersion = this.#getCurrentCachedVersionForProject(ret);
-      if (!largestVersion) {
-        writeTrace(
-          `No current version found for project ${ret} in release group ${releaseGroup.name}, skipping version comparison.`,
+      } else {
+        writeDebug(
+          `Comparing versions for fixed group ${releaseGroup.name}: Current Greatest Version: ${fixedGroup.currentVersion || "none"}, Current Project Version: ${currentVersion} (project: ${project})`,
           this.workspaceConfig
         );
-        return project;
-      }
-      writeDebug(
-        `Comparing versions for fixed group ${releaseGroup.name}: Current Greatest Version: ${largestVersion}, Current Project Version: ${currentVersion} (project: ${project})`,
-        this.workspaceConfig
-      );
-      if (currentVersion && semver.gt(currentVersion, largestVersion)) {
-        return project;
+        const {
+          newVersionInput,
+          newVersionInputReason,
+          newVersionInputReasonData
+        } = await this.#determineVersionBumpForProject(releaseGroup, project);
+        if (!fixedGroup.currentVersion || currentVersion && semver.gt(currentVersion, fixedGroup.currentVersion) || !fixedGroup.newVersion || fixedGroup.newVersion.input === "none" || newVersionInput && semver.gt(newVersionInput, fixedGroup.newVersion.input)) {
+          if (!fixedGroup.currentVersion || currentVersion && semver.gt(currentVersion, fixedGroup.currentVersion)) {
+            fixedGroup.currentVersion = currentVersion;
+          }
+          if (!fixedGroup.newVersion || fixedGroup.newVersion.input === "none" || newVersionInput && semver.gt(newVersionInput, fixedGroup.newVersion.input)) {
+            fixedGroup.newVersion = {
+              input: newVersionInput,
+              reason: newVersionInputReason,
+              reasonData: newVersionInputReasonData
+            };
+          }
+          writeDebug(
+            `Fixed release group ${releaseGroup.name} updated: Current Version: ${fixedGroup.currentVersion || "none"}, New Version: ${fixedGroup.newVersion?.input || "none"} (first project: ${project})`,
+            this.workspaceConfig
+          );
+          fixedGroup.firstProject = project;
+        }
       }
-      return ret;
-    }, "");
-    const {
-      newVersionInput,
-      newVersionInputReason,
-      newVersionInputReasonData
-    } = await this.#determineVersionBumpForProject(releaseGroup, firstProject);
-    if (newVersionInput === "none") {
+    }
+    if (fixedGroup.newVersion?.input === "none") {
       let bumpedByDependency = false;
       const sortedProjects2 = this.#releaseGraph.sortedProjects.get(releaseGroup.name) || [];
       for (const project of sortedProjects2) {
@@ -3881,22 +4571,22 @@ var StormReleaseGroupProcessor = class extends ReleaseGroupProcessor {
             dockerVersion: null,
             dependentProjects: this.#getOriginalDependentProjects(project)
           });
-          if (project === firstProject) {
+          if (project === fixedGroup.firstProject) {
             continue;
           }
           const projectLogger = this.#getProjectLoggerForProject(project);
           projectLogger.buffer(
-            `\u{1F6AB} Skipping versioning for ${project} as it is a part of a fixed release group with ${firstProject} and no dependency bumps were detected`
+            `\u{1F6AB} Skipping versioning for ${project} as it is a part of a fixed release group with ${fixedGroup.firstProject} and no dependency bumps were detected`
           );
         }
       }
       return bumpedByDependency;
     }
     const { newVersion } = await this.#calculateNewVersion(
-      firstProject,
-      newVersionInput,
-      newVersionInputReason,
-      newVersionInputReasonData
+      fixedGroup.firstProject,
+      fixedGroup.newVersion?.input ?? "none",
+      fixedGroup.newVersion.reason,
+      fixedGroup.newVersion?.reasonData ?? {}
     );
     const sortedProjects = this.#releaseGraph.sortedProjects.get(releaseGroup.name) || releaseGroup.projects;
     for (const project of sortedProjects) {
@@ -3905,9 +4595,9 @@ var StormReleaseGroupProcessor = class extends ReleaseGroupProcessor {
       const currentVersion = this.#getCurrentCachedVersionForProject(
         project
       );
-      if (project !== firstProject) {
+      if (project !== fixedGroup.firstProject) {
         projectLogger.buffer(
-          `\u2753 Applied version ${newVersion} directly, because the project is a member of a fixed release group containing ${firstProject}`
+          `\u2753 Applied version ${newVersion} directly, because the project is a member of a fixed release group containing ${fixedGroup.firstProject}`
         );
       }
       const logMessages = await versionActions.updateProjectVersion(
@@ -4163,7 +4853,7 @@ var StormReleaseGroupProcessor = class extends ReleaseGroupProcessor {
         }
       }
     } else {
-      const releaseGroupText = releaseGroupName !== IMPLICIT_DEFAULT_RELEASE_GROUP ? ` in release group "${releaseGroupName}" ` : " ";
+      const releaseGroupText = releaseGroupName !== IMPLICIT_DEFAULT_RELEASE_GROUP$1 ? ` in release group "${releaseGroupName}" ` : " ";
       projectLogger.buffer(
         `\u23E9 Skipping dependent updates as "updateDependents"${releaseGroupText}is not "auto"`
       );
@@ -4346,7 +5036,7 @@ ${formatConfigLog(config5)}`,
         v.newVersion ? extractPreid(v.newVersion) : void 0
       ])
     );
-    const releaseGraph = options.releaseGraph ?? await createReleaseGraph({
+    const releaseGraph = await createReleaseGraph({
       tree: this.tree,
       projectGraph: this.projectGraph,
       nxReleaseConfig: this.releaseConfig,
@@ -4675,7 +5365,7 @@ ${Object.keys(allProjectChangelogs).map((p) => `  - ${p}`).join("\n")}
         "Failed to load the project graph. Please run `nx reset`, then run the `storm-git commit` command again."
       );
     }
-    const releaseGraph = options.releaseGraph ?? await createReleaseGraph({
+    const releaseGraph = await createReleaseGraph({
       tree: this.tree,
       projectGraph: this.projectGraph,
       nxReleaseConfig: this.releaseConfig,