roast-ai 0.1.3 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e40b7ab08d8d4c70d9d884c2c76027ad1426bcdacbae92121b162cc33aa45548
-  data.tar.gz: 936ab6e40dfbfbcef29f68edbb1a7ea41a895d719782f2125c24f47e71005eeb
+  metadata.gz: 9bdaada020320af4c7fead86184a7cd0b1c06a89e88bc15ac424b31f4b449fb6
+  data.tar.gz: 3f83f410a1f21992de59b19b8e2f0ea402b9fe50b314b82514723cf20f9a599f
 SHA512:
-  metadata.gz: 7c8de8b0ac1ee9496a869d056fb75de2101b4f1b674bde76c703a913ae749d22c650b44c783e8ebff4127862baa168e4ba1680f1e62bd60574068ba53c88f154
-  data.tar.gz: f770140fee92dd287d171c52b61d437bbbb3ad7bbe0edc121c68cdb71d4b7628ebbbe1e56946cd8a251ecb991e803e79e62f7d084d59a0efc0efc2ce30b13769
+  metadata.gz: c6dfdd57104e363735a6e24bf5beb43a042340f582f94d8126c3f8a0d30dd92b031c5201a7d3d136bfcd3b7095a51c49329b08c07c5c19544240b18e20ad9948
+  data.tar.gz: 02aec8d620c3fe0c57d0d4e06790a7513a4a1aa44f68462721b6aa7da3f22f377598b4c00453e4ec825b0adcac3c335d470f945599d39571edb67e8a380597ac

data/.github/workflows/ci.yaml

@@ -16,7 +16,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu]
-        ruby: ['3.4', 'ruby-head']
+        ruby: ['3.4']
     runs-on: ${{ matrix.os }}-latest
     continue-on-error: ${{ matrix.ruby == 'ruby-head' }}
     steps:
@@ -25,5 +25,5 @@ jobs:
         with:
           ruby-version: ${{ matrix.ruby }}
           bundler-cache: true
-      - run: bundle exec rake
+      - run: bundle exec rake ci
 

data/CHANGELOG.md

@@ -5,7 +5,47 @@ 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.3] - 2024-05-10
+## [0.1.6] - 2024-05-15
+
+### Added
+- Support for OpenRouter as an API provider
+- `api_provider` configuration option allowing choice between OpenAI and OpenRouter
+- Added separate CI rake task for improved build pipeline
+- Version command to check current Roast version
+- Walking up to home folder for config root
+- Improved initializer support for better project configuration
+
+### Changed
+- Enhanced search tool to work with globs for more flexible searches
+- Improved error handling in configuration and initializers
+- Fixed and simplified interpolation examples
+
+### Fixed
+- Better error messages for search file tool
+- Improved initializer loading and error handling
+- Fixed tests for nested .roast folders
+
+[0.1.6]: https://github.com/Shopify/roast/compare/v0.1.5...v0.1.6
+
+## [0.1.5] - 2024-05-13
+
+### Added
+- Interpolation feature for dynamic workflows using `{{}}` syntax
+- Support for injecting values from workflow context into step names and commands
+- Ability to access file metadata and step outputs using interpolation expressions
+- Examples demonstrating interpolation usage with different file types
+
+[0.1.5]: https://github.com/Shopify/roast/releases/tag/v0.1.5
+
+## [0.1.4] - 2024-05-13
+
+### Fixed
+- Remove test directory restriction from WriteTool. (Thank you @endoze)
+
+[0.1.4]: https://github.com/Shopify/roast/releases/tag/v0.1.4
+
+
+## [0.1.3] - 2024-05-12
 
 ### Fixed
 - ReadFile tool now handles absolute and relative paths correctly

data/CLAUDE.md

@@ -7,16 +7,15 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## Commands
 
-- Build: `bundle exec rake build`
-- Test all: `bundle exec rspec`
-- Run single test: `bundle exec rspec spec/path/to/test_file.rb`
-- Lint: `bundle exec rubocop -A`
 - Default (tests + lint): `bundle exec rake`
-- Run all tests plus rubocop: `bundle exec rake`
+- Test all: `bundle exec test`
+- Run single test: `bundle exec ruby -Itest test/path/to/test_file.rb`
+- Lint: `bundle exec rubocop`
+- Lint (with autocorrect, preferred): `bundle exec rubocop -A`
 
 ## Tech stack
-- `cli-kit` and `cli-ui` for the CLI tool
-- Testing: Use Rspec, VCR for HTTP mocking, test files named with `_spec.rb` suffix
+- `thor` and `cli-ui` for the CLI tool
+- Testing: Use Minitest, VCR for HTTP mocking, test files named with `_test.rb` suffix
 
 ## Code Style Guidelines
 
@@ -30,4 +29,115 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 - Define class methods inside `class << self; end` declarations.
 - Add runtime dependencies to `roast.gemspec`.
 - Add development dependencies to `Gemfile`.
