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]*)(?:-(?