Extend front-door delegation to status/publish; refresh docs and roadmap

- status and publish now delegate to the Node tool when there are no .NET
  projects (with autoRunNode), matching version; snapshot version passes
  its tag through when delegating.
- The delegation loop guard is set on the Node child process only (via a
  new IProcessExecutor environment overload), never on net's own process,
  so it cannot leak between invocations.
- docs/config-file-options.md rewritten for the dotnet-nested schema and
  all keys; ROADMAP.md updated (the GitHub Action already ships).

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

Author: JohnCampionJr

.changeset/delegation-status-publish.md

@@ -0,0 +1,5 @@
+---
+"SolarWinds.Changesets": Minor
+---
+
+Extend front-door delegation to every release command. With `autoRunNode`, `status` and `publish` now delegate to the Node tool in a repository with no .NET projects (matching `version`), and a snapshot `version --snapshot <tag>` passes its tag through to the Node tool when delegating. The delegation loop guard is now set on the Node child process only (never on net's own environment), so it cannot leak between invocations.

ROADMAP.md

@@ -1,26 +1,27 @@
-# Roadmap
+# Roadmap
 
-**`net-changesets`** is currently in the **MVP stage**, meaning it includes the basic functionality to:
+**`net-changesets`** covers the full changesets workflow:
 
-- Create changesets
-- Bump versions and generates changelogs
-- Push packages to a specified NuGet source
+- Create changesets (`add`)
+- Bump versions and generate changelogs (`version`)
+- Show the pending release plan (`status`, `info`)
+- Enter/exit prerelease mode and cut snapshot releases (`pre`, `version --snapshot`)
+- Tag and publish packages to a NuGet source (`tag`, `publish`)
+- Interoperate with the Node [`@changesets`](https://github.com/changesets/changesets) tool in one
+  repository (`interop`, `autoRunNode`)
 
-Unfortunately, these actions must currently be performed **manually** via the CLI tool `net-changeset`.
+## ✅ GitHub Action
 
-Several features and improvements are planned for future releases.
+A composite GitHub Action ships in [`.github/actions/changesets`](.github/actions/changesets). It mirrors
+[`@changesets/action`](https://github.com/changesets/action): when changesets are pending it runs the version
+command and opens/updates a "Version Packages" pull request, and otherwise runs the publish command. The
+version/publish/status commands are configurable, and in interop mode the tool's own `autoRunNode` chains to
+the Node tool so a single action drives both ecosystems.
 
-## 🚧 net-changesets GitHub Action
+## Planned features
 
-The main missing component of net-changesets is the GitHub action that will automate the process
-of creating a pull request with updated package versions and changelogs based on the changesets in your repository.
-For reference, see the original implementation of the [changesets action](https://github.com/changesets/action).
+- **Changelog generators.** Beyond the default format, support the `changelog-git` (commit-hash prefix) and
+  `changelog-github` (PR links, commit links, and author thanks) generators, selected via the `changelog`
+  config key.
 
-We can use **.NET** to develop a custom GitHub Action — see the official [documentation](https://learn.microsoft.com/en-us/dotnet/devops/create-dotnet-github-action).
-
-The plan is to develop the GitHub Action **within this repository**, allowing us to reuse as much existing code as possible.
-
-## Other features
-
-While no specific features are planned at the moment, there is plenty of room for improving the existing functionality.
-If you have an idea or suggestion, feel free to [open a GitHub issue](./issues) to start a discussion.
+Have an idea or suggestion? [Open a GitHub issue](./issues) to start a discussion.

docs/config-file-options.md

@@ -1,35 +1,95 @@
-# Configuring Changesets
+# Configuring net-changesets
 
-Changesets has a minimal amount of configuration options. Mostly these are for when you need to change the default workflows. These are stored in `.changeset/config.json`. The default config is:
+Configuration lives in `.changeset/config.json`. net-changesets shares the [`@changesets`](https://github.com/changesets/changesets)
+config schema so a polyglot repository can keep a single file both tools understand: the standard changesets
+keys at the top level, and the .NET-only settings nested under a `dotnet` key (which the Node tool ignores).
+
+`changeset init` writes a minimal config; every key below has a default, so you only set what you need.
 
 ```json
 {
-    "sourcePath": "src",
+  "baseBranch": "main",
+  "access": "restricted",
+  "ignore": [],
+  "fixed": [],
+  "linked": [],
+  "updateInternalDependencies": "patch",
+  "format": false,
+  "dotnet": {
+    "sourcePath": ".",
     "packageSource": "nuget"
+  }
 }
 ```
 
-## `sourcePath`
+## Shared keys
 
-Specify the relative path from the changeset command's execution folder to the location of the projects.
+These mirror `@changesets`. net-changesets reads the ones below and ignores any others (such as `commit`,
+`changelog`, or `access` beyond what it needs), so a stock Node config loads cleanly.
 
-The default value is `.` (the working directory): when `sourcePath` is not set, projects are discovered from the whole repository. The scan always skips `node_modules`, `.git`, `bin`, and `obj`.
+### `baseBranch`
 
-## `packageSource`
+The branch releases are cut from, used by `status --since` and the release action. Default `main`.
 
-Specify the NuGet package source where the packages will be published.
+### `updateInternalDependencies`
 
-Default value is `nuget`. It is official [nuget.org](https://www.nuget.org/) repository.
+How a package that depends on a changed package is bumped: `patch` (default) or `minor`. Because a
+`ProjectReference` carries no version range, a changed dependency is always "out of range", so dependents are
+always **patch**-bumped to match `@changesets` — this option does not change that for .NET projects.
 
-You can define NuGet package sources using `nuget.config`. To create a default `nuget.config`, use the following CLI command:
+### `fixed`
 
-```bash
-dotnet new nugetconfig
+Groups of packages always released together at the same version when any member changes — including members
+that had no changes. An array of arrays of project names, e.g. `[["Acme.Core", "Acme.Client"]]`.
+
+### `linked`
+
+Groups of packages coordinated to the same version, but only the members that are actually being released.
+Same shape as `fixed`.
+
+### `ignore`
+
+Packages excluded from versioning. An array of project names or globs to skip, e.g. `["Acme.Internal", "Acme.Samples.*"]`.
+
+### `format`
+
+The formatter run over generated changelogs: a formatter name (`prettier`, `dprint`, `biome`, `oxfmt`, `deno`),
+`"auto"` to detect one from the repo, or `false` (the default) to skip formatting.
+
+### `snapshot`
+
+Snapshot-release settings, matching `@changesets`:
+
+```json
+"snapshot": {
+  "useCalculatedVersion": false,
+  "prereleaseTemplate": "{tag}-{datetime}"
+}
 ```
 
-This allows you to specify your own NuGet package sources. For example, you can define the `.\NugetFolderSource` folder as a source.
+- `useCalculatedVersion` — when `true`, snapshot versions use the next calculated version as the base instead
+  of `0.0.0`.
+- `prereleaseTemplate` — the suffix template, supporting `{tag}`, `{commit}`, `{datetime}`, and `{timestamp}`.
+  When unset the suffix is `{tag}-{datetime}` (or just `{datetime}` with no tag).
+
+## `dotnet` keys
+
+The .NET-only settings, nested so the Node tool ignores them.
+
+### `sourcePath`
 
-Using folder sources is the best way to verify the output of your changesets setup!
+The relative path from the changeset command's execution folder to the location of your projects. Default
+`.` (the whole repository): when unset, projects are discovered from the working directory down. The scan
+always skips `node_modules`, `.git`, `bin`, and `obj`. Set it (for example `"src"`) to narrow the scan.
+
+### `packageSource`
+
+The NuGet package source `publish` pushes to. Default `nuget` (the official [nuget.org](https://www.nuget.org/)
+feed). Define your own sources in a `nuget.config`:
+
+```bash
+dotnet new nugetconfig
+```
 
 ```xml
 <?xml version="1.0" encoding="utf-8"?>
@@ -41,3 +101,37 @@ Using folder sources is the best way to verify the output of your changesets set
   </packageSources>
 </configuration>
 ```
+
+Folder sources are the easiest way to verify your changesets setup end to end.
+
+### `versionStrategy`
+
+How a bump is written for projects whose version comes from a shared `Directory.Build.props`: `lockstep`
+(default) bumps the shared value so the group moves together, or `independent` writes an inline `<Version>`
+per project. The `version --independent` flag overrides this for a single run.
+
+### `interop`
+
+Run net-changesets alongside the Node `@changesets` tool in one `.changeset/` folder. Default `false` (net
+owns every `*.md` changeset and deletes them on `version`). When `true`, net also reads
+[`changesetExtension`](#changesetextension) files, only versions changesets that name .NET projects, and never
+deletes a Node changeset — a shared changeset keeps its Node remainder for the Node tool. See the
+["Using alongside @changesets" section of the README](../README.md#using-alongside-changesets-node).
+
+### `changesetExtension`
+
+The extension net-changesets owns when `interop` is on. Must not end in `.md` so the Node reader skips it.
+Default `.net.mkd` (editors still highlight it as markdown, and `.net.` marks a .NET changeset).
+
+### `autoRunNode`
+
+Make net-changesets a front door to the Node tool. Default `false`. When `true`, a single `changeset version`
+versions the .NET side and then runs the Node tool ([`nodeChangesetCommand`](#nodechangesetcommand)); in a
+repository with no .NET projects it delegates to the Node tool entirely. Do not point `nodeChangesetCommand`
+back at net (use `npx changeset`); net guards against an accidental loop, but a distinct command is clearer.
+
+### `nodeChangesetCommand`
+
+The command used to invoke the Node tool when `autoRunNode` is on. Default `npx changeset`. Set it to
+`pnpm changeset`, `yarn changeset`, or any custom invocation. The subcommand (for example `version`) is
+appended.

src/SolarWinds.Changesets/Commands/Publish/PublishChangesetCommand.cs

@@ -51,6 +51,14 @@ public override async Task<int> ExecuteCommandAsync(CommandContext context, Publ
         _console.WriteLine();
 
         CsProject[] csProjects = _csProjectsRepository.GetCsProjects(ChangesetConfig);
+
+        // Front door: no .NET projects to publish, so the publish is the Node tool's.
+        if (csProjects.Length == 0 && ChangesetConfig.AutoRunNode && NodeDelegation.NotAlreadyDelegated)
+        {
+            _console.WriteLine("No .NET projects found; delegating to the Node changeset tool.");
+            return await RunNodePublishAsync();
+        }
+
         List<CsProject> projectsToPublish = await GetProjectsToPublishAsync(csProjects);
 
         if (projectsToPublish.Count == 0)
@@ -101,7 +109,7 @@ await PackageTagger.CreateMissingTagsAsync(
 
             _console.MarkupLine("[green]Changeset publish finished.[/]");
 
-            if (ChangesetConfig.Interop && ChangesetConfig.AutoRunNode)
+            if (ChangesetConfig.Interop && ChangesetConfig.AutoRunNode && NodeDelegation.NotAlreadyDelegated)
             {
                 return await RunNodePublishAsync();
             }

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

@@ -99,6 +99,13 @@ public override async Task<int> ExecuteCommandAsync(CommandContext context, Stat
         }
 
         CsProject[] csProjects = _csProjectsRepository.GetCsProjects(ChangesetConfig);
+
+        // Front door: no .NET projects, so the status is the Node tool's to report.
+        if (csProjects.Length == 0 && ChangesetConfig.AutoRunNode && NodeDelegation.NotAlreadyDelegated)
+        {
+            return await RunNodeStatusAsync();
+        }
+
         if (ChangesetConfig.VersionStrategy == VersionStrategy.Independent)
         {
             csProjects = CsProjectStrategy.ToIndependent(csProjects);
@@ -117,7 +124,7 @@ public override async Task<int> ExecuteCommandAsync(CommandContext context, Stat
             WritePackagesToBeBumped(changelogs, nodeBumps, changesetsByModule, settings.Verbose);
         }
 
-        if (ChangesetConfig.Interop && ChangesetConfig.AutoRunNode)
+        if (ChangesetConfig.Interop && ChangesetConfig.AutoRunNode && NodeDelegation.NotAlreadyDelegated)
         {
             return await RunNodeStatusAsync();
         }

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

@@ -24,6 +24,10 @@ public async Task<ProcessOutput> RunAsync(string command, string subcommand, str
         string executable = parts[0];
         string arguments = string.Join(' ', parts.Skip(1).Append(subcommand));
 
-        return await _processExecutor.Execute(executable, arguments, workingDirectoryPath);
+        // Mark the child as delegated-to, so a nodeChangesetCommand that resolves back to net is caught on the
+        // next hop instead of recursing forever. Set on the child only - never on net's own environment.
+        Dictionary<string, string> environment = new(StringComparer.Ordinal) { [NodeDelegation.GuardVariable] = "1" };
+
+        return await _processExecutor.Execute(executable, arguments, workingDirectoryPath, environment);
     }
 }

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

@@ -94,10 +94,12 @@ public override async Task<int> ExecuteCommandAsync(CommandContext context, Vers
         // delegate to the Node tool when autoRunNode is set; otherwise guide the user and leave changesets be.
         if (csProjects.Length == 0)
         {
-            if (ChangesetConfig.AutoRunNode && NotAlreadyDelegated && !snapshot && !inPreMode && !exiting)
+            if (ChangesetConfig.AutoRunNode && NodeDelegation.NotAlreadyDelegated)
             {
+                // Front door: nothing .NET to do, so the whole release is the Node tool's. A snapshot run
+                // passes its tag through; prerelease mode needs no flag (the Node tool reads its own pre.json).
                 _console.WriteLine("No .NET projects found; delegating to the Node changeset tool.");
-                return await RunNodeVersionAsync();
+                return await RunNodeVersionAsync(BuildNodeVersionSubcommand(settings, snapshot));
             }
 
             WarnNoDotnetProjects();
@@ -183,20 +185,26 @@ await _changesetsRepository.CleanupProcessedChangesetsAsync(
 
         _console.WriteLine(message);
 
-        if (ChangesetConfig.Interop && ChangesetConfig.AutoRunNode && NotAlreadyDelegated && !snapshot && !inPreMode && !exiting)
+        if (ChangesetConfig.Interop && ChangesetConfig.AutoRunNode && NodeDelegation.NotAlreadyDelegated && !snapshot && !inPreMode && !exiting)
         {
-            return await RunNodeVersionAsync();
+            return await RunNodeVersionAsync("version");
         }
 
         return 0;
     }
 
-    // Set on the child environment when net delegates to (or auto-runs) the Node tool, so that a
-    // nodeChangesetCommand mistakenly pointing back at net is caught instead of recursing forever.
-    private const string DelegationGuardVariable = "NET_CHANGESETS_DELEGATED";
+    // The Node `version` subcommand, carrying a snapshot tag through when this is a snapshot run.
+    private static string BuildNodeVersionSubcommand(VersionChangesetCommandSettings settings, bool snapshot)
+    {
+        if (!snapshot)
+        {
+            return "version";
+        }
 
-    private static bool NotAlreadyDelegated =>
-        Environment.GetEnvironmentVariable(DelegationGuardVariable) is not "1";
+        return settings.Snapshot.Value is { Length: > 0 } tag
+            ? $"version --snapshot {tag}"
+            : "version --snapshot";
+    }
 
     private async Task ApplySnapshotVersionsAsync(List<ModuleChangelog> changelogs, VersionChangesetCommandSettings settings)
     {
@@ -315,15 +323,12 @@ private void DeleteOwnedChangesets(ChangesetFile[] changesets, CsProject[] csPro
         _changesetsRepository.DeleteChangesets(Constants.ChangesetDirectoryFullPath, ownedIds);
     }
 
-    private async Task<int> RunNodeVersionAsync()
+    private async Task<int> RunNodeVersionAsync(string subcommand)
     {
-        // Inherited by the Node process; breaks the loop if nodeChangesetCommand resolves back to net.
-        Environment.SetEnvironmentVariable(DelegationGuardVariable, "1");
-
-        _console.WriteLine($"Running '{ChangesetConfig.NodeChangesetCommand} version' for the Node packages...");
+        _console.WriteLine($"Running '{ChangesetConfig.NodeChangesetCommand} {subcommand}' for the Node packages...");
 
         ProcessOutput result = await _nodeChangesetService.RunAsync(
-            ChangesetConfig.NodeChangesetCommand, "version", Constants.WorkingDirectoryFullPath);
+            ChangesetConfig.NodeChangesetCommand, subcommand, Constants.WorkingDirectoryFullPath);
 
         foreach (string line in result.Output)
         {

src/SolarWinds.Changesets/Shared/IProcessExecutor.cs

@@ -17,4 +17,16 @@ internal interface IProcessExecutor
     /// Thrown if the process cannot be started with the specified parameters.
     /// </exception>
     Task<ProcessOutput> Execute(string executable, string arguments, string workingDirectoryPath);
+
+    /// <summary>
+    /// As <see cref="Execute(string, string, string)"/>, additionally setting environment variables on the
+    /// child process (on top of the inherited environment).
+    /// </summary>
+    /// <param name="executable">The path to the executable to run.</param>
+    /// <param name="arguments">The arguments to pass to the executable.</param>
+    /// <param name="workingDirectoryPath">The working directory for the process.</param>
+    /// <param name="environment">Environment variables to set on the child process.</param>
+    /// <returns>A <see cref="ProcessOutput"/> object containing the output and exit code of the process.</returns>
+    Task<ProcessOutput> Execute(
+        string executable, string arguments, string workingDirectoryPath, IReadOnlyDictionary<string, string>? environment);
 }

src/SolarWinds.Changesets/Shared/NodeDelegation.cs

@@ -0,0 +1,15 @@
+namespace SolarWinds.Changesets.Shared;
+
+/// <summary>
+/// Tracks whether net-changesets has already delegated to (or auto-run) the Node tool in this process tree.
+/// The marker is an environment variable, inherited by child processes, so a <c>nodeChangesetCommand</c> that
+/// mistakenly resolves back to net is caught on the second hop instead of recursing forever.
+/// </summary>
+internal static class NodeDelegation
+{
+    /// <summary>The marker set on the Node child process so it does not delegate back to net.</summary>
+    public const string GuardVariable = "NET_CHANGESETS_DELEGATED";
+
+    /// <summary>True when net has not already delegated to the Node tool higher up the process tree.</summary>
+    public static bool NotAlreadyDelegated => Environment.GetEnvironmentVariable(GuardVariable) is not "1";
+}

src/SolarWinds.Changesets/Shared/ProcessExecutor.cs

@@ -6,7 +6,12 @@ namespace SolarWinds.Changesets.Shared;
 internal class ProcessExecutor : IProcessExecutor
 {
     /// <inheritdoc />
-    public async Task<ProcessOutput> Execute(string executable, string arguments, string workingDirectoryPath)
+    public Task<ProcessOutput> Execute(string executable, string arguments, string workingDirectoryPath) =>
+        Execute(executable, arguments, workingDirectoryPath, environment: null);
+
+    /// <inheritdoc />
+    public async Task<ProcessOutput> Execute(
+        string executable, string arguments, string workingDirectoryPath, IReadOnlyDictionary<string, string>? environment)
     {
         var startInfo = new ProcessStartInfo
         {
@@ -19,6 +24,14 @@ public async Task<ProcessOutput> Execute(string executable, string arguments, st
             CreateNoWindow = true
         };
 
+        if (environment is not null)
+        {
+            foreach ((string key, string value) in environment)
+            {
+                startInfo.Environment[key] = value;
+            }
+        }
+
         List<string> output = [];
 
         using Process process = new() { StartInfo = startInfo };