roast-ai 0.1.6 → 0.2.0

data/lib/roast/workflow/dot_access_hash.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    class DotAccessHash
+      def initialize(hash)
+        @hash = hash || {}
+      end
+
+      def [](key)
+        value = @hash[key.to_sym] || @hash[key.to_s]
+        value.is_a?(Hash) ? DotAccessHash.new(value) : value
+      end
+
+      def []=(key, value)
+        @hash[key.to_sym] = value
+      end
+
+      def method_missing(method_name, *args, &block)
+        method_str = method_name.to_s
+
+        # Handle boolean predicate methods (ending with ?)
+        if method_str.end_with?("?")
+          key = method_str.chomp("?")
+          # Always return false for non-existent keys with ? methods
+          return false unless has_key?(key) # rubocop:disable Style/PreferredHashMethods
+
+          !!self[key]
+        # Handle setter methods (ending with =)
+        elsif method_str.end_with?("=")
+          key = method_str.chomp("=")
+          self[key] = args.first
+        # Handle bang methods (ending with !) - should raise
+        elsif method_str.end_with?("!")
+          super
+        # Handle regular getter methods
+        elsif args.empty? && block.nil?
+          # Return nil for non-existent keys (like a hash would)
+          self[method_str]
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        method_str = method_name.to_s
+
+        if method_str.end_with?("!")
+          false # Don't respond to bang methods
+        elsif method_str.end_with?("?")
+          true  # Always respond to predicate methods
+        elsif method_str.end_with?("=")
+          true  # Always respond to setter methods
+        else
+          true  # Always respond to getter methods (they return nil if missing)
+        end
+      end
+
+      def to_h
+        @hash
+      end
+
+      def keys
+        @hash.keys
+      end
+
+      def empty?
+        @hash.empty?
+      end
+
+      def each(&block)
+        @hash.each(&block)
+      end
+
+      def to_s
+        @hash.to_s
+      end
+
+      def inspect
+        @hash.inspect
+      end
+
+      def to_json(*args)
+        @hash.to_json(*args)
+      end
+
+      def merge(other)
+        merged_hash = @hash.dup
+        other_hash = other.is_a?(DotAccessHash) ? other.to_h : other
+        merged_hash.merge!(other_hash)
+        DotAccessHash.new(merged_hash)
+      end
+
+      def values
+        @hash.values
+      end
+
+      def key?(key)
+        has_key?(key) # rubocop:disable Style/PreferredHashMethods
+      end
+
+      def include?(key)
+        has_key?(key) # rubocop:disable Style/PreferredHashMethods
+      end
+
+      def fetch(key, *args)
+        if has_key?(key) # rubocop:disable Style/PreferredHashMethods
+          self[key]
+        elsif block_given?
+          yield(key)
+        elsif !args.empty?
+          args[0]
+        else
+          raise KeyError, "key not found: #{key.inspect}"
+        end
+      end
+
+      def dig(*keys)
+        keys.inject(self) do |obj, key|
+          break nil unless obj.is_a?(DotAccessHash) || obj.is_a?(Hash)
+
+          if obj.is_a?(DotAccessHash)
+            obj[key]
+          else
+            obj[key.to_sym] || obj[key.to_s]
+          end
+        end
+      end
+
+      def size
+        @hash.size
+      end
+
+      alias_method :length, :size
+
+      def map(&block)
+        @hash.map(&block)
+      end
+
+      def select(&block)
+        DotAccessHash.new(@hash.select(&block))
+      end
+
+      def reject(&block)
+        DotAccessHash.new(@hash.reject(&block))
+      end
+
+      def compact
+        DotAccessHash.new(@hash.compact)
+      end
+
+      def slice(*keys)
+        sliced = {}
+        keys.each do |key|
+          if has_key?(key) # rubocop:disable Style/PreferredHashMethods
+            sliced[key.to_sym] = @hash[key.to_sym] || @hash[key.to_s]
+          end
+        end
+        DotAccessHash.new(sliced)
+      end
+
+      def except(*keys)
+        excluded = @hash.dup
+        keys.each do |key|
+          excluded.delete(key.to_sym)
+          excluded.delete(key.to_s)
+        end
+        DotAccessHash.new(excluded)
+      end
+
+      def delete(key)
+        @hash.delete(key.to_sym) || @hash.delete(key.to_s)
+      end
+
+      def clear
+        @hash.clear
+        self
+      end
+
+      def ==(other)
+        case other
+        when DotAccessHash
+          @hash == other.instance_variable_get(:@hash)
+        when Hash
+          @hash == other
+        else
+          false
+        end
+      end
+
+      def has_key?(key_name)
+        @hash.key?(key_name.to_sym) || @hash.key?(key_name.to_s)
+      end
+
+      alias_method :member?, :has_key?
+    end
+  end
+end

