@phuc1403/musketeer 0.11.0 → 0.12.0

package/template/.claude/skills/logical-components/scripts/fixtures/CouplingApp/src/CouplingApp.Application/AbstractMemberCases.cs

@@ -0,0 +1,27 @@
+namespace CouplingApp.Application;
+
+public abstract class PartlyImplemented
+{
+    // Not virtual: this body runs for every subclass (or none), so it is coupling even with no subclass in the repo.
+    public void Ready() => ReadyTarget.Touch();
+
+    // Virtual with zero implementations in the repo: nothing to walk, but the tool should say so instead of staying
+    // silent.
+    public abstract void Missing();
+}
+
+public sealed class ReadyTarget
+{
+    public static void Touch()
+    {
+    }
+}
+
+public sealed class PartlyImplementedUsing
+{
+    public void Run(PartlyImplemented value)
+    {
+        value.Ready();
+        value.Missing();
+    }
+}

package/template/.claude/skills/logical-components/scripts/fixtures/CouplingApp/src/CouplingApp.Application/AttributeCases.cs

@@ -0,0 +1,23 @@
+namespace CouplingApp.Application;
+
+// An attribute's constructor must not be treated as coupling: applying an attribute is metadata the compiler reads,
+// not code the annotated member runs.
+public sealed class AuditedAttribute : Attribute
+{
+    public AuditedAttribute() => AttributeTarget.Touch();
+}
+
+public sealed class AttributeTarget
+{
+    public static void Touch()
+    {
+    }
+}
+
+[Audited]
+public sealed class AttributedRunning
+{
+    public void Run()
+    {
+    }
+}

package/template/.claude/skills/logical-components/scripts/fixtures/CouplingApp/src/CouplingApp.Application/CouplingApp.Application.csproj

@@ -0,0 +1,7 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+</Project>

package/template/.claude/skills/logical-components/scripts/fixtures/CouplingApp/src/CouplingApp.Application/GenericBaseCases.cs

@@ -0,0 +1,14 @@
+namespace CouplingApp.Application;
+
+// A generic abstract base: its own type parameter must bind to what each concrete subclass supplies (however many
+// levels up the walk gathers this base's own code as the subclass's behaviour), or a seam it calls looks unbound and
+// matches every construction. Uses IHandler<T>/PingHandling/PongHandling from GenericSeamBindingCases.cs.
+public abstract class HandlerBase<T>(IHandler<T> inner)
+{
+    protected void Run(T command) => inner.Handle(command);
+}
+
+public sealed class PingRunning(IHandler<Ping> handler) : HandlerBase<Ping>(handler)
+{
+    public void Execute(Ping ping) => Run(ping);
+}

package/template/.claude/skills/logical-components/scripts/fixtures/CouplingApp/src/CouplingApp.Application/GenericSeamBindingCases.cs

@@ -0,0 +1,59 @@
+namespace CouplingApp.Application;
+
+public sealed record Ping(int Value);
+
+public sealed record Pong(int Value);
+
+public interface IHandler<T>
+{
+    void Handle(T command);
+}
+
+public sealed class PingHandling : IHandler<Ping>
+{
+    public void Handle(Ping command)
+    {
+    }
+}
+
+public sealed class PongHandling : IHandler<Pong>
+{
+    public void Handle(Pong command)
+    {
+    }
+}
+
+// A generic method declared on a seam: walking the implementation must bind the method's own type parameter to what
+// this use supplied, or the seam it calls in turn looks unbound and matches every construction.
+public interface IDispatch
+{
+    void Send<T>(T command);
+}
+
+public sealed class Dispatch(IEnumerable<object> handlers) : IDispatch
+{
+    public void Send<T>(T command)
+    {
+        foreach (var handler in handlers.OfType<IHandler<T>>())
+        {
+            handler.Handle(command);
+        }
+    }
+}
+
+public sealed class GenericMethodDispatching(IDispatch dispatch)
+{
+    public void Run() => dispatch.Send(new Ping(1));
+}
+
+// An open-generic decorator wrapping the same generic seam it implements: T must stay bound to the seam's own
+// construction at the use, or the decorator's own call looks unbound and matches every construction it wraps.
+public sealed class Decorator<T>(IHandler<T> inner) : IHandler<T>
+{
+    public void Handle(T command) => inner.Handle(command);
+}
+
+public sealed class DecoratedDispatching(IHandler<Ping> handler)
+{
+    public void Run(Ping ping) => handler.Handle(ping);
+}

