@storm-software/git-tools 2.131.16 → 2.131.18

package/bin/git.cjs

@@ -57,7 +57,6 @@ var semver = require('semver');
 var release = require('nx/release');
 var versionPlans = require('nx/src/command-line/release/config/version-plans');
 var printChanges_js = require('nx/src/command-line/release/utils/print-changes.js');
-var releaseGraph = require('nx/src/command-line/release/utils/release-graph');
 var versionPlanUtils = require('nx/src/command-line/release/utils/version-plan-utils');
 var tree = require('nx/src/generators/tree');
 var fileMapUtils = require('nx/src/project-graph/file-map-utils');
@@ -66,6 +65,15 @@ var DefaultChangelogRenderer = require('nx/release/changelog-renderer');
 var conventionalCommits = require('nx/src/command-line/release/config/conventional-commits');
 var nxJson = require('nx/src/config/nx-json');
 var findMatchingProjects = require('nx/src/utils/find-matching-projects');
+var config$1 = require('nx/src/command-line/release/config/config');
+var repositoryGitTags = require('nx/src/command-line/release/utils/repository-git-tags');
+var projectLogger = require('nx/src/command-line/release/version/project-logger');
+var resolveCurrentVersion = require('nx/src/command-line/release/version/resolve-current-version');
+var topologicalSort = require('nx/src/command-line/release/version/topological-sort');
+var versionActions = require('nx/src/command-line/release/version/version-actions');
+var affectedProjectGraph = require('nx/src/project-graph/affected/affected-project-graph');
+var fileUtils = require('nx/src/project-graph/file-utils');
+var gte = require('semver/functions/gte');
 var config_js = require('nx/src/command-line/release/config/config.js');
 var deriveSpecifierFromConventionalCommits = require('nx/src/command-line/release/version/derive-specifier-from-conventional-commits');
 var deriverSpecifierFromVersionPlans = require('nx/src/command-line/release/version/deriver-specifier-from-version-plans');
@@ -95,6 +103,7 @@ var chalk__default = /*#__PURE__*/_interopDefault(chalk);
 var semver__default = /*#__PURE__*/_interopDefault(semver);
 var importsPlugin__default = /*#__PURE__*/_interopDefault(importsPlugin);
 var DefaultChangelogRenderer__default = /*#__PURE__*/_interopDefault(DefaultChangelogRenderer);
