rubycode 0.1.3 → 0.1.4

data/lib/rubycode/tools/fetch.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "nokogiri"
+
+module RubyCode
+  module Tools
+    # Tool for fetching HTML content from URLs
+    class Fetch < Base
+      MAX_TEXT_SIZE = 50 * 1024 # 50KB limit for text extraction
+      REQUEST_TIMEOUT = 30
+
+      private
+
+      def perform(params)
+        url = params["url"]
+        extract_text = params["extract_text"] || false
+
+        validate_url!(url)
+
+        html = fetch_url(url)
+        output = extract_text ? extract_text_content(html) : html
+
+        build_tool_result(url, output, extract_text)
+      rescue URLError, HTTPError, NetworkError
+        raise # Re-raise specific errors without wrapping
+      rescue URI::InvalidURIError => e
+        raise URLError, "Invalid URL: #{e.message}"
+      rescue SocketError, Errno::ECONNREFUSED, Errno::ETIMEDOUT => e
+        raise NetworkError, "Network error: #{e.message}"
+      rescue StandardError => e
+        raise ToolError, "Fetch failed: #{e.message}"
+      end
+
+      def build_tool_result(url, output, extract_text)
+        ToolResult.new(
+          content: output,
+          metadata: {
+            url: url,
+            size_bytes: output.bytesize,
+            extract_text: extract_text
+          }
+        )
+      end
+
+      def validate_url!(url)
+        uri = URI.parse(url)
+        raise URLError, "URL must have http or https scheme" unless %w[http https].include?(uri.scheme)
+        raise URLError, "URL must have a hostname" if uri.hostname.nil? || uri.hostname.empty?
+      end
+
+      def fetch_url(url)
+        uri = URI.parse(url)
+        response = make_http_request(uri)
+        handle_response(response, uri, url)
+      rescue Net::OpenTimeout, Net::ReadTimeout => e
+        raise NetworkError, "Request timed out: #{e.message}"
+      rescue SocketError, Errno::ECONNREFUSED => e
+        raise NetworkError, "Connection failed: #{e.message}"
+      end
+
+      def make_http_request(uri)
+        Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https",
+                                            read_timeout: REQUEST_TIMEOUT, open_timeout: 10) do |http|
+          request = Net::HTTP::Get.new(uri)
+          request["User-Agent"] = "RubyCode/#{RubyCode::VERSION}"
+          http.request(request)
+        end
+      end
+
+      def handle_response(response, uri, url)
+        case response
+        when Net::HTTPSuccess
+          response.body.force_encoding("UTF-8")
+        when Net::HTTPRedirection
+          handle_redirect(response, uri, url)
+        else
+          raise HTTPError, "HTTP #{response.code}: #{response.message}"
+        end
+      end
+
+      def handle_redirect(response, uri, url)
+        location = response["location"]
+        raise HTTPError, "Redirect loop detected" if location == url
+
+        redirect_uri = build_redirect_uri(location, uri)
+        fetch_url(redirect_uri.to_s)
+      end
+
+      def build_redirect_uri(location, base_uri)
+        redirect_uri = URI.parse(location)
+        redirect_uri.absolute? ? redirect_uri : base_uri + location
+      end
+
+      def extract_text_content(html)
+        doc = Nokogiri::HTML(html)
+
+        # Remove unwanted elements
+        doc.css("script, style, nav, footer").each(&:remove)
+
+        # Extract text from body
+        body = doc.at_css("body")
+        return "" unless body
+
+        text = body.text
+                   .gsub(/\s+/, " ")           # Normalize whitespace
+                   .gsub(/\n\s*\n+/, "\n\n")   # Normalize newlines
+                   .strip
+
+        # Limit size
+        if text.bytesize > MAX_TEXT_SIZE
+          text = text[0...MAX_TEXT_SIZE] + "\n[Content truncated at #{MAX_TEXT_SIZE} bytes]"
+        end
+
+        text
+      end
+    end
+  end
+end

