@el-j/magic-helix-plugins 4.0.0-beta.2 → 4.0.0-beta.4

package/dist/csharp/templates/framework-aspnetcore.md

@@ -0,0 +1,205 @@
+# ASP.NET Core Framework Instructions
+
+## Architecture
+
+### Minimal API (Modern)
+```csharp
+var builder = WebApplication.CreateBuilder(args);
+builder.Services.AddEndpointsApiExplorer();
+builder.Services.AddSwaggerGen();
+
+var app = builder.Build();
+
+app.MapGet("/api/users/{id}", async (int id, UserService service) => {
+    var user = await service.GetUserAsync(id);
+    return user is not null ? Results.Ok(user) : Results.NotFound();
+});
+
+app.Run();
+```
+
+### Controller-based API
+```csharp
+[ApiController]
+[Route("api/[controller]")]
+public class UsersController : ControllerBase {
+    private readonly UserService _service;
+    
+    public UsersController(UserService service) => _service = service;
+    
+    [HttpGet("{id}")]
+    public async Task<ActionResult<User>> GetUser(int id) {
+        var user = await _service.GetUserAsync(id);
+        return user is not null ? Ok(user) : NotFound();
+    }
+    
+    [HttpPost]
+    public async Task<ActionResult<User>> CreateUser(CreateUserRequest request) {
+        var user = await _service.CreateUserAsync(request);
+        return CreatedAtAction(nameof(GetUser), new { id = user.Id }, user);
+    }
+}
+```
+
+## Dependency Injection
+
+```csharp
+// Program.cs
+builder.Services.AddDbContext<AppDbContext>(options =>
+    options.UseNpgsql(builder.Configuration.GetConnectionString("DefaultConnection")));
+
+builder.Services.AddScoped<IUserRepository, UserRepository>();
+builder.Services.AddScoped<UserService>();
+builder.Services.AddSingleton<ICacheService, RedisCacheService>();
+```
+
+## Entity Framework Core
+
+### DbContext
+```csharp
+public class AppDbContext : DbContext {
+    public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { }
+    
+    public DbSet<User> Users => Set<User>();
+    public DbSet<Order> Orders => Set<Order>();
+    
+    protected override void OnModelCreating(ModelBuilder modelBuilder) {
+        modelBuilder.Entity<User>(entity => {
+            entity.HasKey(e => e.Id);
+            entity.HasIndex(e => e.Email).IsUnique();
+            entity.Property(e => e.Name).HasMaxLength(100).IsRequired();
+        });
+    }
+}
+```
+
+### Migrations
+```bash
+dotnet ef migrations add InitialCreate
+dotnet ef database update
+dotnet ef migrations remove
+```
+
+## Configuration
+
+### appsettings.json
+```json
+{
+  "ConnectionStrings": {
+    "DefaultConnection": "Server=localhost;Database=myapp;User Id=sa;Password=P@ssw0rd;"
+  },
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "JwtSettings": {
+    "Secret": "${JWT_SECRET}",
+    "ExpirationMinutes": 60
+  }
+}
+```
+
+### Options Pattern
+```csharp
+public class JwtSettings {
+    public string Secret { get; set; } = string.Empty;
+    public int ExpirationMinutes { get; set; }
+}
+
+// Register
+builder.Services.Configure<JwtSettings>(
+    builder.Configuration.GetSection("JwtSettings"));
+
+// Use
+public class AuthService {
+    private readonly JwtSettings _settings;
+    
+    public AuthService(IOptions<JwtSettings> options) {
+        _settings = options.Value;
+    }
+}
+```
+
+## Middleware
+
+```csharp
+public class RequestLoggingMiddleware {
+    private readonly RequestDelegate _next;
+    private readonly ILogger<RequestLoggingMiddleware> _logger;
+    
+    public RequestLoggingMiddleware(RequestDelegate next, ILogger<RequestLoggingMiddleware> logger) {
+        _next = next;
+        _logger = logger;
+    }
+    
+    public async Task InvokeAsync(HttpContext context) {
+        _logger.LogInformation("Request: {Method} {Path}", context.Request.Method, context.Request.Path);
+        await _next(context);
+    }
+}
+
+// Register
+app.UseMiddleware<RequestLoggingMiddleware>();
+```
+
+## Authentication & Authorization
+
+```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("AdminOnly", policy => policy.RequireRole("Admin"));
+});
+```
+
+## Health Checks
+
+```csharp
+builder.Services.AddHealthChecks()
+    .AddNpgSql(builder.Configuration.GetConnectionString("DefaultConnection")!)
+    .AddRedis(builder.Configuration.GetConnectionString("Redis")!);
+
+app.MapHealthChecks("/health");
+```
+
+## Docker Production Setup
+
+```dockerfile
+FROM mcr.microsoft.com/dotnet/aspnet:8.0-alpine
+WORKDIR /app
+COPY --from=build /app/publish .
+
+ENV ASPNETCORE_URLS=http://+:8080
+ENV ASPNETCORE_ENVIRONMENT=Production
+
+EXPOSE 8080
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+  CMD wget --no-verbose --tries=1 --spider http://localhost:8080/health || exit 1
+
+ENTRYPOINT ["dotnet", "MyApp.dll"]
+```
+
+## Performance Best Practices
+
+- Use async/await throughout
+- Enable response compression
+- Implement caching (ResponseCache, MemoryCache, Redis)
+- Use connection pooling for databases
+- Minimize allocations in hot paths
+- Use `Span<T>` for high-performance scenarios
+- Enable HTTP/2 and HTTP/3
+- Use output caching (ASP.NET Core 7+)

