roast-ai 0.2.0 → 0.2.2

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/command_executor.rb

@@ -6,7 +6,7 @@ module Roast
   module Workflow
     class CommandExecutor
       class CommandExecutionError < StandardError
-        attr_reader :command, :exit_status, :original_error
+        attr_reader :command, :exit_status, :original_error, :output
 
         def initialize(message, command:, exit_status: nil, original_error: nil)
           @command = command
@@ -56,11 +56,14 @@ module Roast
         return output if success
 
         if exit_on_error
-          raise CommandExecutionError.new(
+          error = CommandExecutionError.new(
             "Command exited with non-zero status (#{exit_status})",
             command: command,
             exit_status: exit_status,
           )
+          # Store the output in the error
+          error.instance_variable_set(:@output, output)
+          raise error
         else
           @logger.warn("Command '#{command}' exited with non-zero status (#{exit_status}), continuing execution")
           output + "\n[Exit status: #{exit_status}]"

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/configuration.rb

@@ -11,10 +11,10 @@ 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, :model, :resource
+      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
@@ -30,6 +30,8 @@ module Roast
         # Extract basic configuration values
         @name = ConfigurationLoader.extract_name(@config_hash, workflow_path)
         @steps = ConfigurationLoader.extract_steps(@config_hash)
+        @pre_processing = ConfigurationLoader.extract_pre_processing(@config_hash)
+        @post_processing = ConfigurationLoader.extract_post_processing(@config_hash)
         @tools = ConfigurationLoader.extract_tools(@config_hash)
         @function_configs = ConfigurationLoader.extract_functions(@config_hash)
         @model = ConfigurationLoader.extract_model(@config_hash)

data/lib/roast/workflow/configuration_loader.rb

@@ -32,6 +32,20 @@ module Roast
           config_hash["steps"] || []
         end
 
+        # Extract pre-processing steps from the configuration
+        # @param config_hash [Hash] The configuration hash
+        # @return [Array] The pre_processing array or empty array
+        def extract_pre_processing(config_hash)
+          config_hash["pre_processing"] || []
+        end
+
+        # Extract post-processing steps from the configuration
+        # @param config_hash [Hash] The configuration hash
+        # @return [Array] The post_processing array or empty array
+        def extract_post_processing(config_hash)
+          config_hash["post_processing"] || []
+        end
+
         # Extract tools from the configuration
         # @param config_hash [Hash] The configuration hash
         # @return [Array] The tools array or empty array

data/lib/roast/workflow/error_handler.rb

@@ -85,6 +85,24 @@ module Roast
           execution_time: execution_time,
         })
 
