Added package filtering

sh.actions.package-cleanup/ConfigurationExtension.cs

@@ -0,0 +1,26 @@
+namespace sh.actions.package_cleanup;
+
+public static class ConfigurationExtension
+{
+    private static void EnsureVariable(IConfiguration configuration, string key)
+    {
+        var value = configuration[key];
+        if (string.IsNullOrEmpty(value))
+        {
+            throw new InvalidOperationException($"Configuration variable '{key}' is required but was not found.");
+        }
+    }
+
+    public static IConfigurationBuilder EnsureGiteaConfig(this IConfigurationBuilder builder)
+    {
+        var configuration = builder.Build();
+
+        EnsureVariable(configuration, "URL");
+        EnsureVariable(configuration, "OWNER");
+        EnsureVariable(configuration, "TYPE");
+        EnsureVariable(configuration, "NAME");
+        EnsureVariable(configuration, "API_TOKEN");
+
+        return builder;
+    }
+}

sh.actions.package-cleanup/Models/GiteaPackage.cs

@@ -0,0 +1,10 @@
+namespace sh.actions.package_cleanup.Models;
+
+public class GiteaPackage
+{
+    public int Id { get; set; }
+    public string Name { get; set; } = string.Empty;
+    public string Version { get; set; } = string.Empty;
+    public string Type { get; set; } = string.Empty;
+    public DateTime CreatedAt { get; set; }
+}

sh.actions.package-cleanup/Program.cs

@@ -0,0 +1,21 @@
+using sh.actions.package_cleanup;
+using sh.actions.package_cleanup.Service;
+
+var builder = Host.CreateApplicationBuilder(args);
+
+builder.Configuration
+    .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
+    .AddJsonFile("appsettings.local.json", optional: true, reloadOnChange: true)
+    .AddEnvironmentVariables()
+    .EnsureGiteaConfig();
+
+builder.Services
+    .AddSingleton<IPackageService, PackageService>()
+    .AddScoped<IGiteaPackageService, GiteaPackageService>()
+    .AddHostedService<Worker>()
+    .AddHttpClient<IGiteaPackageService, GiteaPackageService>();
+
+
+var host = builder.Build();
+
+host.Run();

sh.actions.package-cleanup/Properties/launchSettings.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "https://json.schemastore.org/launchsettings.json",
+  "profiles": {
+    "sh.actions.package_cleanup": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "environmentVariables": {
+        "DOTNET_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}

sh.actions.package-cleanup/Service/GiteaPackageService.cs

@@ -0,0 +1,95 @@
+namespace sh.actions.package_cleanup.Service;
+
+using System.Net.Http.Json;
+using Microsoft.Extensions.Logging;
+using sh.actions.package_cleanup.Models;
+
+public class GiteaPackageService(
+    ILogger<GiteaPackageService> logger,
+    IConfiguration configuration,
+    HttpClient httpClient)
+    : IGiteaPackageService
+{
+    public async Task<IEnumerable<GiteaPackage>> GetPackagesByOwnerAsync(CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            var baseUrl =
+                $"{configuration["URL"]?.TrimEnd('/')}/packages/{configuration["OWNER"]}/{configuration["TYPE"]}/{configuration["NAME"]}";
+            var allPackages = new List<GiteaPackage>();
+            var page = 1;
+
+            while (true)
+            {
+                var url = $"{baseUrl}?page={page}";
+
+                logger.LogInformation("Fetching packages from Gitea: {Url}", url);
+                var request = new HttpRequestMessage(HttpMethod.Get, url);
+                request.Headers.Add("Authorization", $"token {configuration["API_TOKEN"]}");
+
+                var response = await httpClient.SendAsync(request, cancellationToken);
+                response.EnsureSuccessStatusCode();
+
+                var packages =
+                    await response.Content.ReadFromJsonAsync<List<GiteaPackage>>(cancellationToken: cancellationToken)
+                    ?? [];
+
+                if (packages.Count == 0)
+                {
+                    break;
+                }
+
+                allPackages.AddRange(packages);
+                logger.LogInformation("Fetched {Count} packages from page {Page}", packages.Count, page);
+
+                page++;
+            }
+
+            logger.LogInformation("Successfully fetched {Count} packages in total", allPackages.Count);
+
+            return allPackages;
+        }
+        catch (HttpRequestException ex)
+        {
+            logger.LogError(ex, "Error fetching packages from Gitea");
+            throw;
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Unexpected error fetching packages");
+            throw;
+        }
+    }
+
+    public async Task DeletePackage(GiteaPackage package, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            var url =
+                $"{configuration["URL"]?.TrimEnd('/')}/packages/{configuration["OWNER"]}/{package.Type}/{package.Name}/{package.Version}";
+            logger.LogInformation("Deleting package {PackageName} (ID: {PackageId}) from Gitea: {Url}", package.Name,
+                package.Id, url);
+
+            var request = new HttpRequestMessage(HttpMethod.Delete, url);
+            request.Headers.Add("Authorization", $"token {configuration["API_TOKEN"]}");
+
+            var response = await httpClient.SendAsync(request, cancellationToken);
+            response.EnsureSuccessStatusCode();
+
+            logger.LogInformation("Successfully deleted package {PackageName} (ID: {PackageId})", package.Name,
+                package.Id);
+        }
+        catch (HttpRequestException ex)
+        {
+            logger.LogError(ex, "Error deleting package {PackageName} (ID: {PackageId}) from Gitea", package.Name,
+                package.Id);
+            throw;
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Unexpected error deleting package {PackageName} (ID: {PackageId})", package.Name,
+                package.Id);
+            throw;
+        }
+    }
+}

