rubyn-code 0.3.0 → 0.5.0

data/lib/rubyn_code/cli/repl_setup.rb

@@ -11,6 +11,7 @@ module RubynCode
         setup_services!
         setup_executor_callbacks!
         setup_hooks!
+        setup_mcp_servers!
         setup_agent_loop!
       end
 
@@ -41,9 +42,41 @@ module RubynCode
         @budget_enforcer = Observability::BudgetEnforcer.new(@db, session_id: current_session_id)
         @background_worker = Background::Worker.new(project_root: @project_root)
         @skill_loader = Skills::Loader.new(Skills::Catalog.new(skill_dirs))
+        @skill_matcher = build_skill_matcher
+        @web_skill_autoload = build_web_skill_autoload
         @session_persistence = Memory::SessionPersistence.new(@db)
       end
 
+      def build_skill_matcher
+        return nil unless skills_autoload_enabled?
+
+        Skills::Matcher.new(catalog: @skill_loader.catalog, project_root: @project_root)
+      end
+
+      def build_web_skill_autoload
+        return nil unless @skill_matcher && skills_autoload_enabled?
+
+        Skills::RegistryAutoload.new(
+          loader: @skill_loader,
+          matcher: @skill_matcher,
+          on_fetching: on_pack_fetching_callback
+        )
+      end
+
+      def skills_autoload_enabled?
+        Config::Settings.new.skills_autoload
+      rescue Config::Settings::LoadError
+        true
+      end
+
+      def on_skills_autoloaded_callback
+        ->(names) { @renderer.system_message("📚 Loaded: #{names.join(' · ')}") }
+      end
+
+      def on_pack_fetching_callback
+        ->(name) { @renderer.system_message("📥 Fetching skill pack '#{name}' from registry…") }
+      end
+
       def setup_executor_callbacks!
         @tool_executor.llm_client = @llm_client
         @tool_executor.background_worker = @background_worker
@@ -106,7 +139,10 @@ module RubynCode
           on_tool_call: ->(name, params) { handle_on_tool_call(name, params) },
           on_tool_result: ->(name, result, _is_error = false) { handle_on_tool_result(name, result) },
           on_text: ->(text) { handle_on_text(text) },
-          skill_loader: @skill_loader, project_root: @project_root
+          on_skills_autoloaded: on_skills_autoloaded_callback,
+          skill_loader: @skill_loader, skill_matcher: @skill_matcher,
+          web_skill_autoload: @web_skill_autoload,
+          project_root: @project_root
         )
       end
 
@@ -138,8 +174,45 @@ module RubynCode
         dirs << project_skills if Dir.exist?(project_skills)
         user_skills = File.join(Config::Defaults::HOME_DIR, 'skills')
         dirs << user_skills if Dir.exist?(user_skills)
+        skill_packs = File.join(Config::Defaults::HOME_DIR, 'skill-packs')
+        dirs << skill_packs if Dir.exist?(skill_packs)
         dirs
       end
+
+      # ── MCP Server Wiring ─────────────────────────────────────────
+
+      def setup_mcp_servers!
+        @mcp_clients = []
+        server_configs = MCP::Config.load(@project_root)
+        return if server_configs.empty?
+
+        server_configs.each do |config|
+          connect_mcp_server(config)
+        end
+
+        at_exit { disconnect_mcp_clients! unless defined?(RSpec) }
+      end
+
+      def connect_mcp_server(config)
+        client = MCP::Client.from_config(config)
+        client.connect!
+        MCP::ToolBridge.bridge(client)
+        @mcp_clients << client
+        @renderer.info("MCP server '#{config[:name]}' connected (#{client.tools.size} tools)")
+      rescue StandardError => e
+        warn "[MCP] Failed to connect '#{config[:name]}': #{e.message}"
+      end
+
+      def disconnect_mcp_clients!
+        return if @mcp_clients.nil? || @mcp_clients.empty?
+
+        @mcp_clients.each do |client|
+          client.disconnect!
+        rescue StandardError => e
+          warn "[MCP] Error disconnecting '#{client.name}': #{e.message}"
+        end
+        @mcp_clients.clear
+      end
     end
   end
 end

data/lib/rubyn_code/config/defaults.rb

@@ -12,6 +12,7 @@ module RubynCode
 
       DEFAULT_PROVIDER = 'anthropic'
       DEFAULT_MODEL = 'claude-opus-4-6'
