roast-ai 0.1.7 → 0.2.0

data/lib/roast/tools/ask_user.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "roast/helpers/logger"
+
+module Roast
+  module Tools
+    module AskUser
+      extend self
+
+      class << self
+        # Add this method to be included in other classes
+        def included(base)
+          base.class_eval do
+            function(
+              :ask_user,
+              "Ask the user for input with a specific prompt. Returns the user's response.",
+              prompt: { type: "string", description: "The prompt to show the user" },
+            ) do |params|
+              Roast::Tools::AskUser.call(params[:prompt])
+            end
+          end
+        end
+      end
+
+      def call(prompt)
+        Roast::Helpers::Logger.info("💬 Asking user: #{prompt}\n")
+
+        response = ::CLI::UI::Prompt.ask(prompt)
+
+        Roast::Helpers::Logger.info("User responded: #{response}\n")
+        response
+      rescue StandardError => e
+        "Error getting user input: #{e.message}".tap do |error_message|
+          Roast::Helpers::Logger.error(error_message + "\n")
+          Roast::Helpers::Logger.debug(e.backtrace.join("\n") + "\n") if ENV["DEBUG"]
+        end
+      end
+    end
+  end
+end

data/lib/roast/tools/cmd.rb

@@ -28,7 +28,7 @@ module Roast
         Roast::Helpers::Logger.info("🔧 Running command: #{command}\n")
 
         # Validate the command starts with one of the allowed prefixes
-        allowed_prefixes = ["pwd", "find", "ls", "rake", "ruby", "dev"]
+        allowed_prefixes = ["pwd", "find", "ls", "rake", "ruby", "dev", "mkdir"]
         command_prefix = command.split(" ").first
 
         err = "Error: Command not allowed. Only commands starting with #{allowed_prefixes.join(", ")} are permitted."

data/lib/roast/tools/search_file.rb

@@ -26,7 +26,7 @@ module Roast
       end
 
       def call(glob_pattern, path = ".")
-        Roast::Helpers::Logger.info("🔍 Searching for: '#{glob_pattern}' in '#{path}'\n")
+        Roast::Helpers::Logger.info("🔍 Searching for: '#{glob_pattern}' in '#{File.expand_path(path)}'\n")
         search_for(glob_pattern, path).then do |results|
           return "No results found for #{glob_pattern} in #{path}" if results.empty?
           return read_contents(results.first) if results.size == 1

data/lib/roast/tools.rb

@@ -2,6 +2,7 @@
 
 require "active_support/cache"
 require "English"
+require "fileutils"
 
 require "roast/tools/grep"
 require "roast/tools/read_file"
@@ -10,12 +11,21 @@ require "roast/tools/write_file"
 require "roast/tools/update_files"
 require "roast/tools/cmd"
 require "roast/tools/coding_agent"
+require "roast/tools/ask_user"
 
 module Roast
   module Tools
     extend self
 
-    CACHE = ActiveSupport::Cache::FileStore.new(File.join(Dir.pwd, ".roast", "cache"))
+    # Initialize cache and ensure .gitignore exists
+    cache_dir = File.join(Dir.pwd, ".roast", "cache")
+    FileUtils.mkdir_p(cache_dir) unless File.directory?(cache_dir)
+
+    # Add .gitignore to cache directory
+    gitignore_path = File.join(cache_dir, ".gitignore")
+    File.write(gitignore_path, "*") unless File.exist?(gitignore_path)
+
+    CACHE = ActiveSupport::Cache::FileStore.new(cache_dir)
 
     def file_to_prompt(file)
       <<~PROMPT

