moai-adk 0.34.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

moai_adk/templates/.claude/skills/moai-lang-csharp/SKILL.md

@@ -1,25 +1,33 @@
 ---
-name: moai-lang-csharp
-description: C# 12 / .NET 8 development specialist covering ASP.NET Core, Entity Framework, Blazor, and modern C# patterns. Use when developing .NET APIs, web applications, or enterprise solutions.
-version: 1.0.0
-category: language
+name: "moai-lang-csharp"
+description: "C# 12 / .NET 8 development specialist covering ASP.NET Core, Entity Framework, Blazor, and modern C# patterns. Use when developing .NET APIs, web applications, or enterprise solutions."
+version: 2.1.0
+category: "language"
+modularized: true
+user-invocable: false
 tags:
-  - csharp
-  - dotnet
-  - aspnetcore
-  - efcore
-  - blazor
-updated: 2025-12-07
-status: active
+  ["language", "csharp", "dotnet", "aspnet-core", "entity-framework", "blazor"]
+allowed-tools:
+  - Read
+  - Grep
+  - Glob
+  - mcp__context7__resolve-library-id
+  - mcp__context7__get-library-docs
+context7-libraries: ["/dotnet/aspnetcore", "/dotnet/efcore", "/dotnet/runtime"]
+updated: 2026-01-11
+status: "active"
 ---
 
-## Quick Reference (30 seconds)
+# C# 12 / .NET 8 Development Specialist
 
-C# 12 / .NET 8 Development Specialist - Modern C# with ASP.NET Core, Entity Framework Core, Blazor, and enterprise patterns.
+Modern C# development with ASP.NET Core, Entity Framework Core, Blazor, and enterprise patterns.
+
+## Quick Reference
 
 Auto-Triggers: `.cs`, `.csproj`, `.sln` files, C# projects, .NET solutions, ASP.NET Core applications
 
 Core Stack:
+
 - C# 12: Primary constructors, collection expressions, alias any type, default lambda parameters
 - .NET 8: Minimal APIs, Native AOT, improved performance, WebSockets
 - ASP.NET Core 8: Controllers, Endpoints, Middleware, Authentication
@@ -28,451 +36,89 @@ Core Stack:
 - Testing: xUnit, NUnit, FluentAssertions, Moq
 
 Quick Commands:
-```bash
-# Create .NET 8 Web API project
-dotnet new webapi -n MyApi --framework net8.0
 
-# Create Blazor Web App
-dotnet new blazor -n MyBlazor --interactivity Auto
+To create a new .NET 8 Web API project, run dotnet new webapi with -n flag for project name and --framework net8.0.
+
+To create a Blazor Web App, run dotnet new blazor with -n flag for project name and --interactivity Auto.
 
-# Add Entity Framework Core
-dotnet add package Microsoft.EntityFrameworkCore.SqlServer
-dotnet add package Microsoft.EntityFrameworkCore.Design
+To add Entity Framework Core, run dotnet add package Microsoft.EntityFrameworkCore.SqlServer followed by Microsoft.EntityFrameworkCore.Design.
 
-# Add FluentValidation and MediatR
-dotnet add package FluentValidation.AspNetCore
-dotnet add package MediatR
-```
+To add FluentValidation and MediatR, run dotnet add package FluentValidation.AspNetCore and dotnet add package MediatR.
 
 ---
 