sh.actions.package-cleanup/Service/IGiteaPackageService.cs

@@ -0,0 +1,9 @@
+namespace sh.actions.package_cleanup.Service;
+
+using sh.actions.package_cleanup.Models;
+
+public interface IGiteaPackageService
+{
+    Task<IEnumerable<GiteaPackage>> GetPackagesByOwnerAsync(CancellationToken cancellationToken = default);
+    Task DeletePackage(GiteaPackage package, CancellationToken cancellationToken = default);
+}

sh.actions.package-cleanup/Service/IPackageService.cs

@@ -0,0 +1,9 @@
+using sh.actions.package_cleanup.Models;
+
+namespace sh.actions.package_cleanup.Service;
+
+public interface IPackageService
+{
+    Task<List<GiteaPackage>> GetFilteredPackages();
+    List<GiteaPackage> FilterPackagesToDelete(List<GiteaPackage> packages);
+}

sh.actions.package-cleanup/Service/PackageService.cs

@@ -0,0 +1,311 @@
+using sh.actions.package_cleanup.Models;
+
+namespace sh.actions.package_cleanup.Service;
+
+public class PackageService(IConfiguration configuration, IGiteaPackageService packageService) : IPackageService
+{
+    public async Task<List<GiteaPackage>> GetFilteredPackages()
+    {
+        var packages = (await packageService.GetPackagesByOwnerAsync()).ToList();
+        return packages;
+    }
+
+    public List<GiteaPackage> FilterPackagesToDelete(List<GiteaPackage> packages)
+    {
+        var packagesToDelete = new List<GiteaPackage>();
+
+        // Group packages by versioning variant
+        var semanticVersionPackages = packages.Where(p => IsSemanticVersion(p.Version)).ToList();
+        var dateVersionPackages = packages.Where(p => IsDateVersion(p.Version)).ToList();
+
+        // Process each group with their respective variant logic
+        packagesToDelete.AddRange(FilterPackagesToDeleteBySemanticVersion(semanticVersionPackages));
+        packagesToDelete.AddRange(FilterPackagesToDeleteByDateVersion(dateVersionPackages));
+
+        return packagesToDelete;
+    }
+
+    private List<GiteaPackage> FilterPackagesToDeleteBySemanticVersion(List<GiteaPackage> packages)
+    {
+        var packagesToDelete = new List<GiteaPackage>();
+
+        // Group packages by release type
+        // Note: Dev releases must be checked before prerelease since -dev is a suffix
+        var devPackages = packages.Where(p => IsDevRelease(p.Version))
+            .OrderByDescending(p => ParseSemanticVersion(p.Version))
+            .ThenByDescending(p => p.CreatedAt)
+            .ToList();
+        var prereleasePackages = packages.Where(p => IsPrereleaseRelease(p.Version) && !IsDevRelease(p.Version))
+            .OrderByDescending(p => ParseSemanticVersion(p.Version))
+            .ThenByDescending(p => p.CreatedAt)
+            .ToList();
+        var prodPackages = packages.Where(p => IsProdRelease(p.Version))
+            .OrderByDescending(p => ParseSemanticVersion(p.Version))
+            .ThenByDescending(p => p.CreatedAt)
+            .ToList();
+
+        // Apply cleanup rules for each type
+        packagesToDelete.AddRange(FilterProdReleases(prodPackages));
+        packagesToDelete.AddRange(FilterPrereleaseReleases(prereleasePackages));
+        packagesToDelete.AddRange(FilterDevReleases(devPackages));
+
+        return packagesToDelete;
+    }
+
+    private List<GiteaPackage> FilterPackagesToDeleteByDateVersion(List<GiteaPackage> packages)
+    {
+        var packagesToDelete = new List<GiteaPackage>();
+
+        // Group packages by release type
+        // Note: Dev releases must be checked before prerelease since -dev is a suffix
+        var devPackages = packages.Where(p => IsDevRelease(p.Version))
+            .OrderByDescending(p => ParseDateVersion(p.Version))
+            .ThenByDescending(p => p.CreatedAt)
+            .ToList();
+        var prereleasePackages = packages.Where(p => IsPrereleaseRelease(p.Version) && !IsDevRelease(p.Version))
+            .OrderByDescending(p => ParseDateVersion(p.Version))
+            .ThenByDescending(p => p.CreatedAt)
+            .ToList();
+        var prodPackages = packages.Where(p => IsProdRelease(p.Version))
+            .OrderByDescending(p => ParseDateVersion(p.Version))
+            .ThenByDescending(p => p.CreatedAt)
+            .ToList();
+
+        // Apply cleanup rules for each type
+        packagesToDelete.AddRange(FilterProdReleasesDateVersion(prodPackages));
+        packagesToDelete.AddRange(FilterPrereleaseReleasesDateVersion(prereleasePackages));
+        packagesToDelete.AddRange(FilterDevReleasesDateVersion(devPackages));
+
+        return packagesToDelete;
+    }
+
+    // Prod release methods for semantic versioning
+    private List<GiteaPackage> FilterProdReleases(List<GiteaPackage> packages)
+    {
+        // Check if prod cleaning is enabled
+        if (!GetBoolConfigValue("CLEAN_PROD_VERSIONS", false))
+            return new List<GiteaPackage>();
+
+        // Get keep count
+        var keepCount = GetIntConfigValue("KEEP_PROD_VERSIONS", 5);
+
+        // If keepCount <= 0, keep all
+        if (keepCount <= 0)
+            return new List<GiteaPackage>();
+
+        // Packages are already sorted descending by version
+        // Keep top N, delete rest
+        return packages.Skip(keepCount).ToList();
+    }
+
+    // Prerelease methods for semantic versioning
+    private List<GiteaPackage> FilterPrereleaseReleases(List<GiteaPackage> packages)
+    {
+        // Get keep count
+        var keepCount = GetIntConfigValue("KEEP_PRERELEASE_VERSIONS", 3);
+
+        // If keepCount <= 0, keep all
+        if (keepCount <= 0)
+            return new List<GiteaPackage>();
+
+        // Packages are already sorted descending by version
+        // Keep top N, delete rest
+        return packages.Skip(keepCount).ToList();
+    }
+
+    // Dev release methods for semantic versioning
+    private List<GiteaPackage> FilterDevReleases(List<GiteaPackage> packages)
+    {
+        // Get keep count
+        var keepCount = GetIntConfigValue("KEEP_DEV_VERSIONS", 5);
+
+        // If keepCount <= 0, keep all
+        if (keepCount <= 0)
+            return new List<GiteaPackage>();
+
+        // Packages are already sorted descending by version
+        // Keep top N, delete rest
+        return packages.Skip(keepCount).ToList();
+    }
+
+    // Prod release methods for date-based versioning
+    private List<GiteaPackage> FilterProdReleasesDateVersion(List<GiteaPackage> packages)
+    {
+        // Check if prod cleaning is enabled
+        if (!GetBoolConfigValue("CLEAN_PROD_VERSIONS", false))
+            return new List<GiteaPackage>();
+
+        // Get keep count
+        var keepCount = GetIntConfigValue("KEEP_PROD_VERSIONS", 5);
+
+        // If keepCount <= 0, keep all
+        if (keepCount <= 0)
+            return new List<GiteaPackage>();
+
+        // Packages are already sorted descending by version
+        // Keep top N, delete rest
+        return packages.Skip(keepCount).ToList();
+    }
+
+    // Prerelease methods for date-based versioning
+    private List<GiteaPackage> FilterPrereleaseReleasesDateVersion(List<GiteaPackage> packages)
+    {
+        // Get keep count
+        var keepCount = GetIntConfigValue("KEEP_PRERELEASE_VERSIONS", 3);
+
+        // If keepCount <= 0, keep all
+        if (keepCount <= 0)
+            return new List<GiteaPackage>();
+
+        // Packages are already sorted descending by version
+        // Keep top N, delete rest
+        return packages.Skip(keepCount).ToList();
+    }
+
+    // Dev release methods for date-based versioning
+    private List<GiteaPackage> FilterDevReleasesDateVersion(List<GiteaPackage> packages)
+    {
+        // Get keep count
+        var keepCount = GetIntConfigValue("KEEP_DEV_VERSIONS", 5);
+
+        // If keepCount <= 0, keep all
+        if (keepCount <= 0)
+            return new List<GiteaPackage>();
+
+        // Packages are already sorted descending by version
+        // Keep top N, delete rest
+        return packages.Skip(keepCount).ToList();
+    }
+
+    // Helper methods to identify release types
+    private bool IsProdRelease(string version)
+    {
+        // Prod versions typically don't have pre-release identifiers (alpha, beta, rc, dev, etc.)
+        return !version.Contains("-", StringComparison.OrdinalIgnoreCase);
+    }
+
+    private bool IsPrereleaseRelease(string version)
+    {
+        // Prerelease versions contain identifiers like -alpha, -beta, -rc, -preview
+        // But NOT -dev, which is a separate release type
+        var lowerVersion = version.ToLowerInvariant();
+        return (lowerVersion.Contains("-alpha") || lowerVersion.Contains("-beta") || 
+               lowerVersion.Contains("-rc") || lowerVersion.Contains("-preview")) && !lowerVersion.Contains("-dev");
+    }
+
+    private bool IsDevRelease(string version)
+    {
+        // Dev versions contain identifiers like -dev or similar
+        return version.ToLowerInvariant().Contains("-dev");
+    }
+
+    // Helper methods to identify versioning variant
+    private bool IsSemanticVersion(string version)
+    {
+        // Semantic versioning: major.minor.micro.build with typically smaller numbers
+        // Examples: 1.2.3.4, 2.0.1.100
+        var versionPart = version.Split('-')[0];
+        var parts = versionPart.Split('.').Where(p => !string.IsNullOrEmpty(p)).ToArray();
+
+        if (parts.Length < 2 || parts.Length > 4)
+            return false;
+
+        // Try to parse all parts as numbers
+        if (!parts.All(p => int.TryParse(p, out var num)))
+            return false;
+
+        // Semantic versioning typically has smaller major version numbers (0-20 range)
+        if (int.TryParse(parts[0], out var major) && major > 100)
+            return false; // Likely a date version if first number > 100
+
+        return true;
+    }
+
+    private bool IsDateVersion(string version)
+    {
+        // Date-based versioning: year.month.day.build
+        // Examples: 2024.12.25.1, 2025.2.14.100
+        var versionPart = version.Split('-')[0];
+        var parts = versionPart.Split('.').Where(p => !string.IsNullOrEmpty(p)).ToArray();
+
+        if (parts.Length != 4)
+            return false;
+
+        // Try to parse all parts as numbers
+        if (!parts.All(p => int.TryParse(p, out var num)))
+            return false;
+
+        // Date version should have year > 1000 and < 3000
+        if (!int.TryParse(parts[0], out var year) || year < 1000 || year > 3000)
+            return false;
+
+        // Month should be 1-12
+        if (!int.TryParse(parts[1], out var month) || month < 1 || month > 12)
+            return false;
+
+        // Day should be 1-31
+        if (!int.TryParse(parts[2], out var day) || day < 1 || day > 31)
+            return false;
+
+        return true;
+    }
+
+    // Version parsing methods
+    private (int major, int minor, int micro, int build) ParseSemanticVersion(string version)
+    {
+        // Remove suffix if present (e.g., "-alpha", "-dev")
+        var versionPart = version.Split('-')[0];
+        var parts = versionPart.Split('.').Select(p => int.TryParse(p, out var num) ? num : 0).ToArray();
+        
+        return (
+            parts.Length > 0 ? parts[0] : 0,
+            parts.Length > 1 ? parts[1] : 0,
+            parts.Length > 2 ? parts[2] : 0,
+            parts.Length > 3 ? parts[3] : 0
+        );
+    }
+
+    private (int year, int month, int day, int build) ParseDateVersion(string version)
+    {
+        // Remove suffix if present (e.g., "-alpha", "-dev")
+        var versionPart = version.Split('-')[0];
+        var parts = versionPart.Split('.').Select(p => int.TryParse(p, out var num) ? num : 0).ToArray();
+        
+        return (
+            parts.Length > 0 ? parts[0] : 0,
+            parts.Length > 1 ? parts[1] : 0,
+            parts.Length > 2 ? parts[2] : 0,
+            parts.Length > 3 ? parts[3] : 0
+        );
+    }
+
+    // Configuration helper methods
+    private int GetIntConfigValue(string key, int defaultValue)
+    {
+        var value = configuration[key];
+        if (string.IsNullOrEmpty(value))
+            return defaultValue;
+
+        if (int.TryParse(value, out var result))
+            return result;
+
+        return defaultValue;
+    }
+
+    private bool GetBoolConfigValue(string key, bool defaultValue)
+    {
+        var value = configuration[key];
+        if (string.IsNullOrEmpty(value))
+            return defaultValue;
+
+        if (bool.TryParse(value, out var result))
+            return result;
+
+        // Handle common string representations
+        if (value.Equals("true", StringComparison.OrdinalIgnoreCase) ||
+            value.Equals("1", StringComparison.OrdinalIgnoreCase))
+            return true;
+
+        return defaultValue;
+    }
+}

