Merge branch 'main' into feature/pre-post-processing

Author: obie

.github/workflows/ci.yaml

@@ -17,8 +17,10 @@ jobs:
       matrix:
         os: [ubuntu]
         ruby: ['3.2', '3.3', '3.4']
+        gemfile: ['activesupport7', 'activesupport8']
     runs-on: ${{ matrix.os }}-latest
-    continue-on-error: ${{ matrix.ruby == 'ruby-head' }}
+    env:
+      BUNDLE_GEMFILE: ${{ github.workspace }}/gemfiles/${{ matrix.gemfile }}.gemfile
     steps:
       - uses: actions/checkout@v4
       - name: Install ripgrep

.gitignore

@@ -38,3 +38,5 @@ bin/ruby-lsp-test-exec
 bin/ruby-parse
 bin/ruby-rewrite
 bin/thor
+
+gemfiles/*.lock

Gemfile.lock

@@ -2,7 +2,7 @@ PATH
   remote: .
   specs:
     roast-ai (0.2.1)
-      activesupport (~> 8.0)
+      activesupport (~> 7.0)
       cli-ui
       diff-lcs (~> 1.5)
       faraday-retry
@@ -13,7 +13,7 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (8.0.2)
+    activesupport (7.2.2.1)
       base64
       benchmark (>= 0.3)
       bigdecimal
@@ -25,7 +25,6 @@ GEM
       minitest (>= 5.1)
       securerandom (>= 0.3)
       tzinfo (~> 2.0, >= 2.0.5)
-      uri (>= 0.13.1)
     addressable (2.8.7)
       public_suffix (>= 2.0.2, < 7.0)
     ast (2.4.3)

README.md

@@ -124,6 +124,9 @@ roast execute workflow.yml target_file.rb
 
 # Or for a targetless workflow (API calls, data generation, etc.)
 roast execute workflow.yml
+
+# Roast will automatically search in `project_root/roast/workflow_name` if the path is incomplete.
+roast execute my_cool_workflow # Equivalent to `roast execute roast/my_cool_workflow/workflow.yml
 ```
 
 ### Understanding Workflows
@@ -476,9 +479,9 @@ Benefits of using OpenRouter:
 
 When using OpenRouter, specify fully qualified model names including the provider prefix (e.g., `anthropic/claude-3-opus-20240229`).
 
-#### Dynamic API Tokens
+#### Dynamic API Tokens and URIs
 
-Roast allows you to dynamically fetch API tokens using shell commands directly in your workflow configuration:
+Roast allows you to dynamically fetch attributes such as API token and URI base (to use with a proxy) via shell commands directly in your workflow configuration:
 
 ```yaml
 # This will execute the shell command and use the result as the API token
@@ -490,8 +493,13 @@ api_token: $(echo $OPENAI_API_KEY)
 # For OpenRouter (requires api_provider setting)
 api_provider: openrouter
 api_token: $(echo $OPENROUTER_API_KEY)
-```
 
+# Static Proxy URI
+uri_base: https://proxy.example.com/v1
+
+# Dynamic Proxy URI
+uri_base: $(echo $AI_PROXY_URI_BASE)
+```
 
 This makes it easy to use environment-specific tokens without hardcoding credentials, especially useful in development environments or CI/CD pipelines. Alternatively, Roast will fall back to `OPENROUTER_API_KEY` or `OPENAI_API_KEY` environment variables based on the specified provider.
 

gemfiles/activesupport7.gemfile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+eval_gemfile "../Gemfile"
+gem "activesupport", "~> 7.0"

gemfiles/activesupport8.gemfile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+eval_gemfile "../Gemfile"
+gem "activesupport", "~> 8.0"

lib/roast.rb

@@ -28,7 +28,13 @@ def execute(*paths)
       raise Thor::Error, "Workflow configuration file is required" if paths.empty?
 
       workflow_path, *files = paths
-      expanded_workflow_path = File.expand_path(workflow_path)
+
+      expanded_workflow_path = if workflow_path.include?("workflow.yml")
+        File.expand_path(workflow_path)
+      else
+        File.expand_path("roast/#{workflow_path}/workflow.yml")
+      end
+
       raise Thor::Error, "Expected a Roast workflow configuration file, got directory: #{expanded_workflow_path}" if File.directory?(expanded_workflow_path)
 
       Roast::Workflow::ConfigurationParser.new(expanded_workflow_path, files, options.transform_keys(&:to_sym)).begin!

lib/roast/tools/search_file.rb

@@ -29,9 +29,9 @@ def call(glob_pattern, path = ".")
         Roast::Helpers::Logger.info("🔍 Searching for: '#{glob_pattern}' in '#{File.expand_path(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
+          return read_contents(File.join(path, results.first)) if results.size == 1
 
-          results.join("\n") # purposely give the AI list of actual paths so that it can read without searching first
+          results.map { |result| File.join(path, result) }.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 '#{glob_pattern}' in '#{path}': #{e.message}".tap do |error_message|

lib/roast/value_objects.rb

@@ -3,3 +3,4 @@
 require "roast/value_objects/api_token"
 require "roast/value_objects/step_name"
 require "roast/value_objects/workflow_path"
+require "roast/value_objects/uri_base"

lib/roast/value_objects/uri_base.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Roast
+  module ValueObjects
+    # Value object representing a URI base with validation
+    class UriBase
+      class InvalidUriBaseError < StandardError; end
+
+      attr_reader :value
+
+      def initialize(value)
+        @value = value&.to_s
+        validate!
+        freeze
+      end
+
+      def present?
+        !blank?
+      end
+
+      def blank?
+        @value.nil? || @value.strip.empty?
+      end
+
+      def to_s
+        @value
+      end
+
+      def ==(other)
+        return false unless other.is_a?(UriBase)
+
+        value == other.value
+      end
+      alias_method :eql?, :==
+
+      def hash
+        [self.class, @value].hash
+      end
+
+      private
+
+      def validate!
+        return if @value.nil? # Allow nil URI base, just not empty strings
+
+        raise InvalidUriBaseError, "URI base cannot be an empty string" if @value.strip.empty?
+      end
+    end
+  end
+end

lib/roast/workflow/api_configuration.rb

@@ -2,12 +2,13 @@
 
 require "roast/factories/api_provider_factory"
 require "roast/workflow/resource_resolver"
+require "roast/value_objects/uri_base"
 
 module Roast
   module Workflow
     # Handles API-related configuration including tokens and providers
     class ApiConfiguration
-      attr_reader :api_token, :api_provider
+      attr_reader :api_token, :api_provider, :uri_base
 
       def initialize(config_hash)
         @config_hash = config_hash
@@ -37,6 +38,7 @@ def effective_token
       def process_api_configuration
         extract_api_token
         extract_api_provider
+        extract_uri_base
       end
 
       def extract_api_token
@@ -49,6 +51,12 @@ def extract_api_provider
         @api_provider = Roast::Factories::ApiProviderFactory.from_config(@config_hash)
       end
 
+      def extract_uri_base
+        if @config_hash["uri_base"]
+          @uri_base = ResourceResolver.process_shell_command(@config_hash["uri_base"])
+        end
+      end
+
       def environment_token
         if openai?
           ENV["OPENAI_API_KEY"]

lib/roast/workflow/configuration.rb

@@ -14,7 +14,7 @@ class Configuration
       attr_reader :config_hash, :workflow_path, :name, :steps, :pre_processing, :post_processing, :tools, :function_configs, :model, :resource
       attr_accessor :target
 
-      delegate :api_provider, :openrouter?, :openai?, to: :api_configuration
+      delegate :api_provider, :openrouter?, :openai?, :uri_base, to: :api_configuration
 
       # Delegate api_token to effective_token for backward compatibility
       def api_token

lib/roast/workflow/workflow_initializer.rb

@@ -81,11 +81,19 @@ def api_client_already_configured?
         end
       end
 
+      def client_options
+        {
+          access_token: @configuration.api_token,
+          uri_base: @configuration.uri_base&.to_s,
+        }.compact
+      end
+
       def configure_openrouter_client
         $stderr.puts "Configuring OpenRouter client with token from workflow"
         require "open_router"
 
-        client = OpenRouter::Client.new(access_token: @configuration.api_token)
+        client = OpenRouter::Client.new(client_options)
+
         Raix.configure do |config|
           config.openrouter_client = client
         end
@@ -96,7 +104,8 @@ def configure_openai_client
         $stderr.puts "Configuring OpenAI client with token from workflow"
         require "openai"
 
-        client = OpenAI::Client.new(access_token: @configuration.api_token)
+        client = OpenAI::Client.new(client_options)
+
         Raix.configure do |config|
           config.openai_client = client
         end

roast.gemspec

@@ -36,7 +36,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency("activesupport", "~> 8.0")
+  spec.add_dependency("activesupport", ">= 7.0")
   spec.add_dependency("cli-ui")
   spec.add_dependency("diff-lcs", "~> 1.5")
   spec.add_dependency("faraday-retry")

test/roast/cli_test.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "mocha/minitest"
+require "roast"
+
+class RoastCLITest < ActiveSupport::TestCase
+  def test_execute_with_workflow_yml_path
+    workflow_path = "path/to/workflow.yml"
+    expanded_path = File.expand_path(workflow_path)
+
+    # Mock the ConfigurationParser to prevent actual execution
+    mock_parser = mock("ConfigurationParser")
+    mock_parser.expects(:begin!).once
+    Roast::Workflow::ConfigurationParser.expects(:new).with(expanded_path, [], {}).returns(mock_parser)
+
+    # Make sure File.directory? returns false to avoid the directory error
+    File.expects(:directory?).with(expanded_path).returns(false)
+
+    # Execute the CLI command
+    cli = Roast::CLI.new
+    cli.execute(workflow_path)
+  end
+
+  def test_execute_with_conventional_path
+    workflow_name = "my_workflow"
+    conventional_path = "roast/#{workflow_name}/workflow.yml"
+    expanded_path = File.expand_path(conventional_path)
+
+    # Mock the ConfigurationParser to prevent actual execution
+    mock_parser = mock("ConfigurationParser")
+    mock_parser.expects(:begin!).once
+    Roast::Workflow::ConfigurationParser.expects(:new).with(expanded_path, [], {}).returns(mock_parser)
+
+    # Make sure File.directory? returns false to avoid the directory error
+    File.expects(:directory?).with(expanded_path).returns(false)
+
+    # Execute the CLI command
+    cli = Roast::CLI.new
+    cli.execute(workflow_name)
+  end
+
+  def test_execute_with_directory_path_raises_error
+    workflow_path = "path/to/directory"
+    expanded_path = File.expand_path("roast/#{workflow_path}/workflow.yml")
+
+    # Make the directory check return true to trigger the error
+    File.expects(:directory?).with(expanded_path).returns(true)
+
+    # Execute the CLI command and expect an error
+    cli = Roast::CLI.new
+    assert_raises(Thor::Error) do
+      cli.execute(workflow_path)
+    end
+  end
+
+  def test_execute_with_files_passes_files_to_parser
+    workflow_path = "path/to/workflow.yml"
+    expanded_path = File.expand_path(workflow_path)
+    files = ["file1.rb", "file2.rb"]
+
+    # Mock the ConfigurationParser to prevent actual execution
+    mock_parser = mock("ConfigurationParser")
+    mock_parser.expects(:begin!).once
+    Roast::Workflow::ConfigurationParser.expects(:new).with(expanded_path, files, {}).returns(mock_parser)
+
+    # Make sure File.directory? returns false to avoid the directory error
+    File.expects(:directory?).with(expanded_path).returns(false)
+
+    # Execute the CLI command
+    cli = Roast::CLI.new
+    cli.execute(workflow_path, *files)
+  end
+
+  def test_execute_with_options_passes_options_to_parser
+    workflow_path = "path/to/workflow.yml"
+    expanded_path = File.expand_path(workflow_path)
+    options = { "verbose" => true, "concise" => false }
+
+    # Mock the ConfigurationParser to prevent actual execution
+    mock_parser = mock("ConfigurationParser")
+    mock_parser.expects(:begin!).once
+    Roast::Workflow::ConfigurationParser.expects(:new).with(expanded_path, [], options.transform_keys(&:to_sym)).returns(mock_parser)
+
+    # Make sure File.directory? returns false to avoid the directory error
+    File.expects(:directory?).with(expanded_path).returns(false)
+
+    # Create CLI with options
+    cli = Roast::CLI.new([], options)
+    cli.execute(workflow_path)
+  end
+end

test/roast/helpers/prompt_loader_test.rb

@@ -5,11 +5,16 @@
 
 class RoastHelpersPromptLoaderTest < ActiveSupport::TestCase
   def setup
+    @original_openai_key = ENV.delete("OPENAI_API_KEY")
     @workflow_file = fixture_file("workflow/workflow.yml")
     @test_file = fixture_file("test.rb")
     @workflow = build_workflow(@workflow_file, @test_file)
   end
 
+  def teardown
+    ENV["OPENAI_API_KEY"] = @original_openai_key
+  end
+
   def build_workflow(workflow_file, test_file)
     parser = Roast::Workflow::ConfigurationParser.new(workflow_file, [test_file])
     parser.instance_variable_set(

test/roast/tools/search_file_test.rb

@@ -81,14 +81,14 @@ def teardown
 
   test ".call returns file content for single match" do
     Roast::Tools::SearchFile.stubs(:search_for).with("test_file1.txt", ".").returns(["test_file1.txt"])
-    Roast::Tools::SearchFile.stubs(:read_contents).with("test_file1.txt").returns("file content")
+    Roast::Tools::SearchFile.stubs(:read_contents).with("./test_file1.txt").returns("file content")
 
     result = Roast::Tools::SearchFile.call("test_file1.txt")
     assert_equal "file content", result
   end
 
   test ".call with path parameter passes path to search_for" do
-    Roast::Tools::SearchFile.expects(:search_for).with("test_file", "nested/dir").returns(["nested/dir/test_file.txt"])
+    Roast::Tools::SearchFile.expects(:search_for).with("test_file", "nested/dir").returns(["test_file.txt"])
     Roast::Tools::SearchFile.stubs(:read_contents).with("nested/dir/test_file.txt").returns("file content")
 
     result = Roast::Tools::SearchFile.call("test_file", "nested/dir")
@@ -99,7 +99,7 @@ def teardown
     Roast::Tools::SearchFile.stubs(:search_for).with("file", ".").returns(["file1.txt", "file2.txt"])
 
     result = Roast::Tools::SearchFile.call("file")
-    assert_equal "file1.txt\nfile2.txt", result
+    assert_equal "./file1.txt\n./file2.txt", result
   end
 
   test ".call returns no results message when empty" do