roast-ai 0.1.7 → 0.2.1

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

data/lib/roast/workflow/step_loader.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "roast/value_objects/step_name"
+require "roast/workflow/workflow_context"
+require "roast/workflow/base_step"
+require "roast/workflow/prompt_step"
+
+module Roast
+  module Workflow
+    # Handles loading and instantiation of workflow steps
+    class StepLoader
+      DEFAULT_MODEL = "openai/gpt-4o-mini"
+
+      # Custom exception classes
+      class StepLoaderError < StandardError
+        attr_reader :step_name, :original_error
+
+        def initialize(message, step_name: nil, original_error: nil)
+          @step_name = step_name
+          @original_error = original_error
+          super(message)
+        end
+      end
+
+      class StepNotFoundError < StepLoaderError; end
+      class StepExecutionError < StepLoaderError; end
+
+      attr_reader :context
+
+      delegate :workflow, :config_hash, :context_path, to: :context
+
+      def initialize(workflow, config_hash, context_path)
+        # Support both old and new initialization patterns
+        @context = if workflow.is_a?(WorkflowContext)
+          workflow
+        else
+          WorkflowContext.new(
+            workflow: workflow,
+            config_hash: config_hash,
+            context_path: context_path,
+          )
+        end
+      end
+
+      # Finds and loads a step by name
+      #
+      # @param step_name [String, StepName] The name of the step to load
+      # @return [BaseStep] The loaded step instance
+      def load(step_name)
+        name = step_name.is_a?(Roast::ValueObjects::StepName) ? step_name : Roast::ValueObjects::StepName.new(step_name)
+
+        # First check for a prompt step (contains spaces)
+        if name.plain_text?
+          step = Roast::Workflow::PromptStep.new(workflow, name: name.to_s, auto_loop: true)
+          configure_step(step, name.to_s)
+          return step
+        end
+
+        # Look for Ruby file in various locations
+        step_file_path = find_step_file(name.to_s)
+        if step_file_path
+          return load_ruby_step(step_file_path, name.to_s)
+        end
+
+        # Look for step directory
+        step_directory = find_step_directory(name.to_s)
+        unless step_directory
+          raise StepNotFoundError.new("Step directory or file not found: #{name}", step_name: name.to_s)
+        end
+
+        create_step_instance(Roast::Workflow::BaseStep, name.to_s, step_directory)
+      end
+
+      private
+
+      # Find a Ruby step file in various locations
+      def find_step_file(step_name)
+        # Check in context path
+        rb_file_path = File.join(context_path, "#{step_name}.rb")
+        return rb_file_path if File.file?(rb_file_path)
+
+        # Check in shared directory
+        shared_rb_path = File.expand_path(File.join(context_path, "..", "shared", "#{step_name}.rb"))
+        return shared_rb_path if File.file?(shared_rb_path)
+
+        nil
+      end
+
+      # Find a step directory
+      def find_step_directory(step_name)
+        # Check in context path
+        step_path = File.join(context_path, step_name)
+        return step_path if File.directory?(step_path)
+
+        # Check in shared directory
+        shared_path = File.expand_path(File.join(context_path, "..", "shared", step_name))
+        return shared_path if File.directory?(shared_path)
+
+        nil
+      end
+
+      # Load a Ruby step from a file
+      def load_ruby_step(file_path, step_name)
+        $stderr.puts "Requiring step file: #{file_path}"
+
+        begin
+          require file_path
+        rescue LoadError => e
+          raise StepNotFoundError.new("Failed to load step file: #{e.message}", step_name: step_name, original_error: e)
+        rescue SyntaxError => e
+          raise StepExecutionError.new("Syntax error in step file: #{e.message}", step_name: step_name, original_error: e)
+        end
+
+        step_class = step_name.classify.constantize
+        context = File.dirname(file_path)
+        create_step_instance(step_class, step_name, context)
+      end
+
+      # Create and configure a step instance
+      def create_step_instance(step_class, step_name, context_path)
+        step = step_class.new(workflow, name: step_name, context_path: context_path)
+        configure_step(step, step_name)
+        step
+      end
+
+      # Configure a step instance with settings from config_hash
+      def configure_step(step, step_name)
+        step_config = config_hash[step_name]
+
+        # Always set the model
+        step.model = determine_model(step_config)
+
+        # Pass resource to step if supported
+        step.resource = workflow.resource if step.respond_to?(:resource=)
+
+        # Apply additional configuration if present
+        apply_step_configuration(step, step_config) if step_config.present?
+      end
+
+      # Determine which model to use for the step
+      def determine_model(step_config)
+        step_config&.dig("model") || config_hash["model"] || DEFAULT_MODEL
+      end
+
+      # Apply configuration settings to a step
+      def apply_step_configuration(step, step_config)
+        step.print_response = step_config["print_response"] if step_config.key?("print_response")
+        step.auto_loop = step_config["loop"] if step_config.key?("loop")
+        step.json = step_config["json"] if step_config.key?("json")
+        step.params = step_config["params"] if step_config.key?("params")
+        step.coerce_to = step_config["coerce_to"].to_sym if step_config.key?("coerce_to")
+      end
+    end
+  end
+end

