roast-ai 0.2.0 → 0.2.2

data/examples/single_target_prepost/workflow.yml

@@ -0,0 +1,20 @@
+name: analyze_codebase
+description: Analyze a single codebase with pre/post processing support
+model: gpt-4o
+target: "src/main.rb"
+
+# Pre-processing: Gather context before analyzing the main file
+pre_processing:
+  - gather_dependencies
+  - setup_analysis_tools
+
+# Main workflow: Analyze the target file
+steps:
+  - analyze_code_quality
+  - identify_improvements
+  - generate_recommendations
+
+# Post-processing: Generate final report
+post_processing:
+  - summarize_findings
+  - create_action_items

data/examples/smart_coercion_defaults/README.md

@@ -0,0 +1,65 @@
+# Smart Coercion Defaults
+
+This example demonstrates how Roast applies intelligent defaults for boolean coercion based on the type of expression being evaluated.
+
+## Default Coercion Rules
+
+When a step is used in a boolean context (like `if`, `unless`, or `until` conditions) and no explicit `coerce_to` is specified, Roast applies these smart defaults:
+
+1. **Ruby Expressions** (`{{expression}}`) → Regular boolean coercion (`!!value`)
+   - `nil` and `false` are falsy
+   - Everything else is truthy (including 0, empty arrays, etc.)
+
+2. **Bash Commands** (`$(command)`) → Exit code interpretation
+   - Exit code 0 = true (success)
+   - Non-zero exit code = false (failure)
+
+3. **Prompt/Step Names** → LLM boolean interpretation
+   - Analyzes natural language responses for yes/no intent
+   - "Yes", "True", "Affirmative" → true
+   - "No", "False", "Negative" → false
+
+4. **Non-string Values** → Regular boolean coercion
+
+## Examples
+
+### Ruby Expression (Regular Boolean)
+```yaml
+- repeat:
+    until: "{{counter >= 5}}"  # Uses !! coercion
+    steps:
+      - increment: counter
+```
+
+### Bash Command (Exit Code)
+```yaml
+- repeat:
+    until: "$(test -f /tmp/done)"  # True when file exists (exit 0)
+    steps:
+      - wait: 1
+```
+
+### Prompt Response (LLM Boolean)
+```yaml
+- if: "Should we continue?"  # Interprets "Yes, let's continue" as true
+  then:
+    - proceed: "Continuing..."
+```
+
+## Overriding Defaults
+
+You can always override the default coercion by specifying `coerce_to` directly in the step:
+
+```yaml
+- each: "get_items"
+  as: "item"
+  coerce_to: iterable  # Override default to split into array
+  steps:
+    - process: "{{item}}"
+```
+
+## Supported Coercion Types
+
+- `boolean` - Standard Ruby truthiness (!! operator)
+- `llm_boolean` - Natural language yes/no interpretation
+- `iterable` - Convert to array (splits strings on newlines)

data/examples/smart_coercion_defaults/workflow.yml

@@ -0,0 +1,44 @@
+name: Smart Coercion Defaults Demo
+description: Demonstrates how different step types get smart boolean coercion defaults
+
+steps:
+  # Example 1: Ruby expressions default to regular boolean coercion
+  - set_counter: 
+      value: 3
+  
+  - repeat:
+      until: "{{counter >= 5}}"  # Ruby expression defaults to boolean
+      steps:
+        - increment_counter: 
+            value: "{{counter + 1}}"
+        - log: "Counter is now {{counter}}"
+  
+  # Example 2: Bash commands default to exit code interpretation
+  - check_file_exists:
+      repeat:
+        until: "$(ls /tmp/important_file 2>/dev/null)"  # Bash command defaults to exit code
+        max_iterations: 3
+        steps:
+          - create_file: "$(mkdir -p /tmp && touch /tmp/important_file)"
+          - log: "Waiting for file to exist..."
+  
+  # Example 3: Prompt/step names default to LLM boolean interpretation
+  - ask_user_ready:
+      prompt: "Are you ready to continue? Please respond yes or no."
+  
+  - conditional:
+      if: "ask_user_ready"  # Step name defaults to llm_boolean
+      then:
+        - proceed: "Great! Let's continue..."
+      else:
+        - wait: "Okay, take your time."
+  
+  # Example 4: Explicit coerce_to overrides smart defaults
+  - get_items:
+      prompt: "List three fruits, one per line"
+  
+  - each: "get_items"
+    as: "fruit"
+    coerce_to: iterable  # Override default llm_boolean to iterable
+    steps:
+      - process_fruit: "Processing {{fruit}}"

data/examples/step_configuration/README.md

