rubycode 0.1.3 → 0.1.4

data/lib/rubycode/adapters/base.rb

@@ -1,15 +1,105 @@
 # frozen_string_literal: true
 
+require_relative "concerns/error_handling"
+require_relative "concerns/http_client"
+
 module RubyCode
   module Adapters
     # Base adapter class for LLM integrations
     class Base
+      include Concerns::ErrorHandling
+      include Concerns::HttpClient
+
+      attr_reader :last_request_time, :current_request_tokens, :total_tokens_counter
+
       def initialize(config)
         @config = config
+        @last_request_time = nil
+        @current_request_tokens = nil
+        @total_tokens_counter = TokenCounter.new
+      end
+
+      def generate(messages:, system: nil, tools: nil)
+        enforce_rate_limit_delay
+
+        uri = build_uri
+        payload = build_payload(messages, system, tools)
+        request = build_request(uri, payload)
+
+        body = send_request_with_retry(uri, request)
+
+        @last_request_time = Time.now
+
+        # Extract and track tokens
+        @current_request_tokens = extract_tokens(body)
+        @total_tokens_counter += @current_request_tokens
+
+        convert_response(body)
+      end
+
+      private
+
+      # Abstract methods to be implemented by subclasses
+      def adapter_name
+        raise NotImplementedError, "Subclass must define adapter_name"
+      end
+
+      def build_payload(_messages, _system, _tools)
+        raise NotImplementedError, "Subclass must define build_payload"
+      end
+
+      def build_request(_uri, _payload)
+        raise NotImplementedError, "Subclass must define build_request"
+      end
+
+      def convert_response(_raw_response)
+        raise NotImplementedError, "Subclass must define convert_response"
+      end
+
+      def api_endpoint
+        raise NotImplementedError, "Subclass must define api_endpoint"
+      end
+
+      def extract_tokens(_response_body)
+        raise NotImplementedError, "Subclass must implement extract_tokens"
+      end
+
+      # Rate limiting enforcement
+      def enforce_rate_limit_delay
+        return unless @last_request_time
+
+        elapsed = Time.now - @last_request_time
+        min_delay = @config.adapter_request_delay || 1.5
+
+        return unless elapsed < min_delay
+
+        sleep_time = min_delay - elapsed
+        sleep(sleep_time)
+      end
+
+      # Concrete shared methods
+      def api_key
+        # Check database first
+        db_key = Models::ApiKey.get_key(adapter: adapter_symbol)
+        return db_key if db_key
+
+        # Fall back to environment variable
+        ENV.fetch("#{adapter_name.upcase}_API_KEY", nil)
+      end
+
+      def adapter_symbol
+        # Convert class name to symbol: Openai -> :openai
+        self.class.name.split("::").last.downcase.to_sym
+      end
+
+      def validate_api_key!
+        return if api_key
+
+        raise AdapterError, I18n.t("rubycode.errors.#{adapter_symbol}.api_key_missing")
       end
 
-      def generate(prompt:)
-        raise NotImplementedError
+      def build_uri
+        URI(api_endpoint)
       end
     end
   end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RubyCode
