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

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

@@ -1,30 +1,403 @@
-# moai-lang-csharp - CLI Reference
+# C# 12 / .NET 8 API Reference
 
-_Last updated: 2025-10-22_
+Comprehensive API reference and Context7 library mappings for C# 12 and .NET 8 development.
 
-## Quick Reference
+---
+
+## Context7 Library Mappings
+
+### Primary Libraries
+
+ASP.NET Core:
+- Context7 ID: `/dotnet/aspnetcore`
+- Topics: minimal-apis, controllers, middleware, authentication, authorization, blazor, signalr
+- Version: 8.0+
+
+Entity Framework Core:
+- Context7 ID: `/dotnet/efcore`
+- Topics: dbcontext, migrations, linq, query-optimization, relationships, tracking
+- Version: 8.0+
+
+.NET Runtime:
+- Context7 ID: `/dotnet/runtime`
+- Topics: collections, threading, memory, span, async, linq
+- Version: 8.0+
+
+### Context7 Query Patterns
+
+```
+# Minimal APIs and Middleware
+mcp__context7__get-library-docs("/dotnet/aspnetcore", "minimal-apis endpoint routing")
+mcp__context7__get-library-docs("/dotnet/aspnetcore", "middleware pipeline")
+
+# Authentication and Authorization
+mcp__context7__get-library-docs("/dotnet/aspnetcore", "jwt authentication bearer")
+mcp__context7__get-library-docs("/dotnet/aspnetcore", "authorization policies claims")
+
+# Entity Framework Queries
+mcp__context7__get-library-docs("/dotnet/efcore", "dbcontext configuration")
+mcp__context7__get-library-docs("/dotnet/efcore", "linq queries optimization")
+mcp__context7__get-library-docs("/dotnet/efcore", "migrations code-first")
+
+# Blazor Components
+mcp__context7__get-library-docs("/dotnet/aspnetcore", "blazor components lifecycle")
+mcp__context7__get-library-docs("/dotnet/aspnetcore", "blazor interactiveserver wasm")
+
+# Collections and Threading
+mcp__context7__get-library-docs("/dotnet/runtime", "concurrent collections")
+mcp__context7__get-library-docs("/dotnet/runtime", "async await patterns")
+```
+
+---
 
-### Installation
+## .NET CLI Reference
+
+### Project Creation
+
+```bash
+# Web API with .NET 8
+dotnet new webapi -n MyApi --framework net8.0
+
+# Blazor Web App with Auto interactivity
+dotnet new blazor -n MyBlazor --interactivity Auto
+
+# Class Library
+dotnet new classlib -n MyLib --framework net8.0
+
+# xUnit Test Project
+dotnet new xunit -n MyApi.Tests --framework net8.0
+
+# Solution file
+dotnet new sln -n MySolution
+dotnet sln add src/MyApi/MyApi.csproj
+```
+
+### Package Management
 
 ```bash
-# Installation commands
+# Entity Framework Core
+dotnet add package Microsoft.EntityFrameworkCore.SqlServer
+dotnet add package Microsoft.EntityFrameworkCore.Design
+dotnet add package Microsoft.EntityFrameworkCore.Tools
+
+# Validation and CQRS
+dotnet add package FluentValidation.AspNetCore
+dotnet add package MediatR
+
+# Authentication
+dotnet add package Microsoft.AspNetCore.Authentication.JwtBearer
+
+# Testing
+dotnet add package xunit
+dotnet add package Moq
+dotnet add package FluentAssertions
+
+# API Documentation
+dotnet add package Swashbuckle.AspNetCore
 ```
 
