rubyn-code 0.2.2 → 0.4.0

data/lib/rubyn_code/agent/dynamic_tool_schema.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Agent
+    # Filters tool schemas sent to the LLM based on detected task context.
+    # Instead of sending all 28+ tool schemas on every call, only include
+    # tools relevant to the current task. This reduces per-turn system
+    # prompt overhead by 30-50%.
+    module DynamicToolSchema
+      BASE_TOOLS = %w[
+        read_file write_file edit_file glob grep bash
+      ].freeze
+
+      TASK_TOOLS = {
+        testing: %w[run_specs].freeze,
+        git: %w[git_status git_diff git_log git_commit].freeze,
+        review: %w[review_pr git_diff].freeze,
+        explore: %w[spawn_agent].freeze,
+        web: %w[web_search web_fetch].freeze,
+        memory: %w[memory_search memory_write].freeze,
+        skills: %w[load_skill].freeze,
+        tasks: %w[task].freeze,
+        teams: %w[spawn_teammate send_message read_inbox].freeze,
+        rails: %w[rails_generate db_migrate bundle_install bundle_add].freeze,
+        background: %w[background_run].freeze,
+        interaction: %w[ask_user compact].freeze
+      }.freeze
+
+      class << self
+        # Returns tool names relevant to the detected task context.
+        #
+        # @param task_context [Symbol, nil] detected task type
+        # @param discovered_tools [Set<String>] tools already discovered this session
+        # @param codebase_index [RubynCode::Index::CodebaseIndex, nil] optional index for deeper context detection
+        # @param message [String, nil] original user message for index-based matching
+        # @return [Array<String>] tool names to include in the schema
+        def active_tools(task_context: nil, discovered_tools: Set.new, codebase_index: nil, message: nil)
+          tools = BASE_TOOLS.dup
+
+          # Always include interaction tools
+          tools.concat(TASK_TOOLS[:interaction])
+          tools.concat(TASK_TOOLS[:memory])
+
+          # Add task-specific tools
+          if task_context
+            context_tools = resolve_context_tools(task_context)
+            tools.concat(context_tools)
+          end
+
+          # Add index-aware tools when a codebase index and message are available
+          if codebase_index && message
+            index_contexts = detect_index_contexts(message, codebase_index)
+            index_contexts.each { |ctx| tools.concat(resolve_context_tools(ctx)) }
+          end
+
+          # Always include previously discovered tools
+          tools.concat(discovered_tools.to_a)
+
+          tools.uniq
+        end
+
+        # Detect task context from a user message.
+        #
+        # @param message [String]
+        # @param codebase_index [RubynCode::Index::CodebaseIndex, nil] optional index for deeper detection
+        # @return [Symbol, nil]
+        def detect_context(message, codebase_index: nil) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity -- context detection dispatch
+          msg = message.to_s.downcase
+          return :testing if msg.match?(/\b(test|spec|rspec)\b/)
+          return :git     if msg.match?(/\b(commit|push|diff|branch|merge|git)\b/)
+          return :review  if msg.match?(/\b(review|pr|pull request)\b/)
+          return :rails   if msg.match?(/\b(migrate|generate|scaffold|rails)\b/)
+          return :web     if msg.match?(/\b(search|fetch|url|http|api)\b/)
+          return :explore if msg.match?(/\b(explore|architecture|structure)\b/)
+          return :teams   if msg.match?(/\b(team|spawn|message|inbox)\b/)
+
+          # Fall back to index-based detection when keyword matching yields nothing
+          return nil unless codebase_index
+
+          index_contexts = detect_index_contexts(message, codebase_index)
+          index_contexts.first
+        end
+
+        # Detect additional tool contexts based on codebase index content.
+        #
+        # @param message [String] user message
+        # @param codebase_index [RubynCode::Index::CodebaseIndex] codebase index instance
+        # @return [Array<Symbol>] detected context symbols
+        def detect_index_contexts(message, codebase_index)
+          contexts = []
+          return contexts unless codebase_index
+
+          contexts << :rails if message_mentions_model?(message, codebase_index)
+          contexts << :testing if message_mentions_specced_file?(message, codebase_index)
+          contexts.uniq
+        rescue StandardError
+          []
+        end
+
+        # Filter full tool definitions to only include active tools.
+        #
+        # @param all_definitions [Array<Hash>] full tool schema list
+        # @param active_names [Array<String>] names of active tools
+        # @return [Array<Hash>] filtered definitions
+        def filter(all_definitions, active_names:)
+          name_set = active_names.to_set
+          all_definitions.select do |defn|
+            name = defn[:name] || defn['name']
+            name_set.include?(name)
+          end
+        end
+
+        private
+
+        def resolve_context_tools(context)
+          case context
+          when Symbol
+            TASK_TOOLS.fetch(context, [])
+          when Array
+            context.flat_map { |c| TASK_TOOLS.fetch(c, []) }
+          else
+            []
+          end
+        end
+
+        # Check if the user message mentions a model name from the index.
+        def message_mentions_model?(message, codebase_index)
+          model_names = codebase_index.nodes
+                                      .select { |n| n['type'] == 'model' }
+                                      .map { |n| n['name'] }
+          return false if model_names.empty?
+
+          msg_lower = message.to_s.downcase
+          model_names.any? { |name| msg_lower.include?(name.downcase) }
+        end
+
+        # Check if the user message mentions a file that has specs in the index.
+        def message_mentions_specced_file?(message, codebase_index)
+          spec_edges = codebase_index.edges.select { |e| e['relationship'] == 'tests' }
+          return false if spec_edges.empty?
+
+          tested_files = spec_edges.map { |e| e['to'] }.compact
+          msg_lower = message.to_s.downcase
+          tested_files.any? do |file|
+            basename = File.basename(file, '.rb')
+            msg_lower.include?(basename)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/agent/feedback_handler.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Agent
+    # Detects positive/negative user feedback and reinforces learned instincts.
+    module FeedbackHandler
+      POSITIVE_PATTERNS =
+        /\b(yes that fixed it|that worked|perfect|thanks|exactly|great|nailed it|that.s right|correct)\b/i
+      NEGATIVE_PATTERNS =
+        /\b(no[, ]+use|wrong|that.s not right|instead use|don.t do that|actually[, ]+use|incorrect)\b/i
+
+      private
+
+      def check_user_feedback(user_input)
+        return unless @project_root
+
+        recent_instincts = fetch_recent_instincts
+        return if recent_instincts.empty?
+
+        reinforce_instincts(user_input, recent_instincts)
+      rescue StandardError
+        # Non-critical; don't interrupt the conversation
+      end
+
+      def fetch_recent_instincts
+        db = DB::Connection.instance
+        db.query(
+          'SELECT id FROM instincts WHERE project_path = ? ORDER BY updated_at DESC LIMIT 5',
+          [@project_root]
+        ).to_a
+      end
+
+      def reinforce_instincts(user_input, recent_instincts)
+        if user_input.match?(POSITIVE_PATTERNS)
+          reinforce_top(recent_instincts, helpful: true)
+        elsif user_input.match?(NEGATIVE_PATTERNS)
+          reinforce_top(recent_instincts, helpful: false)
+        end
+      end
+
+      def reinforce_top(instincts, helpful:)
+        db = DB::Connection.instance
+        instincts.first(2).each do |row|
+          Learning::InstinctMethods.reinforce_in_db(row['id'], db, helpful: helpful)
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/agent/llm_caller.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Agent
+    # Handles LLM chat calls, option building, prompt-too-long recovery,
+    # and maintenance tasks (compaction, budget, stall detection).
+    module LlmCaller # rubocop:disable Metrics/ModuleLength -- LLM call pipeline with routing + recovery
+      private
+
+      def call_llm
+        @hook_runner.fire(:pre_llm_call, conversation: @conversation)
+
+        opts = build_llm_opts
+        log_llm_call(opts)
+        response = @llm_client.chat(**opts)
+
+        @hook_runner.fire(:post_llm_call, response: response, conversation: @conversation)
+        track_usage(response)
+        update_task_budget(response)
+        response
+      rescue LLM::Client::PromptTooLongError
+        recover_prompt_too_long(opts)
+      end
+
+      def build_llm_opts
+        opts = {
+          messages: @conversation.to_api_format,
+          tools: @plan_mode ? read_only_tool_definitions : tool_definitions,
+          system: build_system_prompt,
+          on_text: @on_text
+        }
+        opts[:max_tokens] = @max_tokens_override if @max_tokens_override
+        opts[:model] = routed_model
+        if @task_budget_remaining
+          opts[:task_budget] = {
+            total: UsageTracker::TASK_BUDGET_TOTAL, remaining: @task_budget_remaining
+          }
+        end
+        opts
+      end
+
+      # Uses ModelRouter to pick the right model for the current task.
+      # Only returns models from the active provider — never crosses
+      # provider boundaries (e.g., won't send a GPT model to Anthropic).
+      # Falls back to nil (use client's default) if routing fails.
+      def routed_model # rubocop:disable Metrics/CyclomaticComplexity -- guard clauses for provider/mode checks
+        return nil if manual_model_mode?
+
+        last_user = last_user_message_text
+        return nil unless last_user
+
+        recent = @stall_detector.respond_to?(:recent_tools) ? @stall_detector.recent_tools : []
+        task = LLM::ModelRouter.detect_task(last_user, recent_tools: recent)
+        resolved = LLM::ModelRouter.resolve(task, client: @llm_client)
+
+        # Only use the routed model if it's from the same provider
+        active = @llm_client.respond_to?(:provider_name) ? @llm_client.provider_name : nil
+        return nil if active && resolved[:provider] != active
+
+        resolved[:model]
+      rescue StandardError
+        nil
+      end
+
+      def manual_model_mode?
+        Config::Settings.new.get('model_mode', 'auto') == 'manual'
+      rescue StandardError
+        false
+      end
+
+      def last_user_message_text
+        msg = @conversation.messages.reverse_each.find { |m| m[:role] == 'user' }
+        return nil unless msg
+
+        content = msg[:content]
+        content.is_a?(String) ? content : nil
+      end
+
+      def log_llm_call(opts) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity -- safe accessor checks
+        default_model = @llm_client.respond_to?(:model) ? @llm_client.model : 'default'
+        routed = opts[:model]
+        effective = routed || default_model
+        provider = @llm_client.respond_to?(:provider_name) ? @llm_client.provider_name : 'unknown'
+        tool_count = opts[:tools]&.size || 0
+        routed_tag = routed && routed != default_model ? " (routed from #{default_model})" : ''
+        RubynCode::Debug.llm("chat provider=#{provider} model=#{effective}#{routed_tag} tools=#{tool_count}")
+      rescue StandardError
+        nil
+      end
+
+      def recover_prompt_too_long(opts)
+        RubynCode::Debug.recovery(
+          '413 prompt too long — running emergency compaction'
+        )
+        @context_manager.check_compaction!(@conversation)
+
+        response = @llm_client.chat(**opts, messages: @conversation.to_api_format)
+        @hook_runner.fire(
+          :post_llm_call, response: response, conversation: @conversation
+        )
+        track_usage(response)
+        response
+      end
+
+      # ── Maintenance ──────────────────────────────────────────────────
+
+      def run_maintenance(_iteration)
+        run_compaction
+        check_budget
+        check_stall_detection
+      end
+
+      def run_compaction
+        before = @conversation.length
+        est = @context_manager.estimated_tokens(@conversation.messages)
+        RubynCode::Debug.token(
+          "context=#{est} tokens (~#{before} messages, " \
+          "threshold=#{Config::Defaults::CONTEXT_THRESHOLD_TOKENS})"
+        )
+
+        @context_manager.check_compaction!(@conversation)
+        log_compaction(before, est)
+      rescue NoMethodError
+        # context_manager does not implement check_compaction! yet
+      end
+
+      def log_compaction(before, est)
+        after = @conversation.length
+        return unless after < before
+
+        new_est = @context_manager.estimated_tokens(@conversation.messages)
+        RubynCode::Debug.loop_tick(
+          "Compacted: #{before} -> #{after} messages " \
+          "(#{est} -> #{new_est} tokens)"
+        )
+      end
+
+      def check_budget
+        return unless @budget_enforcer
+
+        @budget_enforcer.check!
+      rescue BudgetExceededError
+        raise
+      rescue NoMethodError
+        # budget_enforcer does not implement check! yet
+      end
+
+      def check_stall_detection
+        return unless @stall_detector.stalled?
+
+        nudge = @stall_detector.nudge_message
+        @conversation.add_user_message(nudge)
+        @stall_detector.reset!
+      end
+    end
+  end
+end