claude-on-rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7d19830990a00a04cfd82d77d58b90a9c14360c12b7b3d621943a5619accbaee
+  data.tar.gz: 00b360935625d1a968f65d37eb14d6d0e6e938de659ff7dccefdee960a15e336
+SHA512:
+  metadata.gz: 6624ad97cb7329398feb4f36cf546d53773ec55d12df72476889a2341edb713170d7ea4f85e40900cb03fa4eea520aed950afe81986f6d9924979b12ed38c3ce
+  data.tar.gz: 10bc654a1de63174c784d75200f0df617612b01e83f9ed93a08cb1d0a5447a4b3707034778a0ab8803f2217bd5e33e4a421a45592141e713164372806a4c8bdf

data/.rspec

@@ -0,0 +1,3 @@
+--require spec_helper
+--format documentation
+--color

data/CHANGELOG.md

@@ -0,0 +1,26 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2025-01-26
+
+### Added
+- Initial release of ClaudeOnRails
+- Rails generator for creating swarm configurations
+- Project structure analyzer to detect Rails patterns
+- Intelligent agent topology based on project type
+- Support for API-only and full-stack Rails applications
+- Agent-specific prompts for different Rails domains
+- Integration with claude-swarm for orchestration
+- Automatic detection of testing frameworks (RSpec/Minitest)
+- GraphQL and Turbo/Stimulus detection
+- Customizable swarm configurations
+
+### Architecture
+- Leverages claude-swarm instead of manual persona management
+- Agents work in specific directories (MVC separation)
+- Automatic task delegation based on context
+- Natural language interface for development tasks

data/CONTRIBUTING.md

