rubycode 0.1.3 → 0.1.4

data/lib/rubycode/client/display_formatter.rb

@@ -12,7 +12,9 @@ module RubyCode
         "read" => ["[READ]", "file_path"],
         "search" => ["[SEARCH]", "pattern"],
         "write" => ["[WRITE]", "file_path"],
-        "update" => ["[UPDATE]", "file_path"]
+        "update" => ["[UPDATE]", "file_path"],
+        "web_search" => ["[WEB SEARCH]", "query"],
+        "fetch" => ["[FETCH]", "url"]
       }.freeze
 
       def initialize(config:)
@@ -21,17 +23,12 @@ module RubyCode
       end
 
       def display_tool_info(tool_name, arguments)
-        if @config.debug
-          puts Views::Formatter::DebugToolInfo.build(tool_name: tool_name, arguments: arguments)
-        else
-          display_minimal_tool_info(tool_name, arguments)
-        end
+        display_minimal_tool_info(tool_name, arguments)
       end
 
-      def display_result(result)
-        return unless @config.debug
-
-        puts Views::Formatter::ToolResult.build(result: result)
+      def display_result(result, tool_name: nil)
+        # Show summaries for web tools
+        display_tool_summary(result, tool_name) if %w[web_search fetch].include?(tool_name)
       end
 
       def display_info(message)
@@ -44,6 +41,17 @@ module RubyCode
 
       private
 
+      def display_tool_summary(result, tool_name)
+        return unless result.is_a?(ToolResult)
+
+        case tool_name
+        when "web_search"
+          puts Views::Formatter::WebSearchSummary.build(result: result)
+        when "fetch"
+          puts Views::Formatter::FetchSummary.build(result: result)
+        end
+      end
+
       def display_minimal_tool_info(tool_name, arguments)
         return unless TOOL_LABELS.key?(tool_name)
 

data/lib/rubycode/client/response_handler.rb

@@ -21,15 +21,8 @@ module RubyCode
       end
 
       def handle_empty_tool_calls(content, iteration, total_tool_calls)
-        if @config.enable_tool_injection_workaround && iteration < 10
-          inject_tool_reminder(iteration)
-          return nil
-        end
-
-        unless @config.debug
-          puts Views::ResponseHandler::CompleteMessage.build(iteration: iteration,
-                                                             total_tool_calls: total_tool_calls)
-        end
+        puts Views::ResponseHandler::CompleteMessage.build(iteration: iteration,
+                                                           total_tool_calls: total_tool_calls)
         content
       end
 
@@ -42,22 +35,10 @@ module RubyCode
       end
 
       def finalize_response(done_result, iteration, total_tool_calls)
-        unless @config.debug
-          puts Views::ResponseHandler::AgentFinished.build(iteration: iteration,
-                                                           total_tool_calls: total_tool_calls + 1)
-        end
+        puts Views::ResponseHandler::AgentFinished.build(iteration: iteration,
+                                                         total_tool_calls: total_tool_calls + 1)
         done_result
       end
-
-      private
-
-      def inject_tool_reminder(iteration)
-        puts Views::ResponseHandler::ToolInjectionWarning.build(iteration: iteration) unless @config.debug
-        @memory.add_message(
-          role: "user",
-          content: "You MUST call a tool. Do not respond with text. Call search, read, bash, or done tool now."
-        )
-      end
     end
   end
 end

data/lib/rubycode/client.rb

@@ -11,6 +11,7 @@ module RubyCode
       @config = RubyCode.config
       @adapter = build_adapter
       @memory = Memory.new
+      @memory.clear # Clear memory at start of each session to prevent payload size issues
       @read_files = Set.new
       @tty_prompt = tty_prompt
     end
@@ -39,6 +40,14 @@ module RubyCode
       case @config.adapter
       when :ollama
         Adapters::Ollama.new(@config)
+      when :openrouter
+        Adapters::Openrouter.new(@config)
+      when :deepseek
+        Adapters::Deepseek.new(@config)
+      when :gemini
+        Adapters::Gemini.new(@config)
+      when :openai
+        Adapters::Openai.new(@config)
       else
         raise I18n.t("rubycode.errors.unknown_adapter")
       end