data/lib/rubycode/tools/web_search.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require_relative "../search_providers/multi_provider"
+require_relative "../search_providers/exa_ai"
+require_relative "../search_providers/duckduckgo_instant"
+require_relative "../search_providers/brave_search"
+
+module RubyCode
+  module Tools
+    # Tool for searching the web using multiple search providers
+    class WebSearch < Base
+      private
+
+      def perform(params)
+        query = params["query"]
+        max_results = params["max_results"] || 5
+
+        request_approval(query, max_results)
+        results = search_web(query, max_results)
+        format_results(results)
+      rescue StandardError => e
+        raise ToolError, "Search failed: #{e.message}"
+      end
+
+      def request_approval(query, max_results)
+        approval_handler = context[:approval_handler]
+        return if approval_handler.request_web_search_approval(query, max_results)
+
+        raise ToolError, I18n.t("rubycode.errors.user_cancelled_search")
+      end
+
+      def search_web(query, max_results)
+        results = fetch_and_parse_results(query, max_results)
+        verified_results = verify_results(results, max_results)
+        verified_results.first(max_results)
+      end
+
+      def fetch_and_parse_results(query, max_results)
+        @multi_provider = SearchProviders::MultiProvider.new
+        configure_search_providers
+        @multi_provider.search(query, max_results: max_results * 2) # Get more to filter
+      rescue StandardError => e
+        raise ToolError, "All search providers failed: #{e.message}"
+      end
+
+      def configure_search_providers
+        add_exa_provider
+        add_duckduckgo_provider
+        add_brave_provider
+      end
+
+      def add_exa_provider
+        exa_api_key = Models::ApiKey.get_key(adapter: :exa) || ENV.fetch("EXA_API_KEY", nil)
+        return unless exa_api_key && !exa_api_key.empty?
+
+        @multi_provider.add_provider(SearchProviders::ExaAi.new(api_key: exa_api_key))
+      end
+
+      def add_duckduckgo_provider
+        @multi_provider.add_provider(SearchProviders::DuckduckgoInstant.new)
+      end
+
+      def add_brave_provider
+        brave_api_key = ENV.fetch("BRAVE_API_KEY", nil)
+        return unless brave_api_key && !brave_api_key.empty?
+
+        @multi_provider.add_provider(SearchProviders::BraveSearch.new(api_key: brave_api_key))
+      end
+
+      def verify_results(results, max_results)
+        verified = []
+
+        # Verify more than needed to account for dead links
+        results.first(max_results * 2).each do |result|
+          verified << result if url_exists?(result[:url])
+          break if verified.size >= max_results
+        end
+
+        verified
+      end
+
+      def url_exists?(url)
+        return false if url.nil? || url.empty?
+
+        uri = URI.parse(url)
+
+        Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https",
+                                            read_timeout: 5, open_timeout: 5) do |http|
+          request = Net::HTTP::Head.new(uri.request_uri)
+          response = http.request(request)
+          response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPRedirection)
+        end
+      rescue StandardError
+        false # Consider URL dead if verification fails
+      end
+
+      def format_results(results)
+        return ToolResult.new(content: "No results found") if results.empty?
+
+        formatted = results.map.with_index(1) do |result, idx|
+          [
+            "#{idx}. #{result[:title]}",
+            "   URL: #{result[:url]}",
+            "   #{result[:snippet]}",
+            ""
+          ].join("\n")
+        end.join("\n")
+
+        ToolResult.new(
+          content: formatted.strip,
+          metadata: {
+            result_count: results.size,
+            results: results,
+            provider: @multi_provider&.last_used_provider || "Search"
+          }
+        )
+      end
+    end
+  end
+end

data/lib/rubycode/tools.rb

@@ -7,6 +7,8 @@ require_relative "tools/search"
 require_relative "tools/write"
 require_relative "tools/update"
 require_relative "tools/done"
+require_relative "tools/web_search"
+require_relative "tools/fetch"
 
 module RubyCode
   # Collection of available tools for the AI agent
@@ -18,7 +20,9 @@ module RubyCode
       Search,
       Write,
       Update,
-      Done
+      Done,
+      WebSearch,
+      Fetch
     ].freeze
 
     def self.definitions

data/lib/rubycode/value_objects.rb

@@ -3,22 +3,26 @@
 module RubyCode
   # Represents a conversation message
   class Message
-    attr_reader :role, :content, :timestamp
+    attr_reader :role, :content, :timestamp, :tool_calls
 
-    def initialize(role:, content:)
+    def initialize(role:, content:, tool_calls: nil)
       @role = role
       @content = content
+      @tool_calls = tool_calls
       @timestamp = Time.now
     end
 
     def to_h
-      { role: role, content: content }
+      hash = { role: role, content: content }
+      hash[:tool_calls] = tool_calls if tool_calls && !tool_calls.empty?
+      hash
     end
 
     def ==(other)
       other.is_a?(Message) &&
         role == other.role &&
-        content == other.content
+        content == other.content &&
+        tool_calls == other.tool_calls
     end
   end
 

data/lib/rubycode/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyCode
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

