octo-agent 0.11.2

data/lib/octo/ui2/components/message_component.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require_relative "base_component"
+
+module Octo
+  module UI2
+    module Components
+      # MessageComponent renders user and assistant messages
+      class MessageComponent < BaseComponent
+        # Render a message
+        # @param data [Hash] Message data
+        #   - :role [String] "user" or "assistant"
+        #   - :content [String] Message content
+        #   - :timestamp [Time, nil] Optional timestamp
+        #   - :files [Array<Hash>] Optional file hashes (for user messages)
+        #   - :prefix_newline [Boolean] Whether to add newline before message (for system messages)
+        # @return [String] Rendered message
+        def render(data)
+          role = data[:role]
+          content = data[:content]
+          timestamp = data[:timestamp]
+          files = data[:files] || []
+          prefix_newline = data.fetch(:prefix_newline, true)
+          
+          case role
+          when "user"
+            render_user_message(content, timestamp, files)
+          when "assistant"
+            render_assistant_message(content, timestamp)
+          else
+            render_system_message(content, timestamp, prefix_newline)
+          end
+        end
+
+
+        # Render user message
+        # @param content [String] Message content
+        # @param timestamp [Time, nil] Optional timestamp
+        # @param files [Array<Hash>] Optional file hashes { name:, mime_type:, ... }
+        # @return [String] Rendered message
+        def render_user_message(content, timestamp = nil, files = [])
+          symbol = format_symbol(:user)
+          text = format_text(content, :user)
+          time_str = timestamp ? @pastel.dim("[#{format_timestamp(timestamp)}]") : ""
+
+          result = "\n#{symbol} #{text} #{time_str}".rstrip
+
+          # Append file attachment info if present
+          if files && files.any?
+            files.each_with_index do |f, idx|
+              filename = f[:name] || f["name"] || "file"
+              result += "\n" + @pastel.dim("    [File #{idx + 1}] #{filename}")
+            end
+          end
+
+          result
+        end
+
+        private def format_filesize(bytes)
+          if bytes < 1024
+            "#{bytes}b"
+          elsif bytes < 1024 * 1024
+            "#{(bytes / 1024.0).round(1)}kb"
+          else
+            "#{(bytes / (1024.0 * 1024)).round(1)}mb"
+          end
+        end
+
+        # Render assistant message
+        # @param content [String] Message content
+        # @param timestamp [Time, nil] Optional timestamp
+        # @return [String] Rendered message
+        def render_assistant_message(content, timestamp = nil)
+          return "" if content.nil? || content.empty?
+
+          symbol = format_symbol(:assistant)
+          text = format_text(content, :assistant)
+          time_str = timestamp ? @pastel.dim("[#{format_timestamp(timestamp)}]") : ""
+
+          "\n#{symbol} #{text} #{time_str}".rstrip
+        end
+
+        # Render system message
+        # @param content [String] Message content
+        # @param timestamp [Time, nil] Optional timestamp
+        # @param prefix_newline [Boolean] Whether to add newline before message
+        # @return [String] Rendered message
+        private def render_system_message(content, timestamp = nil, prefix_newline = true)
+          symbol = format_symbol(:info)
+          text = format_text(content, :info)
+          time_str = timestamp ? @pastel.dim("[#{format_timestamp(timestamp)}]") : ""
+
+          prefix = prefix_newline ? "\n" : ""
+          "#{prefix}#{symbol} #{text} #{time_str}".rstrip
+        end
+      end
+    end
+  end
+end

data/lib/octo/ui2/components/modal_component.rb

