roast-ai 0.1.6 → 0.2.0

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

data/lib/roast/workflow/configuration_loader.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Roast
+  module Workflow
+    # Handles loading and parsing of workflow configuration files
+    class ConfigurationLoader
+      class << self
+        # Load configuration from a YAML file
+        # @param workflow_path [String] Path to the workflow YAML file
+        # @return [Hash] The parsed configuration hash
+        def load(workflow_path)
+          validate_path!(workflow_path)
+          config_hash = YAML.load_file(workflow_path)
+          validate_config!(config_hash)
+          config_hash
+        end
+
+        # Extract the workflow name from config or path
+        # @param config_hash [Hash] The configuration hash
+        # @param workflow_path [String] Path to the workflow file
+        # @return [String] The workflow name
+        def extract_name(config_hash, workflow_path)
+          config_hash["name"] || File.basename(workflow_path, ".yml")
+        end
+
+        # Extract steps from the configuration
+        # @param config_hash [Hash] The configuration hash
+        # @return [Array] The steps array or empty array
+        def extract_steps(config_hash)
+          config_hash["steps"] || []
+        end
+
+        # Extract tools from the configuration
+        # @param config_hash [Hash] The configuration hash
+        # @return [Array] The tools array or empty array
+        def extract_tools(config_hash)
+          config_hash["tools"] || []
+        end
+
+        # Extract function configurations
+        # @param config_hash [Hash] The configuration hash
+        # @return [Hash] The functions configuration or empty hash
+        def extract_functions(config_hash)
+          config_hash["functions"] || {}
+        end
+
+        # Extract model from the configuration
+        # @param config_hash [Hash] The configuration hash
+        # @return [String, nil] The model name if specified
+        def extract_model(config_hash)
+          config_hash["model"]
+        end
+
+        # Extract target from config or options
+        # @param config_hash [Hash] The configuration hash
+        # @param options [Hash] Runtime options
+        # @return [String, nil] The target if specified
+        def extract_target(config_hash, options = {})
+          options[:target] || config_hash["target"]
+        end
+
+        private
+
+        def validate_path!(workflow_path)
+          raise ArgumentError, "Workflow path cannot be nil" if workflow_path.nil?
+          raise ArgumentError, "Workflow file not found: #{workflow_path}" unless File.exist?(workflow_path)
+          raise ArgumentError, "Workflow path must be a YAML file" unless workflow_path.end_with?(".yml", ".yaml")
+        end
+
+        def validate_config!(config_hash)
+          raise ArgumentError, "Invalid workflow configuration" unless config_hash.is_a?(Hash)
+        end
+      end
+    end
+  end
+end

data/lib/roast/workflow/configuration_parser.rb

@@ -1,12 +1,11 @@
 # frozen_string_literal: true
 
-require_relative "workflow_executor"
-require_relative "configuration"
-require_relative "../helpers/function_caching_interceptor"
+require "roast/workflow/configuration"
+require "roast/workflow/workflow_initializer"
+require "roast/workflow/workflow_runner"
 require "active_support"
 require "active_support/isolated_execution_state"
 require "active_support/notifications"
-require "raix"
 
 module Roast
   module Workflow
@@ -21,10 +20,12 @@ module Roast
         @configuration = Configuration.new(workflow_path, options)
         @options = options
         @files = files
-        @replay_processed = false # Initialize replay tracking
-        include_tools
-        load_roast_initializers
-        configure_api_client
+
+        # Initialize workflow dependencies
+        initializer = WorkflowInitializer.new(@configuration)
+        initializer.setup
+
+        @workflow_runner = WorkflowRunner.new(@configuration, @options)
       end
 
       def begin!
@@ -33,33 +34,18 @@ module Roast
         $stderr.puts "Workflow: #{configuration.workflow_path}"
         $stderr.puts "Options: #{options}"
 
-        name = configuration.basename
-        context_path = configuration.context_path
-
         ActiveSupport::Notifications.instrument("roast.workflow.start", {
           workflow_path: configuration.workflow_path,
           options: options,
-          name: name,
+          name: configuration.basename,
         })
 
         if files.any?
