rubycode 0.1.3 → 0.1.4

data/lib/rubycode/search_providers/brave_search.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+require_relative "base"
+
+module RubyCode
+  module SearchProviders
+    # Brave Search API provider
+    # https://brave.com/search/api/
+    class BraveSearch < Base
+      API_ENDPOINT = "https://api.search.brave.com/res/v1/web/search"
+
+      def initialize(api_key: nil, config: nil)
+        super(config: config, api_key: api_key)
+      end
+
+      private
+
+      def provider_name
+        "BraveSearch"
+      end
+
+      def requires_api_key?
+        true
+      end
+
+      def build_request(query, max_results)
+        uri = URI(API_ENDPOINT).tap do |u|
+          u.query = URI.encode_www_form(
+            q: query,
+            count: max_results
+          )
+        end
+
+        request = Net::HTTP::Get.new(uri)
+        request["Accept"] = "application/json"
+        request["X-Subscription-Token"] = api_key
+
+        { uri: uri, request: request }
+      end
+
+      def parse_results(json_body, _max_results)
+        data = JSON.parse(json_body)
+        results = data.dig("web", "results") || []
+
+        results.map do |result|
+          {
+            title: result["title"],
+            url: result["url"],
+            snippet: result["description"] || ""
+          }
+        end
+      rescue JSON::ParserError => e
+        raise SearchProviderError, "Failed to parse Brave Search response: #{e.message}"
+      end
+    end
+  end
+end