-### Common Commands
+### Entity Framework CLI
 
 ```bash
-# Test
-# Lint
-# Format
-# Build
+# Install EF tools
+dotnet tool install --global dotnet-ef
+
+# Migrations
+dotnet ef migrations add InitialCreate
+dotnet ef migrations add AddUserTable
+dotnet ef database update
+dotnet ef database update InitialCreate  # Rollback to specific migration
+
+# Generate SQL script
+dotnet ef migrations script
+
+# Scaffold from existing database
+dotnet ef dbcontext scaffold "Connection" Microsoft.EntityFrameworkCore.SqlServer
+```
+
+---
+
+## NuGet Package Versions (.NET 8)
+
+### Core Packages
+
+```xml
+<PackageReference Include="Microsoft.EntityFrameworkCore" Version="8.0.11" />
+<PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="8.0.11" />
+<PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="8.0.11" />
+<PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="8.0.11" />
+```
+
+### Validation and CQRS
+
+```xml
+<PackageReference Include="FluentValidation" Version="11.11.0" />
+<PackageReference Include="FluentValidation.AspNetCore" Version="11.3.0" />
+<PackageReference Include="FluentValidation.DependencyInjectionExtensions" Version="11.11.0" />
+<PackageReference Include="MediatR" Version="12.4.1" />
+```
+
+### Testing
+
+```xml
+<PackageReference Include="xunit" Version="2.9.2" />
+<PackageReference Include="xunit.runner.visualstudio" Version="2.8.2" />
+<PackageReference Include="Moq" Version="4.20.72" />
+<PackageReference Include="FluentAssertions" Version="6.12.2" />
+<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+```
+
+### Logging and Observability
+
+```xml
+<PackageReference Include="Serilog.AspNetCore" Version="8.0.3" />
+<PackageReference Include="Serilog.Sinks.Console" Version="6.0.0" />
+<PackageReference Include="OpenTelemetry.Extensions.Hosting" Version="1.10.0" />
+```
+
+---
+
+## Configuration Patterns
+
+### appsettings.json Structure
+
+```json
+{
+  "ConnectionStrings": {
+    "Default": "Server=localhost;Database=MyDb;Trusted_Connection=true;TrustServerCertificate=true"
+  },
+  "Jwt": {
+    "Issuer": "https://myapp.com",
+    "Audience": "https://myapp.com",
+    "Key": "your-secret-key-min-32-chars",
+    "ExpirationMinutes": 60
+  },
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning",
+      "Microsoft.EntityFrameworkCore": "Warning"
+    }
+  }
+}
+```
+
+### Environment-Specific Configuration
+
+```
+appsettings.json                    # Base configuration
+appsettings.Development.json        # Development overrides
+appsettings.Production.json         # Production overrides
+```
+
+Access configuration:
+```csharp
+builder.Configuration.GetConnectionString("Default")
+builder.Configuration["Jwt:Issuer"]
+builder.Configuration.GetSection("Jwt").Get<JwtSettings>()
+```
+
+---
+
+## HTTP Status Codes Reference
+
+### Success Responses
+
+```csharp
+Results.Ok(data)              // 200 OK
+Results.Created(uri, data)    // 201 Created
+Results.Accepted()            // 202 Accepted
+Results.NoContent()           // 204 No Content
+```
+
+### Client Error Responses
+
+```csharp
+Results.BadRequest(errors)           // 400 Bad Request
+Results.Unauthorized()               // 401 Unauthorized
+Results.Forbid()                     // 403 Forbidden
+Results.NotFound()                   // 404 Not Found
+Results.Conflict()                   // 409 Conflict
+Results.UnprocessableEntity(errors)  // 422 Unprocessable Entity
+```
+
+### Server Error Responses
+
+```csharp
+Results.Problem(detail: "Error message")  // 500 Internal Server Error
+```
+
+---
+
+## Dependency Injection Lifetimes
+
+### Service Lifetimes
+
+```csharp
+// Singleton: Single instance for application lifetime
+builder.Services.AddSingleton<ICacheService, MemoryCacheService>();
+
+// Scoped: Single instance per HTTP request
+builder.Services.AddScoped<IUserService, UserService>();
+builder.Services.AddScoped<IUserRepository, EfUserRepository>();
+
+// Transient: New instance every time requested
+builder.Services.AddTransient<IEmailService, SmtpEmailService>();
 ```
 
