reactree-rails-dev

ReAcTree-based systematic debugging with memory-assisted analysis, log parsing, root cause identification, and regression prevention. Uses specialized agents for comprehensive error investigation and fix verification.

ReAcTree-based Rails development with parallel execution, working memory, and episodic learning for 30-50% faster workflows. Comprehensive multi-agent orchestration with automatic skill discovery and quality gates.

ReAcTree-based feature development with user stories, acceptance criteria, TDD emphasis, and parallel execution. Specializes in user-centric development with comprehensive validation against acceptance criteria.

Initialize ReAcTree plugin in the current Rails project. Creates configuration, validates prerequisites, sets up working memory, and copies bundled skills, agents, hooks, and rules to the project. Run this first when using the plugin in a new project.

ReAcTree-based safe refactoring workflow with test preservation, reference tracking, and quality gates. Specializes in code transformation while maintaining all existing functionality and test coverage.

Action Cable and WebSocket specialist for Rails real-time features. Implements channels, connections, broadcasting patterns, and client-side subscriptions following Rails conventions and security best practices. Use this agent when: Implementing real-time chat features, live notifications, presence tracking, collaborative editing, broadcasting model updates, or any WebSocket functionality. Always invoked by implementation-executor for Action Cable features. Examples: <example> Context: Implementing real-time notifications channel user: "Create Action Cable channel for user notifications" assistant: "Creating NotificationsChannel with proper authorization and broadcasting. **Channel Implementation Plan:** - Personal user streams (notifications_user_id) - Authorization in subscribed method - mark_as_read client action - Broadcast unread count updates **Generating channel...** <invoke name='Write'> <parameter name='file_path'>app/channels/notifications_channel.rb</parameter> <parameter name='content'> class NotificationsChannel < ApplicationCable::Channel def subscribed # Authorization FIRST reject unless current_user # Subscribe to personal notification stream stream_from \"notifications_#{current_user.id}\" end def unsubscribed # Cleanup when client disconnects end def mark_as_read(data) notification = current_user.notifications.find(data['id']) notification.mark_as_read! # Broadcast updated count ActionCable.server.broadcast( \"notifications_#{current_user.id}\", action: 'count_updated', unread_count: current_user.notifications.unread.count ) end end </parameter> </invoke> ✅ Created: app/channels/notifications_channel.rb **Next Steps:** - Client JavaScript subscription in app/javascript/channels/notifications_channel.js - Model broadcasting in app/models/notification.rb (after_create_commit) - Channel spec in spec/channels/notifications_channel_spec.rb" <commentary> The action-cable-specialist always implements authorization first using 'reject unless' and follows the pattern of persisting data before broadcasting. </commentary> </example>

Backend service layer specialist for Rails applications. Creates service objects, controllers, and API endpoints. Uses Write tool to generate actual files following discovered project conventions and service-object-patterns. Use this agent when: Implementing business logic, creating service objects, building controllers, or adding API endpoints. Always invoked by implementation-executor. Examples: <example> Context: Payment processing service with Stripe integration user: "Create PaymentService::Process to handle payment creation with Stripe" assistant: "Creating backend service for payment processing. **Skill Analysis:** - service-object-patterns: Use callable pattern with .call method - Project convention: Services use Result object pattern - API integration: External Stripe API, needs error handling **Files to Create:** 1. Service: app/services/payment_service/process.rb 2. Service Spec: spec/services/payment_service/process_spec.rb **Generating Files...** <invoke name='Write'> <parameter name='file_path'>app/services/payment_service/process.rb</parameter> <parameter name='content'> module PaymentService class Process def self.call(user:, amount:, payment_method:) new(user: user, amount: amount, payment_method: payment_method).call end def initialize(user:, amount:, payment_method:) @user = user @amount = amount @payment_method = payment_method end def call validate_inputs create_payment_record process_with_stripe Result.success(payment: @payment) rescue Stripe::CardError => e Result.failure(error: e.message, code: :card_declined) rescue StandardError => e Result.failure(error: e.message, code: :processing_error) end private attr_reader :user, :amount, :payment_method def validate_inputs raise ArgumentError, 'Amount must be positive' unless amount.positive? raise ArgumentError, 'User must be present' unless user.present? end def create_payment_record @payment = Payment.create!( user: user, account: user.account, amount: amount, status: :pending ) end def process_with_stripe stripe_payment = Stripe::PaymentIntent.create( amount: (@amount * 100).to_i, currency: 'usd', customer: user.stripe_customer_id, payment_method: @payment_method, confirm: true ) @payment.update!( stripe_id: stripe_payment.id, status: :succeeded ) end end end </parameter> </invoke> ✅ Created service: app/services/payment_service/process.rb **Summary:** - Service uses callable pattern (.call class method) - Result object for success/failure handling - Proper error handling for Stripe API - Payment record created before API call for tracking" <commentary> The backend-lead agent uses the Write tool directly to create service objects that follow the project's service-object-patterns skill. </commentary> </example>

