roast-ai 0.1.7 → 0.2.1

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

data/lib/roast/workflow/step_executor_coordinator.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require "roast/workflow/case_executor"
+require "roast/workflow/conditional_executor"
+require "roast/workflow/step_executor_factory"
+require "roast/workflow/step_type_resolver"
+
+module Roast
+  module Workflow
+    # Coordinates the execution of different types of steps
+    #
+    # This class is responsible for routing steps to their appropriate executors
+    # based on the step type. It acts as a central dispatcher that determines
+    # which execution strategy to use for each step.
+    #
+    # Current Architecture:
+    # - WorkflowExecutor.execute_steps still handles basic routing for backward compatibility
+    # - This coordinator is used by WorkflowExecutor.execute_step for named steps
+    # - Some step types (parallel) use the StepExecutorFactory pattern
+    # - Other step types use direct execution methods
+    #
+    # TODO: Future refactoring should move all execution logic from WorkflowExecutor
+    # to this coordinator and use the factory pattern consistently for all step types.
+    class StepExecutorCoordinator
+      def initialize(context:, dependencies:)
+        @context = context
+        @dependencies = dependencies
+      end
+
+      # Execute a list of steps
+      def execute_steps(workflow_steps)
+        workflow_steps.each do |step|
+          case step
+          when Hash
+            execute(step)
+          when Array
+            execute(step)
+          when String
+            execute(step)
+            # Handle pause after string steps
+            if @context.workflow.pause_step_name == step
+              Kernel.binding.irb # rubocop:disable Lint/Debugger
+            end
+          else
+            step_orchestrator.execute_step(step)
+          end
+        end
+      end
+
+      # Execute a single step (alias for compatibility)
+      def execute_step(step, options = {})
+        execute(step, options)
+      end
+
+      # Execute a step based on its type
+      # @param step [String, Hash, Array] The step to execute
+      # @param options [Hash] Execution options
+      # @return [Object] The result of the step execution
+      def execute(step, options = {})
+        step_type = StepTypeResolver.resolve(step, @context)
+
+        case step_type
+        when StepTypeResolver::COMMAND_STEP
+          # Command steps should also go through interpolation
+          execute_string_step(step, options)
+        when StepTypeResolver::GLOB_STEP
+          execute_glob_step(step)
+        when StepTypeResolver::ITERATION_STEP
+          execute_iteration_step(step)
+        when StepTypeResolver::CONDITIONAL_STEP
+          execute_conditional_step(step)
+        when StepTypeResolver::CASE_STEP
+          execute_case_step(step)
+        when StepTypeResolver::HASH_STEP
+          execute_hash_step(step)
+        when StepTypeResolver::PARALLEL_STEP
+          # Use factory for parallel steps
+          executor = StepExecutorFactory.for(step, workflow_executor)
+          executor.execute(step)
+        when StepTypeResolver::STRING_STEP
+          execute_string_step(step, options)
+        else
+          execute_standard_step(step, options)
+        end
+      end
+
+      private
+
+      attr_reader :context, :dependencies
+
+      def workflow_executor
+        dependencies[:workflow_executor]
+      end
+
+      def interpolator
+        dependencies[:interpolator]
+      end
+
+      def command_executor
+        dependencies[:command_executor]
+      end
+
+      def iteration_executor
+        dependencies[:iteration_executor]
+      end
+
+      def conditional_executor
+        dependencies[:conditional_executor]
+      end
+
+      def case_executor
+        @case_executor ||= dependencies[:case_executor] || CaseExecutor.new(
+          context.workflow,
+          context.context_path,
+          dependencies[:state_manager] || dependencies[:workflow_executor].state_manager,
+          workflow_executor,
+        )
+      end
+
+      def step_orchestrator
+        dependencies[:step_orchestrator]
+      end
+
+      def error_handler
+        dependencies[:error_handler]
+      end
+
+      def execute_command_step(step, options)
+        exit_on_error = options.fetch(:exit_on_error, true)
+        resource_type = @context.resource_type
+
+        error_handler.with_error_handling(step, resource_type: resource_type) do
+          $stderr.puts "Executing: #{step} (Resource type: #{resource_type || "unknown"})"
+
+          output = command_executor.execute(step, exit_on_error: exit_on_error)
+
+          # Add to transcript
+          workflow = context.workflow
+          workflow.transcript << {
+            user: "I just executed the following command: ```\n#{step}\n```\n\nHere is the output:\n\n```\n#{output}\n```",
+          }
+          workflow.transcript << { assistant: "Noted, thank you." }
+
+          output
+        end
+      end
+
+      def execute_glob_step(step)
+        Dir.glob(step).join("\n")
+      end
+
+      def execute_iteration_step(step)
+        name = step.keys.first
+        command = step[name]
+
+        case name
+        when "repeat"
+          iteration_executor.execute_repeat(command)
+        when "each"
+          validate_each_step!(step)
+          iteration_executor.execute_each(step)
+        end
+      end
+
+      def execute_conditional_step(step)
+        conditional_executor.execute_conditional(step)
+      end
+
+      def execute_case_step(step)
+        case_executor.execute_case(step)
+      end
+
+      def execute_hash_step(step)
+        name, command = step.to_a.flatten
+        interpolated_name = interpolator.interpolate(name)
+
+        if command.is_a?(Hash)
+          execute_steps([command])
+        else
+          interpolated_command = interpolator.interpolate(command)
+          exit_on_error = context.exit_on_error?(interpolated_name)
+
+          # Execute the command directly using the appropriate executor
+          result = execute(interpolated_command, { exit_on_error: exit_on_error })
+          context.workflow.output[interpolated_name] = result
+          result
+        end
+      end
+
+      def execute_string_step(step, options = {})
+        # Check for glob before interpolation
+        if StepTypeResolver.glob_step?(step, context)
+          return execute_glob_step(step)
+        end
+
+        interpolated_step = interpolator.interpolate(step)
+
+        if StepTypeResolver.command_step?(interpolated_step)
+          # Command step - execute directly, preserving any passed options
+          exit_on_error = options.fetch(:exit_on_error, true)
+          execute_command_step(interpolated_step, { exit_on_error: exit_on_error })
+        else
+          exit_on_error = options.fetch(:exit_on_error, context.exit_on_error?(step))
+          execute_standard_step(interpolated_step, { exit_on_error: exit_on_error })
+        end
+      end
+
+      def execute_standard_step(step, options)
+        exit_on_error = options.fetch(:exit_on_error, true)
+        step_orchestrator.execute_step(step, exit_on_error: exit_on_error)
+      end
+
+      def validate_each_step!(step)
+        unless step.key?("as") && step.key?("steps")
+          raise WorkflowExecutor::ConfigurationError,
+            "Invalid 'each' step format. 'as' and 'steps' must be at the same level as 'each'"
+        end
+      end
+    end
+  end
+end

