roast-ai 0.3.1 → 0.4.0

data/lib/roast/workflow/file_state_repository.rb

@@ -1,10 +1,5 @@
 # frozen_string_literal: true
 
-require "json"
-require "fileutils"
-require "roast/workflow/session_manager"
-require "roast/workflow/state_repository"
-
 module Roast
   module Workflow
     # File-based implementation of StateRepository

data/lib/roast/workflow/input_executor.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Handles execution of input steps
+    class InputExecutor
+      def initialize(workflow, context_path, state_manager, workflow_executor = nil)
+        @workflow = workflow
+        @context_path = context_path
+        @state_manager = state_manager
+        @workflow_executor = workflow_executor
+      end
+
+      def execute_input(input_config)
+        # Interpolate the prompt if workflow executor is available
+        if @workflow_executor && input_config["prompt"]
+          interpolated_config = input_config.dup
+          interpolated_config["prompt"] = @workflow_executor.interpolate(input_config["prompt"])
+        else
+          interpolated_config = input_config
+        end
+
+        # Create and execute an InputStep
+        input_step = InputStep.new(
+          @workflow,
+          config: interpolated_config,
+          name: input_config["name"] || "input_#{Time.now.to_i}",
+          context_path: @context_path,
+        )
+
+        result = input_step.call
+
+        # Store in 'previous' for conditional checks
+        @workflow.output["previous"] = result
+        @state_manager.save_state("previous", result)
+
+        result
+      end
+    end
+  end
+end

data/lib/roast/workflow/input_step.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "timeout"
+
+module Roast
+  module Workflow
+    class InputStep < BaseStep
+      attr_reader :prompt_text, :type, :required, :default, :timeout, :options, :step_name
+
+      def initialize(workflow, config:, **kwargs)
+        super(workflow, **kwargs)
+        parse_config(config)
+      end
+
+      def call
+        # Get user input based on the configured type
+        result = case type
+        when "boolean"
+          prompt_boolean
+        when "choice"
+          prompt_choice
+        when "password"
+          prompt_password
+        else
+          prompt_text_input
+        end
+
+        # Store the result in workflow state if a name was provided
+        store_in_state(result) if step_name
+
+        result
+      rescue Timeout::Error
+        handle_timeout
+      end
+
+      private
+
+      def parse_config(config)
+        @prompt_text = config["prompt"] || raise_config_error("Missing 'prompt' in input configuration")
+        @step_name = config["name"]
+        @type = config["type"] || "text"
+        @required = config.fetch("required", false)
+        @default = config["default"]
+        @timeout = config["timeout"]
+        @options = config["options"]
+
+        validate_config
+      end
+
+      def validate_config
+        if type == "choice" && options.nil?
+          raise_config_error("Missing 'options' for choice type input")
+        end
+
+        if type == "boolean" && default && ![true, false, "true", "false", "yes", "no"].include?(default)
+          raise_config_error("Invalid default value for boolean type: #{default}")
+        end
+      end
+
+      def prompt_text_input
+        loop do
+          result = if timeout
+            with_timeout { ::CLI::UI.ask(prompt_text, default: default) }
+          else
+            ::CLI::UI.ask(prompt_text, default: default)
+          end
+
+          if required && result.to_s.strip.empty?
+            puts ::CLI::UI.fmt("{{red:This field is required. Please provide a value.}}")
+            next
+          end
+
+          return result
+        end
+      end
+
+      def prompt_boolean
+        if timeout
+          with_timeout { ::CLI::UI.confirm(prompt_text, default: boolean_default) }
+        else
+          ::CLI::UI.confirm(prompt_text, default: boolean_default)
+        end
+      end
+
+      def prompt_choice
+        if timeout
+          with_timeout { ::CLI::UI.ask(prompt_text, options: options, default: default) }
+        else
+          ::CLI::UI.ask(prompt_text, options: options, default: default)
+        end
+      end
+
+      def prompt_password
+        require "io/console"
+
+        loop do
+          result = if timeout
+            with_timeout { prompt_password_with_echo_off }
+          else
+            prompt_password_with_echo_off
+          end
+
+          if required && result.to_s.strip.empty?
+            puts ::CLI::UI.fmt("{{red:This field is required. Please provide a value.}}")
+            next
+          end
+
+          return result
+        end
+      end
+
+      def prompt_password_with_echo_off
+        ::CLI::UI.with_frame_color(:blue) do
+          print("🔒 #{prompt_text} ")
+
+          password = if $stdin.tty?
+            # Use noecho for TTY environments
+            $stdin.noecho { $stdin.gets }.chomp
+          else
+            # Fall back to regular input for non-TTY environments
+            warn("[WARNING] Password will be visible (not running in TTY)")
+            $stdin.gets.chomp
+          end
+
+          puts # Add newline after password input
+          password
+        end
+      end
+
+      def boolean_default
+        case default
+        when true, "true", "yes"
+          true
+        when false, "false", "no"
+          false
+        end
+      end
+
+      def with_timeout(&block)
+        Timeout.timeout(timeout, &block)
+      end
+
+      def handle_timeout
+        puts ::CLI::UI.fmt("{{yellow:Input timed out after #{timeout} seconds}}")
+
+        if default
+          puts ::CLI::UI.fmt("{{yellow:Using default value: #{default}}}")
+          default
+        elsif required
+          raise_config_error("Required input timed out with no default value")
+        end
+      end
+
+      def store_in_state(value)
+        workflow.output[step_name] = value
+      end
+
+      def raise_config_error(message)
+        raise WorkflowExecutor::ConfigurationError, message
+      end
+    end
+  end
+end