package/dist/csharp/templates/framework-blazor.md

@@ -0,0 +1,271 @@
+# Blazor Framework Instructions
+
+## Blazor Modes
+
+### Blazor WebAssembly (Client-side)
+- Runs in browser via WebAssembly
+- Full .NET runtime in browser
+- Offline capable after initial load
+- Slower initial load time
+
+### Blazor Server (Server-side)
+- UI updates via SignalR connection
+- Fast initial load
+- Less client resources needed
+- Requires persistent connection
+
+### Blazor Hybrid (.NET MAUI)
+- Native desktop/mobile apps
+- Uses platform WebView
+- Full .NET access
+
+## Component Structure
+
+### Basic Component
+```razor
+@page "/users"
+@inject UserService UserService
+
+<h3>Users</h3>
+
+@if (users == null) {
+    <p>Loading...</p>
+} else {
+    <ul>
+        @foreach (var user in users) {
+            <li>@user.Name - @user.Email</li>
+        }
+    </ul>
+}
+
+@code {
+    private List<User>? users;
+
+    protected override async Task OnInitializedAsync() {
+        users = await UserService.GetUsersAsync();
+    }
+}
+```
+
+### Component with Parameters
+```razor
+@* UserCard.razor *@
+<div class="card">
+    <h4>@User.Name</h4>
+    <p>@User.Email</p>
+    <button @onclick="OnDeleteClick">Delete</button>
+</div>
+
+@code {
+    [Parameter]
+    public User User { get; set; } = null!;
+    
+    [Parameter]
+    public EventCallback<User> OnDelete { get; set; }
+    
+    private async Task OnDeleteClick() {
+        await OnDelete.InvokeAsync(User);
+    }
+}
+```
+
+## Data Binding
+
+### Two-way Binding
+```razor
+<input @bind="username" />
+<input @bind="username" @bind:event="oninput" />
+
+@code {
+    private string username = "";
+}
+```
+
+### Form Validation
+```razor
+<EditForm Model="user" OnValidSubmit="HandleSubmit">
+    <DataAnnotationsValidator />
+    <ValidationSummary />
+    
+    <InputText @bind-Value="user.Name" />
+    <ValidationMessage For="@(() => user.Name)" />
+    
+    <InputText @bind-Value="user.Email" type="email" />
+    <ValidationMessage For="@(() => user.Email)" />
+    
+    <button type="submit">Submit</button>
+</EditForm>
+
+@code {
+    private UserDto user = new();
+    
+    private async Task HandleSubmit() {
+        await UserService.CreateUserAsync(user);
+    }
+}
+
+public class UserDto {
+    [Required]
+    [StringLength(100)]
+    public string Name { get; set; } = "";
+    
+    [Required]
+    [EmailAddress]
+    public string Email { get; set; } = "";
+}
+```
+
+## Dependency Injection
+
+```csharp
+// Program.cs (Blazor WebAssembly)
+builder.Services.AddScoped<UserService>();
+builder.Services.AddScoped(sp => new HttpClient { 
+    BaseAddress = new Uri(builder.HostEnvironment.BaseAddress) 
+});
+
+// Program.cs (Blazor Server)
+builder.Services.AddScoped<UserService>();
+builder.Services.AddDbContext<AppDbContext>(options =>
+    options.UseNpgsql(builder.Configuration.GetConnectionString("DefaultConnection")));
+```
+
+## JavaScript Interop
+
+```razor
+@inject IJSRuntime JS
+
+<button @onclick="ShowAlert">Show Alert</button>
+
+@code {
+    private async Task ShowAlert() {
+        await JS.InvokeVoidAsync("alert", "Hello from Blazor!");
+    }
+}
+```
+
+```javascript
+// wwwroot/js/app.js
+window.blazorHelpers = {
+    focusElement: (elementId) => {
+        document.getElementById(elementId)?.focus();
+    }
+};
+```
+
+```csharp
+await JS.InvokeVoidAsync("blazorHelpers.focusElement", "myInput");
+```
+
+## State Management
+
+### Cascading Parameters
+```razor
+<CascadingValue Value="theme">
+    <ChildComponent />
+</CascadingValue>
+
+@code {
+    private string theme = "dark";
+}
+
+// In child component
+@code {
+    [CascadingParameter]
+    public string Theme { get; set; } = "";
+}
+```
+
+### Scoped Service for State
+```csharp
+public class AppState {
+    public event Action? OnChange;
+    private string? _currentUser;
+    
+    public string? CurrentUser {
+        get => _currentUser;
+        set {
+            _currentUser = value;
+            NotifyStateChanged();
+        }
+    }
+    
+    private void NotifyStateChanged() => OnChange?.Invoke();
+}
+
+// Register as scoped
+builder.Services.AddScoped<AppState>();
+
+// Use in component
+@implements IDisposable
+@inject AppState AppState
+
+@code {
+    protected override void OnInitialized() {
+        AppState.OnChange += StateHasChanged;
+    }
+    
+    public void Dispose() {
+        AppState.OnChange -= StateHasChanged;
+    }
+}
+```
+
+## Performance Optimization
+
+### Virtualization
+```razor
+<Virtualize Items="@users" Context="user">
+    <UserCard User="user" />
+</Virtualize>
+```
+
+### Lazy Loading
+```razor
+@page "/admin"
+@attribute [Authorize(Roles = "Admin")]
+
+<h3>Admin Panel</h3>
+```
+
+```csharp
+// Program.cs
+builder.Services.AddScoped<LazyAssemblyLoader>();
+
+// Load assemblies on demand
+await LazyAssemblyLoader.LoadAssembliesAsync(new[] { "AdminModule.dll" });
+```
+
+## Docker Deployment
+
+### Blazor WebAssembly
+```dockerfile
+FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
+WORKDIR /src
+COPY . .
+RUN dotnet publish -c Release -o /app/publish
+
+FROM nginx:alpine
+COPY --from=build /app/publish/wwwroot /usr/share/nginx/html
+COPY nginx.conf /etc/nginx/nginx.conf
+```
+
+### Blazor Server
+```dockerfile
+FROM mcr.microsoft.com/dotnet/aspnet:8.0-alpine
+WORKDIR /app
+COPY --from=build /app/publish .
+EXPOSE 8080
+ENTRYPOINT ["dotnet", "BlazorApp.dll"]
+```
+
+## Best Practices
+
+- Use `@key` for list items to improve rendering performance
+- Avoid unnecessary re-renders with `ShouldRender()`
+- Use `StateHasChanged()` sparingly
+- Implement proper error boundaries
+- Use streaming rendering for improved perceived performance
+- Minimize JS interop calls
+- Use virtual scrolling for large lists
+- Implement proper loading states

