roast-ai 0.1.6 → 0.2.0

data/lib/roast/workflow/output_manager.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/indifferent_access"
+require "roast/workflow/dot_access_hash"
+
+module Roast
+  module Workflow
+    # Manages workflow output, including both the key-value output hash
+    # and the final output string/array
+    class OutputManager
+      def initialize
+        @output = ActiveSupport::HashWithIndifferentAccess.new
+        @output_wrapper = nil
+        @final_output = []
+      end
+
+      # Get output wrapped in DotAccessHash for dot notation access
+      def output
+        @output_wrapper ||= DotAccessHash.new(@output)
+      end
+
+      # Set output, ensuring it's always a HashWithIndifferentAccess
+      def output=(value)
+        @output = if value.is_a?(ActiveSupport::HashWithIndifferentAccess)
+          value
+        else
+          ActiveSupport::HashWithIndifferentAccess.new(value)
+        end
+        # Reset the wrapper when output changes
+        @output_wrapper = nil
+      end
+
+      # Append a message to the final output
+      def append_to_final_output(message)
+        @final_output << message
+      end
+
+      # Get the final output as a string
+      def final_output
+        return @final_output if @final_output.is_a?(String)
+        return "" if @final_output.nil?
+
+        # 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
+        end
+      end
+
+      # Set the final output directly (used when loading from state)
+      attr_writer :final_output
+
+      # Get the raw output hash (for internal use)
+      def raw_output
+        @output
+      end
+
+      # Get a snapshot of the current state for persistence
+      def to_h
+        {
+          output: @output.to_h,
+          final_output: @final_output,
+        }
+      end
+
+      # Restore state from a hash
+      def from_h(data)
+        return unless data
+
+        self.output = data[:output] if data.key?(:output)
+        self.final_output = data[:final_output] if data.key?(:final_output)
+      end
+    end
+  end
+end

data/lib/roast/workflow/parallel_executor.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Executes workflow steps in parallel using threads
+    class ParallelExecutor
+      class << self
+        def execute(steps, executor)
+          new(executor).execute(steps)
+        end
+      end
+
+      def initialize(executor)
+        @executor = executor
+      end
+
+      def execute(steps)
+        threads = steps.map do |sub_step|
+          Thread.new do
+            # Each thread needs its own isolated execution context
+            Thread.current[:step] = sub_step
+            Thread.current[:result] = nil
+            Thread.current[:error] = nil
+
+            begin
+              # Execute the single step in this thread
+              @executor.execute_steps([sub_step])
+              Thread.current[:result] = :success
+            rescue => e
+              Thread.current[:error] = e
+            end
+          end
+        end
+
+        # Wait for all threads to complete
+        threads.each(&:join)
+
+        # Check for errors in any thread
+        threads.each_with_index do |thread, _index|
+          if thread[:error]
+            raise thread[:error]
+          end
+        end
+
+        :success
+      end
+    end
+  end
+end