data/lib/roast/workflow/iteration_executor.rb

@@ -24,7 +24,6 @@ module Roast
         raise WorkflowExecutor::ConfigurationError, "Missing 'until' condition in repeat configuration" unless until_condition
 
         # Create and execute a RepeatStep
-        require "roast/workflow/repeat_step" unless defined?(RepeatStep)
         repeat_step = RepeatStep.new(
           @workflow,
           steps: steps,
@@ -64,7 +63,6 @@ module Roast
         raise WorkflowExecutor::ConfigurationError, "Missing 'steps' in each configuration" unless steps
 
         # Create and execute an EachStep
-        require "roast/workflow/each_step" unless defined?(EachStep)
         each_step = EachStep.new(
           @workflow,
           collection_expr: collection_expr,

data/lib/roast/workflow/output_handler.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/workflow/file_state_repository"
-
 module Roast
   module Workflow
     # Handles output operations for workflows including saving final output and results

data/lib/roast/workflow/output_manager.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/workflow/dot_access_hash"
-
 module Roast
   module Workflow
     # Manages workflow output, including both the key-value output hash

data/lib/roast/workflow/replay_handler.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/workflow/step_finder"
-require "roast/workflow/file_state_repository"
-
 module Roast
   module Workflow
     # Handles replay functionality for workflows

data/lib/roast/workflow/resource_resolver.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "open3"
-require "roast/resources"
-
 module Roast
   module Workflow
     # Handles resource resolution and target processing

data/lib/roast/workflow/session_manager.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "fileutils"
-require "digest"
-
 module Roast
   module Workflow
     # Manages session creation, timestamping, and directory management

data/lib/roast/workflow/state_manager.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/workflow/file_state_repository"
-
 module Roast
   module Workflow
     # Manages workflow state persistence and restoration

data/lib/roast/workflow/step_executor_coordinator.rb

@@ -1,10 +1,5 @@
 # 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
@@ -29,20 +24,21 @@ module Roast
 
       # Execute a list of steps
       def execute_steps(workflow_steps)
-        workflow_steps.each do |step|
+        workflow_steps.each_with_index do |step, index|
+          is_last_step = (index == workflow_steps.length - 1)
           case step
           when Hash
-            execute(step)
+            execute(step, is_last_step: is_last_step)
           when Array
-            execute(step)
+            execute(step, is_last_step: is_last_step)
           when String
-            execute(step)
+            execute(step, is_last_step: is_last_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)
+            step_orchestrator.execute_step(step, is_last_step: is_last_step)
           end
         end
       end
@@ -63,6 +59,8 @@ module Roast
         when StepTypeResolver::COMMAND_STEP
           # Command steps should also go through interpolation
           execute_string_step(step, options)
+        when StepTypeResolver::AGENT_STEP
+          execute_agent_step(step, options)
         when StepTypeResolver::GLOB_STEP
           execute_glob_step(step)
         when StepTypeResolver::ITERATION_STEP
@@ -71,6 +69,8 @@ module Roast
           execute_conditional_step(step)
         when StepTypeResolver::CASE_STEP
           execute_case_step(step)
+        when StepTypeResolver::INPUT_STEP
+          execute_input_step(step)
         when StepTypeResolver::HASH_STEP
           execute_hash_step(step)
         when StepTypeResolver::PARALLEL_STEP
@@ -117,6 +117,15 @@ module Roast
         )
       end
 
+      def input_executor
+        @input_executor ||= dependencies[:input_executor] || InputExecutor.new(
+          context.workflow,
+          context.context_path,
+          dependencies[:state_manager] || dependencies[:workflow_executor].state_manager,
+          workflow_executor,
+        )
+      end
+
       def step_orchestrator
         dependencies[:step_orchestrator]
       end
@@ -171,6 +180,15 @@ module Roast
         end
       end
 
+      def execute_agent_step(step, options = {})
+        # Extract the step name without the ^ prefix
+        step_name = StepTypeResolver.extract_name(step)
+
+        # Load and execute the agent step
+        exit_on_error = options.fetch(:exit_on_error, context.exit_on_error?(step))
+        step_orchestrator.execute_step(step_name, exit_on_error:, step_key: options[:step_key], agent_type: :coding_agent)
+      end
+
       def execute_glob_step(step)
         Dir.glob(step).join("\n")
       end
@@ -196,6 +214,10 @@ module Roast
         case_executor.execute_case(step)
       end
 
+      def execute_input_step(step)
+        input_executor.execute_input(step["input"])
+      end
+
       def execute_hash_step(step)
         name, command = step.to_a.flatten
         interpolated_name = interpolator.interpolate(name)
@@ -235,7 +257,8 @@ module Roast
       def execute_standard_step(step, options)
         exit_on_error = options.fetch(:exit_on_error, true)
         step_key = options[:step_key]
-        step_orchestrator.execute_step(step, exit_on_error: exit_on_error, step_key: step_key)
+        is_last_step = options[:is_last_step]
+        step_orchestrator.execute_step(step, exit_on_error:, step_key:, is_last_step:)
       end
 
       def validate_each_step!(step)

data/lib/roast/workflow/step_executor_factory.rb

@@ -1,10 +1,5 @@
 # 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

data/lib/roast/workflow/step_executor_registry.rb

@@ -43,10 +43,7 @@ module Roast
         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
+          StepExecutorFactory.instance_variable_set(:@defaults_registered, false)
         end
 
         # Get all registered executors (useful for debugging)

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

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/workflow/step_executors/base_step_executor"
-require "roast/workflow/step_runner"
-
 module Roast
   module Workflow
     module StepExecutors

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

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/workflow/step_executors/base_step_executor"
-require "roast/workflow/step_runner"
-
 module Roast
   module Workflow
     module StepExecutors

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/workflow/step_executors/base_step_executor"
-
 module Roast
   module Workflow
     module StepExecutors

data/lib/roast/workflow/step_factory.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Factory for creating step instances based on step characteristics
+    class StepFactory
+      class << self
+        # Create a step instance based on the step type and characteristics
+        #
+        # @param workflow [BaseWorkflow] The workflow instance
+        # @param step_name [String, StepName] The name of the step
+        # @param options [Hash] Additional options for step creation
+        # @return [BaseStep] The appropriate step instance
+        def create(workflow, step_name, options = {})
+          name = normalize_step_name(step_name)
+
+          # Determine the step class based on characteristics
+          step_class = determine_step_class(name, options)
+
+          # Create the step instance with appropriate parameters
+          build_step_instance(step_class, workflow, name, options)
+        end
+
+        private
+
+        def normalize_step_name(step_name)
+          step_name.is_a?(Roast::ValueObjects::StepName) ? step_name : Roast::ValueObjects::StepName.new(step_name)
+        end
+
+        def determine_step_class(name, options)
+          # Check if this is an agent step (indicated by special processing needs)
+          if options[:agent_type] == :coding_agent
+            Roast::Workflow::AgentStep
+          elsif name.plain_text?
+            # Plain text steps are always prompt steps
+            options[:agent_type] == :coding_agent ? Roast::Workflow::AgentStep : Roast::Workflow::PromptStep
+          else
+            # Default to BaseStep for directory-based steps
+            Roast::Workflow::BaseStep
+          end
+        end
+
+        def build_step_instance(step_class, workflow, name, options)
+          step_params = {
+            name:,
+          }
+
+          # Add context path if provided
+          step_params[:context_path] = options[:context_path] if options[:context_path]
+
+          step_class.new(workflow, **step_params)
+        end
+      end
+    end
+  end
+end

data/lib/roast/workflow/step_loader.rb

@@ -1,10 +1,5 @@
 # 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
@@ -47,8 +42,9 @@ module Roast
       #
       # @param step_name [String, StepName] The name of the step to load
       # @param step_key [String] The configuration key for the step (optional)
+      # @param options [Hash] Additional options for step loading
       # @return [BaseStep] The loaded step instance
-      def load(step_name, step_key: nil)
+      def load(step_name, step_key: nil, is_last_step: nil, **options)
         name = step_name.is_a?(Roast::ValueObjects::StepName) ? step_name : Roast::ValueObjects::StepName.new(step_name)
 
         # Get step config for per-step path
@@ -57,17 +53,17 @@ module Roast
 
         # First check for a prompt step (contains spaces)
         if name.plain_text?
-          step = Roast::Workflow::PromptStep.new(workflow, name: name.to_s)
+          step = StepFactory.create(workflow, name, options)
           # Use step_key for configuration if provided, otherwise use name
           config_key = step_key || name.to_s
-          configure_step(step, config_key)
+          configure_step(step, config_key, is_last_step:)
           return step
         end
 
         # Look for Ruby file in various locations
         step_file_path = find_step_file(name.to_s, per_step_path)
         if step_file_path
-          return load_ruby_step(step_file_path, name.to_s)
+          return load_ruby_step(step_file_path, name.to_s, is_last_step:)
         end
 
         # Look for step directory
@@ -76,7 +72,10 @@ module Roast
           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)
