Extract a pure ReleasePlanner shared by version and status

Introduce IReleasePlanner.Assemble(ReleaseInputs) -> List<ModuleChangelog>:
a pure transform that runs the changelog generator and folds in the
version computation for the release mode (Normal/Pre/Exit/Snapshot),
mirroring @changesets' shared assembleReleasePlan.

The version command now gathers inputs and calls Assemble instead of
mutating changelogs post-generation; only the impure snapshot-suffix
resolution (commit id + clock) stays in the command. The pre/snapshot
version application and prerelease graduation move into the planner.

The status command now reads pre.json and routes through the same
planner, so it reflects prerelease target versions like version does
(and like the Node tool, whose status and version share getReleasePlan).
Previously status ignored pre mode and could show the wrong versions.

Add ReleasePlannerTests covering each mode with in-memory data; migrate
the status command tests to mock IReleasePlanner + IPreStateRepository.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: JohnCampionJr

src/SolarWinds.Changesets/Commands/Status/StatusChangesetCommand.cs

@@ -21,7 +21,8 @@ internal sealed class StatusChangesetCommand : ConfigurationCommandBase<StatusCh
     private readonly IAnsiConsole _console;
     private readonly IChangesetsRepository _changesetsRepository;
     private readonly ICsProjectsRepository _csProjectsRepository;
-    private readonly IChangelogGenerator _changelogGenerator;
+    private readonly IReleasePlanner _releasePlanner;
+    private readonly IPreStateRepository _preStateRepository;
     private readonly IGitService _gitService;
     private readonly INodeChangesetService _nodeChangesetService;
     private readonly INodePackagesRepository _nodePackagesRepository;
@@ -43,7 +44,8 @@ internal sealed class StatusChangesetCommand : ConfigurationCommandBase<StatusCh
     /// <param name="console">The console.</param>
     /// <param name="changesetsRepository">The changesets repository.</param>
     /// <param name="csProjectsRepository">The .csproj repository.</param>
-    /// <param name="changelogGenerator">The changelog generator used to compute the release plan.</param>
+    /// <param name="releasePlanner">Assembles the release plan - the same planner the version command uses.</param>
+    /// <param name="preStateRepository">Reads pre.json so status reflects prerelease versions, like the version command.</param>
     /// <param name="gitService">Reads files changed since a git ref for --since.</param>
     /// <param name="nodeChangesetService">Runs the Node tool when interop autoRunNode is enabled.</param>
     /// <param name="nodePackagesRepository">Discovers Node packages so interop status can group them.</param>
