Add check command to verify native AOT toolchain

Default publish needs a platform C/C++ linker. `go check` probes readiness
(Windows via `dnx vs -- where +vc`, clang/gcc on Unix) and prints install
fixes; documents this in the skill and readme.

Author: kzu

readme.md

@@ -37,6 +37,16 @@ The default mode publishes the app with native AOT and then runs the resulting e
 with smart up-to-date checks of every C# file used to build the app (including 
 `#include` and `#ref` directives, transitively).
 
+Native AOT needs a platform C/C++ linker (VC++ build tools on Windows, `build-essential` on
+Ubuntu, Xcode Command Line Tools on macOS). Verify with:
+
+```console
+dnx go -- check
+```
+
+On failure, the command prints the recommended install command for your OS (for example
+`dnx vs -- install --passive --sku:build` on Windows).
+
 Use `--r2r` when your app needs more dynamic .NET features (reflection, dynamic loading, etc.) 
 that native AOT does not support, while still keeping most publish optimizations:
 

skills/go-sharp/SKILL.md

@@ -16,6 +16,7 @@ license: MIT
 |-------|---------|----------|
 | **Tweaking / evolving** | `dnx go -- dev app.cs` | Optimized `dotnet run` + up-to-date checks; skip publish/AOT |
 | **Stable (exclusive)** | `dnx go -- app.cs` | Optimized `dotnet publish` (native AOT by default) + run the binary |
+| **Prerequisites** | `dnx go -- check` | Verifies the native C/C++ toolchain needed for AOT publishes |
 
 Once the script is stable, use **`dnx go -- app.cs` only**—not `dev`, not plain `dotnet app.cs`.
 
@@ -51,6 +52,26 @@ Run `dotnet --version`. File-based apps need **.NET 10+**. `#:include`, `#:exclu
 dnx go -- --help
 ```
 
+#### Native toolchain (AOT publishes)
+
+The **stable** path (`dnx go -- app.cs`) publishes with **native AOT** by default and needs a platform C/C++ linker. `dev` and `--r2r` do **not** require it.
+
+Verify before relying on AOT (or when publish fails with a platform linker / VC++ error):
+
+```bash
+dnx go -- check
+```
+
+If the check fails, install the tools for your OS and re-run `check`:
+
+| OS | Fix |
+|----|-----|
+| **Windows** | `dnx vs -- install --passive --sku:build` |
+| **Ubuntu / Debian** | `sudo apt-get install -y build-essential` |
+| **macOS** | `xcode-select --install` |
+
+Typical failure without tools: `Platform linker ('clang' or 'gcc') not found` (Linux/macOS) or missing Visual C++ build tools (Windows).
+
 ### Step 2: Write the app file
 
 Create an entry-point `.cs` file with top-level statements. Place it outside directories that contain a `.csproj` to avoid project conflicts.
@@ -318,6 +339,7 @@ partial class AppJsonContext : JsonSerializerContext;
 
 - [ ] `dotnet --version` reports 10.0 or later
 - [ ] Multi-file `#:include` / `#:exclude` only if SDK is 10.0.300 or later
+- [ ] For default (AOT) publish: `dnx go -- check` succeeds
 - [ ] While iterating: `dnx go -- dev app.cs` produces the expected result
 - [ ] After the last successful edit: `dnx go -- app.cs` works, and **further runs use this form only**
 - [ ] App arguments are not confused with go flags (`--r2r` applies to go, then app args)
@@ -332,7 +354,8 @@ partial class AppJsonContext : JsonSerializerContext;
 | Using `dotnet app.cs` for day-to-day runs | Use `dnx go -- app.cs` (stable) or `dnx go -- dev app.cs` (tweaking) |
 | Staying on `dev` after the script is done | Switch to `dnx go -- app.cs` exclusively |
 | Expecting AOT under `dev` | `dev` is non-AOT; AOT applies to the default publish path |
-| AOT failures on stable runs | Source-generated JSON or `dnx go -- app.cs --r2r` |
+| Platform linker / VC++ missing on stable AOT publish | `dnx go -- check`, then install per the printed fix (Windows: `dnx vs -- install --passive --sku:build`; Ubuntu: `build-essential`; macOS: Xcode CLT) |
+| AOT failures on stable runs (reflection/dynamic) | Source-generated JSON or `dnx go -- app.cs --r2r` |
 | Need verbose SDK/MSBuild diagnostics | Fall back to `dotnet --file app.cs` / `dotnet build app.cs -v:n` |
 | Running a remote ref without consent | Ask the user; check owner/stars/source first |
 | `.cs` file inside a directory with a `.csproj` | Move the app outside the project directory |

