using System.Text.Json; using System.Text.Json.Nodes; using System.Text.RegularExpressions; namespace Chronos.Tools.Commands; /// What a published tag moves (). /// The public content of the releases repository: the highest stable release only. /// The image's :latest: the highest stable release, or the highest pre-release while no stable one exists. internal sealed record ReleaseChannels(bool Latest, bool ImageLatest); /// /// Decides which channels a release moves (BRIEF §19.3, amended 2026-10-26, R1). Gitea's "latest" /// release is the most recently created one, so the choice is made by SemVer 2.0 precedence among the published /// releases instead: re-publishing an older tag never rolls a channel back. Prints latest=… and /// image_latest=…, ready for $GITHUB_OUTPUT. /// internal sealed class ReleaseChannelsCommand : ICommand { public string Name => "release-channels"; public string Summary => "Channels a tag moves: --tag vX.Y.Z[-pre] --releases ; prints latest= and image_latest="; public async Task RunAsync(string[] args) { var a = new Args(args); if (a.Get("tag") is not { Length: > 0 } tag || a.Get("releases") is not { Length: > 0 } file) throw new ToolException("Usage: release-channels --tag vMAJOR.MINOR.PATCH[-PRERELEASE] --releases "); // The tag is checked before the file is read: a mistyped tag is the likelier error. if (TagVersion.Parse(tag) is null) throw new ToolException(InvalidTag(tag)); if (!File.Exists(file)) throw new ToolException($"Releases file not found: {file}"); Console.Out.Write(Render(Decide(tag, await File.ReadAllTextAsync(file)))); return 0; } /// /// The channels moves, given Gitea's releases list (GET /repos/{owner}/{repo}/releases). /// Drafts and tags that are not SemVer are ignored; the tag itself always counts as published. A release is a /// pre-release when its tag has a pre-release part or Gitea flags it so. /// internal static ReleaseChannels Decide(string tag, string releasesJson) { var current = TagVersion.Parse(tag) ?? throw new ToolException(InvalidTag(tag)); var listed = Published(releasesJson); var currentIsPrerelease = current.IsPrerelease || listed.Any(r => r.Version.Tag == tag && r.Prerelease); var all = listed.Where(r => r.Version.Tag != tag).Append((Version: current, Prerelease: currentIsPrerelease)).ToList(); // Equal precedence (v1.0.0 and v1.0.0+build.2) counts as highest: publishing the same version again moves nothing back. bool Highest(IEnumerable versions) => versions.All(v => v.CompareTo(current) <= 0); var stable = all.Where(r => !r.Prerelease).Select(r => r.Version).ToList(); var latest = !currentIsPrerelease && Highest(stable); var imageLatest = stable.Count > 0 ? latest : Highest(all.Select(r => r.Version)); return new ReleaseChannels(latest, imageLatest); } /// The two output lines, with \n on every platform. internal static string Render(ReleaseChannels channels) => $"latest={(channels.Latest ? "true" : "false")}\nimage_latest={(channels.ImageLatest ? "true" : "false")}\n"; private static List<(TagVersion Version, bool Prerelease)> Published(string json) { JsonNode? root; try { root = JsonNode.Parse(json); } catch (JsonException ex) { throw new ToolException($"The releases file is not JSON: {ex.Message}"); } if (root is not JsonArray releases) throw new ToolException("The releases file is not a JSON array of releases."); var published = new List<(TagVersion, bool)>(); foreach (var release in releases.OfType()) { if (Flag(release, "draft")) continue; if (release["tag_name"] is not JsonValue name || !name.TryGetValue(out var tagName)) continue; if (TagVersion.Parse(tagName) is { } version) published.Add((version, version.IsPrerelease || Flag(release, "prerelease"))); } return published; } private static bool Flag(JsonObject release, string name) => release[name] is JsonValue value && value.TryGetValue(out var flag) && flag; private static string InvalidTag(string tag) => $"--tag '{tag}' is not vMAJOR.MINOR.PATCH[-PRERELEASE][+BUILD] (for example v1.2.0 or v1.2.0-rc.1)."; } /// A tag vMAJOR.MINOR.PATCH[-PRERELEASE][+BUILD] ordered by SemVer 2.0 precedence (build metadata ignored). internal sealed partial class TagVersion : IComparable { private readonly string[] _core; private readonly string[] _prerelease; private TagVersion(string tag, string[] core, string[] prerelease) { Tag = tag; _core = core; _prerelease = prerelease; } public string Tag { get; } public bool IsPrerelease => _prerelease.Length > 0; /// The version of , or null when it is not SemVer 2.0 with a leading v. public static TagVersion? Parse(string? tag) { if (tag is null) return null; var m = Pattern().Match(tag); if (!m.Success) return null; string[] core = [m.Groups["major"].Value, m.Groups["minor"].Value, m.Groups["patch"].Value]; return new TagVersion(tag, core, m.Groups["pre"].Success ? m.Groups["pre"].Value.Split('.') : []); } public int CompareTo(TagVersion? other) { if (other is null) return 1; for (var i = 0; i < _core.Length; i++) { var c = CompareNumbers(_core[i], other._core[i]); if (c != 0) return c; } // A version without a pre-release part is higher than the same version with one. if (_prerelease.Length == 0 || other._prerelease.Length == 0) return other._prerelease.Length.CompareTo(_prerelease.Length); for (var i = 0; i < Math.Min(_prerelease.Length, other._prerelease.Length); i++) { var c = CompareIdentifiers(_prerelease[i], other._prerelease[i]); if (c != 0) return c; } return _prerelease.Length.CompareTo(other._prerelease.Length); } public override string ToString() => Tag; // Numeric identifiers rank below alphanumeric ones and compare by value; alphanumeric ones compare in ASCII order. private static int CompareIdentifiers(string a, string b) => (IsNumeric(a), IsNumeric(b)) switch { (true, true) => CompareNumbers(a, b), (true, false) => -1, (false, true) => 1, _ => string.CompareOrdinal(a, b), }; private static bool IsNumeric(string identifier) => identifier.All(char.IsAsciiDigit); // Without leading zeros (the pattern refuses them) the longer number is the larger: no overflow on long ones. private static int CompareNumbers(string a, string b) => a.Length != b.Length ? a.Length.CompareTo(b.Length) : string.CompareOrdinal(a, b); // semver.org's pattern with a leading "v", ASCII digits only and no trailing newline. [GeneratedRegex(@"^v(?0|[1-9][0-9]*)\.(?0|[1-9][0-9]*)\.(?0|[1-9][0-9]*)(?:-(?
(?:0|[1-9][0-9]*|[0-9]*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9][0-9]*|[0-9]*[A-Za-z-][0-9A-Za-z-]*))*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?\z")]
    private static partial Regex Pattern();
}