package/template/.claude/skills/logical-components/scripts/fixtures/CouplingApp/src/CouplingApp.Application/ImplicitCallCases.cs

@@ -0,0 +1,230 @@
+using System.Collections;
+using System.Runtime.CompilerServices;
+
+namespace CouplingApp.Application;
+
+// A collection initializer's elements run the type's Add method.
+public sealed class Bag : IEnumerable<int>
+{
+    private readonly List<int> _items = [];
+
+    public void Add(int item)
+    {
+        AddTarget.Touch();
+        _items.Add(item);
+    }
+
+    public IEnumerator<int> GetEnumerator() => _items.GetEnumerator();
+
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+}
+
+public sealed class AddTarget
+{
+    public static void Touch()
+    {
+    }
+}
+
+public sealed class CollectionInitializerRunning
+{
+    public Bag Make() => new() { 1, 2 };
+}
+
+// A deconstruction, by assignment or by a foreach variable, runs the target's Deconstruct method.
+public sealed class Point(int x, int y)
+{
+    public void Deconstruct(out int deconstructedX, out int deconstructedY)
+    {
+        DeconstructTarget.Touch();
+        deconstructedX = x;
+        deconstructedY = y;
+    }
+}
+
+public sealed class DeconstructTarget
+{
+    public static void Touch()
+    {
+    }
+}
+
+public sealed class DeconstructAssigning
+{
+    public void Run()
+    {
+        int x, y;
+        (x, y) = new Point(1, 2);
+    }
+}
+
+public sealed class PointSequence
+{
+    public IEnumerator<Point> GetEnumerator() => new List<Point> { new(1, 2) }.GetEnumerator();
+}
+
+public sealed class ForeachDeconstructing
+{
+    public int Sum()
+    {
+        var sum = 0;
+        foreach (var (a, b) in new PointSequence())
+        {
+            sum += a + b;
+        }
+
+        return sum;
+    }
+}
+
+// A static constructor runs once, lazily, before the type's first static member use or instantiation.
+public sealed class StaticSeed
+{
+    public static readonly int Value;
+
+    static StaticSeed() => StaticCtorTarget.Touch();
+}
+
+public sealed class StaticCtorTarget
+{
+    public static void Touch()
+    {
+    }
+}
+
+public sealed class StaticSeedReading
+{
+    public int Read() => StaticSeed.Value;
+}
+
+// await runs GetAwaiter, IsCompleted's getter and GetResult on a custom (non-framework) awaitable.
+public sealed class CustomAwaiter(int value) : INotifyCompletion
+{
+    public bool IsCompleted
+    {
+        get
+        {
+            IsCompletedTarget.Touch();
+            return true;
+        }
+    }
+
+    public int GetResult()
+    {
+        GetResultTarget.Touch();
+        return value;
+    }
+
+    public void OnCompleted(Action continuation) => continuation();
+}
+
+public sealed class CustomAwaitable(int value)
+{
+    public CustomAwaiter GetAwaiter()
+    {
+        GetAwaiterTarget.Touch();
+        return new CustomAwaiter(value);
+    }
+}
+
+public sealed class GetAwaiterTarget
+{
+    public static void Touch()
+    {
+    }
+}
+
+public sealed class IsCompletedTarget
+{
+    public static void Touch()
+    {
+    }
+}
+
+public sealed class GetResultTarget
+{
+    public static void Touch()
+    {
+    }
+}
+
+public sealed class Awaiting
+{
+    public async Task<int> RunAsync() => await new CustomAwaitable(1);
+}
+
+// A foreach over a hand-written (non-iterator) enumerator runs its own MoveNext and Current, not just GetEnumerator.
+public sealed class NumberEnumerator
+{
+    private int _current;
+
+    public int Current
+    {
+        get
+        {
+            CurrentTarget.Touch();
+            return _current;
+        }
+    }
+
+    public bool MoveNext()
+    {
+        MoveNextTarget.Touch();
+        if (_current >= 2)
+        {
+            return false;
+        }
+
+        _current++;
+        return true;
+    }
+}
+
+public sealed class NumberSequence
+{
+    public NumberEnumerator GetEnumerator() => new();
+}
+
+public sealed class CurrentTarget
+{
+    public static void Touch()
+    {
+    }
+}
+
+public sealed class MoveNextTarget
+{
+    public static void Touch()
+    {
+    }
+}
+
+public sealed class CustomForEaching
+{
+    public int Sum()
+    {
+        var sum = 0;
+        foreach (var n in new NumberSequence())
+        {
+            sum += n;
+        }
+
+        return sum;
+    }
+}
+
+// A conditional-access indexer (x?[i]) runs the indexer's getter same as x[i] does.
+public sealed class Grid
+{
+    public int this[int index] => IndexerTarget.Touch();
+}
+
+public sealed class IndexerTarget
+{
+    public static int Touch() => 1;
+}
+
+public sealed class ConditionalIndexing
+{
+    public int? Read(Grid? grid) => grid?[0];
+}

