ruby_coded 0.3.1 → 0.4.0

data/lib/ruby_coded/chat/llm_bridge.rb

@@ -6,36 +6,43 @@ 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 "../tools/execution_policy"
+require_relative "../skills"
 require_relative "plan_clarification_parser"
+require_relative "runtime_mode"
+require_relative "bridge_common"
+require_relative "prompt_builder"
 require_relative "llm_bridge/tool_call_handling"
 require_relative "llm_bridge/streaming_retries"
 require_relative "llm_bridge/plan_mode"
+require_relative "llm_bridge/chat_configuration"
 
 module RubyCoded
   module Chat
     # Sends prompts to RubyLLM and streams assistant output into State.
     class LLMBridge
+      include BridgeCommon
       include ToolCallHandling
       include StreamingRetries
       include PlanMode
+      include ChatConfiguration
 
       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_WRITE_TOOL_ROUNDS = Tools::ExecutionPolicy::MAX_WRITE_TOOL_ROUNDS
+      MAX_TOTAL_TOOL_ROUNDS = Tools::ExecutionPolicy::MAX_TOTAL_TOOL_ROUNDS
       MAX_TOOL_RESULT_CHARS = 10_000
 
-      attr_reader :agentic_mode, :plan_mode, :project_root
+      attr_reader :mode, :project_root
 
-      def initialize(state, project_root: Dir.pwd)
+      def initialize(state, project_root: Dir.pwd, skill_catalog: nil)
         @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)
+        @skill_catalog = skill_catalog || RubyCoded::Skills::Catalog.new(project_root: @project_root)
+        @mode = RuntimeMode.chat
+        setup_agent_pipeline!
         reset_chat!(@state.model)
       end
 
@@ -46,33 +53,11 @@ module RubyCoded
         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
+        @policy.reset_counters!
         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
@@ -80,51 +65,32 @@ module RubyCoded
         Thread.new do
           response = attempt_with_retries(chat, input)
           update_response_tokens(response)
-          post_process_plan_response if @plan_mode && !@cancel_requested
+          post_process_plan_response if @mode.plan? && !@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
+      def setup_agent_pipeline!
+        @tool_registry = Tools::Registry.new(project_root: @project_root)
+        @policy = Tools::ExecutionPolicy.new(state: @state, registry: @tool_registry)
+        @prompt_builder = PromptBuilder.new(
+          project_root: @project_root,
+          skill_catalog: @skill_catalog,
+          chat_base: :agentic
+        )
       end
 
-      def reconfigure_chat!
-        @chat_mutex.synchronize do
-          apply_mode_config!(@chat)
-        end
+      def reset_call_counts
+        @policy.reset_counters!
       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
+      # Called by BridgeCommon after any mode transition to
+      # re-apply tools/instructions on the RubyLLM chat.
+      def after_mode_change!
+        reconfigure_chat!
       end
     end
   end

data/lib/ruby_coded/chat/prompt_builder.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "../tools/system_prompt"
+require_relative "../tools/plan_system_prompt"
+require_relative "../tools/execution_policy"
+require_relative "../skills/prompt_formatter"
+
+module RubyCoded
+  module Chat
+    # Assembles the final system instruction set for a given RuntimeMode.
+    #
+    # Composes the base prompt (agent/plan/chat) with project skills
+    # for the same mode. Both LLMBridge and CodexBridge use this to
+    # keep prompt logic in a single place.
+    class PromptBuilder
+      DEFAULT_CHAT_INSTRUCTIONS = "You are a helpful coding assistant. " \
+                                  "Answer concisely and provide code examples when relevant."
+
+      MAX_WRITE_ROUNDS = Tools::ExecutionPolicy::MAX_WRITE_TOOL_ROUNDS
+      MAX_TOTAL_ROUNDS = Tools::ExecutionPolicy::MAX_TOTAL_TOOL_ROUNDS
+
+      # `chat_base`:
+      #   - `:agentic` — chat mode still uses the full agentic prompt
+      #     (matches LLMBridge, where tools may still be relevant),
+      #   - `:simple`  — chat mode uses a light default instruction
+      #     (matches the Codex Responses API).
+      def initialize(project_root:, skill_catalog:, chat_base: :agentic)
+        @project_root = project_root
+        @skill_catalog = skill_catalog
+        @chat_base = chat_base
+      end
+
+      def build(mode)
+        base = base_instructions(mode)
+        skills = @skill_catalog.relevant_skills_for(mode: mode.skill_mode)
+        Skills::PromptFormatter.append(base, skills)
+      end
+
+      private
+
+      def base_instructions(mode)
+        case mode.name
+        when :agent then agentic_prompt
+        when :plan then plan_prompt
+        else chat_prompt
+        end
+      end
+
+      def chat_prompt
+        @chat_base == :simple ? DEFAULT_CHAT_INSTRUCTIONS : agentic_prompt
+      end
+
+      def agentic_prompt
+        Tools::SystemPrompt.build(
+          project_root: @project_root,
+          max_write_rounds: MAX_WRITE_ROUNDS,
+          max_total_rounds: MAX_TOTAL_ROUNDS
+        )
+      end
+
+      def plan_prompt
+        Tools::PlanSystemPrompt.build(project_root: @project_root)
+      end
+    end
+  end
+end

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

