roast-ai 0.1.7 → 0.2.1

data/lib/roast/workflow/error_handler.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "active_support/notifications"
+require "roast/helpers/logger"
+require "roast/workflow/command_executor"
+
+module Roast
+  module Workflow
+    # Handles error logging and instrumentation for workflow execution
+    class ErrorHandler
+      def initialize
+        # Use the Roast logger singleton
+      end
+
+      def with_error_handling(step_name, resource_type: nil)
+        start_time = Time.now
+
+        ActiveSupport::Notifications.instrument("roast.step.start", {
+          step_name: step_name,
+          resource_type: resource_type,
+        })
+
+        result = yield
+
+        execution_time = Time.now - start_time
+
+        ActiveSupport::Notifications.instrument("roast.step.complete", {
+          step_name: step_name,
+          resource_type: resource_type,
+          success: true,
+          execution_time: execution_time,
+          result_size: result.to_s.length,
+        })
+
+        result
+      rescue WorkflowExecutor::WorkflowExecutorError => e
+        handle_workflow_error(e, step_name, resource_type, start_time)
+        raise
+      rescue CommandExecutor::CommandExecutionError => e
+        handle_workflow_error(e, step_name, resource_type, start_time)
+        raise
+      rescue => e
+        handle_generic_error(e, step_name, resource_type, start_time)
+      end
+
+      def log_error(message)
+        Roast::Helpers::Logger.error(message)
+      end
+
+      def log_warning(message)
+        Roast::Helpers::Logger.warn(message)
+      end
+
+      # Alias methods for compatibility
+      def error(message)
+        log_error(message)
+      end
+
+      def warn(message)
+        log_warning(message)
+      end
+
+      private
+
+      def handle_workflow_error(error, step_name, resource_type, start_time)
+        execution_time = Time.now - start_time
+
+        ActiveSupport::Notifications.instrument("roast.step.error", {
+          step_name: step_name,
+          resource_type: resource_type,
+          error: error.class.name,
+          message: error.message,
+          execution_time: execution_time,
+        })
+      end
+
+      def handle_generic_error(error, step_name, resource_type, start_time)
+        execution_time = Time.now - start_time
+
+        ActiveSupport::Notifications.instrument("roast.step.error", {
+          step_name: step_name,
+          resource_type: resource_type,
+          error: error.class.name,
+          message: error.message,
+          execution_time: execution_time,
+        })
+
+        # Wrap the original error with context about which step failed
+        raise WorkflowExecutor::StepExecutionError.new(
+          "Failed to execute step '#{step_name}': #{error.message}",
+          step_name: step_name,
+          original_error: error,
+        )
+      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/expression_utils.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Shared utilities for detecting and extracting expressions
+    module ExpressionUtils
+      # Check if the input is a Ruby expression in {{...}}
+      def ruby_expression?(input)
+        return false unless input.is_a?(String)
+
+        input.strip.start_with?("{{") && input.strip.end_with?("}}")
+      end
+
+      # Check if the input is a Bash command in $(...)
+      def bash_command?(input)
+        return false unless input.is_a?(String)
+
+        input.strip.start_with?("$(") && input.strip.end_with?(")")
+      end
+
+      # Extract the expression from {{...}}
+      def extract_expression(input)
+        return input unless ruby_expression?(input)
+
+        input.strip[2...-2].strip
+      end
+
+      # Extract the command from $(...)
+      def extract_command(input)
+        return input unless bash_command?(input)
+
+        input.strip[2...-1].strip
+      end
+    end
+  end
+end

data/lib/roast/workflow/file_state_repository.rb

@@ -2,8 +2,8 @@
 
 require "json"
 require "fileutils"
-require_relative "session_manager"
-require_relative "state_repository"
+require "roast/workflow/session_manager"
+require "roast/workflow/state_repository"
 
 module Roast
   module Workflow
@@ -28,6 +28,7 @@ module Roast
             timestamp: workflow.session_timestamp,
           )
           step_file = File.join(session_dir, format_step_filename(state_data[:order], step_name))
