roast-ai 0.3.0 → 0.4.0

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

data/lib/roast/workflow/step_type_resolver.rb

@@ -10,10 +10,12 @@ module Roast
       ITERATION_STEP = :iteration
       CONDITIONAL_STEP = :conditional
       CASE_STEP = :case
+      INPUT_STEP = :input
       HASH_STEP = :hash
       PARALLEL_STEP = :parallel
       STRING_STEP = :string
       STANDARD_STEP = :standard
+      AGENT_STEP = :agent
 
       # Special step names for iterations
       ITERATION_STEPS = ["repeat", "each"].freeze
@@ -24,6 +26,9 @@ module Roast
       # Special step name for case statements
       CASE_STEPS = ["case"].freeze
 
+      # Special step name for input steps
+      INPUT_STEPS = ["input"].freeze
+
       class << self
         # Resolve the type of a step
         # @param step [String, Hash, Array] The step to analyze
@@ -49,6 +54,13 @@ module Roast
           step.is_a?(String) && step.start_with?("$(")
         end
 
+        # Check if a step is an agent step
+        # @param step [String] The step to check
+        # @return [Boolean] true if it's an agent step
+        def agent_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
@@ -90,13 +102,24 @@ module Roast
           CASE_STEPS.include?(step_name)
         end
 
+        # Check if a step is an input step
+        # @param step [Hash] The step to check
+        # @return [Boolean] true if it's an input step
+        def input_step?(step)
+          return false unless step.is_a?(Hash)
+
+          step_name = step.keys.first
+          INPUT_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
+            # Strip ^ prefix for agent steps
+            agent_step?(step) ? step[1..] : step
           when Hash
             step.keys.first
           when Array
@@ -109,6 +132,8 @@ module Roast
         def resolve_string_step(step, context)
           if command_step?(step)
             COMMAND_STEP
+          elsif agent_step?(step)
+            AGENT_STEP
           elsif glob_step?(step, context)
             GLOB_STEP
           else
@@ -123,6 +148,8 @@ module Roast
             CONDITIONAL_STEP
           elsif case_step?(step)
             CASE_STEP
+          elsif input_step?(step)
+            INPUT_STEP
           else
             HASH_STEP
           end

data/lib/roast/workflow/validator.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require "json-schema"
-require "json"
-require "yaml"
-
 module Roast
   module Workflow
     class Validator

data/lib/roast/workflow/workflow_executor.rb

@@ -1,21 +1,5 @@
 # frozen_string_literal: true
 
-require "English"
-
-require "roast/workflow/command_executor"
-require "roast/workflow/conditional_executor"
-require "roast/workflow/error_handler"
-require "roast/workflow/interpolator"
-require "roast/workflow/iteration_executor"
-require "roast/workflow/parallel_executor"
-require "roast/workflow/state_manager"
-require "roast/workflow/step_executor_factory"
-require "roast/workflow/step_executor_coordinator"
-require "roast/workflow/step_loader"
-require "roast/workflow/step_orchestrator"
-require "roast/workflow/step_type_resolver"
-require "roast/workflow/workflow_context"
-
 module Roast
   module Workflow
     # Handles the execution of workflow steps, including orchestration and threading

data/lib/roast/workflow/workflow_initializer.rb

@@ -1,12 +1,5 @@
 # frozen_string_literal: true
 
-require "raix"
-require "roast/initializers"
-require "roast/helpers/function_caching_interceptor"
-require "roast/helpers/logger"
-require "roast/workflow/base_workflow"
-require "roast/workflow/interpolator"
-
 module Roast
   module Workflow
     # Handles initialization of workflow dependencies: initializers, tools, and API clients
@@ -103,7 +96,7 @@ module Roast
         # Validate the client configuration by making a test API call
         validate_api_client(client) if client
       rescue OpenRouter::ConfigurationError, Faraday::UnauthorizedError => e
