@phuc1403/musketeer 0.10.0 → 0.12.0

package/template/.claude/skills/logical-components/scripts/LogicalComponents/WorkspaceLoader.cs

@@ -0,0 +1,297 @@
+using System.Diagnostics;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.MSBuild;
+
+namespace LogicalComponents;
+
+/// <summary>A target repo that could not be restored or loaded into a Roslyn workspace.</summary>
+public sealed class WorkspaceLoadException(string message) : Exception(message);
+
+/// <summary>
+/// A loaded repo: the Roslyn solution reduced to one C# source project per project file, plus where it came from.
+/// Owns the workspace (and its out-of-process build host), so dispose it when done.
+/// </summary>
+public sealed class LoadedWorkspace(MSBuildWorkspace workspace, Solution solution, string repoRoot, string source)
+    : IDisposable
+{
+    public Solution Solution { get; } = solution;
+
+    /// <summary>Absolute repo root; every path written to output is made relative to it.</summary>
+    public string RepoRoot { get; } = repoRoot;
+
+    /// <summary>The solution file name, or the glob the loader fell back to.</summary>
+    public string Source { get; } = source;
+
+    public IReadOnlyList<string> ProjectNames { get; } =
+        solution.Projects.Select(p => p.Name).Order(StringComparer.Ordinal).ToList();
+
+    public void Dispose() => workspace.Dispose();
+}
+
+/// <summary>
+/// Loads a repo's source projects into a Roslyn workspace. The top-level solution is preferred; the csproj files
+/// are used only when there is no solution or it contains no source projects. A solution that exists but fails
+/// to open is an error, never a silent switch to a different project set.
+/// </summary>
+public static class WorkspaceLoader
+{
+    private static readonly TimeSpan RestoreTimeout = TimeSpan.FromMinutes(10);
+
+    /// <param name="solution">
+    /// An explicit solution file, relative to <paramref name="repoPath"/> or absolute, used instead of searching the
+    /// repo root. Use it to resolve the "more than one solution" error, or to pick a non-top-level solution on purpose.
+    /// </param>
+    public static async Task<LoadedWorkspace> LoadAsync(
+        string repoPath, bool restore = true, string? solution = null, TextWriter? log = null)
+    {
+        var repoRoot = Path.GetFullPath(repoPath);
+        if (!Directory.Exists(repoRoot))
+        {
+            throw new DirectoryNotFoundException($"Repository path not found: {repoRoot}");
+        }
+
+        log ??= TextWriter.Null;
+
+        var solutionFile = solution is null ? FindSolutionFile(repoRoot) : ResolveGivenSolution(repoRoot, solution);
+        if (solutionFile is not null)
+        {
+            var name = Path.GetFileName(solutionFile);
+            var loaded = await LoadAsync(repoRoot, name, [solutionFile], restore, log,
+                (workspace, file) => workspace.OpenSolutionAsync(file));
+            if (loaded.Solution.Projects.Any())
+            {
+                return loaded;
+            }
+
+            loaded.Dispose();
+            log.WriteLine($"{name} contains no C# source projects; falling back to project files.");
+        }
+
+        var (projectFiles, glob) = FindProjectFiles(repoRoot, log);
+        if (projectFiles.Count == 0)
+        {
+            throw new WorkspaceLoadException($"No solution and no C# source project found under {repoRoot}");
+        }
+
+        return await LoadAsync(repoRoot, glob, projectFiles, restore, log, async (workspace, file) =>
+        {
+            // Opening a project also loads its references; skip ones already pulled in that way.
+            if (workspace.CurrentSolution.Projects.All(p => !PathsEqual(p.FilePath, file)))
+            {
+                await workspace.OpenProjectAsync(file);
+            }
+        });
+    }
+
+    /// <summary>Restores and opens each entry file, then reduces the result to source projects.</summary>
+    private static async Task<LoadedWorkspace> LoadAsync(
+        string repoRoot, string source, IReadOnlyList<string> entryFiles, bool restore, TextWriter log,
+        Func<MSBuildWorkspace, string, Task> open)
+    {
+        var workspace = MSBuildWorkspace.Create();
+        try
+        {
+            var failures = new List<string>();
+            workspace.RegisterWorkspaceFailedHandler(e =>
+            {
+                if (e.Diagnostic.Kind == WorkspaceDiagnosticKind.Failure)
+                {
+                    failures.Add(e.Diagnostic.Message);
+                }
+                else
+                {
+                    log.WriteLine($"warning: {e.Diagnostic.Message}");
+                }
+            });
+
+            foreach (var file in entryFiles)
+            {
+                if (restore)
+                {
+                    await RestoreAsync(file, repoRoot);
+                }
+
+                await open(workspace, file);
+            }
+
+            if (failures.Count > 0)
+            {
+                throw new WorkspaceLoadException(
+                    $"Loading {source} failed:{Environment.NewLine}  " + string.Join(Environment.NewLine + "  ", failures));
+            }
+
+            return new LoadedWorkspace(workspace, KeepSourceProjects(workspace.CurrentSolution, repoRoot, log), repoRoot, source);
+        }
+        catch (Exception e)
+        {
+            workspace.Dispose();
+            throw e is WorkspaceLoadException ? e : new WorkspaceLoadException($"Loading {source} failed: {e.Message}");
+        }
+    }
+
+    /// <summary>
+    /// Drops non-C# and test projects, and keeps one project per multi-targeted project file: the highest target
+    /// framework, renamed without its <c>(tfm)</c> suffix, so every type is seen exactly once. A project referencing a
+    /// dropped copy (another TFM of the same file resolved by a referencing project that targets a lower framework)
+    /// is redirected to the kept copy first, so it never silently loses that reference.
+    /// </summary>
+    private static Solution KeepSourceProjects(Solution solution, string repoRoot, TextWriter log)
+    {
+        foreach (var byFile in solution.Projects.GroupBy(p => p.FilePath ?? "", StringComparer.OrdinalIgnoreCase))
+        {
+            var projects = byFile.ToList();
+            var isTest = byFile.Key != ""
+                && projects[0].Language == LanguageNames.CSharp
+                && ProjectFilters.IsTestProject(Path.GetRelativePath(repoRoot, byFile.Key), File.ReadAllText(byFile.Key));
+            if (isTest)
+            {
+                log.WriteLine($"dropped test project: {Path.GetRelativePath(repoRoot, byFile.Key)}");
+            }
+
+            var isSource = byFile.Key != "" && projects[0].Language == LanguageNames.CSharp && !isTest;
+            var kept = isSource
+                ? projects.MaxBy(p => ProjectFilters.TargetFrameworkRank(p.Name))
+                : null;
+
+            var dropped = projects.Where(p => p != kept).Select(p => p.Id).ToList();
+            if (dropped.Count > 0)
+            {
+                solution = RedirectProjectReferences(solution, dropped, kept?.Id);
+            }
+
+            foreach (var id in dropped)
+            {
+                solution = solution.RemoveProject(id);
+            }
+
+            if (kept is not null)
+            {
+                solution = solution.WithProjectName(kept.Id, ProjectFilters.StripTargetFramework(kept.Name));
+            }
+        }
+
+        return solution;
+    }
+
+    /// <summary>
+    /// Points every reference to one of <paramref name="droppedIds"/> at <paramref name="keptId"/> instead (deduped
+    /// against a reference the project already has), or drops it if there is no kept copy to redirect to (the whole
+    /// group is being dropped, e.g. a test or non-C# project).
+    /// </summary>
+    private static Solution RedirectProjectReferences(
+        Solution solution, IReadOnlyCollection<ProjectId> droppedIds, ProjectId? keptId)
+    {
+        foreach (var project in solution.Projects.ToList())
+        {
+            if (droppedIds.Contains(project.Id) || project.ProjectReferences.All(r => !droppedIds.Contains(r.ProjectId)))
+            {
+                continue;
+            }
+
+            var references = project.ProjectReferences.Where(r => !droppedIds.Contains(r.ProjectId)).ToList();
+            if (keptId is not null && project.Id != keptId && references.All(r => r.ProjectId != keptId))
+            {
+                references.Add(new ProjectReference(keptId));
+            }
+
+            solution = solution.WithProjectReferences(project.Id, references);
+        }
+
+        return solution;
+    }
+
+    private static string? FindSolutionFile(string repoRoot)
+    {
+        // Top-level only: a nested solution usually belongs to a sample or a vendored dependency.
+        var candidates = Directory.EnumerateFiles(repoRoot, "*.slnx")
+            .Concat(Directory.EnumerateFiles(repoRoot, "*.sln"))
+            .Order(StringComparer.Ordinal)
+            .ToList();
+
+        return candidates.Count switch
+        {
+            0 => null,
+            1 => candidates[0],
+            _ => throw new WorkspaceLoadException(
+                $"More than one solution in {repoRoot}: {string.Join(", ", candidates.Select(Path.GetFileName))}"
+                + "; pass --solution <file> to pick one."),
+        };
+    }
+
+    /// <summary>Resolves an explicit <c>--solution</c> file (relative to the repo root, or absolute); errors if missing.</summary>
+    private static string ResolveGivenSolution(string repoRoot, string solution)
+    {
+        var path = Path.IsPathRooted(solution) ? solution : Path.Combine(repoRoot, solution);
+        if (!File.Exists(path))
+        {
+            throw new WorkspaceLoadException($"Solution not found: {Path.GetFullPath(path)}");
+        }
+
+        return Path.GetFullPath(path);
+    }
+
+    /// <summary>C# project files under <c>src/</c>, or under the repo root minus build output and dot folders.</summary>
+    private static (List<string> Files, string Glob) FindProjectFiles(string repoRoot, TextWriter log)
+    {
+        var src = Path.Combine(repoRoot, "src");
+        var (searchRoot, glob) = Directory.Exists(src) ? (src, "src/**/*.csproj") : (repoRoot, "**/*.csproj");
+        var files = Directory
+            .EnumerateFiles(searchRoot, "*.csproj", SearchOption.AllDirectories)
+            .Where(file => !CitableSource.IsBuildOutputPath(Path.GetRelativePath(repoRoot, file))
+                && !Path.GetRelativePath(repoRoot, file)
+                    .Split(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar)
+                    .Any(segment => segment.StartsWith('.')))
+            .Where(file =>
+            {
+                var relative = Path.GetRelativePath(repoRoot, file);
+                if (!ProjectFilters.IsTestProject(relative, File.ReadAllText(file)))
+                {
+                    return true;
+                }
+
+                log.WriteLine($"dropped test project: {relative}");
+                return false;
+            })
+            .Order(StringComparer.Ordinal)
+            .ToList();
+        return (files, glob);
+    }
+
+    /// <summary>
+    /// MSBuildWorkspace needs restored projects (project.assets.json) to resolve references. Runs from the repo root
+    /// so the target's own global.json picks the SDK.
+    /// </summary>
+    private static async Task RestoreAsync(string path, string repoRoot)
+    {
+        var start = new ProcessStartInfo("dotnet", ["restore", path, "--nologo", "-v", "q"])
+        {
+            WorkingDirectory = repoRoot,
+            RedirectStandardOutput = true,
+            RedirectStandardError = true,
+        };
+        using var process = Process.Start(start)
+            ?? throw new WorkspaceLoadException("Could not start `dotnet restore`.");
+        var stdout = process.StandardOutput.ReadToEndAsync();
+        var stderr = process.StandardError.ReadToEndAsync();
+
+        using var timeout = new CancellationTokenSource(RestoreTimeout);
+        try
+        {
+            await process.WaitForExitAsync(timeout.Token);
+        }
+        catch (OperationCanceledException)
+        {
+            process.Kill(entireProcessTree: true);
+            throw new WorkspaceLoadException($"`dotnet restore {path}` did not finish within {RestoreTimeout.TotalMinutes} minutes.");
+        }
+
+        if (process.ExitCode != 0)
+        {
+            throw new WorkspaceLoadException(
+                $"`dotnet restore {path}` failed ({process.ExitCode}):{Environment.NewLine}{await stdout}{await stderr}");
+        }
+    }
+
+    private static bool PathsEqual(string? a, string b) =>
+        a is not null && string.Equals(Path.GetFullPath(a), Path.GetFullPath(b), StringComparison.OrdinalIgnoreCase);
+}

