claude-on-rails 0.1.0

data/lib/claude_on_rails/project_analyzer.rb

@@ -0,0 +1,159 @@
+module ClaudeOnRails
+  class ProjectAnalyzer
+    attr_reader :root_path
+    
+    def initialize(root_path)
+      @root_path = root_path
+    end
+    
+    def analyze
+      {
+        api_only: api_only?,
+        test_framework: detect_test_framework,
+        has_graphql: has_graphql?,
+        has_turbo: has_turbo?,
+        has_devise: has_devise?,
+        has_sidekiq: has_sidekiq?,
+        javascript_framework: detect_javascript_framework,
+        database: detect_database,
+        deployment: detect_deployment_method,
+        custom_patterns: detect_custom_patterns
+      }
+    end
+    
+    private
+    
+    def api_only?
+      application_rb = File.join(root_path, 'config', 'application.rb')
+      return false unless File.exist?(application_rb)
+      
+      File.read(application_rb).include?('config.api_only = true')
+    end
+    
+    def detect_test_framework
+      if File.exist?(File.join(root_path, 'spec'))
+        'RSpec'
+      elsif File.exist?(File.join(root_path, 'test'))
+        'Minitest'
+      else
+        nil
+      end
+    end
+    
+    def has_graphql?
+      gemfile_path = File.join(root_path, 'Gemfile')
+      return false unless File.exist?(gemfile_path)
+      
+      gemfile_content = File.read(gemfile_path)
+      gemfile_content.include?('graphql') || 
+        File.exist?(File.join(root_path, 'app', 'graphql'))
+    end
+    
+    def has_turbo?
+      gemfile_path = File.join(root_path, 'Gemfile')
+      return false unless File.exist?(gemfile_path)
+      
+      gemfile_content = File.read(gemfile_path)
+      gemfile_content.include?('turbo-rails') || 
+        gemfile_content.include?('stimulus-rails') ||
+        File.exist?(File.join(root_path, 'app', 'javascript', 'controllers'))
+    end
+    
+    def has_devise?
+      gemfile_path = File.join(root_path, 'Gemfile')
+      return false unless File.exist?(gemfile_path)
+      
+      File.read(gemfile_path).include?('devise')
+    end
+    
+    def has_sidekiq?
+      gemfile_path = File.join(root_path, 'Gemfile')
+      return false unless File.exist?(gemfile_path)
+      
+      File.read(gemfile_path).include?('sidekiq')
+    end
+    
+    def detect_javascript_framework
+      package_json = File.join(root_path, 'package.json')
+      return 'importmap' unless File.exist?(package_json)
+      
+      content = File.read(package_json)
+      case
+      when content.include?('webpack')
+        'webpack'
+      when content.include?('esbuild')
+        'esbuild'
+      when content.include?('vite')
+        'vite'
+      else
+        'importmap'
+      end
+    end
+    
+    def detect_database
+      database_yml = File.join(root_path, 'config', 'database.yml')
+      return 'sqlite3' unless File.exist?(database_yml)
+      
+      content = File.read(database_yml)
+      case
+      when content.include?('postgresql')
+        'postgresql'
+      when content.include?('mysql2')
+        'mysql'
+      when content.include?('sqlite3')
+        'sqlite3'
+      else
+        'unknown'
+      end
+    end
+    
+    def detect_deployment_method
+      # Check for various deployment configurations
+      return 'kubernetes' if File.exist?(File.join(root_path, 'k8s')) ||
+                            File.exist?(File.join(root_path, 'kubernetes'))
+      return 'docker' if File.exist?(File.join(root_path, 'Dockerfile'))
+      return 'capistrano' if File.exist?(File.join(root_path, 'Capfile'))
+      return 'heroku' if File.exist?(File.join(root_path, 'Procfile'))
+      return 'kamal' if File.exist?(File.join(root_path, 'config', 'deploy.yml'))
+      
+      'unknown'
+    end
+    
+    def detect_custom_patterns
+      patterns = {}
+      
+      # Check for service objects
+      if File.directory?(File.join(root_path, 'app', 'services'))
+        patterns[:has_services] = true
+      end
+      
+      # Check for form objects
+      if File.directory?(File.join(root_path, 'app', 'forms'))
+        patterns[:has_forms] = true
+      end
+      
+      # Check for presenters/decorators
+      if File.directory?(File.join(root_path, 'app', 'presenters')) ||
+         File.directory?(File.join(root_path, 'app', 'decorators'))
+        patterns[:has_presenters] = true
+      end
+      
+      # Check for query objects
+      if File.directory?(File.join(root_path, 'app', 'queries'))
+        patterns[:has_queries] = true
+      end
+      
+      # Check for policies (authorization)
+      if File.directory?(File.join(root_path, 'app', 'policies'))
+        patterns[:has_policies] = true
+      end
+      
+      # Check for serializers
+      if File.directory?(File.join(root_path, 'app', 'serializers'))
+        patterns[:has_serializers] = true
+      end
+      
+      patterns
+    end
+  end
+end

