rubyn-code 0.2.2 → 0.3.0

data/lib/rubyn_code/llm/model_router.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module LLM
+    # Routes tasks to appropriate model tiers based on complexity.
+    # Integrates with the multi-provider adapter layer and reads
+    # per-provider model tier overrides from config.yml.
+    #
+    # Users can configure tier models per provider in config.yml:
+    #
+    #   providers:
+    #     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
+    #
+    module ModelRouter # rubocop:disable Metrics/ModuleLength -- tier routing with provider integration
+      TASK_TIERS = {
+        cheap: %i[
+          file_search spec_summary schema_lookup format_code
+          git_operations memory_retrieval context_summary
+          chatting explore
+        ].freeze,
+        mid: %i[
+          generate_specs simple_refactor code_review
+          documentation bug_fix
+        ].freeze,
+        top: %i[
+          architecture complex_refactor security_review
+          performance planning
+        ].freeze
+      }.freeze
+
+      # Hardcoded fallbacks when no config override exists.
+      TIER_DEFAULTS = {
+        cheap: [
+          %w[anthropic claude-haiku-4-5],
+          %w[openai gpt-5.4-nano]
+        ].freeze,
+        mid: [
+          %w[anthropic claude-sonnet-4-6],
+          %w[openai gpt-5.4-mini]
+        ].freeze,
+        top: [
+          %w[anthropic claude-opus-4-6],
+          %w[openai gpt-5.4]
+        ].freeze
+      }.freeze
+
+      COST_MULTIPLIERS = { cheap: 0.07, mid: 0.20, top: 1.0 }.freeze
+      DEFAULT_COST_MULTIPLIER = 0.20
+      MESSAGE_PATTERNS = [
+        [/\b(architect|design|restructure|multi.?file)\b/, :architecture],
+        [/\b(security|vulnerab|audit|owasp)\b/,           :security_review],
+        [/\b(n\+1|performance|slow|optimize|query)\b/,    :performance],
+        [/\b(spec|test|rspec)\b/,                         :generate_specs],
+        [/\b(fix|bug|error|broken)\b/,                    :bug_fix],
+        [/\b(refactor|extract|rename|move)\b/,            :simple_refactor],
+        [/\b(find|where|search|locate)\b/,                :file_search],
+        [/\b(doc|readme|comment|explain)\b/,              :documentation]
+      ].freeze
+
+      class << self
+        # Determine the appropriate model tier for a task.
+        def tier_for(task_type)
+          TASK_TIERS.each do |tier, tasks|
+            return tier if tasks.include?(task_type.to_sym)
+          end
+          :mid
+        end
+
+        # Resolve the best [provider, model] pair for a task type.
+        # Checks per-provider config overrides first, then falls back
+        # to TIER_DEFAULTS.
+        #
+        # @param task_type [Symbol]
+        # @param client [LLM::Client, nil] active client (for provider checks)
+        # @return [Hash] { provider:, model: }
+        def resolve(task_type, client: nil) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity -- multi-source fallback chain
+          tier = tier_for(task_type)
+          active = active_provider
+
+          # 1. Config overrides — prefer the active provider's config
+          configured = config_tier_models(tier)
+          active_cfg = configured.find { |p, _| p == active }
+          return pair_to_hash(active_cfg) if active_cfg
+
+          # 2. Any other configured provider
+          configured.each do |pair|
+            return pair_to_hash(pair) if client.nil? || provider_available?(pair[0])
+          end
+
+          # 3. Hardcoded defaults — prefer the active provider
+          defaults = TIER_DEFAULTS[tier]
+          active_default = defaults.find { |p, _| p == active }
+          return pair_to_hash(active_default) if active_default
+
+          # 4. Active provider not in defaults (e.g. minimax) — use their configured model for all tiers
+          return { provider: active, model: active_model } if provider_available?(active)
+
+          # 5. Any available default
+          defaults.each do |pair|
+            return pair_to_hash(pair) if client.nil? || provider_available?(pair[0])
+          end
+
+          pair_to_hash(defaults.first)
+        end
+
+        # Returns just the model name for a task type (backward-compatible).
+        # -- config + defaults search
+        def model_for(task_type, available_models: [])
+          tier = tier_for(task_type)
+          candidates = build_candidate_list(tier)
+
+          if available_models.any?
+            candidates.each do |pair|
+              return pair[1] if available_models.any? { |m| m.start_with?(pair[1]) }
+            end
+          end
+
+          candidates.first&.at(1) || TIER_DEFAULTS[tier].first[1]
+        end
+
+        # Detect task type from a user message and recent tool calls.
+        def detect_task(message, recent_tools: [])
+          detect_from_message(message) || detect_from_tools(recent_tools) || :chatting
+        end
+
+        # Returns cost estimate multiplier for a tier relative to top tier.
+        def cost_multiplier(tier)
+          COST_MULTIPLIERS.fetch(tier, DEFAULT_COST_MULTIPLIER)
+        end
+
+        private
+
+        def pair_to_hash(pair)
+          { provider: pair[0], model: pair[1] }
+        end
+
+        # Returns the user's active provider and model from config.
+        def active_provider
+          Config::Settings.new.provider
+        rescue StandardError
+          Config::Defaults::DEFAULT_PROVIDER
+        end
+
+        def active_model
+          Config::Settings.new.model
+        rescue StandardError
+          Config::Defaults::DEFAULT_MODEL
+        end
+
+        # Builds an ordered candidate list: active provider first, then others.
+        # If the active provider isn't in TIER_DEFAULTS or config, the user's
+        # configured model is used as a catch-all for every tier.
+        def build_candidate_list(tier)
+          active = active_provider
+          configured = config_tier_models(tier)
+          defaults = TIER_DEFAULTS[tier]
+          all = configured + defaults.to_a
+
+          # Sort: active provider's entries first, then the rest
+          active_entries, others = all.partition { |p, _| p == active }
+          result = (active_entries + others).uniq { |_, m| m }
+
+          # If the active provider has no entries at all, add the user's
+          # configured model as a fallback so unknown providers still work
+          result.unshift([active, active_model]) if result.none? { |p, _| p == active }
+
+          result
+        end
+
+        # Read per-provider model tier overrides from config.yml.
+        # Returns array of [provider, model] pairs for the given tier.
+        # -- config traversal
+        def config_tier_models(tier)
+          settings = Config::Settings.new
+          providers = settings.to_h['providers']
+          return [] unless providers.is_a?(Hash)
+
+          tier_key = tier.to_s
+          results = []
+
+          providers.each do |provider_name, cfg|
+            next unless cfg.is_a?(Hash)
+
+            models = cfg['models']
+            next unless models.is_a?(Hash) && models[tier_key]
+
+            results << [provider_name, models[tier_key]]
+          end
+
+          results
+        rescue StandardError
+          []
+        end
+
+        def provider_available?(provider)
+          return true if %w[anthropic openai].include?(provider)
+
+          settings = Config::Settings.new
+          !settings.provider_config(provider).nil?
+        rescue StandardError
+          false
+        end
+
+        def detect_from_message(message)
+          msg = message.to_s.downcase
+          MESSAGE_PATTERNS.each do |pattern, task_type|
+            return task_type if msg.match?(pattern)
+          end
+          nil
+        end
+
+        def detect_from_tools(recent_tools)
+          return nil if recent_tools.empty?
+
+          last = recent_tools.last.to_s
+          case last
+          when 'grep', 'glob' then :file_search
+          when 'run_specs'           then :generate_specs
+          when 'review_pr'           then :code_review
+          when 'git_status', 'git_log', 'git_diff', 'git_commit' then :git_operations
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/llm/streaming.rb