package/dist/csharp/templates/lang-csharp.md

@@ -0,0 +1,162 @@
+# C# / .NET Instructions
+
+## Project Type
+- Language: C#
+- Framework: {.NET 6|.NET 7|.NET 8}
+- App Type: {ASP.NET Core|Console|Library|Blazor|MAUI}
+
+## Build Commands
+
+```bash
+dotnet restore           # Restore NuGet packages
+dotnet build            # Build project
+dotnet test             # Run tests
+dotnet run              # Run application
+dotnet publish -c Release  # Publish for deployment
+```
+
+## Code Conventions
+
+### C# Modern Features
+```csharp
+// Nullable reference types (C# 8+)
+#nullable enable
+public class User {
+    public string Name { get; set; } = string.Empty;
+    public string? Email { get; set; }
+}
+
+// Records (C# 9+)
+public record Product(int Id, string Name, decimal Price);
+
+// Pattern matching (C# 9+)
+var result = value switch {
+    null => "null",
+    > 0 => "positive",
+    < 0 => "negative",
+    _ => "zero"
+};
+```
+
+### Async/Await
+```csharp
+public async Task<User> GetUserAsync(int id) {
+    var user = await _context.Users.FindAsync(id);
+    return user ?? throw new NotFoundException();
+}
+```
+
+### LINQ
+```csharp
+var activeUsers = users
+    .Where(u => u.IsActive)
+    .OrderBy(u => u.Name)
+    .Select(u => new UserDto(u.Id, u.Name));
+```
+
+## Docker Optimization
+
+### Multi-stage Dockerfile
+```dockerfile
+# Build stage
+FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
+WORKDIR /src
+COPY ["MyApp.csproj", "./"]
+RUN dotnet restore
+COPY . .
+RUN dotnet publish -c Release -o /app/publish
+
+# Runtime stage
+FROM mcr.microsoft.com/dotnet/aspnet:8.0-alpine
+WORKDIR /app
+COPY --from=build /app/publish .
+
+# Non-root user
+RUN adduser -u 1000 -D appuser && chown -R appuser /app
+USER appuser
+
+EXPOSE 8080
+ENTRYPOINT ["dotnet", "MyApp.dll"]
+```
+
+### Docker Compose for Development
+```yaml
+services:
+  app:
+    build: .
+    ports:
+      - "8080:8080"
+    environment:
+      - ASPNETCORE_ENVIRONMENT=Development
+      - ConnectionStrings__DefaultConnection=Server=db;Database=mydb;
+    depends_on:
+      - db
+  
+  db:
+    image: postgres:15-alpine
+    environment:
+      POSTGRES_PASSWORD: devpassword
+```
+
+## Testing
+
+### Unit Tests (xUnit)
+```csharp
+public class UserServiceTests {
+    [Fact]
+    public async Task GetUser_ReturnsUser_WhenExists() {
+        // Arrange
+        var service = new UserService(mockRepo);
+        
+        // Act
+        var result = await service.GetUserAsync(1);
+        
+        // Assert
+        Assert.NotNull(result);
+        Assert.Equal("John", result.Name);
+    }
+}
+```
+
+### Integration Tests
+```csharp
+public class ApiTests : IClassFixture<WebApplicationFactory<Program>> {
+    private readonly HttpClient _client;
+    
+    public ApiTests(WebApplicationFactory<Program> factory) {
+        _client = factory.CreateClient();
+    }
+    
+    [Fact]
+    public async Task GetUser_ReturnsOk() {
+        var response = await _client.GetAsync("/api/users/1");
+        response.EnsureSuccessStatusCode();
+    }
+}
+```
+
+## NuGet Package Management
+
+```bash
+dotnet add package Microsoft.EntityFrameworkCore
+dotnet remove package OldPackage
+dotnet list package --outdated
+```
+
+## Performance Tips
+
+- Use `Span<T>` and `Memory<T>` for high-performance scenarios
+- Enable nullable reference types for better null safety
+- Use `ValueTask` for frequently synchronous operations
+- Leverage record types for immutable DTOs
+- Use source generators to reduce reflection overhead
+- Profile with dotnet-trace and dotnet-counters
+
+## Security
+
+- Enable nullable reference types
+- Use `IOptions<T>` for configuration
+- Implement proper authentication/authorization
+- Validate user input
+- Use parameterized queries (EF Core does this)
+- Keep dependencies updated