data/lib/rubycode/config_manager.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module RubyCode
+  # Manages configuration persistence to ~/.rubycode/config.yml
+  class ConfigManager
+    CONFIG_DIR = File.join(Dir.home, ".rubycode")
+    CONFIG_FILE = File.join(CONFIG_DIR, "config.yml")
+
+    class << self
+      # Load configuration from file
+      # Returns hash with symbolized keys or nil if file doesn't exist
+      def load
+        return nil unless exists?
+
+        yaml_content = File.read(CONFIG_FILE)
+        config_hash = YAML.safe_load(yaml_content, permitted_classes: [Symbol])
+
+        # Symbolize keys
+        symbolize_keys(config_hash)
+      rescue StandardError => e
+        warn "Warning: Failed to load config from #{CONFIG_FILE}: #{e.message}"
+        nil
+      end
+
+      # Save configuration to file
+      # @param config_hash [Hash] Configuration hash to save
+      def save(config_hash)
+        FileUtils.mkdir_p(CONFIG_DIR)
+
+        File.write(CONFIG_FILE, config_hash.to_yaml)
+        true
+      rescue StandardError => e
+        warn "Warning: Failed to save config to #{CONFIG_FILE}: #{e.message}"
+        false
+      end
+
+      # Check if config file exists
+      # @return [Boolean]
+      def exists?
+        File.exist?(CONFIG_FILE)
+      end
+
+      # Get default configuration for a given adapter
+      # @param adapter [Symbol] The adapter name (:ollama, :groq)
+      # @return [Hash] Default configuration
+      def defaults_for_adapter(adapter)
+        case adapter
+        when :groq
+          {
+            adapter: :groq,
+            model: "llama-3.1-8b-instant",
+            url: "https://api.groq.com/openai/v1/chat/completions"
+          }
+        else
+          # Default to Ollama for unknown adapters
+          {
+            adapter: :ollama,
+            model: "deepseek-r1:8b",
+            url: "http://localhost:11434"
+          }
+        end
+      end
+
+      private
+
+      # Recursively symbolize hash keys
+      def symbolize_keys(hash)
+        return hash unless hash.is_a?(Hash)
+
+        hash.transform_keys do |key|
+          key.to_sym
+        rescue StandardError
+          key
+        end
+      end
+    end
+  end
+end

data/lib/rubycode/configuration.rb

@@ -3,26 +3,37 @@
 module RubyCode
   # Configuration class for Rubycode settings
   class Configuration
-    attr_accessor :adapter, :url, :model, :root_path, :debug, :enable_tool_injection_workaround,
-                  :http_read_timeout, :http_open_timeout, :max_retries, :retry_base_delay
+    attr_accessor :adapter, :url, :model, :root_path,
+                  :http_read_timeout, :http_open_timeout, :max_retries, :retry_base_delay,
+                  :adapter_request_delay, :memory_window, :prune_tool_results
 
     def initialize
       @adapter = :ollama
-      @url = "http://localhost:11434"
-      @model = "deepseek-v3.1:671b-cloud"
+      @url = "https://api.ollama.com"
+      @model = "qwen3-coder:480b-cloud"
       @root_path = Dir.pwd
-      @debug = false # Set to true to see JSON requests/responses
-
-      # WORKAROUND for models that don't follow tool-calling instructions
-      # When enabled, injects reminder messages if model generates text instead of calling tools
-      # Enabled by default as most models need this nudge
-      @enable_tool_injection_workaround = true
 
       # HTTP timeout and retry configuration
       @http_read_timeout = 120 # 2 minutes for LLM inference
       @http_open_timeout = 10  # 10 seconds for connection
       @max_retries = 3         # Number of retries (4 total attempts)
       @retry_base_delay = 2.0  # Base delay for exponential backoff
+
+      # Rate limiting configuration
+      @adapter_request_delay = 1.5 # Delay between consecutive requests (seconds)
+
+      # Memory optimization configuration
+      @memory_window = 10          # Keep last N messages for context
+      @prune_tool_results = true   # Replace old tool results with placeholder
+    end
+
+    # Load configuration from a hash
+    # @param hash [Hash] Configuration hash with symbolized keys
+    def load_from_hash(hash)
+      @adapter = hash[:adapter] if hash.key?(:adapter)
+      @model = hash[:model] if hash.key?(:model)
+      @url = hash[:url] if hash.key?(:url)
+      @root_path = hash[:root_path] if hash.key?(:root_path)
     end
   end
 end

data/lib/rubycode/database.rb

@@ -35,6 +35,7 @@ module RubyCode
 
       def run_migrations
         create_messages_table
+        create_api_keys_table
       end
 
       def create_messages_table
@@ -44,6 +45,24 @@ module RubyCode
           String :content, null: false, text: true
           DateTime :created_at, default: Sequel::CURRENT_TIMESTAMP
         end