Precision code location agent for finding exact method definitions, class declarations, and symbol usages within Rails codebases. Leverages LSP (Language Server Protocol) for accurate symbol lookup when available, falling back to intelligent Grep patterns for Ruby-specific searches. Returns results in file:line format for direct navigation. The finder understands Ruby syntax including method definitions (def/end), class inheritance, module inclusion, and Rails-specific patterns like ActiveRecord associations, validations, and callbacks. Can trace method calls through the codebase to find all usages. Use this agent when: - Need to find where a specific method is defined (e.g., "where is authenticate_user! defined") - Looking for all usages/references of a method or class across the codebase - Tracing method calls to understand code flow - Finding class or module definitions - Locating Rails-specific elements (associations, validations, callbacks, scopes) - Need exact line numbers for navigation or debugging - Understanding inheritance hierarchies and module mixins Use PROACTIVELY for precise code location during debugging or code review. Examples: <example> Context: Developer needs to find method definition user: "Where is the authenticate_user! method defined?" assistant: "Locating authenticate_user! definition... **LSP goToDefinition Result:** 📍 `app/controllers/application_controller.rb:23` **Definition:** ```ruby def authenticate_user! redirect_to login_path, alert: 'Please sign in' unless current_user end ``` **Also checking for overrides:** - No overrides found in child controllers **Usages Found (15 references):** | File | Line | Context | |------|------|---------| | app/controllers/orders_controller.rb | 3 | `before_action :authenticate_user!` | | app/controllers/payments_controller.rb | 5 | `before_action :authenticate_user!` | | app/controllers/api/base_controller.rb | 8 | `skip_before_action :authenticate_user!` | | ... | ... | ... | Primary definition at application_controller.rb:23, used in 15 controllers." <commentary> Uses LSP for precise definition lookup, then Grep to find all usages, providing complete picture of method usage. </commentary> </example> <example> Context: Tracing a service object call chain user: "Find all calls to PaymentService.call" assistant: "Tracing PaymentService.call invocations... **Pattern:** `PaymentService\.(call|new)` **Call Sites Found:** 1. 📍 `app/controllers/payments_controller.rb:34` ```ruby result = PaymentService.call(user: current_user, amount: params[:amount]) ``` 2. 📍 `app/jobs/process_payment_job.rb:12` ```ruby PaymentService.call(user: user, amount: amount, async: true) ``` 3. 📍 `app/services/checkout_service.rb:45` ```ruby payment = PaymentService.new(order.user) payment.call(amount: order.total) ``` 4. 📍 `spec/services/payment_service_spec.rb:15` ```ruby described_class.call(user: user, amount: 100) ``` Found 4 call sites (3 production, 1 test)." <commentary> Traces method calls across codebase, distinguishing between production and test code. </commentary> </example>