+      MODEL_MODE = 'auto' # 'auto' or 'manual'
       MAX_ITERATIONS = 200
       MAX_SUB_AGENT_ITERATIONS = 200
       MAX_EXPLORE_AGENT_ITERATIONS = 200
@@ -30,6 +31,8 @@ module RubynCode
       POLL_INTERVAL = 5
       IDLE_TIMEOUT = 60
 
+      SKILLS_AUTOLOAD = true
+
       SESSION_BUDGET_USD = 5.00
       DAILY_BUDGET_USD = 10.00
 

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,17 +10,19 @@ module RubynCode
       class LoadError < StandardError; end
 
       CONFIGURABLE_KEYS = %i[
-        provider 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
         oauth_client_id oauth_redirect_uri oauth_authorize_url
         oauth_token_url oauth_scopes
+        skills_autoload
       ].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,
@@ -34,7 +36,8 @@ module RubynCode
         oauth_redirect_uri: Defaults::OAUTH_REDIRECT_URI,
         oauth_authorize_url: Defaults::OAUTH_AUTHORIZE_URL,
         oauth_token_url: Defaults::OAUTH_TOKEN_URL,
-        oauth_scopes: Defaults::OAUTH_SCOPES
+        oauth_scopes: Defaults::OAUTH_SCOPES,
+        skills_autoload: Defaults::SKILLS_AUTOLOAD
       }.freeze
 
       attr_reader :config_path, :data
@@ -114,10 +117,11 @@ module RubynCode
       # @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: {})
+      # @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
+          base_url: base_url, env_key: env_key, models: models, pricing: pricing, api_format: api_format
         )
         save!
       end
@@ -158,7 +162,8 @@ module RubynCode
 
       # 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
+      # -- iterates providers with guard clauses
+      def backfill_provider_models!
         providers = @data['providers']
         return unless providers.is_a?(Hash)
 
@@ -176,8 +181,9 @@ module RubynCode
         nil
       end
 
-      def build_provider_hash(base_url:, env_key:, models:, pricing:)
+      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?

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/context_budget.rb

@@ -25,8 +25,9 @@ module RubynCode
 
       attr_reader :loaded_files, :signature_files, :tokens_used
 
-      def initialize(budget: DEFAULT_BUDGET)
+      def initialize(budget: DEFAULT_BUDGET, codebase_index: nil)
         @budget = budget
+        @codebase_index = codebase_index
         @loaded_files = []
         @signature_files = []
         @tokens_used = 0
@@ -34,6 +35,10 @@ module RubynCode
 
       # 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 = []
 
@@ -46,6 +51,9 @@ module RubynCode
         @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
@@ -81,6 +89,13 @@ module RubynCode
 
       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)
@@ -115,7 +130,8 @@ module RubynCode
         end
       end
 
-      def process_signature_line(line, signatures, indent_stack) # rubocop:disable Metrics/AbcSize -- signature extraction dispatch
+      # -- signature extraction dispatch
+      def process_signature_line(line, signatures, indent_stack)
         stripped = line.strip
         if signature_line?(stripped)
           signatures << line

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/manager.rb

@@ -10,7 +10,7 @@ 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
       # @param llm_client [LLM::Client, nil] needed for LLM-driven compaction
@@ -19,10 +19,18 @@ module RubynCode
         @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.
       #
       # @param usage [LLM::Usage, #input_tokens] usage data from an LLM response
@@ -60,16 +68,22 @@ 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 succeeded this turn
+        return if @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,6 +91,7 @@ module RubynCode
         collapsed = ContextCollapse.call(messages, threshold: @threshold)
         if collapsed
           apply_compacted_messages(conversation, collapsed)
+          @last_compaction_turn = @current_turn
           return
         end
 
@@ -86,6 +101,7 @@ module RubynCode
         compactor = Compactor.new(llm_client: @llm_client, threshold: @threshold)
         new_messages = compactor.auto_compact!(messages)
         apply_compacted_messages(conversation, new_messages)
+        @last_compaction_turn = @current_turn
       end
 
       # Resets cumulative token counters to zero.
@@ -94,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)

data/lib/rubyn_code/context/manual_compact.rb

@@ -68,7 +68,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/hooks/registry.rb

@@ -17,6 +17,10 @@ module RubynCode
         on_stall
         on_error
         on_session_end
+        session_start
+        user_prompt_submit
+        permission_request
+        stop
       ].freeze
 
       Hook = Data.define(:callable, :priority)