package/template/.claude/skills/logical-components/scripts/LogicalComponents.Tests/AssignIdsTests.cs

@@ -0,0 +1,41 @@
+namespace LogicalComponents.Tests;
+
+public class AssignIdsTests
+{
+    private static Component Unnamed(string type, string module) =>
+        new(Id: "", Type: type, Name: "", Module: module, Layer: "Application", Spans: []);
+
+    [Fact]
+    public void A_three_way_clash_across_modules_prefixes_every_member_with_its_module()
+    {
+        var named = ComponentDiscovery.AssignIds(
+        [
+            Unnamed("A.Export.Application.Reporting", "Export"),
+            Unnamed("A.Import.Application.Reporting", "Import"),
+            Unnamed("A.Jobs.Reporting", "BuildingBlocks"),
+            Unnamed("A.Export.Application.Framing", "Export"),
+        ]);
+
+        Assert.Equal(
+            [
+                ("A.Export.Application.Framing", "Framing", "Framing"),
+                ("A.Export.Application.Reporting", "Export_Reporting", "Reporting (Export)"),
+                ("A.Import.Application.Reporting", "Import_Reporting", "Reporting (Import)"),
+                ("A.Jobs.Reporting", "BuildingBlocks_Reporting", "Reporting (BuildingBlocks)"),
+            ],
+            named.Select(c => (c.Type, c.Id, c.Name)));
+    }
+
+    [Fact]
+    public void The_same_type_twice_is_an_error_rather_than_two_identical_ids()
+    {
+        // A source file linked into two projects declares the same full type name in both.
+        var error = Assert.Throws<InvalidOperationException>(() => ComponentDiscovery.AssignIds(
+        [
+            Unnamed("A.Shared.Clock", "Export"),
+            Unnamed("A.Shared.Clock", "Import"),
+        ]));
+
+        Assert.Contains("A.Shared.Clock", error.Message);
+    }
+}