-          $stderr.puts "WARNING: Ignoring target parameter because files were provided: #{configuration.target}" if configuration.has_target?
-          files.each do |file|
-            $stderr.puts "Running workflow for file: #{file}"
-            setup_workflow(file.strip, name:, context_path:)
-            parse(configuration.steps)
-          end
+          @workflow_runner.run_for_files(files)
         elsif configuration.has_target?
-          configuration.target.lines.each do |file|
-            $stderr.puts "Running workflow for file: #{file.strip}"
-            setup_workflow(file.strip, name:, context_path:)
-            parse(configuration.steps)
-          end
+          @workflow_runner.run_for_targets
         else
-          # Handle targetless workflow - run once without a specific target
-          $stderr.puts "Running targetless workflow"
-          setup_workflow(nil, name:, context_path:)
-          parse(configuration.steps)
+          @workflow_runner.run_targetless
         end
       ensure
         execution_time = Time.now - start_time
@@ -70,227 +56,6 @@ module Roast
           execution_time: execution_time,
         })
       end
-
-      private
-
-      def setup_workflow(file, name:, context_path:)
-        session_name = configuration.name
-
-        @current_workflow = BaseWorkflow.new(
-          file,
-          name: name,
-          context_path: context_path,
-          resource: configuration.resource,
-          session_name: session_name,
-          configuration: configuration,
-        ).tap do |workflow|
-          workflow.output_file = options[:output] if options[:output].present?
-          workflow.verbose = options[:verbose] if options[:verbose].present?
-          workflow.concise = options[:concise] if options[:concise].present?
-        end
-      end
-
-      def include_tools
-        return unless configuration.tools.present?
-
-        BaseWorkflow.include(Raix::FunctionDispatch)
-        BaseWorkflow.include(Roast::Helpers::FunctionCachingInterceptor) # Add caching support
-        BaseWorkflow.include(*configuration.tools.map(&:constantize))
-      end
-
-      def load_roast_initializers
-        Roast::Initializers.load_all
-      end
-
-      def configure_api_client
-        return unless configuration.api_token
-
-        begin
-          case configuration.api_provider
-          when :openrouter
-            $stderr.puts "Configuring OpenRouter client with token from workflow"
-            require "open_router"
-
-            Raix.configure do |config|
-              config.openrouter_client = OpenRouter::Client.new(api_key: configuration.api_token)
-            end
-          else
-            $stderr.puts "Configuring OpenAI client with token from workflow"
-            require "openai"
-
-            Raix.configure do |config|
-              config.openai_client = OpenAI::Client.new(access_token: configuration.api_token)
-            end
-          end
-        rescue => e
-          Roast::Helpers::Logger.error("Error configuring API client: #{e.message}")
-          # Don't fail the workflow if client can't be configured
-        end
-      end
-
-      def load_state_and_update_steps(steps, skip_until, step_name, timestamp)
-        state_repository = FileStateRepository.new
-        state_data = nil
-
-        if timestamp
-          $stderr.puts "Looking for state before '#{step_name}' in session #{timestamp}..."
-          state_data = state_repository.load_state_before_step(current_workflow, step_name, timestamp: timestamp)
-          if state_data
-            $stderr.puts "Successfully loaded state with data from previous step"
-            restore_workflow_state(state_data)
-          else
-            $stderr.puts "Could not find suitable state data from a previous step to '#{step_name}' in session #{timestamp}."
-            $stderr.puts "Will run workflow from '#{step_name}' without prior context."
-          end
-        else
-          $stderr.puts "Looking for state before '#{step_name}' in most recent session..."
-          state_data = state_repository.load_state_before_step(current_workflow, step_name)
-          if state_data
-            $stderr.puts "Successfully loaded state with data from previous step"
-            restore_workflow_state(state_data)
-          else
-            $stderr.puts "Could not find suitable state data from a previous step to '#{step_name}'."
-            $stderr.puts "Will run workflow from '#{step_name}' without prior context."
-          end
-        end
-
-        # Always return steps from the requested index, regardless of state loading success
-        steps[skip_until..-1]
-      end
-
-      # Restore workflow state from loaded state data
-      def restore_workflow_state(state_data)
-        return unless state_data && current_workflow
-
-        # Restore output
-        if state_data[:output] && current_workflow.respond_to?(:output=)
-          # Use the setter which will ensure it's a HashWithIndifferentAccess
-          current_workflow.output = state_data[:output]
-        end
-
-        # Restore transcript if available
-        if state_data[:transcript] && current_workflow.respond_to?(:transcript=)
-          current_workflow.transcript = state_data[:transcript]
-        elsif state_data[:transcript] && current_workflow.respond_to?(:transcript) &&
-            current_workflow.transcript.respond_to?(:clear) &&
-            current_workflow.transcript.respond_to?(:<<)
-          current_workflow.transcript.clear
-          state_data[:transcript].each do |message|
-            current_workflow.transcript << message
-          end
-        end
-
-        # Restore final output if available
-        if state_data[: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 current_workflow.respond_to?(:final_output=)
-            current_workflow.final_output = final_output
-          elsif current_workflow.instance_variable_defined?(:@final_output)
-            current_workflow.instance_variable_set(:@final_output, final_output)
-          end
-        end
-      end
-
-      def parse(steps)
-        return run(steps) if steps.is_a?(String)
-
-        # Handle replay option - skip to the specified step
-        if @options[:replay] && !@replay_processed
-          replay_param = @options[:replay]
-          timestamp = nil
-          step_name = replay_param
-
-          # Check if timestamp is prepended (format: timestamp:step_name)
-          if 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
-          end
-
-          # Find step index by iterating through the steps
-          skip_until = find_step_index_in_array(steps, step_name)
-
-          if skip_until
-            $stderr.puts "Replaying from step: #{step_name}#{timestamp ? " (session: #{timestamp})" : ""}"
-            current_workflow.session_timestamp = timestamp if timestamp
-            steps = load_state_and_update_steps(steps, skip_until, step_name, timestamp)
-          else
-            $stderr.puts "Step #{step_name} not found in workflow, running from beginning"
-          end
-          @replay_processed = true # Mark that we've processed replay, so we don't do it again in recursive calls
-        end
-
-        # Use the WorkflowExecutor to execute the steps
-        executor = WorkflowExecutor.new(current_workflow, configuration.config_hash, configuration.context_path)
-        executor.execute_steps(steps)
-
-        $stderr.puts "🔥🔥🔥 ROAST COMPLETE! 🔥🔥🔥"
-
-        # Save the final output to the session directory
-        save_final_output(current_workflow)
-
-        # Save results to file if specified
-        if current_workflow.output_file
-          File.write(current_workflow.output_file, current_workflow.final_output)
-          $stdout.puts "Results saved to #{current_workflow.output_file}"
-        else
-          $stdout.puts current_workflow.final_output
-        end
-      end
-
-      # Delegates to WorkflowExecutor
-      def run(name)
-        executor = WorkflowExecutor.new(current_workflow, configuration.config_hash, configuration.context_path)
-        executor.execute_step(name)
-      end
-
-      def find_step_index_in_array(steps_array, step_name)
-        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 == step_name
-          when Array
-            # This is a parallel step container, search inside it
-            step.each_with_index do |substep, _substep_index|
-              case substep
-              when Hash
-                # Could be {name: command}
-                substep_key = substep.keys.first
-                return index if substep_key == step_name
-              when String
-                return index if substep == step_name
-              end
-            end
-          when String
-            return index if step == step_name
-          end
-        end
-        nil
-      end
-
-      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
     end
   end
 end

data/lib/roast/workflow/context_path_resolver.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Determines the context path for workflow and step classes
+    class ContextPathResolver
+      class << self
+        # Determine the directory where the actual class is defined
+        # @param klass [Class] The class to find the context path for
+        # @return [String] The directory path containing the class definition
+        def resolve(klass)
+          # 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) }
+          end
+
+          # Fall back to trying to get the source location
+          if path.nil? && klass.instance_methods(false).any?
+            # Try to get source location from any instance method
+            method = klass.instance_methods(false).first
+            source_location = klass.instance_method(method).source_location
+            path = source_location&.first
+          end
+
+          # Return directory containing the class definition
+          # or the current directory if we can't find it
+          File.dirname(path || Dir.pwd)
+        end
+
+        # Resolve context path for an instance
+        # @param instance [Object] The instance to find the context path for
+        # @return [String] The directory path containing the class definition
+        def resolve_for_instance(instance)
+          resolve(instance.class)
+        end
+      end
+    end
+  end
+end