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

package/dist/default_templates/ruby/lang-ruby.md

@@ -1,216 +0,0 @@
-# Ruby Language Instructions
-
-## Project Type
-- Language: Ruby
-- Package Manager: Bundler (Gemfile)
-- Framework: {Rails|Sinatra|None}
-
-## Build Commands
-
-```bash
-bundle install          # Install dependencies
-bundle exec ruby app.rb # Run application
-bundle exec rake test   # Run tests
-bundle update          # Update dependencies
-```
-
-## Code Conventions
-
-### Ruby Style
-```ruby
-# Use descriptive variable names
-user_name = "John Doe"
-users = User.where(active: true)
-
-# Prefer blocks and enumerables
-users.each do |user|
-  puts user.name
-end
-
-# Use symbols for hash keys
-options = { name: "John", age: 30 }
-
-# Prefer string interpolation
-puts "Hello, #{user.name}!"
-```
-
-### Classes and Modules
-```ruby
-class User
-  attr_accessor :name, :email
-  attr_reader :id
-  
-  def initialize(name:, email:)
-    @name = name
-    @email = email
-    @id = SecureRandom.uuid
-  end
-  
-  def full_profile
-    "#{name} <#{email}>"
-  end
-end
-
-module Authenticatable
-  def authenticate(password)
-    # authentication logic
-  end
-end
-
-class Admin < User
-  include Authenticatable
-end
-```
-
-### Blocks and Procs
-```ruby
-# Block
-numbers.map { |n| n * 2 }
-
-# Multiline block
-numbers.each do |n|
-  puts n
-  log_number(n)
-end
-
-# Proc
-double = ->(x) { x * 2 }
-double.call(5) # => 10
-```
-
-## Testing with RSpec
-
-```ruby
-# spec/models/user_spec.rb
-require 'rails_helper'
-
-RSpec.describe User, type: :model do
-  describe '#full_profile' do
-    it 'returns formatted name and email' do
-      user = User.new(name: 'John', email: 'john@example.com')
-      expect(user.full_profile).to eq('John <john@example.com>')
-    end
-  end
-  
-  describe 'validations' do
-    it { should validate_presence_of(:name) }
-    it { should validate_presence_of(:email) }
-  end
-end
-```
-
-## Docker Optimization
-
-### Multi-stage Dockerfile
-```dockerfile
-FROM ruby:3.2-alpine AS builder
-WORKDIR /app
-
-# Install build dependencies
-RUN apk add --no-cache build-base postgresql-dev
-
-# Install gems
-COPY Gemfile Gemfile.lock ./
-RUN bundle config --local deployment true && \
-    bundle config --local without development:test && \
-    bundle install -j4
-
-# Runtime stage
-FROM ruby:3.2-alpine
-WORKDIR /app
-
-# Install runtime dependencies
-RUN apk add --no-cache postgresql-client tzdata
-
-# Copy installed gems
-COPY --from=builder /usr/local/bundle /usr/local/bundle
-COPY . .
-
-# Non-root user
-RUN adduser -D -u 1000 appuser && chown -R appuser /app
-USER appuser
-
-EXPOSE 3000
-CMD ["bundle", "exec", "puma", "-C", "config/puma.rb"]
-```
-
-### Docker Compose
-```yaml
-services:
-  web:
-    build: .
-    ports:
-      - "3000:3000"
-    environment:
-      - DATABASE_URL=postgresql://postgres:password@db/myapp
-      - REDIS_URL=redis://redis:6379/0
-    depends_on:
-      - db
-      - redis
-  
-  db:
-    image: postgres:15-alpine
-    environment:
-      POSTGRES_PASSWORD: password
-    volumes:
-      - postgres_data:/var/lib/postgresql/data
-  
-  redis:
-    image: redis:7-alpine
-    volumes:
-      - redis_data:/data
-
-volumes:
-  postgres_data:
-  redis_data:
-```
-
-## Dependency Management
-
-```bash
-# Add a gem
-bundle add puma
-
-# Remove a gem
-bundle remove old_gem
-
-# Update specific gem
-bundle update rails
-
-# Check for outdated gems
-bundle outdated
-
-# Audit for security vulnerabilities
-bundle audit
-```
-
-## Performance Tips
-
-- Use `pluck` instead of `map` for database queries
-- Eager load associations to avoid N+1 queries
-- Use background jobs (Sidekiq) for slow operations
-- Cache expensive operations
-- Use `find_each` for large datasets
-- Profile with rack-mini-profiler
-- Use Ruby 3.x for YJIT performance improvements
-
-## Security
-
-- Always use strong parameters in Rails
-- Use `SecureRandom` for tokens
-- Validate user input
-- Use parameterized queries (ActiveRecord does this)
-- Keep dependencies updated with `bundle audit`
-- Set secure headers
-- Use HTTPS in production
-
-## Common Gems
-
-- **puma**: Web server
-- **sidekiq**: Background jobs
-- **rspec**: Testing framework
-- **rubocop**: Linter
-- **devise**: Authentication
-- **cancancan**: Authorization
-- **kaminari**: Pagination
-- **jbuilder**: JSON API builder