package/template/.claude/skills/logical-components/scripts/LogicalComponents.Tests/BatchPlanningTests.cs

@@ -0,0 +1,90 @@
+namespace LogicalComponents.Tests;
+
+public class BatchPlanningTests
+{
+    private static ExtractResult WithComponents(int count) => RenderTestData.Extraction with
+    {
+        Components = [.. Enumerable.Range(1, count).Select(i =>
+            new Component($"C{i:D3}", $"A.C{i:D3}", $"C {i:D3}", "A", "Application", [new SourceSpan($"src/C{i:D3}.cs", 1, 9)]))],
+        ExternalNodes = [],
+        Edges = [],
+    };
+
+    [Theory]
+    [InlineData(82, 9, new[] { 10, 10, 10, 10, 10, 10, 10, 10, 2 })]
+    [InlineData(20, 9, new[] { 3, 3, 3, 3, 3, 3, 2 })]
+    [InlineData(5, 9, new[] { 1, 1, 1, 1, 1 })]
+    public void Components_are_split_into_at_most_the_agent_count_of_equal_batches_in_extraction_order(
+        int components, int agents, int[] sizes)
+    {
+        var batches = BatchPlanning.Plan(WithComponents(components), agents);
+
+        Assert.Equal(sizes, batches.Select(b => b.Components.Count));
+        Assert.Equal(Enumerable.Range(1, sizes.Length), batches.Select(b => b.Batch));
+        Assert.Equal(
+            WithComponents(components).Components.Select(c => c.Id),
+            batches.SelectMany(b => b.Components).Select(c => c.Id));
+    }
+
+    [Fact]
+    public void Each_component_carries_its_spans_and_what_it_uses_by_name()
+    {
+        var batch = BatchPlanning.Plan(RenderTestData.Extraction, 9)
+            .SelectMany(b => b.Components)
+            .Single(c => c.Id == "OrderAcceptance");
+
+        Assert.Equal([new SourceSpan("src/App/OrderAcceptance.cs", 4, 17)], batch.Spans);
+        // Records compare their list members by reference, so compare the contents.
+        Assert.Equal(
+            [
+                ("IAuditTrail", "I Audit Trail", "di", ""),
+                ("OrderQueue", "Order Queue", "di,new", "IOrderQueue,IQueue"),
+            ],
+            batch.Uses.Select(u => (u.Id, u.Name, string.Join(",", u.Kinds), string.Join(",", u.Via))));
+    }
+
+    [Fact]
+    public void Each_component_carries_the_helper_code_it_runs()
+    {
+        var reaches = new List<SourceSpan> { new("src/Infra/OrderQueue.cs", 10, 10) };
+        var extraction = RenderTestData.Extraction with
+        {
+            Components = [RenderTestData.Extraction.Components[0] with { Reaches = reaches }, .. RenderTestData.Extraction.Components.Skip(1)],
+        };
+
+        var batch = BatchPlanning.Plan(extraction, 9).SelectMany(b => b.Components).Single(c => c.Id == "OrderAcceptance");
+
+        Assert.Equal(reaches, batch.Reaches);
+    }
+
+    [Fact]
+    public void An_enormous_agent_count_does_not_overflow_the_batch_size()
+    {
+        var batches = BatchPlanning.Plan(WithComponents(3), int.MaxValue);
+
+        Assert.Equal([1, 1, 1], batches.Select(b => b.Components.Count));
+    }
+
+    [Fact]
+    public void Batch_files_are_written_identically_every_time()
+    {
+        var first = Directory.CreateTempSubdirectory("lc-batches-");
+        var second = Directory.CreateTempSubdirectory("lc-batches-");
+        try
+        {
+            BatchPlanning.Write(BatchPlanning.Plan(WithComponents(20), 9), first.FullName);
+            BatchPlanning.Write(BatchPlanning.Plan(WithComponents(20), 9), second.FullName);
+
+            var names = Directory.GetFiles(first.FullName).Select(Path.GetFileName).Order().ToList();
+            Assert.Equal(Enumerable.Range(1, 7).Select(i => $"batch-{i:D2}.json"), names);
+            Assert.All(names, n => Assert.Equal(
+                File.ReadAllBytes(Path.Combine(first.FullName, n!)),
+                File.ReadAllBytes(Path.Combine(second.FullName, n!))));
+        }
+        finally
+        {
+            first.Delete(recursive: true);
+            second.Delete(recursive: true);
+        }
+    }
+}

