roast-ai 0.1.0 → 0.1.1

data/lib/roast/helpers/function_caching_interceptor.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support"
+require "active_support/isolated_execution_state"
 require "active_support/cache"
 require "active_support/notifications"
 require_relative "logger"
@@ -10,17 +12,79 @@ module Roast
     # This module wraps around Raix::FunctionDispatch to provide caching for tool functions
     module FunctionCachingInterceptor
       def dispatch_tool_function(function_name, params)
-        # legacy workflows don't have a configuration
-        return super(function_name, params) if configuration.blank?
+        start_time = Time.now
 
-        function_config = configuration.function_config(function_name)
-        if function_config&.dig("cache", "enabled")
-          # Call the original function and pass in the cache
-          super(function_name, params, cache: Roast::Tools::CACHE)
-        else
-          Roast::Helpers::Logger.debug("⚠️ Caching not enabled for #{function_name}")
+        ActiveSupport::Notifications.instrument("roast.tool.execute", {
+          function_name: function_name,
+          params: params,
+        })
+
+        # Handle workflows with or without configuration
+        result = if !respond_to?(:configuration) || configuration.nil?
           super(function_name, params)
+        else
+          function_config = if configuration.respond_to?(:function_config)
+            configuration.function_config(function_name)
+          else
+            {}
+          end
+
+          # Check if caching is enabled - handle both formats:
+          # 1. cache: true (boolean format)
+          # 2. cache: { enabled: true } (hash format)
+          cache_enabled = if function_config.is_a?(Hash)
+            cache_config = function_config["cache"]
+            if cache_config.is_a?(Hash)
+              cache_config["enabled"]
+            else
+              # Direct boolean value
+              cache_config
+            end
+          else
+            false
+          end
+
+          if cache_enabled
+            # Call the original function and pass in the cache
+            super(function_name, params, cache: Roast::Tools::CACHE)
+          else
+            Roast::Helpers::Logger.debug("⚠️ Caching not enabled for #{function_name}")
+            super(function_name, params)
+          end
+        end
+
+        execution_time = Time.now - start_time
+
+        # Determine if caching was enabled for metrics
+        cache_enabled = if defined?(function_config) && function_config.is_a?(Hash)
+          cache_config = function_config["cache"]
+          if cache_config.is_a?(Hash)
+            cache_config["enabled"]
+          else
+            # Direct boolean value
+            cache_config
+          end
+        else
+          false
         end
+
+        ActiveSupport::Notifications.instrument("roast.tool.complete", {
+          function_name: function_name,
+          execution_time: execution_time,
+          cache_enabled: cache_enabled,
+        })
+
+        result
+      rescue => e
+        execution_time = Time.now - start_time
+
+        ActiveSupport::Notifications.instrument("roast.tool.error", {
+          function_name: function_name,
+          error: e.class.name,
+          message: e.message,
+          execution_time: execution_time,
+        })
+        raise
       end
     end
   end

data/lib/roast/helpers/prompt_loader.rb

@@ -74,6 +74,8 @@ module Roast
       end
 
       def extract_file_extensions
+        return [] if target_file.nil?
+
         file_basename = File.basename(target_file)
 
         if file_basename.end_with?(".md") && file_basename.count(".") > 1