-## Implementation Guide (5 minutes)
-
-### C# 12 Key Features
-
-Primary Constructors - Class-level constructor parameters:
-```csharp
-// Primary constructor with dependency injection
-public class UserService(IUserRepository repository, ILogger<UserService> logger)
-{
-    public async Task<User?> GetByIdAsync(Guid id)
-    {
-        logger.LogInformation("Fetching user {UserId}", id);
-        return await repository.FindByIdAsync(id);
-    }
-}
-
-// Record with primary constructor
-public record CreateUserCommand(string Name, string Email);
-```
-
-Collection Expressions - Unified collection syntax:
-```csharp
-// Array, List, Span with unified syntax
-int[] numbers = [1, 2, 3, 4, 5];
-List<string> names = ["Alice", "Bob", "Charlie"];
-Span<int> span = [10, 20, 30];
-
-// Spread operator
-int[] combined = [..numbers, 6, 7, 8];
-List<string> allNames = [..names, "David", "Eve"];
-```
-
-Alias Any Type - Type aliases for complex types:
-```csharp
-// Alias for tuple
-using Point = (int X, int Y);
-
-// Alias for complex generic
-using UserCache = System.Collections.Generic.Dictionary<Guid, User>;
-
-public class LocationService
-{
-    public Point GetLocation() => (10, 20);
-    private readonly UserCache _cache = [];
-}
-```
-
-Default Lambda Parameters:
-```csharp
-// Lambda with default parameter
-var greet = (string name, string greeting = "Hello") => $"{greeting}, {name}!";
-
-Console.WriteLine(greet("Alice"));           // "Hello, Alice!"
-Console.WriteLine(greet("Bob", "Hi"));       // "Hi, Bob!"
-```
-
-### ASP.NET Core 8 Patterns
-
-Minimal API with Endpoints:
-```csharp
-var builder = WebApplication.CreateBuilder(args);
-
-// Service registration
-builder.Services.AddDbContext<AppDbContext>(options =>
-    options.UseSqlServer(builder.Configuration.GetConnectionString("Default")));
-builder.Services.AddScoped<IUserService, UserService>();
-
-var app = builder.Build();
-
-// Endpoint routing with typed results
-app.MapGet("/api/users/{id:guid}", async (Guid id, IUserService service) =>
-{
-    var user = await service.GetByIdAsync(id);
-    return user is not null ? Results.Ok(user) : Results.NotFound();
-})
-.WithName("GetUser")
-.WithOpenApi()
-.Produces<User>(200)
-.Produces(404);
-
-app.MapPost("/api/users", async (CreateUserRequest request, IUserService service) =>
-{
-    var user = await service.CreateAsync(request);
-    return Results.Created($"/api/users/{user.Id}", user);
-})
-.WithValidation<CreateUserRequest>();
-
-app.Run();
-```
-
-Controller-Based API:
-```csharp
-[ApiController]
-[Route("api/[controller]")]
-public class UsersController(IUserService userService, ILogger<UsersController> logger)
-    : ControllerBase
-{
-    [HttpGet("{id:guid}")]
-    [ProducesResponseType<User>(StatusCodes.Status200OK)]
-    [ProducesResponseType(StatusCodes.Status404NotFound)]
-    public async Task<ActionResult<User>> GetById(Guid id)
-    {
-        var user = await userService.GetByIdAsync(id);
-        if (user is null)
-        {
-            logger.LogWarning("User {UserId} not found", id);
-            return NotFound();
-        }
-        return user;
-    }
-
-    [HttpPost]
-    [ProducesResponseType<User>(StatusCodes.Status201Created)]
-    [ProducesResponseType<ValidationProblemDetails>(StatusCodes.Status400BadRequest)]
-    public async Task<ActionResult<User>> Create([FromBody] CreateUserRequest request)
-    {
-        var user = await userService.CreateAsync(request);
-        return CreatedAtAction(nameof(GetById), new { id = user.Id }, user);
-    }
-}
-```
-
-### Entity Framework Core 8 Patterns
-
-DbContext Configuration:
-```csharp
-public class AppDbContext(DbContextOptions<AppDbContext> options) : DbContext(options)
-{
-    public DbSet<User> Users => Set<User>();
-    public DbSet<Post> Posts => Set<Post>();
-    public DbSet<Tag> Tags => Set<Tag>();
-
-    protected override void OnModelCreating(ModelBuilder modelBuilder)
-    {
-        modelBuilder.ApplyConfigurationsFromAssembly(typeof(AppDbContext).Assembly);
-    }
-}
-
-// Entity configuration
-public class UserConfiguration : IEntityTypeConfiguration<User>
-{
-    public void Configure(EntityTypeBuilder<User> builder)
-    {
-        builder.HasKey(u => u.Id);
-        builder.Property(u => u.Email).HasMaxLength(256).IsRequired();
-        builder.HasIndex(u => u.Email).IsUnique();
-        builder.HasMany(u => u.Posts).WithOne(p => p.Author).HasForeignKey(p => p.AuthorId);
-    }
-}
-```
-
-Repository Pattern with Specification:
-```csharp
-public interface IRepository<T> where T : class
-{
-    Task<T?> GetByIdAsync(Guid id, CancellationToken ct = default);
-    Task<IReadOnlyList<T>> ListAsync(CancellationToken ct = default);
-    Task<T> AddAsync(T entity, CancellationToken ct = default);
-    Task UpdateAsync(T entity, CancellationToken ct = default);
-    Task DeleteAsync(T entity, CancellationToken ct = default);
-}
-
-public class EfRepository<T>(AppDbContext context) : IRepository<T> where T : class
-{
-    private readonly DbSet<T> _dbSet = context.Set<T>();
-
-    public async Task<T?> GetByIdAsync(Guid id, CancellationToken ct = default)
-        => await _dbSet.FindAsync([id], ct);
-
-    public async Task<IReadOnlyList<T>> ListAsync(CancellationToken ct = default)
-        => await _dbSet.ToListAsync(ct);
-
-    public async Task<T> AddAsync(T entity, CancellationToken ct = default)
-    {
-        await _dbSet.AddAsync(entity, ct);
-        await context.SaveChangesAsync(ct);
-        return entity;
-    }
-
-    public async Task UpdateAsync(T entity, CancellationToken ct = default)
-    {
-        _dbSet.Update(entity);
-        await context.SaveChangesAsync(ct);
-    }
-
-    public async Task DeleteAsync(T entity, CancellationToken ct = default)
-    {
-        _dbSet.Remove(entity);
-        await context.SaveChangesAsync(ct);
-    }
-}
-```
-
-### FluentValidation Patterns
-
-Request Validation:
-```csharp
-public record CreateUserRequest(string Name, string Email, string Password);
-
-public class CreateUserRequestValidator : AbstractValidator<CreateUserRequest>
-{
-    public CreateUserRequestValidator(IUserRepository userRepository)
-    {
-        RuleFor(x => x.Name)
-            .NotEmpty().WithMessage("Name is required")
-            .MaximumLength(100).WithMessage("Name cannot exceed 100 characters");
-
-        RuleFor(x => x.Email)
-            .NotEmpty().WithMessage("Email is required")
-            .EmailAddress().WithMessage("Invalid email format")
-            .MustAsync(async (email, ct) => !await userRepository.EmailExistsAsync(email, ct))
-            .WithMessage("Email already exists");
-
-        RuleFor(x => x.Password)
-            .NotEmpty().WithMessage("Password is required")
-            .MinimumLength(8).WithMessage("Password must be at least 8 characters")
-            .Matches(@"[A-Z]").WithMessage("Password must contain uppercase letter")
-            .Matches(@"[a-z]").WithMessage("Password must contain lowercase letter")
-            .Matches(@"[0-9]").WithMessage("Password must contain digit");
-    }
-}
-
-// Registration in Program.cs
-builder.Services.AddValidatorsFromAssemblyContaining<CreateUserRequestValidator>();
-```
-
-### MediatR CQRS Pattern
-
-Command and Query Separation:
-```csharp
-// Query
-public record GetUserByIdQuery(Guid Id) : IRequest<User?>;
-
-public class GetUserByIdQueryHandler(AppDbContext context)
-    : IRequestHandler<GetUserByIdQuery, User?>
-{
-    public async Task<User?> Handle(GetUserByIdQuery request, CancellationToken ct)
-        => await context.Users
-            .AsNoTracking()
-            .Include(u => u.Posts)
-            .FirstOrDefaultAsync(u => u.Id == request.Id, ct);
-}
-
-// Command
-public record CreateUserCommand(string Name, string Email, string Password) : IRequest<User>;
-
-public class CreateUserCommandHandler(
-    AppDbContext context,
-    IPasswordHasher passwordHasher,
-    IValidator<CreateUserCommand> validator)
-    : IRequestHandler<CreateUserCommand, User>
-{
-    public async Task<User> Handle(CreateUserCommand request, CancellationToken ct)
-    {
-        await validator.ValidateAndThrowAsync(request, ct);
-
-        var user = new User
-        {
-            Id = Guid.NewGuid(),
-            Name = request.Name,
-            Email = request.Email,
-            PasswordHash = passwordHasher.Hash(request.Password),
-            CreatedAt = DateTime.UtcNow
-        };
-
-        context.Users.Add(user);
-        await context.SaveChangesAsync(ct);
-        return user;
-    }
-}
-
-// Usage in controller
-[HttpPost]
-public async Task<ActionResult<User>> Create(
-    [FromBody] CreateUserCommand command,
-    [FromServices] IMediator mediator)
-{
-    var user = await mediator.Send(command);
-    return CreatedAtAction(nameof(GetById), new { id = user.Id }, user);
-}
-```
-
-### Blazor Patterns
-
-Interactive Server Component:
-```csharp
-@page "/users"
-@rendermode InteractiveServer
-@inject IUserService UserService
-
-<h1>Users</h1>
-
-@if (_loading)
-{
-    <p>Loading...</p>
-}
-else if (_users is null)
-{
-    <p>No users found.</p>
-}
-else
-{
-    <table class="table">
-        <thead>
-            <tr><th>Name</th><th>Email</th><th>Actions</th></tr>
-        </thead>
-        <tbody>
-            @foreach (var user in _users)
-            {
-                <tr>
-                    <td>@user.Name</td>
-                    <td>@user.Email</td>
-                    <td>
-                        <button @onclick="() => DeleteUser(user.Id)" class="btn btn-danger btn-sm">
-                            Delete
-                        </button>
-                    </td>
-                </tr>
-            }
-        </tbody>
-    </table>
-}
-
-@code {
-    private List<User>? _users;
-    private bool _loading = true;
-
-    protected override async Task OnInitializedAsync()
-    {
-        _users = await UserService.GetAllAsync();
-        _loading = false;
-    }
-
-    private async Task DeleteUser(Guid id)
-    {
-        await UserService.DeleteAsync(id);
-        _users = await UserService.GetAllAsync();
-    }
-}
-```
-
-### Authentication and Authorization
-
-JWT Authentication Setup:
-```csharp
-builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
-    .AddJwtBearer(options =>
-    {
-        options.TokenValidationParameters = new TokenValidationParameters
-        {
-            ValidateIssuer = true,
-            ValidateAudience = true,
-            ValidateLifetime = true,
-            ValidateIssuerSigningKey = true,
-            ValidIssuer = builder.Configuration["Jwt:Issuer"],
-            ValidAudience = builder.Configuration["Jwt:Audience"],
-            IssuerSigningKey = new SymmetricSecurityKey(
-                Encoding.UTF8.GetBytes(builder.Configuration["Jwt:Key"]!))
-        };
-    });
-
-builder.Services.AddAuthorization(options =>
-{
-    options.AddPolicy("Admin", policy => policy.RequireRole("Admin"));
-    options.AddPolicy("CanEdit", policy => policy.RequireClaim("permission", "edit"));
-});
-```
+## Module Index
+
+This skill uses progressive disclosure with specialized modules for deep coverage:
+
+### Language Features
+
+- [C# 12 Features](modules/csharp12-features.md) - Primary constructors, collection expressions, type aliases, default lambdas
+
+### Web Development
+
+- [ASP.NET Core 8](modules/aspnet-core.md) - Minimal API, Controllers, Middleware, Authentication
+- [Blazor Components](modules/blazor-components.md) - Server, WASM, InteractiveServer, Components
+
+### Data Access
+
+- [Entity Framework Core 8](modules/efcore-patterns.md) - DbContext, Repository pattern, Migrations, Query optimization
+
+### Architecture Patterns
+
+- [CQRS and Validation](modules/cqrs-validation.md) - MediatR CQRS, FluentValidation, Handler patterns
+
+### Reference Materials
+
+- [API Reference](reference.md) - Complete API reference, Context7 library mappings
+- [Code Examples](examples.md) - Production-ready examples, testing templates
 
 ---
 
-## Advanced Patterns
+## Implementation Quick Start
 
-For comprehensive documentation including advanced patterns, performance optimization, testing strategies, and deployment configurations, see:
+### Project Structure (Clean Architecture)
 
-- [reference.md](reference.md) - Complete API reference, Context7 library mappings, advanced patterns
-- [examples.md](examples.md) - Production-ready code examples, full-stack patterns, testing templates
+Organize projects in a src folder with four main projects. MyApp.Api contains the ASP.NET Core Web API layer with Controllers folder for API Controllers, Endpoints folder for Minimal API endpoints, and Program.cs as the application entry point. MyApp.Application contains business logic including Commands folder for CQRS Commands, Queries folder for CQRS Queries, and Validators folder for FluentValidation. MyApp.Domain contains domain entities including Entities folder for domain models and Interfaces folder for repository interfaces. MyApp.Infrastructure contains data access including Data folder for DbContext and Repositories folder for repository implementations.
 
-### Context7 Integration
+### Essential Patterns
 
-```csharp
-// ASP.NET Core - mcp__context7__get_library_docs("/dotnet/aspnetcore", "minimal-apis middleware", 1)
-// EF Core - mcp__context7__get_library_docs("/dotnet/efcore", "dbcontext migrations", 1)
-// .NET Runtime - mcp__context7__get_library_docs("/dotnet/runtime", "collections threading", 1)
-// Blazor - mcp__context7__get_library_docs("/dotnet/aspnetcore", "blazor components", 1)
-```
+Primary Constructor with DI: Define a public class UserService with constructor parameters for IUserRepository and ILogger of UserService. Create async methods like GetByIdAsync that take Guid id, log information using the logger with structured logging for UserId, and return the result from repository.FindByIdAsync.
+
+Minimal API Endpoint: Use app.MapGet with route pattern like "/api/users/{id:guid}" and an async lambda taking Guid id and IUserService. Call the service method, check for null result, and return Results.Ok for found entities or Results.NotFound otherwise. Chain WithName for route naming and WithOpenApi for OpenAPI documentation.
+
+Entity Configuration: Create a class implementing IEntityTypeConfiguration of your entity type. In the Configure method taking EntityTypeBuilder, call HasKey to set the primary key, use Property to configure fields with HasMaxLength and IsRequired, and use HasIndex with IsUnique for unique constraints.
 
 ---
 
-## Works Well With
+## Context7 Integration
 
-- `moai-domain-backend` - API design, database integration patterns
-- `moai-platform-deploy` - Azure, Docker, Kubernetes deployment
-- `moai-workflow-testing` - Testing strategies and patterns
-- `moai-foundation-quality` - Code quality standards
-- `moai-essentials-debug` - Debugging .NET applications
+For latest documentation, use Context7 MCP tools.
+
+For ASP.NET Core documentation, first resolve the library ID using mcp__context7__resolve-library-id with "aspnetcore", then fetch docs using mcp__context7__get-library-docs with the resolved library ID and topic like "minimal-apis middleware".
+
+For Entity Framework Core documentation, resolve with "efcore" and fetch with topics like "dbcontext migrations".
+
+For .NET Runtime documentation, resolve with "dotnet runtime" and fetch with topics like "collections threading".
 
 ---
 
 ## Quick Troubleshooting
 
-Build and Runtime:
-```bash
-dotnet build --verbosity detailed    # Detailed build output
-dotnet run --launch-profile https    # Run with HTTPS profile
-dotnet ef database update            # Apply EF migrations
-dotnet ef migrations add Initial     # Create new migration
-```
-
-Common Issues:
-```csharp
-// Null reference handling
-var user = await context.Users.FindAsync(id);
-ArgumentNullException.ThrowIfNull(user, nameof(user));
-
-// Async enumerable for streaming
-public async IAsyncEnumerable<User> StreamUsersAsync(
-    [EnumeratorCancellation] CancellationToken ct = default)
-{
-    await foreach (var user in context.Users.AsAsyncEnumerable().WithCancellation(ct))
-    {
-        yield return user;
-    }
-}
-```
+Build and Runtime: Run dotnet build with --verbosity detailed for detailed output. Run dotnet run with --launch-profile https for HTTPS profile. Run dotnet ef database update to apply EF migrations. Run dotnet ef migrations add with migration name to create new migrations.
+
+Common Patterns:
+
+For null reference handling, use ArgumentNullException.ThrowIfNull with the variable and nameof expression after fetching from context.
+
+For async enumerable streaming, create async methods returning IAsyncEnumerable of your type. Add EnumeratorCancellation attribute to the CancellationToken parameter. Use await foreach with AsAsyncEnumerable and WithCancellation to iterate, yielding each item.
 
 ---
 
-Version: 1.0.0
-Last Updated: 2025-12-07
-Status: Production Ready
+## Works Well With
+
+- `moai-domain-backend` - API design, database integration patterns
+- `moai-platform-deploy` - Azure, Docker, Kubernetes deployment
+- `moai-workflow-testing` - Testing strategies and patterns
+- `moai-foundation-quality` - Code quality standards
+- `moai-essentials-debug` - Debugging .NET applications