@phuc1403/musketeer 0.12.1 → 0.15.0

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

@@ -1,54 +0,0 @@
-using Microsoft.CodeAnalysis;
-
-namespace LogicalComponents;
-
-/// <summary>
-/// Decides whether a syntax tree is source a reader can open and cite: a real project document inside the repo.
-/// Spans and edge locations only ever come from such trees, which is what keeps the output checkout-independent.
-/// </summary>
-public static class CitableSource
-{
-    public enum Kind
-    {
-        /// <summary>
-        /// Not a project document, a source generator's virtual output, or a real file under a bin/ or obj/ folder
-        /// (gRPC/NSwag output, a stray build copy): never cited, silently skipped.
-        /// </summary>
-        NotSource,
-
-        /// <summary>A real file outside the repo root (linked file, other drive): cannot be cited portably.</summary>
-        OutsideRepo,
-
-        /// <summary>A real file inside the repo: <c>RelativePath</c> is repo-relative with forward slashes.</summary>
-        InRepo,
-    }
-
-    public static (Kind Kind, string RelativePath) Classify(LoadedWorkspace loaded, SyntaxTree? tree)
-    {
-        if (tree is null || loaded.Solution.GetDocument(tree) is null or SourceGeneratedDocument)
-        {
-            return (Kind.NotSource, "");
-        }
-
-        var relative = Path.GetRelativePath(loaded.RepoRoot, tree.FilePath);
-        if (Path.IsPathRooted(relative) || relative.StartsWith(".."))
-        {
-            return (Kind.OutsideRepo, "");
-        }
-
-        return IsBuildOutputPath(relative) ? (Kind.NotSource, "") : (Kind.InRepo, relative.Replace('\\', '/'));
-    }
-
-    /// <summary>
-    /// True when any path segment is <c>bin</c> or <c>obj</c>, case-insensitively: build output is never real source,
-    /// whether it is design-time generator output (gRPC, NSwag) or a build step's stray copy of a project file.
-    /// Shared with <see cref="WorkspaceLoader"/>'s project-file discovery so the two never disagree.
-    /// </summary>
-    public static bool IsBuildOutputPath(string relativePath) =>
-        relativePath.Split('/', '\\').Any(segment =>
-            segment.Equals("bin", StringComparison.OrdinalIgnoreCase) || segment.Equals("obj", StringComparison.OrdinalIgnoreCase));
-
-    /// <summary>Declared in a real document of the loaded solution (not metadata, not generator output).</summary>
-    public static bool IsRepoSource(Microsoft.CodeAnalysis.INamedTypeSymbol type, LoadedWorkspace loaded) =>
-        type.Locations.Any(l => l.IsInSource && Classify(loaded, l.SourceTree).Kind != Kind.NotSource);
-}

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

@@ -1,37 +0,0 @@
-using System.Text.RegularExpressions;
-
-namespace LogicalComponents;
-
-/// <summary>One responsibility an agent wrote for a component, and the source lines it claims show it.</summary>
-public sealed record Responsibility(string Text, string Cite);
-
-/// <summary>
-/// A parsed <c>file:line</c> or <c>file:start-end</c> citation: a repo-relative path with forward slashes and a 1-based,
-/// inclusive line range. Anything looser (surrounding whitespace, control characters, backslashes, non-ASCII digits,
-/// absurd line numbers) does not parse, so it can never reach the rendered document.
-/// </summary>
-public sealed partial record Citation(string File, int Start, int End)
-{
-    public int LineCount => End - Start + 1;
-
-    public static Citation? Parse(string cite)
-    {
-        var match = Pattern().Match(cite);
-        if (!match.Success)
-        {
-            return null;
-        }
-
-        var start = int.Parse(match.Groups["start"].Value);
-        var end = match.Groups["end"].Success ? int.Parse(match.Groups["end"].Value) : start;
-        return start >= 1 && end >= start ? new Citation(match.Groups["file"].Value, start, end) : null;
-    }
-
-    /// <summary>The canonical form rendered in the document: <c>file:7</c> or <c>file:7-12</c>, never <c>file:0007-007</c>.</summary>
-    public override string ToString() => Start == End ? $"{File}:{Start}" : $"{File}:{Start}-{End}";
-
-    // At most 7 ASCII digits per number, so int.Parse cannot overflow; \z (not $) so a trailing newline cannot slip
-    // through; the path has no colon, backslash or control character and neither starts nor ends with whitespace.
-    [GeneratedRegex(@"\A(?<file>[^:\\\s\p{C}](?:[^:\\\p{C}]*[^:\\\s\p{C}])?):(?<start>[0-9]{1,7})(?:-(?<end>[0-9]{1,7}))?\z")]
-    private static partial Regex Pattern();
-}

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