data/lib/claude_on_rails/swarm_builder.rb

@@ -0,0 +1,192 @@
+module ClaudeOnRails
+  class SwarmBuilder
+    attr_reader :project_analysis
+    
+    def initialize(project_analysis)
+      @project_analysis = project_analysis
+    end
+    
+    def build
+      {
+        version: 1,
+        swarm: {
+          name: "Rails Development Team",
+          main: "architect",
+          instances: build_instances
+        }
+      }
+    end
+    
+    private
+    
+    def build_instances
+      instances = {}
+      
+      # Always include architect
+      instances[:architect] = build_architect
+      
+      # Core agents
+      instances[:models] = build_models_agent
+      instances[:controllers] = build_controllers_agent
+      
+      # Conditional agents
+      unless project_analysis[:api_only]
+        instances[:views] = build_views_agent
+      end
+      
+      if project_analysis[:api_only]
+        instances[:api] = build_api_agent
+      end
+      
+      if project_analysis[:has_graphql]
+        instances[:graphql] = build_graphql_agent
+      end
+      
+      if project_analysis[:has_turbo] && !project_analysis[:api_only]
+        instances[:stimulus] = build_stimulus_agent
+      end
+      
+      # Supporting agents
+      instances[:services] = build_services_agent
+      instances[:jobs] = build_jobs_agent
+      
+      if project_analysis[:test_framework]
+        instances[:tests] = build_tests_agent
+      end
+      
+      instances[:devops] = build_devops_agent
+      
+      instances
+    end
+    
+    def build_architect
+      connections = ["models", "controllers"]
+      connections << "views" unless project_analysis[:api_only]
+      connections << "api" if project_analysis[:api_only]
+      connections << "graphql" if project_analysis[:has_graphql]
+      connections << "services"
+      connections << "jobs"
+      connections << "tests" if project_analysis[:test_framework]
+      connections << "devops"
+      
+      {
+        description: "Rails architect coordinating #{project_analysis[:api_only] ? 'API' : 'full-stack'} development",
+        directory: ".",
+        model: ClaudeOnRails.configuration.default_model,
+        connections: connections,
+        prompt_file: ".claude-on-rails/prompts/architect.md",
+        vibe: ClaudeOnRails.configuration.vibe_mode
+      }
+    end
+    
+    def build_models_agent
+      {
+        description: "ActiveRecord models, migrations, and database optimization specialist",
+        directory: "./app/models",
+        model: ClaudeOnRails.configuration.default_model,
+        allowed_tools: %w[Read Edit Write Bash Grep Glob LS],
+        prompt_file: ".claude-on-rails/prompts/models.md"
+      }
+    end
+    
+    def build_controllers_agent
+      connections = ["services"]
+      connections << "api" if project_analysis[:api_only]
+      
+      {
+        description: "Rails controllers, routing, and request handling specialist",
+        directory: "./app/controllers",
+        model: ClaudeOnRails.configuration.default_model,
+        connections: connections.empty? ? nil : connections,
+        allowed_tools: %w[Read Edit Write Bash Grep Glob LS],
+        prompt_file: ".claude-on-rails/prompts/controllers.md"
+      }.compact
+    end
+    
+    def build_views_agent
+      connections = []
+      connections << "stimulus" if project_analysis[:has_turbo]
+      
+      {
+        description: "Rails views, layouts, partials, and asset pipeline specialist",
+        directory: "./app/views",
+        model: ClaudeOnRails.configuration.default_model,
+        connections: connections.empty? ? nil : connections,
+        allowed_tools: %w[Read Edit Write Bash Grep Glob LS],
+        prompt_file: ".claude-on-rails/prompts/views.md"
+      }.compact
+    end
+    
+    def build_api_agent
+      {
+        description: "RESTful API design, serialization, and versioning specialist",
+        directory: "./app/controllers/api",
+        model: ClaudeOnRails.configuration.default_model,
+        allowed_tools: %w[Read Edit Write Bash Grep Glob LS],
+        prompt_file: ".claude-on-rails/prompts/api.md"
+      }
+    end
+    
+    def build_graphql_agent
+      {
+        description: "GraphQL schema, resolvers, and mutations specialist",
+        directory: "./app/graphql",
+        model: ClaudeOnRails.configuration.default_model,
+        allowed_tools: %w[Read Edit Write Bash Grep Glob LS],
+        prompt_file: ".claude-on-rails/prompts/graphql.md"
+      }
+    end
+    
+    def build_stimulus_agent
+      {
+        description: "Stimulus.js controllers and Turbo integration specialist",
+        directory: "./app/javascript",
+        model: ClaudeOnRails.configuration.default_model,
+        allowed_tools: %w[Read Edit Write Bash Grep Glob LS],
+        prompt_file: ".claude-on-rails/prompts/stimulus.md"
+      }
+    end
+    
+    def build_services_agent
+      {
+        description: "Service objects, business logic, and design patterns specialist",
+        directory: "./app/services",
+        model: ClaudeOnRails.configuration.default_model,
+        allowed_tools: %w[Read Edit Write Bash Grep Glob LS],
+        prompt_file: ".claude-on-rails/prompts/services.md"
+      }
+    end
+    
+    def build_jobs_agent
+      {
+        description: "Background jobs, ActiveJob, and async processing specialist",
+        directory: "./app/jobs",
+        model: ClaudeOnRails.configuration.default_model,
+        allowed_tools: %w[Read Edit Write Bash Grep Glob LS],
+        prompt_file: ".claude-on-rails/prompts/jobs.md"
+      }
+    end
+    
+    def build_tests_agent
+      test_dir = project_analysis[:test_framework] == 'RSpec' ? './spec' : './test'
+      
+      {
+        description: "#{project_analysis[:test_framework]} testing, factories, and test coverage specialist",
+        directory: test_dir,
+        model: ClaudeOnRails.configuration.default_model,
+        allowed_tools: %w[Read Edit Write Bash Grep Glob LS],
+        prompt_file: ".claude-on-rails/prompts/tests.md"
+      }
+    end
+    
+    def build_devops_agent
+      {
+        description: "Deployment, Docker, CI/CD, and production configuration specialist",
+        directory: "./config",
+        model: ClaudeOnRails.configuration.default_model,
+        allowed_tools: %w[Read Edit Write Bash Grep Glob LS],
+        prompt_file: ".claude-on-rails/prompts/devops.md"
+      }
+    end
+  end
+end

