ruby_coded 0.1.1

data/lib/ruby_coded/chat/llm_bridge/tool_call_handling.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class LLMBridge
+      # Handles tool call lifecycle: invocation, confirmation, limits, and results.
+      module ToolCallHandling
+        private
+
+        def configure_agentic!(chat)
+          tools = @tool_registry.build_tools
+          chat.with_tools(*tools, replace: true)
+          chat.with_instructions(Tools::SystemPrompt.build(
+                                   project_root: @project_root,
+                                   max_write_rounds: MAX_WRITE_TOOL_ROUNDS,
+                                   max_total_rounds: MAX_TOTAL_TOOL_ROUNDS
+                                 ))
+
+          chat.on_tool_call { |tool_call| handle_tool_call(tool_call) }
+          chat.on_tool_result { |result| handle_tool_result(result) }
+        end
+
+        def handle_tool_call(tool_call)
+          raise Tools::AgentCancelledError, "Operation cancelled by user" if @cancel_requested
+
+          display_name = short_tool_name(tool_call.name)
+          risk = @tool_registry.risk_level_for(tool_call.name)
+
+          increment_call_counts(risk)
+          check_tool_limits!
+          warn_approaching_limit
+
+          process_tool_approval(tool_call, display_name, risk)
+        end
+
+        def increment_call_counts(risk)
+          @tool_call_count += 1
+          @write_tool_call_count += 1 unless risk == Tools::BaseTool::SAFE_RISK
+        end
+
+        def process_tool_approval(tool_call, display_name, risk)
+          args_summary = tool_call.arguments.map { |k, v| "#{k}: #{v}" }.join(", ")
+
+          if risk == Tools::BaseTool::SAFE_RISK || @state.auto_approve_tools?
+            @state.add_message(:tool_call, "[#{display_name}] #{args_summary}")
+          else
+            risk_label = risk == Tools::BaseTool::DANGEROUS_RISK ? "DANGEROUS" : "WRITE"
+            @state.request_tool_confirmation!(display_name, tool_call.arguments, risk_label: risk_label)
+            wait_for_confirmation(tool_call)
+          end
+        end
+
+        def wait_for_confirmation(tool_call)
+          display_name = short_tool_name(tool_call.name)
+          decision = poll_tool_decision
+          apply_tool_decision(decision, display_name)
+        end
+
+        def apply_tool_decision(decision, display_name)
+          case decision
+          when :cancelled
+            @state.clear_tool_confirmation!
+            raise Tools::AgentCancelledError, "Operation cancelled by user"
+          when :approved
+            @state.resolve_tool_confirmation!(:approved)
+          when :rejected
+            @state.resolve_tool_confirmation!(:rejected)
+            raise RubyCoded::Tools::ToolRejectedError, "User rejected #{display_name}"
+          end
+        end
+
+        def poll_tool_decision
+          @state.mutex.synchronize do
+            loop do
+              return :cancelled if @cancel_requested
+
+              case @state.instance_variable_get(:@tool_confirmation_response)
+              when :approved then return :approved
+              when :rejected then return :rejected
+              end
+
+              @state.tool_cv.wait(@state.mutex, 0.1)
+            end
+          end
+        end
+
+        def handle_tool_result(result)
+          text = result.to_s
+          if text.length > MAX_TOOL_RESULT_CHARS
+            text = "#{text[0, MAX_TOOL_RESULT_CHARS]}\n... (truncated, #{text.length} total characters)"
+          end
+          @state.add_message(:tool_result, text)
+        end
+
+        def check_tool_limits!
+          if @write_tool_call_count >= MAX_WRITE_TOOL_ROUNDS
+            @write_tool_call_count = 0
+            @state.add_message(:system,
+                               "Write tool call budget (#{MAX_WRITE_TOOL_ROUNDS}) reached — auto-resetting counter.")
+          end
+
+          return unless @tool_call_count > MAX_TOTAL_TOOL_ROUNDS
+
+          raise Tools::AgentIterationLimitError,
+                "Reached maximum of #{MAX_TOTAL_TOOL_ROUNDS} total tool calls. " \
+                "Send a new message to continue, or use /agent on to reset counters."
+        end
+
+        def warn_approaching_limit
+          warn_limit(@tool_call_count, MAX_TOTAL_TOOL_ROUNDS, "total")
+        end
+
+        def warn_limit(count, max, label)
+          warning_at = (max * TOOL_ROUNDS_WARNING_THRESHOLD).to_i
+          return unless count == warning_at
+
+          remaining = max - count
+          @state.add_message(:system,
+                             "Approaching #{label} tool call limit: #{remaining} calls remaining. " \
+                             "Prioritize completing the most important work.")
+        end
+
+        def short_tool_name(name)
+          name.split("--").last
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/llm_bridge.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "ruby_llm"
+require_relative "../tools/registry"
+require_relative "../tools/system_prompt"
+require_relative "../tools/plan_system_prompt"
+require_relative "../tools/agent_cancelled_error"
+require_relative "../tools/agent_iteration_limit_error"
+require_relative "plan_clarification_parser"
+require_relative "llm_bridge/tool_call_handling"
+require_relative "llm_bridge/streaming_retries"
+require_relative "llm_bridge/plan_mode"
+
+module RubyCoded
+  module Chat
+    # Sends prompts to RubyLLM and streams assistant output into State.
+    class LLMBridge
+      include ToolCallHandling
+      include StreamingRetries
+      include PlanMode
+
+      MAX_RATE_LIMIT_RETRIES = 2
+      RATE_LIMIT_BASE_DELAY = 2
+      MAX_WRITE_TOOL_ROUNDS = 50
+      MAX_TOTAL_TOOL_ROUNDS = 200
+      TOOL_ROUNDS_WARNING_THRESHOLD = 0.8
+      MAX_TOOL_RESULT_CHARS = 10_000
+
+      attr_reader :agentic_mode, :plan_mode, :project_root
+
+      def initialize(state, project_root: Dir.pwd)
+        @state = state
+        @chat_mutex = Mutex.new
+        @cancel_requested = false
+        @project_root = project_root
+        @agentic_mode = false
+        @plan_mode = false
+        @tool_registry = Tools::Registry.new(project_root: @project_root)
+        reset_chat!(@state.model)
+      end
+
+      def reset_chat!(model_name)
+        @chat_mutex.synchronize do
+          @chat = RubyLLM.chat(model: model_name)
+          apply_mode_config!(@chat)
+        end
+      end
+
+      def toggle_agentic_mode!(enabled)
+        @agentic_mode = enabled
+        @state.agentic_mode = enabled
+        if enabled && @plan_mode
+          @plan_mode = false
+          @state.deactivate_plan_mode!
+        end
+        @state.disable_auto_approve! unless enabled
+        reconfigure_chat!
+      end
+
+      def reset_agent_session!
+        @tool_call_count = 0
+        @write_tool_call_count = 0
+        reset_chat!(@state.model)
+      end
+
+      def toggle_plan_mode!(enabled)
+        @plan_mode = enabled
+        if enabled && @agentic_mode
+          @agentic_mode = false
+          @state.agentic_mode = false
+          @state.disable_auto_approve!
+        end
+        reconfigure_chat!
+      end
+
+      def send_async(input)
+        auto_switch_to_agent! if should_auto_switch_to_agent?(input)
+        reset_call_counts
+        chat = prepare_streaming
+        Thread.new do
+          response = attempt_with_retries(chat, input)
+          update_response_tokens(response)
+          post_process_plan_response if @plan_mode && !@cancel_requested
+        ensure
+          @state.streaming = false
+        end
+      end
+
+      def cancel!
+        @cancel_requested = true
+        @state.mutex.synchronize { @state.tool_cv.signal }
+      end
+
+      def approve_tool!
+        @state.tool_confirmation_response = :approved
+      end
+
+      def approve_all_tools!
+        @state.enable_auto_approve!
+        @state.tool_confirmation_response = :approved
+      end
+
+      def reject_tool!
+        @state.tool_confirmation_response = :rejected
+      end
+
+      private
+
+      def reset_call_counts
+        @tool_call_count = 0
+        @write_tool_call_count = 0
+      end
+
+      def reconfigure_chat!
+        @chat_mutex.synchronize do
+          apply_mode_config!(@chat)
+        end
+      end
+
+      def apply_mode_config!(chat)
+        if @agentic_mode
+          configure_agentic!(chat)
+        elsif @plan_mode
+          configure_plan!(chat)
+        else
+          chat.with_tools(replace: true)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/model_filter.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    # Filters deprecated and obsolete models from the selector list.
+    # Uses a multi-layered approach: known deprecated patterns,
+    # age-based filtering, and latest-alias deduplication.
+    module ModelFilter
+      DEPRECATED_PATTERNS = [
+        /\Agpt-3\.5-turbo/,
+        /\Agpt-4-\d{4}/,
+        /\Agpt-4-turbo/,
+        /\Agpt-4\z/,
+        /\Atext-davinci/,
+        /\Ababbage/,
+        /\Acurie/,
+        /\Aada\b/,
+        /\Adavinci/,
+        /\Aclaude-instant/,
+        /\Aclaude-2/,
+        /\Aclaude-3-haiku-2024/,
+        /\Ao1-preview/,
+        /\Ao1-mini/
+      ].freeze
+
+      MAX_AGE_SECONDS = 18 * 30 * 24 * 3600
+
+      module_function
+
+      def filter(models)
+        models = reject_deprecated_patterns(models)
+        models = reject_stale(models)
+        deduplicate_latest_aliases(models)
+      end
+
+      def reject_deprecated_patterns(models)
+        models.reject do |m|
+          id = model_id(m)
+          DEPRECATED_PATTERNS.any? { |pattern| id.match?(pattern) }
+        end
+      end
+
+      def reject_stale(models)
+        cutoff = Time.now - MAX_AGE_SECONDS
+        models.select do |m|
+          created = model_created_at(m)
+          next true unless created
+
+          id = model_id(m)
+          id.include?("latest") || created >= cutoff
+        end
+      end
+
+      def deduplicate_latest_aliases(models)
+        latest_families = collect_latest_families(models)
+        return models if latest_families.empty?
+
+        reject_dated_snapshots(models, latest_families)
+      end
+
+      def collect_latest_families(models)
+        families = Set.new
+        models.each do |m|
+          id = model_id(m)
+          next unless id.end_with?("-latest")
+
+          family = model_family(m)
+          families.add("#{model_provider(m)}:#{family}") if family && !family.empty?
+        end
+        families
+      end
+
+      def reject_dated_snapshots(models, latest_families)
+        models.reject do |m|
+          id = model_id(m)
+          next false if id.end_with?("-latest")
+
+          family = model_family(m)
+          next false unless family && !family.empty?
+
+          key = "#{model_provider(m)}:#{family}"
+          next false unless latest_families.include?(key)
+
+          snapshot_with_date?(id)
+        end
+      end
+
+      def model_id(model)
+        model.respond_to?(:id) ? model.id.to_s : model.to_s
+      end
+
+      def model_created_at(model)
+        model.respond_to?(:created_at) ? model.created_at : nil
+      end
+
+      def model_family(model)
+        model.respond_to?(:family) ? model.family.to_s : ""
+      end
+
+      def model_provider(model)
+        model.respond_to?(:provider) ? model.provider.to_s : "unknown"
+      end
+
+      def snapshot_with_date?(id)
+        id.match?(/\d{4}[-_]?\d{2}[-_]?\d{2}/)
+      end
+
+      private_class_method :reject_deprecated_patterns, :reject_stale,
+                           :deduplicate_latest_aliases, :collect_latest_families,
+                           :reject_dated_snapshots, :model_id,
+                           :model_created_at, :model_family,
+                           :model_provider, :snapshot_with_date?
+    end
+  end
+end

