@phuc1403/musketeer 0.9.0 → 0.11.0

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

@@ -0,0 +1,78 @@
+{
+  "components": [
+    "Sample.Application.Archiving",
+    "Sample.Application.BatchRunning",
+    "Sample.Application.Builder",
+    "Sample.Application.Cache",
+    "Sample.Application.Cache`1",
+    "Sample.Application.CallbackNormalizing",
+    "Sample.Application.CrashSettling",
+    "Sample.Application.Echoing",
+    "Sample.Application.FallbackPricing",
+    "Sample.Application.JobCounting",
+    "Sample.Application.JobReporting",
+    "Sample.Application.JobShowing",
+    "Sample.Application.LabelMaking",
+    "Sample.Application.Labelling",
+    "Sample.Application.LazyWork",
+    "Sample.Application.Limits",
+    "Sample.Application.LineCounting",
+    "Sample.Application.LoudNotifying",
+    "Sample.Application.Measuring",
+    "Sample.Application.NotifyAll",
+    "Sample.Application.Notifying",
+    "Sample.Application.OrderAcceptance",
+    "Sample.Application.OrderHandling",
+    "Sample.Application.OrderNumberFormat",
+    "Sample.Application.OrderRunning",
+    "Sample.Application.OrderTextExtensions",
+    "Sample.Application.OrderValidation",
+    "Sample.Application.PingSending",
+    "Sample.Application.PongViaSeam",
+    "Sample.Application.PriceFormatting",
+    "Sample.Application.PriceRules",
+    "Sample.Application.ReceiptIssuing",
+    "Sample.Application.ReceiptPrinting",
+    "Sample.Application.Receipts",
+    "Sample.Application.RecoveryRouting",
+    "Sample.Application.RegistryReading",
+    "Sample.Application.RunClock",
+    "Sample.Application.ShapeListing",
+    "Sample.Application.ShippingStage",
+    "Sample.Application.Stamping",
+    "Sample.Application.TickCounter",
+    "Sample.Application.TickReading",
+    "Sample.Application.TitleReading",
+    "Sample.Application.TrackedReading",
+    "Sample.Application.TrackedWriting",
+    "Sample.Application.UrgentNotifying",
+    "Sample.Billing.Application.OrderRunning",
+    "Sample.Infrastructure.DefaultPricing",
+    "Sample.Infrastructure.DiskStorage",
+    "Sample.Infrastructure.DwgDrawing",
+    "Sample.Infrastructure.ExportRecovery",
+    "Sample.Infrastructure.ForwardedNotifier",
+    "Sample.Infrastructure.ImportRecovery",
+    "Sample.Infrastructure.LoggingHandler`1",
+    "Sample.Infrastructure.Mailer",
+    "Sample.Infrastructure.OrderQueue",
+    "Sample.Infrastructure.OrderRequestHandler",
+    "Sample.Infrastructure.PingHandling",
+    "Sample.Infrastructure.PongHandling",
+    "Sample.Infrastructure.QueueStore",
+    "Sample.Infrastructure.TextHandler",
+    "Sample.Infrastructure.UnreachedPlumbing"
+  ],
+  "helpers": {
+    "Sample.Application.Dispatch": "Generic dispatch to handlers; no decision.",
+    "Sample.Application.LabelFormat": "Formats a label with the elapsed time; no decision.",
+    "Sample.Application.OrderNumber": "Value object: validates its own value.",
+    "Sample.Application.PaymentMethod": "Value object: one accepted-code check.",
+    "Sample.Application.PingText": "Text formatting.",
+    "Sample.Application.PongText": "Text formatting.",
+    "Sample.Application.Quantity": "Value object: arithmetic on its own value.",
+    "Sample.Application.StampedText": "Appends a fixed stamp to text.",
+    "Sample.Application.Ticks": "Enumerates ticks.",
+    "Sample.Application.TwoWay": "Handler pair used as a helper."
+  }
+}

package/template/.claude/skills/logical-components/scripts/fixtures/SampleApp/src/Sample.Application/CandidateCases.cs