@@ -0,0 +1,419 @@
+# frozen_string_literal: true
+
+require 'io/console'
+require 'tty-prompt'
+require_relative 'base_component'
+
+module Octo
+  module UI2
+    module Components
+      # ModalComponent - Displays a centered modal dialog with form fields
+      class ModalComponent < BaseComponent
+        attr_reader :width, :height
+
+        def initialize
+          super
+          @width = 70
+          @height = 16
+          @title = ""
+          @fields = []
+          @choices = []
+          @values = {}
+          @selected_index = 0
+          @mode = :form
+        end
+
+        # Configure and show the modal
+        # @param title [String] Modal title
+        # @param fields [Array<Hash>] Field definitions (for form mode)
+        # @param choices [Array<Hash>] Choice definitions (for menu mode)
+        #   Example: [{ name: "Option 1", value: :opt1 }, { name: "---", disabled: true }]
+        # @param validator [Proc, nil] Optional validation callback that receives values hash
+        #                              Should return { success: true } or { success: false, error: "message" }
+        # @param on_close [Proc, nil] Optional callback to execute when modal closes (e.g., to re-render screen)
+        # @return [Hash, nil] Hash of field values or selected value, or nil if cancelled
+        def show(title:, fields: nil, choices: nil, validator: nil, on_close: nil)
+          @title = title
+          @mode = choices ? :menu : :form
+          @fields = fields || []
+          @choices = choices || []
+          @values = {}
+          @error_message = nil
+          @selected_index = 0
+          
+          # For menu mode, find first non-disabled choice
+          if @mode == :menu
+            @selected_index = @choices.index { |c| !c[:disabled] } || 0
+          end
+
+          # Adjust height based on mode
+          if @mode == :menu
+            visible_items = [@choices.length, 15].min
+            @height = visible_items + 4  # +4 for title, borders, and instructions
+          else
+            # Form mode - adjust height based on number of fields
+            # Each field takes 2 rows (label + input)
+            # +3 for title and top border
+            # +5 for error message area, buttons, and bottom border
+            @height = (@fields.length * 2) + 3 + 5
+          end
+
+          # Get terminal size
+          term_height, term_width = IO.console.winsize
+
+          # Calculate modal position (centered)
+          start_row = [(term_height - @height) / 2, 1].max
+          start_col = [(term_width - @width) / 2, 1].max
+
+          begin
+            if @mode == :menu
+              # Menu mode - show choices and handle selection
+              return show_menu_mode(start_row, start_col)
+            else
+              # Form mode - collect field inputs
+              return show_form_mode(start_row, start_col, validator)
+            end
+          ensure
+            # Clear modal area
+            clear_modal(start_row, start_col)
+            # Call on_close callback if provided (e.g., to re-render screen)
+            on_close&.call
+          end
+        end
+
+        # Render method (required by BaseComponent, not used for modal)
+        def render(data)
+          # Modal uses interactive show() method instead
+          ""
+        end
+
+
+        # Show menu mode
+        private def show_menu_mode(start_row, start_col)
+          loop do
+            # Draw menu
+            draw_modal(start_row, start_col)
+            draw_menu_choices(start_row + 2, start_col)
+            draw_menu_instructions(start_row + @height - 2, start_col)
+
+            # Read input
+            char = STDIN.getch
+
+            case char
+            when "\r", "\n"  # Enter - select current choice
+              selected = @choices[@selected_index]
+              return nil if selected.nil? || selected[:disabled]
+              print "\e[?25l"  # Hide cursor
+              return selected[:value]
+            when "\e"  # Escape sequence
+              seq = STDIN.read_nonblock(2) rescue ''
+              if seq.empty?
+                # Just Esc key - cancel
+                print "\e[?25l"
+                return nil
+              elsif seq == '[A'  # Up arrow
+                move_menu_selection(-1)
+              elsif seq == '[B'  # Down arrow
+                move_menu_selection(1)
+              end
+            when "\u0003"  # Ctrl+C
+              print "\e[?25l"
+              return nil
+            when 'k', 'K'  # Vim-style up
+              move_menu_selection(-1)
+            when 'j', 'J'  # Vim-style down
+              move_menu_selection(1)
+            when 'q', 'Q'  # Quit
+              print "\e[?25l"
+              return nil
+            end
+          end
+        end
+
+        # Show form mode
+        private def show_form_mode(start_row, start_col, validator)
+          loop do
+            # Draw modal background and border
+            draw_modal(start_row, start_col)
+
+            # Draw error message if present
+            if @error_message
+              draw_error_message(start_row + @height - 5, start_col)
+            end
+
+            # Draw instructions
+            draw_buttons(start_row + @height - 3, start_col)
+            
+            # Collect input for each field
+            current_row = start_row + 3
+            @fields.each do |field|
+              # Use previously entered value as default if validation failed
+              field_with_previous = field.dup
+              field_with_previous[:default] = @values[field[:name]] || field[:default]
+              
+              value = collect_field_input(field_with_previous, current_row, start_col)
+              if value == :cancelled
+                print "\e[?25l"  # Hide cursor
+                return nil  # User pressed Esc
+              end
+              @values[field[:name]] = value
+              current_row += 2
+            end
+
+            # All fields collected - validate if validator provided
+            if validator
+              # Show "Testing..." message
+              testing_row = start_row + @height - 5
+              testing_col = start_col + 3
+              print "\e[#{testing_row};#{testing_col}H\e[K"
+              print "\e[#{testing_row + 1};#{testing_col}H\e[K"
+              print @pastel.cyan("⏳ Testing connection...")
+              STDOUT.flush
+              
+              validation_result = validator.call(@values)
+              
+              # Clear testing messages
+              print "\e[#{testing_row};#{testing_col}H\e[K"
+              print "\e[#{testing_row + 1};#{testing_col}H\e[K"
+              
+              if validation_result[:success]
+                # Validation passed - hide cursor and return values
+                print "\e[?25l"
+                return @values
+              else
+                # Validation failed - show error and loop again to let user correct input
+                @error_message = validation_result[:error] || "Validation failed"
+                # Don't clear modal - just loop again to redraw with error message
+                # This prevents the modal from flickering
+              end
+            else
+              # No validator - return immediately
+              print "\e[?25l"
+              return @values
+            end
+          end
+        end
+
+        # Draw the modal background and border
+        private def draw_modal(start_row, start_col)
+          # Use theme colors - cyan for border, bright_cyan for title
+          reset = "\e[0m"
+
+          # Draw box with border
+          @height.times do |i|
+            print "\e[#{start_row + i};#{start_col}H"
+            
+            if i == 0
+              # Top border with title
+              title_text = " #{@title} "
+              padding = (@width - title_text.length - 2) / 2
+              remaining = @width - padding - title_text.length - 2
+              border_line = @pastel.cyan("┌" + "─" * padding)
+              title_part = @pastel.bright_cyan(title_text)
+              border_rest = @pastel.cyan("─" * remaining + "┐")
+              print border_line + title_part + border_rest
+            elsif i == @height - 1
+              # Bottom border
+              print @pastel.cyan("└" + "─" * (@width - 2) + "┘")
+            else
+              # Side borders with background
+              left_border = @pastel.cyan("│")
+              right_border = @pastel.cyan("│")
+              print left_border + " " * (@width - 2) + right_border
+            end
+          end
+        end
+
+        # Collect input for a single field
+        private def collect_field_input(field, row, col)
+          require 'io/console'
+          
+          label_text = @pastel.white(field[:label])
+
+          # Draw field label
+          print "\e[#{row};#{col + 2}H#{label_text}"
+
+          # Input field position
+          input_row = row + 1
+          input_col = col + 4
+          input_width = @width - 8
+
+          # Initialize input buffer with default value
+          buffer = field[:default].to_s.dup
+          cursor_pos = buffer.length
+          placeholder = "Press Enter to keep current"
+
+          # Show cursor for input
+          print "\e[?25h"
+
+          loop do
+            # Draw input field with cursor or placeholder
+            if buffer.empty?
+              # Show placeholder in dim gray
+              display_text = @pastel.dim(placeholder)
+            elsif field[:mask]
+              # Show masked input - limit display length to prevent overflow
+              mask_length = [buffer.length, input_width].min
+              display_text = @pastel.cyan('*' * mask_length)
+            else
+              # Show normal input
+              display_text = @pastel.cyan(buffer)
+            end
+            
+            # Clear line and draw input
+            print "\e[#{input_row};#{input_col}H\e[K"
+            print display_text
+            
+            # Position cursor and ensure it's visible
+            visible_cursor_pos = [cursor_pos, input_width - 1].min
+            print "\e[#{input_row};#{input_col + visible_cursor_pos}H"
+            STDOUT.flush
+
+            # Read character
+            char = STDIN.getch
+
+            case char
+            when "\r", "\n"  # Enter - confirm input
+              # Clear placeholder if input is empty
+              if buffer.empty?
+                print "\e[#{input_row};#{input_col}H\e[K"
+              end
+              # Don't hide cursor here - next field will reuse it
+              return buffer
+            when "\e"  # Escape sequence
+              seq = STDIN.read_nonblock(2) rescue ''
+              if seq.empty?
+                # Just Esc key - cancel (hide cursor when cancelling)
+                print "\e[?25l"
+                return :cancelled
+              elsif seq == '[C'  # Right arrow
+                cursor_pos = [cursor_pos + 1, buffer.length].min
+              elsif seq == '[D'  # Left arrow
+                cursor_pos = [cursor_pos - 1, 0].max
+              elsif seq == '[H'  # Home
+                cursor_pos = 0
+              elsif seq == '[F'  # End
+                cursor_pos = buffer.length
+              end
+            when "\u007F", "\b"  # Backspace
+              if cursor_pos > 0
+                buffer[cursor_pos - 1] = ''
+                cursor_pos -= 1
+              end
+            when "\u0003"  # Ctrl+C (hide cursor when cancelling)
+              print "\e[?25l"
+              return :cancelled
+            when "\u0015"  # Ctrl+U - clear line
+              buffer = ''
+              cursor_pos = 0
+            else
+              # Regular character input
+              if char.ord >= 32 && char.ord < 127
+                buffer.insert(cursor_pos, char)
+                cursor_pos += 1
+              end
+            end
+          end
+        end
+
+        # Draw error message
+        private def draw_error_message(row, col)
+          return if @error_message.nil? || @error_message.empty?
+          
+          max_width = @width - 6
+          # Truncate error message if too long
+          error_text = @error_message.length > max_width ? @error_message[0..max_width-4] + "..." : @error_message
+          error_col = col + 3
+          
+          # Clear the line first to prevent leftover characters
+          print "\e[#{row};#{error_col}H\e[K"
+          formatted = @pastel.red("⚠  #{error_text}")
+          print formatted
+        end
+
+        # Draw confirmation buttons
+        private def draw_buttons(row, col)
+          # Show instructions at bottom of modal
+          buttons_text = "Press Enter after each field • Press Esc to cancel"
+          button_col = col + (@width - buttons_text.length) / 2
+          
+          formatted = @pastel.dim(buttons_text)
+          print "\e[#{row};#{button_col}H#{formatted}"
+        end
+
+        # Clear the modal area
+        private def clear_modal(start_row, start_col)
+          @height.times do |i|
+            print "\e[#{start_row + i};#{start_col}H#{' ' * @width}"
+          end
+        end
+
+        # Draw menu choices
+        private def draw_menu_choices(start_row, start_col)
+          @choices.each_with_index do |choice, index|
+            row = start_row + index
+            draw_menu_choice(choice, index, row, start_col)
+          end
+        end
+
+        # Draw a single menu choice
+        private def draw_menu_choice(choice, index, row, col)
+          is_selected = (index == @selected_index)
+          
+          # Calculate available width for text
+          text_width = @width - 6  # Account for borders, marker, and padding
+          
+          # Prepare choice text
+          choice_text = choice[:name] || ""
+          if choice_text.length > text_width
+            choice_text = choice_text[0..text_width-4] + "..."
+          end
+          
+          # Prepare marker and styling
+          if choice[:disabled]
+            # Disabled choice (like separator)
+            marker = "  "
+            text = @pastel.dim(choice_text)
+          elsif is_selected
+            marker = @pastel.bright_cyan("→ ")
+            text = @pastel.bright_white(choice_text)
+          else
+            marker = "  "
+            text = @pastel.white(choice_text)
+          end
+          
+          # Draw line
+          print "\e[#{row};#{col}H"
+          print @pastel.cyan("│") + marker + text
+          
+          # Pad to width
+          used_length = choice_text.length + 2  # marker is 2 chars
+          padding_needed = @width - used_length - 2  # -2 for borders
+          print " " * padding_needed + @pastel.cyan("│")
+        end
+
+        # Draw menu instructions
+        private def draw_menu_instructions(row, col)
+          instructions = "↑↓/jk: Navigate • Enter: Select • Esc/q: Cancel"
+          padding = (@width - instructions.length - 2) / 2
+          remaining = @width - padding - instructions.length - 2
+          
+          print "\e[#{row};#{col}H"
+          border_line = @pastel.cyan("└" + "─" * padding)
+          instr_part = @pastel.dim(instructions)
+          border_rest = @pastel.cyan("─" * remaining + "┘")
+          print border_line + instr_part + border_rest
+        end
+
+        # Move menu selection up or down
+        private def move_menu_selection(direction)
+          loop do
+            @selected_index = (@selected_index + direction) % @choices.length
+            # Skip disabled choices
+            break unless @choices[@selected_index][:disabled]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/octo/ui2/components/todo_area.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "pastel"
+
+module Octo
+  module UI2
+    module Components
+      # TodoArea displays active todos above the separator line
+      class TodoArea
+        attr_accessor :height
+        attr_reader :todos
+
+        MAX_DISPLAY_TASKS = 3  # Show current + next 2 tasks
+
+        def initialize
+          @todos = []
+          @pending_todos = []
+          @completed_count = 0
+          @total_count = 0
+          @pastel = Pastel.new
+          @width = TTY::Screen.width
+          @height = 0  # Dynamic height based on todos
+          @hidden = false
+        end
+
+        # Update todos list
+        # @param todos [Array<Hash>] Array of todo items
+        def update(todos)
+          @todos = todos || []
+          @pending_todos = @todos.select { |t| t[:status] == "pending" }
+          @completed_count = @todos.count { |t| t[:status] == "completed" }
+          @total_count = @todos.size
+
+          recalc_height
+        end
+
+        # Hide the area without discarding todos data; show again to restore.
+        def hide
+          return if @hidden
+          @hidden = true
+          @height = 0
+        end
+
+        def show
+          return unless @hidden
+          @hidden = false
+          recalc_height
+        end
+
+        private def recalc_height
+          if @hidden || @pending_todos.empty?
+            @height = 0
+          else
+            @height = [@pending_todos.size, MAX_DISPLAY_TASKS].min
+          end
+        end
+
+        # Check if there are todos to display
+        def visible?
+          @height > 0
+        end
+
+        # Render todos area
+        # @param start_row [Integer] Screen row to start rendering
+        def render(start_row:)
+          return unless visible?
+
+          update_width
+
+          # Render each task on separate line
+          tasks_to_show = @pending_todos.take(MAX_DISPLAY_TASKS)
+          
+          tasks_to_show.each_with_index do |task, index|
+            move_cursor(start_row + index, 0)
+            
+            # Build the line content
+            line_content = if index == 0
+              # First line: Task [2/4]: #3 - Current task description
+              progress = "#{@completed_count}/#{@total_count}"
+              prefix = "Task [#{progress}]: "
+              task_text = "##{task[:id]} - #{task[:task]}"
+              available_width = @width - prefix.length - 2
+              truncated_task = truncate_text(task_text, available_width)
+              
+              "#{@pastel.cyan(prefix)}#{truncated_task}"
+            else
+              # Subsequent lines: -> Next: #4 - Next task description
+              label = index == 1 ? "Next" : "After"
+              prefix = "-> #{label}: "
+              task_text = "##{task[:id]} - #{task[:task]}"
+              available_width = @width - prefix.length - 2
+              truncated_task = truncate_text(task_text, available_width)
+              
+              "#{@pastel.dim(prefix)}#{@pastel.dim(truncated_task)}"
+            end
+
+            # Use carriage return and print content directly (overwrite existing content)
+            print "\r#{line_content}"
+            # Clear any remaining characters from previous render if line is shorter
+            clear_to_end_of_line
+          end
+
+          flush
+        end
+
+        # Clear the area
+        def clear
+          @todos = []
+          @pending_todos = []
+          @completed_count = 0
+          @total_count = 0
+          @height = 0
+        end
+
+
+        # Truncate text to fit width
+        def truncate_text(text, max_width)
+          return "" if text.nil?
+
+          if text.length > max_width
+            text[0...(max_width - 3)] + "..."
+          else
+            text
+          end
+        end
+
+        # Update width on resize
+        def update_width
+          @width = TTY::Screen.width
+        end
+
+        # Move cursor to position
+        def move_cursor(row, col)
+          print "\e[#{row + 1};#{col + 1}H"
+        end
+
+        # Clear from cursor to end of line
+        def clear_to_end_of_line
+          print "\e[0K"
+        end
+
+        # Flush output
+        def flush
+          $stdout.flush
+        end
+      end
+    end
+  end
+end