@@ -2,232 +2,9 @@
 
 module RubynCode
   module LLM
-    class Streaming
-      class ParseError < RubynCode::Error
-      end
-
-      class OverloadError < RubynCode::Error
-      end
-
-      Event = Data.define(:type, :data)
-
-      def initialize(&block)
-        @callback = block
-        @buffer = +''
-        @response_id = nil
-        @content_blocks = []
-        @current_block_index = nil
-        @current_text = +''
-        @current_tool_input_json = +''
-        @stop_reason = nil
-        @usage = nil
-      end
-
-      # Feed raw SSE data chunk from the HTTP response body.
-      def feed(chunk)
-        @buffer << chunk
-        consume_events
-      end
-
-      # Returns the fully assembled Response once the stream completes.
-      def finalize
-        Response.new(
-          id: @response_id,
-          content: build_content_blocks,
-          stop_reason: @stop_reason,
-          usage: @usage
-        )
-      end
-
-      private
-
-      def consume_events
-        while (idx = @buffer.index("\n\n"))
-          raw_event = @buffer.slice!(0..(idx + 1))
-          parse_sse(raw_event)
-        end
-      end
-
-      def parse_sse(raw)
-        event_type = nil
-        data_lines = []
-
-        raw.each_line do |line|
-          line = line.chomp
-          case line
-          when /\Aevent:\s*(.+)/
-            event_type = ::Regexp.last_match(1).strip
-          when /\Adata:\s*(.*)/
-            data_lines << ::Regexp.last_match(1)
-          end
-        end
-
-        return if data_lines.empty? && event_type.nil?
-
-        data_str = data_lines.join("\n")
-        data = data_str.empty? ? {} : parse_json(data_str)
-
-        dispatch(event_type, data)
-      end
-
-      def dispatch(event_type, data)
-        case event_type
-        when 'message_start'
-          handle_message_start(data)
-        when 'content_block_start'
-          handle_content_block_start(data)
-        when 'content_block_delta'
-          handle_content_block_delta(data)
-        when 'content_block_stop'
-          handle_content_block_stop(data)
-        when 'message_delta'
-          handle_message_delta(data)
-        when 'message_stop'
-          handle_message_stop
-        when 'ping'
-          # ignore
-        when 'error'
-          handle_error(data)
-        end
-      end
-
-      def handle_message_start(data)
-        message = data['message'] || data
-        @response_id = message['id']
-
-        if (u = message['usage'])
-          @usage = Usage.new(
-            input_tokens: u['input_tokens'].to_i,
-            output_tokens: u['output_tokens'].to_i,
-            cache_creation_input_tokens: u['cache_creation_input_tokens'].to_i,
-            cache_read_input_tokens: u['cache_read_input_tokens'].to_i
-          )
-        end
-
-        emit(:message_start, data)
-      end
-
-      def handle_content_block_start(data)
-        @current_block_index = data['index']
-        block = data['content_block'] || {}
-
-        case block['type']
-        when 'text'
-          @current_text = +(block['text'] || '')
-        when 'tool_use'
-          @current_tool_id = block['id']
-          @current_tool_name = block['name']
-          @current_tool_input_json = +''
-        end
-
-        emit(:content_block_start, data)
-      end
-
-      def handle_content_block_delta(data)
-        delta = data['delta'] || {}
-
-        case delta['type']
-        when 'text_delta'
-          text = delta['text'] || ''
-          @current_text << text
-          emit(:text_delta, { index: data['index'], text: text })
-        when 'input_json_delta'
-          json_chunk = delta['partial_json'] || ''
-          @current_tool_input_json << json_chunk
-          emit(:input_json_delta, { index: data['index'], partial_json: json_chunk })
-        end
-
-        emit(:content_block_delta, data)
-      end
-
-      def handle_content_block_stop(data)
-        index = data['index'].to_i
-
-        if @current_tool_id
-          input = parse_json(@current_tool_input_json)
-          @content_blocks[index] = ToolUseBlock.new(
-            id: @current_tool_id,
-            name: @current_tool_name,
-            input: input || {}
-          )
-          @current_tool_id = nil
-          @current_tool_name = nil
-          @current_tool_input_json = +''
-        else
-          @content_blocks[index] = TextBlock.new(text: @current_text.dup)
-          @current_text = +''
-        end
-
-        emit(:content_block_stop, data)
-      end
-
-      def handle_message_delta(data)
-        delta = data['delta'] || {}
-        @stop_reason = delta['stop_reason'] if delta['stop_reason']
-
-        if (u = data['usage'])
-          @usage = Usage.new(
-            input_tokens: @usage&.input_tokens || 0,
-            output_tokens: u['output_tokens'].to_i,
-            cache_creation_input_tokens: @usage&.cache_creation_input_tokens || 0,
-            cache_read_input_tokens: @usage&.cache_read_input_tokens || 0
-          )
-        end
-
-        emit(:message_delta, data)
-      end
-
-      def handle_message_stop
-        flush_pending_block
-        emit(:message_stop, {})
-      end
-
-      def handle_error(data)
-        error = data['error'] || data
-        error_type = error['type'] || 'unknown'
-        message = error['message'] || 'Unknown streaming error'
-
-        raise OverloadError, message if error_type == 'overloaded_error'
-
-        raise ParseError, "Streaming error (#{error_type}): #{message}"
-      end
-
-      def emit(type, data)
-        @callback&.call(Event.new(type: type, data: data))
-      end
-
-      def flush_pending_block
-        return unless @current_block_index
-
-        if @current_tool_id
-          input = parse_json(@current_tool_input_json) || {}
-          @content_blocks[@current_block_index] = ToolUseBlock.new(
-            id: @current_tool_id,
-            name: @current_tool_name,
-            input: input
-          )
-          @current_tool_id = nil
-          @current_tool_name = nil
-          @current_tool_input_json = +''
-        elsif !@current_text.empty?
-          @content_blocks[@current_block_index] = TextBlock.new(text: @current_text.dup)
-          @current_text = +''
-        end
-
-        @current_block_index = nil
-      end
-
-      def build_content_blocks
-        @content_blocks.compact
-      end
-
-      def parse_json(str)
-        return nil if str.nil? || str.strip.empty?
-
-        JSON.parse(str)
-      rescue JSON::ParserError
-        nil
-      end
-    end
+    # Backward-compatibility shim.
+    # Delegates to Adapters::AnthropicStreaming so existing references
+    # to LLM::Streaming keep working during the migration.
+    Streaming = Adapters::AnthropicStreaming
   end
 end