+        # Use factory to create the appropriate step instance
+        step = StepFactory.create(workflow, name, options.merge(context_path: step_directory))
+        configure_step(step, name.to_s, is_last_step:)
+        step
       end
 
       private
@@ -141,7 +140,7 @@ module Roast
       end
 
       # Load a Ruby step from a file
-      def load_ruby_step(file_path, step_name)
+      def load_ruby_step(file_path, step_name, is_last_step: nil)
         $stderr.puts "Requiring step file: #{file_path}"
 
         begin
@@ -154,18 +153,24 @@ module Roast
 
         step_class = step_name.classify.constantize
         context = File.dirname(file_path)
-        create_step_instance(step_class, step_name, context)
+        # For Ruby steps, we instantiate the specific class directly
+        # Convert step_name to StepName value object
+        step_name_obj = Roast::ValueObjects::StepName.new(step_name)
+        step = step_class.new(workflow, name: step_name_obj, context_path: context)
+        configure_step(step, step_name, is_last_step:)
+        step
       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)
+      def create_step_instance(step_class, step_name, context_path, options = {})
+        is_last_step = options[:is_last_step]
+        step = StepFactory.create(workflow, step_name, options.merge(context_path: context_path))
+        configure_step(step, step_name, is_last_step:)
         step
       end
 
       # Configure a step instance with settings from config_hash