src/Tests/NativeToolchainTests.cs

@@ -0,0 +1,159 @@
+using System.Runtime.InteropServices;
+using Devlooped;
+
+namespace Tests;
+
+public class NativeToolchainTests
+{
+    [Fact]
+    public void Evaluate_missing_dotnet_fails_without_fix()
+    {
+        var result = NativeToolchain.Evaluate(
+            dotnetPath: null,
+            isOs: _ => true,
+            commandExists: _ => true,
+            run: (_, _) => new NativeToolchain.CapturedProcessResult(0, "C:\\VS", ""));
+
+        Assert.False(result.Ok);
+        Assert.Equal(NativeToolchain.MissingDotnetMessage, result.Message);
+        Assert.Null(result.FixCommand);
+    }
+
+    [Fact]
+    public void Evaluate_windows_ok_when_vs_where_returns_path()
+    {
+        string[]? capturedArgs = null;
+        var result = NativeToolchain.Evaluate(
+            dotnetPath: "dotnet",
+            isOs: p => p == OSPlatform.Windows,
+            commandExists: _ => false,
+            run: (file, args) =>
+            {
+                Assert.Equal("dotnet", file);
+                capturedArgs = [.. args];
+                return new NativeToolchain.CapturedProcessResult(0, @"C:\Program Files\Microsoft Visual Studio\18\BuildTools", "");
+            });
+
+        Assert.True(result.Ok);
+        Assert.Equal(NativeToolchain.ReadyMessage, result.Message);
+        Assert.Null(result.FixCommand);
+        Assert.NotNull(capturedArgs);
+        Assert.Equal(
+            ["dnx", "vs", "--", "where", "+vc", "--prop", "InstallationPath"],
+            capturedArgs);
+    }
+
+    [Fact]
+    public void Evaluate_windows_ok_when_cl_on_path_even_if_vs_fails()
+    {
+        var result = NativeToolchain.Evaluate(
+            dotnetPath: "dotnet",
+            isOs: p => p == OSPlatform.Windows,
+            commandExists: name => name == "cl",
+            run: (_, _) => new NativeToolchain.CapturedProcessResult(1, "", "not found"));
+
+        Assert.True(result.Ok);
+        Assert.Equal(NativeToolchain.ReadyMessage, result.Message);
+    }
+
+    [Fact]
+    public void Evaluate_windows_recommends_vs_install_when_missing()
+    {
+        var result = NativeToolchain.Evaluate(
+            dotnetPath: "dotnet",
+            isOs: p => p == OSPlatform.Windows,
+            commandExists: _ => false,
+            run: (_, _) => new NativeToolchain.CapturedProcessResult(1, "", "not found"));
+
+        Assert.False(result.Ok);
+        Assert.Equal(NativeToolchain.MissingWindowsMessage, result.Message);
+        Assert.Equal(NativeToolchain.WindowsFixCommand, result.FixCommand);
+        Assert.Equal("dnx vs -- install --passive --sku:build", result.FixCommand);
+    }
+
+    [Fact]
+    public void Evaluate_linux_ok_when_clang_or_gcc_present()
+    {
+        var withClang = NativeToolchain.Evaluate(
+            dotnetPath: "dotnet",
+            isOs: p => p == OSPlatform.Linux,
+            commandExists: name => name == "clang",
+            run: (_, _) => throw new InvalidOperationException("should not run"));
+
+        var withGcc = NativeToolchain.Evaluate(
+            dotnetPath: "dotnet",
+            isOs: p => p == OSPlatform.Linux,
+            commandExists: name => name == "gcc",
+            run: (_, _) => throw new InvalidOperationException("should not run"));
+
+        Assert.True(withClang.Ok);
+        Assert.True(withGcc.Ok);
+    }
+
+    [Fact]
+    public void Evaluate_linux_recommends_build_essential_when_missing()
+    {
+        var result = NativeToolchain.Evaluate(
+            dotnetPath: "dotnet",
+            isOs: p => p == OSPlatform.Linux,
+            commandExists: _ => false,
+            run: (_, _) => throw new InvalidOperationException("should not run"));
+
+        Assert.False(result.Ok);
+        Assert.Equal(NativeToolchain.MissingLinuxMessage, result.Message);
+        Assert.Equal(NativeToolchain.LinuxFixCommand, result.FixCommand);
+        Assert.Equal("sudo apt-get install -y build-essential", result.FixCommand);
+    }
+
+    [Fact]
+    public void Evaluate_macos_ok_when_clang_present()
+    {
+        var result = NativeToolchain.Evaluate(
+            dotnetPath: "dotnet",
+            isOs: p => p == OSPlatform.OSX,
+            commandExists: name => name == "clang",
+            run: (_, _) => throw new InvalidOperationException("should not run"));
+
+        Assert.True(result.Ok);
+    }
+
+    [Fact]
+    public void Evaluate_macos_ok_when_xcode_select_succeeds()
+    {
+        var result = NativeToolchain.Evaluate(
+            dotnetPath: "dotnet",
+            isOs: p => p == OSPlatform.OSX,
+            commandExists: _ => false,
+            run: (file, args) =>
+            {
+                Assert.Equal("xcode-select", file);
+                Assert.Equal(["-p"], args);
+                return new NativeToolchain.CapturedProcessResult(0, "/Library/Developer/CommandLineTools", "");
+            });
+
+        Assert.True(result.Ok);
+    }
+
+    [Fact]
+    public void Evaluate_macos_recommends_xcode_select_when_missing()
+    {
+        var result = NativeToolchain.Evaluate(
+            dotnetPath: "dotnet",
+            isOs: p => p == OSPlatform.OSX,
+            commandExists: _ => false,
+            run: (_, _) => new NativeToolchain.CapturedProcessResult(1, "", "error"));
+
+        Assert.False(result.Ok);
+        Assert.Equal(NativeToolchain.MissingMacMessage, result.Message);
+        Assert.Equal(NativeToolchain.MacFixCommand, result.FixCommand);
+        Assert.Equal("xcode-select --install", result.FixCommand);
+    }
+
+    [Fact]
+    public void PrepareCafArgs_passes_check_args_through_unchanged()
+    {
+        var caf = GoArgs.PrepareCafArgs(["check"]);
+        Assert.Equal(["check"], caf);
+        Assert.Empty(GoArgs.ForwardArgs);
+    }
+}

