roast-ai 0.2.0 → 0.2.1

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/lib/roast/version.rb

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

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

data/lib/roast/workflow/case_step.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "roast/workflow/base_step"
+require "roast/workflow/expression_evaluator"
+require "roast/workflow/interpolator"
+
+module Roast
+  module Workflow
+    class CaseStep < BaseStep
+      include ExpressionEvaluator
+
+      def initialize(workflow, config:, name:, context_path:, workflow_executor:, **kwargs)
+        super(workflow, name: name, context_path: context_path, **kwargs)
+
+        @config = config
+        @case_expression = config["case"]
+        @when_clauses = config["when"] || {}
+        @else_steps = config["else"] || []
+        @workflow_executor = workflow_executor
+      end
+
+      def call
+        # Evaluate the case expression to get the value to match against
+        case_value = evaluate_case_expression(@case_expression)
+
+        # Find the matching when clause
+        matched_key = find_matching_when_clause(case_value)
+
+        # Determine which steps to execute
+        steps_to_execute = if matched_key
+          @when_clauses[matched_key]
+        else
+          @else_steps
+        end
+
+        # Execute the selected steps
+        unless steps_to_execute.nil? || steps_to_execute.empty?
+          @workflow_executor.execute_steps(steps_to_execute)
+        end
+
+        # Return a result indicating which branch was taken
+        {
+          case_value: case_value,
+          matched_when: matched_key,
+          branch_executed: matched_key || (steps_to_execute.empty? ? "none" : "else"),
+        }
+      end
+
+      private
+
+      def evaluate_case_expression(expression)
+        return unless expression
+
+        # Handle interpolated expressions
+        if expression.is_a?(String)
+          interpolated = Interpolator.new(@workflow).interpolate(expression)
+
+          if ruby_expression?(interpolated)
+            evaluate_ruby_expression(interpolated)
+          elsif bash_command?(interpolated)
+            evaluate_bash_command(interpolated, for_condition: false)
+          else
+            # Return the interpolated value as-is
+            interpolated
+          end
+        else
+          expression
+        end
+      end
+
+      def find_matching_when_clause(case_value)
+        # Convert case_value to string for comparison
+        case_value_str = case_value.to_s
+
+        @when_clauses.keys.find do |when_key|
+          # Direct string comparison
+          when_key.to_s == case_value_str
+        end
+      end
+    end
+  end
+end

data/lib/roast/workflow/conditional_step.rb

@@ -1,14 +1,13 @@
 # frozen_string_literal: true
 
 require "roast/workflow/base_step"
-require "roast/workflow/command_executor"
-require "roast/workflow/expression_utils"
+require "roast/workflow/expression_evaluator"
 require "roast/workflow/interpolator"
 
 module Roast
   module Workflow
     class ConditionalStep < BaseStep
-      include ExpressionUtils
+      include ExpressionEvaluator
 
       def initialize(workflow, config:, name:, context_path:, workflow_executor:, **kwargs)
         super(workflow, name: name, context_path: context_path, **kwargs)
@@ -46,51 +45,15 @@ module Roast
         return false unless condition.is_a?(String)
 
         if ruby_expression?(condition)
-          evaluate_ruby_expression(condition)
+          # For conditionals, coerce result to boolean
+          !!evaluate_ruby_expression(condition)
         elsif bash_command?(condition)
-          evaluate_bash_command(condition)
+          evaluate_bash_command(condition, for_condition: true)
         else
           # Treat as a step name or direct boolean
-          evaluate_step_or_value(condition)
+          evaluate_step_or_value(condition, for_condition: true)
         end
       end
-
-      def evaluate_ruby_expression(expression)
-        expr = extract_expression(expression)
-        begin
-          !!@workflow.instance_eval(expr)
-        rescue => e
-          $stderr.puts "Warning: Error evaluating expression '#{expr}': #{e.message}"
-          false
-        end
-      end
-
-      def evaluate_bash_command(command)
-        cmd = extract_command(command)
-        executor = CommandExecutor.new(logger: Roast::Helpers::Logger)
-        begin
-          result = executor.execute(cmd, exit_on_error: false)
-          # For conditionals, we care about the exit status
-          result[:success]
-        rescue => e
-          $stderr.puts "Warning: Error executing command '#{cmd}': #{e.message}"
-          false
-        end
-      end
-
-      def evaluate_step_or_value(input)
-        # Check if it's a reference to a previous step output
-        if @workflow.output.key?(input)
-          result = @workflow.output[input]
-          # Coerce to boolean
-          return false if result.nil? || result == false || result == "" || result == "false"
-
-          return true
-        end
-
-        # Otherwise treat as a direct value
-        input.to_s.downcase == "true"
-      end
     end
   end
 end