@@ -0,0 +1,37 @@
+namespace Sample.Application;
+
+// A value object that validates itself: a record with a method of its own, so a candidate (the config calls it a helper).
+public sealed record OrderNumber(string Value)
+{
+    public static OrderNumber Create(string raw) =>
+        raw.Length > 0 ? new OrderNumber(raw) : throw new ArgumentException("empty order number", nameof(raw));
+}
+
+// An abstract record holding a decision: a candidate, even though abstract records are never seams.
+public abstract record PaymentMethod
+{
+    public static bool IsAccepted(string code) => code == "card";
+}
+
+// A record struct with behaviour: a candidate.
+public readonly record struct Quantity(int Value)
+{
+    public Quantity Add(int more) => new(Value + more);
+}
+
+// Only overrides object.ToString: formatting what it holds is not behaviour, so not a candidate.
+public sealed record Money(decimal Amount)
+{
+    public override string ToString() => $"{Amount:0.00}";
+}
+
+// Properties and a constructor only: not a candidate.
+public sealed class OrderSnapshot
+{
+    public OrderSnapshot(int id)
+    {
+        Id = id;
+    }
+
+    public int Id { get; }
+}

package/template/.claude/skills/logical-components/scripts/fixtures/SampleApp/src/Sample.Application/CouplingCases.cs

@@ -0,0 +1,33 @@
+namespace Sample.Application;
+
+// Injects RunClock and also news one: a single edge with both kinds. Calls a C# 14 extension member: a static edge.
+// Also takes a framework interface (IReadOnlyList<string>): not a port, never an edge.
+public sealed class BatchRunning(RunClock clock, IReadOnlyList<string> labels)
+{
+    public int LabelCount() => labels.Count;
+
+    public TimeSpan Run()
+    {
+        using var fresh = new RunClock();
+        return clock.Elapsed() + fresh.Elapsed();
+    }
+
+    public string Cost(decimal price) => price.AsMoney();
+}
+
+// A multi-registration: IEnumerable<INotifier> resolves to every INotifier implementation. Calls a classic extension method.
+public sealed class NotifyAll(IEnumerable<INotifier> notifiers)
+{
+    public void Send(string message)
+    {
+        foreach (var notifier in notifiers)
+        {
+            notifier.Notify(message.Shout());
+        }
+    }
+}
+
+public static class OrderTextExtensions
+{
+    public static string Shout(this string text) => text.ToUpperInvariant();
+}

package/template/.claude/skills/logical-components/scripts/fixtures/SampleApp/src/Sample.Application/DependencyInjection.cs

@@ -0,0 +1,18 @@
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Sample.Application;
+
+// Composition root: it `new`s everything, so it must never become a component or an edge source.
+public static class DependencyInjection
+{
+    public static IServiceCollection AddSampleApplication(this IServiceCollection services)
+    {
+        services.AddSingleton(new OrderValidation());
+        services.AddSingleton(sp => new OrderAcceptance(
+            sp.GetRequiredService<IOrderQueue>(),
+            sp.GetRequiredService<OrderValidation>(),
+            sp.GetRequiredService<INotifier>()));
+        services.AddSingleton(sp => new OrderRunning(sp.GetRequiredService<IAuditTrail>()));
+        return services;
+    }
+}

package/template/.claude/skills/logical-components/scripts/fixtures/SampleApp/src/Sample.Application/EdgeCases.cs

@@ -0,0 +1,63 @@
+using System.Text.RegularExpressions;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Sample.Application;
+
+// File-local: its metadata name embeds a hash of the absolute path, so it must never become a component.
+file static class FileHelper
+{
+    public static int Twice(int value) => value * 2;
+}
+
+// Partial with a source-generated half: only this file may appear in its spans.
+public sealed partial class OrderNumberFormat
+{
+    [GeneratedRegex("^[0-9]+$")]
+    private static partial Regex Digits();
+
+    public bool IsValid(string orderNumber) => Digits().IsMatch(orderNumber);
+}
+
+// C# 14 extension block: its methods are behaviour, so this is a component.
+public static class PriceFormatting
+{
+    extension(decimal price)
+    {
+        public string AsMoney() => price.ToString("0.00");
+    }
+}
+
+// Composition root written as an extension block, with an ordinary helper beside it: still not a component.
+public static class BillingSetup
+{
+    extension(IServiceCollection services)
+    {
+        public IServiceCollection AddBilling() => services;
+    }
+
+    public static int DefaultCurrencyDigits() => 2;
+}
+
+// Only explicit interface implementations: still behaviour, so a component.
+public interface ITick
+{
+    void Tick();
+}
+
+public sealed class TickCounter : ITick
+{
+    void ITick.Tick()
+    {
+    }
+}
+
+// Same simple name, same module: the module prefix alone cannot tell these apart.
+public sealed class Cache
+{
+    public int Size() => 0;
+}
+
+public sealed class Cache<T>
+{
+    public T? Get() => default;
+}