data/lib/claude_on_rails/version.rb

@@ -0,0 +1,3 @@
+module ClaudeOnRails
+  VERSION = "0.1.0"
+end

data/lib/claude_on_rails.rb

@@ -0,0 +1,25 @@
+require "claude_on_rails/version"
+require "claude_on_rails/configuration"
+require "claude_on_rails/project_analyzer"
+require "claude_on_rails/swarm_builder"
+
+module ClaudeOnRails
+  class Error < StandardError; end
+  
+  class << self
+    attr_accessor :configuration
+    
+    def configure
+      self.configuration ||= Configuration.new
+      yield(configuration) if block_given?
+    end
+    
+    def analyze_project(root_path = Rails.root)
+      ProjectAnalyzer.new(root_path).analyze
+    end
+    
+    def build_swarm(project_analysis)
+      SwarmBuilder.new(project_analysis).build
+    end
+  end
+end

data/lib/generators/claude_on_rails/swarm/swarm_generator.rb

@@ -0,0 +1,91 @@
+require "rails/generators/base"
+
+module ClaudeOnRails
+  module Generators
+    class SwarmGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+      
+      class_option :api_only, type: :boolean, default: false,
+                   desc: "Generate swarm for API-only Rails application"
+      
+      class_option :skip_tests, type: :boolean, default: false,
+                   desc: "Skip test agent in swarm configuration"
+                   
+      class_option :graphql, type: :boolean, default: false,
+                   desc: "Include GraphQL specialist agent"
+                   
+      class_option :turbo, type: :boolean, default: true,
+                   desc: "Include Turbo/Stimulus specialist agents"
+      
+      def analyze_project
+        say "Analyzing Rails project structure...", :green
+        @project_analysis = ClaudeOnRails.analyze_project(Rails.root)
+        
+        # Auto-detect features
+        @api_only = options[:api_only] || @project_analysis[:api_only]
+        @has_graphql = options[:graphql] || @project_analysis[:has_graphql]
+        @has_turbo = options[:turbo] && !@api_only
+        @skip_tests = options[:skip_tests]
+        @test_framework = @project_analysis[:test_framework]
+        
+        say "Project type: #{@api_only ? 'API-only' : 'Full-stack Rails'}", :cyan
+        say "Test framework: #{@test_framework}", :cyan if @test_framework
+        say "GraphQL detected: #{@has_graphql ? 'Yes' : 'No'}", :cyan
+      end
+      
+      def create_swarm_config
+        say "Generating swarm configuration...", :green
+        template "swarm.yml.erb", "swarm.yml"
+      end
+      
+      def create_claude_md
+        say "Creating CLAUDE.md configuration...", :green
+        template "CLAUDE.md.erb", "CLAUDE.md"
+      end
+      
+      def create_agent_prompts
+        say "Setting up agent-specific prompts...", :green
+        directory "prompts", ".claude-on-rails/prompts"
+      end
+      
+      def update_gitignore
+        say "Updating .gitignore...", :green
+        append_to_file ".gitignore", "\n# ClaudeOnRails\n.claude-on-rails/sessions/\nswarm.log\n"
+      end
+      
+      def display_next_steps
+        say "\n✅ ClaudeOnRails swarm configuration created!", :green
+        say "\nNext steps:", :yellow
+        say "1. Review and customize swarm.yml for your project"
+        say "2. Install claude-swarm if not already installed:"
+        say "   gem install claude-swarm", :cyan
+        say "3. Start your Rails development swarm:"
+        say "   claude-swarm orchestrate", :cyan
+        say "\nExample usage:"
+        say '   claude "Add user authentication with social login"', :cyan
+        say "\nThe swarm will automatically coordinate the implementation across all layers!"
+      end
+      
+      private
+      
+      def agents
+        @agents ||= build_agent_list
+      end
+      
+      def build_agent_list
+        list = ["architect"]
+        list << "models" 
+        list << "controllers"
+        list << "views" unless @api_only
+        list << "api" if @api_only
+        list << "graphql" if @has_graphql
+        list << "stimulus" if @has_turbo
+        list << "services"
+        list << "jobs"
+        list << "tests" unless @skip_tests
+        list << "devops"
+        list
+      end
+    end
+  end
+end

