roast-ai 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4f94565fdc94547f9ab2fa57b401930d189c2e63f5f31897165a07cf6828b10d
-  data.tar.gz: '068450417abc06ed7fb98af7c36ec972d6671b23e0e85cfdadde8a934c327fdc'
+  metadata.gz: 0c0f1a837c5dafcaecb8443e93a4076c11566f1c3bea1d6835121628fbdf79a7
+  data.tar.gz: ab3679b374486831cbf90ab3a259178d48d4e53d5d5dbdc2a2d43537399e4ca9
 SHA512:
-  metadata.gz: 07e5a581c469a37d3f0371627c92ef0b465cfeb5e977a90221a3cdb7783193de7a1c6600df3b1235705ef65e0e76f566bf88730621172314d3bc0ba70adc5dc4
-  data.tar.gz: 12e7ae70eee847f11eac8c4e593e11b5a94c0574634254a559d41d006e8fac01dc7b7c26fa2ba1a80fc13de0172ac810ff390e8bda2555e96489c0385f815537
+  metadata.gz: 3061d9f04b7f886e3a6d588eb729e10062f6310d5973c7ed5181975f27a385c20d8ff8880ecb7e61abd54dfbd87795211313e1c9a6d2a630269d7c4559ae7cae
+  data.tar.gz: 7962e4991590700003f3f8a827435214ef9aa90fa4324d34d3b421f11d5f647e43663e17189a0b43f81d6fa124bbf68a269f9674a493994832b9ab5c03f192a6

data/.gitignore

