@phuc1403/musketeer 0.9.0 → 0.11.0

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());
+    }
+}

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

@@ -0,0 +1,176 @@
+using System.Text;
+
+namespace LogicalComponents.Tests;
+
+public class ClassifyCommandsTests : IDisposable
+{
+    private readonly DirectoryInfo _work = Directory.CreateTempSubdirectory("lc-classify-");
+
+    public ClassifyCommandsTests() => Directory.CreateDirectory(PathOf("repo"));
+
+    public void Dispose() => _work.Delete(recursive: true);
+
+    private string PathOf(string relative) => Path.Combine(_work.FullName, relative);
+
+    private static CandidatesCommand.Candidate Candidate(string type, string status) =>
+        new(type, "Application", "Sample", [new SourceSpan($"src/{type}.cs", 1, 9)], status);
+
+    private static string Verdict(string type, string verdict, string reason = "Reason.", string? cite = null) =>
+        $$"""{ "type": "{{type}}", "verdict": "{{verdict}}", "reason": "{{reason}}", "cite": "{{cite ?? $"src/{type}.cs:2-4"}}" }""";
+
+    private async Task<int> BatchAsync(int agents, params CandidatesCommand.Candidate[] candidates)
+    {
+        File.WriteAllBytes(PathOf("candidates.json"), ComponentsFile.ToJson(new CandidatesCommand.CandidatesFile(candidates, [])));
+        return await ClassifyBatchesCommand.RunAsync(
+            ["--candidates", PathOf("candidates.json"), "--agents", agents.ToString(), "--repo", PathOf("repo"), "--out", PathOf("batches")],
+            new StringWriter());
+    }
+
+    private void WriteVerdicts(string batchFile, params string[] verdicts)
+    {
+        Directory.CreateDirectory(PathOf("verdicts"));
+        File.WriteAllText(PathOf($"verdicts/{batchFile}"), "[" + string.Join(",", verdicts) + "]");
+    }
+
+    private Task<int> MergeAsync(TextWriter output) => ClassifyMergeCommand.RunAsync(
+        ["--batches", PathOf("batches"), "--verdicts", PathOf("verdicts"), "--repo", PathOf("repo")], output);
+
+    [Fact]
+    public async Task Batches_hold_only_the_unclassified_candidates_split_evenly()
+    {
+        File.WriteAllBytes(PathOf("candidates.json"), ComponentsFile.ToJson(new CandidatesCommand.CandidatesFile(
+            [
+                Candidate("A.One", "component"), Candidate("A.Two", "unclassified"), Candidate("A.Three", "helper"),
+                Candidate("A.Four", "unclassified"), Candidate("A.Five", "unclassified"),
+            ],
+            [])));
+        var output = new StringWriter();
+
+        var exit = await ClassifyBatchesCommand.RunAsync(
+            ["--candidates", PathOf("candidates.json"), "--agents", "2", "--repo", PathOf("repo"), "--out", PathOf("batches")], output);
+
+        Assert.Equal(0, exit);
+        Assert.Equal(["batch-01.json", "batch-02.json"], Directory.GetFiles(PathOf("batches"), "batch-*.json").Select(Path.GetFileName).Order());
+        var first = File.ReadAllText(PathOf("batches/batch-01.json"));
+        Assert.Contains("\"A.Two\"", first);
+        Assert.Contains("\"A.Four\"", first);
+        Assert.DoesNotContain("A.One", first);
+        Assert.Contains("\"A.Five\"", File.ReadAllText(PathOf("batches/batch-02.json")));
+        Assert.StartsWith("3 unclassified candidates in 2 batches", output.ToString());
+    }
+
+    [Fact]
+    public async Task Nothing_unclassified_writes_no_batches()
+    {
+        Directory.CreateDirectory(PathOf("batches"));
+        File.WriteAllText(PathOf("batches/batch-07.json"), "stale");
+
+        Assert.Equal(0, await BatchAsync(9, Candidate("A.One", "component")));
+
+        Assert.Empty(Directory.GetFiles(PathOf("batches"), "batch-*.json"));
+    }
+
+    [Fact]
+    public async Task Merge_adds_every_verdict_of_every_batch_and_writes_sorted_deterministic_json()
+    {
+        File.WriteAllText(PathOf("repo/logical-components.json"), """
+            { "components": ["A.Kept"], "helpers": { "A.Old": "Reviewed by a person." } }
+            """);
+        await BatchAsync(1, Candidate("A.Zeta", "unclassified"), Candidate("A.Beta", "unclassified"));
+        WriteVerdicts("batch-01.json", Verdict("A.Zeta", "component", "Rejects late orders."), Verdict("A.Beta", "helper", "Formats a name."));
+        var output = new StringWriter();
+
+        var exit = await MergeAsync(output);
+
+        Assert.Equal(0, exit);
+        Assert.Equal(
+            "{\n  \"components\": [\n    \"A.Kept\",\n    \"A.Zeta\"\n  ],\n  \"helpers\": {\n"
+            + "    \"A.Beta\": \"Formats a name.\",\n    \"A.Old\": \"Reviewed by a person.\"\n  }\n}\n",
+            Encoding.UTF8.GetString(File.ReadAllBytes(PathOf("repo/logical-components.json"))));
+        Assert.Equal(
+            "helper A.Beta: Formats a name.\ncomponent A.Zeta: Rejects late orders.\n1 components, 1 helpers added\n",
+            output.ToString().Replace("\r\n", "\n"));
+    }
+
+    [Fact]
+    public async Task Merge_creates_the_config_when_the_repo_has_none()
+    {
+        await BatchAsync(1, Candidate("A.One", "unclassified"));
+        WriteVerdicts("batch-01.json", Verdict("A.One", "helper", "Value object."));
+
+        Assert.Equal(0, await MergeAsync(new StringWriter()));
+
+        var config = ExtractConfig.Load(PathOf("repo"));
+        Assert.Empty(config.Components);
+        Assert.Equal("Value object.", config.Helpers["A.One"]);
+    }
+
+    public static TheoryData<string, string> BadVerdicts => new()
+    {
+        { Verdict("A.One", "maybe"), "batch-01.json: A.One: verdict must be component or helper" },
+        { Verdict("A.One", "helper", ""), "batch-01.json: A.One: reason is empty" },
+        { Verdict("A.One", "helper", "x\\nkept Evil: already classified"), "batch-01.json: A.One: reason has control characters" },
+        { Verdict("A.One", "helper", new string('x', 201)), "batch-01.json: A.One: reason is 201 characters; keep it under 200" },
+        { Verdict("A.One", "helper", cite: "src/A.One.cs:12"), "batch-01.json: A.One: cite 'src/A.One.cs:12' is not inside its declaration" },
+        { Verdict("A.One", "helper", cite: "src/Other.cs:2"), "batch-01.json: A.One: cite 'src/Other.cs:2' is not inside its declaration" },
+        { Verdict("A.One", "helper") + "," + Verdict("A.Ghost", "helper"), "batch-01.json: A.Ghost: not a candidate of this batch" },
+        { Verdict("A.One", "helper") + "," + Verdict("A.One", "component"), "batch-01.json: A.One: more than one verdict" },
+        { "null", "batch-01.json: A.One: no verdict" },
+    };
+
+    [Theory]
+    [MemberData(nameof(BadVerdicts))]
+    public async Task A_verdict_breaking_the_contract_fails_the_merge_and_writes_nothing(string verdicts, string error)
+    {
+        await BatchAsync(1, Candidate("A.One", "unclassified"));
+        Directory.CreateDirectory(PathOf("verdicts"));
+        File.WriteAllText(PathOf("verdicts/batch-01.json"), $"[{verdicts}]");
+        var output = new StringWriter();
+
+        var exit = await MergeAsync(output);
+
+        Assert.Equal(3, exit);
+        Assert.Contains(error, output.ToString());
+        Assert.False(File.Exists(PathOf("repo/logical-components.json")));
+    }
+
+    [Fact]
+    public async Task A_missing_verdict_file_and_a_stale_one_from_an_earlier_round_both_fail()
+    {
+        await BatchAsync(1, Candidate("A.One", "unclassified"));
+        WriteVerdicts("batch-02.json", Verdict("A.Old", "helper"));
+        var output = new StringWriter();
+
+        var exit = await MergeAsync(output);
+
+        Assert.Equal(3, exit);
+        Assert.Contains("batch-01.json: no verdict file", output.ToString());
+        Assert.Contains("batch-02.json: verdicts for a batch that does not exist (left from an earlier round?)", output.ToString());
+    }
+
+    [Fact]
+    public async Task A_config_changed_after_batching_fails_the_merge_so_no_edit_bypasses_the_review()
+    {
+        await BatchAsync(1, Candidate("A.One", "unclassified"));
+        WriteVerdicts("batch-01.json", Verdict("A.One", "helper"));
+        File.WriteAllText(PathOf("repo/logical-components.json"), """{ "components": ["A.Sneaky"] }""");
+        var output = new StringWriter();
+
+        var exit = await MergeAsync(output);
+
+        Assert.Equal(3, exit);
+        Assert.Contains("logical-components.json changed since classify-batches", output.ToString());
+    }
+
+    [Fact]
+    public async Task A_missing_repo_directory_is_a_usage_error_not_a_crash()
+    {
+        await BatchAsync(1, Candidate("A.One", "unclassified"));
+        WriteVerdicts("batch-01.json", Verdict("A.One", "helper"));
+
+        var exit = await ClassifyMergeCommand.RunAsync(
+            ["--batches", PathOf("batches"), "--verdicts", PathOf("verdicts"), "--repo", PathOf("no-such-repo")], new StringWriter());
+
+        Assert.Equal(1, exit);
+    }
+}

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