+        # Print user-friendly error message based on error type
+        case error
+        when StepLoader::StepNotFoundError
+          $stderr.puts "\n❌ Step not found: '#{step_name}'"
+          $stderr.puts "   Please check that the step exists in your workflow's steps directory."
+          $stderr.puts "   Looking for: steps/#{step_name}.rb or steps/#{step_name}/prompt.md"
+        when NoMethodError
+          if error.message.include?("undefined method")
+            $stderr.puts "\n❌ Step error: '#{step_name}'"
+            $stderr.puts "   The step file exists but may be missing the 'call' method."
+            $stderr.puts "   Error: #{error.message}"
+          end
+        else
+          $stderr.puts "\n❌ Step failed: '#{step_name}'"
+          $stderr.puts "   Error: #{error.message}"
+          $stderr.puts "   This may be an issue with the step's implementation."
+        end
+
         # Wrap the original error with context about which step failed
         raise WorkflowExecutor::StepExecutionError.new(
           "Failed to execute step '#{step_name}': #{error.message}",

data/lib/roast/workflow/expression_evaluator.rb

@@ -0,0 +1,86 @@
+# 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)
+
+          # Print command output in verbose mode
+          if @workflow.verbose
+            $stderr.puts "Evaluating command: #{cmd}"
+            $stderr.puts "Command output:"
+            $stderr.puts output
+            $stderr.puts
+          end
+
+          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

data/lib/roast/workflow/step_executor_coordinator.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "roast/workflow/case_executor"
 require "roast/workflow/conditional_executor"
 require "roast/workflow/step_executor_factory"
 require "roast/workflow/step_type_resolver"
@@ -68,6 +69,8 @@ module Roast
           execute_iteration_step(step)
         when StepTypeResolver::CONDITIONAL_STEP
           execute_conditional_step(step)
+        when StepTypeResolver::CASE_STEP
+          execute_case_step(step)
         when StepTypeResolver::HASH_STEP
           execute_hash_step(step)
         when StepTypeResolver::PARALLEL_STEP
@@ -105,6 +108,15 @@ module Roast
         dependencies[:conditional_executor]
       end
 
+      def case_executor
+        @case_executor ||= dependencies[:case_executor] || CaseExecutor.new(
+          context.workflow,
+          context.context_path,
+          dependencies[:state_manager] || dependencies[:workflow_executor].state_manager,
+          workflow_executor,
+        )
+      end
+
       def step_orchestrator
         dependencies[:step_orchestrator]
       end
@@ -120,16 +132,42 @@ module Roast
         error_handler.with_error_handling(step, resource_type: resource_type) do
           $stderr.puts "Executing: #{step} (Resource type: #{resource_type || "unknown"})"
 
-          output = command_executor.execute(step, exit_on_error: exit_on_error)
+          begin
+            output = command_executor.execute(step, exit_on_error: exit_on_error)
+
+            # Print command output in verbose mode
+            workflow = context.workflow
+            if workflow.verbose
+              $stderr.puts "Command output:"
+              $stderr.puts output
+              $stderr.puts
+            end
 
-          # Add to transcript
-          workflow = context.workflow
-          workflow.transcript << {
-            user: "I just executed the following command: ```\n#{step}\n```\n\nHere is the output:\n\n```\n#{output}\n```",
-          }
-          workflow.transcript << { assistant: "Noted, thank you." }
+            # Add to transcript
+            workflow.transcript << {
+              user: "I just executed the following command: ```\n#{step}\n```\n\nHere is the output:\n\n```\n#{output}\n```",
+            }
+            workflow.transcript << { assistant: "Noted, thank you." }
+
+            output
+          rescue CommandExecutor::CommandExecutionError => e
+            # Print user-friendly error message
+            $stderr.puts "\n❌ Command failed: #{step}"
+            $stderr.puts "   Exit status: #{e.exit_status}" if e.exit_status
+
+            # Show command output if available
+            if e.respond_to?(:output) && e.output && !e.output.strip.empty?
+              $stderr.puts "   Command output:"
+              e.output.strip.split("\n").each do |line|
+                $stderr.puts "     #{line}"
+              end
+            elsif workflow && !workflow.verbose
+              $stderr.puts "   To see the command output, run with --verbose flag."
+            end
 
-          output
+            $stderr.puts "   This typically means the command returned an error.\n"
+            raise
+          end
         end
       end
 
@@ -154,6 +192,10 @@ module Roast
         conditional_executor.execute_conditional(step)
       end
 
+      def execute_case_step(step)
+        case_executor.execute_case(step)
+      end
+
       def execute_hash_step(step)
         name, command = step.to_a.flatten
         interpolated_name = interpolator.interpolate(name)

data/lib/roast/workflow/step_loader.rb

@@ -25,11 +25,11 @@ module Roast
       class StepNotFoundError < StepLoaderError; end
       class StepExecutionError < StepLoaderError; end
 
-      attr_reader :context
+      attr_reader :context, :phase
 
       delegate :workflow, :config_hash, :context_path, to: :context
 
-      def initialize(workflow, config_hash, context_path)
+      def initialize(workflow, config_hash, context_path, phase: :steps)
         # Support both old and new initialization patterns
         @context = if workflow.is_a?(WorkflowContext)
           workflow
@@ -40,6 +40,7 @@ module Roast
             context_path: context_path,
           )
         end
+        @phase = phase
       end
 
       # Finds and loads a step by name
@@ -51,7 +52,7 @@ module Roast
 
         # First check for a prompt step (contains spaces)
         if name.plain_text?