@@ -1,86 +0,0 @@
-using System.Security.Cryptography;
-using System.Text.Json;
-
-namespace LogicalComponents;
-
-/// <summary>
-/// <c>classify-batches --candidates &lt;candidates.json&gt; --agents &lt;n&gt; --repo &lt;repoPath&gt; --out &lt;dir&gt;</c>: splits
-/// the candidates the config does not classify yet into at most n equal batches, in candidates.json order, one
-/// <c>batch-NN.json</c> per classifier agent. Already classified candidates are never sent again: the repo config is
-/// read fresh here (not trusted from candidates.json's own status), so a stale candidates.json - written before an
-/// earlier classify-merge - cannot resend a type that is already reviewed. It also records the repo config's hash, so
-/// classify-merge can refuse to merge if anything edited the config in between.
-/// Exit codes: 0 written, 1 usage, 2 unreadable candidates.json or repo config.
-/// </summary>
-public static class ClassifyBatchesCommand
-{
-    public const string Usage =
-        "usage: LogicalComponents classify-batches --candidates <candidates.json> --agents <n> --repo <repoPath> --out <dir>";
-
-    /// <summary>The file in the batches directory holding the config hash at batching time.</summary>
-    public const string ConfigHashFile = "config.sha256";
-
-    public sealed record ClassifyCandidate(string Type, string Layer, string Module, IReadOnlyList<SourceSpan> Spans);
-
-    public sealed record ClassifyBatch(int Batch, IReadOnlyList<ClassifyCandidate> Candidates);
-
-    public static async Task<int> RunAsync(string[] args, TextWriter output)
-    {
-        if (args is not ["--candidates", var candidatesPath, "--agents", var agentsText, "--repo", var repo, "--out", var outDir]
-            || !int.TryParse(agentsText, out var agents) || agents < 1 || !Directory.Exists(repo))
-        {
-            await output.WriteLineAsync(Usage);
-            return 1;
-        }
-
-        CandidatesCommand.CandidatesFile file;
-        try
-        {
-            file = ComponentsFile.FromJson<CandidatesCommand.CandidatesFile>(await File.ReadAllBytesAsync(candidatesPath));
-        }
-        catch (Exception e) when (e is IOException or UnauthorizedAccessException or JsonException)
-        {
-            await output.WriteLineAsync($"Cannot read {candidatesPath}: {e.Message}");
-            return 2;
-        }
-
-        if (file.Candidates is null)
-        {
-            await output.WriteLineAsync($"{candidatesPath} is not a candidates.json written by the candidates command");
-            return 2;
-        }
-
-        ExtractConfig config;
-        try
-        {
-            config = ExtractConfig.Load(repo);
-        }
-        catch (ExtractConfigException e)
-        {
-            await output.WriteLineAsync(e.Message);
-            return 2;
-        }
-
-        // c.Status reflects the config at candidates time; re-check against the config now in case it changed since
-        // (classify-merge could have classified some of these candidates in an earlier round).
-        var unclassified = file.Candidates
-            .Where(c => c.Status == CandidatesCommand.Unclassified && !config.IsClassified(c.Type))
-            .Select(c => new ClassifyCandidate(c.Type, c.Layer, c.Module, c.Spans))
-            .ToList();
-        var size = Math.Max(1, (unclassified.Count + agents - 1) / agents);
-        var batches = unclassified.Chunk(size).Select((chunk, index) => new ClassifyBatch(index + 1, chunk)).ToList();
-
-        BatchPlanning.Write(batches, b => b.Batch, outDir);
-        await File.WriteAllTextAsync(Path.Combine(outDir, ConfigHashFile), ConfigHash(repo));
-        await output.WriteLineAsync(
-            $"{unclassified.Count} unclassified candidates in {batches.Count} batches -> {Path.GetFullPath(outDir)}");
-        return 0;
-    }
-
-    /// <summary>SHA-256 of the repo's config file as it is now, or <c>absent</c>.</summary>
-    public static string ConfigHash(string repo)
-    {
-        var path = Path.Combine(repo, ExtractConfig.FileName);
-        return File.Exists(path) ? Convert.ToHexString(SHA256.HashData(File.ReadAllBytes(path))) : "absent";
-    }
-}

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

