roast-ai 0.1.7 → 0.2.0

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

data/lib/roast/workflow/configuration.rb

@@ -1,55 +1,46 @@
 # frozen_string_literal: true
 
-require "open3"
-require "yaml"
+require "active_support/core_ext/module/delegation"
+require "roast/workflow/api_configuration"
+require "roast/workflow/configuration_loader"
+require "roast/workflow/resource_resolver"
+require "roast/workflow/step_finder"
 
 module Roast
   module Workflow
     # 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, :api_token, :api_provider, :model, :resource
+      attr_reader :config_hash, :workflow_path, :name, :steps, :tools, :function_configs, :model, :resource
       attr_accessor :target
 
-      def initialize(workflow_path, options = {})
-        @workflow_path = workflow_path
-        @config_hash = YAML.load_file(workflow_path)
-
-        # Extract key configuration values
-        @name = @config_hash["name"] || File.basename(workflow_path, ".yml")
-        @steps = @config_hash["steps"] || []
+      delegate :api_provider, :openrouter?, :openai?, to: :api_configuration
 
-        # Process tools configuration
-        parse_tools
-
-        # Process function-specific configurations
-        parse_functions
-
-        # Read the target parameter
-        @target = options[:target] || @config_hash["target"]
+      # Delegate api_token to effective_token for backward compatibility
+      def api_token
+        @api_configuration.effective_token
+      end
 
-        # Process the target command if it's a shell command
-        @target = process_target(@target) if has_target?
+      def initialize(workflow_path, options = {})
+        @workflow_path = workflow_path
 
-        # Create the appropriate resource object for the target
-        if defined?(Roast::Resources)
-          @resource = if has_target?
-            Roast::Resources.for(@target)
-          else
-            Roast::Resources::NoneResource.new(nil)
-          end
-        end
+        # Load configuration using ConfigurationLoader
+        @config_hash = ConfigurationLoader.load(workflow_path)
 
-        # Process API token if provided
-        if @config_hash["api_token"]
-          @api_token = process_shell_command(@config_hash["api_token"])
-        end
+        # Extract basic configuration values
+        @name = ConfigurationLoader.extract_name(@config_hash, workflow_path)
+        @steps = ConfigurationLoader.extract_steps(@config_hash)
+        @tools = ConfigurationLoader.extract_tools(@config_hash)
+        @function_configs = ConfigurationLoader.extract_functions(@config_hash)
+        @model = ConfigurationLoader.extract_model(@config_hash)
 
-        # Determine API provider (defaults to OpenAI if not specified)
-        @api_provider = determine_api_provider
+        # Initialize components
+        @api_configuration = ApiConfiguration.new(@config_hash)
+        @step_finder = StepFinder.new(@steps)
 
-        # Extract default model if provided
-        @model = @config_hash["model"]
+        # Process target and resource
+        @target = ConfigurationLoader.extract_target(@config_hash, options)
+        process_resource
       end
 
       def context_path
@@ -76,62 +67,10 @@ module Roast
         # Handle different call patterns for backward compatibility
         if steps_array.is_a?(String) && target_step.nil?
           target_step = steps_array
-          steps_array = steps
-        elsif steps_array.is_a?(Array) && target_step.is_a?(String)
-          # This is the normal case - steps_array and target_step are provided
-        else
-          # Default to self.steps if just the target_step is provided
-          steps_array = steps
+          steps_array = nil
         end
 
-        # First, try using the new more detailed search
-        steps_array.each_with_index do |step, index|
-          case step
-          when Hash
-            # Could be {name: command} or {name: {substeps}}
-            step_key = step.keys.first
-            return index if step_key == target_step
-          when Array
-            # This is a parallel step container, search inside it
-            found = step.any? do |substep|
-              case substep
-              when Hash
-                substep.keys.first == target_step
-              when String
-                substep == target_step
-              else
-                false
-              end
-            end
-            return index if found
-          when String
-            return index if step == target_step
-          end
-        end
-
-        # Fall back to the original method using extract_step_name
-        steps_array.each_with_index do |step, index|
-          step_name = extract_step_name(step)
-          if step_name.is_a?(Array)
-            # For arrays (parallel steps), check if target is in the array
-            return index if step_name.flatten.include?(target_step)
-          elsif step_name == target_step
-            return index
-          end
-        end
-
-        nil
-      end
-
-      # Returns an array of all tool class names
-      def parse_tools
-        # Only support array format: ["Roast::Tools::Grep", "Roast::Tools::ReadFile"]
-        @tools = @config_hash["tools"] || []
-      end
-
-      # Parse function-specific configurations
-      def parse_functions
-        @function_configs = @config_hash["functions"] || {}
+        @step_finder.find_index(target_step, steps_array)
       end
 
       # Get configuration for a specific function
@@ -141,77 +80,15 @@ module Roast
         @function_configs[function_name.to_s] || {}
       end
 
-      def openrouter?
-        @api_provider == :openrouter
-      end
-
-      def openai?
-        @api_provider == :openai
-      end
-
       private
 
-      def determine_api_provider
-        return :openai unless @config_hash["api_provider"]
-
-        provider = @config_hash["api_provider"].to_s.downcase
-
-        case provider
-        when "openai"
-          :openai
-        when "openrouter"
-          :openrouter
-        else
-          Roast::Helpers::Logger.warn("Unknown API provider '#{provider}', defaulting to OpenAI")
-          :openai
-        end
-      end
-
-      def process_shell_command(command)
-        # If it's a bash command with the $(command) syntax
-        if command =~ /^\$\((.*)\)$/
-          return Open3.capture2e({}, ::Regexp.last_match(1)).first.strip
-        end
-
-        # Legacy % prefix for backward compatibility
-        if command.start_with?("% ")
-          return Open3.capture2e({}, *command.split(" ")[1..-1]).first.strip
-        end
-
-        # Not a shell command, return as is
-        command
-      end
-
-      def process_target(command)
-        # Process shell command first
-        processed = process_shell_command(command)
-
-        # If it's a glob pattern, return the full paths of the files it matches
-        if processed.include?("*")
-          matched_files = Dir.glob(processed)
-          # If no files match, return the pattern itself
-          return processed if matched_files.empty?
-
-          return matched_files.map { |file| File.expand_path(file) }.join("\n")
-        end
-
-        # For tests, if the command was already processed as a shell command and is simple,
-        # don't expand the path to avoid breaking existing tests
-        return processed if command != processed && !processed.include?("/")
+      attr_reader :api_configuration
 
-        # assumed to be a direct file path(s)
-        File.expand_path(processed)
-      end
-
-      def extract_step_name(step)
-        case step
-        when String
-          step
-        when Hash
-          step.keys.first
-        when Array
-          # For arrays, we'll need special handling as they contain multiple steps
-          step.map { |s| extract_step_name(s) }
+      def process_resource
+        if defined?(Roast::Resources)
+          @resource = ResourceResolver.resolve(@target, context_path)
+          # Update target with processed value for backward compatibility
+          @target = @resource.value if has_target?
         end
       end
     end