@@ -0,0 +1,87 @@
+# Step Configuration Example
+
+This example demonstrates how to configure various step types in Roast workflows, including:
+- Inline prompts
+- Iterator steps (each/repeat)
+- Regular steps
+
+## Configuration Options
+
+All step types support the following configuration options:
+
+- `model`: The AI model to use (e.g., "gpt-4o", "claude-3-opus")
+- `loop`: Whether to enable auto-looping (true/false)
+- `print_response`: Whether to print the response to stdout (true/false)
+- `json`: Whether to expect a JSON response (true/false)
+- `params`: Additional parameters to pass to the model (e.g., temperature, max_tokens)
+- `coerce_to`: How to convert the step result (options: "boolean", "llm_boolean", "iterable")
+
+## Configuration Precedence
+
+1. **Step-specific configuration** takes highest precedence
+2. **Global configuration** (defined at the workflow level) applies to all steps without specific configuration
+3. **Default values** are used when no configuration is provided
+
+## Inline Prompt Configuration
+
+Inline prompts can be configured in two ways:
+
+### As a top-level key:
+```yaml
+analyze the code:
+  model: gpt-4o
+  loop: false
+  print_response: true
+```
+
+### Inline in the steps array:
+```yaml
+steps:
+  - suggest improvements:
+      model: claude-3-opus
+      params:
+        temperature: 0.9
+```
+
+## Iterator Configuration
+
+Both `each` and `repeat` steps support configuration:
+
+```yaml
+each:
+  each: "{{files}}"
+  as: file
+  model: gpt-3.5-turbo
+  loop: false
+  steps:
+    - process {{file}}
+
+repeat:
+  repeat: true
+  until: "{{done}}"
+  model: gpt-4o
+  print_response: true
+  steps:
+    - check status
+```
+
+## Coercion Types
+
+The `coerce_to` option allows you to convert step results to specific types:
+
+- **`boolean`**: Converts any value to true/false (nil, false, empty string → false; everything else → true)
+- **`llm_boolean`**: Interprets natural language responses as boolean (e.g., "Yes", "Definitely!" → true; "No", "Not yet" → false)
+- **`iterable`**: Ensures the result can be iterated over (splits strings by newlines if needed)
+
+This is particularly useful when:
+- Using steps in conditional contexts (if/unless)
+- Using steps as conditions in repeat loops
+- Processing step results in each loops
+
+## Running the Example
+
+```bash
+bin/roast examples/step_configuration/workflow.yml
+```
+
+Note: This example is for demonstration purposes and shows the configuration syntax. You'll need to adapt it to your specific use case with appropriate prompts and logic.

data/examples/step_configuration/workflow.yml

@@ -0,0 +1,60 @@
+name: Step Configuration Example
+description: Demonstrates how to configure various step types including inline prompts, iterators, and regular steps
+
+# Global configuration that applies to all steps
+model: openai/gpt-4o-mini
+loop: true
+
+# Configuration for specific steps
+summarize the code:
+  model: claude-3-opus  # Override global model
+  loop: false          # Disable auto-loop for this step
+  print_response: true # Print the response
+  json: false          # Don't expect JSON response
+  params:
+    temperature: 0.7   # Custom temperature
+
+analyze complexity:
+  model: gpt-4o
+  json: true           # Expect JSON response
+  params:
+    temperature: 0.2   # Lower temperature for more consistent analysis
+
+# Iterator step configuration
+each:
+  each: "{{files}}"
+  as: file
+  model: gpt-3.5-turbo # Use a faster model for iteration
+  loop: false          # Don't loop on each iteration
+  steps:
+    - process {{file}}
+
+repeat:
+  repeat: true
+  until: "are all tests passing"  # This will be evaluated as a step
+  max_iterations: 5
+  model: gpt-4o
+  print_response: true
+  coerce_to: llm_boolean  # Interpret natural language response as boolean
+  steps:
+    - run tests
+    - fix failing tests
+
+# Step used in boolean context
+are all tests passing:
+  model: gpt-4o
+  coerce_to: llm_boolean  # Convert "Yes, all tests are passing!" to true
+  params:
+    temperature: 0.2
+
+# Steps can mix configured and unconfigured inline prompts
+steps:
+  - list all source files           # Uses global configuration
+  - summarize the code              # Uses step-specific configuration
+  - analyze complexity              # Uses step-specific configuration
+  - suggest improvements:           # Step-specific configuration inline
+      model: claude-3-opus
+      params:
+        temperature: 0.9
+  - each                           # Iterator with configuration
+  - repeat                         # Iterator with configuration

data/gemfiles/activesupport7.gemfile

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

data/gemfiles/activesupport8.gemfile

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

data/lib/roast/tools/grep.rb

@@ -28,10 +28,19 @@ module Roast
 
       def call(string)
         Roast::Helpers::Logger.info("🔍 Grepping for string: #{string}\n")
