roast-ai 0.1.6 → 0.2.0

data/lib/roast/workflow/base_iteration_step.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require "roast/workflow/expression_utils"
+require "roast/workflow/llm_boolean_coercer"
+require "roast/workflow/workflow_executor"
+
+module Roast
+  module Workflow
+    # Base class for iteration steps (RepeatStep and EachStep)
+    class BaseIterationStep < BaseStep
+      include ExpressionUtils
+
+      DEFAULT_MAX_ITERATIONS = 100
+
+      attr_reader :steps
+
+      def initialize(workflow, steps:, **kwargs)
+        super(workflow, **kwargs)
+        @steps = steps
+        # Don't initialize cmd_tool here - we'll do it lazily when needed
+      end
+
+      protected
+
+      # Process various types of inputs and convert to appropriate types for iteration
+      def process_iteration_input(input, context, coerce_to: nil)
+        if input.is_a?(String)
+          if ruby_expression?(input)
+            process_ruby_expression(input, context, coerce_to)
+          elsif bash_command?(input)
+            process_bash_command(input, coerce_to)
+          else
+            process_step_or_prompt(input, context, coerce_to)
+          end
+        else
+          # Non-string inputs are coerced as-is
+          coerce_result(input, coerce_to)
+        end
+      end
+
+      # Interpolates {{expression}} in a string with values from the workflow context
+      def interpolate_expression(text, context)
+        return text unless text.is_a?(String) && text.include?("{{") && text.include?("}}")
+
+        # Replace all {{expression}} with their evaluated values
+        text.gsub(/\{\{([^}]+)\}\}/) do |match|
+          expression = extract_expression(match)
+          begin
+            # Evaluate the expression in the workflow's context
+            result = context.instance_eval(expression)
+            result.inspect # Convert to string representation
+          rescue => e
+            warn_interpolation_error(expression, e)
+            match # Return the original match to preserve it in the string
+          end
+        end
+      end
+
+      # Execute nested steps
+      def execute_nested_steps(steps, context, executor = nil)
+        executor ||= WorkflowExecutor.new(context, {}, context_path)
+        results = []
+
+        steps.each do |step|
+          result = case step
+          when String
+            executor.execute_step(step)
+          when Hash, Array
+            executor.execute_steps([step])
+          end
+          results << result
+        end
+
+        results
+      end
+
+      private
+
+      # Process a Ruby expression
+      def process_ruby_expression(input, context, coerce_to)
+        expression = extract_expression(input)
+        result = evaluate_ruby_expression(expression, context)
+        coerce_result(result, coerce_to)
+      end
+
+      # Process a Bash command
+      def process_bash_command(input, coerce_to)
+        command = extract_command(input)
+        execute_command(command, coerce_to)
+      end
+
+      # Process a step name or prompt
+      def process_step_or_prompt(input, context, coerce_to)
+        step_result = execute_step_by_name(input, context)
+        coerce_result(step_result, coerce_to)
+      end
+
+      # Execute a Ruby expression in the workflow context
+      def evaluate_ruby_expression(expression, context)
+        context.instance_eval(expression)
+      rescue => e
+        warn_expression_error(expression, e)
+        nil
+      end
+
+      # Execute a bash command and return its result
+      def execute_command(command, coerce_to)
+        # Use the Cmd module to execute the command
+        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")
+        else
+          # For other uses, return the output
+          result
+        end
+      end
+
+      # Execute a step by name and return its result
+      def execute_step_by_name(step_name, context)
+        # Reuse existing step execution logic
+        executor = WorkflowExecutor.new(context, {}, context_path)
+        executor.execute_step(step_name)
+      end
+
+      # Coerce results to the appropriate type
+      def coerce_result(result, coerce_to)
+        return coerce_to_boolean(result) if coerce_to == :boolean
+        return coerce_to_iterable(result) if coerce_to == :iterable
+        return coerce_to_llm_boolean(result) if coerce_to == :llm_boolean
+
+        # Default - return as is
+        result
+      end
+
+      # Force a value to boolean
+      def coerce_to_boolean(result)
+        !!result
+      end
+
+      # Ensure a value is iterable
+      def coerce_to_iterable(result)
+        return result if result.respond_to?(:each)
+
+        result.to_s.split("\n")
+      end
+
+      # Convert LLM response to boolean
+      def coerce_to_llm_boolean(result)
+        LlmBooleanCoercer.coerce(result)
+      end
+
+      # Log a warning for expression evaluation errors
+      def warn_expression_error(expression, error)
+        $stderr.puts "Warning: Error evaluating expression '#{expression}': #{error.message}"
+      end
+
+      # Log a warning for interpolation errors
+      def warn_interpolation_error(expression, error)
+        $stderr.puts "Warning: Error interpolating {{#{expression}}}: #{error.message}"
+      end
+    end
+  end
+end

