roast-ai 0.1.7 → 0.2.1

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

data/lib/roast/workflow/dot_access_hash.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    class DotAccessHash
+      def initialize(hash)
+        @hash = hash || {}
+      end
+
+      def [](key)
+        value = @hash[key.to_sym] || @hash[key.to_s]
+        value.is_a?(Hash) ? DotAccessHash.new(value) : value
+      end
+
+      def []=(key, value)
+        @hash[key.to_sym] = value
+      end
+
+      def method_missing(method_name, *args, &block)
+        method_str = method_name.to_s
+
+        # Handle boolean predicate methods (ending with ?)
+        if method_str.end_with?("?")
+          key = method_str.chomp("?")
+          # Always return false for non-existent keys with ? methods
+          return false unless has_key?(key) # rubocop:disable Style/PreferredHashMethods
+
+          !!self[key]
+        # Handle setter methods (ending with =)
+        elsif method_str.end_with?("=")
+          key = method_str.chomp("=")
+          self[key] = args.first
+        # Handle bang methods (ending with !) - should raise
+        elsif method_str.end_with?("!")
+          super
+        # Handle regular getter methods
+        elsif args.empty? && block.nil?
+          # Return nil for non-existent keys (like a hash would)
+          self[method_str]
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        method_str = method_name.to_s
+
+        if method_str.end_with?("!")
+          false # Don't respond to bang methods
+        elsif method_str.end_with?("?")
+          true  # Always respond to predicate methods
+        elsif method_str.end_with?("=")
+          true  # Always respond to setter methods
+        else
+          true  # Always respond to getter methods (they return nil if missing)
+        end
+      end
+
+      def to_h
+        @hash
+      end
+
+      def keys
+        @hash.keys
+      end
+
+      def empty?
+        @hash.empty?
+      end
+
+      def each(&block)
+        @hash.each(&block)
+      end
+
+      def to_s
+        @hash.to_s
+      end
+
+      def inspect
+        @hash.inspect
+      end
+
+      def to_json(*args)
+        @hash.to_json(*args)
+      end
+
+      def merge(other)
+        merged_hash = @hash.dup
+        other_hash = other.is_a?(DotAccessHash) ? other.to_h : other
+        merged_hash.merge!(other_hash)
+        DotAccessHash.new(merged_hash)
+      end
+
+      def values
+        @hash.values
+      end
+
+      def key?(key)
+        has_key?(key) # rubocop:disable Style/PreferredHashMethods
+      end
+
+      def include?(key)
+        has_key?(key) # rubocop:disable Style/PreferredHashMethods
+      end
+
+      def fetch(key, *args)
+        if has_key?(key) # rubocop:disable Style/PreferredHashMethods
+          self[key]
+        elsif block_given?
+          yield(key)
+        elsif !args.empty?
+          args[0]
+        else
+          raise KeyError, "key not found: #{key.inspect}"
+        end
+      end
+
+      def dig(*keys)
+        keys.inject(self) do |obj, key|
+          break nil unless obj.is_a?(DotAccessHash) || obj.is_a?(Hash)
+
+          if obj.is_a?(DotAccessHash)
+            obj[key]
+          else
+            obj[key.to_sym] || obj[key.to_s]
+          end
+        end
+      end
+
+      def size
+        @hash.size
+      end
+
+      alias_method :length, :size
+
+      def map(&block)
+        @hash.map(&block)
+      end
+
+      def select(&block)
+        DotAccessHash.new(@hash.select(&block))
+      end
+
+      def reject(&block)
+        DotAccessHash.new(@hash.reject(&block))
+      end
+
+      def compact
+        DotAccessHash.new(@hash.compact)
+      end
+
+      def slice(*keys)
+        sliced = {}
+        keys.each do |key|
+          if has_key?(key) # rubocop:disable Style/PreferredHashMethods
+            sliced[key.to_sym] = @hash[key.to_sym] || @hash[key.to_s]
+          end
+        end
+        DotAccessHash.new(sliced)
+      end
+
+      def except(*keys)
+        excluded = @hash.dup
+        keys.each do |key|
+          excluded.delete(key.to_sym)
+          excluded.delete(key.to_s)
+        end
+        DotAccessHash.new(excluded)
+      end
+
+      def delete(key)
+        @hash.delete(key.to_sym) || @hash.delete(key.to_s)
+      end
+
+      def clear
+        @hash.clear
+        self
+      end
+
+      def ==(other)
+        case other
+        when DotAccessHash
+          @hash == other.instance_variable_get(:@hash)
+        when Hash
+          @hash == other
+        else
+          false
+        end
+      end
+
+      def has_key?(key_name)
+        @hash.key?(key_name.to_sym) || @hash.key?(key_name.to_s)
+      end
+
+      alias_method :member?, :has_key?
+    end
+  end
+end

data/lib/roast/workflow/each_step.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Executes steps for each item in a collection
+    class EachStep < BaseIterationStep
+      attr_reader :collection_expr, :variable_name
+
+      def initialize(workflow, collection_expr:, variable_name:, steps:, **kwargs)
+        super(workflow, steps: steps, **kwargs)
+        @collection_expr = collection_expr
+        @variable_name = variable_name
+      end
+
+      def call
+        # Process the collection expression with appropriate type coercion
+        collection = process_iteration_input(@collection_expr, workflow, coerce_to: :iterable)
+
+        unless collection.respond_to?(:each)
+          $stderr.puts "Error: Collection '#{@collection_expr}' is not iterable"
+          raise ArgumentError, "Collection '#{@collection_expr}' is not iterable"
+        end
+
+        results = []
+        $stderr.puts "Starting each loop over collection with #{collection.size} items"
+
+        # Iterate over the collection
+        collection.each_with_index do |item, index|
+          $stderr.puts "Each loop iteration #{index + 1} with #{@variable_name}=#{item.inspect}"
+
+          # Create a context with the current item as a variable
+          define_iteration_variable(item)
+
+          # Execute the nested steps
+          step_results = execute_nested_steps(@steps, workflow)
+          results << step_results
+
+          # Save state after each iteration if the workflow supports it
+          save_iteration_state(index, item) if workflow.respond_to?(:session_name) && workflow.session_name
+        end
+
+        $stderr.puts "Each loop completed with #{collection.size} iterations"
+        results
+      end
+
+      private
+
+      # Keep for backward compatibility, deprecated
+      def resolve_collection
+        process_iteration_input(@collection_expr, workflow, coerce_to: :iterable)
+      end
+
+      def define_iteration_variable(value)
+        # Set the variable in the workflow's context
+        workflow.instance_variable_set("@#{@variable_name}", value)
+
+        # Define a getter method for the variable
+        var_name = @variable_name.to_sym
+        workflow.singleton_class.class_eval do
+          attr_reader(var_name)
+        end
+
+        # Make the variable accessible in the output hash
+        workflow.output[@variable_name] = value if workflow.respond_to?(:output)
+      end
+
+      def save_iteration_state(index, item)
+        state_repository = FileStateRepository.new
+
+        # Save the current iteration state
+        state_data = {
+          step_name: name,
+          iteration_index: index,
+          current_item: item,
+          output: workflow.respond_to?(:output) ? workflow.output.clone : {},
+          transcript: workflow.respond_to?(:transcript) ? workflow.transcript.map(&:itself) : [],
+        }
+
+        state_repository.save_state(workflow, "#{name}_item_#{index}", state_data)
+      rescue => e
+        # Don't fail the workflow if state saving fails
+        $stderr.puts "Warning: Failed to save iteration state: #{e.message}"
+      end
+    end
+  end
+end