rubyn-code 0.2.2 → 0.3.0

data/lib/rubyn_code/config/settings.rb

@@ -10,7 +10,7 @@ module RubynCode
       class LoadError < StandardError; end
 
       CONFIGURABLE_KEYS = %i[
-        model max_iterations max_sub_agent_iterations max_output_chars
+        provider model max_iterations max_sub_agent_iterations max_output_chars
         context_threshold_tokens micro_compact_keep_recent
         poll_interval idle_timeout
         session_budget_usd daily_budget_usd
@@ -19,6 +19,7 @@ module RubynCode
       ].freeze
 
       DEFAULT_MAP = {
+        provider: Defaults::DEFAULT_PROVIDER,
         model: Defaults::DEFAULT_MODEL,
         max_iterations: Defaults::MAX_ITERATIONS,
         max_sub_agent_iterations: Defaults::MAX_SUB_AGENT_ITERATIONS,
@@ -42,7 +43,9 @@ module RubynCode
         @config_path = config_path
         @data = {}
         ensure_home_directory!
+        seed_config! unless File.exist?(@config_path)
         load!
+        backfill_provider_models!
       end
 
       # Define accessor methods for each configurable key
@@ -92,8 +95,104 @@ module RubynCode
       def dangerous_patterns = Defaults::DANGEROUS_PATTERNS
       def scrub_env_vars = Defaults::SCRUB_ENV_VARS
 
+      # Returns config hash for a custom provider, or nil if not configured.
+      # Reads from `providers.<name>` in config.yml.
+      #
+      # Expected keys: base_url, env_key, models, pricing
+      # pricing is a hash of model_name => [input_rate, output_rate]
+      def provider_config(name)
+        providers = @data.dig('providers', name.to_s)
+        return nil unless providers.is_a?(Hash)
+
+        providers.transform_keys(&:to_s)
+      end
+
+      # Add or update a provider in the config and persist to disk.
+      #
+      # @param name [String] provider name (e.g., 'groq')
+      # @param base_url [String] API base URL
+      # @param env_key [String, nil] environment variable for the API key
+      # @param models [Array<String>] available model names
+      # @param pricing [Hash] model => [input_rate, output_rate]
+      def add_provider(name, base_url:, env_key: nil, models: [], pricing: {})
+        @data['providers'] ||= {}
+        @data['providers'][name.to_s] = build_provider_hash(
+          base_url: base_url, env_key: env_key, models: models, pricing: pricing
+        )
+        save!
+      end
+
+      # Returns all user-configured pricing as { model => [input, output] }
+      def custom_pricing
+        providers = @data['providers']
+        return {} unless providers.is_a?(Hash)
+
+        providers.each_with_object({}) do |(_, cfg), acc|
+          merge_provider_pricing(cfg, acc)
+        end
+      end
+
+      # Default model tiers per built-in provider. Used by seed_config! and
+      # backfill_provider_models! so new and existing configs stay in sync.
+      DEFAULT_PROVIDER_MODELS = {
+        'anthropic' => {
+          'env_key' => 'ANTHROPIC_API_KEY',
+          'models' => { 'cheap' => 'claude-haiku-4-5', 'mid' => 'claude-sonnet-4-6', 'top' => 'claude-opus-4-6' }
+        },
+        'openai' => {
+          'env_key' => 'OPENAI_API_KEY',
+          'models' => { 'cheap' => 'gpt-5.4-nano', 'mid' => 'gpt-5.4-mini', 'top' => 'gpt-5.4' }
+        }
+      }.freeze
+
       private
 
+      def seed_config!
+        @data = {
+          'provider' => Defaults::DEFAULT_PROVIDER,
+          'model' => Defaults::DEFAULT_MODEL,
+          'providers' => DEFAULT_PROVIDER_MODELS.transform_values(&:dup)
+        }
+        save!
+      end
+
+      # Backfills missing 'models' keys into existing provider configs.
+      # Never overwrites user-set values — only adds what's missing.
+      def backfill_provider_models! # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity -- iterates providers with guard clauses
+        providers = @data['providers']
+        return unless providers.is_a?(Hash)
+
+        changed = false
+        DEFAULT_PROVIDER_MODELS.each do |name, defaults|
+          next unless providers.key?(name)
+          next if providers[name].is_a?(Hash) && providers[name].key?('models')
+
+          providers[name] = {} unless providers[name].is_a?(Hash)
+          providers[name]['models'] = defaults['models'].dup
+          changed = true
+        end
+        save! if changed
+      rescue StandardError
+        nil
+      end
+
+      def build_provider_hash(base_url:, env_key:, models:, pricing:)
+        hash = { 'base_url' => base_url }
+        hash['env_key'] = env_key if env_key
+        hash['models'] = models unless models.empty?
+        hash['pricing'] = pricing unless pricing.empty?
+        hash
+      end
+
+      def merge_provider_pricing(cfg, acc)
+        return unless cfg.is_a?(Hash) && cfg['pricing'].is_a?(Hash)
+
+        cfg['pricing'].each do |model, rates|
+          pair = Array(rates)
+          acc[model.to_s] = pair.map(&:to_f) if pair.size == 2
+        end
+      end
+
       def ensure_home_directory!
         dir = File.dirname(@config_path)
         return if File.directory?(dir)

data/lib/rubyn_code/context/auto_compact.rb

@@ -63,7 +63,7 @@ module RubynCode
         ]
 
         options = {}