+
+        # Add tool_calls column if it doesn't exist (migration for existing databases)
+        return if @db.schema(:messages).any? { |col| col[0] == :tool_calls }
+
+        @db.alter_table(:messages) do
+          add_column :tool_calls, String, text: true, null: true
+        end
+      end
+
+      def create_api_keys_table
+        @db.create_table?(:api_keys) do
+          primary_key :id
+          String :adapter, null: false, unique: true
+          String :encrypted_key, null: false, text: true
+          String :iv, null: false # Initialization vector for encryption
+          DateTime :created_at, default: Sequel::CURRENT_TIMESTAMP
+          DateTime :updated_at, default: Sequel::CURRENT_TIMESTAMP
+        end
       end
     end
   end

data/lib/rubycode/errors.rb

@@ -19,6 +19,15 @@ module RubyCode
   # Raised when command execution fails
   class CommandExecutionError < ToolError; end
 
+  # Base class for all network-related errors
+  class NetworkError < ToolError; end
+
+  # Raised when HTTP request fails
+  class HTTPError < NetworkError; end
+
+  # Raised when URL is invalid
+  class URLError < NetworkError; end
+
   # Base class for all adapter-related errors
   class AdapterError < Error; end
 
@@ -30,4 +39,7 @@ module RubyCode
 
   # Raised when all retry attempts are exhausted
   class AdapterRetryExhaustedError < AdapterError; end
+
+  # Base class for all search provider-related errors
+  class SearchProviderError < Error; end
 end

data/lib/rubycode/models/api_key.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "base64"
+
+module RubyCode
+  module Models
+    # Manages encrypted API keys for LLM providers
+    class ApiKey < Base
+      class << self
+        def table_name
+          :api_keys
+        end
+
+        # Save an API key for a specific adapter
+        # @param adapter [Symbol] The adapter name (:ollama, :groq, etc.)
+        # @param api_key [String] The plaintext API key
+        def save_key(adapter:, api_key:)
+          encrypted_data = encrypt(api_key)
+          existing = dataset.where(adapter: adapter.to_s).first
+
+          if existing
+            update_existing_key(adapter, encrypted_data)
+          else
+            insert_new_key(adapter, encrypted_data)
+          end
+        end
+
+        def update_existing_key(adapter, encrypted_data)
+          dataset.where(adapter: adapter.to_s).update(
+            encrypted_key: encrypted_data[:encrypted],
+            iv: encrypted_data[:iv],
+            updated_at: Time.now
+          )
+        end
+
+        def insert_new_key(adapter, encrypted_data)
+          dataset.insert(
+            adapter: adapter.to_s,
+            encrypted_key: encrypted_data[:encrypted],
+            iv: encrypted_data[:iv]
+          )
+        end
+
+        # Retrieve and decrypt an API key for a specific adapter
+        # @param adapter [Symbol] The adapter name
+        # @return [String, nil] The decrypted API key or nil if not found
+        def get_key(adapter:)
+          row = dataset.where(adapter: adapter.to_s).first
+          return nil unless row
+
+          decrypt(
+            encrypted: row[:encrypted_key],
+            init_vector: row[:iv]
+          )
+        end
+
+        # Delete an API key for a specific adapter
+        # @param adapter [Symbol] The adapter name
+        def delete_key(adapter:)
+          dataset.where(adapter: adapter.to_s).delete
+        end
+
+        # Check if an API key exists for a specific adapter
+        # @param adapter [Symbol] The adapter name
+        # @return [Boolean]
+        def key_exists?(adapter:)
+          dataset.where(adapter: adapter.to_s).any?
+        end
+
+        private
+
+        # Encrypt a plaintext API key
+        # @param plaintext [String] The API key to encrypt
+        # @return [Hash] Contains :encrypted and :iv
+        def encrypt(plaintext)
+          cipher = OpenSSL::Cipher.new("AES-256-CBC")
+          cipher.encrypt
+          cipher.key = encryption_key
+          iv = cipher.random_iv
+
+          encrypted = cipher.update(plaintext) + cipher.final
+
+          {
+            encrypted: Base64.strict_encode64(encrypted),
+            iv: Base64.strict_encode64(iv)
+          }
+        end
+
+        # Decrypt an encrypted API key
+        # @param encrypted [String] Base64-encoded encrypted data
+        # @param init_vector [String] Base64-encoded initialization vector
+        # @return [String] The decrypted API key
+        def decrypt(encrypted:, init_vector:)
+          cipher = OpenSSL::Cipher.new("AES-256-CBC")
+          cipher.decrypt
+          cipher.key = encryption_key
+          cipher.iv = Base64.strict_decode64(init_vector)
+
+          cipher.update(Base64.strict_decode64(encrypted)) + cipher.final
+        end
+
+        # Generate a consistent encryption key based on user's environment
+        # This creates a per-user encryption key
+        # @return [String] 32-byte encryption key
+        def encryption_key
+          # Use a combination of home directory and a salt to generate a consistent key
+          # This provides per-user encryption without requiring password entry
+          salt = "rubycode_api_key_encryption_v1"
+          key_base = "#{Dir.home}#{salt}"
+
+          # Use SHA-256 to generate a 32-byte key
+          OpenSSL::Digest::SHA256.digest(key_base)
+        end
+      end
+    end
+  end
+end