@@ -1,219 +0,0 @@
-using System.Text.Json;
-
-namespace LogicalComponents;
-
-/// <summary>
-/// <c>classify-merge --batches &lt;dir&gt; --verdicts &lt;dir&gt; --repo &lt;repoPath&gt;</c>: adds the classifier agents' verdicts
-/// (<c>verdicts/batch-NN.json</c>: <c>[{ type, verdict: component|helper, reason, cite }]</c>) to the repo's
-/// <c>logical-components.json</c>. The agents' output is checked against the batches they were given before anything is
-/// written: one verdict file per batch and none left over, exactly one verdict per candidate of the batch and no other
-/// type, a known verdict, a one-line reason under 200 characters, a citation inside the candidate's declaration, and a
-/// type the config does not already classify (a stale candidates.json could otherwise resend an already-reviewed type).
-/// The config must be unchanged since classify-batches, so nothing can slip an entry past the review.
-/// Prints each added entry (helpers first, for review) and a summary on <c>output</c>.
-/// Exit codes: 0 written, 1 usage, 2 the existing config or a batch file is unreadable, 3 the verdicts break the
-/// contract or the config changed (every problem listed, nothing written).
-/// </summary>
-public static class ClassifyMergeCommand
-{
-    public const string Usage = "usage: LogicalComponents classify-merge --batches <dir> --verdicts <dir> --repo <repoPath>";
-
-    private const int MaxReasonLength = 200;
-    private const int MaxCitedLines = 30;
-
-    private sealed record VerdictJson(string? Type, string? Verdict, string? Reason, string? Cite);
-
-    /// <summary>A batch file from classify-batches could not be read: an environment/tooling problem, not the agents' fault.</summary>
-    private sealed class MalformedBatchException(string message) : Exception(message);
-
-    public static async Task<int> RunAsync(string[] args, TextWriter output)
-    {
-        if (args is not ["--batches", var batchDir, "--verdicts", var verdictDir, "--repo", var repo]
-            || !Directory.Exists(batchDir) || !Directory.Exists(verdictDir) || !Directory.Exists(repo))
-        {
-            await output.WriteLineAsync(Usage);
-            return 1;
-        }
-
-        ExtractConfig existing;
-        try
-        {
-            existing = ExtractConfig.Load(repo);
-        }
-        catch (ExtractConfigException e)
-        {
-            await output.WriteLineAsync(e.Message);
-            return 2;
-        }
-
-        var problems = new List<string>();
-        var hashFile = Path.Combine(batchDir, ClassifyBatchesCommand.ConfigHashFile);
-        if (!File.Exists(hashFile) || File.ReadAllText(hashFile) != ClassifyBatchesCommand.ConfigHash(repo))
-        {
-            problems.Add($"{ExtractConfig.FileName} changed since classify-batches; review that change, then batch again");
-        }
-
-        List<VerdictJson> verdicts;
-        try
-        {
-            verdicts = Check(batchDir, verdictDir, existing, problems);
-        }
-        catch (MalformedBatchException e)
-        {
-            await output.WriteLineAsync(e.Message);
-            return 2;
-        }
-
-        if (problems.Count > 0)
-        {
-            foreach (var problem in problems)
-            {
-                await output.WriteLineAsync(problem);
-            }
-
-            return 3;
-        }
-
-        var components = existing.Components.ToHashSet(StringComparer.Ordinal);
-        var helpers = new SortedDictionary<string, string>(existing.Helpers.ToDictionary(), StringComparer.Ordinal);
-        var added = verdicts.OrderBy(v => v.Type, StringComparer.Ordinal).ToList();
-        foreach (var verdict in added)
-        {
-            if (verdict.Verdict == CandidatesCommand.Helper)
-            {
-                helpers[verdict.Type!] = verdict.Reason!;
-            }
-            else
-            {
-                components.Add(verdict.Type!);
-            }
-        }
-
-        if (added.Count > 0)
-        {
-            await File.WriteAllBytesAsync(
-                Path.Combine(repo, ExtractConfig.FileName),
-                ComponentsFile.ToJson(new { components = components.Order(StringComparer.Ordinal), helpers }));
-        }
-
-        foreach (var verdict in added.OrderBy(v => v.Verdict == CandidatesCommand.Helper ? 0 : 1))
-        {
-            await output.WriteLineAsync($"{verdict.Verdict} {verdict.Type}: {verdict.Reason}");
-        }
-
-        await output.WriteLineAsync(
-            $"{added.Count(v => v.Verdict == CandidatesCommand.Component)} components, "
-            + $"{added.Count(v => v.Verdict == CandidatesCommand.Helper)} helpers added");
-        return 0;
-    }
-
-    /// <summary>Every verdict of every batch, or problems (in batch file order) when the agents' output breaks the contract.</summary>
-    /// <exception cref="MalformedBatchException">A batch file itself (written by classify-batches, not an agent) is not valid JSON.</exception>
-    private static List<VerdictJson> Check(string batchDir, string verdictDir, ExtractConfig existing, List<string> problems)
-    {
-        var batchFiles = Directory.EnumerateFiles(batchDir, "batch-*.json").Select(Path.GetFileName).OfType<string>()
-            .Order(StringComparer.Ordinal).ToList();
-        problems.AddRange(Directory.EnumerateFiles(verdictDir, "batch-*.json").Select(Path.GetFileName).OfType<string>()
-            .Where(name => !batchFiles.Contains(name))
-            .Order(StringComparer.Ordinal)
-            .Select(name => $"{name}: verdicts for a batch that does not exist (left from an earlier round?)"));
-
-        var all = new List<VerdictJson>();
-        foreach (var name in batchFiles)
-        {
-            ClassifyBatchesCommand.ClassifyBatch batch;
-            try
-            {
-                batch = ComponentsFile.FromJson<ClassifyBatchesCommand.ClassifyBatch>(File.ReadAllBytes(Path.Combine(batchDir, name)));
-            }
-            catch (Exception e) when (e is IOException or UnauthorizedAccessException or JsonException)
-            {
-                throw new MalformedBatchException($"{name}: not a valid batch file ({e.Message})");
-            }
-
-            var verdictPath = Path.Combine(verdictDir, name);
-            if (!File.Exists(verdictPath))
-            {
-                problems.Add($"{name}: no verdict file");
-                continue;
-            }
-
-            List<VerdictJson?> read;
-            try
-            {
-                read = ComponentsFile.FromJson<List<VerdictJson?>>(File.ReadAllBytes(verdictPath));
-            }
-            catch (Exception e) when (e is IOException or UnauthorizedAccessException or JsonException)
-            {
-                problems.Add($"{name}: not a verdict array ({e.Message})");
-                continue;
-            }
-
-            var verdicts = read.OfType<VerdictJson>().ToList();
-            var candidates = batch.Candidates.ToDictionary(c => c.Type, StringComparer.Ordinal);
-            foreach (var group in verdicts.GroupBy(v => v.Type ?? "", StringComparer.Ordinal))
-            {
-                if (!candidates.TryGetValue(group.Key, out var candidate))
-                {
-                    problems.Add($"{name}: {Printable(group.Key)}: not a candidate of this batch");
-                }
-                else if (group.Count() > 1)
-                {
-                    problems.Add($"{name}: {group.Key}: more than one verdict");
-                }
-                else if (Problem(group.Single(), candidate, existing) is { } problem)
-                {
-                    problems.Add($"{name}: {group.Key}: {problem}");
-                }
-            }
-
-            problems.AddRange(candidates.Keys.Where(type => verdicts.All(v => v.Type != type))
-                .Select(type => $"{name}: {type}: no verdict"));
-            all.AddRange(verdicts);
-        }
-
-        return all;
-    }
-
-    private static string? Problem(VerdictJson verdict, ClassifyBatchesCommand.ClassifyCandidate candidate, ExtractConfig existing)
-    {
-        // Never overwrite a reviewed entry: a stale candidates.json could otherwise resend an already-classified type
-        // and have its verdict silently replace the reviewed reason, or put the type in both lists.
-        if (existing.IsClassified(candidate.Type))
-        {
-            return $"already classified in {ExtractConfig.FileName}; re-run candidates";
-        }
-
-        if (verdict.Verdict is not (CandidatesCommand.Component or CandidatesCommand.Helper))
-        {
-            return "verdict must be component or helper";
-        }
-
-        if (string.IsNullOrWhiteSpace(verdict.Reason))
-        {
-            return "reason is empty";
-        }
-
-        // The reason is printed at the review gate and stored in the config: one plain line, so it cannot fake other
-        // lines or hide a bidi/zero-width character in what looks like a normal sentence.
-        if (PlainText.HasDisallowedUnicode(verdict.Reason))
-        {
-            return "reason has control characters";
-        }
-
-        if (verdict.Reason.Length > MaxReasonLength)
-        {
-            return $"reason is {verdict.Reason.Length} characters; keep it under {MaxReasonLength}";
-        }
-
-        var cite = Citation.Parse(verdict.Cite ?? "");
-        return cite is not null
-            && cite.LineCount <= MaxCitedLines
-            && candidate.Spans.Any(s => s.File == cite.File && s.Start <= cite.Start && cite.End <= s.End)
-            ? null
-            : $"cite '{verdict.Cite}' is not inside its declaration";
-    }
-
-    // An unknown type is agent text: print it without anything that could start a new line at the review gate.
-    private static string Printable(string text) => new(text.Select(c => PlainText.IsDisallowed(c) ? '?' : c).ToArray());
-}

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