package/template/.claude/skills/logical-components/scripts/LogicalComponents.Tests/BatchesCommandTests.cs

@@ -0,0 +1,37 @@
+namespace LogicalComponents.Tests;
+
+/// <summary>The batches command end to end: malformed or extreme input fails cleanly instead of crashing.</summary>
+public class BatchesCommandTests : IDisposable
+{
+    private readonly DirectoryInfo _work = Directory.CreateTempSubdirectory("lc-batches-cmd-");
+
+    public void Dispose() => _work.Delete(recursive: true);
+
+    private string PathOf(string relative) => Path.Combine(_work.FullName, relative);
+
+    [Fact]
+    public async Task An_empty_components_json_is_an_error_not_a_crash()
+    {
+        File.WriteAllText(PathOf("components.json"), "{}");
+        var output = new StringWriter();
+
+        var exit = await BatchesCommand.RunAsync(
+            ["--components", PathOf("components.json"), "--agents", "9", "--out", PathOf("batches")], output);
+
+        Assert.Equal(2, exit);
+        Assert.Contains(PathOf("components.json"), output.ToString());
+    }
+
+    [Fact]
+    public async Task An_enormous_agent_count_does_not_crash()
+    {
+        File.WriteAllBytes(PathOf("components.json"), ComponentsFile.Serialize(RenderTestData.Extraction));
+        var output = new StringWriter();
+
+        var exit = await BatchesCommand.RunAsync(
+            ["--components", PathOf("components.json"), "--agents", int.MaxValue.ToString(), "--out", PathOf("batches")], output);
+
+        Assert.Equal(0, exit);
+        Assert.True(File.Exists(Path.Combine(PathOf("batches"), "batch-01.json")));
+    }
+}