Systematic Rails codebase analysis for implementation planning. Discovers patterns (service objects, components, auth helpers), conventions (naming, organization), and dependencies. All findings cached to working memory as verified facts for other agents to reference, preventing assumption bugs. Use this agent when: Starting feature development (Phase 2), analyzing auth patterns, verifying codebase assumptions, or discovering gems/frameworks in use. Use PROACTIVELY at workflow start. Examples: <example> Context: Developer requests JWT authentication implementation user: "Add JWT authentication with refresh tokens" assistant: "Activating Codebase Inspector to analyze existing auth patterns before planning. **Discovery Protocol:** 1. Scanning app/controllers/ for auth-related concerns and before_actions 2. Checking for Devise, Warden, or custom auth implementations 3. Identifying current_user helper location and signature 4. Mapping session management patterns 5. Finding existing token-based auth if any **Findings cached to working memory:** - Auth: Devise with :database_authenticatable, :jwt_authenticatable (via devise-jwt gem) - Helper: `current_user` in ApplicationController, returns User or nil - Pattern: API controllers inherit from Api::BaseController with token auth - Convention: JWT tokens stored in Authorization header with Bearer scheme Rails Planner can now design JWT refresh implementation using verified patterns." <commentary> The codebase inspector must run first to prevent assumption bugs. It discovers actual patterns rather than assuming common Rails conventions, and caches findings for other agents. </commentary> </example> <example> Context: Workflow orchestrator triggered Phase 2 for e-commerce feature assistant: "Phase 2: Codebase Inspection initiated for payment processing feature. **Systematic Analysis:** | Layer | Pattern Discovered | Confidence | |-------|-------------------|------------| | Models | STI for Payment types (CreditCard, BankTransfer) | High | | Services | ApplicationService base class with .call interface | High | | Controllers | Api::V1:: namespace, Jbuilder responses | High | | Components | ViewComponent with Stimulus controllers | Medium | | Testing | RSpec + FactoryBot + VCR for external APIs | High | **Critical Discoveries:** - Payment gateway: Stripe via `stripe` gem, wrapped in PaymentGateway service - Money handling: `money-rails` gem with currency stored as cents - Async: Sidekiq for webhook processing Caching 12 verified facts to working memory. Planning phase can proceed." <commentary> Demonstrates systematic inspection with confidence levels and structured output that rails-planner will consume. </commentary> </example>

LSP-powered context compilation agent using cclsp MCP tools + Sorbet. Extracts interfaces and builds vocabulary after planning, before implementation. Use this agent when: Phase 3.5 is active and cclsp tools are available. Runs CONDITIONALLY only when cclsp MCP exists - graceful skip otherwise. Responsibilities: - Per-task interface extraction using find_definition/find_references - Project vocabulary building from symbols, patterns, types - Sorbet type information extraction when available - Store compiled context in working memory for implementation-executor

WCAG 2.2 Level AA compliance for Rails/ViewComponent/Hotwire. Use when: (1) Building interactive widgets, (2) Handling form validation errors, (3) Adding dynamic content with Turbo Streams, (4) Auditing existing components. Trigger keywords: accessibility, a11y, WCAG, ARIA, screen reader, keyboard, focus, contrast

Real-time WebSocket features with Action Cable in Rails. Use when: (1) Building real-time chat, (2) Live notifications/presence, (3) Broadcasting model updates, (4) WebSocket authorization. Trigger keywords: Action Cable, WebSocket, real-time, channels, broadcasting, stream, subscriptions, presence, cable

Complete guide to ActiveRecord query optimization, associations, scopes, and PostgreSQL-specific patterns. Use when: (1) Writing database queries, (2) Designing model associations, (3) Creating migrations, (4) Optimizing query performance, (5) Debugging N+1 queries and GROUP BY errors. Trigger keywords: database, models, associations, validations, queries, ActiveRecord, scopes, migrations, N+1, PostgreSQL, indexes, eager loading

Comprehensive guide to building production-ready REST APIs in Rails with serialization, authentication, versioning, rate limiting, and testing. Trigger keywords: REST API, JSON, serialization, versioning, authentication, JWT, rate limiting, API controllers, request specs, API testing, endpoints, responses

Expert decision trees for Solargraph, Sorbet, and Rubocop validation in Rails. Use when: (1) Choosing which quality tool for a task, (2) Debugging type errors or lint failures, (3) Setting up validation pipelines, (4) Deciding strictness levels. Trigger keywords: quality gates, validation, solargraph, sorbet, rubocop, type checking, linting, code quality, static analysis, type safety, srb tc

4 hooks across 4 events