@dennisrongo/skills 0.1.0

package/skills/dotnet-onion-api/references/templates/base-controller.cs.md

@@ -0,0 +1,90 @@
+# `src/{{Solution}}.Api/Controllers/BaseController.cs`
+
+```csharp
+using {{Solution}}.Application.Common;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace {{Solution}}.Api.Controllers;
+
+[ApiController]
+[Route("api/[controller]")]
+[Authorize]
+[Produces("application/json")]
+public abstract class BaseController : ControllerBase
+{
+    protected readonly IUserContext UserContext;
+
+    protected BaseController(IUserContext userContext)
+    {
+        UserContext = userContext;
+    }
+}
+```
+
+# `src/{{Solution}}.Application/Common/IUserContext.cs`
+
+```csharp
+namespace {{Solution}}.Application.Common;
+
+/// Provides per-request user identity. Resolved per scope.
+public interface IUserContext
+{
+    int UserId { get; }
+    string UserName { get; }
+    string? ClientId { get; }
+    bool IsAuthenticated { get; }
+    IReadOnlyCollection<string> Roles { get; }
+}
+```
+
+# `src/{{Solution}}.Infrastructure/Auth/UserContext.cs`
+
+```csharp
+using System.Security.Claims;
+using {{Solution}}.Application.Common;
+using Microsoft.AspNetCore.Http;
+
+namespace {{Solution}}.Infrastructure.Auth;
+
+public sealed class UserContext : IUserContext
+{
+    private readonly IHttpContextAccessor _accessor;
+
+    public UserContext(IHttpContextAccessor accessor) => _accessor = accessor;
+
+    private ClaimsPrincipal? User => _accessor.HttpContext?.User;
+
+    public bool IsAuthenticated => User?.Identity?.IsAuthenticated ?? false;
+
+    public int UserId =>
+        int.TryParse(User?.FindFirstValue(ClaimTypes.NameIdentifier), out var id) ? id : 0;
+
+    public string UserName => User?.FindFirstValue(ClaimTypes.Name) ?? string.Empty;
+
+    public string? ClientId => User?.FindFirstValue("client_id");
+
+    public IReadOnlyCollection<string> Roles =>
+        User?.FindAll(ClaimTypes.Role).Select(c => c.Value).ToArray() ?? Array.Empty<string>();
+}
+```
+
+# `src/{{Solution}}.Api/Models/ApiException.cs`
+
+```csharp
+namespace {{Solution}}.Api.Models;
+
+public sealed record ApiException(int StatusCode, string Message, string? Detail = null);
+```
+
+# `src/{{Solution}}.Api/Models/ApiValidationErrorResponse.cs`
+
+```csharp
+namespace {{Solution}}.Api.Models;
+
+public sealed class ApiValidationErrorResponse
+{
+    public string Message { get; set; } = string.Empty;
+    public string[] Errors { get; set; } = Array.Empty<string>();
+}
+```

package/skills/dotnet-onion-api/references/templates/csproj-files.md