@@ -40,3 +40,4 @@ bin/ruby-rewrite
 bin/thor
 
 gemfiles/*.lock
+bin/claude-swarm

data/CHANGELOG.md

@@ -5,6 +5,26 @@ 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.4.0] - 2025-06-12
+
+### Added
+- **Input step type** for collecting user input during workflow execution (#154)
+  - Interactive prompts pause workflow execution to collect user input
+  - Supports multiple input types: `text` (default), `confirm`, `select`, and `password`
+  - `confirm` type provides yes/no prompts with boolean results
+  - `select` type allows choosing from a list of options
+  - `password` type masks input for sensitive data using io/console
+  - Input values are stored in workflow output and accessible via dot notation (e.g., `{{output.step_name}}`)
+  - Integrates with CLI::UI for consistent formatting and user experience
+- **Agent step type** for direct pass-through to coding agents (#151)
+  - Steps prefixed with `^` send prompts directly to the CodingAgent tool
+  - Supports both file-based and inline agent prompts
+  - Bypasses LLM interpretation for precise agent instructions
+
+### Fixed
+- DotAccessHash array wrapping and template response handling
+- CLI::UI formatting and color handling for better terminal output
+
 ## [0.3.1] - 2025-06-05
 
 ### Added

data/CLAUDE.md

@@ -4,6 +4,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## About the codebase
 - This is a Ruby gem called Roast. Its purpose is to run AI workflows defined in a YAML file.
+- Note that this project now uses Zeitwerk, which means you don't have to manually require project files anymore
 
 ## Commands
 
@@ -51,11 +52,14 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
   - ConditionalExecutor handles conditionals (if, unless)
   - Don't combine different responsibilities in one class
 - **Do not implement prompts "inline" using a prompt: attribute nested under step names, that violates the primary design architecture of Roast**
+- When faced with the choice between working around an architectural issue or code smell versus actually diving into fixing the design issue or code smell, choose the latter more principled approach
+- When fixing code smells, you don't have to worry about internal backwards compatibility 
 
 ## Guidance and Expectations
 
 - Do not decide unilaterally to leave code for the sake of "backwards compatibility"... always run those decisions by me first.
 - Don't ever commit and push changes unless directly told to do so
+- You can't test input steps yourself, ask me to do it
 
 ## Git Workflow Practices
 
@@ -130,6 +134,48 @@ gh pr view {pr_number}
 gh pr diff {pr_number}
 ```
 
+### Issue Labeling and Project Management
+
+When creating GitHub issues, always check available labels, projects, and milestones first:
+
+```bash
+# List all available labels
+gh api repos/Shopify/roast/labels | jq '.[].name'
+
+# List all milestones
+gh api repos/Shopify/roast/milestones | jq '.[] | {title: .title, number: .number, state: .state}'
+
+# List projects linked to the roast repository
+gh api graphql -f query='
+{
+  repository(owner: "Shopify", name: "roast") {
+    projectsV2(first: 10) {
+      nodes {
+        title
+        number
+        url
+      }
+    }
+  }
+}' --jq '.data.repository.projectsV2.nodes[] | {title: .title, number: .number, url: .url}'
+```
+
+**Issue Creation Workflow**:
+1. First check what labels exist and apply appropriate ones when creating the issue
+2. After creating the issue, ask the user if they want it added to an existing milestone
+3. Ask the user if they want it added to a particular project board
+
+```bash
+# Create issue with labels
+gh api repos/Shopify/roast/issues -X POST -F title="Issue Title" -F body="Issue description" -F 'labels=["bug", "enhancement"]'
+
+# Add issue to a milestone (after creation)
+gh api repos/Shopify/roast/issues/{issue_number} -X PATCH -F milestone={milestone_number}
+
+# Add issue to a GitHub Project
+gh project item-add {project_number} --url https://github.com/Shopify/roast/issues/{issue_number}
+```
+
 #### Formatting Tips for GitHub API
 1. Use literal newlines in the body text instead of `\n` escape sequences
 2. When formatting is stripped (like backticks), use alternatives:
@@ -167,4 +213,9 @@ gh pr diff {pr_number}
     - Avoid premature optimization outside of hot paths
     - Consider the tradeoff between readability and performance
     - Suggest optimizations that improve both clarity and performance
-```
+
+## CLI::UI Formatting Tips
+- To apply color to terminal output using CLI::UI, use the following syntax:
+  ```ruby
+  puts ::CLI::UI.fmt("{{red:This field is required. Please provide a value.}}")
+  ```

data/Gemfile

@@ -8,7 +8,7 @@ git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
 gemspec
 
 gem "cgi"
-gem "cli-ui"
+gem "cli-ui", "2.3.0"
 gem "dotenv"
 gem "guard"
 gem "guard-minitest"
@@ -18,3 +18,5 @@ gem "rubocop-shopify", require: false
 gem "vcr", require: false
 gem "webmock", require: false
 gem "minitest-rg"
+
+gem "claude_swarm"

data/Gemfile.lock

@@ -1,15 +1,16 @@
 PATH
   remote: .
   specs:
-    roast-ai (0.3.1)
+    roast-ai (0.4.0)
       activesupport (>= 7.0)
-      cli-ui
+      cli-ui (= 2.3.0)
       diff-lcs (~> 1.5)
       faraday-retry
       json-schema
       open_router (~> 0.3)
       raix (~> 1.0)
       thor (~> 1.3)
+      zeitwerk (~> 2.6)
 
 GEM
   remote: https://rubygems.org/
@@ -33,17 +34,49 @@ GEM
     base64 (0.3.0)
     benchmark (0.4.1)
     bigdecimal (3.2.2)
-    cgi (0.4.2)
-    cli-ui (2.3.1)
+    cgi (0.5.0)
+    claude_swarm (0.1.15)
+      fast-mcp-annotations
+      thor (~> 1.3)
+    cli-ui (2.3.0)
     coderay (1.1.3)
     concurrent-ruby (1.3.5)
     connection_pool (2.5.3)
     crack (1.0.0)
       bigdecimal
       rexml
-    diff-lcs (1.6.1)
+    diff-lcs (1.6.2)
     dotenv (3.1.8)
     drb (2.2.3)
+    dry-configurable (1.3.0)
+      dry-core (~> 1.1)
+      zeitwerk (~> 2.6)
+    dry-core (1.1.0)
+      concurrent-ruby (~> 1.0)
+      logger
+      zeitwerk (~> 2.6)
+    dry-inflector (1.2.0)
+    dry-initializer (3.2.0)
+    dry-logic (1.6.0)
+      bigdecimal
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 1.1)
+      zeitwerk (~> 2.6)
+    dry-schema (1.14.1)
+      concurrent-ruby (~> 1.0)
+      dry-configurable (~> 1.0, >= 1.0.1)
+      dry-core (~> 1.1)
+      dry-initializer (~> 3.2)
+      dry-logic (~> 1.5)
+      dry-types (~> 1.8)
+      zeitwerk (~> 2.6)
+    dry-types (1.8.3)
+      bigdecimal (~> 3.0)
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 1.0)
+      dry-inflector (~> 1.0)
+      dry-logic (~> 1.4)
+      zeitwerk (~> 2.6)
     event_stream_parser (1.0.0)
     faraday (2.13.1)
       faraday-net_http (>= 2.0, < 3.5)
@@ -55,6 +88,13 @@ GEM
       net-http (>= 0.5.0)
     faraday-retry (2.3.1)
       faraday (~> 2.0)
+    fast-mcp-annotations (1.5.2)
+      addressable (~> 2.8)
+      base64
+      dry-schema (~> 1.14)
+      json (~> 2.0)
+      mime-types (~> 3.4)
+      rack (~> 3.1)
     ffi (1.17.2-arm64-darwin)
     ffi (1.17.2-x86_64-linux-gnu)
     formatador (1.1.0)
@@ -73,14 +113,14 @@ GEM
     guard-minitest (2.4.6)
       guard-compat (~> 1.2)
       minitest (>= 3.0)
-    hashdiff (1.1.2)
+    hashdiff (1.2.0)
     i18n (1.14.7)
       concurrent-ruby (~> 1.0)
     json (2.12.2)
     json-schema (5.1.1)
       addressable (~> 2.8)
       bigdecimal (~> 3.1)
-    language_server-protocol (3.17.0.4)
+    language_server-protocol (3.17.0.5)
     lint_roller (1.1.0)
     listen (3.9.0)
       rb-fsevent (~> 0.10, >= 0.10.3)
@@ -88,6 +128,10 @@ GEM
     logger (1.7.0)
     lumberjack (1.2.10)
     method_source (1.1.0)
+    mime-types (3.7.0)
+      logger
+      mime-types-data (~> 3.2025, >= 3.2025.0507)
+    mime-types-data (3.2025.0603)
     minitest (5.25.5)
     minitest-rg (5.3.0)
       minitest (~> 5.0)
@@ -114,22 +158,23 @@ GEM
     pry (0.15.2)
       coderay (~> 1.1)
       method_source (~> 1.0)
-    public_suffix (6.0.1)
+    public_suffix (6.0.2)
     racc (1.8.1)
+    rack (3.1.16)
     rainbow (3.1.1)
-    raix (1.0.0)
+    raix (1.0.1)
       activesupport (>= 6.0)
       faraday-retry (~> 2.0)
       open_router (~> 0.2)
       ostruct
       ruby-openai (~> 7)
-    rake (13.2.1)
+    rake (13.3.0)
     rb-fsevent (0.11.2)
     rb-inotify (0.11.1)
       ffi (~> 1.0)
     regexp_parser (2.10.0)
     rexml (3.4.1)
-    rubocop (1.75.3)
+    rubocop (1.76.0)
       json (~> 2.3)
       language_server-protocol (~> 3.17.0.2)
       lint_roller (~> 1.1.0)
@@ -137,13 +182,13 @@ GEM
       parser (>= 3.3.0.2)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 2.9.3, < 3.0)
-      rubocop-ast (>= 1.44.0, < 2.0)
+      rubocop-ast (>= 1.45.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 2.4.0, < 4.0)
-    rubocop-ast (1.44.1)
+    rubocop-ast (1.45.0)
       parser (>= 3.3.7.2)
       prism (~> 1.4)
-    rubocop-shopify (2.17.0)
+    rubocop-shopify (2.17.1)
       rubocop (~> 1.62)
     ruby-openai (7.4.0)
       event_stream_parser (>= 0.3.0, < 2.0.0)
@@ -166,14 +211,16 @@ GEM
       addressable (>= 2.8.0)
       crack (>= 0.3.2)
       hashdiff (>= 0.4.0, < 2.0.0)
+    zeitwerk (2.7.3)
 
 PLATFORMS
-  arm64-darwin-23
+  arm64-darwin
   x86_64-linux
 
 DEPENDENCIES
   cgi
-  cli-ui
+  claude_swarm
+  cli-ui (= 2.3.0)
   dotenv
   guard
   guard-minitest

data/README.md

@@ -82,13 +82,13 @@ steps:
 
 ## Try it
 
-If you don't have one already, get an OpenAI key from [here](https://platform.openai.com/settings/organization/api-keys). You will need an account with a credit card, make sure that a basic completion works.
+If you don’t have one already, get an OpenAI key from [here](https://platform.openai.com/settings/organization/api-keys). You will need an account with a credit card and credits applied to the associated project. Make sure that a basic completion works:
 
 ```bash
 export OPENAI_API_KEY=sk-proj-....
 
 curl -H "Content-Type: application/json" \
-    -H "Authorization: Bearer $API_TOKEN" \
+    -H "Authorization: Bearer $OPENAI_API_KEY" \
     -d '{"model":"gpt-4.1-mini","messages":[{"role":"user","content":"What is 1+1?"}]}' \
     https://api.openai.com/v1/chat/completions
 ```
@@ -270,6 +270,45 @@ Roast supports several types of steps:
    ```
    This creates a simple prompt-response interaction without tool calls or looping. It's detected by the presence of spaces in the step name and is useful for summarization or simple questions at the end of a workflow.
 
+8. **Agent step**: Direct pass-through to coding agents (e.g., Claude Code)
+   ```yaml
+   steps:
+     - ^fix_linting_errors                                    # File-based agent prompt
+     - ^Review the code and identify any performance issues   # Inline agent prompt
+     - regular_analysis                                       # Normal step through LLM
+   ```
+   Agent steps are prefixed with `^` and send the prompt content directly to the CodingAgent tool without LLM translation. This is useful when you want to give precise instructions to a coding agent without the intermediate interpretation layer. Agent steps support both file-based prompts (`fix_linting_errors/prompt.md`) and inline prompts (text with spaces).
+
+9. **Input step**: Interactive prompts for user input during workflow execution
+   ```yaml
+   steps:
+     - analyze_code
+     - get_user_feedback:
+         prompt: "Should we proceed with the refactoring? (yes/no)"
+         type: confirm
+     - review_changes:
+         prompt: "Enter your review comments"
+         type: text
+     - select_strategy:
+         prompt: "Choose optimization strategy"
+         type: select
+         options:
+           - "Performance optimization"
+           - "Memory optimization"
+           - "Code clarity"
+     - api_configuration:
+         prompt: "Enter API key"
+         type: password
+   ```
+   
+   Input steps pause workflow execution to collect user input. They support several types:
+   - `text`: Free-form text input (default if type not specified)
+   - `confirm`: Yes/No confirmation prompts
+   - `select`: Choice from a list of options
+   - `password`: Masked input for sensitive data
+   
+   The user's input is stored in the workflow output using the step name as the key and can be accessed in subsequent steps via interpolation (e.g., `{{output.get_user_feedback}}`).
+
 #### Step Configuration
 
 Steps can be configured with various options to control their behavior:
@@ -658,6 +697,52 @@ tools:
 
 Custom descriptions help the LLM understand when and how to use each command, making your workflows more effective.
 
+### Step-Level Tool Filtering
+
+You can restrict which tools are available to specific steps using the `available_tools` configuration:
+
+```yaml
+# Define all tools globally
+tools:
+  - Roast::Tools::Grep
+  - Roast::Tools::ReadFile
+  - Roast::Tools::WriteFile
+  - Roast::Tools::Cmd:
+      allowed_commands:
+        - pwd
+        - ls
+        - echo
+
+# Configure steps with specific tool access
+explore_directory:
+  available_tools:
+    - pwd
+    - ls
+
+analyze_files:
+  available_tools:
+    - grep
+    - read_file
+
+write_summary:
+  available_tools:
+    - write_file
+    - echo
+```
+
+This feature provides:
+- **Security**: Each step only has access to the tools it needs
+- **Performance**: Reduces the tool list sent to the LLM
+- **Clarity**: Makes tool usage explicit for each step
+
+Key points:
+- Use snake_case tool names (e.g., `read_file` for `Roast::Tools::ReadFile`)
+- For `Cmd` tool, use the specific command names (e.g., `pwd`, `ls`)
+- When `available_tools` is not specified, all tools remain available (backward compatible)
+- Empty array (`available_tools: []`) means no tools for that step
+
+See the [available_tools_demo](examples/available_tools_demo/) for a complete example.
+
 #### ReadFile
 
 Reads the contents of a file from the filesystem.
@@ -836,14 +921,14 @@ tools:
   - Documentation:
       url: https://gitmcp.io/myorg/myrepo/docs
       env:
-        - "Authorization: Bearer {{env.API_TOKEN}}"
+        - "Authorization: Bearer {{ENV['API_TOKEN']}}"
 
   # MCP tools with stdio
   - GitHub:
       command: npx
       args: ["-y", "@modelcontextprotocol/server-github"]
       env:
-        GITHUB_PERSONAL_ACCESS_TOKEN: "{{env.GITHUB_TOKEN}}"
+        GITHUB_PERSONAL_ACCESS_TOKEN: "{{ENV['GITHUB_TOKEN']}}"
       only:
         - search_repositories
         - get_issue
@@ -872,7 +957,7 @@ Connect to local processes implementing the MCP protocol:
     command: docker
     args: ["run", "-i", "--rm", "ghcr.io/example/mcp-server"]
     env:
-      API_KEY: "{{env.API_KEY}}"
+      API_KEY: "{{ENV['API_KEY']}}"
 ```
 
 See the [MCP tools example](examples/mcp/) for complete documentation and more examples.

data/bin/roast

@@ -8,7 +8,7 @@
 # this file is here to facilitate running it.
 #
 
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../.ruby-lsp/Gemfile", __dir__)
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
 
 bundle_binstub = File.expand_path("bundle", __dir__)
 

data/claude-swarm.yml

@@ -0,0 +1,210 @@
+version: 1
+swarm:
+  name: "Roast Development Team"
+  main: lead_developer
+  instances:
+    lead_developer:
+      description: "Lead developer coordinating Roast gem development"
+      directory: .
+      model: opus
+      vibe: true
+      connections: [test_runner, code_quality, raix_expert, solid_critic, github_expert]
+      prompt: |
+        You are the lead developer for Roast, a convention-oriented framework for creating structured AI workflows. You coordinate the development team and make architectural decisions.
+        
+        Your responsibilities:
+        - Coordinate feature development and bug fixes
+        - Review and integrate contributions from team members
+        - Ensure code consistency and project direction
+        - Make architectural decisions
+        - Manage the development workflow
+        
+        You have access to a specialized team:
+        - test_runner: Runs and analyzes test results
+        - code_quality: Ensures code quality standards
+        - raix_expert: Provides expertise on the Raix gem for AI chat completions
+        - solid_critic: Reviews code for SOLID principles compliance
+        - github_expert: Handles all GitHub-related operations
+        
+        When working on tasks:
+        1. Break down complex features into manageable pieces
+        2. Delegate specific aspects to appropriate team members
+        3. Integrate feedback and ensure all changes align with Roast's conventions
+        4. Always ensure tests pass before finalizing changes
+        
+        For maximum efficiency, whenever you need to perform multiple independent operations, invoke all relevant tools simultaneously rather than sequentially.
+    
+    test_runner:
+      description: "Test execution specialist for running and analyzing test results"
+      directory: .
+      model: sonnet
+      vibe: true
+      prompt: |
+        You are the test execution specialist for the Roast gem. Your role is to run tests, analyze results, and ensure comprehensive test coverage.
+        
+        Your responsibilities:
+        - Run the full test suite using `bundle exec rake test`
+        - Run specific tests when requested
+        - Analyze test failures and provide detailed diagnostics
+        - Identify missing test coverage
+        - Suggest new test cases for edge scenarios
+        - Verify that new features have appropriate tests
+        
+        When analyzing test results:
+        1. Clearly identify which tests are failing and why
+        2. Provide stack traces and relevant error messages
+        3. Suggest fixes for failing tests
+        4. Ensure tests follow RSpec best practices
+        5. Check for test isolation and avoid test interdependencies
+        
+        For maximum efficiency, whenever you need to perform multiple independent operations, invoke all relevant tools simultaneously rather than sequentially.
+    
+    code_quality:
+      description: "Code quality enforcer ensuring standards and best practices"
+      directory: .
+      model: sonnet
+      vibe: true
+      prompt: |
+        You are the code quality specialist for the Roast gem. Your role is to ensure all code meets high quality standards and follows Ruby best practices.
+        
+        Your responsibilities:
+        - Run RuboCop for style checking: `bundle exec rubocop`
+        - Apply automatic fixes when safe: `bundle exec rubocop -A`
+        - Check for code smells and anti-patterns
+        - Ensure proper documentation with YARD comments
+        - Verify consistent naming conventions
+        - Check for performance issues
+        - Ensure proper error handling
+        
+        Quality standards to enforce:
+        1. Ruby community style guide compliance
+        2. Clear and meaningful variable/method names
+        3. DRY (Don't Repeat Yourself) principle
+        4. Appropriate use of Ruby idioms
+        5. Proper exception handling with meaningful messages
+        6. Comprehensive inline documentation
+        
+        When reviewing code:
+        - Provide specific line numbers for issues
+        - Suggest concrete improvements
+        - Explain why changes improve quality
+        
+        For maximum efficiency, whenever you need to perform multiple independent operations, invoke all relevant tools simultaneously rather than sequentially.
+    
+    raix_expert:
+      description: "Expert on the Raix gem for AI chat completions integration"
+      directory: ~/src/github.com/OlympiaAI/raix
+      model: opus
+      vibe: true
+      prompt: |
+        You are the Raix gem expert, specializing in AI chat completion integrations. Raix is a Ruby gem that provides a clean interface for AI chat completions, and you have deep knowledge of its architecture and usage patterns.
+        
+        Your expertise includes:
+        - Raix's function dispatch pattern for tools
+        - Chat completion API abstractions
+        - Integration patterns with various AI providers
+        - Best practices for tool definitions
+        - Performance optimization for AI interactions
+        - Error handling in AI contexts
+        
+        When consulted about Roast's AI integration:
+        1. Provide guidance on proper Raix usage patterns
+        2. Suggest optimal ways to structure tool definitions
+        3. Help integrate new AI capabilities using Raix
+        4. Ensure Roast's tools follow Raix conventions
+        5. Optimize AI interaction performance
+        6. Review function definitions for clarity and effectiveness
+        
+        You have access to the Raix source code and can:
+        - Reference specific Raix implementation details
+        - Suggest patterns from Raix that could benefit Roast
+        - Ensure compatibility between Roast and Raix
+        - Provide examples of advanced Raix features
+        
+        For maximum efficiency, whenever you need to perform multiple independent operations, invoke all relevant tools simultaneously rather than sequentially.
+    
+    solid_critic:
+      description: "SOLID principles expert providing aggressive code critique"
+      directory: .
+      model: opus
+      vibe: true
+      prompt: |
+        You are a SOLID principles expert, channeling the expertise and style of Sandi Metz. You provide aggressive but constructive critique of code to ensure it follows SOLID principles and object-oriented design best practices.
+        
+        Your approach:
+        - Be direct and uncompromising about violations
+        - Provide specific examples of how to improve
+        - Reference Sandi Metz's rules for developers
+        - Focus on practical, maintainable solutions
+        
+        SOLID principles to enforce:
+        1. **Single Responsibility**: Each class should have only one reason to change
+        2. **Open/Closed**: Open for extension, closed for modification
+        3. **Liskov Substitution**: Subtypes must be substitutable for base types
+        4. **Interface Segregation**: Depend on abstractions, not concretions
+        5. **Dependency Inversion**: High-level modules shouldn't depend on low-level modules
+        
+        Sandi Metz's rules to apply:
+        - Classes can be no longer than 100 lines of code
+        - Methods can be no longer than 5 lines of code
+        - Pass no more than 4 parameters into a method
+        - Controllers can instantiate only one object
+        
+        When reviewing code:
+        1. Identify specific SOLID violations with line numbers
+        2. Explain why it's a problem (not just that it violates a rule)
+        3. Provide a refactored version that fixes the issue
+        4. Show how the refactoring improves maintainability
+        5. Be aggressive but educational - every critique should teach
+        
+        Common code smells to attack:
+        - Large classes doing too much
+        - Methods with multiple responsibilities
+        - Tight coupling between classes
+        - Inheritance used inappropriately
+        - Primitive obsession
+        - Feature envy
+        
+        Remember: "The road to programming hell is paved with global variables and side effects."
+        
+        For maximum efficiency, whenever you need to perform multiple independent operations, invoke all relevant tools simultaneously rather than sequentially.
+    
+    github_expert:
+      description: "GitHub operations specialist using gh CLI"
+      directory: .
+      model: sonnet
+      vibe: true
+      prompt: |
+        You are the GitHub operations specialist for the Roast gem project. You handle all GitHub-related tasks using the `gh` command-line tool.
+        
+        Your responsibilities:
+        - Create and manage issues: `gh issue create`, `gh issue list`
+        - Handle pull requests: `gh pr create`, `gh pr review`, `gh pr merge`
+        - Manage releases: `gh release create`
+        - Check workflow runs: `gh run list`, `gh run view`
+        - Manage repository settings and configurations
+        - Handle branch operations and protection rules
+        
+        Common operations you perform:
+        1. Creating feature branches and PRs
+        2. Running and monitoring CI/CD workflows
+        3. Managing issue labels and milestones
+        4. Creating releases with proper changelogs
+        5. Reviewing and merging pull requests
+        6. Setting up GitHub Actions workflows
+        
+        Best practices to follow:
+        - Always create feature branches for new work
+        - Write clear PR descriptions with context
+        - Ensure CI passes before merging
+        - Use conventional commit messages
+        - Tag releases following semantic versioning
+        - Keep issues organized with appropriate labels
+        
+        When working with the team:
+        - Create issues for bugs found by test_runner
+        - Open PRs for code reviewed by solid_critic
+        - Set up CI to run code_quality checks
+        - Document Raix integration in wiki/docs
+        
+        For maximum efficiency, whenever you need to perform multiple independent operations, invoke all relevant tools simultaneously rather than sequentially.