-        options[:model] = 'claude-sonnet-4-20250514' if llm_client.respond_to?(:chat)
+        options[:model] = 'claude-sonnet-4-6' if llm_client.respond_to?(:chat)
 
         response = llm_client.chat(messages: summary_messages, **options)
 

data/lib/rubyn_code/context/context_budget.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Context
+    # Budget-aware context loader that prioritizes which related files
+    # to load fully vs. as signatures-only. Prevents context bloat by
+    # capping auto-loaded context at a configurable token budget.
+    class ContextBudget
+      CHARS_PER_TOKEN = 4
+      DEFAULT_BUDGET = 4000 # tokens
+
+      # Rails convention-based priority for related files.
+      # Lower number = higher priority = loaded first.
+      PRIORITY_MAP = {
+        'spec' => 1, # tests for the file
+        'factory' => 2,  # FactoryBot factories
+        'service' => 3,  # service objects
+        'model' => 4, # related models
+        'controller' => 5,  # controllers
+        'serializer' => 6,  # serializers
+        'concern' => 7, # concerns/mixins
+        'helper' => 8, # helpers
+        'migration' => 9 # migrations
+      }.freeze
+
+      attr_reader :loaded_files, :signature_files, :tokens_used
+
+      def initialize(budget: DEFAULT_BUDGET)
+        @budget = budget
+        @loaded_files = []
+        @signature_files = []
+        @tokens_used = 0
+      end
+
+      # Load context for a primary file, filling budget with related files.
+      # Returns array of { file:, content:, mode: :full|:signatures }
+      def load_for(file_path, related_files: [])
+        results = []
+
+        # Primary file always loads fully
+        primary_content = safe_read(file_path)
+        return results unless primary_content
+
+        primary_tokens = estimate_tokens(primary_content)
+        @tokens_used = primary_tokens
+        @loaded_files << file_path
+        results << { file: file_path, content: primary_content, mode: :full }
+
+        # Sort related files by priority and fill remaining budget
+        sorted = prioritize(related_files)
+        remaining = @budget - @tokens_used
+        remaining = load_full_files(sorted, results, remaining)
+        load_signature_files(sorted, results, remaining)
+
+        results
+      end
+
+      # Extract method signatures and class structure without method bodies.
+      # Much more compact than full source — typically 10-20% of original size.
+      def extract_signatures(content)
+        signatures = []
+        indent_stack = []
+
+        content.lines.each do |line|
+          process_signature_line(line, signatures, indent_stack)
+        end
+
+        signatures.join
+      end
+
+      # Returns budget utilization stats.
+      def stats
+        {
+          budget: @budget,
+          tokens_used: @tokens_used,
+          utilization: @budget.positive? ? (@tokens_used.to_f / @budget).round(3) : 0.0,
+          full_files: @loaded_files.size,
+          signature_files: @signature_files.size
+        }
+      end
+
+      private
+
+      def load_full_files(sorted, results, remaining)
+        sorted.each do |rel_path|
+          content = safe_read(rel_path)
+          next unless content
+
+          size = estimate_tokens(content)
+          next unless size <= remaining
+
+          results << { file: rel_path, content: content, mode: :full }
+          @loaded_files << rel_path
+          @tokens_used += size
+          remaining -= size
+        end
+        remaining
+      end
+
+      def load_signature_files(sorted, results, remaining)
+        sorted.each do |rel_path|
+          next if @loaded_files.include?(rel_path)
+
+          content = safe_read(rel_path)
+          next unless content
+
+          sigs = extract_signatures(content)
+          sig_size = estimate_tokens(sigs)
+          next unless sig_size <= remaining
+
+          results << { file: rel_path, content: sigs, mode: :signatures }
+          @signature_files << rel_path
+          @tokens_used += sig_size
+          remaining -= sig_size
+        end
+      end
+
+      def process_signature_line(line, signatures, indent_stack) # rubocop:disable Metrics/AbcSize -- signature extraction dispatch
+        stripped = line.strip
+        if signature_line?(stripped)
+          signatures << line
+          indent_stack << current_indent(line) if block_opener?(stripped)
+        elsif stripped == 'end' && indent_stack.any? && current_indent(line) <= indent_stack.last
+          signatures << line
+          indent_stack.pop
+        elsif class_or_module_line?(stripped)
+          signatures << line
+          indent_stack << current_indent(line)
+        end
+      end
+
+      def prioritize(files)
+        files.sort_by do |path|
+          basename = File.basename(path, '.*').downcase
+          priority = PRIORITY_MAP.find { |key, _| basename.include?(key) }&.last || 10
+          priority
+        end
+      end
+
+      def signature_line?(stripped)
+        stripped.match?(/\A\s*(def\s|attr_|include\s|extend\s|has_|belongs_|validates|scope\s|delegate\s)/)
+      end
+
+      def class_or_module_line?(stripped)
+        stripped.match?(/\A\s*(class|module)\s/)
+      end
+
+      def block_opener?(stripped)
+        stripped.match?(/\Adef\s/)
+      end
+
+      def current_indent(line)
+        line.match(/\A(\s*)/)[1].length
+      end
+
+      def safe_read(path)
+        File.read(path)
+      rescue StandardError
+        nil
+      end
+
+      def estimate_tokens(text)
+        (text.bytesize.to_f / CHARS_PER_TOKEN).ceil
+      end
+    end
+  end
+end