@@ -0,0 +1,152 @@
+# Contributing to ClaudeOnRails
+
+We love your input! We want to make contributing to ClaudeOnRails as easy and transparent as possible, whether it's:
+
+- Reporting a bug
+- Discussing the current state of the code
+- Submitting a fix
+- Proposing new features
+- Becoming a maintainer
+
+## We Develop with Github
+
+We use GitHub to host code, to track issues and feature requests, as well as accept pull requests.
+
+## We Use [Github Flow](https://guides.github.com/introduction/flow/index.html)
+
+Pull requests are the best way to propose changes to the codebase:
+
+1. Fork the repo and create your branch from `main`.
+2. If you've added code that should be tested, add tests.
+3. If you've changed APIs, update the documentation.
+4. Ensure the test suite passes.
+5. Make sure your code lints.
+6. Issue that pull request!
+
+## Any contributions you make will be under the MIT Software License
+
+In short, when you submit code changes, your submissions are understood to be under the same [MIT License](http://choosealicense.com/licenses/mit/) that covers the project.
+
+## Report bugs using Github's [issues](https://github.com/obie/claude-on-rails/issues)
+
+We use GitHub issues to track public bugs. Report a bug by [opening a new issue](https://github.com/obie/claude-on-rails/issues/new).
+
+**Great Bug Reports** tend to have:
+
+- A quick summary and/or background
+- Steps to reproduce
+  - Be specific!
+  - Give sample code if you can
+- What you expected would happen
+- What actually happens
+- Notes (possibly including why you think this might be happening, or stuff you tried that didn't work)
+
+## Development Setup
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/obie/claude-on-rails.git
+   cd claude-on-rails
+   ```
+
+2. Install dependencies:
+   ```bash
+   bundle install
+   ```
+
+3. Run tests:
+   ```bash
+   bundle exec rspec
+   ```
+
+4. Run linting:
+   ```bash
+   bundle exec rubocop
+   ```
+
+## Testing Your Changes
+
+Before submitting a PR, test your changes in a real Rails project:
+
+1. Create a test Rails app:
+   ```bash
+   rails new test_app
+   cd test_app
+   ```
+
+2. Add your local gem:
+   ```ruby
+   # Gemfile
+   gem 'claude-on-rails', path: '/path/to/your/claude-on-rails'
+   ```
+
+3. Run the generator:
+   ```bash
+   bundle install
+   rails generate claude_on_rails:swarm
+   ```
+
+4. Verify the generated files work correctly
+
+## Code Style
+
+We use RuboCop with Rails-specific cops. Please ensure your code passes linting:
+
+```bash
+bundle exec rubocop
+```
+
+To auto-fix issues:
+```bash
+bundle exec rubocop -a
+```
+
+## Adding New Agent Types
+
+If you want to add a new specialized agent:
+
+1. Add detection logic to `ProjectAnalyzer`
+2. Update `SwarmBuilder` to include the new agent
+3. Create a prompt template in `lib/generators/claude_on_rails/swarm/templates/prompts/`
+4. Update the generator to handle the new agent type
+5. Add tests for your changes
+
+Example:
+```ruby
+# In project_analyzer.rb
+def has_action_cable?
+  File.exist?(File.join(root_path, 'app', 'channels'))
+end
+
+# In swarm_builder.rb
+if project_analysis[:has_action_cable]
+  instances[:channels] = build_channels_agent
+end
+```
+
+## Improving Agent Prompts
+
+Agent prompts are crucial for swarm effectiveness. When improving prompts:
+
+1. Keep them focused on their specific domain
+2. Include Rails best practices
+3. Add examples of good patterns
+4. Specify what they should NOT do
+5. Test with real-world scenarios
+
+## Documentation
+
+- Update README.md for user-facing changes
+- Add examples to the examples/ directory
+- Update CHANGELOG.md following [Keep a Changelog](https://keepachangelog.com/)
+- Use YARD format for code documentation
+
+## Pull Request Process
+
+1. Update the README.md with details of changes to the interface
+2. Update the CHANGELOG.md with your changes
+3. The PR will be merged once you have the sign-off of at least one maintainer
+
+## Questions?
+
+Feel free to open an issue for any questions about contributing!

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in claude-on-rails.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+gem "rspec", "~> 3.0"

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Obie Fernandez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,180 @@
+# ClaudeOnRails
+
+A Rails development framework that leverages [claude-swarm](https://github.com/parruda/claude-swarm) to create an intelligent team of AI agents specialized in different aspects of Rails development.
+
+Instead of managing personas manually, ClaudeOnRails automatically orchestrates a swarm of specialized agents that work together like a real development team. Simply describe what you want to build, and the swarm handles the rest.
+
+## How It Works
+
+ClaudeOnRails creates a team of specialized AI agents:
+
+- **Architect**: Coordinates development and makes high-level decisions
+- **Models**: Handles ActiveRecord, migrations, and database design
+- **Controllers**: Manages routing and request handling
+- **Views**: Creates UI templates and manages assets
+- **Services**: Implements business logic and service objects
+- **Tests**: Ensures comprehensive test coverage
+- **DevOps**: Handles deployment and infrastructure
+
+Each agent works in their specific domain (directory) and can collaborate with other agents to implement complex features.
+
+## Installation
+
+Add to your Rails application's Gemfile:
+
+```ruby
+group :development do
+  gem 'claude-on-rails'
+end
+```
+
+Then run:
+
+```bash
+bundle install
+rails generate claude_on_rails:swarm
+```
+
+This will:
+- Analyze your Rails project structure
+- Generate a customized swarm configuration
+- Create agent-specific prompts
+- Set up your development environment
+
+## Usage
+
+### Start Your Development Swarm
+
+```bash
+# In your Rails project directory
+claude-swarm orchestrate
+```
+
+### Natural Language Development
+
+Once the swarm is running, just describe what you want to build in the Claude interface:
+
+```
+> Add user authentication with email confirmation
+[The architect coordinates the implementation across all agents]
+
+> Create a shopping cart with Stripe payment integration
+[Complex features are automatically broken down and implemented]
+
+> Optimize the dashboard - it's loading too slowly
+[Performance improvements across the stack]
+
+> Build a RESTful API for our mobile app with JWT auth
+[API development with authentication]
+```
+
+The swarm automatically:
+- Analyzes your request
+- Delegates to appropriate specialists
+- Implements across all layers (models, controllers, views, tests)
+- Follows Rails best practices
+- Ensures test coverage
+
+## How It's Different
+
+### Traditional Rails Development with AI
+When using AI assistants for Rails development, you typically need to:
+- Manually coordinate different aspects of implementation
+- Switch contexts between models, controllers, views, and tests
+- Ensure consistency across different parts of your application
+- Remember to implement tests, security, and performance considerations
+
+### ClaudeOnRails Approach
+With ClaudeOnRails, you simply describe what you want in natural language:
+```
+> Create a user system with social login
+```
+
+The swarm automatically:
+- Creates models with proper validations and associations
+- Implements controllers with authentication logic
+- Builds views with forms and UI components
+- Adds comprehensive test coverage
+- Handles security considerations
+- Optimizes database queries
+
+All coordinated by specialized agents working together.
+
+## Project Structure
+
+After running the generator, you'll have:
+
+```
+your-rails-app/
+├── swarm.yml                    # Swarm configuration
+├── CLAUDE.md                    # Project-specific Claude config
+└── .claude-on-rails/
+    └── prompts/                 # Agent-specific prompts
+        ├── architect.md
+        ├── models.md
+        ├── controllers.md
+        └── ...
+```
+
+## Customization
+
+### Swarm Configuration
+
+The generated `swarm.yml` can be customized:
+
+```yaml
+instances:
+  architect:
+    description: "Your project-specific architect description"
+    connections: [models, controllers, custom_agent]
+  
+  custom_agent:
+    description: "Specialized agent for your domain"
+    directory: ./app/custom
+    prompt_file: .claude-on-rails/prompts/custom.md
+```
+
+### Agent Prompts
+
+Customize agent behavior by editing prompts in `.claude-on-rails/prompts/`:
+- Add project-specific conventions
+- Include domain knowledge
+- Define coding standards
+
+## Features
+
+- **Automatic Agent Selection**: No need to choose which persona to use
+- **Collaborative Implementation**: Agents work together like a real team
+- **Rails-Aware**: Deep understanding of Rails conventions and best practices
+- **Project Adaptation**: Detects your project structure and adapts accordingly
+- **Test-Driven**: Automatic test generation for all code
+- **Performance Focus**: Built-in optimization capabilities
+
+## Requirements
+
+- Ruby 2.7+
+- Rails 6.0+
+- [claude-swarm](https://github.com/parruda/claude-swarm) gem
+- Claude Code CLI
+
+## Examples
+
+See the [examples](./examples) directory for:
+- E-commerce platform development
+- API-only applications
+- Real-time features with Turbo/Stimulus
+- Performance optimization workflows
+
+## Contributing
+
+We welcome contributions! Please see [CONTRIBUTING.md](./CONTRIBUTING.md) for guidelines.
+
+## License
+
+MIT License - see [LICENSE](./LICENSE) for details.
+
+## Acknowledgments
+
+- Powered by [claude-swarm](https://github.com/parruda/claude-swarm)
+- Built for [Claude Code](https://github.com/anthropics/claude-code)
+- Integrates with [Rails MCP Server](https://github.com/mariochavez/rails-mcp-server)

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/claude-on-rails.gemspec

@@ -0,0 +1,45 @@
+require_relative "lib/claude_on_rails/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "claude-on-rails"
+  spec.version = ClaudeOnRails::VERSION
+  spec.authors = ["Obie Fernandez"]
+  spec.email = ["obiefernandez@gmail.com"]
+
+  spec.summary = "Rails development framework powered by Claude swarm intelligence"
+  spec.description = "ClaudeOnRails leverages claude-swarm to create an intelligent team of AI agents specialized in different aspects of Rails development. Simply describe what you want to build, and the swarm handles the rest."
+  spec.homepage = "https://github.com/obie/claude-on-rails"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.7.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor .github])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Runtime dependencies
+  spec.add_dependency "rails", ">= 6.0"
+  spec.add_dependency "claude-swarm", "~> 0.1"
+  
+  # Development dependencies
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rspec-rails", "~> 5.0"
+  spec.add_development_dependency "rubocop", "~> 1.0"
+  spec.add_development_dependency "rubocop-rails", "~> 2.0"
+  spec.add_development_dependency "rubocop-rspec", "~> 2.0"
+  
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/examples/README.md

@@ -0,0 +1,165 @@
+# ClaudeOnRails Examples
+
+This directory contains examples of using ClaudeOnRails in different scenarios.
+
+## Basic E-commerce Example
+
+```bash
+# In your Rails project
+bundle add claude-on-rails --group development
+rails generate claude_on_rails:swarm
+
+# Start the swarm
+claude-swarm orchestrate
+```
+
+Once the swarm is running, in the Claude interface:
+```
+> Create a product catalog with categories and search
+> Add a shopping cart that persists between sessions  
+> Implement checkout with Stripe payment processing
+> Add order history and tracking for customers
+```
+
+## API Development Example
+
+```bash
+# For an API-only Rails app
+rails new my_api --api
+cd my_api
+bundle add claude-on-rails --group development
+rails generate claude_on_rails:swarm
+
+claude-swarm orchestrate
+```
+
+Then in the Claude interface:
+```
+> Create a RESTful API for a task management system
+> Add JWT authentication with refresh tokens
+> Implement rate limiting per API key
+> Add GraphQL endpoint for complex queries
+```
+
+## Performance Optimization Example
+
+In an existing Rails app with performance issues:
+```bash
+claude-swarm orchestrate
+```
+
+Then describe the performance issues:
+```
+> The dashboard is loading slowly with 500ms+ response times
+
+The swarm will:
+- Analyze database queries (Models agent)
+- Optimize controller actions (Controllers agent)
+- Implement caching strategies (Services agent)
+- Add performance tests (Tests agent)
+
+> Users report the search feature times out with large datasets
+[Automatic optimization across the stack]
+```
+
+## Real-time Features Example
+
+After starting the swarm:
+```
+> Add real-time notifications when users receive messages
+> Create a live-updating dashboard with WebSocket updates
+> Implement collaborative editing for documents
+```
+
+## Test-Driven Development Example
+
+Building features test-first:
+```
+> Create a user registration system with email verification - write tests first
+
+The swarm will:
+1. Tests agent writes comprehensive specs
+2. Models agent creates User model to pass tests
+3. Controllers agent implements registration flow
+4. Services agent handles email verification logic
+5. Tests agent ensures 100% coverage
+```
+
+## Custom Agent Example
+
+If your project has unique requirements, you can add custom agents:
+
+```yaml
+# swarm.yml
+instances:
+  analytics:
+    description: "Analytics and reporting specialist"
+    directory: ./app/analytics
+    model: claude-3-5-haiku-20250110
+    allowed_tools: [Read, Edit, Write, Bash, Grep, Glob, LS]
+    prompt_file: .claude-on-rails/prompts/analytics.md
+    
+  architect:
+    connections: [models, controllers, analytics] # Add to connections
+```
+
+Then in Claude:
+```
+> Create a comprehensive analytics dashboard with export capabilities
+```
+
+## Debugging Workflow Example
+
+When encountering errors:
+```
+> NoMethodError in ProductsController#show - undefined method 'category' for nil:NilClass
+
+The swarm will:
+- Identify the error location
+- Trace through the code path
+- Fix the nil check
+- Add tests to prevent regression
+- Suggest defensive programming practices
+```
+
+## Migration and Refactoring Example
+
+For large-scale refactoring:
+```
+> Refactor our fat User model - it has 500+ lines and 30+ methods
+
+Coordinated refactoring:
+- Architect plans the refactoring strategy
+- Services agent extracts business logic
+- Models agent keeps data integrity
+- Tests agent ensures nothing breaks
+- All changes are incremental and safe
+```
+
+## Tips for Best Results
+
+1. **Be specific about requirements**
+   ```
+   Good:
+   > Create user authentication with email/password, remember me, and password reset
+   
+   Less effective:
+   > Add login
+   ```
+
+2. **Provide context for complex features**
+   ```
+   > We're building a SaaS app. Add multi-tenant support with subdomain isolation
+   ```
+
+3. **Mention constraints or preferences**
+   ```
+   > Build an admin panel using our existing ViewComponent architecture
+   ```
+
+4. **Ask for specific approaches**
+   ```
+   > Implement caching using Redis for our product recommendations
+   ```
+
+Remember: The swarm works best when you describe what you want to achieve, not how to implement it. Let the specialized agents handle the implementation details!

data/lib/claude_on_rails/configuration.rb

@@ -0,0 +1,21 @@
+module ClaudeOnRails
+  class Configuration
+    attr_accessor :default_model, :vibe_mode, :session_directory, :log_directory
+    
+    def initialize
+      @default_model = "claude-3-5-haiku-20250110"
+      @vibe_mode = true
+      @session_directory = ".claude-on-rails/sessions"
+      @log_directory = ".claude-on-rails/logs"
+    end
+    
+    def to_h
+      {
+        default_model: default_model,
+        vibe_mode: vibe_mode,
+        session_directory: session_directory,
+        log_directory: log_directory
+      }
+    end
+  end
+end