@@ -0,0 +1,178 @@
+# `.csproj` templates
+
+⚠️ **Do not paste these as-is.** The `<TargetFramework>` and every `<PackageReference Version="…">` must be resolved at scaffold time (see SKILL.md Step 1). Treat the version strings here as placeholders shown for shape only.
+
+## `Directory.Build.props` (solution root)
+
+```xml
+<Project>
+  <PropertyGroup>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <EnableNETAnalyzers>true</EnableNETAnalyzers>
+    <AnalysisLevel>latest-recommended</AnalysisLevel>
+  </PropertyGroup>
+</Project>
+```
+
+## `src/{{Solution}}.Domain/{{Solution}}.Domain.csproj`
+
+```xml
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>{{TFM}}</TargetFramework>
+  </PropertyGroup>
+  <!-- ZERO ProjectReferences. Domain depends on nothing. -->
+</Project>
+```
+
+## `src/{{Solution}}.Application/{{Solution}}.Application.csproj`
+
+```xml
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>{{TFM}}</TargetFramework>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\{{Solution}}.Domain\{{Solution}}.Domain.csproj" />
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="AutoMapper" Version="{{LATEST}}" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="{{LATEST}}" />
+    <PackageReference Include="Scrutor" Version="{{LATEST}}" />
+  </ItemGroup>
+</Project>
+```
+
+## `src/{{Solution}}.Infrastructure/{{Solution}}.Infrastructure.csproj`
+
+```xml
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>{{TFM}}</TargetFramework>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\{{Solution}}.Application\{{Solution}}.Application.csproj" />
+    <ProjectReference Include="..\{{Solution}}.Domain\{{Solution}}.Domain.csproj" />
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="{{LATEST}}" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="{{LATEST}}" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="{{LATEST}}">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" Version="{{LATEST}}" />
+    <PackageReference Include="Microsoft.Extensions.Http" Version="{{LATEST}}" />
+    <PackageReference Include="Microsoft.AspNetCore.Http.Abstractions" Version="{{LATEST}}" />
+  </ItemGroup>
+</Project>
+```
+
+## `src/{{Solution}}.Api/{{Solution}}.Api.csproj`
+
+```xml
+<Project Sdk="Microsoft.NET.Sdk.Web">
+  <PropertyGroup>
+    <TargetFramework>{{TFM}}</TargetFramework>
+    <UserSecretsId>{{NEW_GUID}}</UserSecretsId>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\{{Solution}}.Application\{{Solution}}.Application.csproj" />
+    <ProjectReference Include="..\{{Solution}}.Infrastructure\{{Solution}}.Infrastructure.csproj" />
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="{{LATEST}}" />
+    <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="{{LATEST}}" />
+    <PackageReference Include="Swashbuckle.AspNetCore" Version="{{LATEST}}" />
+  </ItemGroup>
+</Project>
+```
+
+## `src/{{Solution}}.Workers.{{Worker}}/{{Solution}}.Workers.{{Worker}}.csproj`
+
+```xml
+<Project Sdk="Microsoft.NET.Sdk.Worker">
+  <PropertyGroup>
+    <TargetFramework>{{TFM}}</TargetFramework>
+    <OutputType>Exe</OutputType>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\{{Solution}}.Application\{{Solution}}.Application.csproj" />
+    <ProjectReference Include="..\{{Solution}}.Infrastructure\{{Solution}}.Infrastructure.csproj" />
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Hosting" Version="{{LATEST}}" />
+    <!-- Add only the SDK clients this worker actually needs: -->
+    <!-- <PackageReference Include="Azure.Messaging.ServiceBus" Version="{{LATEST}}" /> -->
+    <!-- <PackageReference Include="Azure.Storage.Queues" Version="{{LATEST}}" /> -->
+  </ItemGroup>
+  <ItemGroup>
+    <None Update="appsettings.json"><CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory></None>
+    <None Update="appsettings.Development.json"><CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory></None>
+  </ItemGroup>
+</Project>
+```
+
+## `tests/{{Solution}}.UnitTests/{{Solution}}.UnitTests.csproj`
+
+```xml
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>{{TFM}}</TargetFramework>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\{{Solution}}.Application\{{Solution}}.Application.csproj" />
+    <ProjectReference Include="..\..\src\{{Solution}}.Domain\{{Solution}}.Domain.csproj" />
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="{{LATEST}}" />
+    <PackageReference Include="xunit" Version="{{LATEST}}" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="{{LATEST}}" />
+    <PackageReference Include="NSubstitute" Version="{{LATEST}}" />
+    <PackageReference Include="FluentAssertions" Version="{{LATEST}}" />
+    <PackageReference Include="AutoMapper" Version="{{LATEST}}" />
+  </ItemGroup>
+</Project>
+```
+
+## `tests/{{Solution}}.IntegrationTests/{{Solution}}.IntegrationTests.csproj`
+
+Only generate if the user explicitly opts in.
+
+```xml
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>{{TFM}}</TargetFramework>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\{{Solution}}.Api\{{Solution}}.Api.csproj" />
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="{{LATEST}}" />
+    <PackageReference Include="xunit" Version="{{LATEST}}" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="{{LATEST}}" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="{{LATEST}}" />
+    <PackageReference Include="Testcontainers.MsSql" Version="{{LATEST}}" />
+    <PackageReference Include="FluentAssertions" Version="{{LATEST}}" />
+  </ItemGroup>
+</Project>
+```
+
+## How to resolve `{{LATEST}}` at scaffold time
+
+For each package, call:
+
+```
+mcp__plugin_context7_context7__resolve-library-id  →  query-docs
+```
+
+with the package id (e.g. `Microsoft.EntityFrameworkCore.SqlServer`). If context7 can't resolve, fall back to `WebFetch` of `https://www.nuget.org/packages/{Package}` and parse the latest stable version (skip pre-release unless the user opts in).
+
+Then substitute every `{{LATEST}}` with the resolved version string before writing the `.csproj`.
+
+State the resolved version table back to the user before writing files.