data/lib/rubyn_code/context/decision_compactor.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Context
+    # Triggers compaction at logical decision boundaries rather than
+    # only at capacity limits. This prevents late-session context bloat
+    # by compacting after meaningful milestones.
+    class DecisionCompactor
+      # Percentage of context threshold at which to trigger compaction
+      # on decision boundaries (lower than the default 95%).
+      EARLY_COMPACT_RATIO = 0.6
+
+      TRIGGERS = %i[
+        specs_passed
+        topic_switch
+        multi_file_edit_complete
+      ].freeze
+
+      attr_reader :pending_trigger
+
+      def initialize(context_manager:, threshold: nil)
+        @context_manager = context_manager
+        @threshold = threshold || Config::Defaults::CONTEXT_THRESHOLD_TOKENS
+        @pending_trigger = nil
+        @last_topic_keywords = Set.new
+        @edited_files = Set.new
+      end
+
+      # Signal that specs passed after implementation.
+      def signal_specs_passed!
+        @pending_trigger = :specs_passed
+      end
+
+      # Signal that a file was edited (for multi-file tracking).
+      def signal_file_edited!(path)
+        @edited_files << path
+      end
+
+      # Signal that multi-file editing is complete.
+      def signal_edit_batch_complete!
+        return unless @edited_files.size > 1
+
+        @pending_trigger = :multi_file_edit_complete
+        @edited_files.clear
+      end
+
+      # Detect topic switch from user message keywords.
+      def detect_topic_switch(user_message)
+        keywords = extract_keywords(user_message)
+        overlap = keywords & @last_topic_keywords
+
+        @pending_trigger = :topic_switch if @last_topic_keywords.any? && overlap.empty? && keywords.any?
+
+        @last_topic_keywords = keywords
+      end
+
+      # Check if compaction should run based on decision boundaries.
+      # Returns true if compaction was triggered.
+      def check!(conversation) # rubocop:disable Naming/PredicateMethod -- side-effectful: triggers compaction, not just a query
+        return false unless should_compact?(conversation)
+
+        trigger = @pending_trigger
+        @pending_trigger = nil
+        RubynCode::Debug.token("Decision compaction triggered: #{trigger}")
+        @context_manager.check_compaction!(conversation)
+        true
+      end
+
+      # Reset all tracked state.
+      def reset!
+        @pending_trigger = nil
+        @last_topic_keywords.clear
+        @edited_files.clear
+      end
+
+      STOPWORDS = %w[the and for this that with from have been will your what].to_set.freeze
+
+      private
+
+      def should_compact?(conversation)
+        return false unless @pending_trigger
+
+        est = @context_manager.estimated_tokens(conversation.messages)
+        est > (@threshold * EARLY_COMPACT_RATIO)
+      end
+
+      def extract_keywords(text)
+        text.to_s.downcase
+            .scan(/\b[a-z]{3,}\b/)
+            .reject { |w| stopword?(w) }
+            .to_set
+      end
+
+      def stopword?(word)
+        STOPWORDS.include?(word)
+      end
+    end
+  end
+end

