octo-agent 0.11.2

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

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+require "pastel"
+require_relative "../theme_manager"
+
+module Octo
+  module UI2
+    module Components
+      # CommandSuggestions displays a dropdown menu of available commands
+      # Supports keyboard navigation and filtering
+      class CommandSuggestions
+        attr_reader :selected_index, :visible
+
+        # System commands available by default
+        SYSTEM_COMMANDS = [
+          { command: "/clear", description: "Clear chat history and restart session" },
+          { command: "/config", description: "Open configuration (models, API keys, settings)" },
+          { command: "/undo", description: "Undo the last task and restore previous state" },
+          { command: "/help", description: "Show help information" },
+          { command: "/exit", description: "Exit the chat session" },
+          { command: "/quit", description: "Quit the application" }
+        ].freeze
+
+        def initialize
+          @pastel = Pastel.new
+          @commands = []
+          @filtered_commands = []
+          @selected_index = 0
+          @visible = false
+          @filter_text = ""
+          @skill_commands = []
+          
+          # Initialize with system commands
+          update_commands
+        end
+
+        # Get current theme from ThemeManager
+        def theme
+          UI2::ThemeManager.current_theme
+        end
+
+        # Load skill commands from skill loader, filtered by agent profile whitelist
+        # @param skill_loader [Octo::SkillLoader] The skill loader instance
+        # @param agent_profile [Octo::AgentProfile, nil] Current agent profile (nil = allow all)
+        def load_skill_commands(skill_loader, agent_profile = nil)
+          return unless skill_loader
+
+          skills = skill_loader.user_invocable_skills
+          skills = skills.select { |s| s.allowed_for_agent?(agent_profile.name) } if agent_profile
+
+          @skill_commands = skills.map do |skill|
+            {
+              command: skill.slash_command,
+              description: skill.description || "No description available",
+              type: :skill,
+              argument_hint: skill.argument_hint
+            }
+          end
+
+          update_commands
+        end
+
+        # Show the suggestions dropdown
+        # @param filter_text [String] Initial filter text (everything after the /)
+        def show(filter_text = "")
+          @filter_text = filter_text
+          @visible = true
+          update_filtered_commands
+          @selected_index = 0
+        end
+
+        # Hide the suggestions dropdown
+        def hide
+          @visible = false
+          @filter_text = ""
+          @filtered_commands = []
+          @selected_index = 0
+        end
+
+        # Update filter text and refresh filtered commands
+        # @param text [String] Filter text (everything after the /)
+        def update_filter(text)
+          @filter_text = text
+          update_filtered_commands
+          @selected_index = 0  # Reset selection when filter changes
+        end
+
+        # Move selection up
+        def select_previous
+          return if @filtered_commands.empty?
+          @selected_index = (@selected_index - 1) % @filtered_commands.size
+        end
+
+        # Move selection down
+        def select_next
+          return if @filtered_commands.empty?
+          @selected_index = (@selected_index + 1) % @filtered_commands.size
+        end
+
+        # Get the currently selected command
+        # @return [Hash, nil] Selected command hash or nil if none selected
+        def selected_command
+          return nil if @filtered_commands.empty?
+          @filtered_commands[@selected_index]
+        end
+
+        # Get the currently selected command text
+        # @return [String, nil] Selected command text or nil if none selected
+        def selected_command_text
+          cmd = selected_command
+          cmd ? cmd[:command] : nil
+        end
+
+        # Get the argument hint for the currently selected command
+        # @return [String, nil] Argument hint string or nil if none
+        def selected_argument_hint
+          cmd = selected_command
+          cmd ? cmd[:argument_hint] : nil
+        end
+
+        # Check if there are any suggestions to show
+        # @return [Boolean]
+        def has_suggestions?
+          @visible && !@filtered_commands.empty?
+        end
+
+        # Calculate required height for rendering
+        # @return [Integer] Number of lines needed
+        def required_height
+          return 0 unless @visible
+          return 0 if @filtered_commands.empty?
+
+          # Header + commands + footer
+          1 + [@filtered_commands.size, 5].min + 1  # Max 5 visible items
+        end
+
+        # Render the suggestions dropdown
+        # @param row [Integer] Starting row position
+        # @param col [Integer] Starting column position
+        # @param width [Integer] Maximum width for the dropdown
+        # @return [String] Rendered output
+        def render(row:, col:, width: 60)
+          return "" unless @visible
+          return "" if @filtered_commands.empty?
+
+          output = []
+          max_items = 5  # Maximum visible items
+
+          # Sliding window: keep selected item visible
+          start_idx = [@selected_index - max_items + 1, 0].max
+          start_idx = [start_idx, [@filtered_commands.size - max_items, 0].max].min
+          visible_commands = @filtered_commands[start_idx, max_items] || []
+
+          # Header
+          header = @pastel.dim("┌─ Commands ") + @pastel.dim("─" * (width - 13)) + @pastel.dim("┐")
+          output << position_cursor(row, col) + header
+
+          # Items
+          visible_commands.each_with_index do |cmd, idx|
+            is_selected = (start_idx + idx == @selected_index)
+            line = render_command_item(cmd, is_selected, width)
+            output << position_cursor(row + 1 + idx, col) + line
+          end
+
+          # Footer with navigation hint
+          footer_row = row + 1 + visible_commands.size
+          total = @filtered_commands.size
+          hint = total > max_items ? " (#{total - max_items} more...)" : ""
+          footer = @pastel.dim("└") + @pastel.dim("─" * (width - 2)) + @pastel.dim("┘")
+          output << position_cursor(footer_row, col) + footer
+
+          output.join
+        end
+
+        # Clear the rendered dropdown from screen
+        # @param row [Integer] Starting row position
+        # @param col [Integer] Starting column position
+        def clear_from_screen(row:, col:)
+          return unless @visible
+
+          height = required_height
+          output = []
+          
+          height.times do |i|
+            output << position_cursor(row + i, col) + clear_line
+          end
+          
+          print output.join
+          flush
+        end
+
+
+        # Update the complete commands list (system + skills)
+        private def update_commands
+          system_cmds = SYSTEM_COMMANDS.map { |c| c.merge(type: :system) }
+          @commands = system_cmds + @skill_commands
+          update_filtered_commands if @visible
+        end
+
+        # Update filtered commands based on current filter text
+        private def update_filtered_commands
+          if @filter_text.empty?
+            @filtered_commands = @commands
+          else
+            filter_lower = @filter_text.downcase
+            @filtered_commands = @commands.select do |cmd|
+              # Remove leading / for comparison
+              cmd_name = cmd[:command].sub(/^\//, "")
+              # Only match command name, not description
+              cmd_name.downcase.start_with?(filter_lower)
+            end
+          end
+        end
+
+        # Render a single command item
+        # @param cmd [Hash] Command hash with :command and :description
+        # @param selected [Boolean] Whether this item is selected
+        # @param width [Integer] Maximum width
+        # @return [String] Rendered item
+        private def render_command_item(cmd, selected, width)
+          # Calculate available space
+          available = width - 4  # Account for borders and padding
+
+          # Format command (e.g., "/clear")
+          command_text = cmd[:command]
+          
+          # Format description
+          max_desc_length = available - command_text.length - 3  # 3 for spacing
+          description = truncate_text(cmd[:description], max_desc_length)
+
+          # Build line
+          if selected
+            # Highlighted selection
+            line = @pastel.on_blue(@pastel.white(" #{command_text} "))
+            line += @pastel.on_blue(@pastel.dim(" #{description}"))
+            # Pad to full width
+            content_length = command_text.length + description.length + 2
+            padding = " " * [available - content_length, 0].max
+            line += @pastel.on_blue(padding)
+            @pastel.dim("│") + line + @pastel.dim("│")
+          else
+            # Normal item
+            line = " #{@pastel.cyan(command_text)} #{@pastel.dim(description)}"
+            # Pad to full width
+            content_length = strip_ansi(line).length
+            padding = " " * [available - content_length, 0].max
+            @pastel.dim("│") + line + padding + @pastel.dim("│")
+          end
+        end
+
+        # Truncate text to maximum length
+        # @param text [String] Text to truncate
+        # @param max_length [Integer] Maximum length
+        # @return [String] Truncated text
+        private def truncate_text(text, max_length)
+          return "" if max_length <= 3
+          return text if text.length <= max_length
+
+          text[0...(max_length - 3)] + "..."
+        end
+
+        # Strip ANSI codes from text
+        # @param text [String] Text with ANSI codes
+        # @return [String] Plain text
+        private def strip_ansi(text)
+          text.gsub(/\e\[[0-9;]*m/, '')
+        end
+
+        # Position cursor at specific row and column
+        # @param row [Integer] Row position (0-indexed)
+        # @param col [Integer] Column position (0-indexed)
+        # @return [String] ANSI escape sequence
+        private def position_cursor(row, col)
+          "\e[#{row + 1};#{col + 1}H"
+        end
+
+        # Clear current line
+        # @return [String] ANSI escape sequence
+        private def clear_line
+          "\e[2K"
+        end
+
+        # Flush output to terminal
+        private def flush
+          $stdout.flush
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative "base_component"
+
+module Octo
+  module UI2
+    module Components
+      # CommonComponent renders common UI elements (progress, success, error, warning)
+      class CommonComponent < BaseComponent
+        # Render thinking indicator
+        # @return [String] Thinking indicator
+        def render_thinking
+          symbol = format_symbol(:thinking)
+          text = format_text("Thinking...", :thinking)
+          "#{symbol} #{text}"
+        end
+
+        # Render progress indicator (stopped state, gray)
+        # @param message [String] Progress message
+        # @return [String] Progress indicator
+        def render_progress(message)
+          symbol = format_symbol(:thinking)
+          text = format_text(message, :thinking)
+          "#{symbol} #{text}"
+        end
+
+        # Render working indicator (active state, yellow)
+        # @param message [String] Progress message
+        # @return [String] Working indicator
+        def render_working(message)
+          symbol = format_symbol(:working)
+          text = format_text(message, :working)
+          "#{symbol} #{text}"
+        end
+
+        # Render success message
+        # @param message [String] Success message
+        # @return [String] Success message
+        def render_success(message)
+          symbol = format_symbol(:success)
+          text = format_text(message, :success)
+          "#{symbol} #{text}"
+        end
+
+        # Render error message
+        # @param message [String] Error message
+        # @return [String] Error message
+        def render_error(message)
+          symbol = format_symbol(:error)
+          text = format_text(message, :error)
+          "#{symbol} #{text}"
+        end
+
+        # Render warning message
+        # @param message [String] Warning message
+        # @return [String] Warning message
+        def render_warning(message)
+          symbol = format_symbol(:warning)
+          text = format_text(message, :warning)
+          "#{symbol} #{text}"
+        end
+
+        # Render task completion summary
+        # @param iterations [Integer] Number of iterations
+        # @param duration [Float] Duration in seconds
+        # @param cache_tokens [Integer] Cache read tokens
+        # @param cache_requests [Integer] Total cache requests count
+        # @param cache_hits [Integer] Cache hit requests count
+        # @return [String] Formatted completion summary
+        def render_task_complete(iterations:, duration: nil, cache_tokens: nil, cache_requests: nil, cache_hits: nil)
+          lines = []
+          lines << ""
+          lines << @pastel.dim("─" * 60)
+          lines << render_success("Task Complete")
+          lines << ""
+
+          # Display each stat on a separate line
+          lines << "  Iterations: #{iterations}"
+          lines << "  Duration: #{duration.round(1)}s" if duration
+
+          # Display cache information if available
+          if cache_tokens && cache_tokens > 0
+            lines << "  Cache Tokens: #{cache_tokens} tokens"
+          end
+
+          if cache_requests && cache_requests > 0
+            hit_rate = cache_hits > 0 ? ((cache_hits.to_f / cache_requests) * 100).round(1) : 0
+            lines << "  Cache Requests: #{cache_requests} (#{cache_hits} hits, #{hit_rate}% hit rate)"
+          end
+
+          lines.join("\n")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require_relative "../line_editor"
+
+module Octo
+  module UI2
+    module Components
+      # InlineInput provides inline input for confirmations and simple prompts
+      # Renders at the end of output area, not at fixed bottom position
+      class InlineInput
+        include LineEditor
+
+        attr_reader :prompt, :default_value
+
+        def initialize(prompt: "", default: nil)
+          initialize_line_editor
+          @prompt = prompt
+          @default_value = default
+          @active = false
+          @result_queue = nil
+          @paste_counter = 0
+          @paste_placeholders = {}
+          @continuation_prompt = "> "  # Continuation prompt for wrapped lines
+        end
+
+        # Activate inline input and wait for user input
+        # @return [String] User input
+        def collect
+          @active = true
+          @result_queue = Queue.new
+          # Don't set default as initial text - start empty
+          @result_queue.pop
+        end
+
+        # Check if active
+        def active?
+          @active
+        end
+
+        # Handle keyboard input
+        # @param key [Symbol, String] Key input
+        # @return [Hash] Result with action
+        def handle_key(key)
+          return { action: nil } unless @active
+
+          case key
+          when Hash
+            if key[:type] == :rapid_input
+              # Handle multi-line paste with placeholder
+              pasted_text = key[:text]
+              pasted_lines = pasted_text.split(/\r\n|\r|\n/)
+
+              if pasted_lines.size > 1
+                # Multi-line paste - use placeholder
+                @paste_counter += 1
+                placeholder = "[##{@paste_counter} Paste Text]"
+                @paste_placeholders[placeholder] = pasted_text
+                insert_text(placeholder)
+              else
+                # Single line - insert directly
+                insert_text(pasted_text)
+              end
+            end
+            { action: :update }
+          when :enter
+            handle_enter
+          when :backspace
+            backspace
+            { action: :update }
+          when :delete
+            delete_char
+            { action: :update }
+          when :left_arrow, :ctrl_b
+            cursor_left
+            { action: :update }
+          when :right_arrow, :ctrl_f
+            cursor_right
+            { action: :update }
+          when :home, :ctrl_a
+            cursor_home
+            { action: :update }
+          when :end, :ctrl_e
+            cursor_end
+            { action: :update }
+          when :ctrl_k
+            kill_to_end
+            { action: :update }
+          when :ctrl_u
+            kill_to_start
+            { action: :update }
+          when :ctrl_w
+            kill_word
+            { action: :update }
+          when :shift_tab
+            handle_shift_tab
+          when :ctrl_o
+            handle_toggle_expand
+          when :ctrl_c
+            handle_cancel
+          when :escape
+            handle_cancel
+          else
+            if key.is_a?(String) && key.length >= 1 && key.ord >= 32
+              insert_char(key)
+              { action: :update }
+            else
+              { action: nil }
+            end
+          end
+        end
+
+        # Render inline input with prompt and cursor
+        # @return [String] Rendered line (may wrap to multiple lines)
+        def render
+          width = TTY::Screen.width
+          # Use effective content width (respecting MAX_CONTENT_WIDTH_RATIO)
+          content_width = effective_content_width(width)
+          prompt_width = calculate_display_width(strip_ansi_codes(@prompt))
+          available_width = content_width - prompt_width
+
+          # Get wrapped segments
+          wrapped_segments = wrap_line(@line, available_width)
+
+          # Build rendered output with cursor
+          output = ""
+
+          wrapped_segments.each_with_index do |segment, idx|
+            prefix = if idx == 0
+              @prompt
+            else
+              "> "  # Continuation prompt indicator
+            end
+
+            # Render segment with cursor if needed
+            segment_text = render_line_segment_with_cursor(@line, segment[:start], segment[:end])
+
+            output += "#{prefix}#{segment_text}"
+            output += "\n" unless idx == wrapped_segments.size - 1
+          end
+
+          output
+        end
+
+        # Get cursor column position
+        # @return [Integer] Column position
+        def cursor_col
+          cursor_column(@prompt)
+        end
+
+        # Get cursor position for display (considering line wrapping and continuation prompt)
+        # @param width [Integer] Terminal width
+        # @return [Array<Integer>] Row and column position (0-indexed)
+        def cursor_position_for_display(width = TTY::Screen.width)
+          # Use effective content width (respecting MAX_CONTENT_WIDTH_RATIO)
+          content_width = effective_content_width(width)
+          cursor_position_with_wrap(@prompt, content_width, @continuation_prompt)
+        end
+
+        # Get the number of lines this input will occupy when rendered
+        # @param width [Integer] Terminal width
+        # @return [Integer] Number of lines
+        def line_count(width = TTY::Screen.width)
+          # Use effective content width (respecting MAX_CONTENT_WIDTH_RATIO)
+          content_width = effective_content_width(width)
+          prompt_width = calculate_display_width(strip_ansi_codes(@prompt))
+          available_width = content_width - prompt_width
+          return 1 if available_width <= 0
+
+          segments = wrap_line(@line, available_width)
+          segments.size
+        end
+
+        # Deactivate inline input
+        def deactivate
+          @active = false
+          @result_queue = nil
+        end
+
+
+        def handle_enter
+          result = expand_placeholders(current_line)
+          # If empty and has default, use default
+          result = @default_value.to_s if result.empty? && @default_value
+
+          queue = @result_queue
+          deactivate
+          queue&.push(result)
+
+          { action: :submit, result: result }
+        end
+
+        def expand_placeholders(text)
+          super(text, @paste_placeholders)
+        end
+
+        def handle_cancel
+          queue = @result_queue
+          deactivate
+          queue&.push(nil)
+
+          { action: :cancel }
+        end
+
+        def handle_shift_tab
+          # Auto-confirm as yes (or use default if it's true)
+          result = if @default_value == true || @default_value.to_s.downcase == "yes"
+            @default_value.to_s
+          else
+            "yes"
+          end
+
+          queue = @result_queue
+          deactivate
+          queue&.push(result)
+
+          { action: :toggle_mode }
+        end
+
+        private def handle_toggle_expand
+          # Toggle expansion of diff display
+          { action: :toggle_expand }
+        end
+      end
+    end
+  end
+end