-## Tool Versions (2025-10-22)
+### Registration Patterns
+
+```csharp
+// Interface to implementation
+builder.Services.AddScoped<IService, Service>();
+
+// Self-registration
+builder.Services.AddScoped<MyService>();
+
+// Factory pattern
+builder.Services.AddScoped<IService>(sp => 
+    new Service(sp.GetRequiredService<IDependency>()));
+
+// Options pattern
+builder.Services.Configure<JwtSettings>(
+    builder.Configuration.GetSection("Jwt"));
+```
+
+---
+
+## Middleware Pipeline Order
+
+### Recommended Order
+
+```csharp
+var app = builder.Build();
+
+// 1. Exception handling (first)
+app.UseExceptionHandler("/error");
+
+// 2. HTTPS redirection
+app.UseHttpsRedirection();
+
+// 3. Static files (if needed)
+app.UseStaticFiles();
+
+// 4. Routing
+app.UseRouting();
+
+// 5. CORS (before auth)
+app.UseCors();
+
+// 6. Authentication
+app.UseAuthentication();
 
-- **C#**: 13.0.0
-- **.NET**: 9.0.0
-- **xUnit**: 2.9.0
+// 7. Authorization
+app.UseAuthorization();
+
+// 8. Custom middleware
+app.UseCustomMiddleware();
+
+// 9. Endpoint mapping (last)
+app.MapControllers();
+app.MapBlazorHub();
+```
+
+---
+
+## Performance Best Practices
+
+### EF Core Query Optimization
+
+```csharp
+// Use AsNoTracking for read-only queries
+var users = await context.Users.AsNoTracking().ToListAsync();
+
+// Use projection to select only needed columns
+var userDtos = await context.Users
+    .Select(u => new UserDto(u.Id, u.Name))
+    .ToListAsync();
+
+// Use compiled queries for hot paths
+private static readonly Func<AppDbContext, Guid, Task<User?>> GetUserById =
+    EF.CompileAsyncQuery((AppDbContext ctx, Guid id) =>
+        ctx.Users.FirstOrDefault(u => u.Id == id));
+
+// Batch operations
+await context.Users.Where(u => u.IsDeleted).ExecuteDeleteAsync();
+await context.Users.Where(u => u.Role == "User").ExecuteUpdateAsync(
+    s => s.SetProperty(u => u.Role, "Member"));
+```
+
+### Async Best Practices
+
+```csharp
+// Always use async/await for I/O operations
+public async Task<User?> GetByIdAsync(Guid id, CancellationToken ct = default)
+    => await context.Users.FindAsync([id], ct);
+
+// Use ConfigureAwait(false) in library code
+public async Task<string> GetDataAsync()
+{
+    var data = await httpClient.GetStringAsync(url).ConfigureAwait(false);
+    return Process(data);
+}
+
+// Use ValueTask for frequently synchronous paths
+public ValueTask<int> GetCachedValueAsync()
+{
+    if (_cache.TryGetValue(key, out var value))
+        return ValueTask.FromResult(value);
+    return new ValueTask<int>(FetchFromDatabaseAsync());
+}
+```
+
+---
+
+## Security Best Practices
+
+### Input Validation
+
+```csharp
+// Always validate and sanitize input
+[HttpPost]
+public async Task<ActionResult> Create([FromBody] CreateRequest request)
+{
+    // Model validation via attributes
+    if (!ModelState.IsValid)
+        return BadRequest(ModelState);
+    
+    // Business validation
+    var result = await validator.ValidateAsync(request);
+    if (!result.IsValid)
+        return BadRequest(result.Errors);
+}
+```
+
+### SQL Injection Prevention
+
+```csharp
+// Use parameterized queries (EF Core does this automatically)
+var user = await context.Users.FirstOrDefaultAsync(u => u.Email == email);
+
+// For raw SQL, always use parameters
+var users = await context.Users
+    .FromSqlInterpolated($"SELECT * FROM Users WHERE Email = {email}")
+    .ToListAsync();
+```
+
+### Secrets Management
+
+```csharp
+// Use User Secrets for development
+dotnet user-secrets init
+dotnet user-secrets set "Jwt:Key" "your-secret-key"
+
+// Use Azure Key Vault for production
+builder.Configuration.AddAzureKeyVault(
+    new Uri("https://myvault.vault.azure.net/"),
+    new DefaultAzureCredential());
+```
 
 ---
 