data/lib/roast/workflow/base_step.rb

@@ -2,6 +2,7 @@
 
 require "erb"
 require "forwardable"
+require "roast/workflow/context_path_resolver"
 
 module Roast
   module Workflow
@@ -15,11 +16,11 @@ module Roast
       def_delegator :workflow, :chat_completion
       def_delegator :workflow, :transcript
 
-      def initialize(workflow, model: "anthropic:claude-3-7-sonnet", name: nil, context_path: nil, auto_loop: true)
+      def initialize(workflow, model: "anthropic:claude-opus-4", name: nil, context_path: nil, auto_loop: true)
         @workflow = workflow
         @model = model
         @name = name || self.class.name.underscore.split("/").last
-        @context_path = context_path || determine_context_path
+        @context_path = context_path || ContextPathResolver.resolve(self.class)
         @print_response = false
         @auto_loop = auto_loop
         @json = false
@@ -35,7 +36,7 @@ module Roast
       protected
 
       def chat_completion(print_response: false, auto_loop: true, json: false, params: {})
-        workflow.chat_completion(openai: model, loop: auto_loop, json:, params:).then do |response|
+        workflow.chat_completion(openai: workflow.openai? && model, loop: auto_loop, model: model, json:, params:).then do |response|
           case response
           in Array
             response.map(&:presence).compact.join("\n")
@@ -47,27 +48,6 @@ module Roast
         end
       end
 
-      # Determine the directory where the actual class is defined, not BaseWorkflow
-      def determine_context_path
-        # Get the actual class's source file
-        klass = self.class
-
-        # Try to get the file path where the class is defined
-        path = if klass.name.include?("::")
-          # For namespaced classes like Roast::Workflow::Grading::Workflow
-          # Convert the class name to a relative path
-          class_path = klass.name.underscore + ".rb"
-          # Look through load path to find the actual file
-          $LOAD_PATH.map { |p| File.join(p, class_path) }.find { |f| File.exist?(f) }
-        else
-          # Fall back to the current file if we can't find it
-          __FILE__
-        end
-
-        # Return directory containing the class definition
-        File.dirname(path || __FILE__)
-      end
-
       def prompt(text)
         transcript << { user: text }
       end

data/lib/roast/workflow/base_workflow.rb

@@ -6,125 +6,128 @@ require "active_support"
 require "active_support/isolated_execution_state"
 require "active_support/notifications"
 require "active_support/core_ext/hash/indifferent_access"
+require "roast/workflow/output_manager"
+require "roast/workflow/context_path_resolver"
 
 module Roast
   module Workflow
     class BaseWorkflow
       include Raix::ChatCompletion
 
-      attr_reader :output
       attr_accessor :file,
         :concise,
         :output_file,
+        :pause_step_name,
         :verbose,
         :name,
         :context_path,
         :resource,
         :session_name,
         :session_timestamp,
-        :configuration
+        :configuration,
+        :model
+
+      delegate :api_provider, :openai?, to: :configuration
+      delegate :output, :output=, :append_to_final_output, :final_output, to: :output_manager
 
       def initialize(file = nil, name: nil, context_path: nil, resource: nil, session_name: nil, configuration: nil)
         @file = file
         @name = name || self.class.name.underscore.split("/").last
-        @context_path = context_path || determine_context_path
-        @final_output = []
-        @output = ActiveSupport::HashWithIndifferentAccess.new
+        @context_path = context_path || ContextPathResolver.resolve(self.class)
         @resource = resource || Roast::Resources.for(file)
         @session_name = session_name || @name
         @session_timestamp = nil
         @configuration = configuration
-        transcript << { system: read_sidecar_prompt }
-        Roast::Tools.setup_interrupt_handler(transcript)
-        Roast::Tools.setup_exit_handler(self)
-      end
-
-      # Custom writer for output to ensure it's always a HashWithIndifferentAccess
-      def output=(value)
-        @output = if value.is_a?(ActiveSupport::HashWithIndifferentAccess)
-          value
-        else
-          ActiveSupport::HashWithIndifferentAccess.new(value)
-        end
-      end
 
-      def append_to_final_output(message)
-        @final_output << message
-      end
+        # Initialize managers
+        @output_manager = OutputManager.new
 
-      def final_output
-        return @final_output if @final_output.is_a?(String)
-        return "" if @final_output.nil?
+        # Setup prompt and handlers
+        read_sidecar_prompt.then do |prompt|
+          next unless prompt
 