package/template/.claude/skills/logical-components/scripts/LogicalComponents.Tests/CandidatesCommandTests.cs

@@ -0,0 +1,59 @@
+namespace LogicalComponents.Tests;
+
+[Collection(FixtureSolutions.Name)]
+public class CandidatesCommandTests(SampleAppWorkspace sample)
+{
+    private static readonly ExtractConfig FixtureConfig = ExtractConfig.Load(FixturePaths.SampleApp);
+
+    [Fact]
+    public async Task Each_candidate_carries_its_spans_and_how_the_config_classifies_it()
+    {
+        var config = FixtureConfig with { Components = FixtureConfig.Components.Where(c => c != "Sample.Infrastructure.Mailer").ToList() };
+
+        var file = await CandidatesCommand.ListAsync(sample.Loaded, config, TestContext.Current.CancellationToken);
+        var byType = file.Candidates.ToDictionary(c => c.Type);
+
+        var acceptance = byType["Sample.Application.OrderAcceptance"];
+        Assert.Equal(("Application", "Sample", "component"), (acceptance.Layer, acceptance.Module, acceptance.Status));
+        Assert.Equal([new SourceSpan("src/Sample.Application/OrderAcceptance.cs", 4, 17)], acceptance.Spans);
+        Assert.Equal("helper", byType["Sample.Application.OrderNumber"].Status);
+        Assert.Equal("unclassified", byType["Sample.Infrastructure.Mailer"].Status);
+        Assert.Equal(file.Candidates.OrderBy(c => c.Type, StringComparer.Ordinal).Select(c => c.Type), file.Candidates.Select(c => c.Type));
+    }
+
+    [Fact]
+    public async Task Extract_refuses_unclassified_candidates_naming_each_one()
+    {
+        var config = FixtureConfig with { Components = FixtureConfig.Components.Where(c => c != "Sample.Infrastructure.Mailer").ToList() };
+
+        var error = await Assert.ThrowsAsync<UnclassifiedCandidatesException>(() =>
+            CouplingResolver.ExtractAsync(sample.Loaded, config, TestContext.Current.CancellationToken));
+
+        Assert.Equal(["Sample.Infrastructure.Mailer"], error.Types);
+    }
+
+    [Fact]
+    public async Task Unknown_option_prints_usage_and_exits_1()
+    {
+        var errors = new StringWriter();
+
+        var exitCode = await CandidatesCommand.RunAsync(["repo", "--bogus"], errors);
+
+        Assert.Equal(1, exitCode);
+        Assert.Contains(CandidatesCommand.Usage, errors.ToString());
+    }
+
+    [Fact]
+    public async Task Solution_option_is_parsed_and_passed_through_to_the_loader()
+    {
+        var errors = new StringWriter();
+        var missing = Path.Combine(Path.GetTempPath(), "lc-does-not-exist-" + Guid.NewGuid());
+
+        var exitCode = await CandidatesCommand.RunAsync([missing, "--solution", "custom.slnx", "--out", "out.json"], errors);
+
+        // --solution and --out both parsed fine (no usage error); it fails later because repoPath itself is missing,
+        // proving the flag reached WorkspaceLoader.LoadAsync rather than being rejected as an unknown option.
+        Assert.Equal(2, exitCode);
+        Assert.Contains(missing, errors.ToString());
+    }
+}