package/template/.claude/skills/logical-components/scripts/fixtures/SampleApp/src/Sample.Application/LoudNotifying.Base.cs

@@ -0,0 +1,5 @@
+namespace Sample.Application;
+
+public sealed partial class LoudNotifying : Notifying
+{
+}

package/template/.claude/skills/logical-components/scripts/fixtures/SampleApp/src/Sample.Application/LoudNotifying.cs

@@ -0,0 +1,7 @@
+namespace Sample.Application;
+
+// A partial class whose base class is declared in its second part: the inherits edge cites that base list.
+public sealed partial class LoudNotifying
+{
+    public string Volume() => "loud";
+}

package/template/.claude/skills/logical-components/scripts/fixtures/SampleApp/src/Sample.Application/OrderAcceptance.cs

@@ -0,0 +1,17 @@
+namespace Sample.Application;
+
+// Primary constructor: DI of a port (IOrderQueue), a class (OrderValidation) and a forwarded port (INotifier).
+public sealed class OrderAcceptance(IOrderQueue queue, OrderValidation validation, INotifier notifier)
+{
+    public bool Accept(OrderRequest request)
+    {
+        if (!validation.IsValid(request))
+        {
+            notifier.Notify($"Rejected order {request.Id}");
+            return false;
+        }
+
+        queue.Enqueue(request);
+        return true;
+    }
+}

package/template/.claude/skills/logical-components/scripts/fixtures/SampleApp/src/Sample.Application/OrderOptions.cs

@@ -0,0 +1,9 @@
+namespace Sample.Application;
+
+// Options, not a component, even though it declares a method.
+public sealed class OrderOptions
+{
+    public int MaxQueued { get; set; } = 10;
+
+    public bool IsWithinLimit(int queued) => queued <= MaxQueued;
+}

package/template/.claude/skills/logical-components/scripts/fixtures/SampleApp/src/Sample.Application/OrderRejectedException.cs

@@ -0,0 +1,7 @@
+namespace Sample.Application;
+
+// An exception with a method of its own: still never a logical component.
+public sealed class OrderRejectedException(string reason) : Exception(reason)
+{
+    public static OrderRejectedException ForPrice(decimal price) => new($"Price {price} is not allowed");
+}

package/template/.claude/skills/logical-components/scripts/fixtures/SampleApp/src/Sample.Application/OrderRequest.cs

@@ -0,0 +1,4 @@
+namespace Sample.Application;
+
+// Data, not a component.
+public record OrderRequest(int Id, decimal Price);

package/template/.claude/skills/logical-components/scripts/fixtures/SampleApp/src/Sample.Application/OrderRunning.cs

@@ -0,0 +1,18 @@
+namespace Sample.Application;
+
+// Classic constructor: DI of a port with no implementation, plus a `new` edge inside a method body.
+public sealed class OrderRunning
+{
+    private readonly IAuditTrail _audit;
+
+    public OrderRunning(IAuditTrail audit)
+    {
+        _audit = audit;
+    }
+
+    public void Run()
+    {
+        using var clock = new RunClock();
+        _audit.Record($"Ran in {clock.Elapsed()}");
+    }
+}

package/template/.claude/skills/logical-components/scripts/fixtures/SampleApp/src/Sample.Application/OrderValidation.cs

@@ -0,0 +1,6 @@
+namespace Sample.Application;
+
+public sealed class OrderValidation
+{
+    public bool IsValid(OrderRequest request) => PriceRules.Check(request.Price);
+}

package/template/.claude/skills/logical-components/scripts/fixtures/SampleApp/src/Sample.Application/Ports.cs

@@ -0,0 +1,19 @@
+namespace Sample.Application;
+
+// Port implemented in Infrastructure: edges through it resolve to OrderQueue.
+public interface IOrderQueue
+{
+    void Enqueue(OrderRequest request);
+}
+
+// Port implemented in Infrastructure by a class registered through forwarding.
+public interface INotifier
+{
+    void Notify(string message);
+}
+
+// Port with no implementation anywhere: must surface as an unresolved port.
+public interface IAuditTrail
+{
+    void Record(string entry);
+}