-        # 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
+          transcript << { system: prompt }
         end
+        Roast::Tools.setup_interrupt_handler(transcript)
+        Roast::Tools.setup_exit_handler(self)
       end
 
       # Override chat_completion to add instrumentation
       def chat_completion(**kwargs)
         start_time = Time.now
-        model = kwargs[:openai] || "default"
-
-        ActiveSupport::Notifications.instrument("roast.chat_completion.start", {
-          model: model,
-          parameters: kwargs.except(:openai),
-        })
-
-        result = super(**kwargs)
+        step_model = kwargs[:model]
+
+        with_model(step_model) do
+          ActiveSupport::Notifications.instrument("roast.chat_completion.start", {
+            model: model,
+            parameters: kwargs.except(:openai, :model),
+          })
+
+          # Call the parent module's chat_completion
+          # skip model because it is read directly from the model method
+          result = super(**kwargs.except(:model))
+          execution_time = Time.now - start_time
+
+          ActiveSupport::Notifications.instrument("roast.chat_completion.complete", {
+            success: true,
+            model: model,
+            parameters: kwargs.except(:openai, :model),
+            execution_time: execution_time,
+            response_size: result.to_s.length,
+          })
+          result
+        end
+      rescue Faraday::ResourceNotFound => e
         execution_time = Time.now - start_time
-
-        ActiveSupport::Notifications.instrument("roast.chat_completion.complete", {
-          success: true,
-          model: model,
-          parameters: kwargs.except(:openai),
-          execution_time: execution_time,
-          response_size: result.to_s.length,
-        })
-
-        result
+        message = e.response.dig(:body, "error", "message") || e.message
+        error = Roast::ResourceNotFoundError.new(message)
+        error.set_backtrace(e.backtrace)
+        log_and_raise_error(error, message, step_model || model, kwargs, execution_time)
       rescue => e
         execution_time = Time.now - start_time
+        log_and_raise_error(e, e.message, step_model || model, kwargs, execution_time)
+      end
 
-        ActiveSupport::Notifications.instrument("roast.chat_completion.error", {
-          error: e.class.name,
-          message: e.message,
-          model: model,
-          parameters: kwargs.except(:openai),
-          execution_time: execution_time,
-        })
-        raise
+      def with_model(model)
+        previous_model = @model
+        @model = model
+        yield
+      ensure
+        @model = previous_model
       end
 
       def workflow
         self
       end
 
-      private
+      # Expose output manager for state management
+      attr_reader :output_manager
 
-      # Determine the directory where the actual class is defined, not BaseWorkflow
-      def determine_context_path
-        # Get the actual class's source file
-        klass = self.class
-
-        # Try to get the file path where the class is defined
-        path = if klass.name.include?("::")
-          # For namespaced classes like Roast::Workflow::Grading::Workflow
-          # Convert the class name to a relative path
-          class_path = klass.name.underscore + ".rb"
-          # Look through load path to find the actual file
-          $LOAD_PATH.map { |p| File.join(p, class_path) }.find { |f| File.exist?(f) }
+      # Allow direct access to output values without 'output.' prefix
+      def method_missing(method_name, *args, &block)
+        if output.respond_to?(method_name)
+          output.send(method_name, *args, &block)
         else
-          # Fall back to the current file if we can't find it
-          __FILE__
+          super
         end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        output.respond_to?(method_name) || super
+      end
+
+      private
+
+      def log_and_raise_error(error, message, model, params, execution_time)
+        ActiveSupport::Notifications.instrument("roast.chat_completion.error", {
+          error: error.class.name,
+          message: message,
+          model: model,
+          parameters: params.except(:openai, :model),
+          execution_time: execution_time,
+        })
 
-        # Return directory containing the class definition
-        File.dirname(path || __FILE__)
+        raise error
       end
 
       def read_sidecar_prompt

