Consistently use -- to separate go args

This avoids inconsistent results when using with `dnx go` which might parse some of the arguments. By always passing them after --, we get consistent results.

This simplifies explaining the subsequent -- to split dotnet args from app args (if present).

Author: kzu

readme.md

@@ -30,14 +30,11 @@ making it optimal for quick iteration and agentic tools authoring and consumptio
 dnx go app.cs
 
 # Pass arguments to your app
-dnx go app.cs arg1 arg2
-
-# Also works
 dnx go app.cs -- arg1 arg2
 
 # Pass arguments to the underlying `dotnet publish`
-# First -- is for dotnet publish, second -- is for your app
-dnx go app.cs -- /p:MyProp=true -- arg1 arg2
+# Args after initial -- are for dotnet publish, after second -- are for your app
+dnx go app.cs -- /p:MyProp=true /v:quiet -- arg1 arg2
 ```
 
 The default mode publishes the app with native AOT and then runs the resulting executable, 
@@ -48,13 +45,7 @@ Use `--r2r` when your app needs more dynamic .NET features (reflection, dynamic
 that native AOT does not support, while still keeping most publish optimizations:
 
 ```console
-dnx go app.cs --r2r
-
-# Pass arguments to your app
-dnx go app.cs --r2r arg1 arg2
-
-# Also works
-dnx go app.cs --r2r -- arg1 arg2
+dnx go app.cs -- --r2r -- arg1 arg2
 ```
 
 This publishes with `/p:PublishAot=false` and `/p:PublishReadyToRun=true`. 
@@ -65,13 +56,13 @@ and runs the app directly from the build output without the optimizations
 applied by dotnet to published executables (i.e. AOT, RID-specific optimizations):
 
 ```console
-dnx go dev app.cs
+dnx go dev -- app.cs
 
 # Pass arguments to your app
-dnx go dev app.cs -- arg1 arg2
+dnx go dev -- app.cs arg1 arg2
 
 # Pass arguments to the underlying `dotnet run`
-dnx go dev app.cs /p:Configuration=Release -- arg1 arg2
+dnx go dev -- app.cs /p:Configuration=Release -- arg1 arg2
 ```
 
 ## Remote references
@@ -81,15 +72,15 @@ the content (when needed) and treat the resulting local file as the entry point:
 
 ```console
 # Run from a public repo (defaults to github.com, main + program.cs or first .cs)
-dnx go kzu/sandbox
+dnx go -- kzu/sandbox
 
 # Specific branch/tag and file
-dnx go kzu/sandbox@v1.2.3:src/hello.cs
+dnx go -- kzu/sandbox@v1.2.3:src/hello.cs
 
 # Full host (GitHub, Gist, GitLab, Azure DevOps)
-dnx go github.com/kzu/sandbox@main:hello.cs
-dnx go gist.github.com/kzu/0ac826dc7de666546aaedd38e5965381
-dnx go gitlab.com/kzu/runcs/-/blob/main/program.cs
+dnx go -- github.com/kzu/sandbox@main:hello.cs
+dnx go -- gist.github.com/kzu/0ac826dc7de666546aaedd38e5965381
+dnx go -- gitlab.com/kzu/runcs/-/blob/main/program.cs
 ```
 
 The first argument is resolved by first checking if it is a local file (`File.Exists`).
@@ -104,10 +95,10 @@ To force a fresh download for a remote ref, clean its bundle first:
 
 ```console
 # Clean the downloaded bundle for a remote ref (forces full download on next run)
-dnx go clean kzu/sandbox
+dnx go -- clean kzu/sandbox
 
 # Works for refs with @ref or :path too (the bundle for the ref is deleted entirely)
-dnx go clean kzu/sandbox@main:program.cs
+dnx go -- clean kzu/sandbox@main:program.cs
 ```
 
 Behavior follows the chosen command:
@@ -124,13 +115,13 @@ user's temp area, which is what makes unchanged re-runs near-instant.
 
 ```console
 # Delete the cached artifacts for a single app (next run rebuilds)
-dnx go clean app.cs
+dnx go -- clean app.cs
 
 # Delete the downloaded bundle for a remote ref (next run re-downloads; :path ignored)
-dnx go clean owner/repo[@ref][:path]
+dnx go -- clean owner/repo[@ref][:path]
 
 # Delete the cached artifacts for all apps
-dnx go clean --all
+dnx go -- clean --all
 ```
 
 Unused download locations and published binaries are periodically cleaned up
@@ -140,8 +131,8 @@ in a detached background process. Apps you run regularly are never affected.
 
 The main advantage of `go#` is **fast unchanged re-runs**. 
 The two core scenarios for `go#` file-based apps are:
-* While tweaking 👉 `dnx go dev app.cs` (optimized `dotnet run app.cs`)
-* When stable 👉 `dnx go app.cs` (optimized `dotnet publish app.cs; app[.exe]`)
+* While tweaking 👉 `dnx go -- dev app.cs` (optimized `dotnet run app.cs`)
+* When stable 👉 `dnx go -- app.cs` (optimized `dotnet publish app.cs; app[.exe]`)
 
 The numbers below showcase both scenarios, comparing `go#` to `dotnet run` and 
 `dotnet publish` for a file-based app with different combinations of `#include` and `#ref` directives.

samples/minimal/app.cs

@@ -1,4 +1,4 @@
 #!/usr/bin/env dotnet
 #:property TargetFramework=net10.0
 
-Console.WriteLine("hello from go");
+Console.WriteLine("hello from go: " + string.Join("|", args));

src/go/Program.cs

@@ -2,6 +2,9 @@
 using ConsoleAppFramework;
 using Devlooped;
 