-          step = Roast::Workflow::PromptStep.new(workflow, name: name.to_s, auto_loop: false)
+          step = Roast::Workflow::PromptStep.new(workflow, name: name.to_s, auto_loop: true)
           configure_step(step, name.to_s)
           return step
         end
@@ -75,6 +76,12 @@ module Roast
 
       # Find a Ruby step file in various locations
       def find_step_file(step_name)
+        # Check in phase-specific directory first
+        if phase != :steps
+          phase_rb_path = File.join(context_path, phase.to_s, "#{step_name}.rb")
+          return phase_rb_path if File.file?(phase_rb_path)
+        end
+
         # Check in context path
         rb_file_path = File.join(context_path, "#{step_name}.rb")
         return rb_file_path if File.file?(rb_file_path)
@@ -88,6 +95,12 @@ module Roast
 
       # Find a step directory
       def find_step_directory(step_name)
+        # Check in phase-specific directory first
+        if phase != :steps
+          phase_step_path = File.join(context_path, phase.to_s, step_name)
+          return phase_step_path if File.directory?(phase_step_path)
+        end
+
         # Check in context path
         step_path = File.join(context_path, step_name)
         return step_path if File.directory?(step_path)
@@ -144,10 +157,11 @@ module Roast
 
       # Apply configuration settings to a step
       def apply_step_configuration(step, step_config)
-        step.print_response = step_config["print_response"] if step_config["print_response"].present?
-        step.auto_loop = step_config["loop"] if step_config["loop"].present?
-        step.json = step_config["json"] if step_config["json"].present?
-        step.params = step_config["params"] if step_config["params"].present?
+        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.coerce_to = step_config["coerce_to"].to_sym if step_config.key?("coerce_to")
       end
     end
   end

data/lib/roast/workflow/step_type_resolver.rb

@@ -9,6 +9,7 @@ module Roast
       GLOB_STEP = :glob
       ITERATION_STEP = :iteration
       CONDITIONAL_STEP = :conditional
+      CASE_STEP = :case
       HASH_STEP = :hash
       PARALLEL_STEP = :parallel
       STRING_STEP = :string
@@ -20,6 +21,9 @@ module Roast
       # Special step names for conditionals
       CONDITIONAL_STEPS = ["if", "unless"].freeze
 
+      # Special step name for case statements
+      CASE_STEPS = ["case"].freeze
+
       class << self
         # Resolve the type of a step
         # @param step [String, Hash, Array] The step to analyze
@@ -76,6 +80,16 @@ module Roast
           CONDITIONAL_STEPS.include?(step_name)
         end
 
+        # Check if a step is a case step
+        # @param step [Hash] The step to check
+        # @return [Boolean] true if it's a case step
+        def case_step?(step)
+          return false unless step.is_a?(Hash)
+
+          step_name = step.keys.first
+          CASE_STEPS.include?(step_name)
+        end
+
         # Extract the step name from various step formats
         # @param step [String, Hash, Array] The step
         # @return [String, nil] The step name or nil
@@ -107,6 +121,8 @@ module Roast
             ITERATION_STEP
           elsif conditional_step?(step)
             CONDITIONAL_STEP
+          elsif case_step?(step)
+            CASE_STEP
           else
             HASH_STEP
           end

data/lib/roast/workflow/workflow_execution_context.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/inflections"
+
+module Roast
+  module Workflow
+    # Manages execution context across pre-processing, target workflows, and post-processing phases
+    class WorkflowExecutionContext
+      attr_reader :pre_processing_output, :target_outputs
+
+      def initialize
+        @pre_processing_output = OutputManager.new
+        @target_outputs = {}
+      end
+
+      # Add output from a target workflow execution
+      def add_target_output(target, output_manager)
+        target_key = generate_target_key(target)
+        @target_outputs[target_key] = output_manager
+      end
+
+      # Get all data as a hash for post-processing
+      def to_h
+        {
+          pre_processing: @pre_processing_output.to_h,
+          targets: @target_outputs.transform_values(&:to_h),
+        }
+      end
+
+      private
+
+      def generate_target_key(target)
+        return "default" unless target
+
+        target.to_s.parameterize
+      end
+    end
+  end
+end