mcp-on-rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9de4dca8095e1020e24bf8f70df4a28f148b2cc85ecf2768a556722da1292132
+  data.tar.gz: c553494738ae79d5ac4409021a2f1ddd69caf1506e47d38c42e93add47c9f106
+SHA512:
+  metadata.gz: cca8f6b8ebcdfe8ff07e50af3008d0aa50208225b127d5edddc3cb7b86b03329dcd36ae897ff079d387e2b4c7ef104932a6e5dca22b1e7da8380d029fc768ed7
+  data.tar.gz: 7c120a4dff702bdb99be86fea3d02e02f0832bdae3e9b008a9397510a4ff7b4cff1f33319e0f038401caa007681a9f7e322c84c27e77f4b6dce4d5a1ce27a4d7

data/.rubocop.yml

@@ -0,0 +1,8 @@
+AllCops:
+  TargetRubyVersion: 3.1
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes

data/CHANGELOG.md

@@ -0,0 +1,24 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-07-30
+
+### Added
+- Initial release of mcp-on-rails gem
+- Pre-configured MCP settings for Rails development
+- Specialized prompts for 8 Rails component areas:
+  - Architect (overall coordination)
+  - Models (ActiveRecord, migrations, database)
+  - Controllers (HTTP handling, routing, APIs)
+  - Views (templates, layouts, frontend)
+  - Stimulus (JavaScript, Turbo integration)
+  - Jobs (background processing)
+  - Tests (testing strategies, coverage)
+  - DevOps (deployment, infrastructure)
+- Template system with ERB for project customization
+- Command-line interface with `mcp-on-rails` executable
+- Compatible with Claude, GitHub Copilot, VS Code, and other MCP clients
+- Automatic project setup with `.mcp-on-rails/` directory structure
+- Comprehensive documentation and usage examples
+
+### Credits
+- Inspired by and adapted from [claude-on-rails](https://github.com/obie/claude-on-rails) by Obie Fernandez

data/README.md

@@ -0,0 +1,152 @@
+# MCP on Rails
+
+MCP on Rails provides pre-configured Model Context Protocol (MCP) settings, specialized prompts, and templates for Rails development with AI assistants like Claude, GitHub Copilot, and other MCP-compatible tools.
+
+> 🙏 **Acknowledgments**: This project is inspired by and adapted from [claude-on-rails](https://github.com/obie/claude-on-rails) by Obie Fernandez. The original prompts and swarm configuration have been restructured for broader MCP compatibility.
+
+## Features
+
+- 🧠 **Specialized AI Prompts** - Context-aware prompts for different Rails components (models, controllers, views, etc.)
+- ⚙️ **MCP Configuration** - Ready-to-use MCP server configuration for Rails projects  
+- 🚀 **Quick Setup** - One command to set up AI assistance for your Rails project
+- 🔧 **Customizable** - Templates that adapt to your project structure
+- 📚 **Best Practices** - Built-in Rails conventions and best practices
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mcp-on-rails'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install mcp-on-rails
+```
+
+## Usage
+
+### Quick Setup
+
+In your Rails project directory, run:
+
+```bash
+$ mcp-on-rails
+```
+
+This will create:
+- `.mcp-on-rails/` directory with configuration and prompts
+- `bin/mcp-setup` executable for project-specific setup
+- MCP configuration file optimized for Rails development
+
+### Manual Setup
+
+You can also set up programmatically:
+
+```ruby
+require 'mcp/on/rails'
+
+Mcp::On::Rails.setup(
+  project_name: "MyRailsApp",
+  project_path: "/path/to/rails/project"
+)
+```
+
+### What Gets Created
+
+```
+your-rails-project/
+├── .mcp-on-rails/
+│   ├── mcp-config.yml      # MCP server configuration
+│   ├── context.md          # Project context for AI
+│   └── prompts/            # Specialized prompts for each area
+│       ├── architect.md    # Overall architecture guidance
+│       ├── models.md       # ActiveRecord and database
+│       ├── controllers.md  # HTTP handling and routing
+│       ├── views.md        # Templates and frontend
+│       ├── stimulus.md     # JavaScript and Turbo
+│       ├── jobs.md         # Background processing
+│       ├── tests.md        # Testing strategies
+│       └── devops.md       # Deployment and infrastructure
+└── bin/
+    └── mcp-setup          # Project setup script
+```
+
+## MCP Client Configuration
+
+### VS Code with GitHub Copilot
+
+1. Install the MCP extension for VS Code
+2. Configure your workspace settings:
+
+```json
+{
+  "mcp.configPath": ".mcp-on-rails/mcp-config.yml"
+}
+```
+
+### Claude Desktop
+
+Add to your Claude Desktop configuration:
+
+```json
+{
+  "mcpServers": {
+    "rails": {
+      "command": "rails-mcp-server",
+      "env": {
+        "RAILS_ENV": "development"
+      }
+    }
+  }
+}
+```
+
+### Other MCP Clients
+
+The generated `mcp-config.yml` is compatible with most MCP clients. Refer to your client's documentation for specific configuration steps.
+
+## Context Areas
+
+MCP on Rails organizes your Rails project into specialized context areas:
+
+- **Architect** - Overall project coordination and architecture decisions
+- **Models** - ActiveRecord models, migrations, database design
+- **Controllers** - HTTP handling, routing, authentication, APIs
+- **Views** - Templates, layouts, partials, frontend components
+- **Stimulus** - JavaScript behavior, Turbo integration
+- **Jobs** - Background processing, queues, scheduled tasks  
+- **Tests** - Testing strategies, factories, test coverage
+- **DevOps** - Deployment, infrastructure, environment configuration
+
+Each area includes specialized prompts that help AI assistants understand the context and provide more relevant suggestions.
+
+## Customization
+
+After running the setup, you can customize:
+
+1. **Project-specific prompts** - Edit files in `.mcp-on-rails/prompts/`
+2. **MCP configuration** - Modify `.mcp-on-rails/mcp-config.yml`
+3. **Context information** - Update `.mcp-on-rails/context.md`
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/GoCoder7/mcp-on-rails.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/exe/mcp-on-rails

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "mcp/on/rails"
+require "optparse"
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: mcp-on-rails [options]"
+
+  opts.on("-n", "--name NAME", "Project name (defaults to current directory name)") do |name|
+    options[:project_name] = name
+  end
+
+  opts.on("-p", "--path PATH", "Project path (defaults to current directory)") do |path|
+    options[:project_path] = path
+  end
+
+  opts.on("-h", "--help", "Prints this help") do
+    puts opts
+    exit
+  end
+
+  opts.on("-v", "--version", "Show version") do
+    puts Mcp::On::Rails::VERSION
+    exit
+  end
+end.parse!
+
+puts "🚀 Setting up MCP on Rails..."
+puts ""
+
+Mcp::On::Rails.setup(
+  project_name: options[:project_name],
+  project_path: options[:project_path] || "."
+)

data/lib/mcp/on/rails/generator.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "erb"
+require "fileutils"
+
+module Mcp
+  module On
+    module Rails
+      class Generator
+        attr_reader :project_name, :project_path
+
+        def initialize(project_name: nil, project_path: ".")
+          @project_name = project_name || File.basename(File.expand_path(project_path))
+          @project_path = File.expand_path(project_path)
+        end
+
+        def generate
+          create_mcp_directory
+          copy_prompts
+          generate_config_file
+          copy_context_file
+          create_executable
+          puts "✅ MCP on Rails setup completed for '#{project_name}'"
+          puts "📁 Files created in: #{File.join(project_path, '.mcp-on-rails')}"
+          puts "🚀 Run: ./bin/mcp-setup to configure your project"
+        end
+
+        private
+
+        def create_mcp_directory
+          mcp_dir = File.join(project_path, ".mcp-on-rails")
+          FileUtils.mkdir_p(mcp_dir)
+        end
+
+        def copy_prompts
+          source_prompts = File.join(templates_path, "prompts")
+          target_prompts = File.join(project_path, ".mcp-on-rails", "prompts")
+          FileUtils.cp_r(source_prompts, target_prompts)
+        end
+
+        def generate_config_file
+          template_file = File.join(templates_path, "mcp-config.yml.erb")
+          target_file = File.join(project_path, ".mcp-on-rails", "mcp-config.yml")
+          
+          template = ERB.new(File.read(template_file))
+          content = template.result(binding)
+          
+          File.write(target_file, content)
+        end
+
+        def copy_context_file
+          source_file = File.join(templates_path, "context.md")
+          target_file = File.join(project_path, ".mcp-on-rails", "context.md")
+          FileUtils.cp(source_file, target_file)
+        end
+
+        def create_executable
+          bin_dir = File.join(project_path, "bin")
+          FileUtils.mkdir_p(bin_dir)
+          
+          executable_content = <<~SCRIPT
+            #!/usr/bin/env ruby
+            # frozen_string_literal: true
+            
+            puts "🔧 Setting up MCP on Rails for #{project_name}"
+            puts "📋 Configuration files are ready in .mcp-on-rails/"
+            puts ""
+            puts "Next steps:"
+            puts "1. Configure your MCP client to use .mcp-on-rails/mcp-config.yml"
+            puts "2. Use the prompts in .mcp-on-rails/prompts/ for context-aware AI assistance"
+            puts "3. Customize the configuration as needed for your project"
+          SCRIPT
+          
+          executable_path = File.join(bin_dir, "mcp-setup")
+          File.write(executable_path, executable_content)
+          FileUtils.chmod(0o755, executable_path)
+        end
+
+        def templates_path
+          File.join(__dir__, "templates")
+        end
+      end
+    end
+  end
+end

data/lib/mcp/on/rails/templates/context.md

@@ -0,0 +1,27 @@
+# ClaudeOnRails Context
+
+This project uses ClaudeOnRails with a swarm of specialized agents for Rails development.
+
+## Project Information
+- **Rails Version**: 8.0.2
+- **Ruby Version**: 3.4.4
+- **Project Type**: Full-stack Rails
+- **Test Framework**: Minitest
+- **Turbo/Stimulus**: Enabled
+
+## Swarm Configuration
+
+The claude-swarm.yml file defines specialized agents for different aspects of Rails development:
+- Each agent has specific expertise and works in designated directories
+- Agents collaborate to implement features across all layers
+- The architect agent coordinates the team
+
+## Development Guidelines
+
+When working on this project:
+- Follow Rails conventions and best practices
+- Write tests for all new functionality
+- Use strong parameters in controllers
+- Keep models focused with single responsibilities
+- Extract complex business logic to service objects
+- Ensure proper database indexing for foreign keys and queries

data/lib/mcp/on/rails/templates/mcp-config.yml.erb

@@ -0,0 +1,96 @@
+# MCP on Rails Configuration
+# This file configures Model Context Protocol settings for Rails development
+# Compatible with various MCP clients including Claude, GitHub Copilot, and VS Code extensions
+
+project:
+  name: "<%= project_name %>"
+  type: "rails"
+  description: "Rails application with MCP-optimized AI assistance"
+
+# MCP Server Configuration
+mcp:
+  servers:
+    rails:
+      type: stdio
+      command: rails-mcp-server
+      args: []
+      env:
+        RAILS_ENV: development
+
+# Context Areas for AI Assistance
+contexts:
+  architect:
+    description: "Rails architect coordinating full-stack development"
+    directory: "."
+    focus: "overall architecture, coordination, best practices"
+    prompts:
+      - ".mcp-on-rails/prompts/architect.md"
+
+  models:
+    description: "ActiveRecord models, migrations, and database optimization"
+    directory: "./app/models"
+    focus: "data modeling, associations, validations, queries"
+    prompts:
+      - ".mcp-on-rails/prompts/models.md"
+
+  controllers:
+    description: "Rails controllers, routing, and request handling"
+    directory: "./app/controllers"
+    focus: "HTTP handling, routing, authentication, API design"
+    prompts:
+      - ".mcp-on-rails/prompts/controllers.md"
+
+  views:
+    description: "Rails views, layouts, partials, and frontend"
+    directory: "./app/views"
+    focus: "templating, UI components, responsive design"
+    related_contexts: ["stimulus"]
+    prompts:
+      - ".mcp-on-rails/prompts/views.md"
+
+  stimulus:
+    description: "Stimulus.js controllers and frontend interactivity"
+    directory: "./app/javascript"
+    focus: "JavaScript behavior, Turbo integration, DOM manipulation"
+    prompts:
+      - ".mcp-on-rails/prompts/stimulus.md"
+
+  jobs:
+    description: "Background jobs, ActiveJob, and async processing"
+    directory: "./app/jobs"
+    focus: "background processing, queues, scheduled tasks"
+    prompts:
+      - ".mcp-on-rails/prompts/jobs.md"
+
+  tests:
+    description: "Testing strategy, factories, and test coverage"
+    directory: "./test"
+    focus: "unit tests, integration tests, test-driven development"
+    prompts:
+      - ".mcp-on-rails/prompts/tests.md"
+
+  devops:
+    description: "Deployment, Docker, CI/CD, and production configuration"
+    directory: "./config"
+    focus: "deployment, infrastructure, environment configuration"
+    prompts:
+      - ".mcp-on-rails/prompts/devops.md"
+
+# Tool Configuration
+tools:
+  allowed:
+    - file_operations  # read, write, edit files
+    - terminal         # run commands
+    - search          # grep, find, search codebase
+    - analysis        # code analysis, linting
+    - testing         # run tests, generate test data
+
+# AI Assistant Guidelines
+guidelines:
+  - "Follow Rails conventions and best practices"
+  - "Use semantic file organization"
+  - "Prioritize readability and maintainability"
+  - "Consider performance implications"
+  - "Ensure proper error handling"
+  - "Write comprehensive tests"
+  - "Document complex logic"

data/lib/mcp/on/rails/templates/prompts/api.md

@@ -0,0 +1,201 @@
+# Rails API Specialist
+
+You are a Rails API specialist working in the app/controllers/api directory. Your expertise covers RESTful API design, serialization, and API best practices.
+
+## Core Responsibilities
+
+1. **RESTful Design**: Implement clean, consistent REST APIs
+2. **Serialization**: Efficient data serialization and response formatting
+3. **Versioning**: API versioning strategies and implementation
+4. **Authentication**: Token-based auth, JWT, OAuth implementation
+5. **Documentation**: Clear API documentation and examples
+
+## API Controller Best Practices
+
+### Base API Controller
+```ruby
+class Api::BaseController < ActionController::API
+  include ActionController::HttpAuthentication::Token::ControllerMethods
+
+  before_action :authenticate
+
+  rescue_from ActiveRecord::RecordNotFound, with: :not_found
+  rescue_from ActiveRecord::RecordInvalid, with: :unprocessable_entity
+
+  private
+
+  def authenticate
+    authenticate_or_request_with_http_token do |token, options|
+      @current_user = User.find_by(api_token: token)
+    end
+  end
+
+  def not_found(exception)
+    render json: { error: exception.message }, status: :not_found
+  end
+
+  def unprocessable_entity(exception)
+    render json: { errors: exception.record.errors }, status: :unprocessable_entity
+  end
+end
+```
+
+### RESTful Actions
+```ruby
+class Api::V1::ProductsController < Api::BaseController
+  def index
+    products = Product.page(params[:page]).per(params[:per_page])
+    render json: products, meta: pagination_meta(products)
+  end
+
+  def show
+    product = Product.find(params[:id])
+    render json: product
+  end
+
+  def create
+    product = Product.new(product_params)
+
+    if product.save
+      render json: product, status: :created
+    else
+      render json: { errors: product.errors }, status: :unprocessable_entity
+    end
+  end
+
+  private
+
+  def product_params
+    params.expect(product: [:name, :price, :description])
+  end
+end
+```
+
+## Serialization Patterns
+
+### Using ActiveModel::Serializers
+```ruby
+class ProductSerializer < ActiveModel::Serializer
+  attributes :id, :name, :price, :description, :created_at
+
+  has_many :reviews
+  belongs_to :category
+
+  def price
+    "$#{object.price}"
+  end
+end
+```
+
+### JSON Response Structure
+```json
+{
+  "data": {
+    "id": "123",
+    "type": "products",
+    "attributes": {
+      "name": "Product Name",
+      "price": "$99.99"
+    },
+    "relationships": {
+      "category": {
+        "data": { "id": "1", "type": "categories" }
+      }
+    }
+  },
+  "meta": {
+    "total": 100,
+    "page": 1,
+    "per_page": 20
+  }
+}
+```
+
+## API Versioning
+
+### URL Versioning
+```ruby
+namespace :api do
+  namespace :v1 do
+    resources :products
+  end
+
+  namespace :v2 do
+    resources :products
+  end
+end
+```
+
+### Header Versioning
+```ruby
+class Api::BaseController < ActionController::API
+  before_action :set_api_version
+
+  private
+
+  def set_api_version
+    @api_version = request.headers['API-Version'] || 'v1'
+  end
+end
+```
+
+## Authentication Strategies
+
+### JWT Implementation
+```ruby
+class Api::AuthController < Api::BaseController
+  skip_before_action :authenticate, only: [:login]
+
+  def login
+    user = User.find_by(email: params[:email])
+
+    if user&.authenticate(params[:password])
+      token = encode_token(user_id: user.id)
+      render json: { token: token, user: user }
+    else
+      render json: { error: 'Invalid credentials' }, status: :unauthorized
+    end
+  end
+
+  private
+
+  def encode_token(payload)
+    JWT.encode(payload, Rails.application.secrets.secret_key_base)
+  end
+end
+```
+
+## Error Handling
+
+### Consistent Error Responses
+```ruby
+def render_error(message, status = :bad_request, errors = nil)
+  response = { error: message }
+  response[:errors] = errors if errors.present?
+  render json: response, status: status
+end
+```
+
+## Performance Optimization
+
+1. **Pagination**: Always paginate large collections
+2. **Caching**: Use HTTP caching headers
+3. **Query Optimization**: Prevent N+1 queries
+4. **Rate Limiting**: Implement request throttling
+
+## API Documentation
+
+### Using annotations
+```ruby
+# @api public
+# @method GET
+# @url /api/v1/products
+# @param page [Integer] Page number
+# @param per_page [Integer] Items per page
+# @response 200 {Array<Product>} List of products
+def index
+  # ...
+end
+```
+
+Remember: APIs should be consistent, well-documented, secure, and performant. Follow REST principles and provide clear error messages.