@@ -0,0 +1,190 @@
+using System.Text;
+
+namespace LogicalComponents.Tests;
+
+[Collection(FixtureSolutions.Name)]
+public class ComponentDiscoveryTests(SampleAppWorkspace sample)
+{
+    private const string OutOfRepoWarning =
+        "declaration of Sample.Billing.Application.SharedClock outside the repo was ignored";
+
+    private static readonly ExtractConfig FixtureConfig = ExtractConfig.Load(FixturePaths.SampleApp);
+
+    private Task<DiscoveryResult> DiscoverAsync(ExtractConfig? config = null) =>
+        ComponentDiscovery.DiscoverAsync(sample.Loaded, config ?? FixtureConfig, TestContext.Current.CancellationToken);
+
+    [Fact]
+    public async Task Candidates_are_the_classes_and_records_with_methods_of_their_own_in_application_and_infrastructure()
+    {
+        var result = await ComponentDiscovery.CandidatesAsync(sample.Loaded, TestContext.Current.CancellationToken);
+
+        // The fixture config classifies every candidate, so the candidates are exactly its entries. Out: records with no
+        // method (OrderRequest, Shape, Circle, QueueEntry, Job) or only a ToString override (Money), OrderSnapshot
+        // (properties and a constructor), OrderOptions (*Options), OrderRejectedException (exception), the composition
+        // roots, FileHelper (file-local), interfaces and abstract classes (seams), Receipts.Builder (nested), SharedClock
+        // (declared outside the repo). In: records with methods, and Infrastructure classes whether reached or not.
+        var types = result.Candidates.Select(c => c.Type).ToList();
+        Assert.Equal(FixtureConfig.Components.Concat(FixtureConfig.Helpers.Keys).Order(StringComparer.Ordinal), types);
+        Assert.Contains("Sample.Application.PaymentMethod", types);
+        Assert.Contains("Sample.Application.Quantity", types);
+        Assert.Contains("Sample.Infrastructure.UnreachedPlumbing", types);
+        Assert.DoesNotContain(types, t => t is "Sample.Application.Money" or "Sample.Application.OrderSnapshot"
+            or "Sample.Application.OrderRequest" or "Sample.Application.Job" or "Sample.Application.Shape"
+            or "Sample.Application.OrderOptions" or "Sample.Application.StageBase" or "Sample.Infrastructure.QueueEntry"
+            or "Sample.Application.Hooks" or "Sample.Application.Registry" or "Sample.Application.Tracked");
+        Assert.Equal([OutOfRepoWarning], result.Warnings);
+    }
+
+    [Fact]
+    public async Task Components_are_exactly_the_candidates_the_config_classifies_as_components()
+    {
+        var result = await DiscoverAsync();
+
+        Assert.Equal(FixtureConfig.Components.Order(StringComparer.Ordinal), result.Components.Select(c => c.Type));
+        Assert.DoesNotContain(result.Components, c => FixtureConfig.Helpers.ContainsKey(c.Type));
+        Assert.Empty(result.Unclassified);
+        Assert.Equal([OutOfRepoWarning], result.Warnings);
+    }
+
+    [Fact]
+    public async Task Candidates_in_neither_list_are_unclassified_and_never_components()
+    {
+        var config = FixtureConfig with
+        {
+            Components = FixtureConfig.Components.Where(c => c != "Sample.Infrastructure.Mailer").ToList(),
+            Helpers = FixtureConfig.Helpers.Where(h => h.Key != "Sample.Application.Quantity").ToDictionary(),
+        };
+
+        var result = await DiscoverAsync(config);
+
+        Assert.Equal(["Sample.Application.Quantity", "Sample.Infrastructure.Mailer"], result.Unclassified);
+        Assert.DoesNotContain(result.Components, c => c.Type == "Sample.Infrastructure.Mailer");
+    }
+
+    [Fact]
+    public async Task Config_entries_naming_no_candidate_are_warnings_not_failures()
+    {
+        var config = FixtureConfig with
+        {
+            Components = [.. FixtureConfig.Components, "Sample.Application.NoSuchType", "Sample.Application.OrderRequest"],
+            Helpers = new Dictionary<string, string>(FixtureConfig.Helpers) { ["RunClock"] = "simple names do not match" },
+        };
+
+        var result = await DiscoverAsync(config);
+
+        Assert.Equal(
+            [
+                OutOfRepoWarning,
+                "config entry 'RunClock' names no candidate; ignored",
+                "config entry 'Sample.Application.NoSuchType' names no candidate; ignored",
+                "config entry 'Sample.Application.OrderRequest' names no candidate; ignored",
+            ],
+            result.Warnings);
+        Assert.Equal(FixtureConfig.Components.Count, result.Components.Count);
+    }
+
+    [Fact]
+    public async Task Clashing_simple_names_get_module_ids_and_names_while_others_stay_plain()
+    {
+        var result = await DiscoverAsync();
+        var byType = result.Components.ToDictionary(c => c.Type);
+
+        var sampleRunning = byType["Sample.Application.OrderRunning"];
+        Assert.Equal(("Sample_OrderRunning", "Order Running (Sample)", "Sample"),
+            (sampleRunning.Id, sampleRunning.Name, sampleRunning.Module));
+
+        var billingRunning = byType["Sample.Billing.Application.OrderRunning"];
+        Assert.Equal(("Billing_OrderRunning", "Order Running (Billing)", "Billing"),
+            (billingRunning.Id, billingRunning.Name, billingRunning.Module));
+
+        var acceptance = byType["Sample.Application.OrderAcceptance"];
+        Assert.Equal(("OrderAcceptance", "Order Acceptance"), (acceptance.Id, acceptance.Name));
+    }
+
+    [Fact]
+    public async Task Same_module_clashes_fall_back_to_the_full_type_name_without_generic_arity_in_the_display_name()
+    {
+        var result = await DiscoverAsync();
+        var byType = result.Components.ToDictionary(c => c.Type);
+
+        Assert.Equal(("Sample_Application_Cache", "Cache (Sample.Application.Cache)"),
+            (byType["Sample.Application.Cache"].Id, byType["Sample.Application.Cache"].Name));
+        Assert.Equal(("Sample_Application_Cache_1", "Cache (Sample.Application.Cache<>)"),
+            (byType["Sample.Application.Cache`1"].Id, byType["Sample.Application.Cache`1"].Name));
+    }
+
+    [Fact]
+    public async Task Spans_are_repo_relative_class_declaration_lines_from_real_source_files_only()
+    {
+        var result = await DiscoverAsync();
+        var byId = result.Components.ToDictionary(c => c.Id);
+
+        Assert.Equal([new SourceSpan("src/Sample.Application/OrderAcceptance.cs", 4, 17)], byId["OrderAcceptance"].Spans);
+        Assert.Equal(
+            [
+                new SourceSpan("src/Sample.Application/ReceiptPrinting.Totals.cs", 3, 6),
+                new SourceSpan("src/Sample.Application/ReceiptPrinting.cs", 4, 7),
+            ],
+            byId["ReceiptPrinting"].Spans);
+        // The [GeneratedRegex] half lives in generator output under obj/; it must not be a span.
+        Assert.Equal([new SourceSpan("src/Sample.Application/EdgeCases.cs", 13, 19)], byId["OrderNumberFormat"].Spans);
+        Assert.All(result.Components.SelectMany(c => c.Spans), s => Assert.StartsWith("src/", s.File));
+    }
+
+    [Fact]
+    public async Task Serialized_output_is_identical_across_runs_lf_only_bom_free_and_repo_relative()
+    {
+        var first = Serialize(await DiscoverAsync());
+        var second = Serialize(await DiscoverAsync());
+
+        Assert.Equal(first, second);
+        var text = Encoding.UTF8.GetString(first);
+        Assert.False(first.AsSpan().StartsWith(Encoding.UTF8.Preamble));
+        Assert.DoesNotContain("\r", text);
+        Assert.EndsWith("\n", text);
+        Assert.DoesNotContain(sample.Loaded.RepoRoot.Replace('\\', '/'), text, StringComparison.OrdinalIgnoreCase);
+        Assert.DoesNotContain(sample.Loaded.RepoRoot, text, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public async Task Output_is_identical_for_the_same_code_checked_out_in_another_folder()
+    {
+        var copyRoot = Directory.CreateTempSubdirectory("lc-checkout-");
+        try
+        {
+            CopySource(FixturePaths.SampleApp, Path.Combine(copyRoot.FullName, "SampleApp"));
+            CopySource(Path.Combine(FixturePaths.Root, "SharedOutsideRepo"), Path.Combine(copyRoot.FullName, "SharedOutsideRepo"));
+            using var copy = await WorkspaceLoader.LoadAsync(Path.Combine(copyRoot.FullName, "SampleApp"));
+
+            var fromCopy = await ComponentDiscovery.DiscoverAsync(copy, FixtureConfig, TestContext.Current.CancellationToken);
+
+            Assert.Equal(
+                Encoding.UTF8.GetString(Serialize(await DiscoverAsync())),
+                Encoding.UTF8.GetString(Serialize(fromCopy)));
+        }
+        finally
+        {
+            copyRoot.Delete(recursive: true);
+        }
+    }
+
+    private static byte[] Serialize(DiscoveryResult result) =>
+        ComponentsFile.Serialize(new ExtractResult(result.Components, [], [], result.Warnings));
+
+    // Copies source files only: bin/obj hold absolute paths of the original checkout.
+    private static void CopySource(string from, string to)
+    {
+        foreach (var file in Directory.EnumerateFiles(from, "*", SearchOption.AllDirectories))
+        {
+            var relative = Path.GetRelativePath(from, file);
+            if (relative.Split(Path.DirectorySeparatorChar).Any(s => s is "bin" or "obj"))
+            {
+                continue;
+            }
+
+            var target = Path.Combine(to, relative);
+            Directory.CreateDirectory(Path.GetDirectoryName(target)!);
+            File.Copy(file, target);
+        }
+    }
+}

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

@@ -0,0 +1,174 @@
+namespace LogicalComponents.Tests;
+
+[Collection(FixtureSolutions.Name)]
+public class CouplingExtractionTests(SampleAppWorkspace sample)
+{
+    private const string AuditTrailPortWarning = "port Sample.Application.IAuditTrail has no implementation";
+
+    private static readonly ExtractConfig FixtureConfig = ExtractConfig.Load(FixturePaths.SampleApp);
+
+    private Task<ExtractResult> ExtractAsync(ExtractConfig? config = null) =>
+        CouplingResolver.ExtractAsync(sample.Loaded, config ?? FixtureConfig, TestContext.Current.CancellationToken);
+
+    private static string Describe(Edge e) =>
+        $"{e.From} -> {e.To} [{string.Join(",", e.Kinds)}]" + (e.Via.Count > 0 ? $" via {string.Join(",", e.Via)}" : "");
+
+    [Fact]
+    public async Task Edges_are_every_way_a_component_runs_or_holds_another_seen_through_helpers_and_seams()
+    {
+        var result = await ExtractAsync();
+
+        // Not edges: anything from DependencyInjection (composition root), references to data (OrderRequest,
+        // QueueEntry), BCL/framework types (DateTime, Console, Enumerable, IReadOnlyList<string>, Lazy, Func), self calls
+        // (OrderNumberFormat.Digits, ShippingStage -> its base's Stamp), a call on a port nothing implements
+        // (IAuditTrail.Record), FakeOrderQueue (test project, never loaded), other constructions of a generic port
+        // (TextHandler), a static member on an interface (FallbackPricing -> DefaultPricing), a const read
+        // (LineCounting -> Limits), the top-level namesake of a nested type (Builder), a record property that runs
+        // nothing (JobCounting -> Job.Id), compiler-written record members (JobShowing -> Job.ToString/Equals), a
+        // property's setter when only its getter runs (TrackedReading), other constructions of a generic seam reached
+        // through a generic helper (PingSending -> PongHandling), and helpers themselves (LabelFormat, Dispatch, ...).
+        Assert.Equal(
+            [
+                "Archiving -> DiskStorage [call,di] via StorageBase",
+                "BatchRunning -> PriceFormatting [static]",
+                "BatchRunning -> RunClock [call,di,new]",
+                "CrashSettling -> ExportRecovery [call] via IRecovery",
+                "CrashSettling -> ImportRecovery [call] via IRecovery",
+                "CrashSettling -> RecoveryRouting [call,di]",
+                "Echoing -> PriceFormatting [static] via PingText",
+                "ForwardedNotifier -> Mailer [call,di]",
+                "JobReporting -> CallbackNormalizing [static] via Job",
+                "LabelMaking -> RunClock [call,new] via LabelBase,ShortLabel",
+                "Labelling -> RunClock [call] via LabelFormat",
+                "LazyWork -> ForwardedNotifier [di] via INotifier",
+                "LazyWork -> OrderQueue [di] via IOrderQueue",
+                "LazyWork -> OrderValidation [di]",
+                "LazyWork -> RunClock [di]",
+                "LoudNotifying -> Notifying [inherits]",
+                "Measuring -> PriceRules [static] via Metres",
+                "NotifyAll -> ForwardedNotifier [call,di] via INotifier",
+                "NotifyAll -> OrderTextExtensions [static]",
+                "OrderAcceptance -> ForwardedNotifier [call,di] via INotifier",
+                "OrderAcceptance -> OrderQueue [call,di] via IOrderQueue",
+                "OrderAcceptance -> OrderValidation [call,di]",
+                "OrderHandling -> LoggingHandler [call,di] via IHandler",
+                "OrderHandling -> OrderRequestHandler [call,di] via IHandler",
+                "OrderQueue -> QueueStore [call,new]",
+                "OrderValidation -> PriceRules [static]",
+                "PingSending -> PingHandling [call] via Dispatch,ICommandHandler",
+                "PongViaSeam -> PongHandling [call,di] via ICommandHandler",
+                "PongViaSeam -> RunClock [call] via ICommandHandler,TwoWay",
+                "ReceiptIssuing -> Receipts [call,new]",
+                "RecoveryRouting -> ExportRecovery [di] via IRecovery",
+                "RecoveryRouting -> ImportRecovery [di] via IRecovery",
+                "RegistryReading -> RunClock [call] via Registry",
+                "Sample_OrderRunning -> IAuditTrail [di]",
+                "Sample_OrderRunning -> RunClock [call,new]",
+                "ShippingStage -> PriceRules [static]",
+                "Stamping -> PriceRules [static] via StampedText",
+                "TickReading -> PriceRules [static] via Ticks",
+                "TitleReading -> DwgDrawing [call] via IDrawing",
+                "TrackedWriting -> CallbackNormalizing [static] via Tracked",
+                "UrgentNotifying -> Notifying [inherits]",
+            ],
+            result.Edges.Select(Describe));
+    }
+
+    [Fact]
+    public async Task An_edge_seen_through_a_helper_cites_the_line_in_the_component_where_the_chain_starts()
+    {
+        var result = await ExtractAsync();
+        var at = result.Edges.ToDictionary(e => (e.From, e.To), e => e.At);
+
+        Assert.Equal("src/Sample.Application/SeeThroughCases.cs:43", at[("JobReporting", "CallbackNormalizing")]);
+        Assert.Equal("src/Sample.Application/SeeThroughCases.cs:59", at[("Labelling", "RunClock")]);
+        Assert.Equal("src/Sample.Application/SeeThroughCases.cs:72", at[("Stamping", "PriceRules")]);
+    }
+
+    [Fact]
+    public async Task Each_component_reaches_exactly_the_helper_members_its_code_runs()
+    {
+        var result = await ExtractAsync();
+        var reaches = result.Components.ToDictionary(c => c.Id, c => c.Reaches ?? []);
+        const string file = "src/Sample.Application/SeeThroughCases.cs";
+
+        // The property of the record it reads, not the record's other members.
+        Assert.Equal([new SourceSpan(file, 33, 33)], reaches["JobReporting"]);
+        Assert.Equal([new SourceSpan(file, 54, 54)], reaches["Labelling"]);
+        // Constructing a helper runs its field initializers.
+        Assert.Equal([new SourceSpan(file, 65, 65)], reaches["Stamping"]);
+        Assert.Empty(reaches["PriceRules"]);
+    }
+
+    [Fact]
+    public async Task Reaches_hold_only_code_that_runs_for_the_use()
+    {
+        var result = await ExtractAsync();
+        var reaches = result.Components.ToDictionary(c => c.Id, c => c.Reaches ?? []);
+        const string file = "src/Sample.Application/ReviewFixCases.cs";
+
+        // The Pong handler of a helper implementing two constructions, not the Ping one listed first.
+        Assert.Equal([new SourceSpan(file, 36, 39)], reaches["PongViaSeam"]);
+        // Compiler-written record members and a getter-only read reach nothing.
+        Assert.Empty(reaches["JobShowing"]);
+        Assert.Single(reaches["TrackedReading"]);
+        Assert.DoesNotContain(reaches["TrackedReading"], s => s.Start == 63);
+    }
+
+    [Fact]
+    public async Task An_inherits_edge_cites_the_base_list_of_the_partial_that_declares_it()
+    {
+        var result = await ExtractAsync();
+
+        Assert.Equal(
+            "src/Sample.Application/LoudNotifying.Base.cs:3",
+            result.Edges.Single(e => (e.From, e.To) == ("LoudNotifying", "Notifying")).At);
+    }
+
+    [Fact]
+    public async Task Every_classified_component_is_a_node_whether_anything_reaches_it_or_not()
+    {
+        var result = await ExtractAsync();
+
+        Assert.Equal(FixtureConfig.Components.Order(StringComparer.Ordinal), result.Components.Select(c => c.Type));
+        Assert.Contains(result.Components, c => c.Type == "Sample.Infrastructure.UnreachedPlumbing");
+    }
+
+    [Fact]
+    public async Task A_port_with_no_implementation_is_an_external_node_with_a_warning()
+    {
+        var result = await ExtractAsync();
+
+        Assert.Equal([new ExternalNode("IAuditTrail", "Sample.Application.IAuditTrail", "I Audit Trail", "port")], result.ExternalNodes);
+        Assert.Contains(AuditTrailPortWarning, result.Warnings);
+    }
+
+    [Fact]
+    public async Task Each_edge_cites_its_first_occurrence()
+    {
+        var result = await ExtractAsync();
+        var at = result.Edges.ToDictionary(e => (e.From, e.To), e => e.At);
+
+        Assert.Equal("src/Sample.Application/OrderAcceptance.cs:4", at[("OrderAcceptance", "OrderQueue")]);
+        Assert.Equal("src/Sample.Application/OrderRunning.cs:15", at[("Sample_OrderRunning", "RunClock")]);
+        Assert.Equal("src/Sample.Application/CouplingCases.cs:5", at[("BatchRunning", "RunClock")]);
+    }
+
+    [Fact]
+    public async Task Serialized_extraction_is_identical_across_runs()
+    {
+        Assert.Equal(ComponentsFile.Serialize(await ExtractAsync()), ComponentsFile.Serialize(await ExtractAsync()));
+    }
+
+    [Fact]
+    public async Task A_repo_that_does_not_compile_is_extracted_with_a_warning_per_broken_project()
+    {
+        using var broken = await WorkspaceLoader.LoadAsync(FixturePaths.BrokenApp);
+
+        var config = ExtractConfig.Empty with { Components = ["Broken.Application.Broken"] };
+        var result = await CouplingResolver.ExtractAsync(broken, config, TestContext.Current.CancellationToken);
+
+        Assert.Equal(["project Broken.Application has 1 compile error(s); coupling may be incomplete"], result.Warnings);
+        Assert.Equal(["Broken.Application.Broken"], result.Components.Select(c => c.Type));
+    }
+}

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

@@ -0,0 +1,17 @@
+namespace LogicalComponents.Tests;
+
+public class DisplayNameTests
+{
+    [Theory]
+    [InlineData("ExportJobAcceptance", "Export Job Acceptance")]
+    [InlineData("OgcServer", "Ogc Server")]
+    [InlineData("IOStream", "IO Stream")]
+    [InlineData("GeoServer", "Geo Server")]
+    [InlineData("Utf8Decoding", "Utf8 Decoding")]
+    [InlineData("HTTPClientFactory", "HTTP Client Factory")]
+    [InlineData("Run", "Run")]
+    public void Pascal_case_splits_into_words_keeping_acronyms_together(string typeName, string expected)
+    {
+        Assert.Equal(expected, DisplayName.FromTypeName(typeName));
+    }
+}