src/go/CheckCommands.cs

@@ -0,0 +1,27 @@
+using ConsoleAppFramework;
+
+namespace Devlooped;
+
+public class CheckCommands
+{
+    /// <summary>Verifies the native toolchain required for native AOT publishes.</summary>
+    [Command("check")]
+    public int Check()
+    {
+        var result = NativeToolchain.Evaluate();
+        if (result.Ok)
+        {
+            Console.WriteLine(result.Message);
+            return 0;
+        }
+
+        ConsoleApp.LogError(result.Message);
+        if (result.FixCommand is not null)
+        {
+            Console.WriteLine("To fix, run:");
+            Console.WriteLine($"  {result.FixCommand}");
+        }
+
+        return 1;
+    }
+}

src/go/GoArgs.cs

@@ -5,7 +5,7 @@ public static class GoArgs
     public static readonly string[] ReadyToRunPublishArgs = ["/p:PublishAot=false", "/p:PublishReadyToRun=true"];
 
     static readonly string[] GoSwitchNames = ["debug", "r2r", "gdbg"];
-    static readonly HashSet<string> Subcommands = new(StringComparer.OrdinalIgnoreCase) { "dev", "clean", "skill" };
+    static readonly HashSet<string> Subcommands = new(StringComparer.OrdinalIgnoreCase) { "dev", "clean", "check", "skill" };
 
     static string[]? forwardArgs;
 
@@ -96,8 +96,8 @@ internal static string[] PrepareCafArgs(string[] args)
             index = 1;
         }
 
-        // clean / skill (and nested skill remove) own their args; do not split for app forwarding.
-        if (subcommand is "clean" or "skill")
+        // clean / check / skill (and nested skill remove) own their args; do not split for app forwarding.
+        if (subcommand is "clean" or "check" or "skill")
         {
             forwardArgs = [];
             return args;