data/lib/roast/workflow/expression_evaluator.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "roast/workflow/command_executor"
+require "roast/workflow/expression_utils"
+
+module Roast
+  module Workflow
+    # Shared module for evaluating expressions in workflow steps
+    module ExpressionEvaluator
+      include ExpressionUtils
+
+      # Evaluate a Ruby expression in the workflow context
+      # @param expression [String] The expression to evaluate
+      # @return [Object] The result of the expression
+      def evaluate_ruby_expression(expression)
+        expr = extract_expression(expression)
+        begin
+          @workflow.instance_eval(expr)
+        rescue => e
+          $stderr.puts "Warning: Error evaluating expression '#{expr}': #{e.message}"
+          nil
+        end
+      end
+
+      # Evaluate a bash command and return its output
+      # @param command [String] The command to execute
+      # @param for_condition [Boolean] If true, returns success status; if false, returns output
+      # @return [Boolean, String, nil] Command result based on for_condition flag
+      def evaluate_bash_command(command, for_condition: false)
+        cmd = command.start_with?("$(") ? command : extract_command(command)
+        executor = CommandExecutor.new(logger: Roast::Helpers::Logger)
+
+        begin
+          output = executor.execute(cmd, exit_on_error: false)
+
+          if for_condition
+            # For conditions, we care about the exit status (success = true)
+            # Check if output contains exit status marker
+            !output.include?("[Exit status:")
+          else
+            # For case expressions, we want the actual output
+            output.strip
+          end
+        rescue => e
+          $stderr.puts "Warning: Error executing command '#{cmd}': #{e.message}"
+          for_condition ? false : nil
+        end
+      end
+
+      # Evaluate a step reference or direct value
+      # @param input [String] The input to evaluate
+      # @return [Boolean, Object] The result for conditions, or the value itself
+      def evaluate_step_or_value(input, for_condition: false)
+        # Check if it's a reference to a previous step output
+        if @workflow.output.key?(input)
+          result = @workflow.output[input]
+
+          if for_condition
+            # Coerce to boolean for conditions
+            return false if result.nil? || result == false || result == "" || result == "false"
+
+            return true
+          else
+            # Return the actual value for case expressions
+            return result
+          end
+        end
+
+        # Otherwise treat as a direct value
+        if for_condition
+          input.to_s.downcase == "true"
+        else
+          input
+        end
+      end
+    end
+  end
+end

data/lib/roast/workflow/iteration_executor.rb

@@ -33,6 +33,9 @@ module Roast
           context_path: @context_path,
         )
 
+        # Apply configuration if provided
+        apply_step_configuration(repeat_step, repeat_config)
+
         results = repeat_step.call
 
         # Store results in workflow output
@@ -69,6 +72,9 @@ module Roast
           context_path: @context_path,
         )
 
+        # Apply configuration if provided
+        apply_step_configuration(each_step, each_config)
+
         results = each_step.call
 
         # Store results in workflow output
@@ -80,6 +86,18 @@ module Roast
 
         results
       end
+
+      private
+
+      # Apply configuration settings to a step
+      def apply_step_configuration(step, step_config)
+        step.print_response = step_config["print_response"] if step_config.key?("print_response")
+        step.auto_loop = step_config["loop"] if step_config.key?("loop")
+        step.json = step_config["json"] if step_config.key?("json")
+        step.params = step_config["params"] if step_config.key?("params")
+        step.model = step_config["model"] if step_config.key?("model")
+        step.coerce_to = step_config["coerce_to"].to_sym if step_config.key?("coerce_to")
+      end
     end
   end
 end

data/lib/roast/workflow/prompt_step.rb

@@ -9,7 +9,10 @@ module Roast
 
       def call
         prompt(name)
-        chat_completion(auto_loop: false, print_response: true)
+        result = chat_completion
+
+        # Apply coercion if configured
+        apply_coercion(result)
       end
     end
   end

data/lib/roast/workflow/repeat_step.rb

@@ -23,8 +23,8 @@ module Roast
 
         begin
           # Loop until condition is met or max_iterations is reached
-          # Process the until_condition based on its type with Boolean coercion
-          until process_iteration_input(@until_condition, workflow, coerce_to: :boolean) || (iteration >= @max_iterations)
+          # Process the until_condition based on its type with configured coercion
+          until process_iteration_input(@until_condition, workflow, coerce_to: @coerce_to) || (iteration >= @max_iterations)
             $stderr.puts "Repeat loop iteration #{iteration + 1}"
 
             # Execute the nested steps