+          FileUtils.mkdir_p(File.dirname(step_file))
           File.write(step_file, JSON.pretty_generate(state_data))
         end
       rescue => e

data/lib/roast/workflow/interpolator.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    class Interpolator
+      def initialize(context, logger: nil)
+        @context = context
+        @logger = logger || NullLogger.new
+      end
+
+      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 context
+            @context.instance_eval(expression).to_s
+          rescue => e
+            # Provide a detailed error message but preserve the original expression
+            error_msg = "Error interpolating {{#{expression}}}: #{e.message}. This variable is not defined in the workflow context."
+            @logger.error(error_msg)
+            match # Preserve the original expression in the string
+          end
+        end
+      end
+
+      class NullLogger
+        def error(_message); end
+      end
+    end
+  end
+end

data/lib/roast/workflow/iteration_executor.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Handles execution of iteration steps (repeat and each)
+    class IterationExecutor
+      def initialize(workflow, context_path, state_manager)
+        @workflow = workflow
+        @context_path = context_path
+        @state_manager = state_manager
+      end
+
+      def execute_repeat(repeat_config)
+        $stderr.puts "Executing repeat step: #{repeat_config.inspect}"
+
+        # Extract parameters from the repeat configuration
+        steps = repeat_config["steps"]
+        until_condition = repeat_config["until"]
+        max_iterations = repeat_config["max_iterations"] || BaseIterationStep::DEFAULT_MAX_ITERATIONS
+
+        # Verify required parameters
+        raise WorkflowExecutor::ConfigurationError, "Missing 'steps' in repeat configuration" unless steps
+        raise WorkflowExecutor::ConfigurationError, "Missing 'until' condition in repeat configuration" unless until_condition
+
+        # Create and execute a RepeatStep
+        require "roast/workflow/repeat_step" unless defined?(RepeatStep)
+        repeat_step = RepeatStep.new(
+          @workflow,
+          steps: steps,
+          until_condition: until_condition,
+          max_iterations: max_iterations,
+          name: "repeat_#{@workflow.output.size}",
+          context_path: @context_path,
+        )
+
+        # Apply configuration if provided
+        apply_step_configuration(repeat_step, repeat_config)
+
+        results = repeat_step.call
+
+        # Store results in workflow output
+        step_name = "repeat_#{until_condition.gsub(/[^a-zA-Z0-9_]/, "_")}"
+        @workflow.output[step_name] = results
+
+        # Save state
+        @state_manager.save_state(step_name, results)
+
+        results
+      end
+
+      def execute_each(each_config)
+        $stderr.puts "Executing each step: #{each_config.inspect}"
+
+        # Extract parameters from the each configuration
+        collection_expr = each_config["each"]
+        variable_name = each_config["as"]
+        steps = each_config["steps"]
+
+        # Verify required parameters
+        raise WorkflowExecutor::ConfigurationError, "Missing collection expression in each configuration" unless collection_expr
+        raise WorkflowExecutor::ConfigurationError, "Missing 'as' variable name in each configuration" unless variable_name
+        raise WorkflowExecutor::ConfigurationError, "Missing 'steps' in each configuration" unless steps
+
+        # Create and execute an EachStep
+        require "roast/workflow/each_step" unless defined?(EachStep)
+        each_step = EachStep.new(
+          @workflow,
+          collection_expr: collection_expr,
+          variable_name: variable_name,
+          steps: steps,
+          name: "each_#{variable_name}",
+          context_path: @context_path,
+        )
+
+        # Apply configuration if provided
+        apply_step_configuration(each_step, each_config)
+
+        results = each_step.call
+
+        # Store results in workflow output
+        step_name = "each_#{variable_name}"
+        @workflow.output[step_name] = results
+
+        # Save state
+        @state_manager.save_state(step_name, results)
+
+        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/llm_boolean_coercer.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Handles intelligent coercion of LLM responses to boolean values
+    class LlmBooleanCoercer
+      # Patterns for detecting affirmative and negative responses
+      EXPLICIT_TRUE_PATTERN = /\A(yes|y|true|t|1)\z/i
+      EXPLICIT_FALSE_PATTERN = /\A(no|n|false|f|0)\z/i
+      AFFIRMATIVE_PATTERN = /\b(yes|true|correct|affirmative|confirmed|indeed|right|positive|agree|definitely|certainly|absolutely)\b/
+      NEGATIVE_PATTERN = /\b(no|false|incorrect|negative|denied|wrong|disagree|never)\b/
+
+      class << self
+        # Convert an LLM response to a boolean value
+        #
+        # @param result [Object] The value to coerce to boolean
+        # @return [Boolean] The coerced boolean value
+        def coerce(result)
+          return true if result.is_a?(TrueClass)
+          return false if result.is_a?(FalseClass) || result.nil?
+
+          text = result.to_s.downcase.strip
+
+          # Check for explicit boolean-like responses first
+          return true if text =~ EXPLICIT_TRUE_PATTERN
+          return false if text =~ EXPLICIT_FALSE_PATTERN
+
+          # Then check for these words within longer responses
+          has_affirmative = !!(text =~ AFFIRMATIVE_PATTERN)
+          has_negative = !!(text =~ NEGATIVE_PATTERN)
+
+          # Handle conflicts
+          if has_affirmative && has_negative
+            warn_ambiguity(result, "contains both affirmative and negative terms")
+            false
+          elsif has_affirmative
+            true
+          elsif has_negative
+            false
+          else
+            warn_ambiguity(result, "no clear boolean indicators found")
+            false
+          end
+        end
+
+        private
+
+        # Log a warning for ambiguous LLM boolean responses
+        def warn_ambiguity(result, reason)
+          $stderr.puts "Warning: Ambiguous LLM response for boolean conversion (#{reason}): '#{result.to_s.strip}'"
+        end
+      end
+    end
+  end
+end

