ruby_coded 0.1.1

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class Renderer
+      # Thinking-panel detection, parsing, and rendering for agent
+      # response cycles that include tool activity or open <think> blocks.
+      module ChatPanelThinking
+        THINK_OPEN = "<think>"
+        THINK_CLOSE = "</think>"
+        TOOL_ROLES = %i[tool_call tool_pending tool_result].freeze
+        MAX_THINKING_MESSAGES = 20
+
+        private
+
+        def thinking_in_progress?(messages)
+          cycle = current_cycle_messages(messages)
+          return false if cycle.empty?
+
+          cycle.any? { |m| TOOL_ROLES.include?(m[:role]) } ||
+            cycle.any? { |m| m[:role] == :assistant && open_think_block?(m[:content]) }
+        end
+
+        def current_cycle_messages(messages)
+          last_user_idx = messages.rindex { |m| m[:role] == :user }
+          return messages unless last_user_idx
+
+          messages[(last_user_idx + 1)..]
+        end
+
+        def tail_of_cycle(cycle)
+          return cycle if cycle.length <= MAX_THINKING_MESSAGES
+
+          truncated = cycle.last(MAX_THINKING_MESSAGES)
+          omitted = cycle.length - MAX_THINKING_MESSAGES
+          header = { role: :system, content: "... #{omitted} earlier messages omitted ...", timestamp: Time.now,
+                     **RubyCoded::Chat::State::Messages::ZERO_TOKEN_USAGE }
+          [header] + truncated
+        end
+
+        def open_think_block?(content)
+          content.include?(THINK_OPEN) && !content.include?(THINK_CLOSE)
+        end
+
+        def parse_thinking_content(content)
+          think_start = content.index(THINK_OPEN)
+          return [nil, content, true] unless think_start
+
+          think_end = content.index(THINK_CLOSE)
+          if think_end
+            parse_closed_think_block(content, think_start, think_end)
+          else
+            thinking = content[(think_start + THINK_OPEN.length)..]
+            [thinking, content[0...think_start].strip, false]
+          end
+        end
+
+        def parse_closed_think_block(content, think_start, think_end)
+          thinking = content[(think_start + THINK_OPEN.length)...think_end]
+          before = content[0...think_start]
+          after = content[(think_end + THINK_CLOSE.length)..]
+          [thinking, (before + after).strip, true]
+        end
+
+        def strip_think_tags(content)
+          _, result, = parse_thinking_content(content)
+          result
+        end
+
+        def format_thinking_text(cycle_messages)
+          cycle_messages.map { |m| format_thinking_message(m) }.join("\n")
+        end
+
+        def format_thinking_message(msg)
+          case msg[:role]
+          when :assistant    then msg[:content].gsub(%r{</?think>}, "")
+          when :tool_call    then ">> #{msg[:content]}"
+          when :tool_pending then "?? #{msg[:content]}"
+          when :tool_result  then "   #{msg[:content]}"
+          when :system       then "--- #{msg[:content]}"
+          else                    msg[:content]
+          end
+        end
+
+        def render_chat_with_thinking(frame, area, messages)
+          full_cycle = current_cycle_messages(messages)
+          cycle = tail_of_cycle(full_cycle)
+          prior = messages[0...(messages.length - full_cycle.length)]
+          chat_area, thinking_area = split_chat_thinking(area)
+
+          render_messages_in_area(frame, chat_area, prior)
+          render_thinking_panel(frame, thinking_area, format_thinking_text(cycle))
+        end
+
+        def split_chat_thinking(area)
+          @tui.layout_split(
+            area,
+            direction: :vertical,
+            constraints: [@tui.constraint_fill(3), @tui.constraint_fill(2)]
+          )
+        end
+
+        def render_thinking_panel(frame, area, thinking_text)
+          scroll_y = thinking_scroll_y(area, thinking_text)
+
+          widget = @tui.paragraph(
+            text: thinking_text,
+            wrap: true,
+            scroll: [scroll_y, 0],
+            block: @tui.block(title: "thinking...", borders: [:all])
+          )
+          frame.render_widget(widget, area)
+        end
+
+        def thinking_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)
+          [total_lines - inner_height, 0].max
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class Renderer
+      # This module contains the logic for rendering the UI model selector component
+      module ModelSelector
+        private
+
+        def render_model_selector(frame, area)
+          popup_area = centered_popup(area)
+          frame.render_widget(@tui.clear, popup_area)
+
+          search_area, list_area = popup_layout(popup_area)
+          render_model_search(frame, search_area)
+          render_model_list(frame, list_area)
+        end
+
+        def popup_layout(popup_area)
+          @tui.layout_split(
+            popup_area,
+            direction: :vertical,
+            constraints: [
+              @tui.constraint_length(3),
+              @tui.constraint_fill(1)
+            ]
+          )
+        end
+
+        def render_model_search(frame, area)
+          widget = @tui.paragraph(
+            text: "Search: #{@state.model_select_filter}",
+            block: @tui.block(title: "↑↓ navigate, Enter select, Esc cancel", borders: [:all])
+          )
+          frame.render_widget(widget, area)
+        end
+
+        def render_model_list(frame, area)
+          filtered = @state.filtered_model_list
+          items = filtered.map { |m| model_display_label(m) }
+          widget = model_list_widget(items, filtered.size)
+          frame.render_widget(widget, area)
+        end
+
+        def model_list_widget(items, count)
+          title = @state.model_select_show_all? ? "All Models (#{count})" : "Models (#{count})"
+          @tui.list(
+            items: items,
+            selected_index: @state.model_select_index,
+            highlight_style: @tui.style(bg: :blue, fg: :white, modifiers: [:bold]),
+            highlight_symbol: "> ",
+            scroll_padding: 2,
+            block: @tui.block(title: title, borders: [:all])
+          )
+        end
+
+        def centered_popup(area)
+          vertical = centered_vertical(area)
+          centered_horizontal(vertical[1])
+        end
+
+        def centered_vertical(area)
+          @tui.layout_split(
+            area,
+            direction: :vertical,
+            constraints: [
+              @tui.constraint_percentage(15),
+              @tui.constraint_percentage(70),
+              @tui.constraint_percentage(15)
+            ]
+          )
+        end
+
+        def centered_horizontal(area)
+          horizontal = @tui.layout_split(
+            area,
+            direction: :horizontal,
+            constraints: [
+              @tui.constraint_percentage(20),
+              @tui.constraint_percentage(60),
+              @tui.constraint_percentage(20)
+            ]
+          )
+          horizontal[1]
+        end
+
+        def model_display_label(model)
+          id = model.respond_to?(:id) ? model.id : model.to_s
+          provider = model.respond_to?(:provider) ? model.provider : "unknown"
+          current_marker = id == @state.model ? " *" : ""
+          "#{id} (#{provider})#{current_marker}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class Renderer
+      # Renders a centered popup for plan clarification questions.
+      # The popup has three zones: question, options list, and free text input.
+      module PlanClarifier
+        private
+
+        def render_plan_clarifier(frame, area)
+          popup_area = clarifier_centered_popup(area)
+          frame.render_widget(@tui.clear, popup_area)
+
+          question_area, options_area, input_area = clarifier_layout(popup_area)
+          render_clarifier_question(frame, question_area)
+          render_clarifier_options(frame, options_area)
+          render_clarifier_input(frame, input_area)
+        end
+
+        def clarifier_layout(popup_area)
+          question_height = clarifier_question_height(popup_area.width)
+
+          @tui.layout_split(
+            popup_area,
+            direction: :vertical,
+            constraints: [
+              @tui.constraint_length(question_height),
+              @tui.constraint_fill(1),
+              @tui.constraint_length(3)
+            ]
+          )
+        end
+
+        def clarifier_question_height(popup_width)
+          question = @state.clarification_question || ""
+          inner_width = [popup_width - 2, 1].max
+          wrapped = (question.length.to_f / inner_width).ceil
+          [wrapped + 2, 4].max
+        end
+
+        def render_clarifier_question(frame, area)
+          question = @state.clarification_question || ""
+          widget = @tui.paragraph(
+            text: question,
+            wrap: true,
+            block: @tui.block(title: "Plan Clarification", borders: [:all])
+          )
+          frame.render_widget(widget, area)
+        end
+
+        def render_clarifier_options(frame, area)
+          options = @state.clarification_options
+
+          widget = @tui.list(
+            items: wrap_clarifier_items(options, [area.width - 4, 1].max),
+            selected_index: @state.clarification_index,
+            highlight_style: clarifier_highlight_style,
+            highlight_symbol: "> ",
+            scroll_padding: 1,
+            block: @tui.block(title: "Options (#{options.size})", borders: [:all])
+          )
+          frame.render_widget(widget, area)
+        end
+
+        def wrap_clarifier_items(options, width)
+          options.each_with_index.map do |opt, i|
+            clarifier_wrap_option("[#{i + 1}] #{opt}", width)
+          end
+        end
+
+        def clarifier_highlight_style
+          if @state.clarification_input_mode == :options
+            @tui.style(bg: :blue, fg: :white, modifiers: [:bold])
+          else
+            @tui.style(fg: :dark_gray)
+          end
+        end
+
+        def render_clarifier_input(frame, area)
+          active = @state.clarification_input_mode == :custom
+          hint = active ? "Enter: send | Tab: back to options" : "Tab: switch to free text | Esc: skip"
+          text = active ? ">> #{@state.clarification_custom_input}" : hint
+
+          widget = @tui.paragraph(
+            text: text,
+            wrap: true,
+            block: @tui.block(title: "Free response", borders: [:all])
+          )
+          frame.render_widget(widget, area)
+        end
+
+        # Wraps a single option string into multiple lines that fit the
+        # available width, preserving word boundaries when possible.
+        def clarifier_wrap_option(text, max_width)
+          return text if text.length <= max_width
+
+          lines = []
+          remaining = text
+          while remaining.length > max_width
+            break_at = remaining.rindex(" ", max_width) || max_width
+            lines << remaining[0...break_at]
+            remaining = remaining[break_at..].lstrip
+          end
+          lines << remaining unless remaining.empty?
+          lines.join("\n")
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class Renderer
+      # Layout helpers for centering the plan clarifier popup.
+      module PlanClarifierLayout
+        private
+
+        def clarifier_centered_popup(area)
+          vertical = clarifier_centered_vertical(area)
+          clarifier_centered_horizontal(vertical[1])
+        end
+
+        def clarifier_centered_vertical(area)
+          @tui.layout_split(
+            area,
+            direction: :vertical,
+            constraints: [
+              @tui.constraint_percentage(5),
+              @tui.constraint_percentage(90),
+              @tui.constraint_percentage(5)
+            ]
+          )
+        end
+
+        def clarifier_centered_horizontal(area)
+          horizontal = @tui.layout_split(
+            area,
+            direction: :horizontal,
+            constraints: [
+              @tui.constraint_percentage(5),
+              @tui.constraint_percentage(90),
+              @tui.constraint_percentage(5)
+            ]
+          )
+          horizontal[1]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class Renderer
+      # Renders a single-line status bar showing session token usage,
+      # current model, and estimated cost.
+      module StatusBar
+        private
+
+        def render_status_bar(frame, area)
+          widget = @tui.paragraph(text: status_bar_text(area.width))
+          frame.render_widget(widget, area)
+        end
+
+        def status_bar_text(width)
+          left = status_bar_left
+          right = "#{@state.model} | #{format_cost(@state.total_session_cost)} "
+          center_pad = [width - left.length - right.length, 1].max
+          "#{left}#{" " * center_pad}#{right}"
+        end
+
+        def status_bar_left
+          input_tok = @state.total_input_tokens
+          output_tok = @state.total_output_tokens
+          thinking_tok = @state.total_thinking_tokens
+          total_tok = input_tok + output_tok + thinking_tok
+
+          left = " ↑#{format_number(input_tok)} ↓#{format_number(output_tok)}"
+          left << " 💭#{format_number(thinking_tok)}" if thinking_tok.positive?
+          left << " (#{format_number(total_tok)} tokens)"
+          left
+        end
+
+        def format_number(num)
+          num.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
+        end
+
+        def format_cost(cost)
+          return "Cost: N/A" if cost.nil?
+
+          "Cost: $#{format("%.2f", cost)}"
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/renderer.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "renderer/chat_panel"
+require_relative "renderer/chat_panel_thinking"
+require_relative "renderer/chat_panel_input"
+require_relative "renderer/model_selector"
+require_relative "renderer/plan_clarifier_layout"
+require_relative "renderer/plan_clarifier"
+require_relative "renderer/status_bar"
+
+module RubyCoded
+  module Chat
+    # This class manages the rendering of the UI elements
+    class Renderer
+      include ChatPanel
+      include ChatPanelThinking
+      include ChatPanelInput
+      include ModelSelector
+      include PlanClarifierLayout
+      include PlanClarifier
+      include StatusBar
+
+      def initialize(tui, state)
+        @tui = tui
+        @state = state
+      end
+
+      def draw
+        @tui.clear
+
+        @tui.draw do |frame|
+          chat_area, status_area, input_area = main_layout(frame)
+          render_chat_panel(frame, chat_area)
+          render_status_bar(frame, status_area)
+          render_input_panel(frame, input_area)
+          render_model_selector(frame, chat_area) if @state.model_select?
+          render_plan_clarifier(frame, chat_area) if @state.plan_clarification?
+          render_plugin_overlays(frame, chat_area, input_area)
+        end
+      end
+
+      private
+
+      # Calls each plugin's render method in registration order.
+      def render_plugin_overlays(frame, chat_area, input_area)
+        RubyCoded.plugin_registry.render_configs.each do |config|
+          send(config[:method], frame, chat_area, input_area)
+        end
+      end
+
+      def main_layout(frame)
+        @tui.layout_split(
+          frame.area,
+          direction: :vertical,
+          constraints: [
+            @tui.constraint_fill(1),
+            @tui.constraint_length(1),
+            @tui.constraint_length(3)
+          ]
+        )
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/state/message_assistant.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class State
+      # Operations on the last assistant message: streaming, reset, and error handling.
+      module MessageAssistant
+        # Ensures the last message is :assistant so streaming chunks
+        # land in the right place after tool call/result messages.
+        def ensure_last_is_assistant!
+          @mutex.synchronize do
+            return if !@messages.empty? && @messages.last[:role] == :assistant
+
+            @messages << build_message(:assistant)
+            @message_generation += 1
+            @dirty = true
+          end
+        end
+
+        # Single-mutex operation combining ensure_last_is_assistant! + append.
+        def streaming_append(text)
+          @mutex.synchronize do
+            @messages << build_message(:assistant) if @messages.empty? || @messages.last[:role] != :assistant
+            @messages.last[:content] << text.to_s
+            @message_generation += 1
+            @dirty = true
+          end
+        end
+
+        def last_assistant_empty?
+          @mutex.synchronize do
+            return true if @messages.empty?
+
+            last = @messages.last
+            last[:role] == :assistant && last[:content].strip.empty?
+          end
+        end
+
+        def reset_last_assistant_content
+          @mutex.synchronize do
+            return if @messages.empty?
+
+            last = @messages.last
+            return unless last[:role] == :assistant
+
+            last[:content] = String.new
+            @message_generation += 1
+            @dirty = true
+          end
+        end
+
+        def fail_last_assistant(error, friendly_message: nil)
+          @mutex.synchronize do
+            return if @messages.empty?
+
+            last = @messages.last
+            return unless last[:role] == :assistant
+
+            apply_error_to_message(last, friendly_message || "[Error] #{error.class}: #{error.message}")
+            @message_generation += 1
+            @dirty = true
+          end
+        end
+
+        private
+
+        def apply_error_to_message(message, err_line)
+          if message[:content].strip.empty?
+            message[:content] = String.new(err_line)
+          else
+            message[:content] << "\n\n#{err_line}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/state/message_token_tracking.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class State
+      # Tracks per-message and per-model token usage counters.
+      module MessageTokenTracking
+        TOKEN_KEYS = %i[input_tokens output_tokens thinking_tokens cached_tokens cache_creation_tokens].freeze
+
+        def update_last_message_tokens(model: nil, **token_counts)
+          @mutex.synchronize do
+            return if @messages.empty?
+
+            counts = TOKEN_KEYS.to_h { |key| [key, token_counts[key].to_i] }
+            apply_token_counts(@messages.last, counts)
+            accumulate_token_counts(model || @model, counts)
+          end
+        end
+
+        def total_input_tokens
+          @mutex.synchronize do
+            @messages.sum { |message| message[:input_tokens] }
+          end
+        end
+
+        def total_output_tokens
+          @mutex.synchronize do
+            @messages.sum { |message| message[:output_tokens] }
+          end
+        end
+
+        def total_thinking_tokens
+          @mutex.synchronize do
+            @messages.sum { |message| message[:thinking_tokens] }
+          end
+        end
+
+        def token_usage_by_model
+          @mutex.synchronize do
+            @token_usage_by_model.transform_values(&:dup)
+          end
+        end
+
+        private
+
+        def apply_token_counts(message, counts)
+          counts.each { |key, value| message[key] = value }
+        end
+
+        def accumulate_token_counts(model, counts)
+          usage = @token_usage_by_model[model]
+          counts.each { |key, value| usage[key] += value }
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/state/messages.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class State
+      # Core message storage: add, append, clear, and snapshot.
+      module Messages
+        attr_reader :message_generation
+
+        ZERO_TOKEN_USAGE = {
+          input_tokens: 0, output_tokens: 0,
+          thinking_tokens: 0, cached_tokens: 0, cache_creation_tokens: 0
+        }.freeze
+
+        def init_messages
+          @message_generation = 0
+          @snapshot_cache = nil
+          @snapshot_cache_gen = -1
+          @token_usage_by_model = Hash.new { |h, k| h[k] = ZERO_TOKEN_USAGE.dup }
+        end
+
+        def add_message(role, content)
+          @mutex.synchronize do
+            @messages << build_message(role, content)
+            @message_generation += 1
+            @dirty = true
+          end
+
+          scroll_to_bottom
+        end
+
+        def build_message(role, content = "")
+          { role: role, content: String.new(content.to_s), timestamp: Time.now, **ZERO_TOKEN_USAGE }
+        end
+
+        def append_to_last_message(text)
+          @mutex.synchronize do
+            return if @messages.empty?
+
+            @messages.last[:content] << text.to_s
+            @message_generation += 1
+            @dirty = true
+          end
+        end
+
+        def clear_messages!
+          @mutex.synchronize do
+            @messages.clear
+            @token_usage_by_model.clear
+            @message_generation += 1
+            @dirty = true
+          end
+          @scroll_offset = 0
+        end
+
+        def messages_snapshot
+          @mutex.synchronize do
+            return @snapshot_cache if @snapshot_cache_gen == @message_generation
+
+            @snapshot_cache = @messages.map do |msg|
+              msg.dup.tap { |m| m[:content] = m[:content].dup }
+            end
+            @snapshot_cache_gen = @message_generation
+            @snapshot_cache
+          end
+        end
+      end
+    end
+  end
+end