data/lib/rubyn_code/context/manager.rb

@@ -13,12 +13,16 @@ module RubynCode
       attr_reader :total_input_tokens, :total_output_tokens
 
       # @param threshold [Integer] estimated token count that triggers auto-compaction
-      def initialize(threshold: Config::Defaults::CONTEXT_THRESHOLD_TOKENS)
+      # @param llm_client [LLM::Client, nil] needed for LLM-driven compaction
+      def initialize(threshold: Config::Defaults::CONTEXT_THRESHOLD_TOKENS, llm_client: nil)
         @threshold = threshold
+        @llm_client = llm_client
         @total_input_tokens = 0
         @total_output_tokens = 0
       end
 
+      attr_writer :llm_client
+
       # Accumulates token counts from an LLM response usage object.
       #
       # @param usage [LLM::Usage, #input_tokens] usage data from an LLM response
@@ -77,11 +81,9 @@ module RubynCode
         end
 
         # Step 3: Full LLM-driven auto-compact (expensive, last resort)
-        compactor = Compactor.new(
-          llm_client: conversation.respond_to?(:llm_client) ? conversation.llm_client : nil,
-          threshold: @threshold
-        )
+        return unless @llm_client
 
+        compactor = Compactor.new(llm_client: @llm_client, threshold: @threshold)
         new_messages = compactor.auto_compact!(messages)
         apply_compacted_messages(conversation, new_messages)
       end

data/lib/rubyn_code/context/micro_compact.rb

@@ -22,22 +22,27 @@ module RubynCode
 
         tool_name_index = build_tool_name_index(messages)
         candidates = tool_result_refs[0..-(keep_recent + 1)]
-        compacted = 0
+        compact_candidates(candidates, tool_name_index, preserve_tools)
+      end
 
+      def self.compact_candidates(candidates, tool_name_index, preserve_tools)
+        compacted = 0
         candidates.each do |ref|
-          block = ref[:block]
-          content = extract_content(block)
-          next if content.nil? || content.length < MIN_CONTENT_LENGTH
+          compacted += 1 if compact_single_ref(ref, tool_name_index, preserve_tools)
+        end
+        compacted
+      end
 
-          tool_name = resolve_tool_name(block, tool_name_index)
-          next if preserve_tools.include?(tool_name)
+      def self.compact_single_ref(ref, tool_name_index, preserve_tools) # rubocop:disable Naming/PredicateMethod -- returns boolean but is an action method
+        block = ref[:block]
+        content = extract_content(block)
+        return false if content.nil? || content.length < MIN_CONTENT_LENGTH
 
-          placeholder = format(PLACEHOLDER_TEMPLATE, tool_name: tool_name || 'tool')
-          replace_content!(block, placeholder)
-          compacted += 1
-        end
+        tool_name = resolve_tool_name(block, tool_name_index)
+        return false if preserve_tools.include?(tool_name)
 
-        compacted
+        replace_content!(block, format(PLACEHOLDER_TEMPLATE, tool_name: tool_name || 'tool'))
+        true
       end
 
       # Collects all tool_result content blocks across user messages, preserving
@@ -70,19 +75,23 @@ module RubynCode
         messages.each do |msg|
           next unless msg[:role] == 'assistant' && msg[:content].is_a?(Array)
 
-          msg[:content].each do |block|
-            case block
-            when Hash
-              index[block[:id] || block['id']] = block[:name] || block['name'] if block_type(block) == 'tool_use'
-            when LLM::ToolUseBlock
-              index[block.id] = block.name
-            end
-          end
+          msg[:content].each { |block| index_tool_use(index, block) }
         end
 
         index
       end
 
+      def self.index_tool_use(index, block)
+        case block
+        when Hash
+          return unless block_type(block) == 'tool_use'
+
+          index[block[:id] || block['id']] = block[:name] || block['name']
+        when LLM::ToolUseBlock
+          index[block.id] = block.name
+        end
+      end
+
       def self.tool_result_block?(block)
         case block
         when Hash