data/lib/roast/workflow/output_handler.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "roast/workflow/file_state_repository"
+
+module Roast
+  module Workflow
+    # Handles output operations for workflows including saving final output and results
+    class OutputHandler
+      def save_final_output(workflow)
+        return unless workflow.respond_to?(:session_name) && workflow.session_name && workflow.respond_to?(:final_output)
+
+        begin
+          final_output = workflow.final_output.to_s
+          return if final_output.empty?
+
+          state_repository = FileStateRepository.new
+          output_file = state_repository.save_final_output(workflow, final_output)
+          $stderr.puts "Final output saved to: #{output_file}" if output_file
+        rescue => e
+          # Don't fail if saving output fails
+          $stderr.puts "Warning: Failed to save final output to session: #{e.message}"
+        end
+      end
+
+      def write_results(workflow)
+        if workflow.output_file
+          File.write(workflow.output_file, workflow.final_output)
+          $stdout.puts "Results saved to #{workflow.output_file}"
+        else
+          $stdout.puts workflow.final_output
+        end
+      end
+    end
+  end
+end

data/lib/roast/workflow/output_manager.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/indifferent_access"
+require "roast/workflow/dot_access_hash"
+
+module Roast
+  module Workflow
+    # Manages workflow output, including both the key-value output hash
+    # and the final output string/array
+    class OutputManager
+      def initialize
+        @output = ActiveSupport::HashWithIndifferentAccess.new
+        @output_wrapper = nil
+        @final_output = []
+      end
+
+      # Get output wrapped in DotAccessHash for dot notation access
+      def output
+        @output_wrapper ||= DotAccessHash.new(@output)
+      end
+
+      # Set output, ensuring it's always a HashWithIndifferentAccess
+      def output=(value)
+        @output = if value.is_a?(ActiveSupport::HashWithIndifferentAccess)
+          value
+        else
+          ActiveSupport::HashWithIndifferentAccess.new(value)
+        end
+        # Reset the wrapper when output changes
+        @output_wrapper = nil
+      end
+
+      # Append a message to the final output
+      def append_to_final_output(message)
+        @final_output << message
+      end
+
+      # Get the final output as a string
+      def final_output
+        return @final_output if @final_output.is_a?(String)
+        return "" if @final_output.nil?
+
+        # Handle array case (expected normal case)
+        if @final_output.respond_to?(:join)
+          @final_output.join("\n\n")
+        else
+          # Handle any other unexpected type by converting to string
+          @final_output.to_s
+        end
+      end
+
+      # Set the final output directly (used when loading from state)
+      attr_writer :final_output
+
+      # Get the raw output hash (for internal use)
+      def raw_output
+        @output
+      end
+
+      # Get a snapshot of the current state for persistence
+      def to_h
+        {
+          output: @output.to_h,
+          final_output: @final_output,
+        }
+      end
+
+      # Restore state from a hash
+      def from_h(data)
+        return unless data
+
+        self.output = data[:output] if data.key?(:output)
+        self.final_output = data[:final_output] if data.key?(:final_output)
+      end
+    end
+  end
+end