data/lib/rubycode/views/adapter/debug_delay.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RubyCode
+  module Views
+    module Adapter
+      # Displays rate limit delay debug information
+      class DebugDelay
+        def self.build(adapter_name:, delay:)
+          pastel = Pastel.new
+
+          [
+            "",
+            pastel.yellow("⏱️  Rate limit delay: #{delay}s (#{adapter_name})"),
+            ""
+          ].join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/rubycode/views/adapter/debug_request.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "pastel"
+require "json"
+
+module RubyCode
+  module Views
+    module Adapter
+      # Builds debug request text for adapter API calls
+      class DebugRequest
+        def self.build(adapter_name:, url:, model:, payload:)
+          pastel = Pastel.new
+          content = build_content_lines(pastel, adapter_name, url, model, payload)
+          content.join("\n")
+        end
+
+        def self.build_content_lines(pastel, adapter_name, url, model, payload)
+          [
+            "",
+            pastel.yellow.bold("=== DEBUG REQUEST ==="),
+            "#{pastel.bold("Adapter:")} #{adapter_name}",
+            "#{pastel.bold("URL:")} #{url}",
+            "#{pastel.bold("Model:")} #{model}",
+            "",
+            pastel.bold("Payload:"),
+            JSON.pretty_generate(payload),
+            pastel.yellow.bold("=" * 21)
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/rubycode/views/adapter/debug_response.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "pastel"
+require "json"
+
+module RubyCode
+  module Views
+    module Adapter
+      # Builds debug response text for adapter API responses
+      class DebugResponse
+        def self.build(adapter_name:, body:)
+          pastel = Pastel.new
+          content = build_content_lines(pastel, adapter_name, body)
+          content.join("\n")
+        end
+
+        def self.build_content_lines(pastel, adapter_name, body)
+          [
+            "",
+            pastel.green.bold("=== DEBUG RESPONSE ==="),
+            "#{pastel.bold("Adapter:")} #{adapter_name}",
+            "",
+            pastel.bold("Response:"),
+            JSON.pretty_generate(body),
+            pastel.green.bold("=" * 22)
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/rubycode/views/agent_loop/token_summary.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RubyCode
+  module Views
+    module AgentLoop
+      # Displays token usage and cost information
+      class TokenSummary
+        def self.build(tokens:, adapter:, model:, cumulative: nil)
+          pastel = Pastel.new
+          cost = Pricing.calculate_cost(adapter: adapter, model: model, tokens: tokens)
+
+          lines = build_token_lines(tokens, cost, pastel)
+          lines.concat(build_cumulative_lines(cumulative, adapter, model, pastel)) if cumulative
+
+          lines.join("\n")
+        end
+
+        def self.build_token_lines(tokens, cost, pastel)
+          lines = [""]
+          lines << build_tokens_line(tokens, pastel)
+          lines << build_thinking_line(tokens, pastel) if tokens.thinking&.positive?
+          lines << build_cached_line(tokens, pastel) if tokens.cached&.positive?
+          lines << build_cost_line(cost, pastel)
+          lines
+        end
+
+        def self.build_tokens_line(tokens, pastel)
+          "   #{pastel.dim("Tokens:")} " \
+            "#{pastel.cyan(tokens.input.to_s)} in / " \
+            "#{pastel.cyan(tokens.output.to_s)} out"
+        end
+
+        def self.build_thinking_line(tokens, pastel)
+          "   #{pastel.dim("Thinking:")} #{pastel.yellow(tokens.thinking.to_s)} tokens"
+        end
+
+        def self.build_cached_line(tokens, pastel)
+          "   #{pastel.dim("Cached:")} #{pastel.green(tokens.cached.to_s)} tokens (cost saved)"
+        end
+
+        def self.build_cost_line(cost, pastel)
+          "   #{pastel.dim("Cost:")} #{pastel.bold(Pricing.format_cost(cost))}"
+        end
+
+        def self.build_cumulative_lines(cumulative, adapter, model, pastel)
+          total_cost = Pricing.calculate_cost(adapter: adapter, model: model, tokens: cumulative)
+          ["   #{pastel.dim("Session total:")} " \
+           "#{pastel.cyan(cumulative.total.to_s)} tokens / " \
+           "#{pastel.bold(Pricing.format_cost(total_cost))}"]
+        end
+      end
+    end
+  end
+end

data/lib/rubycode/views/agent_loop.rb

@@ -6,3 +6,5 @@ require_relative "agent_loop/response_received"
 require_relative "agent_loop/iteration_header"
 require_relative "agent_loop/iteration_footer"
 require_relative "agent_loop/tool_error"
+require_relative "agent_loop/adapter_error"
+require_relative "agent_loop/retry_status"

data/lib/rubycode/views/cli/api_key_missing.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "tty-box"
+require "pastel"
+
+module RubyCode
+  module Views
+    module Cli
+      # Builds API key missing warning
+      class ApiKeyMissing
+        def self.build(adapter:)
+          Pastel.new
+          adapter_upper = adapter.to_s.upcase
+          adapter_info = I18n.t("rubycode.adapters.#{adapter}")
+
+          warning_box = TTY::Box.frame(
+            title: { top_left: " ⚠️  #{I18n.t("rubycode.setup.api_key_missing", adapter: adapter_upper)} " },
+            border: :thick,
+            padding: 1,
+            style: {
+              fg: :yellow,
+              border: {
+                fg: :yellow
+              }
+            }
+          ) do
+            I18n.t("rubycode.setup.api_key_help",
+                   url: adapter_info[:api_key_url],
+                   env_var: "#{adapter_upper}_API_KEY")
+          end
+
+          "\n#{warning_box}"
+        end
+      end
+    end
+  end
+end

data/lib/rubycode/views/cli/config_saved.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "pastel"
+
+module RubyCode
+  module Views
+    module Cli
+      # Builds configuration saved message
+      class ConfigSaved
+        def self.build(path: "~/.rubycode/config.yml")
+          pastel = Pastel.new
+          "\n#{pastel.green("✓")} #{I18n.t("rubycode.setup.config_saved", path: path)}\n"
+        end
+      end
+    end
+  end
+end

data/lib/rubycode/views/cli/configuration_table.rb

@@ -8,15 +8,15 @@ module RubyCode
     module Cli
       # Builds configuration table display
       class ConfigurationTable
-        def self.build(directory:, model:, debug_mode:)
+        def self.build(directory:, model:, adapter: :ollama)
           pastel = Pastel.new
 
           table = TTY::Table.new(
             header: [pastel.bold("Setting"), pastel.bold("Value")],
             rows: [
-              ["Directory", directory],
+              ["Adapter", adapter.to_s.capitalize],
               ["Model", model],
-              ["Debug Mode", debug_mode ? pastel.green("ON") : pastel.dim("OFF")]
+              ["Directory", directory]
             ]
           )
 

data/lib/rubycode/views/cli/first_time_setup.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "pastel"
+
+module RubyCode
+  module Views
+    module Cli
+      # Builds first time setup message
+      class FirstTimeSetup
+        def self.build
+          pastel = Pastel.new
+          "\n#{pastel.green(I18n.t("rubycode.setup.first_time"))}\n"
+        end
+      end
+    end
+  end
+end

data/lib/rubycode/views/cli/restart_message.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "pastel"
+
+module RubyCode
+  module Views
+    module Cli
+      # Builds restart message
+      class RestartMessage
+        def self.build
+          pastel = Pastel.new
+          "\n#{pastel.yellow(I18n.t("rubycode.setup.restart_message"))}\n"
+        end
+      end
+    end
+  end
+end

data/lib/rubycode/views/cli/setup_title.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "pastel"
+
+module RubyCode
+  module Views
+    module Cli
+      # Builds setup wizard title
+      class SetupTitle
+        def self.build
+          pastel = Pastel.new
+          "\n#{pastel.bold(I18n.t("rubycode.setup.title"))}\n\n"
+        end
+      end
+    end
+  end
+end

data/lib/rubycode/views/cli.rb

@@ -9,3 +9,8 @@ require_relative "cli/memory_cleared_message"
 require_relative "cli/response_box"
 require_relative "cli/interrupt_message"
 require_relative "cli/error_display"
+require_relative "cli/setup_title"
+require_relative "cli/first_time_setup"
+require_relative "cli/api_key_missing"
+require_relative "cli/config_saved"
+require_relative "cli/restart_message"

data/lib/rubycode/views/formatter/fetch_summary.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "pastel"
+
+module RubyCode
+  module Views
+    module Formatter
+      # Builds fetch result summary display
+      class FetchSummary
+        def self.build(result:)
+          pastel = Pastel.new
+          metadata = result.metadata || {}
+          content = result.content || ""
+
+          lines = build_header_lines(pastel, metadata, content)
+          lines.concat(build_preview_lines(pastel, content))
+          lines << ""
+
+          lines.join("\n")
+        end
+
+        def self.build_header_lines(pastel, metadata, content)
+          url = metadata[:url] || "Unknown URL"
+          size_kb = (content.bytesize / 1024.0).round(1)
+          size_bytes = content.bytesize
+
+          [
+            "",
+            "   #{pastel.cyan("📥")} Fetched from: #{pastel.bold(url)}",
+            "   #{pastel.dim("Status:")} Success",
+            "   #{pastel.dim("Size:")} #{size_kb} KB (#{size_bytes} bytes)"
+          ]
+        end
+
+        def self.build_preview_lines(pastel, content)
+          first_line = content.lines.first&.strip || ""
+          return [] unless first_line.length.positive?
+
+          [
+            "",
+            pastel.dim("   Preview:"),
+            pastel.dim("   #{truncate(first_line, 100)}")
+          ]
+        end
+
+        def self.truncate(text, max_length)
+          return text if text.length <= max_length
+
+          "#{text[0...(max_length - 3)]}..."
+        end
+      end
+    end
+  end
+end