-      def configure_step(step, step_name)
+      def configure_step(step, step_name, is_last_step: nil)
         step_config = config_hash[step_name]
 
         # Always set the model
@@ -176,6 +181,11 @@ module Roast
 
         # Apply additional configuration if present
         apply_step_configuration(step, step_config) if step_config.present?
+
+        # Set print_response to true for the last step if not already configured
+        if is_last_step && !step_config&.key?("print_response")
+          step.print_response = true
+        end
       end
 
       # Determine which model to use for the step
@@ -189,6 +199,10 @@ module Roast
         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")
+
+        if step_config.key?("available_tools")
+          step.available_tools = step_config["available_tools"]
+        end
       end
     end
   end

data/lib/roast/workflow/step_orchestrator.rb

@@ -22,7 +22,7 @@ module Roast
         @workflow_executor = workflow_executor
       end
 
-      def execute_step(name, exit_on_error: true, step_key: nil)
+      def execute_step(name, exit_on_error: true, step_key: nil, **options)
         resource_type = @workflow.respond_to?(:resource) ? @workflow.resource&.type : nil
 
         @error_handler.with_error_handling(name, resource_type: resource_type) do
@@ -30,7 +30,8 @@ module Roast
 
           # Use step_key for loading if provided, otherwise use name
           load_key = step_key || name
-          step_object = @step_loader.load(name, step_key: load_key)
+          is_last_step = options[:is_last_step]
+          step_object = @step_loader.load(name, step_key: load_key, is_last_step:, **options)
           step_result = step_object.call
 
           # Store result in workflow output