rubyn-code 0.2.2 → 0.4.0

data/lib/rubyn_code/config/schema.json

@@ -0,0 +1,49 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "provider": {
+      "type": "string",
+      "minLength": 1
+    },
+    "model": {
+      "type": "string",
+      "minLength": 1
+    },
+    "model_mode": {
+      "type": "string",
+      "enum": ["auto", "manual"]
+    },
+    "max_iterations": {
+      "type": "integer",
+      "minimum": 1,
+      "maximum": 1000
+    },
+    "max_sub_agent_iterations": {
+      "type": "integer",
+      "minimum": 1,
+      "maximum": 500
+    },
+    "max_output_chars": {
+      "type": "integer",
+      "minimum": 1000,
+      "maximum": 1000000
+    },
+    "context_threshold_tokens": {
+      "type": "integer",
+      "minimum": 10000,
+      "maximum": 200000
+    },
+    "session_budget_usd": {
+      "type": "number",
+      "minimum": 0.1,
+      "maximum": 100
+    },
+    "daily_budget_usd": {
+      "type": "number",
+      "minimum": 0.5,
+      "maximum": 500
+    }
+  },
+  "additionalProperties": true
+}

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 model_mode 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,7 +19,9 @@ module RubynCode
       ].freeze
 
       DEFAULT_MAP = {
+        provider: Defaults::DEFAULT_PROVIDER,
         model: Defaults::DEFAULT_MODEL,
+        model_mode: Defaults::MODEL_MODE,
         max_iterations: Defaults::MAX_ITERATIONS,
         max_sub_agent_iterations: Defaults::MAX_SUB_AGENT_ITERATIONS,
         max_output_chars: Defaults::MAX_OUTPUT_CHARS,
@@ -42,7 +44,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 +96,106 @@ 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]
+      # @param api_format [String, nil] API format ('openai' or 'anthropic')
+      def add_provider(name, base_url:, env_key: nil, models: [], pricing: {}, api_format: nil) # rubocop:disable Metrics/ParameterLists -- all optional kwargs with defaults
+        @data['providers'] ||= {}
+        @data['providers'][name.to_s] = build_provider_hash(
+          base_url: base_url, env_key: env_key, models: models, pricing: pricing, api_format: api_format
+        )
+        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:, api_format: nil)
+        hash = { 'base_url' => base_url }
+        hash['api_format'] = api_format if api_format
+        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/config/validator.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'json_schemer'
+
+module RubynCode
+  module Config
+    class Validator
+      SCHEMA_PATH = File.expand_path('schema.json', __dir__)
+
+      def initialize
+        @raw_schema = JSON.parse(File.read(SCHEMA_PATH))
+        @schemer = JSONSchemer.schema(@raw_schema)
+      end
+
+      # Validates a single config key/value pair against the schema.
+      #
+      # @param key [String] the config key
+      # @param value [Object] the value to validate
+      # @return [Hash] { valid: true/false, errors: [String] }
+      def validate(key, value)
+        # If the key has no schema definition, accept any value
+        properties = @raw_schema.fetch('properties', {})
+        unless properties.key?(key.to_s)
+          return { valid: true, errors: [] }
+        end
+
+        doc = { key.to_s => value }
+        errors = @schemer.validate(doc).select { |e| e['data_pointer'] == "/#{key}" }
+
+        if errors.empty?
+          { valid: true, errors: [] }
+        else
+          messages = errors.map { |e| format_error(key, e) }
+          { valid: false, errors: messages }
+        end
+      end
+
+      private
+
+      def format_error(key, error)
+        detail = error['type']
+        schema_node = error.fetch('schema', {})
+
+        parts = ["#{key}: invalid value"]
+        parts << "(expected #{detail})" if detail
+
+        if schema_node.key?('minimum') || schema_node.key?('maximum')
+          range_parts = []
+          range_parts << "min #{schema_node['minimum']}" if schema_node.key?('minimum')
+          range_parts << "max #{schema_node['maximum']}" if schema_node.key?('maximum')
+          parts << "[#{range_parts.join(', ')}]"
+        end
+
+        if schema_node.key?('enum')
+          parts << "allowed: #{schema_node['enum'].join(', ')}"
+        end
+
+        parts.join(' ')
+      end
+    end
+  end
+end

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,182 @@
+# 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, codebase_index: nil)
+        @budget = budget
+        @codebase_index = codebase_index
+        @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 }
+      #
+      # When a codebase_index is available and no related_files are supplied,
+      # uses impact_analysis to auto-discover related files (specs,
+      # associated models, controllers, etc.).
+      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 }
+
+        # Auto-discover related files from the index when none supplied
+        related_files = discover_related_files(file_path) if related_files.empty? && @codebase_index
+
+        # 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 discover_related_files(file_path)
+        analysis = @codebase_index.impact_analysis(file_path)
+        analysis[:affected_files].reject { |f| f == file_path }
+      rescue StandardError
+        []
+      end
+
+      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/context_collapse.rb