data/lib/roast/workflow/each_step.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Executes steps for each item in a collection
+    class EachStep < BaseIterationStep
+      attr_reader :collection_expr, :variable_name
+
+      def initialize(workflow, collection_expr:, variable_name:, steps:, **kwargs)
+        super(workflow, steps: steps, **kwargs)
+        @collection_expr = collection_expr
+        @variable_name = variable_name
+      end
+
+      def call
+        # Process the collection expression with appropriate type coercion
+        collection = process_iteration_input(@collection_expr, workflow, coerce_to: :iterable)
+
+        unless collection.respond_to?(:each)
+          $stderr.puts "Error: Collection '#{@collection_expr}' is not iterable"
+          raise ArgumentError, "Collection '#{@collection_expr}' is not iterable"
+        end
+
+        results = []
+        $stderr.puts "Starting each loop over collection with #{collection.size} items"
+
+        # Iterate over the collection
+        collection.each_with_index do |item, index|
+          $stderr.puts "Each loop iteration #{index + 1} with #{@variable_name}=#{item.inspect}"
+
+          # Create a context with the current item as a variable
+          define_iteration_variable(item)
+
+          # Execute the nested steps
+          step_results = execute_nested_steps(@steps, workflow)
+          results << step_results
+
+          # Save state after each iteration if the workflow supports it
+          save_iteration_state(index, item) if workflow.respond_to?(:session_name) && workflow.session_name
+        end
+
+        $stderr.puts "Each loop completed with #{collection.size} iterations"
+        results
+      end
+
+      private
+
+      # Keep for backward compatibility, deprecated
+      def resolve_collection
+        process_iteration_input(@collection_expr, workflow, coerce_to: :iterable)
+      end
+
+      def define_iteration_variable(value)
+        # Set the variable in the workflow's context
+        workflow.instance_variable_set("@#{@variable_name}", value)
+
+        # Define a getter method for the variable
+        var_name = @variable_name.to_sym
+        workflow.singleton_class.class_eval do
+          attr_reader(var_name)
+        end
+
+        # Make the variable accessible in the output hash
+        workflow.output[@variable_name] = value if workflow.respond_to?(:output)
+      end
+
+      def save_iteration_state(index, item)
+        state_repository = FileStateRepository.new
+
+        # Save the current iteration state
+        state_data = {
+          step_name: name,
+          iteration_index: index,
+          current_item: item,
+          output: workflow.respond_to?(:output) ? workflow.output.clone : {},
+          transcript: workflow.respond_to?(:transcript) ? workflow.transcript.map(&:itself) : [],
+        }
+
+        state_repository.save_state(workflow, "#{name}_item_#{index}", state_data)
+      rescue => e
+        # Don't fail the workflow if state saving fails
+        $stderr.puts "Warning: Failed to save iteration state: #{e.message}"
+      end
+    end
+  end
+end

data/lib/roast/workflow/error_handler.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "active_support/notifications"
+require "roast/helpers/logger"
+require "roast/workflow/command_executor"
+
+module Roast
+  module Workflow
+    # Handles error logging and instrumentation for workflow execution
+    class ErrorHandler
+      def initialize
+        # Use the Roast logger singleton
+      end
+
+      def with_error_handling(step_name, resource_type: nil)
+        start_time = Time.now
+
+        ActiveSupport::Notifications.instrument("roast.step.start", {
+          step_name: step_name,
+          resource_type: resource_type,
+        })
+
+        result = yield
+
+        execution_time = Time.now - start_time
+
+        ActiveSupport::Notifications.instrument("roast.step.complete", {
+          step_name: step_name,
+          resource_type: resource_type,
+          success: true,
+          execution_time: execution_time,
+          result_size: result.to_s.length,
+        })
+
+        result
+      rescue WorkflowExecutor::WorkflowExecutorError => e
+        handle_workflow_error(e, step_name, resource_type, start_time)
+        raise
+      rescue CommandExecutor::CommandExecutionError => e
+        handle_workflow_error(e, step_name, resource_type, start_time)
+        raise
+      rescue => e
+        handle_generic_error(e, step_name, resource_type, start_time)
+      end
+
+      def log_error(message)
+        Roast::Helpers::Logger.error(message)
+      end
+
+      def log_warning(message)
+        Roast::Helpers::Logger.warn(message)
+      end
+
+      # Alias methods for compatibility
+      def error(message)
+        log_error(message)
+      end
+
+      def warn(message)
+        log_warning(message)
+      end
+
+      private
+
+      def handle_workflow_error(error, step_name, resource_type, start_time)
+        execution_time = Time.now - start_time
+
+        ActiveSupport::Notifications.instrument("roast.step.error", {
+          step_name: step_name,
+          resource_type: resource_type,
+          error: error.class.name,
+          message: error.message,
+          execution_time: execution_time,
+        })
+      end
+
+      def handle_generic_error(error, step_name, resource_type, start_time)
+        execution_time = Time.now - start_time
+
+        ActiveSupport::Notifications.instrument("roast.step.error", {
+          step_name: step_name,
+          resource_type: resource_type,
+          error: error.class.name,
+          message: error.message,
+          execution_time: execution_time,
+        })
+
+        # Wrap the original error with context about which step failed
+        raise WorkflowExecutor::StepExecutionError.new(
+          "Failed to execute step '#{step_name}': #{error.message}",
+          step_name: step_name,
+          original_error: error,
+        )
+      end
+    end
+  end
+end