data/lib/roast/workflow/step_orchestrator.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Handles the orchestration of step execution, managing the flow and control
+    # of individual steps without knowing how to execute them
+    #
+    # This class is specifically for executing CUSTOM steps defined in the workflow's
+    # step directory (e.g., steps/*.rb files). It loads and executes Ruby step files
+    # that define a `call` method.
+    #
+    # The primary method execute_step is used by StepExecutorCoordinator for
+    # executing custom Ruby steps.
+    #
+    # TODO: Consider renaming this class to CustomStepOrchestrator to clarify its purpose
+    class StepOrchestrator
+      def initialize(workflow, step_loader, state_manager, error_handler, workflow_executor)
+        @workflow = workflow
+        @step_loader = step_loader
+        @state_manager = state_manager
+        @error_handler = error_handler
+        @workflow_executor = workflow_executor
+      end
+
+      def execute_step(name, exit_on_error: true)
+        resource_type = @workflow.respond_to?(:resource) ? @workflow.resource&.type : nil
+
+        @error_handler.with_error_handling(name, resource_type: resource_type) do
+          $stderr.puts "Executing: #{name} (Resource type: #{resource_type || "unknown"})"
+
+          step_object = @step_loader.load(name)
+          step_result = step_object.call
+
+          # Store result in workflow output
+          @workflow.output[name] = step_result
+
+          # Save state after each step
+          @state_manager.save_state(name, step_result)
+
+          step_result
+        end
+      end
+    end
+  end
+end

data/lib/roast/workflow/step_runner.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Interface for running workflow steps.
+    # This abstraction breaks the circular dependency between executors and the workflow.
+    class StepRunner
+      def initialize(coordinator)
+        @coordinator = coordinator
+      end
+
+      # Execute a list of steps
+      def execute_steps(steps)
+        @coordinator.execute_steps(steps)
+      end
+
+      # Execute a single step
+      def execute_step(step, options = {})
+        @coordinator.execute_step(step, options)
+      end
+    end
+  end
+end

