@phuc1403/musketeer 0.10.0 → 0.11.0

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

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

@@ -0,0 +1,72 @@
+namespace LogicalComponents.Tests;
+
+public class ExtractConfigTests
+{
+    private static ExtractConfig LoadWith(string json)
+    {
+        var repo = Directory.CreateTempSubdirectory("lc-config-");
+        try
+        {
+            File.WriteAllText(Path.Combine(repo.FullName, ExtractConfig.FileName), json);
+            return ExtractConfig.Load(repo.FullName);
+        }
+        finally
+        {
+            repo.Delete(recursive: true);
+        }
+    }
+
+    [Fact]
+    public void A_repo_without_a_config_file_gets_the_empty_config()
+    {
+        var repo = Directory.CreateTempSubdirectory("lc-no-config-");
+        try
+        {
+            Assert.Equal(ExtractConfig.Empty, ExtractConfig.Load(repo.FullName));
+        }
+        finally
+        {
+            repo.Delete(recursive: true);
+        }
+    }
+
+    [Fact]
+    public void The_config_file_lists_components_and_helpers_with_their_reasons()
+    {
+        var config = LoadWith("""
+            {
+              "components": ["Some.App.OrderAcceptance"],
+              "helpers": { "Some.App.OrderNumber": "Value object." }
+            }
+            """);
+
+        Assert.Equal(["Some.App.OrderAcceptance"], config.Components);
+        Assert.Equal(new Dictionary<string, string> { ["Some.App.OrderNumber"] = "Value object." }, config.Helpers);
+    }
+
+    [Fact]
+    public void The_old_exclude_and_include_keys_fail_and_point_to_the_new_ones()
+    {
+        var error = Assert.Throws<ExtractConfigException>(() => LoadWith("""{ "exclude": ["HebrewAlphabet"] }"""));
+
+        Assert.Contains("'exclude'/'include' were replaced by 'components' and 'helpers'", error.Message);
+    }
+
+    [Fact]
+    public void A_type_in_both_lists_fails()
+    {
+        var error = Assert.Throws<ExtractConfigException>(() => LoadWith("""
+            { "components": ["Some.App.Clock"], "helpers": { "Some.App.Clock": "?" } }
+            """));
+
+        Assert.Contains("'Some.App.Clock' is in both components and helpers", error.Message);
+    }
+
+    [Fact]
+    public void A_malformed_config_file_fails_naming_the_file()
+    {
+        var error = Assert.Throws<ExtractConfigException>(() => LoadWith("{ not json"));
+
+        Assert.Contains(ExtractConfig.FileName, error.Message);
+    }
+}

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

@@ -0,0 +1,32 @@
+namespace LogicalComponents.Tests;
+
+/// <summary>
+/// Locates the fixture solutions under scripts/fixtures by walking up from the test binaries,
+/// so the tests run the same from an IDE, `dotnet test`, or any working directory.
+/// </summary>
+internal static class FixturePaths
+{
+    public static string Root { get; } = FindFixturesRoot();
+
+    public static string SampleApp => Path.Combine(Root, "SampleApp");
+
+    public static string NoSolutionApp => Path.Combine(Root, "NoSolutionApp");
+
+    public static string MultiTargetApp => Path.Combine(Root, "MultiTargetApp");
+
+    public static string BrokenApp => Path.Combine(Root, "BrokenApp");
+
+    private static string FindFixturesRoot()
+    {
+        for (var dir = new DirectoryInfo(AppContext.BaseDirectory); dir is not null; dir = dir.Parent)
+        {
+            var candidate = Path.Combine(dir.FullName, "fixtures");
+            if (Directory.Exists(Path.Combine(candidate, "SampleApp")))
+            {
+                return candidate;
+            }
+        }
+
+        throw new DirectoryNotFoundException($"No fixtures/SampleApp found above {AppContext.BaseDirectory}");
+    }
+}

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

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <OutputType>Exe</OutputType>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="xunit.v3" Version="4.0.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Xunit" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="../LogicalComponents/LogicalComponents.csproj" />
+  </ItemGroup>
+
+</Project>

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