-_For detailed usage, see SKILL.md_
+Version: 2.0.0
+Last Updated: 2026-01-06

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

@@ -0,0 +1,135 @@
+---
+name: "moai-lang-elixir"
+description: "Elixir 1.17+ development specialist covering Phoenix 1.7, LiveView, Ecto, and OTP patterns. Use when developing real-time applications, distributed systems, or Phoenix projects."
+version: 1.1.0
+category: "language"
+modularized: true
+user-invocable: false
+tags: ["language", "elixir", "phoenix", "liveview", "ecto", "otp", "genserver"]
+updated: 2026-01-11
+status: "active"
+allowed-tools:
+  - Read
+  - Grep
+  - Glob
+  - Bash
+  - mcp__context7__resolve-library-id
+  - mcp__context7__get-library-docs
+---
+
+## Quick Reference (30 seconds)
+
+Elixir 1.17+ Development Specialist - Phoenix 1.7, LiveView, Ecto, OTP patterns, and functional programming.
+
+Auto-Triggers: `.ex`, `.exs` files, `mix.exs`, `config/`, Phoenix/LiveView discussions
+
+Core Capabilities:
+
+- Elixir 1.17: Pattern matching, pipes, protocols, behaviours, macros
+- Phoenix 1.7: Controllers, LiveView, Channels, PubSub, Verified Routes
+- Ecto: Schemas, Changesets, Queries, Migrations, Multi
+- OTP: GenServer, Supervisor, Agent, Task, Registry
+- ExUnit: Testing with setup, describe, async
+- Mix: Build tool, tasks, releases
+- Oban: Background job processing
+
+### Quick Patterns
+
+Phoenix Controller: Define a module using MyAppWeb with :controller. Create alias for the context module like MyApp.Accounts. Define action functions like show taking conn and params map with destructured id. Fetch data using the context function with bang like get_user! and render the template passing the data as assigns.
+
+For create actions, pattern match on the context result tuple. On ok tuple, use pipe operator to put_flash with success message and redirect using ~p sigil for verified routes. On error tuple with Ecto.Changeset, render the form template passing the changeset.
+
+Ecto Schema with Changeset: Define a module using Ecto.Schema and importing Ecto.Changeset. Define the schema block with field declarations including types like :string and virtual fields. Create a changeset function taking the struct and attrs, using pipe operator to chain cast with the list of fields to cast, validate_required, validate_format with regex, validate_length with min option, and unique_constraint.
+
+GenServer Pattern: Define a module using GenServer. Create start_link taking initial_value and calling GenServer.start_link with __MODULE__, initial_value, and name option. Define client API functions that call GenServer.call with __MODULE__ and the message atom. Implement init callback returning ok tuple with state. Implement handle_call callbacks for each message, returning reply tuple with response and new state.
+
+---
+
+## Implementation Guide (5 minutes)
+
+### Elixir 1.17 Features
+
+Pattern Matching Advanced: Define function heads with pattern matching on map keys and types. Use guard clauses with when to add constraints like is_binary or byte_size checks. Add a catch-all clause returning error tuple for invalid inputs.
+
+Pipe Operator with Error Handling: Use the with special form for chaining operations that may fail. Pattern match each step with left arrow, and on successful completion of all steps, return the final ok tuple. In the else block, handle error tuples by returning them unchanged.
+
+Protocols for Polymorphism: Define a protocol with @doc and function specification using defprotocol. Implement the protocol for specific types using defimpl with for: option. Each implementation provides the specific behavior for that type.
+
+### Phoenix 1.7 Patterns
+
+LiveView Component: Define a module using MyAppWeb with :live_view. Implement mount callback taking params, session, and socket, returning ok tuple with assigned state. Implement handle_event callback for user interactions, returning noreply tuple with updated socket using update helper. Implement render callback with assigns, using ~H sigil for HEEx templates with assigns accessed via @ prefix.
+
+LiveView Form with Changesets: In mount, create initial changeset and assign using to_form helper. Implement validate event handler that creates changeset with :validate action and reassigns the form. Implement save event handler that calls context create function, on success using put_flash and push_navigate, on error reassigning the form with error changeset.
+
+Phoenix Channels: Define a module using MyAppWeb with :channel. Implement join callback matching on topic pattern with angle brackets for dynamic segments. Use send with self() for after_join messages. Implement handle_info for server-side messages using push. Implement handle_in for client messages using broadcast! to send to all subscribers.
+
+Verified Routes: Define routes in router.ex within scope blocks using live macro for LiveView routes. Use ~p sigil for verified routes in templates and controllers, with interpolation syntax for dynamic segments.
+
+### Ecto Patterns
+
+Multi for Transactions: Use Ecto.Multi.new() and pipe through operations using Ecto.Multi.update with name atoms and changeset functions. Use Ecto.Multi.insert with function callback when needing results from previous steps. Pipe final Multi to Repo.transaction() which returns ok or error tuple with named results.
+
+Query Composition: Create a query module with composable query functions. Define a base function returning from expression. Create filter functions with default parameter for query, returning modified from expression with where clause. Chain functions with pipe operator before passing to Repo.all.
+
+---
+
+## Advanced Implementation (10+ minutes)
+
+For comprehensive coverage including:
+
+- Production deployment with releases
+- Distributed systems with libcluster
+- Advanced LiveView patterns (streams, components)
+- OTP supervision trees and dynamic supervisors
+- Telemetry and observability
+- Security best practices
+- CI/CD integration patterns
+
+See:
+
+- [Advanced Patterns](modules/advanced-patterns.md) - Complete advanced patterns guide
+
+---
+
+## Context7 Library Mappings
+
+- /elixir-lang/elixir - Elixir language documentation
+- /phoenixframework/phoenix - Phoenix web framework
+- /phoenixframework/phoenix_live_view - LiveView real-time UI
+- /elixir-ecto/ecto - Database wrapper and query language
+- /sorentwo/oban - Background job processing
+
+---
+
+## Works Well With
+
+- `moai-domain-backend` - REST API and microservices architecture
+- `moai-domain-database` - SQL patterns and query optimization
+- `moai-workflow-testing` - TDD and testing strategies
+- `moai-essentials-debug` - AI-powered debugging
+- `moai-platform-deploy` - Deployment and infrastructure
+
+---
+
+## Troubleshooting
+
+Common Issues:
+
+Elixir Version Check: Run elixir --version to verify 1.17+ and mix --version for Mix build tool version.
+
+Dependency Issues: Run mix deps.get to fetch dependencies, mix deps.compile to compile them, and mix clean to remove build artifacts.
+
+Database Migrations: Run mix ecto.create to create database, mix ecto.migrate to run migrations, and mix ecto.rollback to rollback last migration.
+
+Phoenix Server: Run mix phx.server to start the server, iex -S mix phx.server to start with IEx shell, and MIX_ENV=prod mix release to build production release.
+
+LiveView Not Loading:
+
+- Check websocket connection in browser developer console
+- Verify endpoint configuration includes websocket transport
+- Ensure Phoenix.LiveView is listed in mix.exs dependencies
+
+---
+
+Last Updated: 2026-01-11
+Status: Active (v1.1.0)