package/template/.claude/skills/logical-components/scripts/fixtures/CouplingApp/src/CouplingApp.Application/PartialInheritCases.First.cs

@@ -0,0 +1,11 @@
+namespace CouplingApp.Application;
+
+// This partial fragment has a base list too, but it names only an interface, never PartialBase: the inherits
+// citation must not land here just because it is the first declaration with any base list at all.
+public interface IMarker
+{
+}
+
+public sealed partial class PartialInheriting : IMarker
+{
+}

package/template/.claude/skills/logical-components/scripts/fixtures/CouplingApp/src/CouplingApp.Application/PartialInheritCases.Second.cs

@@ -0,0 +1,14 @@
+namespace CouplingApp.Application;
+
+public class PartialBase
+{
+    public void Ping()
+    {
+    }
+}
+
+// The inherits edge must cite this base list, the one that actually names PartialBase.
+public sealed partial class PartialInheriting : PartialBase
+{
+    public void Act() => Ping();
+}

package/template/.claude/skills/logical-components/scripts/fixtures/CouplingApp/src/CouplingApp.Application/StackOverflowCases.cs

@@ -0,0 +1,14 @@
+namespace CouplingApp.Application;
+
+// A generic helper that instantiates itself one level deeper at every recursive call (Nest<T> calling Nest<List<T>>):
+// the (member, bindings) pair walked never repeats, so the cycle guard alone can't stop it. Without a depth bound the
+// walk would recurse until the process stack overflows.
+public static class Nest<T>
+{
+    public static int Go(int n) => n <= 0 ? 0 : Nest<List<T>>.Go(n - 1);
+}
+
+public sealed class NestRunning
+{
+    public int Run() => Nest<int>.Go(3);
+}

package/template/.claude/skills/logical-components/scripts/fixtures/CouplingApp/src/CouplingApp.Application/ViaDisambiguationCases.cs

@@ -0,0 +1,36 @@
+namespace CouplingApp.Application.Left
+{
+    // Two unrelated types named Builder, in different namespaces, on the same coupling path: via must tell them apart
+    // instead of both showing as the bare, indistinguishable "Builder".
+    public sealed class Builder
+    {
+        public string Make() => new CouplingApp.Application.Right.Builder().Build();
+    }
+}
+
+namespace CouplingApp.Application.Right
+{
+    public sealed class Builder
+    {
+        public string Build()
+        {
+            CouplingApp.Application.ViaTarget.Touch();
+            return "built";
+        }
+    }
+}
+
+namespace CouplingApp.Application
+{
+    public sealed class ViaTarget
+    {
+        public static void Touch()
+        {
+        }
+    }
+
+    public sealed class ViaDisambiguating
+    {
+        public string Run() => new Left.Builder().Make();
+    }
+}

