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

package/dist/default_templates/ruby/framework-rails.md

@@ -1,309 +0,0 @@
-# Ruby on Rails Framework Instructions
-
-## Project Structure
-```
-app/
-├── models/          # Database models
-├── controllers/     # Request handlers
-├── views/          # Templates
-├── jobs/           # Background jobs
-├── mailers/        # Email templates
-└── channels/       # WebSocket channels
-config/
-├── routes.rb       # URL routing
-├── database.yml    # Database config
-└── application.rb  # App config
-db/
-├── migrate/        # Database migrations
-└── schema.rb       # Current schema
-```
-
-## MVC Pattern
-
-### Model
-```ruby
-class User < ApplicationRecord
-  has_many :posts
-  validates :email, presence: true, uniqueness: true
-  validates :name, presence: true
-  
-  scope :active, -> { where(active: true) }
-  
-  def full_name
-    "#{first_name} #{last_name}"
-  end
-end
-```
-
-### Controller
-```ruby
-class UsersController < ApplicationController
-  before_action :set_user, only: [:show, :update, :destroy]
-  before_action :authenticate_user!
-  
-  def index
-    @users = User.active.page(params[:page])
-    render json: @users
-  end
-  
-  def create
-    @user = User.new(user_params)
-    
-    if @user.save
-      render json: @user, status: :created
-    else
-      render json: @user.errors, status: :unprocessable_entity
-    end
-  end
-  
-  private
-  
-  def set_user
-    @user = User.find(params[:id])
-  end
-  
-  def user_params
-    params.require(:user).permit(:name, :email)
-  end
-end
-```
-
-### View (ERB)
-```erb
-<h1>Users</h1>
-
-<% @users.each do |user| %>
-  <div class="user">
-    <h2><%= user.name %></h2>
-    <p><%= user.email %></p>
-    <%= link_to 'Show', user_path(user) %>
-  </div>
-<% end %>
-
-<%= paginate @users %>
-```
-
-## Routing
-
-```ruby
-# config/routes.rb
-Rails.application.routes.draw do
-  root 'home#index'
-  
-  resources :users do
-    resources :posts
-  end
-  
-  namespace :api do
-    namespace :v1 do
-      resources :users, only: [:index, :show, :create]
-    end
-  end
-  
-  get '/health', to: 'health#index'
-end
-```
-
-## Database Migrations
-
-```bash
-rails generate migration CreateUsers name:string email:string
-rails db:migrate
-rails db:rollback
-rails db:migrate:status
-```
-
-```ruby
-class CreateUsers < ActiveRecord::Migration[7.0]
-  def change
-    create_table :users do |t|
-      t.string :name, null: false
-      t.string :email, null: false
-      t.boolean :active, default: true
-      
-      t.timestamps
-    end
-    
-    add_index :users, :email, unique: true
-  end
-end
-```
-
-## Active Record Queries
-
-```ruby
-# Find
-User.find(1)
-User.find_by(email: 'user@example.com')
-
-# Where
-User.where(active: true)
-User.where('created_at > ?', 1.week.ago)
-
-# Joins
-User.joins(:posts).where(posts: { published: true })
-
-# Eager loading (avoid N+1)
-User.includes(:posts).all
-
-# Aggregations
-User.count
-User.average(:age)
-User.group(:country).count
-```
-
-## Background Jobs (Sidekiq)
-
-```ruby
-class UserMailerJob < ApplicationJob
-  queue_as :default
-  
-  def perform(user_id)
-    user = User.find(user_id)
-    UserMailer.welcome_email(user).deliver_now
-  end
-end
-
-# Enqueue job
-UserMailerJob.perform_later(user.id)
-```
-
-## API Development
-
-### JSON API
-```ruby
-class Api::V1::UsersController < ApplicationController
-  def index
-    users = User.active
-    render json: users, each_serializer: UserSerializer
-  end
-end
-
-class UserSerializer < ActiveModel::Serializer
-  attributes :id, :name, :email, :created_at
-  
-  has_many :posts
-end
-```
-
-### Jbuilder
-```ruby
-# app/views/users/index.json.jbuilder
-json.array! @users do |user|
-  json.id user.id
-  json.name user.name
-  json.email user.email
-  json.posts user.posts, :id, :title
-end
-```
-
-## Testing with RSpec
-
-```ruby
-# spec/requests/users_spec.rb
-require 'rails_helper'
-
-RSpec.describe 'Users API', type: :request do
-  describe 'GET /api/v1/users' do
-    it 'returns all active users' do
-      create_list(:user, 3, active: true)
-      
-      get '/api/v1/users'
-      
-      expect(response).to have_http_status(:ok)
-      expect(JSON.parse(response.body).size).to eq(3)
-    end
-  end
-end
-
-# spec/models/user_spec.rb
-require 'rails_helper'
-
-RSpec.describe User, type: :model do
-  it { should validate_presence_of(:email) }
-  it { should have_many(:posts) }
-  
-  describe '.active' do
-    it 'returns only active users' do
-      active_user = create(:user, active: true)
-      create(:user, active: false)
-      
-      expect(User.active).to eq([active_user])
-    end
-  end
-end
-```
-
-## Configuration
-
-### Database (config/database.yml)
-```yaml
-production:
-  adapter: postgresql
-  url: <%= ENV['DATABASE_URL'] %>
-  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
-```
-
-### Credentials
-```bash
-rails credentials:edit
-```
-
-```yaml
-# config/credentials.yml.enc
-secret_key_base: xxx
-aws:
-  access_key_id: xxx
-  secret_access_key: xxx
-```
-
-```ruby
-# Access in code
-Rails.application.credentials.aws[:access_key_id]
-```
-
-## Docker Production Setup
-
-```dockerfile
-FROM ruby:3.2-alpine
-WORKDIR /app
-
-RUN apk add --no-cache postgresql-client tzdata
-
-COPY --from=builder /usr/local/bundle /usr/local/bundle
-COPY . .
-
-RUN adduser -D -u 1000 rails && chown -R rails /app
-USER rails
-
-ENV RAILS_ENV=production
-ENV RAILS_SERVE_STATIC_FILES=true
-ENV RAILS_LOG_TO_STDOUT=true
-
-EXPOSE 3000
-
-CMD ["bundle", "exec", "puma", "-C", "config/puma.rb"]
-```
-
-## Performance Best Practices
-
-- Use database indexes strategically
-- Eager load associations with `includes`
-- Use `pluck` for simple data extraction
-- Cache expensive operations
-- Use fragment caching for views
-- Optimize database queries (N+1 detection)
-- Use background jobs for slow operations
-- Enable YJIT in Ruby 3.x
-- Use ActionCable for real-time features
-
-## Security Best Practices
-
-- Use strong parameters
-- Enable CSRF protection (default)
-- Use `has_secure_password` for authentication
-- Set secure headers
-- Use SSL in production
-- Sanitize user input
-- Use parameterized queries (ActiveRecord default)
-- Keep dependencies updated

