claude-code-templates 1.10.0 → 1.10.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-templates",
-  "version": "1.10.0",
+  "version": "1.10.1",
   "description": "CLI tool to setup Claude Code configurations with framework-specific commands, automation hooks and MCP Servers for your projects",
   "main": "src/index.js",
   "bin": {
@@ -31,7 +31,7 @@
     "dev:link": "npm link",
     "dev:unlink": "npm unlink -g claude-code-templates",
     "pretest:commands": "npm run dev:link",
-    "prepublishOnly": "echo 'Skipping tests for Health Check release'",
+    "prepublishOnly": "echo 'Skipping tests for Ruby on Rails 8 release'",
     "analytics:start": "node src/analytics.js",
     "analytics:test": "npm run test:analytics"
   },

package/src/hook-scanner.js

@@ -123,6 +123,10 @@ function getHookDescription(hook, matcher, type) {
     return 'Block print() statements in Python files';
   }
   
+  if (command.includes('puts\\|p ') && command.includes('rb$')) {
+    return 'Block puts/p statements in Ruby files';
+  }
+  
   if (command.includes('fmt.Print') && command.includes('go$')) {
     return 'Block fmt.Print statements in Go files';
   }
@@ -131,7 +135,7 @@ function getHookDescription(hook, matcher, type) {
     return 'Block println! macros in Rust files';
   }
   
-  if (command.includes('npm audit') || command.includes('pip-audit') || command.includes('cargo audit')) {
+  if (command.includes('npm audit') || command.includes('pip-audit') || command.includes('bundle audit') || command.includes('cargo audit')) {
     return 'Security audit for dependencies';
   }
   
@@ -143,6 +147,18 @@ function getHookDescription(hook, matcher, type) {
     return 'Auto-format Python files with Black';
   }
   
+  if (command.includes('rubocop -A') && command.includes('rb$')) {
+    return 'Auto-format Ruby files with RuboCop';
+  }
+  
+  if (command.includes('rubocop') && command.includes('rb$') && !command.includes('-A')) {
+    return 'Run Ruby linting with RuboCop';
+  }
+  
+  if (command.includes('brakeman')) {
+    return 'Run Ruby security scan with Brakeman';
+  }
+  
   if (command.includes('isort') && command.includes('py$')) {
     return 'Auto-sort Python imports with isort';
   }
@@ -195,6 +211,10 @@ function getHookDescription(hook, matcher, type) {
     return 'Auto-run Python tests for modified files';
   }
   
+  if (command.includes('rspec')) {
+    return 'Auto-run Ruby tests with RSpec';
+  }
+  
   if (command.includes('go test')) {
     return 'Auto-run Go tests for modified files';
   }

package/src/templates.js

@@ -76,6 +76,30 @@ const TEMPLATES_CONFIG = {
       }
     }
   },
+  'ruby': {
+    name: 'Ruby',
+    description: 'Optimized for Ruby development with modern tools',
+    files: [
+      { source: 'ruby/CLAUDE.md', destination: 'CLAUDE.md' },
+      { source: 'ruby/.claude', destination: '.claude' },
+      { source: 'ruby/.mcp.json', destination: '.mcp.json' }
+    ],
+    frameworks: {
+      'rails': {
+        name: 'Ruby on Rails 8',
+        additionalFiles: [
+          { source: 'ruby/examples/rails-app/.claude/commands', destination: '.claude/commands' },
+          { source: 'ruby/examples/rails-app/CLAUDE.md', destination: 'CLAUDE.md' }
+        ]
+      },
+      'sinatra': {
+        name: 'Sinatra',
+        additionalFiles: [
+          { source: 'ruby/examples/sinatra-app/.claude/commands', destination: '.claude/commands' }
+        ]
+      }
+    }
+  },
   'rust': {
     name: 'Rust',
     description: 'Optimized for Rust development',

package/src/utils.js

@@ -60,6 +60,50 @@ async function detectProject(targetDir) {
     }
   }
   