-- Don't ever test private methods directly. Specs should test behavior, not implementation.
+- Don't ever test private methods directly. Specs should test behavior, not implementation.
+
+## Git Workflow Practices
+
+1. **Amending Commits**:
+   - Use `git commit --amend --no-edit` to add staged changes to the last commit without changing the commit message
+   - This is useful for incorporating small fixes or changes that belong with the previous commit
+   - Be careful when amending commits that have already been pushed, as it will require a force push
+
+2. **Force Pushing Safety**:
+   - Always use `git push --force-with-lease` rather than `git push --force` when pushing amended commits
+   - This prevents accidentally overwriting remote changes made by others that you haven't pulled yet
+   - It's a safer alternative that respects collaborative work environments
+
+4. **PR Management**:
+   - Pay attention to linting results before pushing to avoid CI failures
+
+## GitHub API Commands
+To get comments from a Pull Request using the GitHub CLI:
+
+```bash
+# Get review comments from a PR
+gh api repos/Shopify/roast/pulls/{pr_number}/comments
+
+# Get issue-style comments
+gh api repos/Shopify/roast/issues/{pr_number}/comments
+
+# Filter comments from a specific user using jq
+gh api repos/Shopify/roast/pulls/{pr_number}/comments | jq '.[] | select(.user.login == "username")'
+
+# Get only the comment content
+gh api repos/Shopify/roast/pulls/{pr_number}/comments | jq '.[].body'
+```
+
+### Creating and Managing Issues via API
+
+```bash
+# Create a new issue
+gh api repos/Shopify/roast/issues -X POST -F title="Issue Title" -F body="Issue description"
+
+# Update an existing issue
+gh api repos/Shopify/roast/issues/{issue_number} -X PATCH -F body="Updated description"
+
+# Add a comment to an issue
+gh api repos/Shopify/roast/issues/{issue_number}/comments -X POST -F body="Comment text"
+```
+
+### Creating and Managing Pull Requests
+
+```bash
+# Create a new PR with a detailed description using heredoc
+gh pr create --title "PR Title" --body "$(cat <<'EOF'
+## Summary
+
+Detailed description here...
+
+## Testing
+
+Testing instructions here...
+EOF
+)"
+
+# Update an existing PR description
+gh pr edit {pr_number} --body "$(cat <<'EOF'
+Updated PR description...
+EOF
+)"
+
+# Check PR details
+gh pr view {pr_number}
+
+# View PR diff
+gh pr diff {pr_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:
+   - **Bold text** instead of `code formatting`
+   - Add a follow-up comment with proper formatting
+3. For complex issues, create the basic issue first, then enhance with formatted comments
+4. Always verify the formatting in the created content
+5. Use raw JSON for complex formatting requirements:
+   ```bash
+   gh api repos/Shopify/roast/issues -X POST --raw-field '{"title":"Issue Title","body":"Complex **formatting** with `code` and lists:\n\n1. Item one\n2. Item two"}'
+   ```
+
+## PR Review Best Practices
+1. **Always provide your honest opinion about the PR** - be candid about both strengths and concerns
+2. Give a clear assessment of risks, architectural implications, and potential future issues
+3. Don't be afraid to point out potential problems even in otherwise good PRs
+4. When reviewing feature flag removal PRs, carefully inspect control flow changes, not just code branch removals
+5. Pay special attention to control flow modifiers like `next`, `return`, and `break` which affect iteration behavior
+6. Look for variable scope issues, especially for variables that persist across loop iterations
+7. Analyze how code behavior changes in all cases, not just how code structure changes
+8. Be skeptical of seemingly simple changes that simply remove conditional branches
+9. When CI checks fail, look for subtle logic inversions or control flow changes
+10. Examine every file changed in a PR with local code for context, focusing on both what's removed and what remains
+11. Verify variable initialization, modification, and usage patterns remain consistent after refactoring
+12. **Never try to directly check out PR branches** - instead, compare PR changes against the existing local codebase
+13. Understand the broader system architecture to identify potential impacts beyond the changed files
+14. Look at both the "before" and "after" state of the code when evaluating changes, not just the diff itself
+15. Consider how the changes will interact with other components that depend on the modified code
+16. Run searches or examine related files even if they're not directly modified by the PR
+17. Look for optimization opportunities, especially in frequently-called methods:
+    - Unnecessary object creation in loops 
+    - Redundant collection transformations
+    - Inefficient filtering methods that create temporary collections
+18. Prioritize code readability while encouraging performance optimizations:
+    - Avoid premature optimization outside of hot paths
+    - Consider the tradeoff between readability and performance
+    - Suggest optimizations that improve both clarity and performance

data/Gemfile

@@ -7,11 +7,11 @@ git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
 # Specify your gem's dependencies in roast.gemspec
 gemspec
 
+gem "cgi"
 gem "dotenv"
-gem "guard-rspec"
 gem "guard"
+gem "guard-minitest"
 gem "mocha"
-gem "pry"
 gem "rake", require: false
 gem "rubocop-shopify", require: false
 gem "vcr", require: false

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    roast-ai (0.1.3)
+    roast-ai (0.1.6)
       activesupport (~> 8.0)
       faraday-retry
       json-schema
@@ -30,13 +30,13 @@ GEM
     base64 (0.2.0)
     benchmark (0.4.0)
     bigdecimal (3.1.9)
+    cgi (0.4.2)
     coderay (1.1.3)
     concurrent-ruby (1.3.5)
     connection_pool (2.5.1)
     crack (1.0.0)
       bigdecimal
       rexml
-    diff-lcs (1.6.1)
     dotenv (3.1.8)
     drb (2.2.1)
     event_stream_parser (1.0.0)
@@ -52,6 +52,7 @@ GEM
       faraday (~> 2.0)
     ffi (1.17.2)
     ffi (1.17.2-arm64-darwin)
+    ffi (1.17.2-x86_64-linux-gnu)
     formatador (1.1.0)
     guard (2.19.1)
       formatador (>= 0.2.4)
@@ -65,10 +66,9 @@ GEM
       shellany (~> 0.0)
       thor (>= 0.18.1)
     guard-compat (1.2.1)
-    guard-rspec (4.7.3)
-      guard (~> 2.1)
-      guard-compat (~> 1.1)
-      rspec (>= 2.99.0, < 4.0)
+    guard-minitest (2.4.6)
+      guard-compat (~> 1.2)
+      minitest (>= 3.0)
     hashdiff (1.1.2)
     i18n (1.14.7)
       concurrent-ruby (~> 1.0)
@@ -122,19 +122,6 @@ GEM
       ffi (~> 1.0)
     regexp_parser (2.10.0)
     rexml (3.4.1)
-    rspec (3.13.0)
-      rspec-core (~> 3.13.0)
-      rspec-expectations (~> 3.13.0)
-      rspec-mocks (~> 3.13.0)
-    rspec-core (3.13.3)
-      rspec-support (~> 3.13.0)
-    rspec-expectations (3.13.3)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.13.0)
-    rspec-mocks (3.13.2)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.13.0)
-    rspec-support (3.13.2)
     rubocop (1.75.3)
       json (~> 2.3)
       language_server-protocol (~> 3.17.0.2)
@@ -175,14 +162,14 @@ GEM
 
 PLATFORMS
   arm64-darwin-23
-  ruby
+  x86_64-linux
 
 DEPENDENCIES
+  cgi
   dotenv
   guard
-  guard-rspec
+  guard-minitest
   mocha
-  pry
   rake
   roast-ai!
   rubocop-shopify

data/README.md

@@ -53,15 +53,15 @@ steps:
   - generate_final_report
 ```
 