data/lib/roast/workflow/step_type_resolver.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Determines the type of a step and how it should be executed
+    class StepTypeResolver
+      # Step type constants
+      COMMAND_STEP = :command
+      GLOB_STEP = :glob
+      ITERATION_STEP = :iteration
+      CONDITIONAL_STEP = :conditional
+      CASE_STEP = :case
+      HASH_STEP = :hash
+      PARALLEL_STEP = :parallel
+      STRING_STEP = :string
+      STANDARD_STEP = :standard
+
+      # Special step names for iterations
+      ITERATION_STEPS = ["repeat", "each"].freeze
+
+      # Special step names for conditionals
+      CONDITIONAL_STEPS = ["if", "unless"].freeze
+
+      # Special step name for case statements
+      CASE_STEPS = ["case"].freeze
+
+      class << self
+        # Resolve the type of a step
+        # @param step [String, Hash, Array] The step to analyze
+        # @param context [WorkflowContext] The workflow context
+        # @return [Symbol] The step type
+        def resolve(step, context = nil)
+          case step
+          when String
+            resolve_string_step(step, context)
+          when Hash
+            resolve_hash_step(step)
+          when Array
+            PARALLEL_STEP
+          else
+            STANDARD_STEP
+          end
+        end
+
+        # Check if a step is a command step
+        # @param step [String] The step to check
+        # @return [Boolean] true if it's a command step
+        def command_step?(step)
+          step.is_a?(String) && step.start_with?("$(")
+        end
+
+        # Check if a step is a glob pattern
+        # @param step [String] The step to check
+        # @param context [WorkflowContext, nil] The workflow context
+        # @return [Boolean] true if it's a glob pattern
+        def glob_step?(step, context = nil)
+          return false unless step.is_a?(String) && step.include?("*")
+
+          # Only treat as glob if we don't have a resource
+          context.nil? || !context.has_resource?
+        end
+
+        # Check if a step is an iteration step
+        # @param step [Hash] The step to check
+        # @return [Boolean] true if it's an iteration step
+        def iteration_step?(step)
+          return false unless step.is_a?(Hash)
+
+          step_name = step.keys.first
+          ITERATION_STEPS.include?(step_name)
+        end
+
+        # Check if a step is a conditional step
+        # @param step [Hash] The step to check
+        # @return [Boolean] true if it's a conditional step
+        def conditional_step?(step)
+          return false unless step.is_a?(Hash)
+
+          step_name = step.keys.first
+          CONDITIONAL_STEPS.include?(step_name)
+        end
+
+        # Check if a step is a case step
+        # @param step [Hash] The step to check
+        # @return [Boolean] true if it's a case step
+        def case_step?(step)
+          return false unless step.is_a?(Hash)
+
+          step_name = step.keys.first
+          CASE_STEPS.include?(step_name)
+        end
+
+        # Extract the step name from various step formats
+        # @param step [String, Hash, Array] The step
+        # @return [String, nil] The step name or nil
+        def extract_name(step)
+          case step
+          when String
+            step
+          when Hash
+            step.keys.first
+          when Array
+            nil # Parallel steps don't have a single name
+          end
+        end
+
+        private
+
+        def resolve_string_step(step, context)
+          if command_step?(step)
+            COMMAND_STEP
+          elsif glob_step?(step, context)
+            GLOB_STEP
+          else
+            STRING_STEP
+          end
+        end
+
+        def resolve_hash_step(step)
+          if iteration_step?(step)
+            ITERATION_STEP
+          elsif conditional_step?(step)
+            CONDITIONAL_STEP
+          elsif case_step?(step)
+            CASE_STEP
+          else
+            HASH_STEP
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roast/workflow/workflow_context.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Encapsulates common workflow execution context parameters
+    # Reduces data clump anti-pattern by grouping related parameters
+    class WorkflowContext
+      attr_reader :workflow, :config_hash, :context_path
+
+      # Initialize the workflow context
+      # @param workflow [BaseWorkflow] The workflow instance
+      # @param config_hash [Hash] The workflow configuration hash
+      # @param context_path [String] The context directory path
+      def initialize(workflow:, config_hash:, context_path:)
+        @workflow = workflow
+        @config_hash = config_hash
+        @context_path = context_path
+        freeze
+      end
+
+      # Create a new context with updated workflow
+      # @param new_workflow [BaseWorkflow] The new workflow instance
+      # @return [WorkflowContext] A new context with the updated workflow
+      def with_workflow(new_workflow)
+        self.class.new(
+          workflow: new_workflow,
+          config_hash: config_hash,
+          context_path: context_path,
+        )
+      end
+
+      # Check if the workflow has a resource
+      # @return [Boolean] true if workflow responds to resource and has one
+      def has_resource?
+        workflow.respond_to?(:resource) && workflow.resource
+      end
+
+      # Get the resource type from the workflow
+      # @return [Symbol, nil] The resource type or nil
+      def resource_type
+        has_resource? ? workflow.resource.type : nil
+      end
+
+      # Get configuration for a specific step
+      # @param step_name [String] The name of the step
+      # @return [Hash] The step configuration or empty hash
+      def step_config(step_name)
+        config_hash[step_name] || {}
+      end
+
+      # Check if a step should exit on error
+      # @param step_name [String] The name of the step
+      # @return [Boolean] true if the step should exit on error (default true)
+      def exit_on_error?(step_name)
+        config = step_config(step_name)
+        config.is_a?(Hash) ? config.fetch("exit_on_error", true) : true
+      end
+    end
+  end
+end