@@ -1,28 +1,15 @@
 # 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.
+      # Core chat-panel rendering pipeline: widget composition, caching,
+      # and scroll-aware layout for the main chat display area.
       module ChatPanel
-        private
+        STICKY_HEADER_TITLE = "current prompt"
+        STICKY_HEADER_HEIGHT = 4
 
-        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
+        private
 
         def render_chat_panel(frame, area)
           init_render_cache if @cached_format_gen.nil?
@@ -36,20 +23,36 @@ module RubyCoded
         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?)
+          return render_text_panel(frame, area, cover_banner, false) if messages.empty?
+
+          sections = cached_chat_sections(messages)
+          sticky = sticky_header_for(area, sections)
+
+          if sticky
+            header_area, body_area = split_chat_sticky(area)
+            render_sticky_header(frame, header_area, sticky[:header_text], sticky[:header_rich_lines])
+            render_sections_panel(frame, body_area, sections)
+          else
+            render_sections_panel(frame, area, sections)
+          end
         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?)
+          return render_text_panel(frame, area, cover_banner, false) if messages.empty?
+
+          render_sections_panel(frame, area, build_chat_sections(messages))
         end
 
-        def render_text_panel(frame, area, text, scrollable)
-          scroll_y = scrollable ? chat_scroll_y(area, text) : 0
+        def render_sections_panel(frame, area, sections)
+          rich_lines = sections_to_rich_lines(sections)
+          render_text_panel(frame, area, rich_lines, true)
+        end
+
+        def render_text_panel(frame, area, text_or_lines, scrollable)
+          scroll_y = scrollable ? chat_scroll_y(area, text_or_lines) : 0
 
           widget = @tui.paragraph(
-            text: text,
+            text: text_or_lines,
             wrap: scrollable,
             scroll: [scroll_y, 0],
             block: @tui.block(title: chat_panel_title, borders: [:all])
@@ -57,10 +60,28 @@ module RubyCoded
           frame.render_widget(widget, area)
         end
 
-        def chat_scroll_y(area, text)
+        def render_sticky_header(frame, area, text, rich_lines = nil)
+          widget = @tui.paragraph(
+            text: rich_lines || text,
+            wrap: true,
+            scroll: [0, 0],
+            block: @tui.block(title: STICKY_HEADER_TITLE, borders: [:all])
+          )
+          frame.render_widget(widget, area)
+        end
+
+        def split_chat_sticky(area)
+          @tui.layout_split(
+            area,
+            direction: :vertical,
+            constraints: [@tui.constraint_length(STICKY_HEADER_HEIGHT), @tui.constraint_fill(1)]
+          )
+        end
+
+        def chat_scroll_y(area, text_or_lines)
           inner_height = [area.height - 2, 0].max
           inner_width = [area.width - 2, 0].max
-          total_lines = count_wrapped_lines(text, inner_width)
+          total_lines = count_wrapped_lines(text_or_lines, inner_width)
           @state.update_scroll_metrics(total_lines: total_lines, visible_height: inner_height)
           compute_scroll_y(total_lines, inner_height)
         end
@@ -81,47 +102,12 @@ module RubyCoded
           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

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class Renderer
+      # Generation-aware caching of built chat sections and their derived
+      # plain-text and rich-line representations.
+      module ChatPanelCache
+        private
+
+        def init_render_cache
+          @cached_chat_sections = nil
+          @cached_format_gen = -1
+        end
+
+        def cached_chat_sections(messages)
+          gen = @state.message_generation
+          if gen != @cached_format_gen
+            @cached_chat_sections = build_chat_sections(messages)
+            @cached_format_gen = gen
+          end
+          @cached_chat_sections
+        end
+
+        def cached_formatted_text(messages)
+          sections_to_text(cached_chat_sections(messages))
+        end
+
+        def cached_formatted_lines(messages)
+          sections_to_rich_lines(cached_chat_sections(messages))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class Renderer
+      # Message-to-text formatting helpers used by the chat panel.
+      module ChatPanelFormatting
+        USER_LABEL = "YOU"
+
+        private
+
+        def format_messages_text(messages)
+          messages.filter_map { |m| format_message_plain(m) }.join("\n")
+        end
+
+        def format_message_plain(msg)
+          plain = format_message_rich(msg)
+          return nil unless plain
+
+          rich_text_plain(plain)
+        end
+
+        def format_message(msg)
+          format_message_plain(msg)
+        end
+
+        def format_message_rich(msg)
+          case msg[:role]
+          when :tool_call, :tool_pending, :tool_result then nil
+          when :system    then format_system_message_rich(msg[:content])
+          when :user      then format_user_message_rich(msg[:content])
+          when :assistant then format_assistant_message_rich(msg[:content])
+          else                 rich_text_lines("#{msg[:role]}: #{msg[:content]}", role: :assistant)
+          end
+        end
+
+        def format_system_message_rich(content)
+          rich_text_lines("--- #{content}", role: :system)
+        end
+
+        def format_user_message(content)
+          rich_text_plain(format_user_message_rich(content))
+        end
+
+        def format_user_message_rich(content)
+          body_lines = rich_text_lines(content, role: :user)
+          return [user_label_line] if body_lines.empty?
+
+          [user_label_line(body_lines.first), *(body_lines[1..] || [])]
+        end
+
+        def user_label_line(first_line = nil)
+          label_span = @tui.span(content: "[#{USER_LABEL}]#{" " if first_line}", style: base_text_style(:user_label))
+          spans = first_line ? [label_span, *Array(first_line.spans)] : [label_span]
+          @tui.line(spans: spans)
+        end
+
+        def format_assistant_message(content)
+          result = strip_think_tags(content)
+          result.empty? ? nil : result
+        end
+
+        def format_assistant_message_rich(content)
+          result = strip_think_tags(content)
+          return nil if result.empty?
+
+          rich_text_lines(result, role: :assistant)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class Renderer
+      # Sticky-header computation and section layout helpers backing the
+      # chat panel's scroll-aware rendering.
+      module ChatPanelLayout
+        private
+
+        def sticky_header_for(area, sections)
+          return nil if sections.empty?
+          return nil if @state.scroll_offset <= 0
+
+          inner_width = [area.width - 2, 0].max
+          inner_height = [area.height - 2, 0].max
+          return nil if inner_width <= 0 || inner_height <= 0
+
+          layout = build_section_layout(sections, inner_width)
+          active = active_sticky_section(layout, inner_height)
+          return nil unless active
+
+          { header_text: active[:user_text], header_rich_lines: active[:user_rich_lines] }
+        end
+
+        def build_section_layout(sections, inner_width)
+          cursor = 0
+
+          sections.map do |section|
+            entry_layouts = section[:entries].map do |entry|
+              layout = layout_entry(entry, inner_width, cursor)
+              cursor = layout[:end_line] + 1
+              layout
+            end
+            section_layout(section, entry_layouts)
+          end
+        end
+
+        def layout_entry(entry, inner_width, start_line)
+          wrapped_lines = count_wrapped_lines(entry[:text], inner_width)
+          entry.merge(
+            wrapped_lines: wrapped_lines,
+            start_line: start_line,
+            end_line: start_line + wrapped_lines - 1
+          )
+        end
+
+        def section_layout(section, entry_layouts)
+          user_entry = entry_layouts.find { |entry| entry[:role] == :user }
+          {
+            user_text: section[:user_text],
+            user_rich_lines: section[:user_rich_lines],
+            entries: entry_layouts,
+            start_line: entry_layouts.first[:start_line],
+            end_line: entry_layouts.last[:end_line],
+            user_end_line: user_entry ? user_entry[:end_line] : nil
+          }
+        end
+
+        def active_sticky_section(layout, visible_height)
+          return nil if layout.empty?
+
+          total_lines = layout.last[:end_line] + 1
+          top_visible_line = compute_scroll_y(total_lines, visible_height)
+
+          layout.find do |section|
+            next false unless section[:user_text]
+            next false unless line_in_section?(top_visible_line, section)
+            next false if section[:user_end_line] && top_visible_line <= section[:user_end_line]
+
+            true
+          end
+        end
+
+        def line_in_section?(line_index, section)
+          line_index.between?(section[:start_line], section[:end_line])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "unicode/display_width"
+
+module RubyCoded
+  module Chat
+    class Renderer
+      # Section building, sticky-header computation, and line-measurement
+      # helpers backing the chat panel's scroll-aware rendering.
+      module ChatPanelSections
+        private
+
+        def build_chat_sections(messages)
+          sections = []
+          visible_index = 0
+
+          messages.each do |msg|
+            rich_lines = format_message_rich(msg)
+            next if rich_lines.nil?
+
+            append_section_entry(sections, msg, rich_lines, visible_index)
+            visible_index += 1
+          end
+
+          sections
+        end
+
+        def append_section_entry(sections, msg, rich_lines, visible_index)
+          plain_text = rich_text_plain(rich_lines)
+          section = next_section_for(sections, msg, plain_text, rich_lines)
+          section[:entries] << {
+            role: msg[:role],
+            text: plain_text,
+            rich_lines: rich_lines,
+            visible_index: visible_index
+          }
+        end
+
+        def next_section_for(sections, msg, text, rich_lines)
+          return sections.last if sections.any? && msg[:role] != :user
+
+          sections << {
+            user_text: msg[:role] == :user ? text : nil,
+            user_rich_lines: msg[:role] == :user ? rich_lines : nil,
+            entries: []
+          }
+          sections.last
+        end
+
+        def sections_to_text(sections)
+          sections.flat_map { |section| section[:entries].map { |entry| entry[:text] } }.join("\n")
+        end
+
+        def sections_to_rich_lines(sections)
+          sections.flat_map.with_index do |section, section_index|
+            lines = section[:entries].flat_map { |entry| Array(entry[:rich_lines]) }
+            section_index == sections.length - 1 ? lines : lines + [@tui.line(spans: [@tui.span(content: "")])]
+          end
+        end
+
+        def count_wrapped_lines(text_or_lines, width)
+          return 1 if width <= 0
+
+          if text_or_lines.is_a?(Array)
+            count_wrapped_rich_lines(text_or_lines, width)
+          else
+            count_wrapped_text_lines(text_or_lines.to_s, width)
+          end
+        end
+
+        def count_wrapped_rich_lines(lines, width)
+          return 1 if lines.empty?
+
+          lines.sum { |line| wrapped_line_count(rich_line_plain(line), width) }
+        end
+
+        def count_wrapped_text_lines(text, width)
+          return 1 if text.empty?
+
+          text.split("\n", -1).sum { |line| wrapped_line_count(line, width) }
+        end
+
+        def wrapped_line_count(line, width)
+          line.empty? ? 1 : (display_width(line).to_f / width).ceil
+        end
+
+        def display_width(line)
+          Unicode::DisplayWidth.of(line)
+        end
+      end
+    end
+  end
+end