-Workflows can include steps that run bash commands (wrap in `$()`) and even simple inlined prompts as a natural language string.
+Workflows can include steps that run bash commands (wrap in `$()`), use interpolation with `{{}}` syntax, and even simple inlined prompts as a natural language string.
 
 ```yaml
 steps:
   - analyze_spec
   - create_minitest
   - run_and_improve
-  - $(bundle exec rubocop -A)
-  - Summarize the changes made to the codebase.
+  - $(bundle exec rubocop -A {{file}})
+  - Summarize the changes made to {{File.basename(file)}}.
 ```
 
 ## How to use Roast
@@ -122,7 +122,7 @@ Roast supports several types of steps:
 
 #### Data Flow Between Steps
 
-Roast handles data flow between steps in two primary ways:
+Roast handles data flow between steps in three primary ways:
 
 1. **Conversation Context (Implicit)**: The LLM naturally remembers the entire conversation history, including all previous prompts and responses. In most cases, this is all you need for a step to reference and build upon previous results. This is the preferred approach for most prompt-oriented workflows.
 
@@ -131,7 +131,21 @@ Roast handles data flow between steps in two primary ways:
    - You're writing custom output logic
    - You need to access specific values for presentation or logging
 
-For typical AI workflows, the continuous conversation history provides seamless data flow without requiring explicit access to the output hash. Steps can simply refer to previous information in their prompts, and the AI model will use its memory of the conversation to provide context-aware responses.
+3. **Interpolation (Dynamic)**: You can use `{{expression}}` syntax to inject values from the workflow context directly into step names, commands, or prompt text. For example:
+   ```yaml
+   steps:
+     - analyze_file
+     - $(rubocop -A {{file}})
+     - Generate a summary for {{file}}
+     - result_for_{{file}}: store_results
+   ```
+   
+   Interpolation supports:
+   - Simple variable access: `{{file}}`, `{{resource.target}}`
+   - Access to step outputs: `{{output['previous_step']}}`
+   - Any valid Ruby expression evaluated in the workflow context: `{{File.basename(file)}}`
+
+For typical AI workflows, the continuous conversation history provides seamless data flow without requiring explicit access to the output hash. Steps can simply refer to previous information in their prompts, and the AI model will use its memory of the conversation to provide context-aware responses. For more dynamic requirements, the interpolation syntax provides a convenient way to inject context-specific values into steps.
 
 ### Command Line Options
 