data/lib/roast/workflow/step_executor_factory.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "roast/workflow/step_executor_registry"
+require "roast/workflow/step_executors/hash_step_executor"
+require "roast/workflow/step_executors/parallel_step_executor"
+require "roast/workflow/step_executors/string_step_executor"
+
+module Roast
+  module Workflow
+    # Factory for creating step executors - now delegates to registry
+    class StepExecutorFactory
+      class << self
+        # Method to ensure default executors are registered
+        def ensure_defaults_registered
+          return if @defaults_registered
+
+          StepExecutorRegistry.register(Hash, StepExecutors::HashStepExecutor)
+          StepExecutorRegistry.register(Array, StepExecutors::ParallelStepExecutor)
+          StepExecutorRegistry.register(String, StepExecutors::StringStepExecutor)
+
+          @defaults_registered = true
+        end
+      end
+
+      # Initialize on first use
+      ensure_defaults_registered
+
+      class << self
+        # Delegate to the registry for backward compatibility
+        def for(step, workflow_executor)
+          ensure_defaults_registered
+          StepExecutorRegistry.for(step, workflow_executor)
+        end
+
+        # Allow registration of new executors
+        def register(klass, executor_class)
+          StepExecutorRegistry.register(klass, executor_class)
+        end
+
+        # Allow registration with custom matchers
+        def register_with_matcher(matcher, executor_class)
+          StepExecutorRegistry.register_with_matcher(matcher, executor_class)
+        end
+      end
+    end
+  end
+end

data/lib/roast/workflow/step_executor_registry.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Registry pattern for step executors - eliminates case statements
+    # and follows Open/Closed Principle
+    class StepExecutorRegistry
+      class UnknownStepTypeError < StandardError; end
+
+      @executors = {}
+      @type_matchers = []
+
+      class << self
+        # Register an executor for a specific class
+        # @param klass [Class] The class to match
+        # @param executor_class [Class] The executor class to use
+        def register(klass, executor_class)
+          @executors[klass] = executor_class
+        end
+
+        # Register an executor with a custom matcher
+        # @param matcher [Proc] A proc that returns true if the step matches
+        # @param executor_class [Class] The executor class to use
+        def register_with_matcher(matcher, executor_class)
+          @type_matchers << { matcher: matcher, executor_class: executor_class }
+        end
+
+        # Find the appropriate executor for a step
+        # @param step [Object] The step to find an executor for
+        # @param workflow_executor [WorkflowExecutor] The workflow executor instance
+        # @return [Object] An instance of the appropriate executor
+        def for(step, workflow_executor)
+          executor_class = find_executor_class(step)
+
+          unless executor_class
+            raise UnknownStepTypeError, "No executor registered for step type: #{step.class} (#{step.inspect})"
+          end
+
+          executor_class.new(workflow_executor)
+        end
+
+        # Clear all registrations (useful for testing)
+        def clear!
+          @executors.clear
+          @type_matchers.clear
+          # Reset the factory's defaults flag if it's defined
+          if defined?(StepExecutorFactory)
+            StepExecutorFactory.instance_variable_set(:@defaults_registered, false)
+          end
+        end
+
+        # Get all registered executors (useful for debugging)
+        def registered_executors
+          @executors.dup
+        end
+
+        private
+
+        def find_executor_class(step)
+          # First check exact class matches
+          executor_class = @executors[step.class]
+          return executor_class if executor_class
+
+          # Then check custom matchers
+          matcher_entry = @type_matchers.find { |entry| entry[:matcher].call(step) }
+          return matcher_entry[:executor_class] if matcher_entry
+
+          # Finally check inheritance chain
+          step.class.ancestors.each do |ancestor|
+            executor_class = @executors[ancestor]
+            return executor_class if executor_class
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/roast/workflow/step_executors/base_step_executor.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    module StepExecutors
+      class BaseStepExecutor
+        def initialize(workflow_executor)
+          @workflow_executor = workflow_executor
+          @workflow = workflow_executor.workflow
+          @config_hash = workflow_executor.config_hash
+        end
+
+        def execute(step)
+          raise NotImplementedError, "Subclasses must implement execute"
+        end
+
+        protected
+
+        attr_reader :workflow_executor, :workflow, :config_hash
+      end
+    end
+  end
+end