data/lib/roast/value_objects/api_token.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Roast
+  module ValueObjects
+    # Value object representing an API token with validation
+    class ApiToken
+      class InvalidTokenError < StandardError; end
+
+      attr_reader :value
+
+      def initialize(value)
+        @value = value&.to_s
+        validate!
+        freeze
+      end
+
+      def present?
+        !blank?
+      end
+
+      def blank?
+        @value.nil? || @value.strip.empty?
+      end
+
+      def to_s
+        @value
+      end
+
+      def ==(other)
+        return false unless other.is_a?(ApiToken)
+
+        value == other.value
+      end
+      alias_method :eql?, :==
+
+      def hash
+        [self.class, @value].hash
+      end
+
+      private
+
+      def validate!
+        return if @value.nil? # Allow nil tokens, just not empty strings
+
+        raise InvalidTokenError, "API token cannot be an empty string" if @value.strip.empty?
+      end
+    end
+  end
+end

data/lib/roast/value_objects/step_name.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Roast
+  module ValueObjects
+    # Value object representing a step name, which can be either a plain text prompt
+    # or a reference to a step file
+    class StepName
+      attr_reader :value
+
+      def initialize(name)
+        @value = name.to_s.strip
+        freeze
+      end
+
+      def plain_text?
+        @value.include?(" ")
+      end
+
+      def file_reference?
+        !plain_text?
+      end
+
+      def to_s
+        @value
+      end
+
+      def ==(other)
+        return false unless other.is_a?(StepName)
+
+        value == other.value
+      end
+      alias_method :eql?, :==
+
+      def hash
+        [self.class, @value].hash
+      end
+    end
+  end
+end

data/lib/roast/value_objects/workflow_path.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Roast
+  module ValueObjects
+    # Value object representing a workflow file path with validation and resolution
+    class WorkflowPath
+      class InvalidPathError < StandardError; end
+
+      attr_reader :value
+
+      def initialize(path)
+        @value = normalize_path(path)
+        @pathname = Pathname.new(@value)
+        validate!
+        freeze
+      end
+
+      def exist?
+        pathname.exist?
+      end
+
+      def absolute?
+        pathname.absolute?
+      end
+
+      def relative?
+        pathname.relative?
+      end
+
+      def dirname
+        pathname.dirname.to_s
+      end
+
+      def basename
+        pathname.basename.to_s
+      end
+
+      def to_s
+        @value
+      end
+
+      def to_path
+        @value
+      end
+
+      def ==(other)
+        return false unless other.is_a?(WorkflowPath)
+
+        value == other.value
+      end
+      alias_method :eql?, :==
+
+      def hash
+        [self.class, @value].hash
+      end
+
+      private
+
+      attr_reader :pathname
+
+      def normalize_path(path)
+        path.to_s.strip
+      end
+
+      def validate!
+        raise InvalidPathError, "Workflow path cannot be empty" if @value.empty?
+        raise InvalidPathError, "Workflow path must have .yml or .yaml extension" unless valid_extension?
+      end
+
+      def valid_extension?
+        @value.end_with?(".yml") || @value.end_with?(".yaml")
+      end
+    end
+  end
+end

data/lib/roast/value_objects.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "roast/value_objects/api_token"
+require "roast/value_objects/step_name"
+require "roast/value_objects/workflow_path"

data/lib/roast/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Roast
-  VERSION = "0.1.7"
+  VERSION = "0.2.0"
 end

data/lib/roast/workflow/api_configuration.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "roast/factories/api_provider_factory"
+require "roast/workflow/resource_resolver"
+
+module Roast
+  module Workflow
+    # Handles API-related configuration including tokens and providers
+    class ApiConfiguration
+      attr_reader :api_token, :api_provider
+
+      def initialize(config_hash)
+        @config_hash = config_hash
+        process_api_configuration
+      end
+
+      # Check if using OpenRouter
+      # @return [Boolean] true if using OpenRouter
+      def openrouter?
+        Roast::Factories::ApiProviderFactory.openrouter?(@api_provider)
+      end
+
+      # Check if using OpenAI
+      # @return [Boolean] true if using OpenAI
+      def openai?
+        Roast::Factories::ApiProviderFactory.openai?(@api_provider)
+      end
+
+      # Get the effective API token including environment variables
+      # @return [String, nil] The API token
+      def effective_token
+        @api_token || environment_token
+      end
+
+      private
+
+      def process_api_configuration
+        extract_api_token
+        extract_api_provider
+      end
+
+      def extract_api_token
+        if @config_hash["api_token"]
+          @api_token = ResourceResolver.process_shell_command(@config_hash["api_token"])
+        end
+      end
+
+      def extract_api_provider
+        @api_provider = Roast::Factories::ApiProviderFactory.from_config(@config_hash)
+      end
+
+      def environment_token
+        if openai?
+          ENV["OPENAI_API_KEY"]
+        elsif openrouter?
+          ENV["OPENROUTER_API_KEY"]
+        end
+      end
+    end
+  end
+end

