roast-ai 0.1.7 → 0.2.1

data/examples/workflow_generator/workflow.yml

@@ -0,0 +1,35 @@
+# Workflow Generator
+#
+# This workflow generates new Roast workflows based on user descriptions.
+# It gets user input, analyzes the request, generates an appropriate workflow structure,
+# and creates all necessary files in a new directory.
+
+name: Workflow Generator
+model: gpt-4o-mini
+
+tools:
+  - Roast::Tools::WriteFile
+  - Roast::Tools::ReadFile
+  - Roast::Tools::Cmd
+  - Roast::Tools::AskUser
+
+steps:
+  - get_user_input
+  - info_from_roast
+  - analyze_user_request
+  - create_workflow_files
+
+# Step configurations
+get_user_input:
+  print_response: false
+  json: true
+  auto_loop: false
+
+analyze_user_request:
+  print_response: true
+
+generate_workflow_structure:
+  print_response: true
+
+create_workflow_files:
+  print_response: false

data/lib/roast/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Roast
+  # Custom error for API resource not found (404) responses
+  class ResourceNotFoundError < StandardError; end
+
+  # Custom error for when API authentication fails
+  class AuthenticationError < StandardError; end
+end

data/lib/roast/factories/api_provider_factory.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Roast
+  module Factories
+    # Factory for determining and creating API provider configurations
+    class ApiProviderFactory
+      SUPPORTED_PROVIDERS = {
+        "openai" => :openai,
+        "openrouter" => :openrouter,
+      }.freeze
+
+      DEFAULT_PROVIDER = :openai
+
+      class << self
+        # Determines the API provider from configuration
+        # @param config [Hash] The configuration hash
+        # @return [Symbol] The API provider symbol (:openai or :openrouter)
+        def from_config(config)
+          return DEFAULT_PROVIDER unless config["api_provider"]
+
+          provider_name = config["api_provider"].to_s.downcase
+          provider = SUPPORTED_PROVIDERS[provider_name]
+
+          unless provider
+            Roast::Helpers::Logger.warn("Unknown API provider '#{provider_name}', defaulting to #{DEFAULT_PROVIDER}")
+            return DEFAULT_PROVIDER
+          end
+
+          provider
+        end
+
+        # Returns true if the provider is OpenRouter
+        # @param provider [Symbol] The provider symbol
+        # @return [Boolean]
+        def openrouter?(provider)
+          provider == :openrouter
+        end
+
+        # Returns true if the provider is OpenAI
+        # @param provider [Symbol] The provider symbol
+        # @return [Boolean]
+        def openai?(provider)
+          provider == :openai
+        end
+
+        # Returns the list of supported provider names
+        # @return [Array<String>]
+        def supported_provider_names
+          SUPPORTED_PROVIDERS.keys
+        end
+
+        # Validates a provider symbol
+        # @param provider [Symbol] The provider to validate
+        # @return [Boolean]
+        def valid_provider?(provider)
+          SUPPORTED_PROVIDERS.values.include?(provider)
+        end
+      end
+    end
+  end
+end

data/lib/roast/helpers/function_caching_interceptor.rb

@@ -4,7 +4,7 @@ require "active_support"
 require "active_support/isolated_execution_state"
 require "active_support/cache"
 require "active_support/notifications"
-require_relative "logger"
+require "roast/helpers/logger"
 
 module Roast
   module Helpers

data/lib/roast/helpers/minitest_coverage_runner.rb

@@ -2,7 +2,7 @@
 
 require "coverage"
 require "minitest"
-require_relative "logger"
+require "roast/helpers/logger"
 
 # Disable the built-in `at_exit` hook for Minitest before anything else
 module Minitest

data/lib/roast/helpers/prompt_loader.rb

@@ -89,11 +89,60 @@ module Roast
 
       def process_erb_if_needed(content)
         if content.include?("<%")
-          ERB.new(content, trim_mode: "-").result(context.instance_eval { binding })
+          begin
+            ERB.new(content, trim_mode: "-").result(context.instance_eval { binding })
+          rescue TypeError => e
+            if e.message.include?("no implicit conversion of nil into String")
+              # Try to find which variable is causing the issue
+              variable_hint = detect_nil_variable(content)
+
+              error_message = <<~ERROR
+                This workflow requires a file or target to be specified.
+                #{variable_hint}
+
+                Usage: roast execute <workflow.yml> <file_or_pattern>
+
+                Examples:
+                  roast execute #{context.respond_to?(:configuration) && context.configuration&.workflow_path || "workflow.yml"} test/my_test.rb
+                  roast execute #{context.respond_to?(:configuration) && context.configuration&.workflow_path || "workflow.yml"} "test/**/*_test.rb"
+              ERROR
+              raise error_message
+            else
+              raise e
+            end
+          rescue NoMethodError => e
+            if e.message.include?("undefined method") && e.message.include?("for nil")
+              variable_hint = detect_nil_variable(content)
+
+              error_message = <<~ERROR
+                Error processing prompt template: #{e.message}
+                #{variable_hint}
+
+                This may indicate that the workflow requires a file or target to be specified.
+
+                Usage: roast execute <workflow.yml> <file_or_pattern>
+              ERROR
+              raise error_message
+            else
+              raise e
+            end
+          end
         else
           content
         end
       end
+
+      def detect_nil_variable(content)
+        if content.include?("workflow.file")
+          "The prompt template references 'workflow.file' but no file was provided."
+        elsif content.include?("<%= file %>")
+          "The prompt template references 'file' but no file was provided."
+        elsif content.match(/<%= .*?\.(\w+) %>/)
+          "The prompt template is trying to access a property that doesn't exist."
+        else
+          "The prompt template contains an ERB expression that references a nil value."
+        end
+      end
     end
   end
 end

data/lib/roast/resources/base_resource.rb

@@ -19,6 +19,13 @@ module Roast
         target
       end
 
+      # Get the value of the resource (alias for target)
+      # Used for backward compatibility
+      # @return [String] The resource target value
+      def value
+        target
+      end
+
       # Check if the resource exists
       # @return [Boolean] true if the resource exists
       def exists?

data/lib/roast/resources.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require_relative "resources/base_resource"
-require_relative "resources/file_resource"
-require_relative "resources/directory_resource"
-require_relative "resources/url_resource"
-require_relative "resources/api_resource"
-require_relative "resources/none_resource"
+require "roast/resources/base_resource"
+require "roast/resources/file_resource"
+require "roast/resources/directory_resource"
+require "roast/resources/url_resource"
+require "roast/resources/api_resource"
+require "roast/resources/none_resource"
 require "uri"
 
 module Roast

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.1"
 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