sh.actions.package-cleanup/Worker.cs

@@ -0,0 +1,41 @@
+using sh.actions.package_cleanup.Models;
+using sh.actions.package_cleanup.Service;
+
+namespace sh.actions.package_cleanup;
+
+public class Worker(
+    ILogger<Worker> logger,
+    IConfiguration configuration,
+    IHostApplicationLifetime appLifetime,
+    IPackageService packageService,
+    IGiteaPackageService giteaPackageService
+) : BackgroundService
+{
+    private async Task DeletePackages(List<GiteaPackage> packages, CancellationToken cancellationToken = default)
+    {
+        if (configuration["DRY_RUN"]?.ToLower() == "true")
+        {
+            logger.LogInformation("Dry run enabled, not deleting packages");
+            return;
+        }
+
+        foreach (var giteaPackage in packages)
+        {
+            await giteaPackageService.DeletePackage(giteaPackage, cancellationToken);
+        }
+    }
+
+    protected override async Task ExecuteAsync(CancellationToken cancellationToken)
+    {
+        var packages = await packageService.GetFilteredPackages();
+        Console.WriteLine($"Found {packages.Count()} packages");
+        
+        var packagesToDelete = packageService.FilterPackagesToDelete(packages);
+        Console.WriteLine($"Found {packagesToDelete.Count()} packages to delete");
+        
+        await DeletePackages(packagesToDelete, cancellationToken);
+        
+        logger.LogInformation("Cleanup finished, stopping application");
+        appLifetime.StopApplication();
+    }
+}

sh.actions.package-cleanup/appsettings.json

@@ -0,0 +1 @@
+{}

sh.actions.package-cleanup/sh.actions.package-cleanup.csproj

@@ -0,0 +1,15 @@
+<Project Sdk="Microsoft.NET.Sdk.Worker">
+
+    <PropertyGroup>
+        <TargetFramework>net10.0</TargetFramework>
+        <Nullable>enable</Nullable>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <UserSecretsId>dotnet-sh.actions.package_cleanup-2b7a013f-ec22-4325-9832-0c9ca9b8ced9</UserSecretsId>
+        <RootNamespace>sh.actions.package_cleanup</RootNamespace>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="Microsoft.Extensions.Hosting" Version="10.0.3" />
+        <PackageReference Include="Microsoft.Extensions.Http" Version="10.0.3" />
+    </ItemGroup>
+</Project>