@@ -128,6 +137,7 @@ module RubynCode
       end
 
       private_class_method :collect_tool_results, :build_tool_name_index,
+                           :index_tool_use, :compact_candidates, :compact_single_ref,
                            :tool_result_block?, :block_type, :extract_content,
                            :resolve_tool_name, :replace_content!
     end

data/lib/rubyn_code/context/schema_filter.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Context
+    # Extracts only the relevant table definitions from db/schema.rb
+    # based on which models are currently in context. Loading the full
+    # schema for a large Rails app can be 5-10K tokens; filtering to
+    # relevant tables typically reduces this to 200-500 tokens.
+    module SchemaFilter
+      TABLE_PATTERN = /create_table\s+"([^"]+)"/
+      END_PATTERN = /\A\s+end\s*\z/
+
+      class << self
+        # Returns schema definitions for only the specified table names.
+        #
+        # @param schema_path [String] path to db/schema.rb
+        # @param table_names [Array<String>] table names to include
+        # @return [String] filtered schema content
+        def filter(schema_path, table_names:)
+          return '' if table_names.empty?
+          return '' unless File.exist?(schema_path)
+
+          lines = File.readlines(schema_path)
+          extract_tables(lines, table_names.to_set(&:to_s))
+        end
+
+        # Derives table names from model class names using Rails conventions.
+        #
+        # @param model_names [Array<String>] e.g., ["User", "OrderItem"]
+        # @return [Array<String>] e.g., ["users", "order_items"]
+        def tableize(model_names)
+          model_names.map { |name| "#{name.gsub(/([a-z])([A-Z])/, '\1_\2').downcase}s" }
+        end
+
+        # Convenience: filter schema by model names instead of table names.
+        def filter_for_models(schema_path, model_names:)
+          tables = tableize(model_names)
+          filter(schema_path, table_names: tables)
+        end
+
+        private
+
+        def extract_tables(lines, table_set)
+          result = []
+          capturing = false
+
+          lines.each do |line|
+            match = TABLE_PATTERN.match(line)
+            capturing = true if match && table_set.include?(match[1])
+
+            result << line if capturing
+
+            if capturing && END_PATTERN.match?(line)
+              capturing = false
+              result << "\n"
+            end
+          end
+
+          result.join
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/db/connection.rb

@@ -106,34 +106,11 @@ module RubynCode
       #
       # @yield the block to execute
       # @return [Object] the block's return value
-      def transaction
+      def transaction(&block)
         synchronize do
-          if @transaction_depth.zero?
-            begin_top_level_transaction
-          else
-            begin_savepoint
-          end
-
+          @transaction_depth.zero? ? begin_top_level_transaction : begin_savepoint
           @transaction_depth += 1
-          begin
-            result = yield
-            if @transaction_depth == 1
-              @db.execute('COMMIT')
-            else
-              @db.execute("RELEASE SAVEPOINT sp_#{@transaction_depth}")
-            end
-            result
-          rescue StandardError => e
-            if @transaction_depth == 1
-              @db.execute('ROLLBACK')
-            else
-              @db.execute("ROLLBACK TO SAVEPOINT sp_#{@transaction_depth}")
-              @db.execute("RELEASE SAVEPOINT sp_#{@transaction_depth}")
-            end
-            raise e
-          ensure
-            @transaction_depth -= 1
-          end
+          execute_transaction_body(&block)
         end
       end
 
@@ -171,6 +148,34 @@ module RubynCode
       def begin_savepoint
         @db.execute("SAVEPOINT sp_#{@transaction_depth + 1}")
       end
+
+      def execute_transaction_body
+        result = yield
+        commit_or_release
+        result
+      rescue StandardError => e
+        rollback_or_release
+        raise e
+      ensure
+        @transaction_depth -= 1
+      end
+
+      def commit_or_release
+        if @transaction_depth == 1
+          @db.execute('COMMIT')
+        else
+          @db.execute("RELEASE SAVEPOINT sp_#{@transaction_depth}")
+        end
+      end
+
+      def rollback_or_release
+        if @transaction_depth == 1
+          @db.execute('ROLLBACK')
+        else
+          @db.execute("ROLLBACK TO SAVEPOINT sp_#{@transaction_depth}")
+          @db.execute("RELEASE SAVEPOINT sp_#{@transaction_depth}")
+        end
+      end
     end
   end
 end