data/lib/generators/claude_on_rails/swarm/templates/CLAUDE.md.erb

@@ -0,0 +1,101 @@
+# <%= Rails.application.class.module_parent_name %> Rails Development with ClaudeOnRails
+
+This project uses ClaudeOnRails to create an intelligent swarm of AI agents specialized in different aspects of Rails development.
+
+## Project Overview
+
+- **Application**: <%= Rails.application.class.module_parent_name %>
+- **Rails Version**: <%= Rails.version %>
+- **Ruby Version**: <%= RUBY_VERSION %>
+- **Type**: <%= @api_only ? 'API-only' : 'Full-stack Rails application' %>
+- **Test Framework**: <%= @test_framework || 'Not detected' %>
+<% if @has_graphql -%>
+- **GraphQL**: Enabled
+<% end -%>
+
+## How to Use
+
+Simply describe what you want to build or fix, and the swarm will automatically coordinate the implementation:
+
+```bash
+# Start the swarm
+claude-swarm orchestrate
+
+# Then just describe your task
+claude "Add user authentication with email confirmation"
+claude "Optimize the dashboard queries that are running slowly"
+claude "Create an API endpoint for mobile app integration"
+```
+
+## Swarm Architecture
+
+The following specialized agents work together to implement your requests:
+
+- **Architect**: Coordinates all development and makes high-level decisions
+- **Models**: Handles ActiveRecord models, migrations, and database design
+- **Controllers**: Manages request handling, routing, and controller logic
+<% unless @api_only -%>
+- **Views**: Creates and maintains views, layouts, and partials
+<% end -%>
+<% if @api_only -%>
+- **API**: Designs RESTful endpoints and handles serialization
+<% end -%>
+<% if @has_graphql -%>
+- **GraphQL**: Manages GraphQL schemas, types, and resolvers
+<% end -%>
+<% if @has_turbo -%>
+- **Stimulus**: Implements interactive features with Stimulus controllers
+<% end -%>
+- **Services**: Extracts business logic into service objects
+- **Jobs**: Handles background processing and async tasks
+<% unless @skip_tests -%>
+- **Tests**: Ensures comprehensive test coverage with <%= @test_framework %>
+<% end -%>
+- **DevOps**: Manages deployment and production configurations
+
+## Project Conventions
+
+### Code Style
+- Follow Rails conventions and best practices
+- Use RuboCop for Ruby style enforcement
+- Prefer clarity over cleverness
+- Write self-documenting code
+
+### Testing
+<% if @test_framework == 'RSpec' -%>
+- RSpec for all tests
+- Factory Bot for test data
+- Request specs for API endpoints
+- System specs for user interactions
+<% else -%>
+- Minitest for all tests
+- Fixtures or factories for test data
+- Integration tests for user flows
+- Unit tests for models and services
+<% end -%>
+
+### Git Workflow
+- Feature branches for new work
+- Descriptive commit messages
+- PR reviews before merging
+- Keep main branch deployable
+
+## Custom Patterns
+
+Add your project-specific patterns and conventions here:
+
+```yaml
+# Example: Custom service object pattern
+Services:
+  Pattern: Command pattern with Result objects
+  Location: app/services/
+  Naming: VerbNoun (e.g., CreateOrder, SendEmail)
+  Testing: Unit tests with mocked dependencies
+```
+
+## Notes
+
+- This configuration was generated by ClaudeOnRails
+- Customize agent prompts in `.claude-on-rails/prompts/`
+- Update this file with project-specific conventions
+- The swarm learns from your codebase patterns

