roast-ai 0.1.7 → 0.2.0

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,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