data/lib/rubycode/models/memory.rb

@@ -10,11 +10,11 @@ module RubyCode
     end
 
     # Accept either Message objects or keyword arguments for backwards compatibility
-    def add_message(message = nil, role: nil, content: nil)
+    def add_message(message = nil, role: nil, content: nil, tool_calls: nil)
       if message.is_a?(Message)
-        insert_message(message.role, message.content)
+        insert_message(message.role, message.content, message.tool_calls)
       elsif role && content
-        insert_message(role, content)
+        insert_message(role, content, tool_calls)
       else
         raise ArgumentError, "Must provide either a Message object or role: and content: keyword arguments"
       end
@@ -22,12 +22,60 @@ module RubyCode
 
     def messages
       db[:messages].order(:id).map do |row|
-        Message.new(role: row[:role], content: row[:content])
+        Message.new(
+          role: row[:role],
+          content: row[:content],
+          tool_calls: deserialize_tool_calls(row[:tool_calls])
+        )
       end
     end
 
-    def to_llm_format
-      messages.map(&:to_h)
+    def to_llm_format(window_size: 10, prune_tool_results: true)
+      all_messages = messages
+      return all_messages.map(&:to_h) if all_messages.length <= window_size
+
+      build_windowed_format(all_messages, window_size, prune_tool_results)
+    end
+
+    def build_windowed_format(all_messages, window_size, prune_tool_results)
+      first_msg, recent, middle = partition_messages(all_messages, window_size)
+
+      return recent.map(&:to_h) if recent.include?(first_msg)
+
+      result_messages = build_message_list(first_msg, middle, recent, prune_tool_results)
+      result_messages.map(&:to_h)
+    end
+
+    def build_message_list(first_msg, middle, recent, prune_tool_results)
+      return [first_msg] + recent unless should_prune_middle?(prune_tool_results, middle)
+
+      pruned_middle = prune_tool_results_from_middle(middle)
+      [first_msg] + pruned_middle + recent
+    end
+
+    def partition_messages(all_messages, window_size)
+      first_msg = all_messages.first
+      recent = all_messages.last(window_size)
+      middle = all_messages[1..-(window_size + 1)] || []
+      [first_msg, recent, middle]
+    end
+
+    def should_prune_middle?(prune_tool_results, middle)
+      prune_tool_results && middle.any? { |msg| tool_result_message?(msg) }
+    end
+
+    def tool_result_message?(message)
+      message.role == "user" && message.content.start_with?("Tool '")
+    end
+
+    def prune_tool_results_from_middle(middle)
+      middle.map do |msg|
+        if tool_result_message?(msg)
+          Message.new(role: msg.role, content: "[Tool result cleared]")
+        else
+          msg
+        end
+      end
     end
 
     def clear
@@ -38,20 +86,46 @@ module RubyCode
       row = self.class.latest.where(role: "user").first
       return nil unless row
 
-      Message.new(role: row[:role], content: row[:content])
+      Message.new(
+        role: row[:role],
+        content: row[:content],
+        tool_calls: deserialize_tool_calls(row[:tool_calls])
+      )
     end
 
     def last_assistant_message
       row = self.class.latest.where(role: "assistant").first
       return nil unless row
 
-      Message.new(role: row[:role], content: row[:content])
+      Message.new(
+        role: row[:role],
+        content: row[:content],
+        tool_calls: deserialize_tool_calls(row[:tool_calls])
+      )
     end
 
     private
 
-    def insert_message(role, content)
-      db[:messages].insert(role: role, content: content)
+    def insert_message(role, content, tool_calls = nil)
+      db[:messages].insert(
+        role: role,
+        content: content,
+        tool_calls: serialize_tool_calls(tool_calls)
+      )
+    end
+
+    def serialize_tool_calls(tool_calls)
+      return nil if tool_calls.nil? || tool_calls.empty?
+
+      JSON.generate(tool_calls)
+    end
+
+    def deserialize_tool_calls(tool_calls_json)
+      return nil if tool_calls_json.nil? || tool_calls_json.empty?
+
+      JSON.parse(tool_calls_json)
+    rescue JSON::ParserError
+      nil
     end
   end
 end

