feat: support \go clean <remote-ref>\ (bundle + per-path publishes); remove --force

Author: kzu

readme.md

@@ -88,17 +88,18 @@ and participates in the normal up-to-date checks. Remote refs are always revalid
 by sending a conditional request (using ETag when available) to the source. A 304
 Not Modified response means the local copy is used as-is.
 
+To force a fresh download for a remote ref, clean its bundle first:
+
 ```console
-# Force a fresh download (bypasses ETag conditional check)
-dnx go --force kzu/sandbox
+# Clean the downloaded bundle for a remote ref (forces full download on next run)
+dnx go clean kzu/sandbox
 
-# Same using the --go- alias form
-dnx go --go-force 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
 ```
 
 The go-specific switches support both bare and `--go-` prefixed forms for consistency:
 
-- `--force` / `--go-force`
 - `--debug` / `--go-debug`
 - `--r2r` / `--go-r2r`
 
@@ -120,6 +121,9 @@ unchanged re-runs near-instant.
 # Delete the cached artifacts for a single app (next run rebuilds)
 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]
+
 # Delete the cached artifacts for all apps
 dnx go clean --all
 ```

src/Tests/EndToEndTests.cs

@@ -298,12 +298,6 @@ public void Remote_ref_always_revalidates_via_etag_root_dir_touched_source_files
 
             Assert.True((mtimeAfterImm - mtimeBeforeImm).TotalSeconds < 2.0, "immediate must not change source file mtime");
             Assert.True(rootAfterImm > rootBeforeImm || rootAfterImm >= rootBeforeImm, "root dir touched on immediate use too");
-
-            // --force should succeed (forces full fetch, bypassing any conditional).
-            var (exitForce, outForce) = RunGo("--force", remoteRef, "--", "-v:q");
-            File.AppendAllText(logPath, "FORCE:\n" + outForce);
-            Assert.Equal(0, exitForce);
-            Assert.Contains("run.cs", outForce);
         }
         finally
         {

src/Tests/GoArgsTests.cs

@@ -59,25 +59,25 @@ public void ApplyPublishMode_leaves_args_unchanged_when_disabled()
     [Fact]
     public void Normalize_maps_go_prefixed_switches_to_bare_forms()
     {
-        var normalized = GoArgs.Normalize(["--go-force", "--go-debug", "--go-r2r", "owner/repo", "--", "apparg"]);
+        var normalized = GoArgs.Normalize(["--go-debug", "--go-r2r", "owner/repo", "--", "apparg"]);
 
-        Assert.Equal(["--force", "--debug", "--r2r", "owner/repo", "--", "apparg"], normalized);
+        Assert.Equal(["--debug", "--r2r", "owner/repo", "--", "apparg"], normalized);
     }
 
     [Fact]
     public void Normalize_leaves_bare_and_unknown_untouched()
     {
-        var normalized = GoArgs.Normalize(["--force", "--debug", "--r2r", "--other", "input.cs"]);
+        var normalized = GoArgs.Normalize(["--debug", "--r2r", "--other", "input.cs"]);
 
-        Assert.Equal(["--force", "--debug", "--r2r", "--other", "input.cs"], normalized);
+        Assert.Equal(["--debug", "--r2r", "--other", "input.cs"], normalized);
     }
 
     [Fact]
     public void Normalize_handles_mixed_case_and_all_forms()
     {
-        var normalized = GoArgs.Normalize(["--Go-Force", "--DEBUG", "ref"]);
+        var normalized = GoArgs.Normalize(["--Go-Debug", "--R2R", "ref"]);
 
-        Assert.Equal(["--force", "--debug", "ref"], normalized);
+        Assert.Equal(["--debug", "--r2r", "ref"], normalized);
     }
 
     [Fact]

src/Tests/GoBuildCacheTests.cs

@@ -200,7 +200,7 @@ public async Task GetEffectiveSourceAsync_returns_local_existing_without_net()
     {
         var dir = CreateTempDir();
         var f = WriteFile(dir, "local.cs", "Console.WriteLine(\"hi\");");
-        var eff = await Devlooped.RemoteSourceResolver.GetEffectiveSourceAsync(f, force: false);
+        var eff = await Devlooped.RemoteSourceResolver.GetEffectiveSourceAsync(f);
         Assert.Equal(Path.GetFullPath(f), eff);
     }
 }

src/go/GoArgs.cs

@@ -4,10 +4,10 @@ public static class GoArgs
 {
     public static readonly string[] ReadyToRunPublishArgs = ["/p:PublishAot=false", "/p:PublishReadyToRun=true"];
 
-    static readonly string[] GoSwitchNames = ["force", "debug", "r2r"];
+    static readonly string[] GoSwitchNames = ["debug", "r2r"];
 
     /// <summary>
-    /// Normalizes go-specific switches so both prefix-less (--force) and --go- forms (--go-force)
+    /// Normalizes go-specific switches so both prefix-less and --go- forms
     /// are accepted; maps --go-* aliases to the bare form the command methods declare.
     /// </summary>
     public static string[] Normalize(string[] args)

src/go/Program.cs

@@ -15,16 +15,15 @@
 /// </summary>
 /// <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. Alias: --go-r2r.</param>
-/// <param name="force">Force re-download of remote ref if applicable. Alias: --go-force.</param>
 /// <param name="debug">Launch debugger before executing. Alias: --go-debug.</param>
 /// <param name="extraArgs">Arguments before '--' are passed to 'dotnet publish'; arguments after '--' are forwarded to the published app. Without '--', all extra arguments are forwarded to the published app.
 /// </param>
-static async Task<int> RunAsync([Argument] string input, bool r2r = false, bool force = false, bool debug = false, [Argument] params string[] extraArgs)
+static async Task<int> RunAsync([Argument] string input, bool r2r = false, bool debug = false, [Argument] params string[] extraArgs)
 {
     if (debug)
         System.Diagnostics.Debugger.Launch();
 
-    var source = await GetEffectiveSourceAsync(input, force);
+    var source = await GetEffectiveSourceAsync(input);
     if (source is null)
         return 1;
 
@@ -55,9 +54,9 @@ state.App is not null &&
 }
 
 /// <summary>
-/// Deletes cached publish artifacts for a file-based .NET app.
+/// Deletes cached publish artifacts for a file-based .NET app, or for a remote ref: deletes the bundle and also its associated publish artifacts for every previously-used path recorded in the bundle's ETags/Entry (:path on the ref is ignored).
 /// </summary>
-/// <param name="input">Path to an existing .cs file.</param>
+/// <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>
 static int CleanAsync([Argument] string? input = null, bool all = false)
 {
@@ -74,31 +73,88 @@ static int CleanAsync([Argument] string? input = null, bool all = false)
 
     if (input is null)
     {
-        ConsoleApp.LogError("Specify a .cs file to clean, or --all to clean all cached apps.");
+        ConsoleApp.LogError("Specify a .cs file or remote ref to clean, or --all to clean all cached apps.");
         return 1;
     }
 
-    if (!TryResolveEntryPoint(input, out _, out var publishDir, out var stamp))
+    var full = Path.GetFullPath(input);
+    if (File.Exists(full))
+    {
+        if (!TryResolveEntryPoint(input, out _, out var publishDir, out var stamp))
+            return 1;
+
+        return AppCleaner.Clean(publishDir, stamp);
+    }
+
+    if (RemoteRef.TryParse(input, out var remote))
+    {
+        var bundleDir = remote.TempPath;
+        if (Directory.Exists(bundleDir))
+        {
+            try
+            {
+                // A bundle can contain multiple ref paths in use (e.g. different :path or discovered entries).
+                // ETags keys (and the persisted Entry) record the relative file paths previously used to run.
+                // Clean the published artifacts for each by treating them as local file paths (before we nuke the bundle).
+                var settings = RemoteSettingsStore.Load(bundleDir);
+                var keys = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+                if (!string.IsNullOrEmpty(settings.Entry))
+                    keys.Add(settings.Entry.Replace('\\', '/'));
+                if (settings.ETags != null)
+                {
+                    foreach (var k in settings.ETags.Keys)
+                        keys.Add(k.Replace('\\', '/'));
+                }
+
+                foreach (var key in keys)
+                {
+                    var filePath = Path.Combine(bundleDir, key.Replace('/', Path.DirectorySeparatorChar));
+                    if (File.Exists(filePath))
+                    {
+                        if (TryResolveEntryPoint(filePath, out _, out var publishDir, out var stamp))
+                            AppCleaner.Clean(publishDir, stamp);
+                    }
+                }
+            }
+            catch
+            {
+                // Best-effort: continue to delete the bundle even if some publish cleans failed.
+            }
+
+            try
+            {
+                Directory.Delete(bundleDir, recursive: true);
+                return 0;
+            }
+            catch
+            {
+                return 1;
+            }
+        }
+
+        return 0;
+    }
+
+    if (!TryResolveEntryPoint(input, out _, out var pdir, out var stmp))
         return 1;
 
-    return AppCleaner.Clean(publishDir, stamp);
+    return AppCleaner.Clean(pdir, stmp);
 }
 
 /// <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). Alias: --go-r2r.</param>
-/// <param name="force">Force re-download of remote ref if applicable. Alias: --go-force.</param>
 /// <param name="debug">Launch debugger before executing. Alias: --go-debug.</param>
 /// <param name="extraArgs">Arguments before '--' are passed to 'dotnet run'; arguments after '--' are forwarded to the app. Without '--', all extra arguments are forwarded to the app.
 /// </param>
-static async Task<int> DevAsync([Argument] string input, bool r2r = false, bool force = false, bool debug = false, [Argument] params string[] extraArgs)
+static async Task<int> DevAsync([Argument] string input, bool r2r = false, bool debug = false, [Argument] params string[] extraArgs)
 {
     if (debug)
         System.Diagnostics.Debugger.Launch();
 
-    var source = await GetEffectiveSourceAsync(input, force);
+    var source = await GetEffectiveSourceAsync(input);
     if (source is null)
         return 1;
 
@@ -150,5 +206,5 @@ static bool TryResolveEntryPoint(string input, out string effectiveCs, out strin
     return (dotnet, cs, publishDir, stamp, targets, mode, dotnetArgs, appArgs);
 }
 
-static async Task<string?> GetEffectiveSourceAsync(string input, bool force)
-    => await RemoteSourceResolver.GetEffectiveSourceAsync(input, force);
+static async Task<string?> GetEffectiveSourceAsync(string input)
+    => await RemoteSourceResolver.GetEffectiveSourceAsync(input);

src/go/RemoteSourceResolver.cs

@@ -82,7 +82,7 @@ public static bool IsRemoteDownloadStale(string sourcePath)
         return (DateTime.UtcNow - mtime) > TimeSpan.FromDays(14);
     }
 
-    public static async Task<string?> GetEffectiveSourceAsync(string input, bool force)
+    public static async Task<string?> GetEffectiveSourceAsync(string input)
     {
         var full = Path.GetFullPath(input);
         if (File.Exists(full))
@@ -94,22 +94,17 @@ public static bool IsRemoteDownloadStale(string sourcePath)
             return null;
         }
 
-        return await DownloadIfNeededAsync(remote, force);
+        return await DownloadIfNeededAsync(remote);
     }
 
-    internal static async Task<string> DownloadIfNeededAsync(RemoteRef remote, bool force)
+    internal static async Task<string> DownloadIfNeededAsync(RemoteRef remote)
     {
-        if (force && Directory.Exists(remote.TempPath))
-        {
-            try { Directory.Delete(remote.TempPath, recursive: true); } catch { }
-        }
-
         var candidate = GetRemoteEntryPointPath(remote);
 
         // Always revalidate remote refs via ETag (conditional request to source).
         // 304 => keep local, 200 => (re)extract. No local mtime-based freshness gate.
         string? etag = null;
-        if (!force && Directory.Exists(remote.TempPath))
+        if (Directory.Exists(remote.TempPath))
         {
             var rs = RemoteSettingsStore.Load(remote.TempPath);
             var key = GetStartupKey(remote, candidate);
@@ -120,6 +115,7 @@ internal static async Task<string> DownloadIfNeededAsync(RemoteRef remote, bool
         var requestRef = remote with { ETag = etag };
         HttpResponseMessage? contents = null;
         bool didExtract = false;
+        string? newEtag = null;
         try
         {
             contents = await provider.GetAsync(requestRef);
@@ -140,15 +136,9 @@ internal static async Task<string> DownloadIfNeededAsync(RemoteRef remote, bool
                 await contents.ExtractToAsync(remote);
                 didExtract = true;
 
-                // Persist ETag for future conditional requests (if server provided one).
-                var newEtag = contents.Headers.ETag?.ToString();
-                if (!string.IsNullOrWhiteSpace(newEtag))
-                {
-                    var rs = RemoteSettingsStore.Load(remote.TempPath);
-                    var key = GetStartupKey(remote, candidate);
-                    RemoteSettingsStore.SetETag(rs, key, newEtag);
-                    RemoteSettingsStore.Save(rs, remote.TempPath);
-                }
+                // Capture ETag; persist below using the *final* candidate (important for
+                // no-:path refs where default "program.cs" candidate may be overridden by discovery).
+                newEtag = contents.Headers.ETag?.ToString();
 
                 // Mark the ref root (unzipped bundle) dir for cleanup tracking.
                 Directory.Touch(remote.TempPath);
@@ -184,6 +174,19 @@ internal static async Task<string> DownloadIfNeededAsync(RemoteRef remote, bool
             }
         }
 
+        // Persist ETag for future conditional requests (if server provided one), using final candidate key.
+        if (didExtract && !string.IsNullOrWhiteSpace(newEtag))
+        {
+            try
+            {
+                var rs = RemoteSettingsStore.Load(remote.TempPath);
+                var key = GetStartupKey(remote, candidate);
+                RemoteSettingsStore.SetETag(rs, key, newEtag);
+                RemoteSettingsStore.Save(rs, remote.TempPath);
+            }
+            catch { }
+        }
+
         // If candidate missing but dir now exists (e.g. 304 path or prior state), recompute.
         if (!File.Exists(candidate) && Directory.Exists(remote.TempPath))
         {

src/go/help.md

@@ -9,10 +9,9 @@ Arguments:
 
 Options:
   --r2r      Publish with ReadyToRun instead of native AOT; supports more dynamic .NET features while keeping most publish optimizations. Alias: --go-r2r.
-  --force    Force re-download of remote ref if applicable. Alias: --go-force.
   --debug    Launch debugger before executing. Alias: --go-debug.
 
 Commands:
-  clean    Deletes cached publish artifacts for a file-based .NET app.
+  clean    Deletes cached publish artifacts for a file-based .NET app, or for a remote ref: deletes the bundle and also its associated publish artifacts for every previously-used path recorded in the bundle's ETags/Entry (:path on the ref is ignored).
   dev      Runs a file-based .NET app from a .cs entrypoint using dotnet run for fast iteration.
 ```

src/go/readme.md

@@ -71,6 +71,9 @@ unchanged re-runs near-instant.
 # Delete the cached artifacts for a single app (next run rebuilds)
 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]
+
 # Delete the cached artifacts for all apps
 dnx go clean --all
 ```