data/lib/roast/workflow/expression_utils.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Shared utilities for detecting and extracting expressions
+    module ExpressionUtils
+      # Check if the input is a Ruby expression in {{...}}
+      def ruby_expression?(input)
+        return false unless input.is_a?(String)
+
+        input.strip.start_with?("{{") && input.strip.end_with?("}}")
+      end
+
+      # Check if the input is a Bash command in $(...)
+      def bash_command?(input)
+        return false unless input.is_a?(String)
+
+        input.strip.start_with?("$(") && input.strip.end_with?(")")
+      end
+
+      # Extract the expression from {{...}}
+      def extract_expression(input)
+        return input unless ruby_expression?(input)
+
+        input.strip[2...-2].strip
+      end
+
+      # Extract the command from $(...)
+      def extract_command(input)
+        return input unless bash_command?(input)
+
+        input.strip[2...-1].strip
+      end
+    end
+  end
+end

data/lib/roast/workflow/file_state_repository.rb

@@ -2,8 +2,8 @@
 
 require "json"
 require "fileutils"
-require_relative "session_manager"
-require_relative "state_repository"
+require "roast/workflow/session_manager"
+require "roast/workflow/state_repository"
 
 module Roast
   module Workflow
@@ -28,6 +28,7 @@ module Roast
             timestamp: workflow.session_timestamp,
           )
           step_file = File.join(session_dir, format_step_filename(state_data[:order], step_name))
+          FileUtils.mkdir_p(File.dirname(step_file))
           File.write(step_file, JSON.pretty_generate(state_data))
         end
       rescue => e

data/lib/roast/workflow/interpolator.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    class Interpolator
+      def initialize(context, logger: nil)
+        @context = context
+        @logger = logger || NullLogger.new
+      end
+
+      def interpolate(text)
+        return text unless text.is_a?(String) && text.include?("{{") && text.include?("}}")
+
+        # Replace all {{expression}} with their evaluated values
+        text.gsub(/\{\{([^}]+)\}\}/) do |match|
+          expression = Regexp.last_match(1).strip
+          begin
+            # Evaluate the expression in the context
+            @context.instance_eval(expression).to_s
+          rescue => e
+            # Provide a detailed error message but preserve the original expression
+            error_msg = "Error interpolating {{#{expression}}}: #{e.message}. This variable is not defined in the workflow context."
+            @logger.error(error_msg)
+            match # Preserve the original expression in the string
+          end
+        end
+      end
+
+      class NullLogger
+        def error(_message); end
+      end
+    end
+  end
+end