-        error = Roast::AuthenticationError.new("API authentication failed: No API token provided or token is invalid")
+        error = Roast::Errors::AuthenticationError.new("API authentication failed: No API token provided or token is invalid")
         error.set_backtrace(e.backtrace)
 
         ActiveSupport::Notifications.instrument("roast.workflow.start.error", {

data/lib/roast/workflow/workflow_runner.rb

@@ -1,12 +1,5 @@
 # frozen_string_literal: true
 
-require "erb"
-require "roast/workflow/replay_handler"
-require "roast/workflow/workflow_executor"
-require "roast/workflow/output_handler"
-require "roast/workflow/base_workflow"
-require "roast/workflow/dot_access_hash"
-
 module Roast
   module Workflow
     # Handles running workflows for files/targets and orchestrating execution

data/lib/roast/workflow.rb

@@ -1,20 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/workflow/base_step"
-require "roast/workflow/prompt_step"
-require "roast/workflow/base_iteration_step"
-require "roast/workflow/repeat_step"
-require "roast/workflow/each_step"
-require "roast/workflow/base_workflow"
-require "roast/workflow/configuration"
-require "roast/workflow/workflow_execution_context"
-require "roast/workflow/workflow_executor"
-require "roast/workflow/configuration_parser"
-require "roast/workflow/validator"
-require "roast/workflow/state_repository"
-require "roast/workflow/session_manager"
-require "roast/workflow/file_state_repository"
-
 module Roast
   module Workflow
   end

data/lib/roast.rb

@@ -1,24 +1,43 @@
 # frozen_string_literal: true
 
+# Standard library requires
+require "digest"
+require "English"
+require "erb"
+require "fileutils"
+require "json"
+require "logger"
+require "net/http"
+require "open3"
+require "pathname"
+require "securerandom"
+require "tempfile"
+require "uri"
+require "yaml"
+
+# Third-party gem requires
 require "active_support"
 require "active_support/cache"
-require "active_support/notifications"
 require "active_support/core_ext/hash/indifferent_access"
+require "active_support/core_ext/module/delegation"
 require "active_support/core_ext/string"
 require "active_support/core_ext/string/inflections"
-require "active_support/core_ext/module/delegation"
 require "active_support/isolated_execution_state"
-require "fileutils"
+require "active_support/notifications"
 require "cli/ui"
+require "diff/lcs"
+require "json-schema"
 require "raix"
+require "raix/chat_completion"
+require "raix/function_dispatch"
 require "thor"
-require "roast/errors"
-require "roast/helpers"
-require "roast/initializers"
-require "roast/resources"
-require "roast/tools"
-require "roast/version"
-require "roast/workflow"
+
+# Autoloading setup
+require "zeitwerk"
+
+# Set up Zeitwerk autoloader
+loader = Zeitwerk::Loader.for_gem
+loader.setup
 
 module Roast
   ROOT = File.expand_path("../..", __FILE__)
@@ -63,6 +82,32 @@ module Roast
       end
     end
 
+    desc "list", "List workflows visible to Roast and their source"
+    def list
+      roast_dir = File.join(Dir.pwd, "roast")
+
+      unless File.directory?(roast_dir)
+        raise Thor::Error, "No roast/ directory found in current path"
+      end
+
+      workflow_files = Dir.glob(File.join(roast_dir, "**/workflow.yml")).sort
+
+      if workflow_files.empty?
+        raise Thor::Error, "No workflow.yml files found in roast/ directory"
+      end
+
+      puts "Available workflows:"
+      puts
+
+      workflow_files.each do |file|
+        workflow_name = File.dirname(file.sub("#{roast_dir}/", ""))
+        puts "  #{workflow_name} (from project)"
+      end
+
+      puts
+      puts "Run a workflow with: roast execute <workflow_name>"
+    end
+
     private
 
     def show_example_picker

data/roast.gemspec

@@ -37,11 +37,12 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency("activesupport", ">= 7.0")
-  spec.add_dependency("cli-ui")
+  spec.add_dependency("cli-ui", "2.3.0")
   spec.add_dependency("diff-lcs", "~> 1.5")
   spec.add_dependency("faraday-retry")
   spec.add_dependency("json-schema")
   spec.add_dependency("open_router", "~> 0.3")
   spec.add_dependency("raix", "~> 1.0")
   spec.add_dependency("thor", "~> 1.3")
+  spec.add_dependency("zeitwerk", "~> 2.6")
 end

data/schema/workflow.json

@@ -206,6 +206,52 @@
                 }
               },
               "required": ["case", "when"]
+            },
+            {
+              "type": "object",
+              "properties": {
+                "input": {
+                  "type": "object",
+                  "properties": {
+                    "prompt": {
+                      "type": "string",
+                      "description": "The prompt text to display to the user"
+                    },
+                    "name": {
+                      "type": "string",
+                      "description": "Optional name to store the input value in workflow state"
+                    },
+                    "type": {
+                      "type": "string",
+                      "enum": ["text", "boolean", "choice", "password"],
+                      "default": "text",
+                      "description": "The type of input to collect"
+                    },
+                    "required": {
+                      "type": "boolean",
+                      "default": false,
+                      "description": "Whether the input is required"
+                    },
+                    "default": {
+                      "description": "Default value for the input"
+                    },
+                    "timeout": {
+                      "type": "number",
+                      "description": "Optional timeout in seconds"
+                    },
+                    "options": {
+                      "type": "array",
+                      "items": {
+                        "type": "string"
+                      },
+                      "description": "Options for choice type inputs"
+                    }
+                  },
+                  "required": ["prompt"],
+                  "additionalProperties": false
+                }
+              },
+              "required": ["input"]
             }
           ]
         }