package/template/.claude/skills/logical-components/scripts/fixtures/SampleApp/src/Sample.Application/PriceRules.cs

@@ -0,0 +1,7 @@
+namespace Sample.Application;
+
+// Static class with behaviour: a component, reached by a static call.
+public static class PriceRules
+{
+    public static bool Check(decimal price) => price > 0;
+}

package/template/.claude/skills/logical-components/scripts/fixtures/SampleApp/src/Sample.Application/ReceiptPrinting.Totals.cs

@@ -0,0 +1,6 @@
+namespace Sample.Application;
+
+public sealed partial class ReceiptPrinting
+{
+    public string Footer(decimal total) => $"Total {total}";
+}

package/template/.claude/skills/logical-components/scripts/fixtures/SampleApp/src/Sample.Application/ReceiptPrinting.cs

@@ -0,0 +1,7 @@
+namespace Sample.Application;
+
+// A partial class split across two files: both declarations are spans.
+public sealed partial class ReceiptPrinting
+{
+    public string Header(int orderId) => $"Receipt {orderId}";
+}

package/template/.claude/skills/logical-components/scripts/fixtures/SampleApp/src/Sample.Application/ReviewCases.cs

@@ -0,0 +1,107 @@
+namespace Sample.Application;
+
+// Generic port: IHandler<OrderRequest> resolves only to implementations of that construction, or open generic ones.
+public interface IHandler<T>
+{
+    void Handle(T item);
+}
+
+public sealed class OrderHandling(IHandler<OrderRequest> handler)
+{
+    public void Run(OrderRequest request) => handler.Handle(request);
+}
+
+// A nested type used from outside: the edge goes to its outer component, never to a top-level namesake.
+public sealed class Receipts
+{
+    public sealed class Builder
+    {
+        public string Build() => "receipt";
+    }
+
+    public string Prefix() => "R-";
+}
+
+public sealed class Builder
+{
+    public string Build() => "top-level";
+}
+
+public sealed class ReceiptIssuing
+{
+    public string Issue() => new Receipts.Builder().Build();
+}
+
+// A static member on an interface runs no implementation code: no edge to implementations.
+public interface IPricingDefaults
+{
+    static decimal Fallback() => 1m;
+}
+
+public sealed class FallbackPricing
+{
+    public decimal Price() => IPricingDefaults.Fallback();
+}
+
+// Consts are copied in at compile time: reading one is not coupling.
+public static class Limits
+{
+    public const int MaxLines = 100;
+
+    public static int Clamp(int lines) => Math.Min(lines, MaxLines);
+}
+
+public sealed class LineCounting
+{
+    public int Count(int lines) => lines > Limits.MaxLines ? Limits.MaxLines : lines;
+}
+
+// An abstract dependency resolves to its concrete subclasses, like an interface.
+public abstract class StorageBase
+{
+    public abstract void Save(string text);
+}
+
+public sealed class Archiving(StorageBase storage)
+{
+    public void Archive(string text) => storage.Save(text);
+}
+
+// A non-component abstract base: its own code counts toward the classes deriving from it.
+public abstract class StageBase
+{
+    protected string Stamp() => PriceRules.Check(1m) ? "ok" : "no";
+}
+
+public sealed class ShippingStage : StageBase
+{
+    public string Run() => Stamp();
+}
+
+// Inheriting from a component is an 'inherits' edge.
+public class Notifying
+{
+    public virtual string Channel() => "default";
+}
+
+public sealed class UrgentNotifying : Notifying
+{
+    public override string Channel() => "urgent";
+}
+
+// An abstract record is a data hierarchy, not a seam: holding a list of them is not coupling.
+public abstract record Shape;
+
+public sealed record Circle(double Radius) : Shape;
+
+public sealed class ShapeListing(IReadOnlyList<Shape> shapes)
+{
+    public int Count() => shapes.Count;
+}
+
+// Wrapped dependencies are dependencies on what they wrap.
+public sealed class LazyWork(
+    Lazy<OrderValidation> validation, Func<RunClock> clocks, INotifier[] notifiers, IReadOnlyList<IOrderQueue> queues)
+{
+    public int Count() => notifiers.Length + queues.Count + (validation.IsValueCreated ? 1 : 0) + (clocks() is null ? 0 : 1);
+}