+var gte__default = /*#__PURE__*/_interopDefault(gte);
 
 function parseCargoToml(cargoString) {
   if (!cargoString) {
@@ -3612,6 +3621,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 = 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.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: versionActions$1,
+            afterAllProjectsVersioned
+          } = await versionActions.resolveVersionActionsForProject(
+            tree,
+            releaseGroup,
+            projectGraphNode,
+            finalConfigForProject
+          );
+          if (!this.uniqueAfterAllProjectsVersioned.has(versionActionsPath)) {
+            this.uniqueAfterAllProjectsVersioned.set(
+              versionActionsPath,
+              afterAllProjectsVersioned
+            );
+          }
+          let versionActionsToUse = versionActions$1;
+          const shouldSkip = shared.shouldSkipVersionActions(
+            finalConfigForProject.dockerOptions,
+            project
+          );
+          if (shouldSkip) {
+            versionActionsToUse = new versionActions.NOOP_VERSION_ACTIONS(
+              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 === config$1.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: git.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 git.getLatestGitTagForPattern(
+              releaseTagPattern,
+              additionalInterpolationData,
+              this.resolveRepositoryTags.bind(this),
+              options
+            );
+            const projectReleaseTag = await git.getLatestGitTagForPattern(
+              releaseTagPattern.includes("{releaseGroupName}") ? releaseTagPattern.replace(
+                /\{releaseGroupName\}/g,
+                "{projectName}"
+              ) : `{projectName}@${releaseTagPattern}`,
+              additionalInterpolationData,
+              this.resolveRepositoryTags.bind(this),
+              options
+            );
+            if (projectReleaseTag?.extractedVersion && groupReleaseTag?.extractedVersion && gte__default.default(
+              projectReleaseTag.extractedVersion,
+              groupReleaseTag.extractedVersion
+            )) {
+              latestMatchingGitTag = projectReleaseTag;
+            } else {
+              latestMatchingGitTag = groupReleaseTag;
+            }
+          } else {
+            latestMatchingGitTag = await git.getLatestGitTagForPattern(
+              releaseTagPattern,
+              additionalInterpolationData,
+              this.resolveRepositoryTags.bind(this),
+              options
+            );
+          }
+          this.cachedLatestMatchingGitTag.set(
+            projectName,
+            latestMatchingGitTag
+          );
+          const currentVersion = await resolveCurrentVersion.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.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.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 = shared.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 = fileUtils.calculateFileChanges(commit.affectedFiles, {
+      base: `${commit.shortHash}^`,
+      head: commit.shortHash
+    });
+    affectedGraph = await affectedProjectGraph.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.ReleaseGroupProcessor {
   constructor(tree, workspaceConfig, projectGraph, nxReleaseConfig, releaseGraph, versionOptions) {
     super(tree, projectGraph, nxReleaseConfig, releaseGraph, {
@@ -3817,45 +4505,48 @@ var StormReleaseGroupProcessor = class extends releaseGroupProcessor.ReleaseGrou
       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) {
         chunkOOFHIS6Q_cjs.writeTrace(
           `No current version found for project ${project} in release group ${releaseGroup.name}, skipping version comparison.`,
           this.workspaceConfig
         );
-        return "";
-      }
-      if (!ret) {
-        chunkOOFHIS6Q_cjs.writeTrace(
-          `Defaulting to first version ${currentVersion} (project: ${project})`,
-          this.workspaceConfig
-        );
-        return project;
-      }
-      const largestVersion = this.#getCurrentCachedVersionForProject(ret);
-      if (!largestVersion) {
-        chunkOOFHIS6Q_cjs.writeTrace(
-          `No current version found for project ${ret} in release group ${releaseGroup.name}, skipping version comparison.`,
+      } else {
+        chunkOOFHIS6Q_cjs.writeDebug(
+          `Comparing versions for fixed group ${releaseGroup.name}: Current Greatest Version: ${fixedGroup.currentVersion || "none"}, Current Project Version: ${currentVersion} (project: ${project})`,
           this.workspaceConfig
         );
-        return project;
-      }
-      chunkOOFHIS6Q_cjs.writeDebug(
-        `Comparing versions for fixed group ${releaseGroup.name}: Current Greatest Version: ${largestVersion}, Current Project Version: ${currentVersion} (project: ${project})`,
-        this.workspaceConfig
-      );
-      if (currentVersion && semver__default.default.gt(currentVersion, largestVersion)) {
-        return project;
+        const {
+          newVersionInput,
+          newVersionInputReason,
+          newVersionInputReasonData
+        } = await this.#determineVersionBumpForProject(releaseGroup, project);
+        if (!fixedGroup.currentVersion || currentVersion && semver__default.default.gt(currentVersion, fixedGroup.currentVersion) || !fixedGroup.newVersion || fixedGroup.newVersion.input === "none" || newVersionInput && semver__default.default.gt(newVersionInput, fixedGroup.newVersion.input)) {
+          if (!fixedGroup.currentVersion || currentVersion && semver__default.default.gt(currentVersion, fixedGroup.currentVersion)) {
+            fixedGroup.currentVersion = currentVersion;
+          }
+          if (!fixedGroup.newVersion || fixedGroup.newVersion.input === "none" || newVersionInput && semver__default.default.gt(newVersionInput, fixedGroup.newVersion.input)) {
+            fixedGroup.newVersion = {
+              input: newVersionInput,
+              reason: newVersionInputReason,
+              reasonData: newVersionInputReasonData
+            };
+          }
+          chunkOOFHIS6Q_cjs.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) {
@@ -3905,22 +4596,22 @@ var StormReleaseGroupProcessor = class extends releaseGroupProcessor.ReleaseGrou
             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) {
@@ -3929,9 +4620,9 @@ var StormReleaseGroupProcessor = class extends releaseGroupProcessor.ReleaseGrou
       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(
@@ -4370,7 +5061,7 @@ ${formatConfigLog(config5)}`,
         v.newVersion ? extractPreid(v.newVersion) : void 0
       ])
     );
-    const releaseGraph$1 = options.releaseGraph ?? await releaseGraph.createReleaseGraph({
+    const releaseGraph = await createReleaseGraph({
       tree: this.tree,
       projectGraph: this.projectGraph,
       nxReleaseConfig: this.releaseConfig,
@@ -4382,7 +5073,7 @@ ${formatConfigLog(config5)}`,
       verbose: chunkOOFHIS6Q_cjs.isVerbose(this.workspaceConfig.logLevel)
     });
     const projectToAdditionalDependencyBumps = /* @__PURE__ */ new Map();
-    for (const releaseGroup of releaseGraph$1.releaseGroups) {
+    for (const releaseGroup of releaseGraph.releaseGroups) {
       if (releaseGroup.projectsRelationship !== "independent") {
         continue;
       }
@@ -4410,12 +5101,12 @@ ${formatConfigLog(config5)}`,
       }
     }
     const allProjectChangelogs = {};
-    for (const releaseGroup of releaseGraph$1.releaseGroups) {
+    for (const releaseGroup of releaseGraph.releaseGroups) {
       const config5 = releaseGroup.changelog;
       if (config5 === false) {
         continue;
       }
-      if (!releaseGraph$1.releaseGroupToFilteredProjects.has(releaseGroup)) {
+      if (!releaseGraph.releaseGroupToFilteredProjects.has(releaseGroup)) {
         throw new Error(
           `No filtered projects found for release group ${releaseGroup.name}`
         );
@@ -4424,7 +5115,7 @@ ${formatConfigLog(config5)}`,
         // 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
-          releaseGraph$1.releaseGroupToFilteredProjects.get(releaseGroup)
+          releaseGraph.releaseGroupToFilteredProjects.get(releaseGroup)
         ).flatMap((project) => {
           return [
             project,
@@ -4447,7 +5138,7 @@ ${formatConfigLog(config5)}`,
               projectName: project.name,
               releaseGroupName: releaseGroup.name
             },
-            releaseGraph$1.resolveRepositoryTags.bind(releaseGraph$1),
+            releaseGraph.resolveRepositoryTags.bind(releaseGraph),
             {
               checkAllBranchesWhen: releaseGroup.releaseTag.checkAllBranchesWhen,
               preid: projectsPreid[project.name] || this.workspaceConfig.preid,
@@ -4541,7 +5232,7 @@ ${formatConfigLog(config5)}`,
           {
             releaseGroupName: releaseGroup.name
           },
-          releaseGraph$1.resolveRepositoryTags.bind(releaseGraph$1),
+          releaseGraph.resolveRepositoryTags.bind(releaseGraph),
           {
             checkAllBranchesWhen: releaseGroup.releaseTag.checkAllBranchesWhen,
             preid: Object.keys(projectsPreid)[0] && projectsPreid?.[Object.keys(projectsPreid)[0]] ? projectsPreid?.[Object.keys(projectsPreid)[0]] : this.workspaceConfig.preid,
@@ -4699,7 +5390,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$1 = options.releaseGraph ?? await releaseGraph.createReleaseGraph({
+    const releaseGraph = await createReleaseGraph({
       tree: this.tree,
       projectGraph: this.projectGraph,
       nxReleaseConfig: this.releaseConfig,
@@ -4712,26 +5403,26 @@ ${Object.keys(allProjectChangelogs).map((p) => `  - ${p}`).join("\n")}
       preid: options.preid ?? this.workspaceConfig.preid,
       versionActionsOptionsOverrides: options.versionActionsOptionsOverrides
     });
-    if (releaseGraph$1.filterLog && process.env.NX_RELEASE_INTERNAL_SUPPRESS_FILTER_LOG !== "true") {
-      chunkOOFHIS6Q_cjs.writeDebug(formatNxLog(releaseGraph$1.filterLog), this.workspaceConfig);
+    if (releaseGraph.filterLog && process.env.NX_RELEASE_INTERNAL_SUPPRESS_FILTER_LOG !== "true") {
+      chunkOOFHIS6Q_cjs.writeDebug(formatNxLog(releaseGraph.filterLog), this.workspaceConfig);
     }
     if (!options.specifier) {
       const rawVersionPlans = await versionPlans.readRawVersionPlans();
       await versionPlans.setResolvedVersionPlansOnGroups(
         rawVersionPlans,
-        releaseGraph$1.releaseGroups,
+        releaseGraph.releaseGroups,
         Object.keys(this.projectGraph.nodes),
         verbose
       );
       const versionPlanValidationError = versionPlanUtils.validateResolvedVersionPlansAgainstFilter(
-        releaseGraph$1.releaseGroups,
-        releaseGraph$1.releaseGroupToFilteredProjects
+        releaseGraph.releaseGroups,
+        releaseGraph.releaseGroupToFilteredProjects
       );
       if (versionPlanValidationError) {
         throw new Error(formatNxLog(versionPlanValidationError));
       }
     } else {
-      if (verbose && releaseGraph$1.releaseGroups.some((g) => !!g.versionPlans)) {
+      if (verbose && releaseGraph.releaseGroups.some((g) => !!g.versionPlans)) {
         chunkOOFHIS6Q_cjs.writeDebug(
           `Skipping version plan discovery as a specifier was provided`,
           this.workspaceConfig
@@ -4770,8 +5461,8 @@ ${Object.keys(allProjectChangelogs).map((p) => `  - ${p}`).join("\n")}
         );
       }
     }
-    for (const groupName of releaseGraph$1.sortedReleaseGroups) {
-      const releaseGroup = releaseGraph$1.releaseGroups.find(
+    for (const groupName of releaseGraph.sortedReleaseGroups) {
+      const releaseGroup = releaseGraph.releaseGroups.find(
         (g) => g.name === groupName
       );
       if (!releaseGroup) {
@@ -4808,7 +5499,7 @@ ${Object.keys(allProjectChangelogs).map((p) => `  - ${p}`).join("\n")}
         }
       }
     }
-    await releaseGraph$1.validate(this.tree);
+    await releaseGraph.validate(this.tree);
     const commitMessage = options.gitCommitMessage || this.releaseConfig.version?.git?.commitMessage;
     const additionalChangedFiles = /* @__PURE__ */ new Set();
     const additionalDeletedFiles = /* @__PURE__ */ new Set();
@@ -4817,7 +5508,7 @@ ${Object.keys(allProjectChangelogs).map((p) => `  - ${p}`).join("\n")}
       this.workspaceConfig,
       this.projectGraph,
       this.releaseConfig,
-      releaseGraph$1,
+      releaseGraph,
       options
     );
     try {
@@ -4867,8 +5558,8 @@ ${Object.keys(allProjectChangelogs).map((p) => `  - ${p}`).join("\n")}
         );
       }
     }
-    for (const groupName of releaseGraph$1.sortedReleaseGroups) {
-      const releaseGroup = releaseGraph$1.releaseGroups.find(
+    for (const groupName of releaseGraph.sortedReleaseGroups) {
+      const releaseGroup = releaseGraph.releaseGroups.find(
         (g) => g.name === groupName
       );
       if (!releaseGroup) {
@@ -4905,7 +5596,7 @@ ${Object.keys(allProjectChangelogs).map((p) => `  - ${p}`).join("\n")}
         }
       }
     }
-    if (this.releaseConfig.docker || releaseGraph$1.releaseGroups.some((rg) => rg.docker)) {
+    if (this.releaseConfig.docker || releaseGraph.releaseGroups.some((rg) => rg.docker)) {
       chunkOOFHIS6Q_cjs.writeWarning(
         formatNxLog({
           title: "Warning",
@@ -4921,17 +5612,17 @@ ${Object.keys(allProjectChangelogs).map((p) => `  - ${p}`).join("\n")}
     );
     const versionData = processor.getVersionData();
     const gitTagValues = options.gitTag ?? this.releaseConfig.version?.git?.tag ? shared.createGitTagValues(
-      releaseGraph$1.releaseGroups,
-      releaseGraph$1.releaseGroupToFilteredProjects,
+      releaseGraph.releaseGroups,
+      releaseGraph.releaseGroupToFilteredProjects,
       versionData
     ) : [];
     shared.handleDuplicateGitTags(gitTagValues);
     let workspaceVersion = void 0;
-    if (releaseGraph$1.releaseGroups.length === 1) {
-      const releaseGroup = releaseGraph$1.releaseGroups[0];
+    if (releaseGraph.releaseGroups.length === 1) {
+      const releaseGroup = releaseGraph.releaseGroups[0];
       if (releaseGroup?.projectsRelationship === "fixed") {
         const releaseGroupProjectNames = Array.from(
-          releaseGraph$1.releaseGroupToFilteredProjects.get(releaseGroup)
+          releaseGraph.releaseGroupToFilteredProjects.get(releaseGroup)
         );
         workspaceVersion = versionData[releaseGroupProjectNames[0]].newVersion;
       }
@@ -4945,7 +5636,7 @@ ${Object.keys(allProjectChangelogs).map((p) => `  - ${p}`).join("\n")}
       return {
         workspaceVersion,
         projectsVersionData: versionData,
-        releaseGraph: releaseGraph$1
+        releaseGraph
       };
     }
     if (options.gitCommit ?? this.releaseConfig.version?.git?.commit) {
@@ -4955,8 +5646,8 @@ ${Object.keys(allProjectChangelogs).map((p) => `  - ${p}`).join("\n")}
         isDryRun: !!options.dryRun,
         isVerbose: !!options.verbose,
         gitCommitMessages: shared.createCommitMessageValues(
-          releaseGraph$1.releaseGroups,
-          releaseGraph$1.releaseGroupToFilteredProjects,
+          releaseGraph.releaseGroups,
+          releaseGraph.releaseGroupToFilteredProjects,
           versionData,
           commitMessage
         ),
@@ -4995,7 +5686,7 @@ ${Object.keys(allProjectChangelogs).map((p) => `  - ${p}`).join("\n")}
     return {
       workspaceVersion,
       projectsVersionData: versionData,
-      releaseGraph: releaseGraph$1
+      releaseGraph
     };
   };
 };