@@ -1,180 +0,0 @@
-using Microsoft.CodeAnalysis;
-
-namespace LogicalComponents;
-
-/// <summary>
-/// Lists the candidates (every type in an Application or Infrastructure project that passes <see cref="ComponentRule"/>)
-/// and keeps as components the ones the repo's frozen classification calls components. Output order is by full type
-/// name, so the same code and config always yield the same list.
-/// </summary>
-public static class ComponentDiscovery
-{
-    public const string ApplicationLayer = "Application";
-    public const string InfrastructureLayer = "Infrastructure";
-
-    /// <summary>The candidates, as components not yet named (empty id and name), plus out-of-repo warnings.</summary>
-    public sealed record CandidateList(IReadOnlyList<Component> Candidates, IReadOnlyList<string> Warnings);
-
-    public static async Task<CandidateList> CandidatesAsync(LoadedWorkspace loaded, CancellationToken cancellationToken = default)
-    {
-        var warnings = new List<string>();
-        var types = await SourceTypesAsync(loaded.Solution, cancellationToken);
-        if (types.All(t => t.Layer is not (ApplicationLayer or InfrastructureLayer)))
-        {
-            // Nothing to classify is easy to miss: an empty document with no explanation looks like success.
-            warnings.Add(
-                $"no {ApplicationLayer} or {InfrastructureLayer} project found among: {string.Join(", ", loaded.ProjectNames)}");
-        }
-
-        var candidates = types
-            .Where(t => t.Layer is (ApplicationLayer or InfrastructureLayer) && ComponentRule.IsCandidate(t.Symbol))
-            .Select(t => ToComponent(t, loaded, warnings))
-            .OfType<Component>()
-            .ToList();
-        return new CandidateList(candidates, warnings);
-    }
-
-    public static async Task<DiscoveryResult> DiscoverAsync(
-        LoadedWorkspace loaded, ExtractConfig config, CancellationToken cancellationToken = default)
-    {
-        var (candidates, candidateWarnings) = await CandidatesAsync(loaded, cancellationToken);
-        var known = candidates.Select(c => c.Type).ToHashSet(StringComparer.Ordinal);
-        var stale = config.Components.Concat(config.Helpers.Keys)
-            .Where(name => !known.Contains(name))
-            .Distinct()
-            .Order(StringComparer.Ordinal)
-            .Select(name => $"config entry '{name}' names no candidate; ignored");
-
-        return new DiscoveryResult(
-            AssignIds(candidates.Where(c => config.Components.Contains(c.Type)).ToList()),
-            candidates.Where(c => !config.IsClassified(c.Type)).Select(c => c.Type).ToList(),
-            [.. candidateWarnings, .. stale]);
-    }
-
-    /// <summary>A top-level type declared in a loaded project, with the layer and module its project gives it.</summary>
-    public sealed record SourceType(INamedTypeSymbol Symbol, string Layer, string Module);
-
-    public static async Task<List<SourceType>> SourceTypesAsync(Solution solution, CancellationToken cancellationToken)
-    {
-        var types = new List<SourceType>();
-        foreach (var project in solution.Projects)
-        {
-            var compilation = await project.GetCompilationAsync(cancellationToken)
-                ?? throw new InvalidOperationException($"No compilation for {project.Name}");
-            var (layer, module) = LayerAndModule(project.Name);
-            types.AddRange(TopLevelTypes(compilation.Assembly.GlobalNamespace)
-                .Where(t => t.Locations.Any(l => l.IsInSource))
-                .Select(t => new SourceType(t, layer, module)));
-        }
-
-        return types.OrderBy(t => SymbolNames.FullName(t.Symbol), StringComparer.Ordinal).ToList();
-    }
-
-    /// <summary>
-    /// <c>WorkerDwg.Export.Application</c> → (Application, Export); <c>Sample.Infrastructure</c> → (Infrastructure, Sample);
-    /// a bare <c>Application</c>/<c>Infrastructure</c> project → that layer, itself as its module; matched
-    /// case-insensitively, so <c>Foo.application</c> counts too. Any other project → (Other, its last name segment).
-    /// </summary>
-    public static (string Layer, string Module) LayerAndModule(string projectName)
-    {
-        foreach (var layer in new[] { ApplicationLayer, InfrastructureLayer })
-        {
-            if (string.Equals(projectName, layer, StringComparison.OrdinalIgnoreCase))
-            {
-                return (layer, projectName);
-            }
-
-            if (projectName.EndsWith("." + layer, StringComparison.OrdinalIgnoreCase))
-            {
-                var rest = projectName[..^(layer.Length + 1)];
-                return (layer, rest[(rest.LastIndexOf('.') + 1)..]);
-            }
-        }
-
-        return ("Other", projectName[(projectName.LastIndexOf('.') + 1)..]);
-    }
-
-    /// <summary>
-    /// Ids and names are the plain type name unless several components share it; then every one of them is prefixed
-    /// with its module (<c>Export_JobOutcomeReporting</c>, "Job Outcome Reporting (Export)"). If that still clashes
-    /// (same module, different namespace or generic arity), the full type name disambiguates. The same full type twice
-    /// (a file linked into two projects) has no honest id and is an error.
-    /// </summary>
-    public static List<Component> AssignIds(IReadOnlyList<Component> components)
-    {
-        var duplicateTypes = components.GroupBy(c => c.Type).Where(g => g.Count() > 1).Select(g => g.Key).ToList();
-        if (duplicateTypes.Count > 0)
-        {
-            throw new InvalidOperationException(
-                $"Declared in more than one project, so no unique component id: {string.Join(", ", duplicateTypes.Order(StringComparer.Ordinal))}");
-        }
-
-        var bySimpleName = components.GroupBy(c => SymbolNames.SimpleName(c.Type)).ToDictionary(g => g.Key, g => g.Count());
-        var named = components.Select(c =>
-        {
-            var simple = SymbolNames.SimpleName(c.Type);
-            var words = DisplayName.FromTypeName(simple);
-            return bySimpleName[simple] == 1
-                ? c with { Id = simple, Name = words }
-                : c with { Id = $"{c.Module}_{simple}", Name = $"{words} ({c.Module})" };
-        }).ToList();
-
-        var clashingIds = named.GroupBy(c => c.Id).Where(g => g.Count() > 1).Select(g => g.Key).ToHashSet();
-        return named
-            .Select(c => clashingIds.Contains(c.Id)
-                ? c with
-                {
-                    Id = SymbolNames.ToIdentifier(c.Type),
-                    Name = $"{DisplayName.FromTypeName(SymbolNames.SimpleName(c.Type))} ({SymbolNames.ReadableFullName(c.Type)})",
-                }
-                : c)
-            .OrderBy(c => c.Type, StringComparer.Ordinal)
-            .ToList();
-    }
-
-    /// <summary>
-    /// The component for a type, with spans from real source files inside the repo only. Generator output — a source
-    /// generator's virtual document, or a real file under bin/ or obj/ — is skipped silently; a declaration outside the
-    /// repo cannot be cited, so it is skipped with a warning. No span left means no component.
-    /// </summary>
-    public static Component? ToComponent(SourceType type, LoadedWorkspace loaded, List<string> warnings)
-    {
-        var spans = new List<SourceSpan>();
-        foreach (var reference in type.Symbol.DeclaringSyntaxReferences)
-        {
-            var (kind, relative) = CitableSource.Classify(loaded, reference.SyntaxTree);
-            if (kind == CitableSource.Kind.OutsideRepo)
-            {
-                var warning = $"declaration of {SymbolNames.FullName(type.Symbol)} outside the repo was ignored";
-                if (!warnings.Contains(warning))
-                {
-                    warnings.Add(warning);
-                }
-            }
-
-            if (kind != CitableSource.Kind.InRepo)
-            {
-                continue;
-            }
-
-            var lines = reference.GetSyntax().GetLocation().GetLineSpan();
-            spans.Add(new SourceSpan(relative, lines.StartLinePosition.Line + 1, lines.EndLinePosition.Line + 1));
-        }
-
-        if (spans.Count == 0)
-        {
-            return null;
-        }
-
-        return new Component(
-            Id: "",
-            Type: SymbolNames.FullName(type.Symbol),
-            Name: "",
-            Module: type.Module,
-            Layer: type.Layer,
-            Spans: spans.OrderBy(s => s.File, StringComparer.Ordinal).ThenBy(s => s.Start).ToList());
-    }
-
-    private static IEnumerable<INamedTypeSymbol> TopLevelTypes(INamespaceSymbol ns) =>
-        ns.GetTypeMembers().Concat(ns.GetNamespaceMembers().SelectMany(TopLevelTypes));
-}