package/skills/dotnet-onion-api/references/templates/dbcontext.cs.md

@@ -0,0 +1,149 @@
+# EF Core DbContext + Application ports + Infrastructure DI
+
+## `src/{{Solution}}.Infrastructure/Persistence/AppDbContext.cs`
+
+```csharp
+using {{Solution}}.Application.Common;
+using Microsoft.EntityFrameworkCore;
+using System.Reflection;
+
+namespace {{Solution}}.Infrastructure.Persistence;
+
+public sealed class AppDbContext : DbContext
+{
+    private readonly IUserContext _userContext;
+
+    public AppDbContext(DbContextOptions<AppDbContext> options, IUserContext userContext)
+        : base(options)
+    {
+        _userContext = userContext;
+    }
+
+    // Add DbSet<T> properties per feature. Example:
+    // public DbSet<Customer> Customers => Set<Customer>();
+
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        modelBuilder.ApplyConfigurationsFromAssembly(Assembly.GetExecutingAssembly());
+        base.OnModelCreating(modelBuilder);
+    }
+
+    public override Task<int> SaveChangesAsync(CancellationToken ct = default)
+    {
+        // Hook: stamp audit columns from _userContext here if entities implement IAuditable.
+        return base.SaveChangesAsync(ct);
+    }
+}
+```
+
+## `src/{{Solution}}.Application/Common/IUnitOfWork.cs`
+
+```csharp
+namespace {{Solution}}.Application.Common;
+
+public interface IUnitOfWork
+{
+    Task<int> SaveChangesAsync(CancellationToken ct = default);
+}
+```
+
+## `src/{{Solution}}.Infrastructure/Persistence/UnitOfWork.cs`
+
+```csharp
+using {{Solution}}.Application.Common;
+
+namespace {{Solution}}.Infrastructure.Persistence;
+
+public sealed class UnitOfWork : IUnitOfWork
+{
+    private readonly AppDbContext _db;
+    public UnitOfWork(AppDbContext db) => _db = db;
+    public Task<int> SaveChangesAsync(CancellationToken ct = default) => _db.SaveChangesAsync(ct);
+}
+```
+
+## `src/{{Solution}}.Infrastructure/DependencyInjection.cs`
+
+```csharp
+using {{Solution}}.Application.Common;
+using {{Solution}}.Infrastructure.Auth;
+using {{Solution}}.Infrastructure.Persistence;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace {{Solution}}.Infrastructure;
+
+public static class DependencyInjection
+{
+    public static IServiceCollection AddInfrastructure(this IServiceCollection services, IConfiguration config)
+    {
+        var connectionString = config.GetConnectionString("Default")
+            ?? throw new InvalidOperationException("ConnectionStrings:Default is required.");
+
+        services.AddDbContext<AppDbContext>(opt =>
+            opt.UseSqlServer(connectionString, sql =>
+            {
+                sql.EnableRetryOnFailure();
+                sql.CommandTimeout(60);
+            }));
+
+        services.AddScoped<IUnitOfWork, UnitOfWork>();
+        services.AddScoped<IUserContext, UserContext>();
+
+        // Auto-register concrete adapters whose interface lives in Application.
+        // Convention: Infrastructure types named *Repository implement *Repository ports.
+        services.Scan(s => s
+            .FromAssemblyOf<AssemblyMarker>()
+            .AddClasses(c => c.Where(t => t.Name.EndsWith("Repository")))
+                .AsImplementedInterfaces()
+                .WithScopedLifetime());
+
+        return services;
+    }
+}
+
+internal sealed class AssemblyMarker;
+```
+
+## `src/{{Solution}}.Application/DependencyInjection.cs`
+
+```csharp
+using Microsoft.Extensions.DependencyInjection;
+
+namespace {{Solution}}.Application;
+
+public static class DependencyInjection
+{
+    public static IServiceCollection AddApplication(this IServiceCollection services)
+    {
+        services.AddAutoMapper(cfg => cfg.AddMaps(typeof(ApplicationAssemblyMarker).Assembly));
+
+        services.Scan(s => s
+            .FromAssemblyOf<ApplicationAssemblyMarker>()
+            .AddClasses(c => c.Where(t => t.Name.EndsWith("Service")))
+                .AsImplementedInterfaces()
+                .WithScopedLifetime());
+
+        return services;
+    }
+}
+
+public sealed class ApplicationAssemblyMarker;
+```
+
+## EF migrations
+
+After scaffold, the user runs:
+
+```bash
+dotnet ef migrations add Initial \
+  --project src/{{Solution}}.Infrastructure \
+  --startup-project src/{{Solution}}.Api
+
+dotnet ef database update \
+  --project src/{{Solution}}.Infrastructure \
+  --startup-project src/{{Solution}}.Api
+```
+
+Print this command in your final report so the user doesn't have to look it up.