@@ -52,15 +54,17 @@ public StatusChangesetCommand(
         IAnsiConsole console,
         IChangesetsRepository changesetsRepository,
         ICsProjectsRepository csProjectsRepository,
-        IChangelogGenerator changelogGenerator,
+        IReleasePlanner releasePlanner,
+        IPreStateRepository preStateRepository,
         IGitService gitService,
         INodeChangesetService nodeChangesetService,
         INodePackagesRepository nodePackagesRepository) : base(configurationService)
     {
         _console = console;
         _changesetsRepository = changesetsRepository;
         _csProjectsRepository = csProjectsRepository;
-        _changelogGenerator = changelogGenerator;
+        _releasePlanner = releasePlanner;
+        _preStateRepository = preStateRepository;
         _gitService = gitService;
         _nodeChangesetService = nodeChangesetService;
         _nodePackagesRepository = nodePackagesRepository;
@@ -111,9 +115,33 @@ public override async Task<int> ExecuteCommandAsync(CommandContext context, Stat
             csProjects = CsProjectStrategy.ToIndependent(csProjects);
         }
 
-        List<ModuleChangelog> changelogs = _changelogGenerator.GetProcessedChangelogs(changesets, csProjects, ChangesetConfig).ToList();
-        Dictionary<string, List<string>> changesetsByModule = MapChangesetsToModules(changesets);
-        Dictionary<string, BumpType> nodeBumps = ComputeNodeBumps(changesets, csProjects);
+        // Reflect prerelease mode the same way the version command does, so status never shows a different target
+        // version than the release that would follow. Snapshot has no status equivalent (there is no status --snapshot).
+        PreState? preState = await _preStateRepository.ReadAsync(Constants.ChangesetDirectoryFullPath);
+        ReleaseMode mode = preState switch
+        {
+            { Mode: PreMode.Pre } => ReleaseMode.Pre,
+            { Mode: PreMode.Exit } => ReleaseMode.Exit,
+            _ => ReleaseMode.Normal,
+        };
+
+        // In pre mode a changeset is only released once; mirror version's filtering so the plan matches.
+        ChangesetFile[] relevantChangesets = mode == ReleaseMode.Pre
+            ? changesets.Where(changeset => changeset.Id is null || !preState!.Changesets.Contains(changeset.Id, StringComparer.Ordinal)).ToArray()
+            : changesets;
+
+        List<ModuleChangelog> changelogs = _releasePlanner.Assemble(new ReleaseInputs
+        {
+            Changesets = relevantChangesets,
+            Projects = csProjects,
+            Config = ChangesetConfig,
+            Mode = mode,
+            PreTag = mode == ReleaseMode.Pre ? preState!.Tag : null,
+        });
+        // Use the same relevant set as the plan so already-consumed (pre-mode) changesets are not listed as
+        // pending changeset files or node bumps.
+        Dictionary<string, List<string>> changesetsByModule = MapChangesetsToModules(relevantChangesets);
+        Dictionary<string, BumpType> nodeBumps = ComputeNodeBumps(relevantChangesets, csProjects);
 
         if (settings.Output is not null)
         {

src/SolarWinds.Changesets/Commands/Version/Helpers/IReleasePlanner.cs

@@ -0,0 +1,68 @@
+using SolarWinds.Changesets.Shared;
+
+namespace SolarWinds.Changesets.Commands.Version.Helpers;
+
+/// <summary>
+/// The kind of release being assembled, which determines how each module's final version is computed.
+/// </summary>
+internal enum ReleaseMode
+{
+    /// <summary>A normal release: each module takes its next stable bump.</summary>
+    Normal,
+
+    /// <summary>Prerelease mode: each module takes a <c>-{tag}.{n}</c> prerelease version.</summary>
+    Pre,
+
+    /// <summary>Exiting prerelease mode: prerelease packages without a changeset graduate to stable.</summary>
+    Exit,
+
+    /// <summary>A snapshot release: each module takes a throwaway <c>{base}-{suffix}</c> version.</summary>
+    Snapshot,
+}
+
+/// <summary>
+/// The fully-gathered inputs to a release plan. All I/O (reading changesets, projects, prestate, resolving
+/// commit facts and the snapshot suffix) happens before this is built, so <see cref="IReleasePlanner.Assemble"/>
+/// stays a pure transform.
+/// </summary>
+internal sealed record ReleaseInputs
+{
+    /// <summary>The changesets to release.</summary>
+    public required ChangesetFile[] Changesets { get; init; }
+
+    /// <summary>The discovered .NET projects, already adjusted for the chosen version strategy.</summary>
+    public required IReadOnlyList<CsProject> Projects { get; init; }
+
+    /// <summary>The changeset configuration driving dependent bumps, grouping, and ignored packages.</summary>
+    public required ChangesetConfig Config { get; init; }
+
+    /// <summary>The kind of release to assemble.</summary>
+    public ReleaseMode Mode { get; init; } = ReleaseMode.Normal;
+
+    /// <summary>Per-changeset-id commit facts for the git/github changelog generators. Optional.</summary>
+    public IReadOnlyDictionary<string, ChangesetCommitInfo>? CommitInfo { get; init; }
+
+    /// <summary>The prerelease tag (e.g. <c>next</c>), required when <see cref="Mode"/> is <see cref="ReleaseMode.Pre"/>.</summary>
+    public string? PreTag { get; init; }
+
+    /// <summary>The resolved snapshot suffix, required when <see cref="Mode"/> is <see cref="ReleaseMode.Snapshot"/>.</summary>
+    public string? SnapshotSuffix { get; init; }
+
+    /// <summary>Whether snapshot versions build on the calculated next version rather than <c>0.0.0</c>.</summary>
+    public bool SnapshotUseCalculatedVersion { get; init; }
+}
+
+/// <summary>
+/// Assembles a release plan from already-gathered inputs: runs the changelog generator (dependency cascade,
+/// linked/fixed/lockstep grouping) and folds in the version computation for the release <see cref="ReleaseMode"/>.
+/// Pure - both <c>version</c> and <c>status</c> call this so they can never disagree on what a release looks like,
+/// mirroring <c>@changesets</c>' shared <c>assembleReleasePlan</c>.
+/// </summary>
+internal interface IReleasePlanner
+{
+    /// <summary>
+    /// Computes the per-module changelogs for the release, with each module's final version resolved according to
+    /// <see cref="ReleaseInputs.Mode"/>.
+    /// </summary>
+    List<ModuleChangelog> Assemble(ReleaseInputs inputs);
+}

src/SolarWinds.Changesets/Commands/Version/Helpers/ReleasePlanner.cs

@@ -0,0 +1,89 @@
+using SolarWinds.Changesets.Shared;
+
+namespace SolarWinds.Changesets.Commands.Version.Helpers;
+
+/// <inheritdoc />
+internal sealed class ReleasePlanner : IReleasePlanner
+{
+    private static readonly IReadOnlyDictionary<string, ChangesetCommitInfo> s_noCommitInfo =
+        new Dictionary<string, ChangesetCommitInfo>(StringComparer.Ordinal);
+
+    private readonly IChangelogGenerator _changelogGenerator;
+
+    public ReleasePlanner(IChangelogGenerator changelogGenerator)
+    {
+        _changelogGenerator = changelogGenerator;
+    }
+
+    /// <inheritdoc />
+    public List<ModuleChangelog> Assemble(ReleaseInputs inputs)
+    {
+        List<ModuleChangelog> changelogs = _changelogGenerator
+            .GetProcessedChangelogs(inputs.Changesets, inputs.Projects, inputs.Config, inputs.CommitInfo ?? s_noCommitInfo)
+            .ToList();
+
+        switch (inputs.Mode)
+        {
+            case ReleaseMode.Snapshot:
+                ApplySnapshotVersions(changelogs, inputs);
+                break;
+
+            case ReleaseMode.Pre:
+                ApplyPreVersions(changelogs, inputs.PreTag ?? string.Empty);
+                break;
+
+            case ReleaseMode.Exit:
+                AddPrereleaseGraduations(changelogs, inputs.Projects);
+                break;
+
+            case ReleaseMode.Normal:
+            default:
+                break;
+        }
+
+        return changelogs;
+    }
+
+    private static void ApplySnapshotVersions(List<ModuleChangelog> changelogs, ReleaseInputs inputs)
+    {
+        string suffix = inputs.SnapshotSuffix ?? string.Empty;
+
+        foreach (ModuleChangelog changelog in changelogs)
+        {
+            changelog.NewVersionOverride = ReleaseVersionPlanner.SnapshotVersion(
+                changelog, inputs.SnapshotUseCalculatedVersion, suffix);
+        }
+    }
+
+    private static void ApplyPreVersions(List<ModuleChangelog> changelogs, string tag)
+    {
+        foreach (ModuleChangelog changelog in changelogs)
+        {
+            changelog.NewVersionOverride = ReleaseVersionPlanner.PreVersion(changelog, tag);
+        }
+    }
+
+    private static void AddPrereleaseGraduations(List<ModuleChangelog> changelogs, IReadOnlyList<CsProject> csProjects)
+    {
+        // On exit, any package still on a prerelease version that has no changeset graduates to its stable version.
+        HashSet<string> covered = changelogs.Select(changelog => changelog.ModuleName).ToHashSet(StringComparer.Ordinal);
+
+        foreach (CsProject csProject in csProjects)
+        {
+            if (csProject.Version.Prerelease is null || covered.Contains(csProject.Name))
+            {
+                continue;
+            }
+
+            changelogs.Add(new ModuleChangelog
+            {
+                ModuleName = csProject.Name,
+                ModuleCsProjFilePath = csProject.CsprojFilePath,
+                CurrentVersion = csProject.Version,
+                PackageTitle = csProject.PackageId,
+                BumpTypeOverride = BumpType.Patch,
+                Changes = [],
+            });
+        }
+    }
+}

src/SolarWinds.Changesets/Commands/Version/VersionChangesetCommand.cs

@@ -15,7 +15,7 @@ internal sealed class VersionChangesetCommand : ConfigurationCommandBase<Version
     private readonly IAnsiConsole _console;
     private readonly IChangesetsRepository _changesetsRepository;
     private readonly ICsProjectsRepository _csProjFileHelper;
-    private readonly IChangelogGenerator _changelogGenerator;
+    private readonly IReleasePlanner _releasePlanner;
     private readonly IChangelogFileWriter _changelogFileWriter;
     private readonly IChangelogFormatter _changelogFormatter;
     private readonly INodeChangesetService _nodeChangesetService;
@@ -33,7 +33,7 @@ public VersionChangesetCommand(
         IConfigurationService configurationService,
         IChangesetsRepository changesetsRepository,
         ICsProjectsRepository csProjFileHelper,
-        IChangelogGenerator changelogGenerator,
+        IReleasePlanner releasePlanner,
         IChangelogFileWriter changelogFileWriter,
         IChangelogFormatter changelogFormatter,
         INodeChangesetService nodeChangesetService,
@@ -46,7 +46,7 @@ IChangelogCommitResolver commitResolver
         _console = console;
         _changesetsRepository = changesetsRepository;
         _csProjFileHelper = csProjFileHelper;
-        _changelogGenerator = changelogGenerator;
+        _releasePlanner = releasePlanner;
         _changelogFileWriter = changelogFileWriter;
         _changelogFormatter = changelogFormatter;
         _nodeChangesetService = nodeChangesetService;
@@ -126,24 +126,22 @@ public override async Task<int> ExecuteCommandAsync(CommandContext context, Vers
             ChangesetConfig.Changelog,
             Constants.WorkingDirectoryFullPath);
 
-        List<ModuleChangelog> changelogs = _changelogGenerator
-            .GetProcessedChangelogs(relevantChangesets, csProjects, ChangesetConfig, commitInfo).ToList();
+        ReleaseMode mode = snapshot ? ReleaseMode.Snapshot
+            : inPreMode ? ReleaseMode.Pre
+            : exiting ? ReleaseMode.Exit
+            : ReleaseMode.Normal;
 
-        if (snapshot)
+        List<ModuleChangelog> changelogs = _releasePlanner.Assemble(new ReleaseInputs
         {
-            await ApplySnapshotVersionsAsync(changelogs, settings);
-        }
-        else if (inPreMode)
-        {
-            foreach (ModuleChangelog changelog in changelogs)
-            {
-                changelog.NewVersionOverride = ReleaseVersionPlanner.PreVersion(changelog, preState!.Tag);
-            }
-        }
-        else if (exiting)
-        {
-            AddPrereleaseGraduations(changelogs, csProjects);
-        }
+            Changesets = relevantChangesets,
+            Projects = csProjects,
+            Config = ChangesetConfig,
+            Mode = mode,
+            CommitInfo = commitInfo,
+            PreTag = inPreMode ? preState!.Tag : null,
+            SnapshotSuffix = snapshot ? await BuildSnapshotSuffixAsync(settings) : null,
+            SnapshotUseCalculatedVersion = ChangesetConfig.Snapshot.UseCalculatedVersion,
+        });
 
         if (changelogs.Count == 0)
         {
@@ -215,7 +213,9 @@ private static string BuildNodeVersionSubcommand(VersionChangesetCommandSettings
             : "version --snapshot";
     }
 
-    private async Task ApplySnapshotVersionsAsync(List<ModuleChangelog> changelogs, VersionChangesetCommandSettings settings)
+    // Resolves the snapshot suffix - the one impure part of snapshot versioning (it may read the current commit
+    // id and the clock). The planner applies the resolved suffix purely.
+    private async Task<string> BuildSnapshotSuffixAsync(VersionChangesetCommandSettings settings)
     {
         string? template = settings.SnapshotPrereleaseTemplate ?? ChangesetConfig.Snapshot.PrereleaseTemplate;
         string? tag = settings.Snapshot.Value;
@@ -224,37 +224,7 @@ private async Task ApplySnapshotVersionsAsync(List<ModuleChangelog> changelogs,
             ? await _gitService.GetCurrentCommitIdAsync(Constants.WorkingDirectoryFullPath)
             : null;
 
-        string suffix = SnapshotSuffix.Build(template, tag, commit, DateTimeOffset.UtcNow);
-
-        foreach (ModuleChangelog changelog in changelogs)
-        {
-            changelog.NewVersionOverride = ReleaseVersionPlanner.SnapshotVersion(
-                changelog, ChangesetConfig.Snapshot.UseCalculatedVersion, suffix);
-        }
-    }
-
-    private static void AddPrereleaseGraduations(List<ModuleChangelog> changelogs, CsProject[] csProjects)
-    {
-        // On exit, any package still on a prerelease version that has no changeset graduates to its stable version.
-        HashSet<string> covered = changelogs.Select(changelog => changelog.ModuleName).ToHashSet(StringComparer.Ordinal);
-
-        foreach (CsProject csProject in csProjects)
-        {
-            if (csProject.Version.Prerelease is null || covered.Contains(csProject.Name))
-            {
-                continue;
-            }
-
-            changelogs.Add(new ModuleChangelog
-            {
-                ModuleName = csProject.Name,
-                ModuleCsProjFilePath = csProject.CsprojFilePath,
-                CurrentVersion = csProject.Version,
-                PackageTitle = csProject.PackageId,
-                BumpTypeOverride = BumpType.Patch,
-                Changes = [],
-            });
-        }
+        return SnapshotSuffix.Build(template, tag, commit, DateTimeOffset.UtcNow);
     }
 
     private void WarnOnUnknownChangesetNames(ChangesetFile[] changesets, CsProject[] csProjects)

src/SolarWinds.Changesets/Program.cs

@@ -32,6 +32,7 @@
 serviceCollection.AddSingleton<IChangesetsRepository, ChangesetsRepository>();
 serviceCollection.AddSingleton<IChangelogFileWriter, ChangelogFileWriter>();
 serviceCollection.AddSingleton<IChangelogGenerator, ChangelogGenerator>();
+serviceCollection.AddSingleton<IReleasePlanner, ReleasePlanner>();
 serviceCollection.AddSingleton<IChangelogCommitResolver, ChangelogCommitResolver>();
 serviceCollection.AddSingleton<IChangelogFormatter, ChangelogFormatter>();
 serviceCollection.AddSingleton<ICsProjectsRepository, CsProjectsRepository>();