@@ -298,9 +312,27 @@ Individual steps can override this setting with their own model parameter:
 
 ```yaml
 analyze_data:
-  model: anthropic:claude-3-haiku  # Takes precedence over the global model
+  model: anthropic/claude-3-haiku  # Takes precedence over the global model
 ```
 
+#### API Provider Configuration
+
+Roast supports both OpenAI and OpenRouter as API providers. By default, Roast uses OpenAI, but you can specify OpenRouter:
+
+```yaml
+name: My Workflow
+api_provider: openrouter
+api_token: $(echo $OPENROUTER_API_KEY)
+model: anthropic/claude-3-opus-20240229
+```
+
+Benefits of using OpenRouter:
+- Access to multiple model providers through a single API
+- Support for models from Anthropic, Meta, Mistral, and more
+- Consistent API interface across different model providers
+
+When using OpenRouter, specify fully qualified model names including the provider prefix (e.g., `anthropic/claude-3-opus-20240229`).
+
 #### Dynamic API Tokens
 
 Roast allows you to dynamically fetch API tokens using shell commands directly in your workflow configuration:
@@ -309,8 +341,12 @@ Roast allows you to dynamically fetch API tokens using shell commands directly i
 # This will execute the shell command and use the result as the API token
 api_token: $(print-token --key)
 
-# Or a simpler example for demonstration:
+# For OpenAI (default)
 api_token: $(echo $OPENAI_API_KEY)