data/lib/roast/workflow/repeat_step.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Executes steps repeatedly until a condition is met or max_iterations is reached
+    class RepeatStep < BaseIterationStep
+      attr_reader :until_condition, :max_iterations
+
+      def initialize(workflow, steps:, until_condition:, max_iterations: DEFAULT_MAX_ITERATIONS, **kwargs)
+        super(workflow, steps: steps, **kwargs)
+        @until_condition = until_condition
+        @max_iterations = max_iterations.to_i
+
+        # Ensure max_iterations is at least 1
+        @max_iterations = 1 if @max_iterations < 1
+      end
+
+      def call
+        iteration = 0
+        results = []
+
+        $stderr.puts "Starting repeat loop with max_iterations: #{@max_iterations}"
+
+        begin
+          # Loop until condition is met or max_iterations is reached
+          # Process the until_condition based on its type with Boolean coercion
+          until process_iteration_input(@until_condition, workflow, coerce_to: :boolean) || (iteration >= @max_iterations)
+            $stderr.puts "Repeat loop iteration #{iteration + 1}"
+
+            # Execute the nested steps
+            step_results = execute_nested_steps(@steps, workflow)
+            results << step_results
+
+            # Increment iteration counter
+            iteration += 1
+
+            # Save state after each iteration if the workflow supports it
+            save_iteration_state(iteration) if workflow.respond_to?(:session_name) && workflow.session_name
+          end
+
+          if iteration >= @max_iterations
+            $stderr.puts "Repeat loop reached maximum iterations (#{@max_iterations})"
+          else
+            $stderr.puts "Repeat loop condition satisfied after #{iteration} iterations"
+          end
+
+          # Return the results of all iterations
+          results
+        rescue => e
+          $stderr.puts "Error in repeat loop: #{e.message}"
+          raise
+        end
+      end
+
+      private
+
+      def save_iteration_state(iteration)
+        state_repository = FileStateRepository.new
+
+        # Save the current iteration count in the state
+        state_data = {
+          step_name: name,
+          iteration: iteration,
+          output: workflow.respond_to?(:output) ? workflow.output.clone : {},
+          transcript: workflow.respond_to?(:transcript) ? workflow.transcript.map(&:itself) : [],
+        }
+
+        state_repository.save_state(workflow, "#{name}_iteration_#{iteration}", 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

data/lib/roast/workflow/replay_handler.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "roast/workflow/step_finder"
+require "roast/workflow/file_state_repository"
+
+module Roast
+  module Workflow
+    # Handles replay functionality for workflows
+    # Manages skipping to specific steps and loading previous state
+    class ReplayHandler
+      attr_reader :processed
+
+      def initialize(workflow, state_repository: nil)
+        @workflow = workflow
+        @state_repository = state_repository || FileStateRepository.new
+        @processed = false
+      end
+
+      def process_replay(steps, replay_option)
+        return steps unless replay_option && !@processed
+
+        timestamp, step_name = parse_replay_option(replay_option)
+        skip_index = StepFinder.find_index(steps, step_name)
+
+        if skip_index
+          $stderr.puts "Replaying from step: #{step_name}#{timestamp ? " (session: #{timestamp})" : ""}"
+          @workflow.session_timestamp = timestamp if timestamp && @workflow.respond_to?(:session_timestamp=)
+          steps = load_state_and_get_remaining_steps(steps, skip_index, step_name, timestamp)
+        else
+          $stderr.puts "Step #{step_name} not found in workflow, running from beginning"
+        end
+
+        @processed = true
+        steps
+      end
+
+      def load_state_and_restore(step_name, timestamp: nil)
+        state_data = if timestamp
+          $stderr.puts "Looking for state before '#{step_name}' in session #{timestamp}..."
+          @state_repository.load_state_before_step(@workflow, step_name, timestamp: timestamp)
+        else
+          $stderr.puts "Looking for state before '#{step_name}' in most recent session..."
+          @state_repository.load_state_before_step(@workflow, step_name)
+        end
+
+        if state_data
+          $stderr.puts "Successfully loaded state with data from previous step"
+          restore_workflow_state(state_data)
+        else
+          session_info = timestamp ? " in session #{timestamp}" : ""
+          $stderr.puts "Could not find suitable state data from a previous step to '#{step_name}'#{session_info}."
+          $stderr.puts "Will run workflow from '#{step_name}' without prior context."
+        end
+
+        state_data
+      end
+
+      private
+
+      def parse_replay_option(replay_param)
+        return [nil, replay_param] unless 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
+
+        [timestamp, step_name]
+      end
+
+      def load_state_and_get_remaining_steps(steps, skip_index, step_name, timestamp)
+        load_state_and_restore(step_name, timestamp: timestamp)
+        # Always return steps from the requested index, regardless of state loading success
+        steps[skip_index..-1]
+      end
+
+      def restore_workflow_state(state_data)
+        return unless state_data && @workflow
+
+        restore_output(state_data)
+        restore_transcript(state_data)
+        restore_final_output(state_data)
+      end
+
+      def restore_output(state_data)
+        return unless state_data.key?(:output)
+        return unless @workflow.respond_to?(:output=)
+
+        @workflow.output = state_data[:output]
+      end
+
+      def restore_transcript(state_data)
+        return unless state_data.key?(:transcript)
+        return unless @workflow.respond_to?(:transcript)
+
+        # Transcript is an array from Raix::ChatCompletion
+        # We need to clear it and repopulate it
+        if @workflow.transcript.respond_to?(:clear) && @workflow.transcript.respond_to?(:<<)
+          @workflow.transcript.clear
+          state_data[:transcript].each do |message|
+            @workflow.transcript << message
+          end
+        end
+      end
+
+      def restore_final_output(state_data)
+        return unless state_data.key?(: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 @workflow.respond_to?(:final_output=)
+          @workflow.final_output = final_output
+        elsif @workflow.instance_variable_defined?(:@final_output)
+          @workflow.instance_variable_set(:@final_output, final_output)
+        end
+      end
+    end
+  end
+end

data/lib/roast/workflow/resource_resolver.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "open3"
+require "roast/resources"
+
+module Roast
+  module Workflow
+    # Handles resource resolution and target processing
+    # Extracts file/resource handling logic from Configuration
+    class ResourceResolver
+      class << self
+        # Process the target and create appropriate resource object
+        # @param target [String, nil] The target from configuration or options
+        # @param context_path [String] The directory containing the workflow file
+        # @return [Roast::Resources::BaseResource] The resolved resource object
+        def resolve(target, context_path)
+          return Roast::Resources::NoneResource.new(nil) unless has_target?(target)
+
+          processed_target = process_target(target, context_path)
+          Roast::Resources.for(processed_target)
+        end
+
+        # Process target through shell command expansion and glob pattern matching
+        # @param target [String] The raw target string
+        # @param context_path [String] The directory containing the workflow file
+        # @return [String] The processed target
+        def process_target(target, context_path)
+          # Process shell command first
+          processed = process_shell_command(target)
+
+          # 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 target != processed && !processed.include?("/")
+
+          # Don't expand URLs
+          return processed if processed.match?(%r{^https?://})
+
+          # assumed to be a direct file path
+          File.expand_path(processed)
+        end
+
+        # Process shell commands in $(command) or legacy % format
+        # @param command [String] The command string
+        # @return [String] The command output or original string if not a shell command
+        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
+
+        private
+
+        def has_target?(target)
+          !target.nil? && !target.empty?
+        end
+      end
+    end
+  end
+end

data/lib/roast/workflow/session_manager.rb

@@ -7,6 +7,8 @@ module Roast
   module Workflow
     # Manages session creation, timestamping, and directory management
     class SessionManager
+      TARGETLESS_FILE_PATH = "notarget"
+
       def initialize
         @session_mutex = Mutex.new
         @session_timestamps = {}
@@ -66,9 +68,11 @@ module Roast
       private
 
       def workflow_directory(session_name, file_path)
+        file_path ||= TARGETLESS_FILE_PATH
         workflow_dir_name = session_name.parameterize.underscore
-        file_id = Digest::MD5.hexdigest(file_path)
-        file_basename = File.basename(file_path).parameterize.underscore
+        # For targetless sessions we don't have a file_path
+        file_id = Digest::MD5.hexdigest(file_path || Dir.pwd)
+        file_basename = File.basename(file_path || Dir.pwd).parameterize.underscore
         human_readable_id = "#{file_basename}_#{file_id[0..7]}"
         File.join(Dir.pwd, ".roast", "sessions", workflow_dir_name, human_readable_id)
       end

data/lib/roast/workflow/state_manager.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "roast/workflow/file_state_repository"
+
+module Roast
+  module Workflow
+    # Manages workflow state persistence and restoration
+    class StateManager
+      attr_reader :workflow, :logger
+
+      def initialize(workflow, logger: nil)
+        @workflow = workflow
+        @logger = logger
+        @state_repository = FileStateRepository.new
+      end
+
+      # Save the current state after a step execution
+      #
+      # @param step_name [String] The name of the step that just completed
+      # @param step_result [Object] The result of the step execution
+      def save_state(step_name, step_result)
+        return unless should_save_state?
+
+        state_data = build_state_data(step_name, step_result)
+        @state_repository.save_state(workflow, step_name, state_data)
+      rescue => e
+        # Don't fail the workflow if state saving fails
+        log_warning("Failed to save workflow state: #{e.message}")
+      end
+
+      # Check if state should be saved for the current workflow
+      #
+      # @return [Boolean] true if state should be saved
+      def should_save_state?
+        workflow.respond_to?(:session_name) && workflow.session_name
+      end
+
+      private
+
+      # Build the state data structure for persistence
+      def build_state_data(step_name, step_result)
+        {
+          step_name: step_name,
+          order: determine_step_order(step_name),
+          transcript: extract_transcript,
+          output: extract_output,
+          final_output: extract_final_output,
+          execution_order: extract_execution_order,
+        }
+      end
+
+      # Determine the order of the step in the workflow
+      def determine_step_order(step_name)
+        return 0 unless workflow.respond_to?(:output)
+
+        workflow.output.keys.index(step_name) || workflow.output.size
+      end
+
+      # Extract transcript data if available
+      def extract_transcript
+        return [] unless workflow.respond_to?(:transcript)
+
+        workflow.transcript.map(&:itself)
+      end
+
+      # Extract output data if available
+      def extract_output
+        return {} unless workflow.respond_to?(:output)
+
+        workflow.output.clone
+      end
+
+      # Extract final output data if available
+      def extract_final_output
+        return [] unless workflow.respond_to?(:final_output)
+
+        workflow.final_output.clone
+      end
+
+      # Extract execution order from workflow output
+      def extract_execution_order
+        return [] unless workflow.respond_to?(:output)
+
+        workflow.output.keys
+      end
+
+      # Log a warning message
+      def log_warning(message)
+        if logger
+          logger.warn(message)
+        else
+          $stderr.puts "WARNING: #{message}"
+        end
+      end
+    end
+  end
+end