@@ -0,0 +1,50 @@
+namespace LogicalComponents.Tests;
+
+public class MarkdownRendererTests
+{
+    [Fact]
+    public void Renders_canonical_citations()
+    {
+        var responsibilities = RenderTestData.ValidResponsibilities();
+        responsibilities["OrderQueue"] = [new Responsibility("Stores each queued order.", "src/Infra/OrderQueue.cs:0010-010")];
+
+        var markdown = MarkdownRenderer.Render(RenderTestData.Extraction, responsibilities);
+
+        Assert.Contains("- Stores each queued order. (`src/Infra/OrderQueue.cs:10`)\n", markdown);
+    }
+
+    [Fact]
+    public void Diagram_ids_are_prefixed_and_sanitized_so_mermaid_keywords_and_odd_characters_cannot_break_it()
+    {
+        var extraction = RenderTestData.Extraction with
+        {
+            Components =
+            [
+                RenderTestData.Extraction.Components[0] with { Id = "end", Name = "Say \"Hi\"" },
+                RenderTestData.Extraction.Components[2] with { Id = "My Module_Queue" },
+            ],
+            ExternalNodes = [],
+            Edges = [new Edge("end", "My Module_Queue", ["di"], [], "src/App/OrderAcceptance.cs:4")],
+        };
+        var responsibilities = RenderTestData.ValidResponsibilities();
+        responsibilities["end"] = responsibilities["OrderAcceptance"];
+        responsibilities["My Module_Queue"] = responsibilities["OrderQueue"];
+
+        var markdown = MarkdownRenderer.Render(extraction, responsibilities);
+
+        Assert.Contains("    n_end[\"Say #quot;Hi#quot;\"]\n", markdown);
+        Assert.Contains("    n_My_Module_Queue[\"Order Queue\"]\n", markdown);
+        Assert.Contains("    n_end --> n_My_Module_Queue\n", markdown);
+    }
+
+    [Fact]
+    public void Diagram_arrow_points_from_the_dependent_component_to_the_one_it_depends_on_without_labels()
+    {
+        var markdown = MarkdownRenderer.Render(RenderTestData.Extraction, RenderTestData.ValidResponsibilities());
+
+        Assert.Contains("    n_OrderAcceptance --> n_OrderQueue\n", markdown);
+        Assert.Contains("    n_ReceiptPrinting --> n_OrderAcceptance\n", markdown);
+        Assert.DoesNotContain("-->|", markdown);
+        Assert.DoesNotContain("classDef", markdown);
+    }
+}

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

@@ -0,0 +1,65 @@
+namespace LogicalComponents.Tests;
+
+public class ProjectFiltersTests
+{
+    private const string PlainLibrary = """<Project Sdk="Microsoft.NET.Sdk"></Project>""";
+
+    [Theory]
+    [InlineData("tests/Foo/Foo.csproj")]
+    [InlineData("test/Foo/Foo.csproj")]
+    [InlineData("src/Foo.Tests/Foo.Tests.csproj")]
+    [InlineData("src/Foo.UnitTests/Foo.UnitTests.csproj")]
+    [InlineData("src/Foo.IntegrationTests/Foo.IntegrationTests.csproj")]
+    [InlineData("src/Foo.Test/Foo.Test.csproj")]
+    [InlineData("src/Foo.Specs/Foo.Specs.csproj")]
+    public void Test_folders_and_test_project_names_are_test_projects(string relativePath)
+    {
+        Assert.True(ProjectFilters.IsTestProject(relativePath, PlainLibrary));
+    }
+
+    [Theory]
+    [InlineData("""<Project Sdk="MSTest.Sdk/3.8.0"></Project>""")]
+    [InlineData("""<Project><PropertyGroup><IsTestProject> true </IsTestProject></PropertyGroup></Project>""")]
+    [InlineData("""<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />""")]
+    [InlineData("""<PackageReference Include="xunit" Version="2.9.0" />""")]
+    [InlineData("""<PackageReference Include="xunit.v3" Version="3.0.0" />""")]
+    [InlineData("""<PackageReference Include="xunit.core" Version="2.9.0" />""")]
+    [InlineData("""<PackageReference Include="NUnit" Version="4.0.0" />""")]
+    [InlineData("""<PackageReference Include="MSTest.TestFramework" Version="3.0.0" />""")]
+    [InlineData("""<PackageReference Include="Microsoft.Testing.Platform" Version="1.0.0" />""")]
+    public void Test_framework_markers_in_the_project_file_make_a_test_project(string projectText)
+    {
+        Assert.True(ProjectFilters.IsTestProject("src/Foo/Foo.csproj", projectText));
+    }
+
+    [Theory]
+    [InlineData("src/Foo.Application/Foo.Application.csproj")]
+    [InlineData("src/Foo.Contest/Foo.Contest.csproj")]
+    [InlineData("src/Latest.Feeds/Latest.Feeds.csproj")]
+    [InlineData("src/Foo.Testing/Foo.Testing.csproj")]
+    public void Source_projects_are_not_test_projects(string relativePath)
+    {
+        Assert.False(ProjectFilters.IsTestProject(relativePath, PlainLibrary));
+    }
+
+    [Theory]
+    [InlineData("Multi.Application(net10.0)", "Multi.Application(net8.0)")]
+    [InlineData("A(net8.0)", "A(netstandard2.1)")]
+    [InlineData("A(netstandard2.1)", "A(netstandard2.0)")]
+    [InlineData("A(netcoreapp3.1)", "A(netstandard2.1)")]
+    [InlineData("A(net10.0)", "A(net9.0-windows)")]
+    [InlineData("A(net472)", "A(net45)")]
+    [InlineData("A(netstandard2.0)", "A(net48)")]
+    public void Higher_target_framework_ranks_above_lower(string higher, string lower)
+    {
+        Assert.True(ProjectFilters.TargetFrameworkRank(higher).CompareTo(ProjectFilters.TargetFrameworkRank(lower)) > 0);
+    }
+
+    [Theory]
+    [InlineData("Multi.Application(net10.0)", "Multi.Application")]
+    [InlineData("Plain.Project", "Plain.Project")]
+    public void Target_framework_suffix_is_stripped_from_project_names(string loadedName, string expected)
+    {
+        Assert.Equal(expected, ProjectFilters.StripTargetFramework(loadedName));
+    }
+}