-        # Escape regex special characters in strings with curly braces
-        # Example: "import {render}" becomes "import \{render\}"
-        escaped_string = string.gsub(/(\{|\})/, '\\\\\\1')
-        %x(rg -C 4 --trim --color=never --heading -F -- "#{escaped_string}" . | head -n #{MAX_RESULT_LINES})
+
+        # Use Open3 to safely pass the string as an argument, avoiding shell injection
+        require "open3"
+        cmd = ["rg", "-C", "4", "--trim", "--color=never", "--heading", "-F", "--", string, "."]
+        stdout, _stderr, _status = Open3.capture3(*cmd)
+
+        # Limit output to MAX_RESULT_LINES
+        lines = stdout.lines
+        if lines.size > MAX_RESULT_LINES
+          lines.first(MAX_RESULT_LINES).join + "\n... (truncated to #{MAX_RESULT_LINES} lines)"
+        else
+          stdout
+        end
       rescue StandardError => e
         "Error grepping for string: #{e.message}".tap do |error_message|
           Roast::Helpers::Logger.error(error_message + "\n")

data/lib/roast/tools/search_file.rb

@@ -29,9 +29,9 @@ module Roast
         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|

data/lib/roast/tools.rb

@@ -52,7 +52,22 @@ module Roast
       # Hook that runs on any exit (including crashes and unhandled exceptions)
       at_exit do
         if $ERROR_INFO && !$ERROR_INFO.is_a?(SystemExit) # If exiting due to unhandled exception
-          puts "\n\nExiting due to error: #{$ERROR_INFO.class}: #{$ERROR_INFO.message}\n"
+          # Print a more user-friendly message based on the error type
+          case $ERROR_INFO
+          when Roast::Workflow::CommandExecutor::CommandExecutionError
+            puts "\n\n🛑 Workflow stopped due to command failure."
+            puts "   To continue execution despite command failures, you can:"
+            puts "   - Fix the failing command"
+            puts "   - Run with --verbose to see command output"
+            puts "   - Modify your workflow to handle errors gracefully"
+          when Roast::Workflow::WorkflowExecutor::StepExecutionError
+            puts "\n\n🛑 Workflow stopped due to step failure."
+            puts "   Check the error message above for details."
+          else
+            puts "\n\n🛑 Workflow stopped due to an unexpected error:"
+            puts "   #{$ERROR_INFO.class}: #{$ERROR_INFO.message}"
+          end
+          puts "\nFor debugging, you can run with --verbose for more details."
           # Temporary disable the debugger to fix directory issues
           # context.instance_eval { binding.irb }
         end

data/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

data/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"

data/lib/roast/version.rb

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

data/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 @@ module Roast
       def process_api_configuration
         extract_api_token
         extract_api_provider
+        extract_uri_base
       end
 
       def extract_api_token
@@ -49,6 +51,12 @@ module Roast
         @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"]

data/lib/roast/workflow/base_iteration_step.rb

@@ -26,14 +26,21 @@ module Roast
       def process_iteration_input(input, context, coerce_to: nil)
         if input.is_a?(String)
           if ruby_expression?(input)
+            # Default to regular boolean for ruby expressions
+            coerce_to ||= :boolean
             process_ruby_expression(input, context, coerce_to)
           elsif bash_command?(input)
+            # Default to boolean (which will interpret exit code) for bash commands
+            coerce_to ||= :boolean
             process_bash_command(input, coerce_to)
           else
+            # For prompts/steps, default to llm_boolean
+            coerce_to ||= :llm_boolean
             process_step_or_prompt(input, context, coerce_to)
           end
         else
-          # Non-string inputs are coerced as-is
+          # Non-string inputs default to regular boolean
+          coerce_to ||= :boolean
           coerce_result(input, coerce_to)
         end
       end
@@ -109,8 +116,20 @@ module Roast
         result = Roast::Tools::Cmd.call(command)
 
         if coerce_to == :boolean
-          # For boolean coercion, use exit status (assume success unless error message)
-          !result.to_s.start_with?("Error")
+          # For boolean coercion, check if command was allowed and exit status was 0
+          if result.to_s.start_with?("Error: Command not allowed")
+            return false
+          end
+
+          # Parse exit status from the output
+          # The Cmd tool returns output in format: "Command: X\nExit status: Y\nOutput:\nZ"
+          if result =~ /Exit status: (\d+)/
+            exit_status = ::Regexp.last_match(1).to_i
+            exit_status == 0
+          else
+            # If we can't parse exit status, assume success if no error
+            !result.to_s.start_with?("Error")
+          end
         else
           # For other uses, return the output
           result

data/lib/roast/workflow/base_step.rb

@@ -9,7 +9,7 @@ module Roast
     class BaseStep
       extend Forwardable
 
-      attr_accessor :model, :print_response, :auto_loop, :json, :params, :resource
+      attr_accessor :model, :print_response, :auto_loop, :json, :params, :resource, :coerce_to
       attr_reader :workflow, :name, :context_path
 
       def_delegator :workflow, :append_to_final_output
@@ -25,20 +25,33 @@ module Roast
         @auto_loop = auto_loop
         @json = false
         @params = {}
+        @coerce_to = nil
         @resource = workflow.resource if workflow.respond_to?(:resource)
       end
 
       def call
         prompt(read_sidecar_prompt)
-        chat_completion(print_response:, auto_loop:, json:, params:)
+        result = chat_completion(print_response:, auto_loop:, json:, params:)
+
+        # Apply coercion if configured
+        apply_coercion(result)
       end
 
       protected
 
-      def chat_completion(print_response: false, auto_loop: true, json: false, params: {})
+      def chat_completion(print_response: nil, auto_loop: nil, json: nil, params: nil)
+        # Use instance variables as defaults if parameters are not provided
+        print_response = @print_response if print_response.nil?
+        auto_loop = @auto_loop if auto_loop.nil?
+        json = @json if json.nil?
+        params = @params if params.nil?
+
         workflow.chat_completion(openai: workflow.openai? && model, loop: auto_loop, model: model, json:, params:).then do |response|
           case response
+          in Array if json
+            response.flatten.first
           in Array
+            # For non-JSON responses, join array elements
             response.map(&:presence).compact.join("\n")
           else
             response
@@ -73,6 +86,30 @@ module Roast
           append_to_final_output(response)
         end
       end
+
+      private
+
+      def apply_coercion(result)
+        return result unless @coerce_to
+
+        case @coerce_to
+        when :boolean
+          # Simple boolean coercion
+          !!result
+        when :llm_boolean
+          # Use LLM boolean coercer for natural language responses
+          require "roast/workflow/llm_boolean_coercer"
+          LlmBooleanCoercer.coerce(result)
+        when :iterable
+          # Ensure result is iterable
+          return result if result.respond_to?(:each)
+
+          result.to_s.split("\n")
+        else
+          # Unknown coercion type, return as-is
+          result
+        end
+      end
     end
   end
 end

data/lib/roast/workflow/base_workflow.rb

@@ -27,10 +27,12 @@ module Roast
         :configuration,
         :model
 
+      attr_reader :pre_processing_data
+
       delegate :api_provider, :openai?, to: :configuration
       delegate :output, :output=, :append_to_final_output, :final_output, to: :output_manager
 
-      def initialize(file = nil, name: nil, context_path: nil, resource: nil, session_name: nil, configuration: nil)
+      def initialize(file = nil, name: nil, context_path: nil, resource: nil, session_name: nil, configuration: nil, pre_processing_data: nil)
         @file = file
         @name = name || self.class.name.underscore.split("/").last
         @context_path = context_path || ContextPathResolver.resolve(self.class)
@@ -38,6 +40,7 @@ module Roast
         @session_name = session_name || @name
         @session_timestamp = nil
         @configuration = configuration
+        @pre_processing_data = pre_processing_data ? DotAccessHash.new(pre_processing_data).freeze : nil
 
         # Initialize managers
         @output_manager = OutputManager.new

data/lib/roast/workflow/case_executor.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Handles execution of case/when/else steps
+    class CaseExecutor
+      def initialize(workflow, context_path, state_manager, workflow_executor = nil)
+        @workflow = workflow
+        @context_path = context_path
+        @state_manager = state_manager
+        @workflow_executor = workflow_executor
+      end
+
+      def execute_case(case_config)
+        $stderr.puts "Executing case step: #{case_config.inspect}"
+
+        # Extract case expression
+        case_expr = case_config["case"]
+        when_clauses = case_config["when"]
+        case_config["else"]
+
+        # Verify required parameters
+        raise WorkflowExecutor::ConfigurationError, "Missing 'case' expression in case configuration" unless case_expr
+        raise WorkflowExecutor::ConfigurationError, "Missing 'when' clauses in case configuration" unless when_clauses
+
+        # Create and execute a CaseStep
+        require "roast/workflow/case_step" unless defined?(Roast::Workflow::CaseStep)
+        case_step = CaseStep.new(
+          @workflow,
+          config: case_config,
+          name: "case_#{case_expr.to_s.gsub(/[^a-zA-Z0-9_]/, "_")[0..30]}",
+          context_path: @context_path,
+          workflow_executor: @workflow_executor,
+        )
+
+        result = case_step.call
+
+        # Store the result in workflow output
+        step_name = "case_#{case_expr.to_s.gsub(/[^a-zA-Z0-9_]/, "_")[0..30]}"
+        @workflow.output[step_name] = result
+
+        # Save state
+        @state_manager.save_state(step_name, @workflow.output[step_name])
+
+        result
+      end
+    end
+  end
+end