package/dist/default_templates/rust/lang-rust.md

@@ -1,89 +0,0 @@
-# Rust Development Guidelines
-
-## Overview
-This project uses Rust. Follow Rust idioms, ownership rules, and best practices.
-
-## Code Style
-- Use `rustfmt` for automatic code formatting
-- Follow the [Rust API Guidelines](https://rust-lang.github.io/api-guidelines/)
-- Use `clippy` for linting: `cargo clippy`
-- Keep functions small and focused
-- Use descriptive variable names
-
-## Ownership & Borrowing
-- Follow Rust's ownership rules strictly
-- Prefer borrowing (`&T`) over taking ownership when possible
-- Use `&mut T` for mutable borrows
-- Avoid unnecessary `.clone()` calls
-- Use `Cow<'_, T>` for conditional ownership
-
-## Error Handling
-- Use `Result<T, E>` for operations that can fail
-- Use the `?` operator for error propagation
-- Create custom error types using `thiserror` crate
-- Avoid `unwrap()` and `expect()` in production code
-- Provide meaningful error messages
-
-## Types & Traits
-- Use strong typing and avoid `String` everywhere
-- Implement common traits (`Debug`, `Clone`, `PartialEq`) when appropriate
-- Use `derive` macros for automatic implementations
-- Define traits for shared behavior
-- Use generics for code reuse
-
-## Cargo Commands
-- Build: `cargo build` (debug) or `cargo build --release` (optimized)
-- Run: `cargo run`
-- Test: `cargo test`
-- Check: `cargo check` (faster than build for syntax checking)
-- Format: `cargo fmt`
-- Lint: `cargo clippy`
-- Doc: `cargo doc --open`
-
-## Project Structure
-- `src/main.rs` - Binary entry point
-- `src/lib.rs` - Library entry point
-- `src/bin/` - Additional binaries
-- `tests/` - Integration tests
-- `benches/` - Benchmarks
-- `examples/` - Example code
-
-## Dependencies
-- Add dependencies in `Cargo.toml`
-- Use semantic versioning
-- Run `cargo update` to update dependencies
-- Check for outdated deps: `cargo outdated`
-
-## Testing
-- Write unit tests in the same file: `#[cfg(test)] mod tests { ... }`
-- Write integration tests in `tests/` directory
-- Use `assert!`, `assert_eq!`, `assert_ne!` macros
-- Run specific tests: `cargo test test_name`
-- Run with output: `cargo test -- --nocapture`
-
-## Async/Await
-- Use `tokio` or `async-std` for async runtime
-- Mark async functions with `async fn`
-- Use `.await` to wait for futures
-- Use `#[tokio::main]` or `#[async_std::main]` for async main
-
-## Documentation
-- Use `///` for public API documentation
-- Use `//!` for module-level documentation
-- Include examples in doc comments
-- Run `cargo doc` to generate documentation
-- Use `#[doc = "..."]` for advanced docs
-
-## Performance
-- Profile before optimizing: use `cargo flamegraph`
-- Use release builds for benchmarks: `cargo bench`
-- Avoid unnecessary allocations
-- Use iterators instead of loops when appropriate
-- Consider using `rayon` for parallel processing
-
-## Common Patterns
-- Builder pattern for complex constructors
-- Newtype pattern for type safety
-- Use `match` for exhaustive pattern matching
-- Use `if let` for simple pattern matching
-- Use `Option<T>` instead of null

package/dist/default_templates/swift/framework-vapor.md

@@ -1,352 +0,0 @@
-# Vapor Framework Instructions
-
-## Server-Side Swift Web Framework
-
-Vapor is a modern, high-performance web framework for Swift.
-
-## Project Structure
-```
-Sources/
-├── App/
-│   ├── Controllers/
-│   ├── Models/
-│   ├── Migrations/
-│   ├── configure.swift
-│   └── routes.swift
-└── Run/
-    └── main.swift
-Tests/
-    └── AppTests/
-Package.swift
-```
-
-## Basic Application
-
-### configure.swift
-```swift
-import Vapor
-import Fluent
-import FluentPostgresDriver
-
-public func configure(_ app: Application) async throws {
-    // Database
-    app.databases.use(
-        .postgres(
-            hostname: Environment.get("DATABASE_HOST") ?? "localhost",
-            port: Environment.get("DATABASE_PORT").flatMap(Int.init) ?? 5432,
-            username: Environment.get("DATABASE_USERNAME") ?? "postgres",
-            password: Environment.get("DATABASE_PASSWORD") ?? "",
-            database: Environment.get("DATABASE_NAME") ?? "vapor"
-        ),
-        as: .psql
-    )
-    
-    // Migrations
-    app.migrations.add(CreateUser())
-    
-    try await app.autoMigrate()
-    
-    // Routes
-    try routes(app)
-}
-```
-
-### routes.swift
-```swift
-import Vapor
-
-func routes(_ app: Application) throws {
-    app.get { req in
-        "Welcome to Vapor!"
-    }
-    
-    app.get("hello", ":name") { req -> String in
-        let name = req.parameters.get("name")!
-        return "Hello, \(name)!"
-    }
-    
-    try app.register(collection: UserController())
-}
-```
-
-## Models with Fluent ORM
-
-```swift
-import Fluent
-import Vapor
-
-final class User: Model, Content {
-    static let schema = "users"
-    
-    @ID(key: .id)
-    var id: UUID?
-    
-    @Field(key: "name")
-    var name: String
-    
-    @Field(key: "email")
-    var email: String
-    
-    @Children(for: \.$user)
-    var posts: [Post]
-    
-    init() {}
-    
-    init(id: UUID? = nil, name: String, email: String) {
-        self.id = id
-        self.name = name
-        self.email = email
-    }
-}
-
-// Migration
-struct CreateUser: AsyncMigration {
-    func prepare(on database: Database) async throws {
-        try await database.schema("users")
-            .id()
-            .field("name", .string, .required)
-            .field("email", .string, .required)
-            .unique(on: "email")
-            .create()
-    }
-    
-    func revert(on database: Database) async throws {
-        try await database.schema("users").delete()
-    }
-}
-```
-
-## Controllers
-
-```swift
-import Vapor
-
-struct UserController: RouteCollection {
-    func boot(routes: RoutesBuilder) throws {
-        let users = routes.grouped("api", "users")
-        users.get(use: index)
-        users.get(":id", use: show)
-        users.post(use: create)
-        users.put(":id", use: update)
-        users.delete(":id", use: delete)
-    }
-    
-    func index(req: Request) async throws -> [User] {
-        try await User.query(on: req.db).all()
-    }
-    
-    func show(req: Request) async throws -> User {
-        guard let user = try await User.find(req.parameters.get("id"), on: req.db) else {
-            throw Abort(.notFound)
-        }
-        return user
-    }
-    
-    func create(req: Request) async throws -> User {
-        let user = try req.content.decode(User.self)
-        try await user.save(on: req.db)
-        return user
-    }
-    
-    func update(req: Request) async throws -> User {
-        guard let user = try await User.find(req.parameters.get("id"), on: req.db) else {
-            throw Abort(.notFound)
-        }
-        
-        let updateData = try req.content.decode(User.self)
-        user.name = updateData.name
-        user.email = updateData.email
-        try await user.save(on: req.db)
-        return user
-    }
-    
-    func delete(req: Request) async throws -> HTTPStatus {
-        guard let user = try await User.find(req.parameters.get("id"), on: req.db) else {
-            throw Abort(.notFound)
-        }
-        try await user.delete(on: req.db)
-        return .noContent
-    }
-}
-```
-
-## Middleware
-
-```swift
-import Vapor
-
-struct LogMiddleware: AsyncMiddleware {
-    func respond(to request: Request, chainingTo next: AsyncResponder) async throws -> Response {
-        request.logger.info("\(request.method) \(request.url.path)")
-        let response = try await next.respond(to: request)
-        request.logger.info("Response: \(response.status.code)")
-        return response
-    }
-}
-
-// Register middleware
-app.middleware.use(LogMiddleware())
-```
-
-## Authentication
-
-```swift
-import Vapor
-import Fluent
-
-final class User: Model, Content, Authenticatable {
-    // ... model definition
-    
-    static func authenticator() -> Authenticator {
-        return BearerAuthenticator()
-    }
-}
-
-// Protected route
-let protected = app.grouped(User.authenticator())
-protected.get("protected") { req -> String in
-    let user = try req.auth.require(User.self)
-    return "Hello, \(user.name)!"
-}
-```
-
-## Validation
-
-```swift
-import Vapor
-
-struct CreateUserRequest: Content, Validatable {
-    var name: String
-    var email: String
-    
-    static func validations(_ validations: inout Validations) {
-        validations.add("name", as: String.self, is: !.empty)
-        validations.add("email", as: String.self, is: .email)
-    }
-}
-
-func create(req: Request) async throws -> User {
-    try CreateUserRequest.validate(content: req)
-    let userData = try req.content.decode(CreateUserRequest.self)
-    // ...
-}
-```
-
-## Testing
-
-```swift
-import XCTVapor
-@testable import App
-
-final class UserTests: XCTestCase {
-    var app: Application!
-    
-    override func setUp() async throws {
-        app = Application(.testing)
-        try await configure(app)
-    }
-    
-    override func tearDown() async throws {
-        app.shutdown()
-    }
-    
-    func testGetUsers() async throws {
-        try await app.test(.GET, "api/users") { res in
-            XCTAssertEqual(res.status, .ok)
-            let users = try res.content.decode([User].self)
-            XCTAssertGreaterThan(users.count, 0)
-        }
-    }
-    
-    func testCreateUser() async throws {
-        let user = User(name: "John", email: "john@example.com")
-        
-        try await app.test(.POST, "api/users", beforeRequest: { req in
-            try req.content.encode(user)
-        }, afterResponse: { res in
-            XCTAssertEqual(res.status, .ok)
-            let created = try res.content.decode(User.self)
-            XCTAssertEqual(created.name, "John")
-        })
-    }
-}
-```
-
-## Docker Production Setup
-
-```dockerfile
-FROM swift:5.9-jammy AS build
-WORKDIR /app
-
-COPY Package.swift Package.resolved ./
-RUN swift package resolve
-
-COPY . .
-RUN swift build -c release --static-swift-stdlib
-
-FROM ubuntu:22.04
-WORKDIR /app
-
-RUN apt-get update && apt-get install -y \
-    libcurl4 \
-    libxml2 \
-    ca-certificates \
-    && rm -rf /var/lib/apt/lists/*
-
-COPY --from=build /app/.build/release/Run ./Run
-
-RUN useradd -m -u 1000 vapor
-USER vapor
-
-EXPOSE 8080
-ENV VAPOR_ENV=production
-
-ENTRYPOINT ["./Run"]
-CMD ["serve", "--hostname", "0.0.0.0", "--port", "8080"]
-```
-
-## Environment Configuration
-
-```swift
-import Vapor
-
-func configure(_ app: Application) async throws {
-    switch app.environment {
-    case .production:
-        app.logger.logLevel = .warning
-    case .development:
-        app.logger.logLevel = .debug
-    default:
-        break
-    }
-    
-    // Database URL from environment
-    if let databaseURL = Environment.get("DATABASE_URL") {
-        try app.databases.use(.postgres(url: databaseURL), as: .psql)
-    }
-}
-```
-
-## Performance Tips
-
-- Use async/await throughout
-- Leverage connection pooling
-- Implement caching where appropriate
-- Use database indexes
-- Profile with Instruments
-- Enable release optimizations
-- Use EventLoopFuture batching for multiple operations
-- Implement pagination for large datasets
-
-## Best Practices
-
-- Use proper error handling with `Abort`
-- Validate user input
-- Implement authentication/authorization
-- Use migrations for database schema changes
-- Write comprehensive tests
-- Use environment variables for configuration
-- Implement health check endpoints
-- Log appropriately
-- Use middlewares for cross-cutting concerns
-- Keep controllers thin, logic in services