+  module Adapters
+    module Concerns
+      # Debug output for adapter requests and responses
+      module Debugging
+        private
+
+        def debug_request(uri, payload)
+          puts Views::Adapter::DebugRequest.build(
+            adapter_name: adapter_name,
+            url: sanitize_url(uri),
+            model: @config.model,
+            payload: payload
+          )
+        end
+
+        def debug_response(body)
+          puts Views::Adapter::DebugResponse.build(
+            adapter_name: adapter_name,
+            body: body
+          )
+        end
+
+        def sanitize_url(uri)
+          uri.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RubyCode
+  module Adapters
+    module Concerns
+      # Error handling for adapter HTTP responses
+      module ErrorHandling
+        private
+
+        def handle_network_error(error, uri)
+          case error
+          when Net::ReadTimeout
+            raise_timeout_error(:read_timeout, @config.http_read_timeout, error)
+          when Net::OpenTimeout
+            raise_timeout_error(:open_timeout, @config.http_open_timeout, error)
+          when Errno::ECONNREFUSED
+            raise_connection_error(:connection_refused, uri, error)
+          when Errno::ETIMEDOUT
+            raise_connection_error(:connection_timeout, uri, error)
+          when SocketError
+            raise AdapterConnectionError,
+                  I18n.t("rubycode.errors.adapter.host_unreachable",
+                         hostname: uri.hostname,
+                         error: error.message)
+          end
+        end
+
+        def raise_timeout_error(key, timeout, error)
+          raise AdapterTimeoutError,
+                I18n.t("rubycode.errors.adapter.#{key}",
+                       timeout: timeout,
+                       error: error.message)
+        end
+
+        def raise_connection_error(key, uri, error)
+          raise AdapterConnectionError,
+                I18n.t("rubycode.errors.adapter.#{key}",
+                       uri: uri,
+                       error: error.message)
+        end
+
+        def handle_response(response)
+          body = JSON.parse(response.body)
+
+          case response.code.to_i
+          when 200..299
+            body
+          when 401, 403
+            raise_auth_error(response.code)
+          when 429
+            raise_rate_limit_error(response)
+          when 500..599
+            raise_server_error(response)
+          else
+            raise_http_error(response)
+          end
+        end
+
+        def raise_auth_error(code)
+          raise AdapterError,
+                I18n.t("rubycode.errors.adapter.auth_failed",
+                       code: code,
+                       adapter_name: adapter_name.upcase)
+        end
+
+        def raise_rate_limit_error(response)
+          raise AdapterConnectionError,
+                I18n.t("rubycode.errors.adapter.rate_limited",
+                       code: response.code,
+                       message: response.message)
+        end
+
+        def raise_server_error(response)
+          raise AdapterConnectionError,
+                I18n.t("rubycode.errors.adapter.server_error",
+                       code: response.code,
+                       message: response.message)
+        end
+
+        def raise_http_error(response)
+          raise AdapterError,
+                I18n.t("rubycode.errors.adapter.http_error",
+                       code: response.code,
+                       message: response.message)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RubyCode
+  module Adapters
+    module Concerns
+      # HTTP client with retry logic for adapters
+      module HttpClient
+        private
+
+        def send_request_with_retry(uri, request)
+          attempt = 0
+
+          begin
+            attempt += 1
+            send_request(uri, request)
+          rescue AdapterTimeoutError, AdapterConnectionError => e
+            unless attempt <= @config.max_retries
+              raise AdapterRetryExhaustedError,
+                    I18n.t("rubycode.errors.adapter.retry_failed",
+                           max_retries: @config.max_retries,
+                           error: e.message)
+            end
+
+            delay = @config.retry_base_delay * (2**(attempt - 1))
+            display_retry_status(attempt, @config.max_retries, delay, e)
+            sleep(delay)
+            retry
+          end
+        end
+
+        def display_retry_status(attempt, max_retries, delay, error)
+          puts Views::AgentLoop::RetryStatus.build(
+            attempt: attempt,
+            max_retries: max_retries,
+            delay: delay,
+            error: error.message
+          )
+        end
+
+        def send_request(uri, request)
+          response = perform_http_request(uri, request)
+          handle_response(response)
+        rescue Net::ReadTimeout, Net::OpenTimeout, Errno::ECONNREFUSED, Errno::ETIMEDOUT, SocketError => e
+          handle_network_error(e, uri)
+        rescue JSON::ParserError => e
+          raise AdapterError, I18n.t("rubycode.errors.adapter.invalid_json", error: e.message)
+        rescue StandardError => e
+          raise AdapterError, I18n.t("rubycode.errors.adapter.unexpected_error", error: e.message)
+        end
+
+        def perform_http_request(uri, request)
+          Net::HTTP.start(
+            uri.hostname,
+            uri.port,
+            use_ssl: use_ssl?(uri),
+            read_timeout: @config.http_read_timeout,
+            open_timeout: @config.http_open_timeout
+          ) { |http| http.request(request) }
+        end
+
+        def use_ssl?(uri)
+          uri.scheme == "https"
+        end
+      end
+    end
+  end
+end

data/lib/rubycode/adapters/deepseek.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+
+module RubyCode
+  module Adapters
+    # DeepSeek adapter for cloud LLM integration (OpenAI-compatible API)
+    # DeepSeek provides powerful reasoning models with competitive pricing
+    class Deepseek < Base
+      API_ENDPOINT = "https://api.deepseek.com/v1/chat/completions"
+
+      def initialize(config)
+        super
+        validate_api_key!
+      end
+
+      private
+
+      def adapter_name
+        "DeepSeek"
+      end
+
+      def api_endpoint
+        API_ENDPOINT
+      end
+
+      def build_payload(messages, system, tools)
+        # OpenAI-compatible format: system message goes in messages array
+        formatted_messages = messages.dup
+
+        formatted_messages.unshift({ role: "system", content: system }) if system
+
+        payload = {
+          model: @config.model,
+          messages: formatted_messages,
+          temperature: 0.7
+        }
+
+        # DeepSeek supports function calling format
+        payload[:tools] = tools if tools
+
+        payload
+      end
+
+      def build_request(uri, payload)
+        request = Net::HTTP::Post.new(uri)
+        request["Content-Type"] = "application/json"
+        request["Authorization"] = "Bearer #{api_key}"
+        request.body = payload.to_json
+        request
+      end
+
+      def convert_response(deepseek_response)
+        # DeepSeek uses OpenAI-compatible format
+        # Format: { choices: [{ message: { role, content, tool_calls } }] }
+        # Our format: { "message" => { "content" => ..., "tool_calls" => [...] } }
+
+        choice = deepseek_response["choices"]&.first
+        raise AdapterError, I18n.t("rubycode.errors.adapter.no_choices") unless choice
+
+        message = choice["message"]
+        raise AdapterError, I18n.t("rubycode.errors.adapter.no_message") unless message
+
+        {
+          "message" => {
+            "content" => message["content"] || "",
+            "tool_calls" => format_tool_calls(message["tool_calls"])
+          }
+        }
+      end
+
+      def format_tool_calls(tool_calls)
+        return [] unless tool_calls
+
+        tool_calls.map do |tool_call|
+          {
+            "function" => {
+              "name" => tool_call.dig("function", "name"),
+              "arguments" => tool_call.dig("function", "arguments")
+            }
+          }
+        end
+      end
+
+      def extract_tokens(response_body)
+        usage = response_body["usage"] || {}
+
+        TokenCounter.new(
+          input: usage["prompt_tokens"],
+          output: usage["completion_tokens"],
+          thinking: usage["reasoning_tokens"] # DeepSeek specific
+        )
+      end
+    end
+  end
+end