data/lib/rubycode/search_providers/concerns/debugging.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RubyCode
+  module SearchProviders
+    module Concerns
+      # Debug output for search providers
+      module Debugging
+        private
+
+        def debug_search_request(query, max_results, uri_or_request)
+          url = if uri_or_request.is_a?(URI)
+                  uri_or_request.to_s
+                elsif uri_or_request.is_a?(Hash)
+                  uri_or_request[:uri].to_s
+                else
+                  "Unknown"
+                end
+
+          puts Views::SearchProvider::DebugRequest.build(
+            provider_name: provider_name,
+            query: query,
+            max_results: max_results,
+            url: url
+          )
+        end
+
+        def debug_search_response(response)
+          puts Views::SearchProvider::DebugResponse.build(
+            provider_name: provider_name,
+            status_code: response.code,
+            body_preview: response.body[0...500] # First 500 chars
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubycode/search_providers/concerns/error_handling.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RubyCode
+  module SearchProviders
+    module Concerns
+      # Error handling for search providers
+      module ErrorHandling
+        private
+
+        def handle_network_error(error, uri)
+          error_key = network_error_key(error)
+          error_params = build_network_error_params(error, uri)
+          raise SearchProviderError, I18n.t("rubycode.errors.search_provider.#{error_key}", error_params)
+        end
+
+        def network_error_key(error)
+          case error
+          when Net::ReadTimeout then :read_timeout
+          when Net::OpenTimeout then :open_timeout
+          when Errno::ECONNREFUSED then :connection_refused
+          when Errno::ETIMEDOUT then :connection_timeout
+          when SocketError then :host_unreachable
+          end
+        end
+
+        def build_network_error_params(error, uri)
+          base_params = { provider: provider_name, error: error.message }
+          case error
+          when Net::ReadTimeout
+            base_params.merge(timeout: http_read_timeout)
+          when Net::OpenTimeout
+            base_params.merge(timeout: http_open_timeout)
+          when Errno::ECONNREFUSED, Errno::ETIMEDOUT
+            base_params.merge(uri: uri)
+          when SocketError
+            base_params.merge(hostname: uri.hostname)
+          else
+            base_params
+          end
+        end
+
+        def handle_http_error(response)
+          code = response.code.to_i
+          return response if code.between?(200, 299)
+
+          error_key = http_error_key(code)
+          raise SearchProviderError,
+                I18n.t("rubycode.errors.search_provider.#{error_key}",
+                       code: response.code,
+                       provider: provider_name)
+        end
+
+        def http_error_key(code)
+          case code
+          when 401, 403 then :auth_failed
+          when 429 then :rate_limited
+          when 500..599 then :server_error
+          else :http_error
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubycode/search_providers/concerns/http_client.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "net/http"
+
+module RubyCode
+  module SearchProviders
+    module Concerns
+      # HTTP client for search providers
+      module HttpClient
+        private
+
+        def make_http_request(uri_or_request)
+          if uri_or_request.is_a?(URI)
+            make_http_request_from_uri(uri_or_request)
+          elsif uri_or_request.is_a?(Hash) && uri_or_request[:uri] && uri_or_request[:request]
+            make_http_request_with_custom_request(uri_or_request[:uri], uri_or_request[:request])
+          else
+            raise ArgumentError, "Expected URI or {uri:, request:} hash"
+          end
+        end
+
+        def make_http_request_from_uri(uri)
+          Net::HTTP.start(
+            uri.host,
+            uri.port,
+            use_ssl: uri.scheme == "https",
+            read_timeout: http_read_timeout,
+            open_timeout: http_open_timeout
+          ) do |http|
+            request = Net::HTTP::Get.new(uri)
+            request["Accept"] = "application/json"
+            request["User-Agent"] = "RubyCode/#{RubyCode::VERSION}"
+            http.request(request)
+          end
+        rescue Net::ReadTimeout, Net::OpenTimeout, Errno::ECONNREFUSED, Errno::ETIMEDOUT, SocketError => e
+          handle_network_error(e, uri)
+        rescue StandardError => e
+          raise SearchProviderError, "HTTP request failed: #{e.message}"
+        end
+
+        def make_http_request_with_custom_request(uri, request)
+          Net::HTTP.start(
+            uri.host,
+            uri.port,
+            use_ssl: uri.scheme == "https",
+            read_timeout: http_read_timeout,
+            open_timeout: http_open_timeout
+          ) do |http|
+            http.request(request)
+          end
+        rescue Net::ReadTimeout, Net::OpenTimeout, Errno::ECONNREFUSED, Errno::ETIMEDOUT, SocketError => e
+          handle_network_error(e, uri)
+        rescue StandardError => e
+          raise SearchProviderError, "HTTP request failed: #{e.message}"
+        end
+
+        def http_read_timeout
+          @config&.http_read_timeout || 10
+        end
+
+        def http_open_timeout
+          @config&.http_open_timeout || 10
+        end
+      end
+    end
+  end
+end

data/lib/rubycode/search_providers/duckduckgo_instant.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+require_relative "base"
+
+module RubyCode
+  module SearchProviders
+    # DuckDuckGo Instant Answer API provider (FREE)
+    # https://duckduckgo.com/api
+    # Note: Returns instant answers/summaries, not full web search results
+    class DuckduckgoInstant < Base
+      API_ENDPOINT = "https://api.duckduckgo.com/"
+
+      def initialize(config: nil)
+        super(config: config, api_key: nil)
+      end
+
+      private
+
+      def provider_name
+        "DuckDuckGo"
+      end
+
+      def build_request(query, _max_results)
+        URI(API_ENDPOINT).tap do |uri|
+          uri.query = URI.encode_www_form(
+            q: query,
+            format: "json",
+            no_html: 1,
+            skip_disambig: 1
+          )
+        end
+      end
+
+      def parse_results(json_body, max_results)
+        data = JSON.parse(json_body)
+        results = []
+
+        add_abstract_result(results, data)
+        add_related_topics(results, data, max_results)
+        add_other_results(results, data, max_results) if results.empty?
+
+        results
+      rescue JSON::ParserError => e
+        raise SearchProviderError, "Failed to parse DuckDuckGo response: #{e.message}"
+      end
+
+      def add_abstract_result(results, data)
+        return unless data["Abstract"] && !data["Abstract"].empty?
+
+        results << {
+          title: data["Heading"] || "Summary",
+          url: data["AbstractURL"] || "",
+          snippet: data["Abstract"]
+        }
+      end
+
+      def add_related_topics(results, data, max_results)
+        related = data["RelatedTopics"] || []
+        related.first(max_results - results.length).each do |topic|
+          next if skip_topic?(topic)
+
+          results << build_topic_result(topic)
+        end
+      end
+
+      def skip_topic?(topic)
+        topic["Topics"] # Skip categories
+      end
+
+      def build_topic_result(topic)
+        {
+          title: extract_topic_title(topic),
+          url: topic["FirstURL"] || "",
+          snippet: topic["Text"] || ""
+        }
+      end
+
+      def extract_topic_title(topic)
+        topic["Text"]&.split(" - ")&.first || "Related"
+      end
+
+      def add_other_results(results, data, max_results)
+        return unless data["Results"]
+
+        data["Results"].first(max_results).each do |result|
+          results << {
+            title: result["Text"] || "Result",
+            url: result["FirstURL"] || "",
+            snippet: result["Text"] || ""
+          }
+        end
+      end
+    end
+  end
+end

data/lib/rubycode/search_providers/exa_ai.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+require_relative "base"
+
+module RubyCode
+  module SearchProviders
+    # Exa.ai search provider - AI-native search engine optimized for LLMs
+    # https://exa.ai
+    # Uses MCP (Model Context Protocol) endpoint
+    class ExaAi < Base
+      MCP_ENDPOINT = "https://mcp.exa.ai/mcp"
+      TIMEOUT = 25 # seconds
+
+      def initialize(api_key: nil, config: nil)
+        super(config: config, api_key: api_key || ENV.fetch("EXA_API_KEY", nil))
+      end
+
+      private
+
+      def provider_name
+        "Exa.ai"
+      end
+
+      def requires_api_key?
+        true
+      end
+
+      def build_request(query, max_results)
+        uri = URI(MCP_ENDPOINT)
+        request = Net::HTTP::Post.new(uri)
+        request["Content-Type"] = "application/json"
+        request["Accept"] = "application/json, text/event-stream"
+        request["User-Agent"] = "RubyCode/#{RubyCode::VERSION}"
+
+        request.body = build_mcp_payload(query, max_results).to_json
+
+        { uri: uri, request: request }
+      end
+
+      def build_mcp_payload(query, max_results)
+        {
+          jsonrpc: "2.0",
+          id: 1,
+          method: "tools/call",
+          params: {
+            name: "web_search_exa",
+            arguments: {
+              query: query,
+              type: "auto",
+              numResults: max_results,
+              livecrawl: "fallback",
+              contextMaxCharacters: 10_000
+            }
+          }
+        }
+      end
+
+      def parse_results(body, _max_results)
+        results = []
+
+        # Parse SSE (Server-Sent Events) response
+        body.split("\n").each do |line|
+          next unless line.start_with?("data: ")
+
+          process_sse_line(line, results)
+        end
+
+        results
+      rescue JSON::ParserError => e
+        raise SearchProviderError, "Failed to parse Exa.ai response: #{e.message}"
+      end
+
+      def process_sse_line(line, results)
+        data = JSON.parse(line[6..]) # Skip "data: " prefix
+        return unless data["result"]&.dig("content")
+
+        data["result"]["content"].each do |item|
+          next unless item["type"] == "text"
+
+          results.concat(parse_markdown_results(item["text"]))
+        end
+      end
+
+      def parse_markdown_results(text)
+        results = []
+        current_result = {}
+        collecting_text = false
+
+        text.split("\n").each do |line|
+          line = line.strip
+          next if line.empty?
+
+          result = process_markdown_line(line, current_result, results, collecting_text)
+          collecting_text = result[:collecting]
+        end
+
+        finalize_result(current_result, results)
+        cleanup_snippets(results)
+
+        results
+      end
+
+      def process_markdown_line(line, current_result, results, collecting_text)
+        return handle_title_line(line, current_result, results) if line.start_with?("Title:")
+        return handle_url_line(line, current_result, collecting_text) if line.start_with?("URL:")
+        return handle_text_line(line, current_result) if line.start_with?("Text:")
+
+        handle_content_line(line, current_result, collecting_text)
+      end
+
+      def handle_title_line(line, current_result, results)
+        save_current_result(current_result, results)
+        start_new_result(line, current_result)
+        { collecting: false }
+      end
+
+      def handle_url_line(line, current_result, collecting_text)
+        current_result[:url] = line.sub("URL:", "").strip if current_result[:title]
+        { collecting: collecting_text }
+      end
+
+      def handle_text_line(line, current_result)
+        current_result[:snippet] = line.sub("Text:", "").strip if current_result[:title]
+        { collecting: true }
+      end
+
+      def handle_content_line(line, current_result, collecting_text)
+        return { collecting: collecting_text } unless collecting_text && current_result[:title]
+
+        append_text_if_valid(line, current_result)
+        { collecting: collecting_text }
+      end
+
+      def save_current_result(current_result, results)
+        return unless current_result[:title] && current_result[:url] && !current_result[:url].empty?
+
+        results << current_result
+      end
+
+      def start_new_result(line, current_result)
+        current_result.replace(
+          title: line.sub("Title:", "").strip,
+          url: "",
+          snippet: ""
+        )
+      end
+
+      def append_text_if_valid(line, current_result)
+        return if current_result[:snippet].length >= 500
+
+        break_keywords = ["Title:", "Author:", "Published Date:", "URL:"]
+        return if break_keywords.any? { |kw| line.start_with?(kw) }
+
+        current_result[:snippet] = "#{current_result[:snippet]} #{line}"
+      end
+
+      def finalize_result(current_result, results)
+        save_current_result(current_result, results)
+      end
+
+      def cleanup_snippets(results)
+        results.each do |result|
+          result[:snippet] = result[:snippet].strip[0..300] # Limit to 300 chars
+        end
+      end
+    end
+  end
+end

data/lib/rubycode/search_providers/multi_provider.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RubyCode
+  module SearchProviders
+    # Multi-provider search with automatic fallback
+    class MultiProvider
+      attr_reader :last_used_provider
+
+      def initialize(providers: [])
+        @providers = providers
+        @last_used_provider = nil
+      end
+
+      def search(query, max_results: 5)
+        last_error = nil
+
+        @providers.each do |provider|
+          results = provider.search(query, max_results: max_results)
+          if results && !results.empty?
+            @last_used_provider = provider.class.name.split("::").last
+            return results
+          end
+        rescue StandardError => e
+          last_error = e
+          # Continue to next provider
+        end
+
+        # If all providers failed, raise the last error
+        raise last_error if last_error
+
+        # If no error but no results, return empty array
+        @last_used_provider = nil
+        []
+      end
+
+      # Add a provider to the list
+      def add_provider(provider)
+        @providers << provider
+      end
+
+      # Get list of available providers
+      def provider_names
+        @providers.map { |p| p.class.name.split("::").last }
+      end
+    end
+  end
+end

data/lib/rubycode/token_counter.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RubyCode
+  # Tracks token usage across LLM requests
+  class TokenCounter
+    attr_reader :input, :output, :cached, :cache_creation, :thinking
+
+    def initialize(input: 0, output: 0, cached: 0, cache_creation: 0, thinking: 0)
+      @input = input || 0
+      @output = output || 0
+      @cached = cached || 0
+      @cache_creation = cache_creation || 0
+      @thinking = thinking || 0
+    end
+
+    def total
+      input + output + thinking
+    end
+
+    def to_h
+      {
+        input_tokens: input,
+        output_tokens: output,
+        cached_tokens: cached,
+        cache_creation_tokens: cache_creation,
+        thinking_tokens: thinking,
+        total_tokens: total
+      }.compact
+    end
+
+    def +(other)
+      TokenCounter.new(
+        input: input + other.input,
+        output: output + other.output,
+        cached: cached + other.cached,
+        cache_creation: cache_creation + other.cache_creation,
+        thinking: thinking + other.thinking
+      )
+    end
+  end
+end

data/lib/rubycode/tools/bash.rb

@@ -44,19 +44,49 @@ module RubyCode
 
       def execute_command(command)
         Dir.chdir(root_path) do
-          output = `#{command} 2>&1`
-          exit_code = $CHILD_STATUS.exitstatus
+          require "open3"
 
-          raise CommandExecutionError, "Command failed with exit code #{exit_code}:\n#{output}" unless exit_code.zero?
+          output, exit_code = run_command_with_streaming(command)
+          raise CommandExecutionError, build_error_message(exit_code, output) unless exit_code.zero?
 
-          CommandResult.new(
-            stdout: truncate_output(output),
-            stderr: "",
-            exit_code: exit_code
-          )
+          build_command_result(output, exit_code)
         end
       end
 
+      def run_command_with_streaming(command)
+        output_lines = []
+        exit_code = 0
+
+        Open3.popen2e(command) do |stdin, stdout_err, wait_thr|
+          stdin.close # Close stdin to prevent interactive prompts
+          output_lines = stream_output(stdout_err)
+          exit_code = wait_thr.value.exitstatus
+        end
+
+        [output_lines.join, exit_code]
+      end
+
+      def stream_output(stdout_err)
+        output_lines = []
+        stdout_err.each_line do |line|
+          print line # Show output in real-time
+          output_lines << line
+        end
+        output_lines
+      end
+
+      def build_error_message(exit_code, output)
+        "Command failed with exit code #{exit_code}:\n#{output}"
+      end
+
+      def build_command_result(output, exit_code)
+        CommandResult.new(
+          stdout: truncate_output(output),
+          stderr: "",
+          exit_code: exit_code
+        )
+      end
+
       def truncate_output(output)
         lines = output.split("\n")
         return output if lines.length <= 200