+
+# For OpenRouter (requires api_provider setting)
+api_provider: openrouter
+api_token: $(echo $OPENROUTER_API_KEY)
 ```
 
 This makes it easy to use environment-specific tokens without hardcoding credentials, especially useful in development environments or CI/CD pipelines.

data/Rakefile

@@ -12,7 +12,11 @@ end
 
 task test: [:minitest]
 
-RuboCop::RakeTask.new do |task|
+RuboCop::RakeTask.new(:rubocop_ci)
+
+task ci: [:test, :rubocop_ci]
+
+RuboCop::RakeTask.new(:rubocop) do |task|
   task.options = ["--autocorrect"]
 end
 

data/examples/interpolation/README.md

@@ -0,0 +1,50 @@
+# Interpolation Example
+
+This example demonstrates how to use Roast's interpolation feature to create dynamic workflows.
+
+## Overview
+
+The workflow in this example:
+1. Analyzes a file and extracts its metadata
+2. Extracts patterns based on the file type
+3. Dynamically selects a report generation step based on the file extension
+4. Outputs a completion message using the file's basename
+
+## Interpolation Examples
+
+The workflow demonstrates several types of interpolation:
+
+- `{{ }}` syntax for embedding dynamic values
+- Access to file metadata via expressions like `{{file_basename}}` and `{{file_ext}}`
+- Dynamic step selection with `generate_report_for_{{file_ext}}`
+- Shell command interpolation with `$(echo "Processing completed for file: {{file_basename}}")`
+
+## Running the Example
+
+To run this example with a Ruby file:
+
+```bash
+roast execute workflow.yml /path/to/some_file.rb
+```
+
+Or with a JavaScript file:
+
+```bash
+roast execute workflow.yml /path/to/some_file.js
+```
+
+The workflow will:
+1. Extract the file's basename and extension
+2. Store these in the workflow context
+3. Dynamically choose a report generator based on file extension
+4. Create a markdown report file
+5. Output a completion message with the filename
+
+## How Interpolation Works
+
+1. When Roast processes a step name or shell command, it looks for `{{ }}` patterns
+2. Expressions inside `{{ }}` are evaluated in the workflow's context using Ruby's `instance_eval`
+3. This allows access to the workflow's variables, methods, and output hash
+4. The evaluated expressions replace the `{{ }}` patterns in the step name or command
+
+This makes workflows dynamic and able to respond to different inputs without code changes.

data/examples/interpolation/analyze_file/prompt.md

@@ -0,0 +1 @@
+Analyze the file at: <%= workflow.file %>

data/examples/interpolation/analyze_patterns/prompt.md

@@ -0,0 +1,27 @@
+Extract some patterns about this file and return in json format like this:
+
+<json>
+{
+  "code_patterns": {
+    "class_structure": {
+      "name": "Calculator",
+      "instance_variables": ["@memory"],
+      "method_count": 7,
+      "method_types": {
+        "constructor": ["initialize"],
+        "operations": ["add", "subtract", "multiply", "divide"],
+        "accessors": ["memory"],
+        "utility": ["clear"]
+      }
+    },
+    "error_handling": {
+      "techniques": ["conditional raise", "zero check"],
+      "examples": ["raise \"Division by zero!\" if number.zero?"]
+    },
+    "design_patterns": {
+      "state": "Uses instance variable to maintain calculator state",
+      "command": "Each operation method modifies the internal state"
+    }
+  }
+}
+</json>

data/examples/interpolation/generate_report_for_js/prompt.md

@@ -0,0 +1,3 @@
+Generate a nicely formatted report based on the following metadata:
+
+<%= workflow.output[:analyze_patterns] %>

data/examples/interpolation/generate_report_for_rb/prompt.md

@@ -0,0 +1,3 @@
+Generate a nicely formatted report based on the following metadata:
+
+<%= workflow.output[:analyze_patterns] %>

data/examples/interpolation/sample.js

@@ -0,0 +1,48 @@
+// Sample JavaScript file for testing interpolation in workflows
+
+class Calculator {
+  constructor() {
+    this.memory = 0;
+  }
+
+  add(number) {
+    this.memory += number;
+    return this.memory;
+  }
+
+  subtract(number) {
+    this.memory -= number;
+    return this.memory;
+  }
+
+  multiply(number) {
+    this.memory *= number;
+    return this.memory;
+  }
+
+  divide(number) {
+    if (number === 0) {
+      throw new Error("Division by zero!");
+    }
+    this.memory /= number;
+    return this.memory;
+  }
+
+  getMemory() {
+    return this.memory;
+  }
+
+  clear() {
+    this.memory = 0;
+    return this.memory;
+  }
+}
+
+// Example usage
+if (require.main === module) {
+  const calc = new Calculator();
+  calc.add(10);
+  calc.multiply(2);
+  calc.subtract(5);
+  console.log(`Result: ${calc.getMemory()}`);
+}

data/examples/interpolation/sample.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# Sample Ruby file for testing interpolation in workflows
+
+class Calculator
+  def initialize
+    @memory = 0
+  end
+
+  def add(number)
+    @memory += number
+  end
+
+  def subtract(number)
+    @memory -= number
+  end
+
+  def multiply(number)
+    @memory *= number
+  end
+
+  def divide(number)
+    raise "Division by zero!" if number.zero?
+
+    @memory /= number
+  end
+
+  attr_reader :memory
+
+  def clear
+    @memory = 0
+  end
+end
+
+# Example usage
+if __FILE__ == $PROGRAM_NAME
+  calc = Calculator.new
+  calc.add(10)
+  calc.multiply(2)
+  calc.subtract(5)
+  puts "Result: #{calc.memory}"
+end

data/examples/interpolation/workflow.md

@@ -0,0 +1 @@
+You are a good robot.

data/examples/interpolation/workflow.yml

@@ -0,0 +1,21 @@
+name: interpolation_example
+model: anthropic:claude-3-7-sonnet
+
+tools:
+  - Roast::Tools::ReadFile
+
+steps:
+  - analyze_file
+  - analyze_patterns
+  - generate_report_for_{{File.extname(workflow.file).sub('.', '')}}
+  - '$(echo "Processing completed for file: {{File.basename(workflow.file)}}")'
+
+analyze_patterns:
+  json: true
+
+generate_report_for_rb:
+  print_response: true
+
+generate_report_for_md:
+  print_response: true
+  

data/examples/openrouter_example/README.md

@@ -0,0 +1,48 @@
+# OpenRouter Example
+
+This example demonstrates how to use OpenRouter with Roast to access models from different providers through a single API.
+
+## Setup
+
+1. Sign up for an account at [OpenRouter](https://openrouter.ai/)
+2. Get your API key from the OpenRouter dashboard
+3. Set the API key as an environment variable:
+   ```bash
+   export OPENROUTER_API_KEY=your_api_key_here
+   ```
+
+## Running the Example
+
+```bash
+# Run without a specific target (general analysis)
+roast execute workflow.yml
+
+# Run with a specific file to analyze
+roast execute workflow.yml path/to/your/file.txt
+```
+
+## How it Works
+
+This example configures Roast to use OpenRouter as the API provider:
+
+```yaml
+api_provider: openrouter
+api_token: $(echo $OPENROUTER_API_KEY)
+model: anthropic/claude-3-haiku-20240307
+```
+
+The workflow consists of two steps:
+1. `analyze_input`: Analyzes the provided content (or generates general insights if no target is provided)
+2. `generate_response`: Creates a structured response based on the analysis
+
+## Available Models
+
+When using OpenRouter, you can access models from multiple providers by specifying the fully qualified model name, including the provider prefix. Some examples:
+
+- `anthropic/claude-3-opus-20240229`
+- `anthropic/claude-3-sonnet-20240229`
+- `meta/llama-3-70b-instruct`
+- `google/gemini-1.5-pro-latest`
+- `mistral/mistral-large-latest`
+
+Check the [OpenRouter documentation](https://openrouter.ai/docs) for the complete list of supported models.

data/examples/openrouter_example/analyze_input/prompt.md

@@ -0,0 +1,16 @@
+I'd like you to analyze the following input and provide your insights.
+
+<% if workflow.file && workflow.resource.content %>
+Here is the content to analyze:
+
+```
+<%= workflow.resource.content %>
+```
+<% else %>
+The workflow is running without a specific file target. Please provide general insights based on the context.
+<% end %>
+
+Please provide:
+1. A summary of the key points
+2. Any notable patterns or issues
+3. Recommendations based on your analysis

data/examples/openrouter_example/generate_response/prompt.md

@@ -0,0 +1,9 @@
+Based on the analysis from the previous step, please generate a response that addresses the findings.
+
+Your response should be well-structured and include:
+1. An introduction summarizing the analysis
+2. Detailed discussion of key points
+3. Clear recommendations for improvements
+4. A conclusion
+
+Format the response in markdown for better readability.

data/examples/openrouter_example/workflow.yml

@@ -0,0 +1,12 @@
+name: OpenRouter Example
+api_provider: openrouter
+api_token: $(echo $OPENROUTER_API_KEY)
+model: anthropic/claude-3-haiku-20240307
+
+tools:
+  - Roast::Tools::ReadFile
+  - Roast::Tools::WriteFile
+
+steps:
+  - analyze_input
+  - generate_response

data/lib/roast/initializers.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Roast
+  class Initializers
+    class << self
+      def config_root(starting_path = Dir.pwd, ending_path = File.dirname(Dir.home))
+        paths = []
+        candidate = starting_path
+        while candidate != ending_path
+          paths << File.join(candidate, ".roast")
+          candidate = File.dirname(candidate)
+        end
+
+        first_existing = paths.find { |path| Dir.exist?(path) }
+        first_existing || paths.first
+      end
+
+      def initializers_path
+        File.join(Roast::Initializers.config_root, "initializers")
+      end
+
+      def load_all
+        project_initializers = Roast::Initializers.initializers_path
+        return unless Dir.exist?(project_initializers)
+
+        $stderr.puts "Loading project initializers from #{project_initializers}"
+        pattern = File.join(project_initializers, "**/*.rb")
+        Dir.glob(pattern, sort: true).each do |file|
+          $stderr.puts "Loading initializer: #{file}"
+          require file
+        end
+      rescue => e
+        puts "ERROR: Error loading initializers: #{e.message}"
+        Roast::Helpers::Logger.error("Error loading initializers: #{e.message}")
+        # Don't fail the workflow if initializers can't be loaded
+      end
+    end
+  end
+end

data/lib/roast/tools/search_file.rb

@@ -13,10 +13,11 @@ module Roast
           base.class_eval do
             function(
               :search_for_file,
-              'Search for a file in the project using `find . -type f -path "*#{@file_name}*"` in the project root',
-              name: { type: "string", description: "filename with as much of the path as you can deduce" },
+              "Search for a file in the project using a glob pattern.",
+              glob_pattern: { type: "string", description: "A glob pattern to search for. Example: 'test/**/*_test.rb'" },
+              path: { type: "string", description: "path to search from" },
             ) do |params|
-              Roast::Tools::SearchFile.call(params[:name]).tap do |result|
+              Roast::Tools::SearchFile.call(params[:glob_pattern], params[:path]).tap do |result|
                 Roast::Helpers::Logger.debug(result) if ENV["DEBUG"]
               end
             end
@@ -24,27 +25,33 @@ module Roast
         end
       end
 
-      def call(filename)
-        Roast::Helpers::Logger.info("🔍 Searching for file: #{filename}\n")
-        search_for(filename).then do |results|
-          return "No results found for #{filename}" if results.empty?
-          return Roast::Tools::ReadFile.call(results.first) if results.size == 1
+      def call(glob_pattern, path = ".")
+        Roast::Helpers::Logger.info("🔍 Searching for: '#{glob_pattern}' in '#{path}'\n")
+        search_for(glob_pattern, path).then do |results|
+          return "No results found for #{glob_pattern} in #{path}" if results.empty?
+          return read_contents(results.first) if results.size == 1
 
-          results.inspect # purposely give the AI list of actual paths so that it can read without searching first
+          results.join("\n") # purposely give the AI list of actual paths so that it can read without searching first
         end
       rescue StandardError => e
-        "Error searching for file: #{e.message}".tap do |error_message|
+        "Error searching for '#{glob_pattern}' in '#{path}': #{e.message}".tap do |error_message|
           Roast::Helpers::Logger.error(error_message + "\n")
           Roast::Helpers::Logger.debug(e.backtrace.join("\n") + "\n") if ENV["DEBUG"]
         end
       end
 
-      def search_for(filename)
-        # Execute find command and get the output using -path to match against full paths
-        result = %x(find . -type f -path "*#{filename}*").strip
+      def read_contents(path)
+        contents = File.read(path)
+        token_count = contents.size / 4
+        if token_count > 25_000
+          path
+        else
+          contents
+        end
+      end
 
-        # Split by newlines and get the first result
-        result.split("\n").map(&:strip).reject(&:empty?).map { |path| path.sub(%r{^\./}, "") }
+      def search_for(pattern, path)
+        Dir.glob(pattern, base: path)
       end
     end
   end

data/lib/roast/tools/write_file.rb

@@ -21,7 +21,9 @@ module Roast
               },
               content: { type: "string", description: "The content to write to the file" },
             ) do |params|
-              Roast::Tools::WriteFile.call(params[:path], params[:content]).tap do |_result|
+              restrict_path = params[:params]&.dig("restrict")
+
+              Roast::Tools::WriteFile.call(params[:path], params[:content], restrict_path).tap do |_result|
                 Roast::Helpers::Logger.info(params[:content])
               end
             end
@@ -29,9 +31,8 @@ module Roast
         end
       end
 
-      def call(path, content)
-        if path.start_with?("test/")
-
+      def call(path, content, restrict_path = nil)
+        if restrict_path.nil? || restrict_path.empty? || path.start_with?(restrict_path)
           Roast::Helpers::Logger.info("📝 Writing to file: #{path}\n")
 
           # Ensure the directory exists
@@ -46,8 +47,9 @@ module Roast
 
           "Successfully wrote #{content.lines.count} lines to #{path}"
         else
-          Roast::Helpers::Logger.error("😳 Path must start with 'test/' to use the write_file tool\n")
-          "Error: Path must start with 'test/' to use the write_file tool, try again."
+          restriction_message = "😳 Path must start with '#{restrict_path}' to use the write_file tool\n"
+          Roast::Helpers::Logger.error(restriction_message)
+          "Error: Path must start with '#{restrict_path}' to use the write_file tool, try again."
         end
       rescue StandardError => e
         "Error writing file: #{e.message}".tap do |error_message|

data/lib/roast/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Roast
-  VERSION = "0.1.3"
+  VERSION = "0.1.6"
 end

data/lib/roast/workflow/base_workflow.rb

@@ -100,6 +100,10 @@ module Roast
         raise
       end
 
+      def workflow
+        self
+      end
+
       private
 
       # Determine the directory where the actual class is defined, not BaseWorkflow

data/lib/roast/workflow/configuration.rb

@@ -8,7 +8,7 @@ module Roast
     # Encapsulates workflow configuration data and provides structured access
     # to the configuration settings
     class Configuration
-      attr_reader :config_hash, :workflow_path, :name, :steps, :tools, :function_configs, :api_token, :model, :resource
+      attr_reader :config_hash, :workflow_path, :name, :steps, :tools, :function_configs, :api_token, :api_provider, :model, :resource
       attr_accessor :target
 
       def initialize(workflow_path, options = {})
@@ -45,6 +45,9 @@ module Roast
           @api_token = process_shell_command(@config_hash["api_token"])
         end
 
+        # Determine API provider (defaults to OpenAI if not specified)
+        @api_provider = determine_api_provider
+
         # Extract default model if provided
         @model = @config_hash["model"]
       end
@@ -138,8 +141,32 @@ module Roast
         @function_configs[function_name.to_s] || {}
       end
 
+      def openrouter?
+        @api_provider == :openrouter
+      end
+
+      def openai?
+        @api_provider == :openai
+      end
+
       private
 
+      def determine_api_provider
+        return :openai unless @config_hash["api_provider"]
+
+        provider = @config_hash["api_provider"].to_s.downcase
+
+        case provider
+        when "openai"
+          :openai
+        when "openrouter"
+          :openrouter
+        else
+          Roast::Helpers::Logger.warn("Unknown API provider '#{provider}', defaulting to OpenAI")
+          :openai
+        end
+      end
+
       def process_shell_command(command)
         # If it's a bash command with the $(command) syntax
         if command =~ /^\$\((.*)\)$/

data/lib/roast/workflow/configuration_parser.rb

@@ -6,6 +6,7 @@ require_relative "../helpers/function_caching_interceptor"
 require "active_support"
 require "active_support/isolated_execution_state"
 require "active_support/notifications"
+require "raix"
 
 module Roast
   module Workflow
@@ -98,35 +99,23 @@ module Roast
       end
 
       def load_roast_initializers
-        # Project-specific initializers
-        project_initializers = File.join(Dir.pwd, ".roast", "initializers")
-
-        if Dir.exist?(project_initializers)
-          $stderr.puts "Loading project initializers from #{project_initializers}"
-          Dir.glob(File.join(project_initializers, "**/*.rb")).sort.each do |file|
-            $stderr.puts "Loading initializer: #{file}"
-            require file
-          end
-        end
-      rescue => e
-        Roast::Helpers::Logger.error("Error loading initializers: #{e.message}")
-        # Don't fail the workflow if initializers can't be loaded
+        Roast::Initializers.load_all
       end
 
       def configure_api_client
         return unless configuration.api_token
 
         begin
-          require "raix"
-
-          # Configure OpenAI client with the token
-          $stderr.puts "Configuring API client with token from workflow"
+          case configuration.api_provider
+          when :openrouter
+            $stderr.puts "Configuring OpenRouter client with token from workflow"
+            require "open_router"
 
-          # Initialize the OpenAI client if it doesn't exist
-          if defined?(Raix.configuration.openai_client)
-            # Create a new client with the token
-            Raix.configuration.openai_client = OpenAI::Client.new(access_token: configuration.api_token)
+            Raix.configure do |config|
+              config.openrouter_client = OpenRouter::Client.new(api_key: configuration.api_token)
+            end
           else
+            $stderr.puts "Configuring OpenAI client with token from workflow"
             require "openai"
 
             Raix.configure do |config|

data/lib/roast/workflow/workflow_executor.rb

@@ -33,6 +33,25 @@ module Roast
         end
       end
 
+      # Interpolates {{expression}} in a string with values from the workflow context
+      def interpolate(text)
+        return text unless text.is_a?(String) && text.include?("{{") && text.include?("}}")
+
+        # Replace all {{expression}} with their evaluated values
+        text.gsub(/\{\{([^}]+)\}\}/) do |match|
+          expression = Regexp.last_match(1).strip
+          begin
+            # Evaluate the expression in the workflow's context
+            workflow.instance_eval(expression).to_s
+          rescue => e
+            # If evaluation fails, provide a more detailed error message but preserve the original expression
+            error_msg = "Error interpolating {{#{expression}}}: #{e.message}. This variable is not defined in the workflow context. Please define it before using it in a step name."
+            $stderr.puts "ERROR: #{error_msg}"
+            match # Return the original match to preserve it in the string
+          end
+        end
+      end
+
       def execute_step(name)
         start_time = Time.now
         # For tests, make sure that we handle this gracefully
@@ -95,10 +114,16 @@ module Roast
       def execute_hash_step(step)
         # execute a command and store the output in a variable
         name, command = step.to_a.flatten
+
+        # Interpolate variable name if it contains {{}}
+        interpolated_name = interpolate(name)
+
         if command.is_a?(Hash)
           execute_steps([command])
         else
-          workflow.output[name] = execute_step(command)
+          # Interpolate command value
+          interpolated_command = interpolate(command)
+          workflow.output[interpolated_name] = execute_step(interpolated_command)
         end
       end
 
@@ -110,7 +135,9 @@ module Roast
       end
 
       def execute_string_step(step)
-        execute_step(step)
+        # Interpolate any {{}} expressions before executing the step
+        interpolated_step = interpolate(step)
+        execute_step(interpolated_step)
       end
 
       def find_and_load_step(step_name)
@@ -172,7 +199,11 @@ module Roast
 
       def strip_and_execute(step)
         if step.match?(/^\$\((.*)\)$/)
+          # Extract the command from the $(command) syntax
           command = step.strip.match(/^\$\((.*)\)$/)[1]
+
+          # NOTE: We don't need to call interpolate here as it's already been done
+          # in execute_string_step before this method is called
           %x(#{command})
         else
           raise "Missing closing parentheses: #{step}"

data/lib/roast.rb

@@ -7,6 +7,7 @@ require "roast/tools"
 require "roast/helpers"
 require "roast/resources"
 require "roast/workflow"
+require "roast/initializers"
 
 module Roast
   ROOT = File.expand_path("../..", __FILE__)
@@ -28,6 +29,11 @@ module Roast
       Roast::Workflow::ConfigurationParser.new(expanded_workflow_path, files, options.transform_keys(&:to_sym)).begin!
     end
 
+    desc "version", "Display the current version of Roast"
+    def version
+      puts "Roast version #{Roast::VERSION}"
+    end
+
     class << self
       def exit_on_failure?
         true

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: roast-ai
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.6
 platform: ruby
 authors:
 - Shopify
@@ -128,6 +128,19 @@ files:
 - examples/grading/workflow.ts+tsx.md
 - examples/grading/workflow.yml
 - examples/instrumentation.rb
+- examples/interpolation/README.md
+- examples/interpolation/analyze_file/prompt.md
+- examples/interpolation/analyze_patterns/prompt.md
+- examples/interpolation/generate_report_for_js/prompt.md
+- examples/interpolation/generate_report_for_rb/prompt.md
+- examples/interpolation/sample.js
+- examples/interpolation/sample.rb
+- examples/interpolation/workflow.md
+- examples/interpolation/workflow.yml
+- examples/openrouter_example/README.md
+- examples/openrouter_example/analyze_input/prompt.md
+- examples/openrouter_example/generate_response/prompt.md
+- examples/openrouter_example/workflow.yml
 - examples/rspec_to_minitest/README.md
 - examples/rspec_to_minitest/analyze_spec/prompt.md
 - examples/rspec_to_minitest/create_minitest/prompt.md
@@ -142,6 +155,7 @@ files:
 - lib/roast/helpers/minitest_coverage_runner.rb
 - lib/roast/helpers/path_resolver.rb
 - lib/roast/helpers/prompt_loader.rb
+- lib/roast/initializers.rb
 - lib/roast/resources.rb
 - lib/roast/resources/api_resource.rb
 - lib/roast/resources/base_resource.rb