data/lib/roast/resources/api_resource.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+module Roast
+  module Resources
+    # Resource implementation for API endpoints using Fetch API-style format
+    class ApiResource < BaseResource
+      def process
+        # For API resources, the target might be a JSON configuration or endpoint URL
+        target
+      end
+
+      def config
+        return @config if defined?(@config)
+
+        @config = if target.is_a?(String) && target.match?(/^\s*{/)
+          begin
+            JSON.parse(target)
+          rescue JSON::ParserError
+            nil
+          end
+        end
+      end
+
+      def api_url
+        if config && config["url"]
+          config["url"]
+        else
+          # Assume direct URL
+          target
+        end
+      end
+
+      def options
+        return {} unless config
+
+        config["options"] || {}
+      end
+
+      def http_method
+        method_name = (options["method"] || "GET").upcase
+        case method_name
+        when "GET" then Net::HTTP::Get
+        when "POST" then Net::HTTP::Post
+        when "PUT" then Net::HTTP::Put
+        when "DELETE" then Net::HTTP::Delete
+        when "PATCH" then Net::HTTP::Patch
+        when "HEAD" then Net::HTTP::Head
+        else Net::HTTP::Get
+        end
+      end
+
+      def exists?
+        return false unless target
+
+        uri = URI.parse(api_url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == "https")
+
+        # Use HEAD request to check existence
+        request = Net::HTTP::Head.new(uri.path.empty? ? "/" : uri.path)
+
+        # Add headers if present in options
+        if options["headers"].is_a?(Hash)
+          options["headers"].each do |key, value|
+            # Process any environment variables in header values
+            processed_value = process_env_vars(value.to_s)
+            request[key] = processed_value
+          end
+        end
+
+        # Make the request
+        response = http.request(request)
+
+        # Consider 2xx and 3xx as success
+        response.code.to_i < 400
+      rescue StandardError => e
+        # Log the error but don't crash
+        Roast::Helpers::Logger.error("Error checking API existence: #{e.message}")
+        false
+      end
+
+      def contents
+        return unless target
+
+        # If it's a configuration, return a prepared request object
+        if config
+          JSON.pretty_generate({
+            "url" => api_url,
+            "method" => (options["method"] || "GET").upcase,
+            "headers" => options["headers"] || {},
+            "body" => options["body"],
+          })
+        else
+          # Assume it's a direct API URL, do a simple GET
+          begin
+            uri = URI.parse(target)
+            Net::HTTP.get(uri)
+          rescue StandardError => e
+            # Log the error but don't crash
+            Roast::Helpers::Logger.error("Error fetching API contents: #{e.message}")
+            nil
+          end
+        end
+      end
+
+      def name
+        if target
+          if config && config["url"]
+            "API #{config["url"]} (#{(options["method"] || "GET").upcase})"
+          else
+            "API #{target}"
+          end
+        else
+          "Unnamed API"
+        end
+      end
+
+      def type
+        :api
+      end
+
+      private
+
+      # Replace environment variables in the format ${VAR_NAME}
+      def process_env_vars(text)
+        text.gsub(/\${([^}]+)}/) do |_match|
+          var_name = ::Regexp.last_match(1).strip
+          ENV.fetch(var_name, "${#{var_name}}")
+        end
+      end
+    end
+  end
+end

data/lib/roast/resources/base_resource.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Roast
+  module Resources
+    # Base class for all resource types
+    # Follows the Strategy pattern to handle different resource types in a polymorphic way
+    class BaseResource
+      attr_reader :target
+
+      # Initialize a resource with a target
+      # @param target [String] The target specified in the workflow, can be nil
+      def initialize(target)
+        @target = target
+      end
+
+      # Process the resource to prepare it for use
+      # @return [String] The processed target
+      def process
+        target
+      end
+
+      # Check if the resource exists
+      # @return [Boolean] true if the resource exists
+      def exists?
+        false # Override in subclasses
+      end
+
+      # Get the contents of the resource
+      # @return [String] The contents of the resource
+      def contents
+        nil # Override in subclasses
+      end
+
+      # Get a name for the resource to display in logs
+      # @return [String] A descriptive name for the resource
+      def name
+        target || "Unnamed Resource"
+      end
+
+      # Get the type of this resource as a symbol
+      # @return [Symbol] The resource type
+      def type
+        :unknown
+      end
+    end
+  end
+end

