roast-ai 0.1.7 → 0.2.1

data/lib/roast/workflow/base_iteration_step.rb

@@ -0,0 +1,184 @@
+# 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)
+            # Default to regular boolean for ruby expressions
+            coerce_to ||= :boolean
+            process_ruby_expression(input, context, coerce_to)
+          elsif bash_command?(input)
+            # Default to boolean (which will interpret exit code) for bash commands
+            coerce_to ||= :boolean
+            process_bash_command(input, coerce_to)
+          else
+            # For prompts/steps, default to llm_boolean
+            coerce_to ||= :llm_boolean
+            process_step_or_prompt(input, context, coerce_to)
+          end
+        else
+          # Non-string inputs default to regular boolean
+          coerce_to ||= :boolean
+          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, check if command was allowed and exit status was 0
+          if result.to_s.start_with?("Error: Command not allowed")
+            return false
+          end
+
+          # Parse exit status from the output
+          # The Cmd tool returns output in format: "Command: X\nExit status: Y\nOutput:\nZ"
+          if result =~ /Exit status: (\d+)/
+            exit_status = ::Regexp.last_match(1).to_i
+            exit_status == 0
+          else
+            # If we can't parse exit status, assume success if no error
+            !result.to_s.start_with?("Error")
+          end
+        else
+          # For other uses, return the output
+          result
+        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,42 +2,56 @@
 
 require "erb"
 require "forwardable"
+require "roast/workflow/context_path_resolver"
 
 module Roast
   module Workflow
     class BaseStep
       extend Forwardable
 
-      attr_accessor :model, :print_response, :auto_loop, :json, :params, :resource
+      attr_accessor :model, :print_response, :auto_loop, :json, :params, :resource, :coerce_to
       attr_reader :workflow, :name, :context_path
 
       def_delegator :workflow, :append_to_final_output
       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
         @params = {}
+        @coerce_to = nil
         @resource = workflow.resource if workflow.respond_to?(:resource)
       end
 
       def call
         prompt(read_sidecar_prompt)
-        chat_completion(print_response:, auto_loop:, json:, params:)
+        result = chat_completion(print_response:, auto_loop:, json:, params:)
+
+        # Apply coercion if configured
+        apply_coercion(result)
       end
 
       protected
 
-      def chat_completion(print_response: false, auto_loop: true, json: false, params: {})
-        workflow.chat_completion(openai: model, loop: auto_loop, json:, params:).then do |response|
+      def chat_completion(print_response: nil, auto_loop: nil, json: nil, params: nil)
+        # Use instance variables as defaults if parameters are not provided
+        print_response = @print_response if print_response.nil?
+        auto_loop = @auto_loop if auto_loop.nil?
+        json = @json if json.nil?
+        params = @params if params.nil?
+
+        workflow.chat_completion(openai: workflow.openai? && model, loop: auto_loop, model: model, json:, params:).then do |response|
           case response
+          in Array if json
+            response.flatten.first
           in Array
+            # For non-JSON responses, join array elements
             response.map(&:presence).compact.join("\n")
           else
             response
@@ -47,27 +61,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
@@ -93,6 +86,30 @@ module Roast
           append_to_final_output(response)
         end
       end
+
+      private
+
+      def apply_coercion(result)
+        return result unless @coerce_to
+
+        case @coerce_to
+        when :boolean
+          # Simple boolean coercion
+          !!result
+        when :llm_boolean
+          # Use LLM boolean coercer for natural language responses
+          require "roast/workflow/llm_boolean_coercer"
+          LlmBooleanCoercer.coerce(result)
+        when :iterable
+          # Ensure result is iterable
+          return result if result.respond_to?(:each)
+
+          result.to_s.split("\n")
+        else
+          # Unknown coercion type, return as-is
+          result
+        end
+      end
     end
   end
 end

data/lib/roast/workflow/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/case_executor.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Handles execution of case/when/else steps
+    class CaseExecutor
+      def initialize(workflow, context_path, state_manager, workflow_executor = nil)
+        @workflow = workflow
+        @context_path = context_path
+        @state_manager = state_manager
+        @workflow_executor = workflow_executor
+      end
+
+      def execute_case(case_config)
+        $stderr.puts "Executing case step: #{case_config.inspect}"
+
+        # Extract case expression
+        case_expr = case_config["case"]
+        when_clauses = case_config["when"]
+        case_config["else"]
+
+        # Verify required parameters
+        raise WorkflowExecutor::ConfigurationError, "Missing 'case' expression in case configuration" unless case_expr
+        raise WorkflowExecutor::ConfigurationError, "Missing 'when' clauses in case configuration" unless when_clauses
+
+        # Create and execute a CaseStep
+        require "roast/workflow/case_step" unless defined?(Roast::Workflow::CaseStep)
+        case_step = CaseStep.new(
+          @workflow,
+          config: case_config,
+          name: "case_#{case_expr.to_s.gsub(/[^a-zA-Z0-9_]/, "_")[0..30]}",
+          context_path: @context_path,
+          workflow_executor: @workflow_executor,
+        )
+
+        result = case_step.call
+
+        # Store the result in workflow output
+        step_name = "case_#{case_expr.to_s.gsub(/[^a-zA-Z0-9_]/, "_")[0..30]}"
+        @workflow.output[step_name] = result
+
+        # Save state
+        @state_manager.save_state(step_name, @workflow.output[step_name])
+
+        result
+      end
+    end
+  end
+end

data/lib/roast/workflow/case_step.rb

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