data/lib/rubyn_code/mcp/client.rb

@@ -66,7 +66,7 @@ module RubynCode
       def disconnect!
         @transport.stop!
         @initialized = false
-        @tools_cache = nil
+        @tools = nil
       end
 
       # Returns whether the client is connected and the transport is alive.

data/lib/rubyn_code/mcp/config.rb

@@ -30,18 +30,8 @@ module RubynCode
           config_path = File.join(project_path, CONFIG_FILENAME)
           return [] unless File.exist?(config_path)
 
-          raw = File.read(config_path)
-          data = JSON.parse(raw)
-          servers = data['mcpServers'] || {}
-
-          servers.map do |name, server_def|
-            {
-              name: name,
-              command: server_def['command'],
-              args: Array(server_def['args']),
-              env: expand_env(server_def['env'] || {})
-            }
-          end
+          data = JSON.parse(File.read(config_path))
+          parse_servers(data['mcpServers'] || {})
         rescue JSON::ParserError => e
           warn "[MCP::Config] Failed to parse #{config_path}: #{e.message}"
           []
@@ -56,6 +46,13 @@ module RubynCode
         #
         # @param env_hash [Hash<String, String>] raw env key-value pairs
         # @return [Hash<String, String>] expanded env key-value pairs
+        def parse_servers(servers)
+          servers.map do |name, server_def|
+            { name: name, command: server_def['command'],
+              args: Array(server_def['args']), env: expand_env(server_def['env'] || {}) }
+          end
+        end
+
         def expand_env(env_hash)
           env_hash.each_with_object({}) do |(key, value), result|
             result[key] = expand_value(value)