data/lib/rubycode/models.rb

@@ -2,3 +2,4 @@
 
 require_relative "models/base"
 require_relative "models/memory"
+require_relative "models/api_key"

data/lib/rubycode/pricing.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RubyCode
+  # Calculates cost estimates based on provider pricing
+  module Pricing
+    # Prices per 1M tokens (as of March 2026)
+    RATES = {
+      gemini: {
+        "gemini-2.5-flash" => { input: 0.0375, output: 0.15, cached: 0.01 },
+        "gemini-2.5-pro" => { input: 1.25, output: 5.00, cached: 0.31 },
+        "gemini-3-flash-preview" => { input: 0.0375, output: 0.15, cached: 0.01 }
+      },
+      openai: {
+        "gpt-4o" => { input: 2.50, output: 10.00, cached: 1.25 },
+        "gpt-4o-mini" => { input: 0.15, output: 0.60, cached: 0.075 },
+        "o1" => { input: 15.00, output: 60.00 }
+      },
+      deepseek: {
+        "deepseek-chat" => { input: 0.14, output: 0.28, cached: 0.014 },
+        "deepseek-reasoner" => { input: 0.55, output: 2.19, cached: 0.014 }
+      },
+      openrouter: {
+        "anthropic/claude-sonnet-4.5" => { input: 3.00, output: 15.00, cached: 0.30 },
+        "anthropic/claude-opus-4.6" => { input: 15.00, output: 75.00, cached: 1.50 }
+      },
+      ollama: {
+        "default" => { input: 0.0, output: 0.0 }
+      }
+    }.freeze
+
+    def self.calculate_cost(adapter:, model:, tokens:)
+      rates = find_rates(adapter, model)
+      return 0.0 unless rates
+
+      input_cost = calculate_token_cost(tokens.input, rates[:input])
+      output_cost = calculate_token_cost(tokens.output, rates[:output])
+      cached_cost = calculate_token_cost(tokens.cached, rates[:cached] || 0)
+
+      input_cost + output_cost - cached_cost # Cached reduces cost
+    end
+
+    def self.find_rates(adapter, model)
+      RATES.dig(adapter.to_sym, model) || RATES.dig(adapter.to_sym, "default")
+    end
+
+    def self.calculate_token_cost(token_count, rate_per_million)
+      (token_count / 1_000_000.0) * rate_per_million
+    end
+
+    def self.format_cost(cost_usd)
+      if cost_usd < 0.01
+        cents = (cost_usd * 100).round(4)
+        "$#{cents}¢"
+      else
+        "$#{cost_usd.round(4)}"
+      end
+    end
+  end
+end

data/lib/rubycode/search_providers/base.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "concerns/http_client"
+require_relative "concerns/error_handling"
+
+module RubyCode
+  module SearchProviders
+    # Base class for search providers
+    class Base
+      include Concerns::HttpClient
+      include Concerns::ErrorHandling
+
+      def initialize(config: nil, api_key: nil)
+        @config = config
+        @api_key = api_key
+        validate_api_key! if requires_api_key?
+      end
+
+      def search(query, max_results: 5)
+        uri_or_request = build_request(query, max_results)
+
+        debug_search_request(query, max_results, uri_or_request) if debug_enabled?
+
+        response = make_http_request(uri_or_request)
+
+        debug_search_response(response) if debug_enabled?
+
+        parse_results(response.body, max_results)
+      end
+
+      private
+
+      # Abstract methods to be implemented by subclasses
+      def provider_name
+        raise NotImplementedError, "Subclass must define provider_name"
+      end
+
+      def build_request(_query, _max_results)
+        raise NotImplementedError, "Subclass must define build_request"
+      end
+
+      def parse_results(_body, _max_results)
+        raise NotImplementedError, "Subclass must define parse_results"
+      end
+
+      # Concrete shared methods
+      def requires_api_key?
+        # Override in subclass if API key is required
+        false
+      end
+
+      attr_reader :api_key
+
+      def validate_api_key!
+        return if api_key && !api_key.empty?
+
+        raise SearchProviderError, I18n.t("rubycode.errors.search_provider.api_key_missing",
+                                          provider: provider_name)
+      end
+
+      def debug_enabled?
+        @config&.debug || false
+      end
+    end
+  end
+end