data/lib/roast/workflow/base_iteration_step.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require "roast/workflow/expression_utils"
+require "roast/workflow/llm_boolean_coercer"
+require "roast/workflow/workflow_executor"
+
+module Roast
+  module Workflow
+    # Base class for iteration steps (RepeatStep and EachStep)
+    class BaseIterationStep < BaseStep
+      include ExpressionUtils
+
+      DEFAULT_MAX_ITERATIONS = 100
+
+      attr_reader :steps
+
+      def initialize(workflow, steps:, **kwargs)
+        super(workflow, **kwargs)
+        @steps = steps
+        # Don't initialize cmd_tool here - we'll do it lazily when needed
+      end
+
+      protected
+
+      # Process various types of inputs and convert to appropriate types for iteration
+      def process_iteration_input(input, context, coerce_to: nil)
+        if input.is_a?(String)
+          if ruby_expression?(input)
+            process_ruby_expression(input, context, coerce_to)
+          elsif bash_command?(input)
+            process_bash_command(input, coerce_to)
+          else
+            process_step_or_prompt(input, context, coerce_to)
+          end
+        else
+          # Non-string inputs are coerced as-is
+          coerce_result(input, coerce_to)
+        end
+      end
+
+      # Interpolates {{expression}} in a string with values from the workflow context
+      def interpolate_expression(text, context)
+        return text unless text.is_a?(String) && text.include?("{{") && text.include?("}}")
+
+        # Replace all {{expression}} with their evaluated values
+        text.gsub(/\{\{([^}]+)\}\}/) do |match|
+          expression = extract_expression(match)
+          begin
+            # Evaluate the expression in the workflow's context
+            result = context.instance_eval(expression)
+            result.inspect # Convert to string representation
+          rescue => e
+            warn_interpolation_error(expression, e)
+            match # Return the original match to preserve it in the string
+          end
+        end
+      end
+
+      # Execute nested steps
+      def execute_nested_steps(steps, context, executor = nil)
+        executor ||= WorkflowExecutor.new(context, {}, context_path)
+        results = []
+
+        steps.each do |step|
+          result = case step
+          when String
+            executor.execute_step(step)
+          when Hash, Array
+            executor.execute_steps([step])
+          end
+          results << result
+        end
+
+        results
+      end
+
+      private
+
+      # Process a Ruby expression
+      def process_ruby_expression(input, context, coerce_to)
+        expression = extract_expression(input)
+        result = evaluate_ruby_expression(expression, context)
+        coerce_result(result, coerce_to)
+      end
+
+      # Process a Bash command
+      def process_bash_command(input, coerce_to)
+        command = extract_command(input)
+        execute_command(command, coerce_to)
+      end
+
+      # Process a step name or prompt
+      def process_step_or_prompt(input, context, coerce_to)
+        step_result = execute_step_by_name(input, context)
+        coerce_result(step_result, coerce_to)
+      end
+
+      # Execute a Ruby expression in the workflow context
+      def evaluate_ruby_expression(expression, context)
+        context.instance_eval(expression)
+      rescue => e
+        warn_expression_error(expression, e)
+        nil
+      end
+
+      # Execute a bash command and return its result
+      def execute_command(command, coerce_to)
+        # Use the Cmd module to execute the command
+        result = Roast::Tools::Cmd.call(command)
+
+        if coerce_to == :boolean
+          # For boolean coercion, use exit status (assume success unless error message)
+          !result.to_s.start_with?("Error")
+        else
+          # For other uses, return the output
+          result
+        end
+      end
+
+      # Execute a step by name and return its result
+      def execute_step_by_name(step_name, context)
+        # Reuse existing step execution logic
+        executor = WorkflowExecutor.new(context, {}, context_path)
+        executor.execute_step(step_name)
+      end
+
+      # Coerce results to the appropriate type
+      def coerce_result(result, coerce_to)
+        return coerce_to_boolean(result) if coerce_to == :boolean
+        return coerce_to_iterable(result) if coerce_to == :iterable
+        return coerce_to_llm_boolean(result) if coerce_to == :llm_boolean
+
+        # Default - return as is
+        result
+      end
+
+      # Force a value to boolean
+      def coerce_to_boolean(result)
+        !!result
+      end
+
+      # Ensure a value is iterable
+      def coerce_to_iterable(result)
+        return result if result.respond_to?(:each)
+
+        result.to_s.split("\n")
+      end
+
+      # Convert LLM response to boolean
+      def coerce_to_llm_boolean(result)
+        LlmBooleanCoercer.coerce(result)
+      end
+
+      # Log a warning for expression evaluation errors
+      def warn_expression_error(expression, error)
+        $stderr.puts "Warning: Error evaluating expression '#{expression}': #{error.message}"
+      end
+
+      # Log a warning for interpolation errors
+      def warn_interpolation_error(expression, error)
+        $stderr.puts "Warning: Error interpolating {{#{expression}}}: #{error.message}"
+      end
+    end
+  end
+end