data/lib/rubyn_code/mcp/sse_transport.rb

@@ -124,7 +124,9 @@ module RubynCode
           req.body = JSON.generate(request)
         end
 
-        raise TransportError, "MCP server returned HTTP #{response.status}: #{response.body}" unless response.success?
+        return if response.success?
+
+        raise TransportError, "MCP server returned HTTP #{response.status}: #{response.body}"
       rescue Faraday::Error => e
         raise TransportError, "Failed to send request to MCP server: #{e.message}"
       end
@@ -148,16 +150,10 @@ module RubynCode
       end
 
       def run_sse_listener
-        sse_connection = Faraday.new(url: base_url) do |f|
-          f.options.timeout = nil # Keep-alive
-          f.options.open_timeout = @timeout
-          f.headers['Accept'] = 'text/event-stream'
-          f.adapter Faraday.default_adapter
-        end
-
+        conn = build_sse_connection
         buffer = +''
 
-        sse_connection.get(@url) do |req|
+        conn.get(@url) do |req|
           req.options.on_data = proc do |chunk, _bytes, _env|
             buffer << chunk
             process_sse_buffer(buffer)
@@ -168,6 +164,15 @@ module RubynCode
         warn "[MCP::SSETransport] SSE connection lost: #{e.message}"
       end
 