data/lib/rubycode/adapters/gemini.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+
+module RubyCode
+  module Adapters
+    # Google Gemini adapter for cloud LLM integration
+    # Gemini provides powerful multimodal models with long context windows
+    class Gemini < Base
+      API_ENDPOINT = "https://generativelanguage.googleapis.com/v1beta/models"
+
+      def initialize(config)
+        super
+        validate_api_key!
+      end
+
+      private
+
+      def adapter_name
+        "Gemini"
+      end
+
+      def api_endpoint
+        # Gemini embeds API key in URL
+        "https://generativelanguage.googleapis.com/v1beta/models/#{@config.model}:generateContent?key=#{api_key}"
+      end
+
+      def build_payload(messages, system, tools)
+        # Convert to Gemini format
+        contents = messages.map do |msg|
+          {
+            role: msg[:role] == "assistant" ? "model" : "user",
+            parts: [{ text: msg[:content] }]
+          }
+        end
+
+        payload = { contents: contents }
+
+        # Add system instruction if provided
+        payload[:systemInstruction] = { parts: [{ text: system }] } if system
+
+        # Add tools if provided
+        payload[:tools] = convert_tools_to_gemini_format(tools) if tools
+
+        payload
+      end
+
+      def convert_tools_to_gemini_format(tools)
+        return nil unless tools
+
+        [{
+          functionDeclarations: tools.map do |tool|
+            {
+              name: tool.dig(:function, :name),
+              description: tool.dig(:function, :description),
+              parameters: tool.dig(:function, :parameters)
+            }
+          end
+        }]
+      end
+
+      def build_request(uri, payload)
+        request = Net::HTTP::Post.new(uri)
+        request["Content-Type"] = "application/json"
+        request.body = payload.to_json
+        request
+      end
+
+      def convert_response(gemini_response)
+        # Gemini format: { candidates: [{ content: { parts: [...], role: "model" }, finishReason: "STOP" }] }
+        # Our format: { "message" => { "content" => ..., "tool_calls" => [...] } }
+
+        parts = extract_parts_from_response(gemini_response)
+
+        {
+          "message" => {
+            "content" => extract_text_content(parts),
+            "tool_calls" => extract_tool_calls(parts)
+          }
+        }
+      end
+
+      def extract_parts_from_response(gemini_response)
+        candidate = gemini_response["candidates"]&.first
+        raise AdapterError, I18n.t("rubycode.errors.adapter.no_choices") unless candidate
+
+        content_obj = candidate["content"]
+        raise AdapterError, I18n.t("rubycode.errors.adapter.no_message") unless content_obj
+
+        content_obj["parts"] || []
+      end
+
+      def extract_text_content(parts)
+        parts
+          .select { |p| p["text"] }
+          .map { |p| p["text"] }
+          .join("\n")
+      end
+
+      def extract_tool_calls(parts)
+        parts
+          .select { |p| p["functionCall"] }
+          .map { |p| convert_function_call(p["functionCall"]) }
+      end
+
+      def convert_function_call(function_call)
+        {
+          "function" => {
+            "name" => function_call["name"],
+            "arguments" => function_call["args"] || {}
+          }
+        }
+      end
+
+      def extract_tokens(response_body)
+        usage = response_body["usageMetadata"] || {}
+        candidates = usage["candidatesTokenCount"] || 0
+        thoughts = usage["thoughtsTokenCount"] || 0
+
+        TokenCounter.new(
+          input: usage["promptTokenCount"],
+          output: candidates + thoughts, # Must sum both
+          thinking: thoughts
+        )
+      end
+
+      def sanitize_url(uri)
+        uri.to_s.gsub(/key=[^&]*/, "key=***")
+      end
+    end
+  end
+end