package/template/.claude/skills/logical-components/scripts/fixtures/SampleApp/src/Sample.Application/ReviewFixCases.cs

@@ -0,0 +1,143 @@
+namespace Sample.Application;
+
+// A generic seam used inside a generic helper: only the construction the caller asks for is reached.
+public interface ICommandHandler<T>
+{
+    void Handle(T command);
+}
+
+public sealed record Ping(int N);
+
+public sealed record Pong(int N);
+
+public sealed class Dispatch(IEnumerable<object> handlers)
+{
+    public void Send<T>(T command)
+    {
+        foreach (var handler in handlers.OfType<ICommandHandler<T>>())
+        {
+            handler.Handle(command);
+        }
+    }
+}
+
+public sealed class PingSending(Dispatch dispatch)
+{
+    public void Send() => dispatch.Send(new Ping(1));
+}
+
+// A helper implementing two constructions of one seam: the member for the requested construction is the one that runs.
+public sealed class TwoWay(RunClock clock) : ICommandHandler<Ping>, ICommandHandler<Pong>
+{
+    public void Handle(Ping command)
+    {
+    }
+
+    public void Handle(Pong command)
+    {
+        clock.Elapsed();
+    }
+}
+
+public sealed class PongViaSeam(ICommandHandler<Pong> handler)
+{
+    public void Run(Pong pong) => handler.Handle(pong);
+}
+
+// Compiler-written record members (ToString, Equals) run nothing of the record's own code.
+public sealed class JobShowing
+{
+    public string Show(Job job) => job.ToString();
+
+    public bool Same(Job first, Job second) => first.Equals(second);
+}
+
+// Only the accessor that runs counts: reading a property never runs its setter.
+public sealed class Tracked
+{
+    private string _value = "";
+
+    public string Value
+    {
+        get => _value;
+        set => _value = CallbackNormalizing.Normalize(value);
+    }
+}
+
+public sealed class TrackedReading
+{
+    public string Read(Tracked tracked) => tracked.Value;
+}
+
+public sealed class TrackedWriting
+{
+    public void Write(Tracked tracked) => tracked.Value = "x";
+}
+
+// An indexer, a user-defined operator and a foreach enumerator are calls too.
+public sealed class Registry(RunClock clock)
+{
+    public TimeSpan this[int index] => clock.Elapsed();
+}
+
+public sealed class RegistryReading
+{
+    public TimeSpan Read(Registry registry) => registry[0];
+}
+
+public readonly struct Metres(int value)
+{
+    public int Value => value;
+
+    public static Metres operator +(Metres first, Metres second) =>
+        new(first.Value + second.Value + (PriceRules.Check(1m) ? 0 : 1));
+}
+
+public sealed class Measuring
+{
+    public Metres Sum(Metres first, Metres second) => first + second;
+}
+
+public sealed class Ticks
+{
+    public IEnumerator<int> GetEnumerator()
+    {
+        PriceRules.Check(1m);
+        yield return 1;
+    }
+}
+
+public sealed class TickReading
+{
+    public int Sum(Ticks ticks)
+    {
+        var sum = 0;
+        foreach (var tick in ticks)
+        {
+            sum += tick;
+        }
+
+        return sum;
+    }
+}
+
+// Constructing a helper runs its base class's initializers too.
+public class LabelBase
+{
+    protected readonly TimeSpan Started = new RunClock().Elapsed();
+}
+
+public sealed class ShortLabel : LabelBase
+{
+}
+
+public sealed class LabelMaking
+{
+    public object Make() => new ShortLabel();
+}
+
+// A partial method with no implementation has no body: not behaviour.
+public sealed partial class Hooks
+{
+    partial void OnStart();
+}

package/template/.claude/skills/logical-components/scripts/fixtures/SampleApp/src/Sample.Application/RunClock.cs

@@ -0,0 +1,12 @@
+namespace Sample.Application;
+
+public sealed class RunClock : IDisposable
+{
+    private readonly DateTime _started = DateTime.UtcNow;
+
+    public TimeSpan Elapsed() => DateTime.UtcNow - _started;
+
+    public void Dispose()
+    {
+    }
+}

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

@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="10.0.0" />
+  </ItemGroup>
+</Project>