+      def build_sse_connection
+        Faraday.new(url: base_url) do |f|
+          f.options.timeout = nil
+          f.options.open_timeout = @timeout
+          f.headers['Accept'] = 'text/event-stream'
+          f.adapter Faraday.default_adapter
+        end
+      end
+
       def process_sse_buffer(buffer)
         while (idx = buffer.index("\n\n"))
           raw_event = buffer.slice!(0, idx + 2)
@@ -195,11 +200,8 @@ module RubynCode
       end
 
       def handle_sse_event(event)
-        case event[:type]
-        when 'endpoint'
+        if event[:type] == 'endpoint'
           @post_endpoint = event[:data]
-        when 'message'
-          dispatch_message(event[:data])
         else
           dispatch_message(event[:data])
         end

data/lib/rubyn_code/mcp/stdio_transport.rb

@@ -140,29 +140,27 @@ module RubynCode
       def read_response(expected_id)
         Timeout.timeout(@timeout, TimeoutError, "MCP server did not respond within #{@timeout}s") do
           loop do
-            line = @stdout.gets
-            raise TransportError, 'MCP server closed stdout unexpectedly' if line.nil?
+            message = read_next_message
+            next unless message&.key?('id') && message['id'] == expected_id
 
-            line = line.strip
-            next if line.empty?
-
-            message = parse_json(line)
-            next unless message
+            raise_mcp_error(message['error']) if message.key?('error')
+            return message['result']
+          end
+        end
+      end
 
-            # Skip notifications (no id field)
-            next unless message.key?('id')
+      def read_next_message
+        line = @stdout.gets
+        raise TransportError, 'MCP server closed stdout unexpectedly' if line.nil?
 
-            # Skip responses for other requests
-            next unless message['id'] == expected_id
+        stripped = line.strip
+        return nil if stripped.empty?
 
-            if message.key?('error')
-              err = message['error']
-              raise TransportError, "MCP error (#{err['code']}): #{err['message']}"
-            end
+        parse_json(stripped)
+      end
 
-            return message['result']
-          end
-        end
+      def raise_mcp_error(err)
+        raise TransportError, "MCP error (#{err['code']}): #{err['message']}"
       end
 
       def parse_json(line)