data/lib/roast/workflow/parallel_executor.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Executes workflow steps in parallel using threads
+    class ParallelExecutor
+      class << self
+        def execute(steps, executor)
+          new(executor).execute(steps)
+        end
+      end
+
+      def initialize(executor)
+        @executor = executor
+      end
+
+      def execute(steps)
+        threads = steps.map do |sub_step|
+          Thread.new do
+            # Each thread needs its own isolated execution context
+            Thread.current[:step] = sub_step
+            Thread.current[:result] = nil
+            Thread.current[:error] = nil
+
+            begin
+              # Execute the single step in this thread
+              @executor.execute_steps([sub_step])
+              Thread.current[:result] = :success
+            rescue => e
+              Thread.current[:error] = e
+            end
+          end
+        end
+
+        # Wait for all threads to complete
+        threads.each(&:join)
+
+        # Check for errors in any thread
+        threads.each_with_index do |thread, _index|
+          if thread[:error]
+            raise thread[:error]
+          end
+        end
+
+        :success
+      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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Executes steps repeatedly until a condition is met or max_iterations is reached
+    class RepeatStep < BaseIterationStep
+      attr_reader :until_condition, :max_iterations
+
+      def initialize(workflow, steps:, until_condition:, max_iterations: DEFAULT_MAX_ITERATIONS, **kwargs)
+        super(workflow, steps: steps, **kwargs)
+        @until_condition = until_condition
+        @max_iterations = max_iterations.to_i
+
+        # Ensure max_iterations is at least 1
+        @max_iterations = 1 if @max_iterations < 1
+      end
+
+      def call
+        iteration = 0
+        results = []
+
+        $stderr.puts "Starting repeat loop with max_iterations: #{@max_iterations}"
+
+        begin
+          # Loop until condition is met or max_iterations is reached
+          # 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
+            step_results = execute_nested_steps(@steps, workflow)
+            results << step_results
+
+            # Increment iteration counter
+            iteration += 1
+
+            # Save state after each iteration if the workflow supports it
+            save_iteration_state(iteration) if workflow.respond_to?(:session_name) && workflow.session_name
+          end
+
+          if iteration >= @max_iterations
+            $stderr.puts "Repeat loop reached maximum iterations (#{@max_iterations})"
+          else
+            $stderr.puts "Repeat loop condition satisfied after #{iteration} iterations"
+          end
+
+          # Return the results of all iterations
+          results
+        rescue => e
+          $stderr.puts "Error in repeat loop: #{e.message}"
+          raise
+        end
+      end
+
+      private
+
+      def save_iteration_state(iteration)
+        state_repository = FileStateRepository.new
+
+        # Save the current iteration count in the state
+        state_data = {
+          step_name: name,
+          iteration: iteration,
+          output: workflow.respond_to?(:output) ? workflow.output.clone : {},
+          transcript: workflow.respond_to?(:transcript) ? workflow.transcript.map(&:itself) : [],
+        }
+
+        state_repository.save_state(workflow, "#{name}_iteration_#{iteration}", state_data)
+      rescue => e
+        # Don't fail the workflow if state saving fails
+        $stderr.puts "Warning: Failed to save iteration state: #{e.message}"
+      end
+    end
+  end
+end