package/skills/dotnet-onion-api/references/templates/exception-middleware.cs.md

@@ -0,0 +1,101 @@
+# Exception handler middleware
+
+## `src/{{Solution}}.Api/Middlewares/ExceptionHandlerMiddleware.cs`
+
+```csharp
+using System.Net;
+using System.Text.Json;
+using {{Solution}}.Api.Models;
+using {{Solution}}.Application.Common.Exceptions;
+
+namespace {{Solution}}.Api.Middlewares;
+
+public sealed class ExceptionHandlerMiddleware
+{
+    private readonly RequestDelegate _next;
+    private readonly ILogger<ExceptionHandlerMiddleware> _logger;
+    private readonly IWebHostEnvironment _env;
+
+    public ExceptionHandlerMiddleware(
+        RequestDelegate next,
+        ILogger<ExceptionHandlerMiddleware> logger,
+        IWebHostEnvironment env)
+    {
+        _next = next;
+        _logger = logger;
+        _env = env;
+    }
+
+    public async Task InvokeAsync(HttpContext context)
+    {
+        try
+        {
+            await _next(context);
+        }
+        catch (Exception ex)
+        {
+            await HandleAsync(context, ex);
+        }
+    }
+
+    private async Task HandleAsync(HttpContext context, Exception ex)
+    {
+        var (status, message) = ex switch
+        {
+            NotFoundException nf  => ((int)HttpStatusCode.NotFound, nf.Message),
+            ValidationException v => ((int)HttpStatusCode.BadRequest, v.Message),
+            ConflictException c   => ((int)HttpStatusCode.Conflict, c.Message),
+            UnauthorizedAccessException u => ((int)HttpStatusCode.Unauthorized, u.Message),
+            _ => ((int)HttpStatusCode.InternalServerError, "An unexpected error occurred.")
+        };
+
+        if (status >= 500)
+        {
+            _logger.LogError(ex, "Unhandled exception: {Message}", ex.Message);
+        }
+        else
+        {
+            _logger.LogWarning(ex, "Handled exception: {Message}", ex.Message);
+        }
+
+        context.Response.ContentType = "application/json";
+        context.Response.StatusCode = status;
+
+        var includeDetail = _env.IsDevelopment() || _env.IsStaging();
+        var payload = new ApiException(status, message, includeDetail ? ex.StackTrace : null);
+
+        await context.Response.WriteAsync(JsonSerializer.Serialize(payload, new JsonSerializerOptions
+        {
+            PropertyNamingPolicy = JsonNamingPolicy.CamelCase
+        }));
+    }
+}
+
+public static class MiddlewareExtensions
+{
+    public static IApplicationBuilder UseCustomExceptionHandler(this IApplicationBuilder app) =>
+        app.UseMiddleware<ExceptionHandlerMiddleware>();
+}
+```
+
+## `src/{{Solution}}.Application/Common/Exceptions/*.cs`
+
+```csharp
+namespace {{Solution}}.Application.Common.Exceptions;
+
+public class NotFoundException : Exception
+{
+    public NotFoundException(string entity, object key)
+        : base($"{entity} with key '{key}' was not found.") { }
+}
+
+public class ValidationException : Exception
+{
+    public ValidationException(string message) : base(message) { }
+}
+
+public class ConflictException : Exception
+{
+    public ConflictException(string message) : base(message) { }
+}
+```