data/lib/generators/claude_on_rails/swarm/templates/prompts/architect.md

@@ -0,0 +1,48 @@
+# Rails Architect Agent
+
+You are the lead Rails architect coordinating development across a team of specialized agents. Your role is to:
+
+## Primary Responsibilities
+
+1. **Understand Requirements**: Analyze user requests and break them down into actionable tasks
+2. **Coordinate Implementation**: Delegate work to appropriate specialist agents
+3. **Ensure Best Practices**: Enforce Rails conventions and patterns across the team
+4. **Maintain Architecture**: Keep the overall system design coherent and scalable
+
+## Your Team
+
+You coordinate the following specialists:
+- **Models**: Database schema, ActiveRecord models, migrations
+- **Controllers**: Request handling, routing, API endpoints
+- **Views**: UI templates, layouts, assets (if not API-only)
+- **Services**: Business logic, service objects, complex operations
+- **Tests**: Test coverage, specs, test-driven development
+- **DevOps**: Deployment, configuration, infrastructure
+
+## Decision Framework
+
+When receiving a request:
+1. Analyze what needs to be built or fixed
+2. Identify which layers of the Rails stack are involved
+3. Plan the implementation order (typically: models → controllers → views/services → tests)
+4. Delegate to appropriate specialists with clear instructions
+5. Synthesize their work into a cohesive solution
+
+## Rails Best Practices
+
+Always ensure:
+- RESTful design principles
+- DRY (Don't Repeat Yourself)
+- Convention over configuration
+- Test-driven development
+- Security by default
+- Performance considerations
+
+## Communication Style
+
+- Be clear and specific when delegating to specialists
+- Provide context about the overall feature being built
+- Ensure specialists understand how their work fits together
+- Summarize the complete implementation for the user
+
+Remember: You're the conductor of the Rails development orchestra. Your job is to ensure all parts work in harmony to deliver high-quality Rails applications.