data/lib/roast/workflow/iteration_executor.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Handles execution of iteration steps (repeat and each)
+    class IterationExecutor
+      def initialize(workflow, context_path, state_manager)
+        @workflow = workflow
+        @context_path = context_path
+        @state_manager = state_manager
+      end
+
+      def execute_repeat(repeat_config)
+        $stderr.puts "Executing repeat step: #{repeat_config.inspect}"
+
+        # Extract parameters from the repeat configuration
+        steps = repeat_config["steps"]
+        until_condition = repeat_config["until"]
+        max_iterations = repeat_config["max_iterations"] || BaseIterationStep::DEFAULT_MAX_ITERATIONS
+
+        # Verify required parameters
+        raise WorkflowExecutor::ConfigurationError, "Missing 'steps' in repeat configuration" unless steps
+        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,
+          until_condition: until_condition,
+          max_iterations: max_iterations,
+          name: "repeat_#{@workflow.output.size}",
+          context_path: @context_path,
+        )
+
+        results = repeat_step.call
+
+        # Store results in workflow output
+        step_name = "repeat_#{until_condition.gsub(/[^a-zA-Z0-9_]/, "_")}"
+        @workflow.output[step_name] = results
+
+        # Save state
+        @state_manager.save_state(step_name, results)
+
+        results
+      end
+
+      def execute_each(each_config)
+        $stderr.puts "Executing each step: #{each_config.inspect}"
+
+        # Extract parameters from the each configuration
+        collection_expr = each_config["each"]
+        variable_name = each_config["as"]
+        steps = each_config["steps"]
+
+        # Verify required parameters
+        raise WorkflowExecutor::ConfigurationError, "Missing collection expression in each configuration" unless collection_expr
+        raise WorkflowExecutor::ConfigurationError, "Missing 'as' variable name in each configuration" unless variable_name
+        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,
+          variable_name: variable_name,
+          steps: steps,
+          name: "each_#{variable_name}",
+          context_path: @context_path,
+        )
+
+        results = each_step.call
+
+        # Store results in workflow output
+        step_name = "each_#{variable_name}"
+        @workflow.output[step_name] = results
+
+        # Save state
+        @state_manager.save_state(step_name, results)
+
+        results
+      end
+    end
+  end
+end

data/lib/roast/workflow/llm_boolean_coercer.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Handles intelligent coercion of LLM responses to boolean values
+    class LlmBooleanCoercer
+      # Patterns for detecting affirmative and negative responses
+      EXPLICIT_TRUE_PATTERN = /\A(yes|y|true|t|1)\z/i
+      EXPLICIT_FALSE_PATTERN = /\A(no|n|false|f|0)\z/i
+      AFFIRMATIVE_PATTERN = /\b(yes|true|correct|affirmative|confirmed|indeed|right|positive|agree|definitely|certainly|absolutely)\b/
+      NEGATIVE_PATTERN = /\b(no|false|incorrect|negative|denied|wrong|disagree|never)\b/
+
+      class << self
+        # Convert an LLM response to a boolean value
+        #
+        # @param result [Object] The value to coerce to boolean
+        # @return [Boolean] The coerced boolean value
+        def coerce(result)
+          return true if result.is_a?(TrueClass)
+          return false if result.is_a?(FalseClass) || result.nil?
+
+          text = result.to_s.downcase.strip
+
+          # Check for explicit boolean-like responses first
+          return true if text =~ EXPLICIT_TRUE_PATTERN
+          return false if text =~ EXPLICIT_FALSE_PATTERN
+
+          # Then check for these words within longer responses
+          has_affirmative = !!(text =~ AFFIRMATIVE_PATTERN)
+          has_negative = !!(text =~ NEGATIVE_PATTERN)
+
+          # Handle conflicts
+          if has_affirmative && has_negative
+            warn_ambiguity(result, "contains both affirmative and negative terms")
+            false
+          elsif has_affirmative
+            true
+          elsif has_negative
+            false
+          else
+            warn_ambiguity(result, "no clear boolean indicators found")
+            false
+          end
+        end
+
+        private
+
+        # Log a warning for ambiguous LLM boolean responses
+        def warn_ambiguity(result, reason)
+          $stderr.puts "Warning: Ambiguous LLM response for boolean conversion (#{reason}): '#{result.to_s.strip}'"
+        end
+      end
+    end
+  end
+end

data/lib/roast/workflow/output_handler.rb

@@ -0,0 +1,35 @@
+# 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
+    class OutputHandler
+      def save_final_output(workflow)
+        return unless workflow.respond_to?(:session_name) && workflow.session_name && workflow.respond_to?(:final_output)
+
+        begin
+          final_output = workflow.final_output.to_s
+          return if final_output.empty?
+
+          state_repository = FileStateRepository.new
+          output_file = state_repository.save_final_output(workflow, final_output)
+          $stderr.puts "Final output saved to: #{output_file}" if output_file
+        rescue => e
+          # Don't fail if saving output fails
+          $stderr.puts "Warning: Failed to save final output to session: #{e.message}"
+        end
+      end
+
+      def write_results(workflow)
+        if workflow.output_file
+          File.write(workflow.output_file, workflow.final_output)
+          $stdout.puts "Results saved to #{workflow.output_file}"
+        else
+          $stdout.puts workflow.final_output
+        end
+      end
+    end
+  end
+end