package/dist/default_templates/ruby/framework-sinatra.md

@@ -1,227 +0,0 @@
-# Sinatra Framework Instructions
-
-## Minimal Web Framework
-
-Sinatra is a lightweight Ruby web framework for quick web applications and APIs.
-
-## Basic Application
-
-```ruby
-require 'sinatra'
-require 'json'
-
-# Simple route
-get '/' do
-  'Hello World!'
-end
-
-# Route with parameters
-get '/users/:id' do
-  user = User.find(params[:id])
-  user.to_json
-end
-
-# POST request
-post '/users' do
-  request.body.rewind
-  data = JSON.parse(request.body.read)
-  user = User.create(data)
-  status 201
-  user.to_json
-end
-```
-
-## Modular Application
-
-```ruby
-# app.rb
-require 'sinatra/base'
-
-class MyApp < Sinatra::Base
-  configure do
-    set :show_exceptions, false
-    set :raise_errors, true
-  end
-  
-  before do
-    content_type :json
-  end
-  
-  get '/api/users' do
-    User.all.to_json
-  end
-  
-  error 404 do
-    { error: 'Not Found' }.to_json
-  end
-  
-  run! if app_file == $0
-end
-```
-
-## Configuration
-
-### config.ru
-```ruby
-require './app'
-
-use Rack::Logger
-use Rack::Session::Cookie, secret: ENV['SESSION_SECRET']
-
-run MyApp
-```
-
-## Middleware
-
-```ruby
-class MyApp < Sinatra::Base
-  use Rack::Auth::Basic do |username, password|
-    username == 'admin' && password == 'secret'
-  end
-  
-  use Rack::Cors do
-    allow do
-      origins '*'
-      resource '*', headers: :any, methods: [:get, :post]
-    end
-  end
-end
-```
-
-## Helpers
-
-```ruby
-class MyApp < Sinatra::Base
-  helpers do
-    def authenticated?
-      session[:user_id].present?
-    end
-    
-    def current_user
-      @current_user ||= User.find(session[:user_id]) if authenticated?
-    end
-    
-    def require_authentication!
-      halt 401, { error: 'Unauthorized' }.to_json unless authenticated?
-    end
-  end
-  
-  before '/api/*' do
-    require_authentication!
-  end
-end
-```
-
-## Templates (ERB)
-
-```ruby
-get '/users/:id' do
-  @user = User.find(params[:id])
-  erb :user
-end
-```
-
-```erb
-<!-- views/user.erb -->
-<h1><%= @user.name %></h1>
-<p><%= @user.email %></p>
-```
-
-## Testing with RSpec
-
-```ruby
-# spec/app_spec.rb
-require 'rack/test'
-require './app'
-
-RSpec.describe 'MyApp' do
-  include Rack::Test::Methods
-  
-  def app
-    MyApp
-  end
-  
-  describe 'GET /api/users' do
-    it 'returns all users' do
-      create_list(:user, 3)
-      
-      get '/api/users'
-      
-      expect(last_response.status).to eq(200)
-      expect(JSON.parse(last_response.body).size).to eq(3)
-    end
-  end
-end
-```
-
-## Docker Setup
-
-```dockerfile
-FROM ruby:3.2-alpine
-WORKDIR /app
-
-RUN apk add --no-cache build-base
-
-COPY Gemfile Gemfile.lock ./
-RUN bundle install --without development test
-
-COPY . .
-
-RUN adduser -D -u 1000 sinatra && chown -R sinatra /app
-USER sinatra
-
-EXPOSE 4567
-
-CMD ["ruby", "app.rb", "-o", "0.0.0.0"]
-```
-
-## Running the Application
-
-```bash
-# Development
-ruby app.rb
-
-# With Puma
-bundle exec puma config.ru
-
-# Production (Puma)
-bundle exec puma -C config/puma.rb
-```
-
-## Common Extensions
-
-```ruby
-# Gemfile
-gem 'sinatra'
-gem 'sinatra-contrib'  # Reloader, JSON helpers
-gem 'puma'             # Web server
-gem 'activerecord'     # Database ORM
-gem 'rack-cors'        # CORS support
-gem 'rack-protection'  # Security
-```
-
-## Best Practices
-
-- Use modular style for larger apps
-- Implement proper error handling
-- Use middleware for cross-cutting concerns
-- Keep routes organized
-- Use helpers for common logic
-- Implement authentication/authorization
-- Use environment variables for config
-- Add logging
-- Implement health checks
-
-## When to Use Sinatra
-
-✅ **Good for:**
-- Simple APIs
-- Microservices
-- Prototypes
-- Lightweight web services
-
-❌ **Use Rails instead for:**
-- Large applications
-- Complex business logic
-- Need for convention over configuration
-- Built-in admin interfaces