data/lib/roast/resources/directory_resource.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Roast
+  module Resources
+    # Resource implementation for directories
+    class DirectoryResource < BaseResource
+      def process
+        if target.include?("*") || target.include?("?")
+          # If it's a glob pattern, return only directories
+          Dir.glob(target).select { |f| Dir.exist?(f) }.map { |d| File.expand_path(d) }.join("\n")
+        else
+          File.expand_path(target)
+        end
+      end
+
+      def exists?
+        Dir.exist?(target)
+      end
+
+      def contents
+        # Return a listing of files in the directory
+        if exists?
+          Dir.entries(target).reject { |f| f == "." || f == ".." }.join("\n")
+        end
+      end
+
+      def name
+        if target
+          File.basename(target) + "/"
+        else
+          "Unnamed Directory"
+        end
+      end
+
+      def type
+        :directory
+      end
+    end
+  end
+end

data/lib/roast/resources/file_resource.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Roast
+  module Resources
+    # Resource implementation for files
+    class FileResource < BaseResource
+      def process
+        # Handle glob patterns in the target
+        if target.include?("*") || target.include?("?")
+          Dir.glob(target).map { |f| File.expand_path(f) unless Dir.exist?(f) }.compact.join("\n")
+        else
+          File.expand_path(target)
+        end
+      end
+
+      def exists?
+        File.exist?(target) && !Dir.exist?(target)
+      end
+
+      def contents
+        File.read(target) if exists?
+      end
+
+      def name
+        File.basename(target) if target
+      end
+
+      def type
+        :file
+      end
+    end
+  end
+end

data/lib/roast/resources/none_resource.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Roast
+  module Resources
+    # Resource implementation for workflows with no target (targetless workflows)
+    class NoneResource < BaseResource
+      def process
+        nil
+      end
+
+      def exists?
+        # There's no target to check, so this is always true
+        true
+      end
+
+      def contents
+        nil
+      end
+
+      def name
+        "Targetless Resource"
+      end
+
+      def type
+        :none
+      end
+    end
+  end
+end

data/lib/roast/resources/url_resource.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+
+module Roast
+  module Resources
+    # Resource implementation for URLs
+    class UrlResource < BaseResource
+      def process
+        # URLs don't need special processing, just return as is
+        target
+      end
+
+      def exists?
+        return false unless target
+
+        begin
+          uri = URI.parse(target)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = (uri.scheme == "https")
+
+          # Just check the head to see if the resource exists
+          response = http.request_head(uri.path.empty? ? "/" : uri.path)
+
+          # Consider 2xx and 3xx as success
+          response.code.to_i < 400
+        rescue StandardError => e
+          # Log the error but don't crash
+          Roast::Helpers::Logger.error("Error checking URL existence: #{e.message}")
+          false
+        end
+      end
+
+      def contents
+        return unless target
+
+        begin
+          uri = URI.parse(target)
+          Net::HTTP.get(uri)
+        rescue StandardError => e
+          # Log the error but don't crash
+          Roast::Helpers::Logger.error("Error fetching URL contents: #{e.message}")
+          nil
+        end
+      end
+
+      def name
+        if target
+          URI.parse(target).host
+        else
+          "Unnamed URL"
+        end
+      rescue URI::InvalidURIError
+        "Invalid URL"
+      end
+
+      def type
+        :url
+      end
+    end
+  end
+end

data/lib/roast/resources.rb

