roast-ai 0.3.0 → 0.4.0

data/lib/roast/workflow/base_step.rb

@@ -1,37 +1,31 @@
 # frozen_string_literal: true
 
-require "erb"
-require "forwardable"
-require "roast/workflow/context_path_resolver"
-
 module Roast
   module Workflow
     class BaseStep
-      extend Forwardable
-
-      attr_accessor :model, :print_response, :json, :params, :resource, :coerce_to
+      attr_accessor :model, :print_response, :json, :params, :resource, :coerce_to, :available_tools
       attr_reader :workflow, :name, :context_path
 
-      def_delegator :workflow, :append_to_final_output
-      def_delegator :workflow, :chat_completion
-      def_delegator :workflow, :transcript
+      delegate :append_to_final_output, :transcript, to: :workflow
+      delegate_missing_to :workflow
 
       # TODO: is this really the model we want to default to, and is this the right place to set it?
       def initialize(workflow, model: "anthropic:claude-opus-4", name: nil, context_path: nil)
         @workflow = workflow
         @model = model
-        @name = name || self.class.name.underscore.split("/").last
+        @name = normalize_name(name)
         @context_path = context_path || ContextPathResolver.resolve(self.class)
         @print_response = false
         @json = false
         @params = {}
         @coerce_to = nil
+        @available_tools = nil
         @resource = workflow.resource if workflow.respond_to?(:resource)
       end
 
       def call
         prompt(read_sidecar_prompt)
-        result = chat_completion(print_response:, json:, params:)
+        result = chat_completion(print_response:, json:, params:, available_tools:)
 
         # Apply coercion if configured
         apply_coercion(result)
@@ -39,25 +33,17 @@ module Roast
 
       protected
 
-      def chat_completion(print_response: nil, json: nil, params: nil)
+      def chat_completion(print_response: nil, json: nil, params: nil, available_tools: nil)
         # Use instance variables as defaults if parameters are not provided
         print_response = @print_response if print_response.nil?
         json = @json if json.nil?
         params = @params if params.nil?
+        available_tools = @available_tools if available_tools.nil?
 
-        workflow.chat_completion(openai: workflow.openai? && model, model: model, json:, params:).tap do |result|
-          process_output(result, print_response:)
-
-          begin
-            if json
-              return nil if result.strip.empty? # Explicitly handle empty string
+        result = workflow.chat_completion(openai: workflow.openai? && model, model: model, json:, params:, available_tools:)
+        process_output(result, print_response:)
 
-              return JSON.parse(result)
-            end
-          rescue JSON::ParserError
-            # If JSON parsing fails, leave it as a string
-          end
-        end
+        result
       end
 
       def prompt(text)
@@ -79,8 +65,20 @@ module Roast
       def process_output(response, print_response:)
         output_path = File.join(context_path, "output.txt")
         if File.exist?(output_path) && print_response
-          # TODO: use the workflow binding or the step?
-          append_to_final_output(ERB.new(File.read(output_path), trim_mode: "-").result(binding))
+          # Deep wrap the response for template access
+          template_response = deep_wrap_for_templates(response)
+
+          # Debug output
+          if template_response.is_a?(DotAccessHash) && template_response.recommendations&.is_a?(Array)
+            $stderr.puts "DEBUG: recommendations array has #{template_response.recommendations.size} items"
+            $stderr.puts "DEBUG: first item class: #{template_response.recommendations.first.class}" if template_response.recommendations.first
+          end
+
+          # Create a binding that includes the wrapped response
+          template_binding = binding
+          template_binding.local_variable_set(:response, template_response)
+
+          append_to_final_output(ERB.new(File.read(output_path), trim_mode: "-").result(template_binding))
         elsif print_response
           append_to_final_output(response)
         end
@@ -88,6 +86,35 @@ module Roast
 
       private
 
+      def normalize_name(name)
+        return name if name.is_a?(Roast::ValueObjects::StepName)
+
+        name_value = name || self.class.name.underscore.split("/").last
+        Roast::ValueObjects::StepName.new(name_value)
+      end
+
+      # Deep wrap response for ERB templates
+      # This creates a new structure where:
+      # - Hashes are wrapped in DotAccessHash
+      # - Arrays are cloned with their Hash elements wrapped
+      def deep_wrap_for_templates(obj)
+        case obj
+        when Hash
+          # Convert the hash to a new hash with wrapped values
+          wrapped_hash = {}
+          obj.each do |key, value|
+            wrapped_hash[key] = deep_wrap_for_templates(value)
+          end
+          DotAccessHash.new(wrapped_hash)
+        when Array
+          # Create a new array with wrapped elements
+          # This allows the template to use dot notation on array elements
+          obj.map { |item| deep_wrap_for_templates(item) }
+        else
+          obj
+        end
+      end
+
       def apply_coercion(result)
         case @coerce_to
         when :boolean
@@ -97,7 +124,6 @@ module Roast
           !!result
         when :llm_boolean
           # Use LLM boolean coercer for natural language responses
-          require "roast/workflow/llm_boolean_coercer"
           LlmBooleanCoercer.coerce(result)
         when :iterable
           # Ensure result is iterable

data/lib/roast/workflow/base_workflow.rb

@@ -1,12 +1,5 @@
 # frozen_string_literal: true
 
-require "raix/chat_completion"
-require "raix/function_dispatch"
-
-require "roast/workflow/context_path_resolver"
-require "roast/workflow/dot_access_hash"
-require "roast/workflow/output_manager"
-
 module Roast
   module Workflow
     class BaseWorkflow
@@ -29,6 +22,7 @@ module Roast
 
       delegate :api_provider, :openai?, to: :workflow_configuration, allow_nil: true
       delegate :output, :output=, :append_to_final_output, :final_output, to: :output_manager
