Add 'clean' command and automatic cleanup of stale caches

- Add top-level 'go clean <file.cs>' to delete publish cache for a specific app
- Add hidden 'cleanup' command (and CleanupCommands) for global stale dir pruning
- Implement CleanupScheduler to trigger background cleanup after runs when due
- Add AppCleaner, CleanupManager, Settings (Tomlyn) and DirectoryExtensions
- Refactor to centralize publishDir and touch dirs on use for LRU cleanup
- Add unit tests for the new cleanup functionality
- Update help and add Tomlyn dependency

Author: kzu

src/Tests/AppCleanerTests.cs

@@ -0,0 +1,56 @@
+using Devlooped;
+
+namespace Tests;
+
+public class AppCleanerTests
+{
+    [Fact]
+    public void Clean_deletes_publish_directory_when_present()
+    {
+        var root = CreateTempDir();
+        var stamp = Path.Combine(root, "go.stamp");
+        File.WriteAllText(stamp, "mode=aot");
+        File.WriteAllText(Path.Combine(root, "app.exe"), "app");
+
+        var exit = AppCleaner.Clean(root, stamp);
+
+        Assert.Equal(0, exit);
+        Assert.False(Directory.Exists(root));
+    }
+
+    [Fact]
+    public void Clean_deletes_stamp_when_publish_directory_delete_fails()
+    {
+        var root = CreateTempDir();
+        var stamp = Path.Combine(root, "go.stamp");
+        var locked = Path.Combine(root, "locked.exe");
+        File.WriteAllText(stamp, "mode=aot");
+        File.WriteAllText(locked, "locked");
+
+        using var stream = new FileStream(locked, FileMode.Open, FileAccess.Read, FileShare.None);
+
+        var exit = AppCleaner.Clean(root, stamp);
+
+        Assert.Equal(0, exit);
+        Assert.True(Directory.Exists(root));
+        Assert.False(File.Exists(stamp));
+    }
+
+    [Fact]
+    public void Clean_succeeds_when_publish_directory_is_missing()
+    {
+        var root = Path.Combine(Path.GetTempPath(), "go-tests-" + Guid.NewGuid().ToString("N"));
+        var stamp = Path.Combine(root, "go.stamp");
+
+        var exit = AppCleaner.Clean(root, stamp);
+
+        Assert.Equal(0, exit);
+    }
+
+    static string CreateTempDir()
+    {
+        var dir = Path.Combine(Path.GetTempPath(), "go-tests-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(dir);
+        return dir;
+    }
+}

src/Tests/CleanupManagerTests.cs

@@ -0,0 +1,58 @@
+using Devlooped;
+
+namespace Tests;
+
+public class CleanupManagerTests
+{
+    [Fact]
+    public void CleanupStaleDirectories_deletes_directories_older_than_cutoff()
+    {
+        var root = CreateTempDir();
+        var stale = CreateSubDir(root, "stale");
+        var fresh = CreateSubDir(root, "fresh");
+
+        Directory.SetLastWriteTimeUtc(stale, DateTime.UtcNow.AddDays(-5));
+        Directory.SetLastWriteTimeUtc(fresh, DateTime.UtcNow);
+
+        CleanupManager.CleanupStaleDirectories(root, days: 2);
+
+        Assert.False(Directory.Exists(stale));
+        Assert.True(Directory.Exists(fresh));
+    }
+
+    [Fact]
+    public void SettingsStore_roundtrips_last_cleanup_utc()
+    {
+        var root = CreateTempDir();
+        var settingsPath = Path.Combine(root, "go.toml");
+
+        try
+        {
+            var expected = new DateTimeOffset(2026, 3, 15, 12, 30, 0, TimeSpan.Zero);
+            SettingsStore.Save(new Settings { LastCleanupUtc = expected }, settingsPath);
+
+            var loaded = SettingsStore.Load(settingsPath);
+
+            Assert.Equal(expected, loaded.LastCleanupUtc);
+        }
+        finally
+        {
+            if (File.Exists(settingsPath))
+                File.Delete(settingsPath);
+        }
+    }
+
+    static string CreateTempDir()
+    {
+        var dir = Path.Combine(Path.GetTempPath(), "go-tests-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(dir);
+        return dir;
+    }
+
+    static string CreateSubDir(string root, string name)
+    {
+        var path = Path.Combine(root, name);
+        Directory.CreateDirectory(path);
+        return path;
+    }
+}

src/Tests/CleanupSchedulerTests.cs

@@ -0,0 +1,76 @@
+using Devlooped;
+
+namespace Tests;
+
+public class CleanupSchedulerTests
+{
+    [Fact]
+    public void ShouldRun_returns_true_when_last_cleanup_is_null()
+    {
+        var settingsPath = CreateSettingsPath();
+
+        try
+        {
+            SettingsStore.Save(new Settings(), settingsPath);
+
+            Assert.True(CleanupScheduler.ShouldRun(settingsPath: settingsPath));
+        }
+        finally
+        {
+            DeleteIfExists(settingsPath);
+        }
+    }
+
+    [Fact]
+    public void ShouldRun_returns_true_when_last_cleanup_is_older_than_default_days()
+    {
+        var settingsPath = CreateSettingsPath();
+
+        try
+        {
+            SettingsStore.Save(new Settings
+            {
+                LastCleanupUtc = DateTimeOffset.UtcNow.AddDays(-3),
+            }, settingsPath);
+
+            Assert.True(CleanupScheduler.ShouldRun(settingsPath: settingsPath));
+        }
+        finally
+        {
+            DeleteIfExists(settingsPath);
+        }
+    }
+
+    [Fact]
+    public void ShouldRun_returns_false_when_last_cleanup_is_recent()
+    {
+        var settingsPath = CreateSettingsPath();
+
+        try
+        {
+            SettingsStore.Save(new Settings
+            {
+                LastCleanupUtc = DateTimeOffset.UtcNow.AddHours(-1),
+            }, settingsPath);
+
+            Assert.False(CleanupScheduler.ShouldRun(settingsPath: settingsPath));
+        }
+        finally
+        {
+            DeleteIfExists(settingsPath);
+        }
+    }
+
+    static string CreateSettingsPath()
+    {
+        var dir = Path.Combine(Path.GetTempPath(), "go-tests-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(dir);
+        return Path.Combine(dir, "go.toml");
+    }
+
+    static void DeleteIfExists(string path)
+    {
+        if (File.Exists(path))
+            File.Delete(path);
+    }
+}

src/go/AppCleaner.cs

@@ -0,0 +1,29 @@
+namespace Devlooped;
+
+public static class AppCleaner
+{
+    public static int Clean(string publishDir, string stamp)
+    {
+        try
+        {
+            if (Directory.Exists(publishDir))
+                Directory.Delete(publishDir, recursive: true);
+
+            return 0;
+        }
+        catch
+        {
+            try
+            {
+                if (File.Exists(stamp))
+                    File.Delete(stamp);
+
+                return 0;
+            }
+            catch
+            {
+                return 1;
+            }
+        }
+    }
+}

src/go/CleanupCommands.cs

@@ -0,0 +1,10 @@
+using ConsoleAppFramework;
+
+namespace Devlooped;
+
+public class CleanupCommands
+{
+    [Command("cleanup")]
+    [Hidden]
+    public int Cleanup(int days = CleanupManager.DefaultDays) => CleanupManager.Cleanup(days);
+}

src/go/CleanupManager.cs

@@ -0,0 +1,27 @@
+namespace Devlooped;
+
+public static class CleanupManager
+{
+    public const int DefaultDays = 2;
+
+    public static int Cleanup(int days = DefaultDays)
+    {
+        CleanupStaleDirectories(Directory.GetTempRoot(), days);
+
+        SettingsStore.Save(new Settings { LastCleanupUtc = DateTimeOffset.UtcNow });
+        return 0;
+    }
+
+    public static void CleanupStaleDirectories(string root, int days)
+    {
+        var cutoff = DateTime.UtcNow.AddDays(-days);
+
+        foreach (var directory in Directory.EnumerateDirectories(root))
+        {
+            if (Directory.GetLastWriteTimeUtc(directory) >= cutoff)
+                continue;
+
+            Directory.Delete(directory, recursive: true);
+        }
+    }
+}

src/go/CleanupScheduler.cs

@@ -0,0 +1,73 @@
+using System.Diagnostics;
+using System.Reflection;
+
+namespace Devlooped;
+
+public static class CleanupScheduler
+{
+    public static bool ShouldRun(int days = CleanupManager.DefaultDays, string? settingsPath = null)
+    {
+        var settings = SettingsStore.Load(settingsPath);
+        if (settings.LastCleanupUtc is null)
+            return true;
+
+        return settings.LastCleanupUtc < DateTimeOffset.UtcNow.AddDays(-days);
+    }
+
+    public static void StartDetached()
+        => Process.Start(CreateCleanupProcessStartInfo());
+
+    public static Task TryScheduleAsync()
+    {
+        return Task.Run(() =>
+        {
+            try
+            {
+                if (!ShouldRun())
+                    return;
+
+                StartDetached();
+            }
+            catch
+            {
+            }
+        });
+    }
+
+    static ProcessStartInfo CreateCleanupProcessStartInfo()
+    {
+        var commandLine = Environment.GetCommandLineArgs();
+        var fileName = Environment.ProcessPath ?? commandLine[0];
+
+        var startInfo = new ProcessStartInfo
+        {
+            FileName = fileName,
+            UseShellExecute = false,
+            CreateNoWindow = true,
+        };
+
+        if (IsDotnetHost(fileName) &&
+            commandLine.Length >= 3 &&
+            commandLine[1] == "exec" &&
+            commandLine[2].EndsWith("go.dll", StringComparison.OrdinalIgnoreCase))
+        {
+            startInfo.ArgumentList.Add("exec");
+            startInfo.ArgumentList.Add(commandLine[2]);
+        }
+        else if (IsDotnetHost(fileName))
+        {
+            var assembly = Assembly.GetEntryAssembly()?.Location;
+            if (!string.IsNullOrEmpty(assembly))
+            {
+                startInfo.ArgumentList.Add("exec");
+                startInfo.ArgumentList.Add(assembly);
+            }
+        }
+
+        startInfo.ArgumentList.Add("cleanup");
+        return startInfo;
+    }
+
+    static bool IsDotnetHost(string path)
+        => Path.GetFileNameWithoutExtension(path).Equals("dotnet", StringComparison.OrdinalIgnoreCase);
+}