@@ -0,0 +1,100 @@
+# 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 "uri"
+
+module Roast
+  # The Resources module contains classes for handling different types of resources
+  # that workflows can operate on. Each resource type implements a common interface.
+  module Resources
+    extend self
+
+    # Create the appropriate resource based on the target
+    # @param target [String] The target specified in the workflow
+    # @return [BaseResource] A resource object of the appropriate type
+    def for(target)
+      type = detect_type(target)
+
+      case type
+      when :file
+        FileResource.new(target)
+      when :directory
+        DirectoryResource.new(target)
+      when :url
+        UrlResource.new(target)
+      when :api
+        ApiResource.new(target)
+      when :command
+        CommandResource.new(target)
+      when :none
+        NoneResource.new(target)
+      else
+        BaseResource.new(target) # Default to base resource
+      end
+    end
+
+    # Determines the resource type from the target
+    # @param target [String] The target specified in the workflow
+    # @return [Symbol] :file, :directory, :url, :api, or :none
+    def detect_type(target)
+      return :none if target.nil? || target.strip.empty?
+
+      # Check for command syntax $(...)
+      if target.match?(/^\$\(.*\)$/)
+        return :command
+      end
+
+      # Check for URLs
+      if target.start_with?("http://", "https://", "ftp://")
+        return :url
+      end
+
+      # Try to parse as URI to detect other URL schemes
+      begin
+        uri = URI.parse(target)
+        return :url if uri.scheme && uri.host
+      rescue URI::InvalidURIError
+        # Not a URL, continue with other checks
+      end
+
+      # Check for directory
+      if Dir.exist?(target)
+        return :directory
+      end
+
+      # Check for glob patterns (containing * or ?)
+      if target.include?("*") || target.include?("?")
+        matches = Dir.glob(target)
+        return :none if matches.empty?
+        # If the glob matches only directories, treat as directory type
+        return :directory if matches.all? { |path| Dir.exist?(path) }
+
+        # Otherwise treat as file type (could be mixed or all files)
+        return :file
+      end
+
+      # Check for file
+      if File.exist?(target)
+        return :file
+      end
+
+      # Check for API configuration in Fetch API style format
+      begin
+        potential_config = JSON.parse(target)
+        if potential_config.is_a?(Hash) && potential_config.key?("url") && potential_config.key?("options")
+          return :api
+        end
+      rescue JSON::ParserError
+        # Not a JSON string, continue with other checks
+      end
+
+      # Default to file for anything else
+      :file
+    end
+  end
+end

data/lib/roast/tools/coding_agent.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "roast/helpers/logger"
+require "open3"
+require "tempfile"
+require "securerandom"
+
+module Roast
+  module Tools
+    module CodingAgent
+      extend self
+
+      class << self
+        def included(base)
+          base.class_eval do
+            function(
+              :coding_agent,
+              "AI-powered coding agent that runs Claude Code CLI with the given prompt",
+              prompt: { type: "string", description: "The prompt to send to Claude Code" },
+            ) do |params|
+              Roast::Tools::CodingAgent.call(params[:prompt])
+            end
+          end
+        end
+      end
+
+      def call(prompt)
+        Roast::Helpers::Logger.info("🤖 Running CodingAgent\n")
+        run_claude_code(prompt)
+      rescue StandardError => e
+        "Error running CodingAgent: #{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
+
+      private
+
+      def run_claude_code(prompt)
+        Roast::Helpers::Logger.debug("🤖 Executing Claude Code CLI with prompt: #{prompt}\n")
+
+        # Create a temporary file with a unique name
+        timestamp = Time.now.to_i
+        random_id = SecureRandom.hex(8)
+        pid = Process.pid
+        temp_file = Tempfile.new(["claude_prompt_#{timestamp}_#{pid}_#{random_id}", ".txt"])
+
+        begin
+          # Write the prompt to the file
+          temp_file.write(prompt)
+          temp_file.close
+
+          # Run Claude Code CLI using the temp file as input
+          claude_code_command = ENV.fetch("CLAUDE_CODE_COMMAND", "claude -p")
+          stdout, stderr, status = Open3.capture3("cat #{temp_file.path} | #{claude_code_command}")
+
+          if status.success?
+            stdout
+          else
+            "Error running ClaudeCode: #{stderr}"
+          end
+        ensure
+          # Always clean up the temp file
+          temp_file.unlink
+        end
+      end
+    end
+  end
+end

data/lib/roast/tools.rb

@@ -8,6 +8,7 @@ require "roast/tools/read_file"
 require "roast/tools/search_file"
 require "roast/tools/write_file"
 require "roast/tools/cmd"
+require "roast/tools/coding_agent"
 
 module Roast
   module Tools

data/lib/roast/version.rb

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