+  // Check for Ruby files
+  const rubyFiles = await findFilesByExtension(targetDir, ['.rb']);
+  const gemfilePath = path.join(targetDir, 'Gemfile');
+  const gemfileLockPath = path.join(targetDir, 'Gemfile.lock');
+  
+  if (rubyFiles.length > 0 || await fs.pathExists(gemfilePath)) {
+    detectedLanguages.push('ruby');
+    
+    // Check for Ruby frameworks
+    if (await fs.pathExists(gemfilePath)) {
+      try {
+        const gemfile = await fs.readFile(gemfilePath, 'utf-8');
+        if (gemfile.includes('rails')) {
+          detectedFrameworks.push('rails');
+        }
+        if (gemfile.includes('sinatra')) {
+          detectedFrameworks.push('sinatra');
+        }
+      } catch (error) {
+        console.warn('Could not parse Gemfile');
+      }
+    }
+    
+    // Check for Rails application structure
+    const railsAppPath = path.join(targetDir, 'config', 'application.rb');
+    const railsRoutesPath = path.join(targetDir, 'config', 'routes.rb');
+    if (await fs.pathExists(railsAppPath) || await fs.pathExists(railsRoutesPath)) {
+      detectedFrameworks.push('rails');
+    }
+    
+    // Check for Rakefile (common in Rails and Ruby projects)
+    const rakefilePath = path.join(targetDir, 'Rakefile');
+    if (await fs.pathExists(rakefilePath)) {
+      try {
+        const rakefile = await fs.readFile(rakefilePath, 'utf-8');
+        if (rakefile.includes('Rails.application.load_tasks')) {
+          detectedFrameworks.push('rails');
+        }
+      } catch (error) {
+        // Ignore parsing errors
+      }
+    }
+  }
+  
   // Check for Rust files
   const rustFiles = await findFilesByExtension(targetDir, ['.rs']);
   const cargoPath = path.join(targetDir, 'Cargo.toml');
@@ -145,6 +189,7 @@ async function getProjectSummary(targetDir) {
     hasGit: await fs.pathExists(path.join(targetDir, '.git')),
     hasNodeModules: await fs.pathExists(path.join(targetDir, 'node_modules')),
     hasVenv: await fs.pathExists(path.join(targetDir, 'venv')) || await fs.pathExists(path.join(targetDir, '.venv')),
+    hasBundle: await fs.pathExists(path.join(targetDir, 'vendor', 'bundle')),
     configFiles: []
   };
   