+      delegate_missing_to :output
 
       def initialize(file = nil, name: nil, context_path: nil, resource: nil, session_name: nil, workflow_configuration: nil, pre_processing_data: nil)
         @file = file
@@ -81,7 +75,7 @@ module Roast
       rescue Faraday::ResourceNotFound => e
         execution_time = Time.now - start_time
         message = e.response.dig(:body, "error", "message") || e.message
-        error = Roast::ResourceNotFoundError.new(message)
+        error = Roast::Errors::ResourceNotFoundError.new(message)
         error.set_backtrace(e.backtrace)
         log_and_raise_error(error, message, step_model || model, kwargs, execution_time)
       rescue => e
@@ -104,19 +98,6 @@ module Roast
       # Expose output manager for state management
       attr_reader :output_manager
 
-      # Allow direct access to output values without 'output.' prefix
-      def method_missing(method_name, *args, &block)
-        if output.respond_to?(method_name)
-          output.send(method_name, *args, &block)
-        else
-          super
-        end
-      end
-
-      def respond_to_missing?(method_name, include_private = false)
-        output.respond_to?(method_name) || super
-      end
-
       private
 
       def log_and_raise_error(error, message, model, params, execution_time)

data/lib/roast/workflow/case_executor.rb

@@ -24,7 +24,6 @@ module Roast
         raise WorkflowExecutor::ConfigurationError, "Missing 'when' clauses in case configuration" unless when_clauses
 
         # Create and execute a CaseStep
-        require "roast/workflow/case_step" unless defined?(Roast::Workflow::CaseStep)
         case_step = CaseStep.new(
           @workflow,
           config: case_config,

data/lib/roast/workflow/case_step.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/workflow/base_step"
-require "roast/workflow/expression_evaluator"
-require "roast/workflow/interpolator"
-
 module Roast
   module Workflow
     class CaseStep < BaseStep

data/lib/roast/workflow/command_executor.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "English"
-
 module Roast
   module Workflow
     class CommandExecutor

data/lib/roast/workflow/conditional_executor.rb

@@ -24,7 +24,6 @@ module Roast
         raise WorkflowExecutor::ConfigurationError, "Missing 'then' steps in conditional configuration" unless then_steps
 
         # Create and execute a ConditionalStep
-        require "roast/workflow/conditional_step" unless defined?(Roast::Workflow::ConditionalStep)
         conditional_step = ConditionalStep.new(
           @workflow,
           config: conditional_config,

data/lib/roast/workflow/conditional_step.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/workflow/base_step"
-require "roast/workflow/expression_evaluator"
-require "roast/workflow/interpolator"
-
 module Roast
   module Workflow
     class ConditionalStep < BaseStep

data/lib/roast/workflow/configuration.rb

@@ -1,10 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/workflow/api_configuration"
-require "roast/workflow/configuration_loader"
-require "roast/workflow/resource_resolver"
-require "roast/workflow/step_finder"
-
 module Roast
   module Workflow
     # Encapsulates workflow configuration data and provides structured access
@@ -96,11 +91,9 @@ module Roast
       attr_reader :api_configuration
 
       def process_resource
-        if defined?(Roast::Resources)
-          @resource = ResourceResolver.resolve(@target, context_path)
-          # Update target with processed value for backward compatibility
-          @target = @resource.value if has_target?
-        end
+        @resource = ResourceResolver.resolve(@target, context_path)
+        # Update target with processed value for backward compatibility
+        @target = @resource.value if has_target?
       end
     end
   end

data/lib/roast/workflow/configuration_loader.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "yaml"
-
 module Roast
   module Workflow
     # Handles loading and parsing of workflow configuration files

data/lib/roast/workflow/configuration_parser.rb

@@ -1,17 +1,11 @@
 # frozen_string_literal: true
 
-require "roast/workflow/configuration"
-require "roast/workflow/workflow_initializer"
-require "roast/workflow/workflow_runner"
-
 module Roast
   module Workflow
     class ConfigurationParser
-      extend Forwardable
-
       attr_reader :configuration, :options, :files, :current_workflow
 
-      def_delegator :current_workflow, :output
+      delegate :output, to: :current_workflow
 
       def initialize(workflow_path, files = [], options = {})
         @configuration = Configuration.new(workflow_path, options)

data/lib/roast/workflow/dot_access_hash.rb

@@ -9,7 +9,7 @@ module Roast
 
       def [](key)
         value = @hash[key.to_sym] || @hash[key.to_s]
-        value.is_a?(Hash) ? DotAccessHash.new(value) : value
+        wrap_value(value)
       end
 
       def []=(key, value)
@@ -193,6 +193,21 @@ module Roast
       end
 
       alias_method :member?, :has_key?
+
+      private
+
+      def wrap_value(value)
+        case value
+        when Hash
+          DotAccessHash.new(value)
+        when Array
+          # Don't create a new array - return the original array
+          # Only wrap Hash elements within the array when needed
+          value
+        else
+          value
+        end
+      end
     end
   end
 end

data/lib/roast/workflow/error_handler.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/helpers/logger"
-require "roast/workflow/command_executor"
-
 module Roast
   module Workflow
     # Handles error logging and instrumentation for workflow execution

data/lib/roast/workflow/expression_evaluator.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/workflow/command_executor"
-require "roast/workflow/expression_utils"
-
 module Roast
   module Workflow
     # Shared module for evaluating expressions in workflow steps

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/prompt_step.rb

@@ -9,7 +9,7 @@ module Roast
 
       def call
         prompt(name)
-        result = chat_completion
+        result = chat_completion(print_response:, json:, params:)
 
         # Apply coercion if configured
         apply_coercion(result)

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