package/template/.claude/skills/logical-components/scripts/fixtures/MultiTargetApp/MultiTargetApp.slnx

@@ -1,6 +1,7 @@
 <Solution>
   <Folder Name="/src/">
     <Project Path="src/Multi.Application/Multi.Application.csproj" />
+    <Project Path="src/Multi.Infrastructure/Multi.Infrastructure.csproj" />
     <Project Path="src/Legacy.FSharp/Legacy.FSharp.fsproj" />
   </Folder>
 </Solution>

package/template/.claude/skills/logical-components/scripts/fixtures/MultiTargetApp/src/Multi.Infrastructure/Multi.Infrastructure.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+  <ItemGroup>
+    <!-- Single-targeted, so MSBuild resolves this reference to the net8.0 copy of Multi.Application, not the
+         net10.0 copy the loader keeps: proves a reference to a dropped TFM copy survives KeepSourceProjects. -->
+    <ProjectReference Include="../Multi.Application/Multi.Application.csproj" />
+  </ItemGroup>
+</Project>

package/template/.claude/skills/logical-components/scripts/fixtures/MultiTargetApp/src/Multi.Infrastructure/SchedulingClient.cs

@@ -0,0 +1,12 @@
+using Multi.Application;
+
+namespace Multi.Infrastructure;
+
+/// <summary>
+/// Targets only net8.0 and ctor-injects a type from the multi-targeted Multi.Application, whose net8.0 copy the loader
+/// drops: its reference must follow the kept copy.
+/// </summary>
+public sealed class SchedulingClient(Scheduling scheduling)
+{
+    public DateOnly Tomorrow(DateOnly from) => scheduling.Next(from);
+}

package/template/.claude/skills/logical-components/scripts/fixtures/ObjOutputApp/ObjOutputApp.slnx

@@ -0,0 +1,5 @@
+<Solution>
+  <Folder Name="/src/">
+    <Project Path="src/Obj.Application/Obj.Application.csproj" />
+  </Folder>
+</Solution>

package/template/.claude/skills/logical-components/scripts/fixtures/ObjOutputApp/src/Obj.Application/Greeting.cs

@@ -0,0 +1,7 @@
+namespace Obj.Application;
+
+/// <summary>A normal, real-source candidate: contrast for GrpcStub (written under obj/ at test time).</summary>
+public sealed class Greeting
+{
+    public string For(string name) => $"Hello, {name}!";
+}

package/template/.claude/skills/logical-components/scripts/fixtures/ObjOutputApp/src/Obj.Application/Obj.Application.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+  <ItemGroup>
+    <!-- Simulates gRPC/NSwag output written into obj/ by a build-time code generator: an explicit Compile item
+         (not the SDK's default glob, which excludes obj/) pointing at a real file, not a Roslyn source generator's
+         virtual document. obj/ is gitignored in scripts/, so this file is not checked in; the test that loads this
+         fixture writes it before calling WorkspaceLoader.LoadAsync. -->
+    <Compile Include="obj/Generated/GrpcStub.cs" />
+  </ItemGroup>
+</Project>

package/template/.claude/skills/logical-components/scripts/fixtures/RenderGolden/components.json

@@ -59,5 +59,9 @@
       "at": "src/App/OrderAcceptance.cs:3"
     }
   ],
-  "warnings": []
+  "warnings": [],
+  "fileHashes": {
+    "src/App/OrderAcceptance.cs": "28a98da24919780874e1d25e8c2c9ef6b496cf3dfd6dc171e79dda6bfc9f062a",
+    "src/Infra/OrderQueue.cs": "5d0de05d2b60730ec4accce7cc93da9c025fb7961549a1ca154400a6de5d12b7"
+  }
 }