roast-ai 0.1.6 → 0.2.0

data/lib/roast/workflow/step_executor_coordinator.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+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::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 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_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

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "roast/workflow/step_executors/base_step_executor"
+require "roast/workflow/step_runner"
+
+module Roast
+  module Workflow
+    module StepExecutors
+      class HashStepExecutor < BaseStepExecutor
+        def execute(step)
+          # execute a command and store the output in a variable
+          name, command = step.to_a.flatten
+
+          # Interpolate variable name if it contains {{}}
+          interpolated_name = workflow_executor.interpolate(name)
+
+          if command.is_a?(Hash)
+            step_runner.execute_steps([command])
+          else
+            # Interpolate command value
+            interpolated_command = workflow_executor.interpolate(command)
+
+            # Check if this step has exit_on_error configuration
+            step_config = config_hash[interpolated_name]
+            exit_on_error = step_config.is_a?(Hash) ? step_config.fetch("exit_on_error", true) : true
+
+            workflow.output[interpolated_name] = step_runner.execute_step(interpolated_command, exit_on_error: exit_on_error)
+          end
+        end
+
+        private
+
+        def step_runner
+          @step_runner ||= StepRunner.new(coordinator)
+        end
+
+        def coordinator
+          workflow_executor.step_executor_coordinator
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "roast/workflow/step_executors/base_step_executor"
+require "roast/workflow/step_runner"
+
+module Roast
+  module Workflow
+    module StepExecutors
+      class ParallelStepExecutor < BaseStepExecutor
+        def execute(steps)
+          # run steps in parallel, don't proceed until all are done
+          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
+                step_runner.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
+
+        private
+
+        def step_runner
+          @step_runner ||= StepRunner.new(coordinator)
+        end
+
+        def coordinator
+          workflow_executor.step_executor_coordinator
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "roast/workflow/step_executors/base_step_executor"
+
+module Roast
+  module Workflow
+    module StepExecutors
+      class StringStepExecutor < BaseStepExecutor
+        def execute(step)
+          # Interpolate any {{}} expressions before executing the step
+          interpolated_step = workflow_executor.interpolate(step)
+
+          # For command steps, check if there's an exit_on_error configuration
+          # We need to extract the step name to look up configuration
+          if interpolated_step.starts_with?("$(")
+            # This is a direct command without a name, so exit_on_error defaults to true
+            workflow_executor.execute_step(interpolated_step)
+          else
+            # Check if this step has exit_on_error configuration
+            step_config = config_hash[step]
+            exit_on_error = step_config.is_a?(Hash) ? step_config.fetch("exit_on_error", true) : true
+
+            workflow_executor.execute_step(interpolated_step, exit_on_error: exit_on_error)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roast/workflow/step_finder.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Finds step indices within workflow step arrays
+    # Handles various step formats: strings, hashes, parallel arrays
+    class StepFinder
+      attr_reader :steps
+
+      def initialize(steps = nil)
+        @steps = steps || []
+      end
+
+      class << self
+        def find_index(steps_array, step_name)
+          new(steps_array).find_index(step_name)
+        end
+      end
+
+      # Find the index of a step in the workflow steps array
+      # @param step_name [String] The name of the step to find
+      # @param steps_array [Array, nil] Optional steps array to search in
+      # @return [Integer, nil] The index of the step, or nil if not found
+      def find_index(step_name, steps_array = nil)
+        search_array = steps_array || @steps
+        # First, try direct search
+        index = find_by_direct_search(search_array, step_name)
+        return index if index
+
+        # Fall back to extracted name search
+        find_by_extracted_name(search_array, step_name)
+      end
+
+      # Extract the name from a step definition
+      # @param step [String, Hash, Array] The step definition
+      # @return [String, Array] The step name(s)
+      def extract_name(step)
+        case step
+        when String
+          step
+        when Hash
+          step.keys.first
+        when Array
+          # For arrays, extract names from all contained steps
+          step.map { |s| extract_name(s) }
+        end
+      end
+
+      private
+
+      def find_by_direct_search(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
+            if contains_step?(step, step_name)
+              return index
+            end
+          when String
+            return index if step == step_name
+          end
+        end
+        nil
+      end
+
+      def find_by_extracted_name(steps_array, step_name)
+        steps_array.each_with_index do |step, index|
+          name = extract_name(step)
+          if name.is_a?(Array)
+            # For arrays (parallel steps), check if target is in the array
+            return index if name.flatten.include?(step_name)
+          elsif name == step_name
+            return index
+          end
+        end
+        nil
+      end
+
+      def contains_step?(parallel_steps, step_name)
+        parallel_steps.any? do |substep|
+          case substep
+          when Hash
+            substep.keys.first == step_name
+          when String
+            substep == step_name
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end