+if (Environment.GetEnvironmentVariable("GO_DEBUG") == "1")
+    System.Diagnostics.Debugger.Launch();
+
 var app = ConsoleApp.Create();
 app.Add("", RunAsync);
 app.Add("dev", DevAsync);
@@ -13,7 +16,8 @@
 /// <param name="input">Path to an existing .cs file or remote ref (owner/repo[@ref][:path]).</param>
 /// <param name="r2r">Publish with ReadyToRun instead of native AOT; supports more dynamic .NET features while keeping most publish optimizations. </param>
 /// <param name="gdbg">Launch debugger before executing.</param>
-static async Task<int> RunAsync([Argument] string input, bool r2r = false, [Hidden] bool gdbg = false)
+/// <param name="args">Arguments to pass to the app, or to dotnet publish and the app, separated by --.</param>
+static async Task<int> RunAsync([Argument] string input, bool r2r = false, [Hidden] bool gdbg = false, [Argument] params string[] args)
 {
     if (gdbg)
         System.Diagnostics.Debugger.Launch();
@@ -48,6 +52,36 @@ state.App is not null &&
     return await ExecuteAppAsync(publishDir, () => ProcessRunner.RunAsync(state.App, appArgs));
 }
 
+/// <summary>Runs a file-based .NET app from a .cs entrypoint using dotnet run for fast iteration.</summary>
+/// <param name="input">Path to an existing .cs file or remote ref (owner/repo[@ref][:path]).</param>
+/// <param name="r2r">Accepted for consistency (ignored for dev which uses dotnet run).</param>
+/// <param name="gdbg">Launch debugger before executing.</param>
+/// <param name="args">Arguments to pass to the app, or to dotnet run and the app, separated by --.</param>
+static async Task<int> DevAsync([Argument] string input, [Hidden] bool r2r = false, [Hidden] bool gdbg = false, [Argument] params string[] args)
+{
+    if (gdbg)
+        System.Diagnostics.Debugger.Launch();
+
+    var source = await GetEffectiveSourceAsync(input);
+    if (source is null)
+        return 1;
+
+    var context = Prepare(source, GoArgs.ForwardArgs);
+    if (context is null)
+        return 1;
+
+    var (dotnet, cs, publishDir, stamp, targets, _, dotnetArgs, appArgs) = context.Value;
+
+    if (BuildState.TryRead(stamp, out var state) &&
+        state.Bin is not null &&
+        BuildManager.IsUpToDate(state, state.Bin))
+        return await ExecuteAppAsync(publishDir, () => ProcessRunner.DotnetExecAsync(dotnet, state.Bin, appArgs));
+
+    File.WriteAllText(stamp, string.Empty, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
+
+    return await ExecuteAppAsync(publishDir, () => ProcessRunner.DotnetRunAsync(dotnet, cs, stamp, targets, dotnetArgs, appArgs));
+}
+
 /// <summary>Deletes cached publish artifacts for a file-based .NET app, or for a remote ref.</summary>
 /// <param name="input">Path to an existing .cs file or remote ref (owner/repo[@ref][:path]).</param>
 /// <param name="all">Delete cached artifacts for all apps instead.</param>
@@ -138,35 +172,6 @@ static int CleanAsync([Argument] string? input = null, bool all = false, [Hidden
     return AppCleaner.Clean(pdir, stmp, cs);
 }
 
-/// <summary>Runs a file-based .NET app from a .cs entrypoint using dotnet run for fast iteration.</summary>
-/// <param name="input">Path to an existing .cs file or remote ref (owner/repo[@ref][:path]).</param>
-/// <param name="r2r">Accepted for consistency (ignored for dev which uses dotnet run).</param>
-/// <param name="gdbg">Launch debugger before executing.</param>
-static async Task<int> DevAsync([Argument] string input, [Hidden] bool r2r = false, [Hidden] bool gdbg = false)
-{
-    if (gdbg)
-        System.Diagnostics.Debugger.Launch();
-
-    var source = await GetEffectiveSourceAsync(input);
-    if (source is null)
-        return 1;
-
-    var context = Prepare(source, GoArgs.ForwardArgs);
-    if (context is null)
-        return 1;
-
-    var (dotnet, cs, publishDir, stamp, targets, _, dotnetArgs, appArgs) = context.Value;
-
-    if (BuildState.TryRead(stamp, out var state) &&
-        state.Bin is not null &&
-        BuildManager.IsUpToDate(state, state.Bin))
-        return await ExecuteAppAsync(publishDir, () => ProcessRunner.DotnetExecAsync(dotnet, state.Bin, appArgs));
-
-    File.WriteAllText(stamp, string.Empty, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
-
-    return await ExecuteAppAsync(publishDir, () => ProcessRunner.DotnetRunAsync(dotnet, cs, stamp, targets, dotnetArgs, appArgs));
-}
-
 static async Task<int> ExecuteAppAsync(string publishDir, Func<Task<int>> execute)
 {
     Directory.Touch(publishDir);

src/go/help.md

@@ -4,7 +4,8 @@ Usage: [command] [arguments...] [options...] [-h|--help] [--version]
 Runs a file-based .NET app from a .cs entrypoint.
 
 Arguments:
-  [0] <string>    Path to an existing .cs file or remote ref (owner/repo[@ref][:path]).
+  [0] <string>      Path to an existing .cs file or remote ref (owner/repo[@ref][:path]).
+  [1] <string[]>    Arguments to pass to the app, or to dotnet publish and the app, separated by --.
 
 Options:
   --r2r    Publish with ReadyToRun instead of native AOT; supports more dynamic .NET features while keeping most publish optimizations.