data/lib/roast/workflow/command_executor.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "English"
+
+module Roast
+  module Workflow
+    class CommandExecutor
+      class CommandExecutionError < StandardError
+        attr_reader :command, :exit_status, :original_error
+
+        def initialize(message, command:, exit_status: nil, original_error: nil)
+          @command = command
+          @exit_status = exit_status
+          @original_error = original_error
+          super(message)
+        end
+      end
+
+      def initialize(logger: nil)
+        @logger = logger || NullLogger.new
+      end
+
+      def execute(command_string, exit_on_error: true)
+        command = extract_command(command_string)
+
+        output = %x(#{command})
+        exit_status = $CHILD_STATUS.exitstatus
+
+        handle_execution_result(
+          command: command,
+          output: output,
+          exit_status: exit_status,
+          success: $CHILD_STATUS.success?,
+          exit_on_error: exit_on_error,
+        )
+      rescue ArgumentError, CommandExecutionError
+        raise
+      rescue => e
+        handle_execution_error(
+          command: command,
+          error: e,
+          exit_on_error: exit_on_error,
+        )
+      end
+
+      private
+
+      def extract_command(command_string)
+        match = command_string.strip.match(/^\$\((.*)\)$/)
+        raise ArgumentError, "Invalid command format. Expected $(command), got: #{command_string}" unless match
+
+        match[1]
+      end
+
+      def handle_execution_result(command:, output:, exit_status:, success:, exit_on_error:)
+        return output if success
+
+        if exit_on_error
+          raise CommandExecutionError.new(
+            "Command exited with non-zero status (#{exit_status})",
+            command: command,
+            exit_status: exit_status,
+          )
+        else
+          @logger.warn("Command '#{command}' exited with non-zero status (#{exit_status}), continuing execution")
+          output + "\n[Exit status: #{exit_status}]"
+        end
+      end
+
+      def handle_execution_error(command:, error:, exit_on_error:)
+        if exit_on_error
+          raise CommandExecutionError.new(
+            "Failed to execute command '#{command}': #{error.message}",
+            command: command,
+            original_error: error,
+          )
+        else
+          @logger.warn("Command '#{command}' failed with error: #{error.message}, continuing execution")
+          "Error executing command: #{error.message}\n[Exit status: error]"
+        end
+      end
+
+      class NullLogger
+        def warn(_message); end
+      end
+    end
+  end
+end

data/lib/roast/workflow/conditional_executor.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Handles execution of conditional steps (if and unless)
+    class ConditionalExecutor
+      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_conditional(conditional_config)
+        $stderr.puts "Executing conditional step: #{conditional_config.inspect}"
+
+        # Determine if this is an 'if' or 'unless' condition
+        condition_expr = conditional_config["if"] || conditional_config["unless"]
+        is_unless = conditional_config.key?("unless")
+        then_steps = conditional_config["then"]
+
+        # Verify required parameters
+        raise WorkflowExecutor::ConfigurationError, "Missing condition in conditional configuration" unless condition_expr
+        raise WorkflowExecutor::ConfigurationError, "Missing 'then' steps in conditional configuration" unless then_steps
+
+        # Create and execute a ConditionalStep
+        require "roast/workflow/conditional_step" unless defined?(Roast::Workflow::ConditionalStep)
+        conditional_step = ConditionalStep.new(
+          @workflow,
+          config: conditional_config,
+          name: "conditional_#{condition_expr.gsub(/[^a-zA-Z0-9_]/, "_")[0..20]}",
+          context_path: @context_path,
+          workflow_executor: @workflow_executor,
+        )
+
+        result = conditional_step.call
+
+        # Store a marker in workflow output to indicate which branch was taken
+        condition_key = is_unless ? "unless" : "if"
+        step_name = "#{condition_key}_#{condition_expr.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/conditional_step.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "roast/workflow/base_step"
+require "roast/workflow/command_executor"
+require "roast/workflow/expression_utils"
+require "roast/workflow/interpolator"
+
+module Roast
+  module Workflow
+    class ConditionalStep < BaseStep
+      include ExpressionUtils
+
+      def initialize(workflow, config:, name:, context_path:, workflow_executor:, **kwargs)
+        super(workflow, name: name, context_path: context_path, **kwargs)
+
+        @config = config
+        @condition = config["if"] || config["unless"]
+        @is_unless = config.key?("unless")
+        @then_steps = config["then"] || []
+        @else_steps = config["else"] || []
+        @workflow_executor = workflow_executor
+      end
+
+      def call
+        # Evaluate the condition
+        condition_result = evaluate_condition(@condition)
+
+        # Invert the result if this is an 'unless' condition
+        condition_result = !condition_result if @is_unless
+
+        # Select which steps to execute based on the condition
+        steps_to_execute = condition_result ? @then_steps : @else_steps
+
+        # Execute the selected steps
+        unless steps_to_execute.empty?
+          @workflow_executor.execute_steps(steps_to_execute)
+        end
+
+        # Return a result indicating which branch was taken
+        { condition_result: condition_result, branch_executed: condition_result ? "then" : "else" }
+      end
+
+      private
+
+      def evaluate_condition(condition)
+        return false unless condition.is_a?(String)
+
+        if ruby_expression?(condition)
+          evaluate_ruby_expression(condition)
+        elsif bash_command?(condition)
+          evaluate_bash_command(condition)
+        else
+          # Treat as a step name or direct boolean
+          evaluate_step_or_value(condition)
+        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