data/lib/roast/workflow/base_step.rb

@@ -2,6 +2,7 @@
 
 require "erb"
 require "forwardable"
+require "roast/workflow/context_path_resolver"
 
 module Roast
   module Workflow
@@ -15,11 +16,11 @@ module Roast
       def_delegator :workflow, :chat_completion
       def_delegator :workflow, :transcript
 
-      def initialize(workflow, model: "anthropic:claude-3-7-sonnet", name: nil, context_path: nil, auto_loop: true)
+      def initialize(workflow, model: "anthropic:claude-opus-4", name: nil, context_path: nil, auto_loop: true)
         @workflow = workflow
         @model = model
         @name = name || self.class.name.underscore.split("/").last
-        @context_path = context_path || determine_context_path
+        @context_path = context_path || ContextPathResolver.resolve(self.class)
         @print_response = false
         @auto_loop = auto_loop
         @json = false
@@ -35,7 +36,7 @@ module Roast
       protected
 
       def chat_completion(print_response: false, auto_loop: true, json: false, params: {})
-        workflow.chat_completion(openai: model, loop: auto_loop, json:, params:).then do |response|
+        workflow.chat_completion(openai: workflow.openai? && model, loop: auto_loop, model: model, json:, params:).then do |response|
           case response
           in Array
             response.map(&:presence).compact.join("\n")
@@ -47,27 +48,6 @@ module Roast
         end
       end
 
-      # Determine the directory where the actual class is defined, not BaseWorkflow
-      def determine_context_path
-        # Get the actual class's source file
-        klass = self.class
-
-        # Try to get the file path where the class is defined
-        path = if klass.name.include?("::")
-          # For namespaced classes like Roast::Workflow::Grading::Workflow
-          # Convert the class name to a relative path
-          class_path = klass.name.underscore + ".rb"
-          # Look through load path to find the actual file
-          $LOAD_PATH.map { |p| File.join(p, class_path) }.find { |f| File.exist?(f) }
-        else
-          # Fall back to the current file if we can't find it
-          __FILE__
-        end
-
-        # Return directory containing the class definition
-        File.dirname(path || __FILE__)
-      end
-
       def prompt(text)
         transcript << { user: text }
       end