@@ -23,13 +23,16 @@ module RubynCode
       def self.call(messages, threshold:, keep_recent: 6)
         return nil if messages.size <= keep_recent + 2
 
-        # Keep first message + last N messages, snip the middle
-        first = messages.first
+        # Always preserve the very first message (may contain critical
+        # system-level context like auth shims) AND the first real user
+        # message so the agent retains the user's original request.
+        anchors = build_anchors(messages)
+
         recent = messages.last(keep_recent)
-        snipped_count = messages.size - keep_recent - 1
+        snipped_count = messages.size - keep_recent - anchors.size
 
         collapsed = [
-          first,
+          *anchors,
           { role: 'user', content: format(SNIP_MARKER, snipped_count) },
           *recent
         ]
@@ -40,6 +43,33 @@ module RubynCode
       rescue JSON::GeneratorError
         nil
       end
+
+      # Builds the list of anchor messages to preserve at the top.
+      # Always keeps messages[0] (may contain critical system context).
+      # If messages[0] is a system injection, also keeps the first real
+      # user message so the agent retains the original request.
+      def self.build_anchors(messages)
+        first = messages.first
+        anchors = [first]
+        return anchors unless system_injection?(first)
+
+        user_msg = first_real_user_message(messages)
+        anchors << user_msg if user_msg
+        anchors
+      end
+
+      def self.system_injection?(msg)
+        content = msg[:content]
+        content.is_a?(String) && content.start_with?('[system]')
+      end
+
+      def self.first_real_user_message(messages)
+        messages[1..].find do |msg|
+          msg[:role] == 'user' && !system_injection?(msg)
+        end
+      end
+
+      private_class_method :build_anchors
     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

@@ -10,13 +10,25 @@ module RubynCode
     class Manager
       CHARS_PER_TOKEN = 4
 
-      attr_reader :total_input_tokens, :total_output_tokens
+      attr_reader :total_input_tokens, :total_output_tokens, :current_turn
 
       # @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
+        @last_compaction_turn = -1
+        @current_turn = 0
+      end
+
+      attr_writer :llm_client
+
+      # Advances the turn counter. Call once per iteration so that
+      # duplicate compaction calls within the same turn are skipped.
+      def advance_turn!
+        @current_turn += 1
       end
 
       # Accumulates token counts from an LLM response usage object.
@@ -56,16 +68,24 @@ module RubynCode
       # Fraction of the compaction threshold at which micro-compact kicks in.
       # Running it too early busts the prompt cache prefix (mutated messages
       # change the hash, invalidating server-side cached tokens).
-      MICRO_COMPACT_RATIO = 0.7
+      # Anthropic has prompt caching so we delay compaction (0.7).
+      # OpenAI has no cache prefix to protect so we compact earlier (0.5).
+      MICRO_COMPACT_RATIO_CACHED = 0.7
+      MICRO_COMPACT_RATIO_UNCACHED = 0.5
 
       def check_compaction!(conversation)
+        # Guard: skip if compaction already ran this turn
+        return if @last_compaction_turn == @current_turn
+
+        @last_compaction_turn = @current_turn
+
         messages = conversation.messages
 
         # Step 1: Zero-cost micro-compact — but only when we're approaching
         # the compaction threshold. Running it every turn mutates old messages,
         # which invalidates the prompt cache prefix and wastes tokens.
         est = estimated_tokens(messages)
-        MicroCompact.call(messages) if est > (@threshold * MICRO_COMPACT_RATIO)
+        MicroCompact.call(messages) if est > (@threshold * micro_compact_ratio)
 
         return unless needs_compaction?(messages)
 
@@ -77,11 +97,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
@@ -92,10 +110,28 @@ module RubynCode
       def reset!
         @total_input_tokens = 0
         @total_output_tokens = 0
+        @last_compaction_turn = -1
+        @current_turn = 0
       end
 
       private
 
+      # Returns the micro-compact ratio based on the active provider.
+      # Providers with prompt caching (Anthropic) use a higher ratio to
+      # preserve cached prefixes; providers without caching compact earlier.
+      def micro_compact_ratio
+        return MICRO_COMPACT_RATIO_UNCACHED if uncached_provider?
+
+        MICRO_COMPACT_RATIO_CACHED
+      end
+
+      def uncached_provider?
+        return false unless @llm_client
+
+        provider = @llm_client.provider_name if @llm_client.respond_to?(:provider_name)
+        %w[openai openai_compatible].include?(provider)
+      end
+
       def apply_compacted_messages(conversation, new_messages)
         if conversation.respond_to?(:replace_messages)
           conversation.replace_messages(new_messages)