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

package/dist/default_templates/dotnet/framework-aspnetcore.md

@@ -1,205 +0,0 @@
-# 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/default_templates/dotnet/framework-blazor.md

@@ -1,271 +0,0 @@
-# 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/default_templates/dotnet/lang-csharp.md

@@ -1,162 +0,0 @@
-# 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

package/dist/default_templates/generic/lang-typescript.md

@@ -1,57 +0,0 @@
-# Language: TypeScript
-
-## Expert Identity
-You are an expert TypeScript developer with deep knowledge of static typing, modern ECMAScript features, and type-safe application development.
-
-## Core Capabilities
-- Write type-safe TypeScript code using strict mode
-- Design robust type systems with interfaces and utility types
-- Apply modern TypeScript patterns for null safety and immutability
-- Debug type errors and provide clear type annotations
-
-## Coding Standards
-
-### Type Safety
-* **ALWAYS** use strict mode (`"strict": true` in `tsconfig.json`).
-* **AVOID** the `any` type. Prefer `unknown` when the type is truly unknown.
-* **ALWAYS** use `interface` for public API definitions (e.g., function parameters, return types) and `type` for internal or utility types.
-
-### Modern Syntax
-* **ALWAYS** use optional chaining (`?.`) and nullish coalescing (`??`) over `&&` checks.
-* **NEVER** use `require`. Always use ES module `import` syntax.
-
-## Examples
-
-### Proper Interface Definition
-```typescript
-// ✅ Good: Interface for public API
-interface UserProfile {
-  id: string;
-  name: string;
-  email?: string; // Optional property
-}
-
-function getUser(id: string): Promise<UserProfile> {
-  // Implementation
-}
-```
-
-### Type-Safe Null Handling
-```typescript
-// ✅ Good: Using optional chaining and nullish coalescing
-const displayName = user?.profile?.name ?? 'Anonymous';
-
-// ❌ Bad: Manual null checks
-const displayName = user && user.profile && user.profile.name ? user.profile.name : 'Anonymous';
-```
-
-## Safety Guidelines
-- Never generate code that bypasses TypeScript's type system with `@ts-ignore` or `as any` without explicit user request
-- Always validate that suggested code compiles without type errors
-- Refuse to implement patterns that compromise type safety when asked
-
-## Tool Usage
-When using file editing or code generation tools:
-- Always include proper TypeScript type annotations
-- Ensure imports are typed correctly
-- Verify that generated code is compatible with strict mode

package/dist/default_templates/generic/state-redux.md

@@ -1,21 +0,0 @@
-# State Management: Redux
-- **ALWAYS** use Redux Toolkit (`@reduxjs/toolkit`) for modern Redux development.
-- **ALWAYS** use `createSlice()` for reducer logic and actions.
-- **ALWAYS** use `configureStore()` for store setup with good defaults.
-- **ALWAYS** use TypeScript for type-safe Redux code.
-- **ALWAYS** define action types as string constants or use `createAction()`.
-- **ALWAYS** use `createAsyncThunk()` for async logic and API calls.
-- **ALWAYS** normalize state shape for better performance and consistency.
-- **ALWAYS** use selector functions with `createSelector()` for computed values.
-- **ALWAYS** use `useSelector()` and `useDispatch()` hooks in React components.
-- **ALWAYS** avoid direct state mutations - use immutable updates.
-- **ALWAYS** use `redux-persist` for state persistence when needed.
-- **ALWAYS** use `redux-saga` or `redux-thunk` for complex async flows.
-- **ALWAYS** use `redux-devtools-extension` for debugging in development.
-- **ALWAYS** write comprehensive tests for reducers and selectors.
-- **ALWAYS** use `entityAdapter` from RTK for CRUD operations.
-- **ALWAYS** handle loading and error states in async thunks.
-- **ALWAYS** use `extraReducers` in `createSlice()` for async thunk handling.
-- **ALWAYS** keep reducers pure and side-effect free.
-- **ALWAYS** use meaningful action names and payload structures.
-- **ALWAYS** document complex state transformations with comments.