package/template/.claude/skills/logical-components/scripts/LogicalComponents.Tests/CitationTests.cs

@@ -0,0 +1,42 @@
+namespace LogicalComponents.Tests;
+
+public class CitationTests
+{
+    [Theory]
+    [InlineData("src/A/B.cs:12-30", "src/A/B.cs", 12, 30)]
+    [InlineData("src/A/B.cs:7", "src/A/B.cs", 7, 7)]
+    [InlineData("src/My Folder/C.cs:1-2", "src/My Folder/C.cs", 1, 2)]
+    [InlineData("src/A/B.cs:0007-007", "src/A/B.cs", 7, 7)]
+    public void Parses_a_file_with_a_line_or_a_line_range(string cite, string file, int start, int end)
+    {
+        Assert.Equal(new Citation(file, start, end), Citation.Parse(cite));
+    }
+
+    [Theory]
+    [InlineData("")]
+    [InlineData("src/A/B.cs")]
+    [InlineData("src/A/B.cs:")]
+    [InlineData("src/A/B.cs:0-3")]
+    [InlineData("src/A/B.cs:9-3")]
+    [InlineData("src/A/B.cs:a-b")]
+    [InlineData(":3-4")]
+    [InlineData("src\\A\\B.cs:3-4")]
+    [InlineData("src/A/B.cs:99999999999")]
+    [InlineData("src/A/B.cs:٣")]
+    [InlineData("src/A/B.cs:11\n")]
+    [InlineData(" src/A/B.cs:11")]
+    [InlineData("src/A/B.cs:11 ")]
+    [InlineData("src/A\tB.cs:11")]
+    public void Anything_else_does_not_parse(string cite)
+    {
+        Assert.Null(Citation.Parse(cite));
+    }
+
+    [Theory]
+    [InlineData("src/A/B.cs:0007-007", "src/A/B.cs:7")]
+    [InlineData("src/A/B.cs:3-09", "src/A/B.cs:3-9")]
+    public void Prints_in_canonical_form(string cite, string canonical)
+    {
+        Assert.Equal(canonical, Citation.Parse(cite)!.ToString());
+    }
+}