roast-ai 0.1.7 → 0.2.0

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_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,85 @@
+# 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,
+        )
+
+        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,
+        )
+
+        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
+    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/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 Boolean coercion
+          until process_iteration_input(@until_condition, workflow, coerce_to: :boolean) || (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

data/lib/roast/workflow/replay_handler.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "roast/workflow/step_finder"
+require "roast/workflow/file_state_repository"
+
+module Roast
+  module Workflow
+    # Handles replay functionality for workflows
+    # Manages skipping to specific steps and loading previous state
+    class ReplayHandler
+      attr_reader :processed
+
+      def initialize(workflow, state_repository: nil)
+        @workflow = workflow
+        @state_repository = state_repository || FileStateRepository.new
+        @processed = false
+      end
+
+      def process_replay(steps, replay_option)
+        return steps unless replay_option && !@processed
+
+        timestamp, step_name = parse_replay_option(replay_option)
+        skip_index = StepFinder.find_index(steps, step_name)
+
+        if skip_index
+          $stderr.puts "Replaying from step: #{step_name}#{timestamp ? " (session: #{timestamp})" : ""}"
+          @workflow.session_timestamp = timestamp if timestamp && @workflow.respond_to?(:session_timestamp=)
+          steps = load_state_and_get_remaining_steps(steps, skip_index, step_name, timestamp)
+        else
+          $stderr.puts "Step #{step_name} not found in workflow, running from beginning"
+        end
+
+        @processed = true
+        steps
+      end
+
+      def load_state_and_restore(step_name, timestamp: nil)
+        state_data = if timestamp
+          $stderr.puts "Looking for state before '#{step_name}' in session #{timestamp}..."
+          @state_repository.load_state_before_step(@workflow, step_name, timestamp: timestamp)
+        else
+          $stderr.puts "Looking for state before '#{step_name}' in most recent session..."
+          @state_repository.load_state_before_step(@workflow, step_name)
+        end
+
+        if state_data
+          $stderr.puts "Successfully loaded state with data from previous step"
+          restore_workflow_state(state_data)
+        else
+          session_info = timestamp ? " in session #{timestamp}" : ""
+          $stderr.puts "Could not find suitable state data from a previous step to '#{step_name}'#{session_info}."
+          $stderr.puts "Will run workflow from '#{step_name}' without prior context."
+        end
+
+        state_data
+      end
+
+      private
+
+      def parse_replay_option(replay_param)
+        return [nil, replay_param] unless replay_param.include?(":")
+
+        timestamp, step_name = replay_param.split(":", 2)
+
+        # Validate timestamp format (YYYYMMDD_HHMMSS_LLL)
+        unless timestamp.match?(/^\d{8}_\d{6}_\d{3}$/)
+          raise ArgumentError, "Invalid timestamp format: #{timestamp}. Expected YYYYMMDD_HHMMSS_LLL"
+        end
+
+        [timestamp, step_name]
+      end
+
+      def load_state_and_get_remaining_steps(steps, skip_index, step_name, timestamp)
+        load_state_and_restore(step_name, timestamp: timestamp)
+        # Always return steps from the requested index, regardless of state loading success
+        steps[skip_index..-1]
+      end
+
+      def restore_workflow_state(state_data)
+        return unless state_data && @workflow
+
+        restore_output(state_data)
+        restore_transcript(state_data)
+        restore_final_output(state_data)
+      end
+
+      def restore_output(state_data)
+        return unless state_data.key?(:output)
+        return unless @workflow.respond_to?(:output=)
+
+        @workflow.output = state_data[:output]
+      end
+
+      def restore_transcript(state_data)
+        return unless state_data.key?(:transcript)
+        return unless @workflow.respond_to?(:transcript)
+
+        # Transcript is an array from Raix::ChatCompletion
+        # We need to clear it and repopulate it
+        if @workflow.transcript.respond_to?(:clear) && @workflow.transcript.respond_to?(:<<)
+          @workflow.transcript.clear
+          state_data[:transcript].each do |message|
+            @workflow.transcript << message
+          end
+        end
+      end
+
+      def restore_final_output(state_data)
+        return unless state_data.key?(:final_output)
+
+        # Make sure final_output is always handled as an array
+        final_output = state_data[:final_output]
+        final_output = [final_output] if final_output.is_a?(String)
+
+        if @workflow.respond_to?(:final_output=)
+          @workflow.final_output = final_output
+        elsif @workflow.instance_variable_defined?(:@final_output)
+          @workflow.instance_variable_set(:@final_output, final_output)
+        end
+      end
+    end
+  end
+end