data/lib/ruby_coded/chat/plan_clarification_parser.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    # Parses <clarification> tags from LLM responses in plan mode.
+    # Extracts a single question and its options for the UI.
+    module PlanClarificationParser
+      CLARIFICATION_REGEX = %r{<clarification>\s*(.*?)\s*</clarification>}m
+      QUESTION_REGEX = %r{<question>\s*(.*?)\s*</question>}m
+      OPTION_REGEX = %r{<option>\s*(.*?)\s*</option>}m
+
+      def self.clarification?(content)
+        CLARIFICATION_REGEX.match?(content)
+      end
+
+      # Returns { question: String, options: [String], preamble: String }
+      # or nil if no clarification tags are found.
+      def self.parse(content)
+        match = CLARIFICATION_REGEX.match(content)
+        return nil unless match
+
+        inner = match[1]
+        question = QUESTION_REGEX.match(inner)&.[](1)&.strip
+        options = inner.scan(OPTION_REGEX).flatten.map(&:strip)
+
+        return nil unless question && options.size >= 2
+
+        preamble = content[0...match.begin(0)].strip
+
+        { question: question, options: options, preamble: preamble }
+      end
+
+      def self.strip_clarification(content)
+        content.sub(CLARIFICATION_REGEX, "").strip
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/renderer/chat_panel.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "unicode/display_width"
+
+module RubyCoded
+  module Chat
+    class Renderer
+      # Core chat-panel rendering: message formatting, scroll management,
+      # and the main chat display area.
+      module ChatPanel
+        private
+
+        def init_render_cache
+          @cached_formatted_text = nil
+          @cached_format_gen = -1
+        end
+
+        def cached_formatted_text(messages)
+          gen = @state.message_generation
+          if gen != @cached_format_gen
+            @cached_formatted_text = format_messages_text(messages)
+            @cached_format_gen = gen
+          end
+          @cached_formatted_text
+        end
+
+        def render_chat_panel(frame, area)
+          init_render_cache if @cached_format_gen.nil?
+          messages = @state.messages_snapshot
+
+          if @state.streaming? && thinking_in_progress?(messages)
+            render_chat_with_thinking(frame, area, messages)
+          else
+            render_chat_standard(frame, area, messages)
+          end
+        end
+
+        def render_chat_standard(frame, area, messages)
+          text = messages.empty? ? cover_banner : cached_formatted_text(messages)
+          render_text_panel(frame, area, text, !messages.empty?)
+        end
+
+        def render_messages_in_area(frame, area, messages)
+          text = messages.empty? ? cover_banner : format_messages_text(messages)
+          render_text_panel(frame, area, text, !messages.empty?)
+        end
+
+        def render_text_panel(frame, area, text, scrollable)
+          scroll_y = scrollable ? chat_scroll_y(area, text) : 0
+
+          widget = @tui.paragraph(
+            text: text,
+            wrap: scrollable,
+            scroll: [scroll_y, 0],
+            block: @tui.block(title: chat_panel_title, borders: [:all])
+          )
+          frame.render_widget(widget, area)
+        end
+
+        def chat_scroll_y(area, text)
+          inner_height = [area.height - 2, 0].max
+          inner_width = [area.width - 2, 0].max
+          total_lines = count_wrapped_lines(text, inner_width)
+          @state.update_scroll_metrics(total_lines: total_lines, visible_height: inner_height)
+          compute_scroll_y(total_lines, inner_height)
+        end
+
+        def chat_panel_title
+          title = @state.model.to_s
+          title += " [agent]" if agent_mode_active?
+          title += " [plan]" if @state.respond_to?(:plan_mode_active?) && @state.plan_mode_active?
+          title
+        end
+
+        def agent_mode_active?
+          @state.respond_to?(:agentic_mode?) && @state.agentic_mode?
+        end
+
+        def chat_panel_text
+          messages = @state.messages_snapshot
+          messages.empty? ? cover_banner : cached_formatted_text(messages)
+        end
+
+        def format_messages_text(messages)
+          messages.filter_map { |m| format_message(m) }.join("\n")
+        end
+
+        def chat_messages_text
+          cached_formatted_text(@state.messages_snapshot)
+        end
+
+        def format_message(msg)
+          case msg[:role]
+          when :tool_call, :tool_pending, :tool_result then nil
+          when :system    then "--- #{msg[:content]}"
+          when :user      then "> #{msg[:content]}"
+          when :assistant then format_assistant_message(msg[:content])
+          else                 "#{msg[:role]}: #{msg[:content]}"
+          end
+        end
+
+        def format_assistant_message(content)
+          result = strip_think_tags(content)
+          result.empty? ? nil : result
+        end
+
+        def compute_scroll_y(total_lines, visible_height)
+          overflow = total_lines - visible_height
+          return 0 if overflow <= 0
+
+          [overflow - @state.scroll_offset, 0].max
+        end
+
+        def count_wrapped_lines(text, width)
+          return 1 if width <= 0 || text.empty?
+
+          text.split("\n", -1).sum do |line|
+            line.empty? ? 1 : (display_width(line).to_f / width).ceil
+          end
+        end
+
+        def display_width(line)
+          Unicode::DisplayWidth.of(line)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/renderer/chat_panel_input.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "../../initializer/cover"
+
+module RubyCoded
+  module Chat
+    class Renderer
+      # Renders the input prompt panel and cursor at the bottom of the chat UI.
+      module ChatPanelInput
+        INPUT_PREFIX = "ruby_coded> "
+
+        private
+
+        def render_input_panel(frame, area)
+          prefix_len, offset, text = prepare_input_text(area)
+
+          widget = @tui.paragraph(
+            text: text,
+            block: @tui.block(borders: [:all])
+          )
+          frame.render_widget(widget, area)
+          render_input_cursor(frame, area, prefix_len, offset) unless input_locked?
+        end
+
+        def prepare_input_text(area)
+          inner_width = [area.width - 2, 0].max
+          prefix_len = INPUT_PREFIX.length
+          text_visible_width = [inner_width - prefix_len, 0].max
+
+          @state.update_input_visible_width(text_visible_width)
+          @state.update_input_scroll_offset
+
+          offset = @state.input_scroll_offset
+          visible_slice = @state.input_buffer[offset, text_visible_width] || ""
+          display_prefix = offset.positive? ? "…#{INPUT_PREFIX[1..]}" : INPUT_PREFIX
+
+          [prefix_len, offset, "#{display_prefix}#{visible_slice}"]
+        end
+
+        def input_locked?
+          @state.streaming? || @state.model_select? || @state.plan_clarification?
+        end
+
+        def render_input_cursor(frame, area, prefix_len, scroll_offset)
+          cursor_x = area.x + 1 + prefix_len + (@state.cursor_position - scroll_offset)
+          cursor_y = area.y + 1
+          frame.set_cursor_position(cursor_x, cursor_y)
+        end
+
+        def cover_banner
+          Initializer::Cover::BANNER.sub("%<version>s", RubyCoded::VERSION)
+        end
+      end
+    end
+  end
+end