@@ -152,6 +197,7 @@ async function getProjectSummary(targetDir) {
   const configFiles = [
     'package.json', 'tsconfig.json', 'webpack.config.js', 'vite.config.js',
     'requirements.txt', 'setup.py', 'pyproject.toml', 'Pipfile',
+    'Gemfile', 'Gemfile.lock', 'Rakefile', 'config.ru',
     'Cargo.toml', 'go.mod', '.gitignore', 'README.md'
   ];
   

package/templates/ruby/.claude/commands/model.md

@@ -0,0 +1,360 @@
+# Ruby Model Generator
+
+Create Ruby classes and models with proper structure and best practices.
+
+## Purpose
+
+This command helps you quickly create Ruby model classes with proper initialization, attributes, and methods following Ruby conventions.
+
+## Usage
+
+```
+/model
+```
+
+## What this command does
+
+1. **Creates model classes** with proper initialization methods
+2. **Adds attribute accessors** and instance variables
+3. **Includes validation methods** and error handling
+4. **Follows Ruby conventions** and best practices
+5. **Generates related test files** when applicable
+
+## Example Output
+
+```ruby
+# app/models/user.rb
+class User
+  attr_accessor :name, :email, :age
+  attr_reader :id, :created_at
+  
+  def initialize(attributes = {})
+    @id = attributes[:id] || generate_id
+    @name = attributes[:name]
+    @email = attributes[:email]
+    @age = attributes[:age]
+    @created_at = Time.now
+    @errors = []
+  end
+  
+  def valid?
+    @errors.clear
+    validate_presence_of_name
+    validate_email_format
+    validate_age_range
+    @errors.empty?
+  end
+  
+  def errors
+    @errors.dup
+  end
+  
+  def save
+    return false unless valid?
+    
+    # Persist logic here
+    true
+  end
+  
+  def to_h
+    {
+      id: @id,
+      name: @name,
+      email: @email,
+      age: @age,
+      created_at: @created_at
+    }
+  end
+  
+  def to_json(*args)
+    JSON.generate(to_h, *args)
+  end
+  
+  private
+  
+  def validate_presence_of_name
+    if @name.nil? || @name.strip.empty?
+      @errors << "Name cannot be blank"
+    end
+  end
+  
+  def validate_email_format
+    if @email && !@email.match?(/\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i)
+      @errors << "Email format is invalid"
+    end
+  end
+  
+  def validate_age_range
+    if @age && (@age < 0 || @age > 150)
+      @errors << "Age must be between 0 and 150"
+    end
+  end
+  
+  def generate_id
+    SecureRandom.uuid
+  end
+end
+
+# Example with inheritance
+class AdminUser < User
+  attr_accessor :permissions
+  
+  def initialize(attributes = {})
+    super
+    @permissions = attributes[:permissions] || []
+  end
+  
+  def admin?
+    true
+  end
+  
+  def has_permission?(permission)
+    @permissions.include?(permission)
+  end
+  
+  private
+  
+  def validate_permissions
+    unless @permissions.is_a?(Array)
+      @errors << "Permissions must be an array"
+    end
+  end
+end
+```
+
+## Advanced Features
+
+### Module Inclusion
+```ruby
+module Timestamps
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  
+  module ClassMethods
+    def with_timestamps
+      attr_reader :created_at, :updated_at
+      
+      define_method :initialize do |*args|
+        super(*args)
+        @created_at ||= Time.now
+        @updated_at = @created_at
+      end
+      
+      define_method :touch do
+        @updated_at = Time.now
+      end
+    end
+  end
+end
+
+class Post
+  include Timestamps
+  with_timestamps
+  
+  attr_accessor :title, :content
+  
+  def initialize(attributes = {})
+    @title = attributes[:title]
+    @content = attributes[:content]
+    super
+  end
+end
+```
+
+### Class Methods and Scopes
+```ruby
+class User
+  @@users = []
+  
+  def self.all
+    @@users.dup
+  end
+  
+  def self.find_by_email(email)
+    @@users.find { |user| user.email == email }
+  end
+  
+  def self.where(conditions = {})
+    @@users.select do |user|
+      conditions.all? { |key, value| user.send(key) == value }
+    end
+  end
+  
+  def self.create(attributes = {})
+    user = new(attributes)
+    if user.save
+      @@users << user
+      user
+    else
+      nil
+    end
+  end
+  
+  def save
+    return false unless valid?
+    
+    unless @@users.include?(self)
+      @@users << self
+    end
+    true
+  end
+  
+  def destroy
+    @@users.delete(self)
+  end
+end
+```
+
+## Testing Template
+
+```ruby
+# spec/models/user_spec.rb
+require 'spec_helper'
+
+RSpec.describe User do
+  let(:valid_attributes) do
+    {
+      name: 'John Doe',
+      email: 'john@example.com',
+      age: 30
+    }
+  end
+  
+  describe '#initialize' do
+    it 'sets attributes correctly' do
+      user = User.new(valid_attributes)
+      
+      expect(user.name).to eq('John Doe')
+      expect(user.email).to eq('john@example.com')
+      expect(user.age).to eq(30)
+      expect(user.id).not_to be_nil
+      expect(user.created_at).to be_a(Time)
+    end
+  end
+  
+  describe '#valid?' do
+    it 'returns true for valid attributes' do
+      user = User.new(valid_attributes)
+      expect(user).to be_valid
+    end
+    
+    it 'returns false when name is blank' do
+      user = User.new(valid_attributes.merge(name: ''))
+      expect(user).not_to be_valid
+      expect(user.errors).to include('Name cannot be blank')
+    end
+    
+    it 'returns false for invalid email format' do
+      user = User.new(valid_attributes.merge(email: 'invalid-email'))
+      expect(user).not_to be_valid
+      expect(user.errors).to include('Email format is invalid')
+    end
+    
+    it 'returns false for invalid age' do
+      user = User.new(valid_attributes.merge(age: -5))
+      expect(user).not_to be_valid
+      expect(user.errors).to include('Age must be between 0 and 150')
+    end
+  end
+  
+  describe '#save' do
+    it 'saves valid user' do
+      user = User.new(valid_attributes)
+      expect(user.save).to be true
+    end
+    
+    it 'does not save invalid user' do
+      user = User.new(name: '')
+      expect(user.save).to be false
+    end
+  end
+  
+  describe '#to_h' do
+    it 'returns hash representation' do
+      user = User.new(valid_attributes)
+      hash = user.to_h
+      
+      expect(hash).to include(
+        name: 'John Doe',
+        email: 'john@example.com',
+        age: 30
+      )
+      expect(hash[:id]).not_to be_nil
+      expect(hash[:created_at]).to be_a(Time)
+    end
+  end
+end
+```
+
+## Best Practices Included
+
+- **Proper initialization** with hash parameters
+- **Attribute accessors** for public attributes
+- **Validation methods** with error collection
+- **JSON serialization** support
+- **Class and instance methods** separation
+- **Error handling** and reporting
+- **Ruby naming conventions** (snake_case)
+- **Encapsulation** with private methods
+
+## Common Patterns
+
+### Value Objects
+```ruby
+class Money
+  include Comparable
+  
+  attr_reader :amount, :currency
+  
+  def initialize(amount, currency = 'USD')
+    @amount = amount.to_f
+    @currency = currency.to_s.upcase
+  end
+  
+  def +(other)
+    raise ArgumentError, "Currency mismatch" unless currency == other.currency
+    Money.new(amount + other.amount, currency)
+  end
+  
+  def <=>(other)
+    raise ArgumentError, "Currency mismatch" unless currency == other.currency
+    amount <=> other.amount
+  end
+  
+  def to_s
+    "#{currency} #{format('%.2f', amount)}"
+  end
+end
+```
+
+### Service Objects
+```ruby
+class UserRegistrationService
+  attr_reader :user, :errors
+  
+  def initialize(user_params)
+    @user_params = user_params
+    @errors = []
+  end
+  
+  def call
+    @user = User.new(@user_params)
+    
+    if @user.valid?
+      @user.save
+      send_welcome_email
+      true
+    else
+      @errors = @user.errors
+      false
+    end
+  end
+  
+  private
+  
+  def send_welcome_email
+    # Email sending logic
+  end
+end
+```