openclacky 0.6.1 → 0.6.3

data/lib/clacky/ui2/components/input_area.rb

@@ -4,6 +4,7 @@ require "pastel"
 require "tempfile"
 require_relative "../theme_manager"
 require_relative "../line_editor"
+require_relative "command_suggestions"
 
 module Clacky
   module UI2
@@ -68,6 +69,10 @@ module Clacky
           @animation_frame = 0
           @last_animation_update = Time.now
           @working_frames = ["❄", "❅", "❆"]
+
+          # Command suggestions dropdown
+          @command_suggestions = CommandSuggestions.new
+          @skill_loader = nil  # Will be set via set_skill_loader method
         end
 
         # Get current theme from ThemeManager
@@ -84,8 +89,15 @@ module Clacky
           # When paused (InlineInput active), don't take up any space
           return 0 if @paused
 
-          height = 1  # Session bar (top)
-          height += 1  # Separator after session bar
+          height = 0
+          
+          # Session bar - calculate actual wrapped height
+          height += calculate_sessionbar_height
+          
+          # Separator after session bar
+          height += 1
+          
+          # Images
           height += @images.size
           
           # Calculate height considering wrapped lines
@@ -101,12 +113,26 @@ module Clacky
             height += wrapped_segments.size
           end
           
-          height += 1  # Bottom separator
+          # Bottom separator
+          height += 1
+          
+          # Command suggestions (rendered above input)
+          height += @command_suggestions.required_height if @command_suggestions
+          
+          # Tips and user tips
           height += 1 if @tips_message
           height += 1 if @user_tip
+          
           height
         end
 
+        # Set skill loader for command suggestions
+        # @param skill_loader [Clacky::SkillLoader] The skill loader instance
+        def set_skill_loader(skill_loader)
+          @skill_loader = skill_loader
+          @command_suggestions.load_skill_commands(skill_loader) if skill_loader
+        end
+
         # Update session bar info
         # @param working_dir [String] Working directory
         # @param mode [String] Permission mode
@@ -133,17 +159,65 @@ module Clacky
 
           old_height = required_height
 
+          # Handle command suggestions navigation first if visible
+          if @command_suggestions.visible
+            case key
+            when :up_arrow
+              @command_suggestions.select_previous
+              return { action: nil }
+            when :down_arrow
+              @command_suggestions.select_next
+              return { action: nil }
+            when :enter
+              # Accept selected command
+              if @command_suggestions.has_suggestions?
+                selected = @command_suggestions.selected_command_text
+                if selected
+                  # Replace current input with selected command
+                  @lines = [selected]
+                  @line_index = 0
+                  @cursor_position = selected.length
+                  @command_suggestions.hide
+                  return { action: nil }
+                end
+              end
+              # Fall through to normal enter handling if no suggestion
+            when :escape
+              @command_suggestions.hide
+              return { action: nil }
+            when :tab
+              # Tab also accepts the suggestion
+              if @command_suggestions.has_suggestions?
+                selected = @command_suggestions.selected_command_text
+                if selected
+                  @lines = [selected]
+                  @line_index = 0
+                  @cursor_position = selected.length
+                  @command_suggestions.hide
+                  return { action: nil }
+                end
+              end
+            end
+          end
+
           result = case key
           when Hash
             if key[:type] == :rapid_input
               insert_text(key[:text])
               clear_tips
+              update_command_suggestions
             end
             { action: nil }
           when :enter then handle_enter
           when :newline then newline; { action: nil }
-          when :backspace then backspace; { action: nil }
-          when :delete then delete_char; { action: nil }
+          when :backspace 
+            backspace
+            update_command_suggestions
+            { action: nil }
+          when :delete 
+            delete_char
+            update_command_suggestions
+            { action: nil }
           when :left_arrow, :ctrl_b then cursor_left; { action: nil }
           when :right_arrow, :ctrl_f then cursor_right; { action: nil }
           when :up_arrow then handle_up_arrow
@@ -157,10 +231,15 @@ module Clacky
           when :ctrl_d then handle_ctrl_d
           when :ctrl_v then handle_paste
           when :shift_tab then { action: :toggle_mode }
-          when :escape then { action: nil }
+          when :escape 
+            if @command_suggestions.visible
+              @command_suggestions.hide
+            end
+            { action: nil }
           else
             if key.is_a?(String) && key.length >= 1 && key.ord >= 32
               insert_char(key)
+              update_command_suggestions
             end
             { action: nil }
           end
@@ -202,54 +281,19 @@ module Clacky
           end
 
           # Input lines with auto-wrap support
-          @lines.each_with_index do |line, idx|
-            prefix = if idx == 0
-              prompt_text = theme.format_symbol(:user) + " "
-              prompt_text
-            else
-              " " * prompt.length
-            end
-
-            # Calculate available width for text (excluding prefix)
-            prefix_width = calculate_display_width(strip_ansi_codes(prefix))
-            available_width = @width - prefix_width
-
-            # Wrap line if needed
-            wrapped_segments = wrap_line(line, available_width)
-
-            wrapped_segments.each_with_index do |segment_info, wrap_idx|
-              move_cursor(current_row, 0)
-
-              segment_text = segment_info[:text]
-              segment_start = segment_info[:start]
-              segment_end = segment_info[:end]
-
-              content = if wrap_idx == 0
-                # First wrapped line includes prefix
-                if idx == @line_index
-                  "#{prefix}#{render_line_segment_with_cursor(line, segment_start, segment_end)}"
-                else
-                  "#{prefix}#{theme.format_text(segment_text, :user)}"
-                end
-              else
-                # Continuation lines have indent matching prefix width
-                continuation_indent = " " * prefix_width
-                if idx == @line_index
-                  "#{continuation_indent}#{render_line_segment_with_cursor(line, segment_start, segment_end)}"
-                else
-                  "#{continuation_indent}#{theme.format_text(segment_text, :user)}"
-                end
-              end
-              
-              print_with_padding(content)
-              current_row += 1
-            end
-          end
+          current_row = render_input_lines(current_row)
 
           # Bottom separator
           render_separator(current_row)
           current_row += 1
 
+          # Command suggestions (rendered above tips)
+          if @command_suggestions && @command_suggestions.visible
+            # Render suggestions at current row
+            print @command_suggestions.render(row: current_row, col: 0, width: [@width - 4, 60].min)
+            current_row += @command_suggestions.required_height
+          end
+
           # Tips bar (if any)
           if @tips_message
             move_cursor(current_row, 0)
@@ -526,6 +570,7 @@ module Clacky
           @paste_counter = 0
           @paste_placeholders = {}
           clear_tips
+          @command_suggestions.hide if @command_suggestions
         end
 
         def submit
@@ -561,75 +606,104 @@ module Clacky
 
         private
 
-        # Wrap a line into multiple segments based on available width
-        # Considers display width of characters (multi-byte characters like Chinese)
-        # @param line [String] The line to wrap
-        # @param max_width [Integer] Maximum display width per wrapped line
-        # @return [Array<Hash>] Array of segment info: { text: String, start: Integer, end: Integer }
-        def wrap_line(line, max_width)
-          return [{ text: "", start: 0, end: 0 }] if line.empty?
-          return [{ text: line, start: 0, end: line.length }] if max_width <= 0
+        # Update command suggestions based on current input
+        # Shows suggestions when input starts with /
+        private def update_command_suggestions
+          return unless @command_suggestions
+          
+          current = current_line.strip
+          
+          # Check if we should show suggestions (input starts with /)
+          if current.start_with?('/') && @line_index == 0
+            # Extract the filter text (everything after /)
+            filter_text = current[1..-1] || ""
+            @command_suggestions.show(filter_text)
+          else
+            @command_suggestions.hide
+          end
+        end
 
-          segments = []
-          chars = line.chars
-          segment_start = 0
-          current_width = 0
-          current_end = 0
+        # Render all input lines with auto-wrap support
+        # @param start_row [Integer] Starting row position
+        # @return [Integer] Next available row after rendering all lines
+        def render_input_lines(start_row)
+          current_row = start_row
+          
+          @lines.each_with_index do |line, line_idx|
+            prefix = calculate_line_prefix(line_idx)
+            prefix_width = calculate_display_width(strip_ansi_codes(prefix))
+            available_width = @width - prefix_width
+            wrapped_segments = wrap_line(line, available_width)
 
-          chars.each_with_index do |char, idx|
-            char_width = char_display_width(char)
-            
-            # If adding this character exceeds max width, complete current segment
-            if current_width + char_width > max_width && current_end > segment_start
-              segments << {
-                text: chars[segment_start...current_end].join,
-                start: segment_start,
-                end: current_end
-              }
-              segment_start = idx
-              current_end = idx + 1
-              current_width = char_width
-            else
-              current_end = idx + 1
-              current_width += char_width
+            wrapped_segments.each_with_index do |segment_info, wrap_idx|
+              content = render_line_segment(line, line_idx, segment_info, wrap_idx, prefix, prefix_width)
+              move_cursor(current_row, 0)
+              print_with_padding(content)
+              current_row += 1
             end
           end
+          
+          current_row
+        end
 
-          # Add the last segment
-          if current_end > segment_start
-            segments << {
-              text: chars[segment_start...current_end].join,
-              start: segment_start,
-              end: current_end
-            }
+        # Calculate the prefix (prompt or indent) for a given line index
+        # @param line_idx [Integer] Index of the line
+        # @return [String] Prefix string (with formatting)
+        private def calculate_line_prefix(line_idx)
+          if line_idx == 0
+            theme.format_symbol(:user) + " "
+          else
+            " " * prompt.length
           end
+        end
+
+        # Render a single segment of a line (handling cursor and wrapping)
+        # @param line [String] Full line text
+        # @param line_idx [Integer] Index of the line in @lines
+        # @param segment_info [Hash] Segment information from wrap_line
+        # @param wrap_idx [Integer] Index of this segment in wrapped segments
+        # @param prefix [String] Line prefix (prompt or indent)
+        # @param prefix_width [Integer] Display width of the prefix
+        # @return [String] Formatted content for this segment
+        private def render_line_segment(line, line_idx, segment_info, wrap_idx, prefix, prefix_width)
+          segment_text = segment_info[:text]
+          segment_start = segment_info[:start]
+          segment_end = segment_info[:end]
           
-          segments.empty? ? [{ text: "", start: 0, end: 0 }] : segments
+          is_current_line = (line_idx == @line_index)
+          is_first_segment = (wrap_idx == 0)
+          
+          # Determine the line prefix
+          line_prefix = if is_first_segment
+            prefix
+          else
+            " " * prefix_width  # Continuation indent
+          end
+          
+          # Render the segment content (with or without cursor)
+          segment_content = if is_current_line
+            render_line_segment_with_cursor(line, segment_start, segment_end)
+          else
+            theme.format_text(segment_text, :user)
+          end
+          
+          "#{line_prefix}#{segment_content}"
+        end
+
+        # Wrap a line into multiple segments based on available width
+        # Considers display width of characters (multi-byte characters like Chinese)
+        # @param line [String] The line to wrap
+        # @param max_width [Integer] Maximum display width per wrapped line
+        # @return [Array<Hash>] Array of segment info: { text: String, start: Integer, end: Integer }
+        def wrap_line(line, max_width)
+          super(line, max_width)
         end
 
         # Calculate display width of a single character
         # @param char [String] Single character
         # @return [Integer] Display width (1 or 2)
         def char_display_width(char)
-          code = char.ord
-          # East Asian Wide and Fullwidth characters take 2 columns
-          if (code >= 0x1100 && code <= 0x115F) ||
-             (code >= 0x2329 && code <= 0x232A) ||
-             (code >= 0x2E80 && code <= 0x303E) ||
-             (code >= 0x3040 && code <= 0xA4CF) ||
-             (code >= 0xAC00 && code <= 0xD7A3) ||
-             (code >= 0xF900 && code <= 0xFAFF) ||
-             (code >= 0xFE10 && code <= 0xFE19) ||
-             (code >= 0xFE30 && code <= 0xFE6F) ||
-             (code >= 0xFF00 && code <= 0xFF60) ||
-             (code >= 0xFFE0 && code <= 0xFFE6) ||
-             (code >= 0x1F300 && code <= 0x1F9FF) ||
-             (code >= 0x20000 && code <= 0x2FFFD) ||
-             (code >= 0x30000 && code <= 0x3FFFD)
-            2
-          else
-            1
-          end
+          super(char)
         end
 
         # Strip ANSI escape codes from a string
@@ -646,12 +720,29 @@ module Clacky
           visible_content = content.gsub(/\e\[[0-9;]*m/, '')
           visible_width = calculate_display_width(visible_content)
           
-          # Print content
-          print content
-          
-          # Pad with spaces if needed to clear old content
-          remaining = @width - visible_width
-          print " " * remaining if remaining > 0
+          # IMPORTANT: If content exceeds screen width, truncate to prevent terminal auto-wrap
+          if visible_width > @width
+            # Content too long - truncate to fit (loses ANSI colors but prevents wrapping)
+            truncate_at = 0
+            current_width = 0
+            visible_content.each_char.with_index do |char, idx|
+              char_width = char_display_width(char)
+              break if current_width + char_width + 3 > @width  # Reserve 3 for "..."
+              current_width += char_width
+              truncate_at = idx + 1
+            end
+            print visible_content[0...truncate_at]
+            print "..."
+            # Pad remaining
+            remaining = @width - current_width - 3
+            print " " * remaining if remaining > 0
+          else
+            # Content fits - print normally
+            print content
+            # Pad with spaces if needed to clear old content
+            remaining = @width - visible_width
+            print " " * remaining if remaining > 0
+          end
         end
 
         def handle_enter
@@ -661,7 +752,7 @@ module Clacky
           if text.start_with?('/')
             # Check if it's a command (single slash followed by English letters only)
             # Paths like /xxx/xxxx should not be treated as commands
-            if text =~ /^\/([a-zA-Z]+)$/
+            if text =~ /^\/([a-zA-Z-]+)$/
               case text
               when '/clear'
                 clear
@@ -671,8 +762,8 @@ module Clacky
               when '/exit', '/quit'
                 return { action: :exit }
               else
-                set_tips("Unknown command: #{text} (Available: /clear, /help, /exit)", type: :warning)
-                return { action: nil }
+                # Let other commands (like skills) pass through to agent
+                # Fall through to submit
               end
             end
             # If it's not a command pattern (e.g., /xxx/xxxx), treat as normal input
@@ -926,44 +1017,52 @@ module Clacky
         # @param segment_end [Integer] End position of segment in line (char index)
         # @return [String] Rendered segment with cursor if applicable
         def render_line_segment_with_cursor(line, segment_start, segment_end)
-          chars = line.chars
-          segment_chars = chars[segment_start...segment_end]
-          
-          # Check if cursor is in this segment
-          if @cursor_position >= segment_start && @cursor_position < segment_end
-            # Cursor is in this segment
-            cursor_pos_in_segment = @cursor_position - segment_start
-            before_cursor = segment_chars[0...cursor_pos_in_segment].join
-            cursor_char = segment_chars[cursor_pos_in_segment] || " "
-            after_cursor = segment_chars[(cursor_pos_in_segment + 1)..-1]&.join || ""
-            
-            "#{@pastel.white(before_cursor)}#{@pastel.on_white(@pastel.black(cursor_char))}#{@pastel.white(after_cursor)}"
-          elsif @cursor_position == segment_end && segment_end == line.length
-            # Cursor is at the very end of the line, show it in last segment
-            segment_text = segment_chars.join
-            "#{@pastel.white(segment_text)}#{@pastel.on_white(@pastel.black(' '))}"
-          else
-            # Cursor is not in this segment, just format normally
-            theme.format_text(segment_chars.join, :user)
-          end
+          # Delegate to LineEditor's shared implementation
+          rendered = super(line, segment_start, segment_end)
+          # Apply theme colors for InputArea
+          theme.format_text(rendered, :user)
         end
 
+        # Render a separator line (ensures it doesn't exceed screen width)
+        # @param row [Integer] Row position to render
         def render_separator(row)
           move_cursor(row, 0)
-          content = @pastel.dim("─" * @width)
-          print_with_padding(content)
+          # Ensure separator doesn't exceed screen width to prevent wrapping
+          separator_width = [@width, 1].max
+          content = @pastel.dim("─" * separator_width)
+          print content
+          # Clear any remaining space
+          remaining = @width - separator_width
+          print " " * remaining if remaining > 0
         end
 
+        # Render session bar with wrapping support
+        # @param row [Integer] Starting row position
+        # @return [Integer] Number of rows actually used
         def render_sessionbar(row)
           move_cursor(row, 0)
 
           # If no sessionbar info, just render a separator
           unless @sessionbar_info[:working_dir]
-            content = @pastel.dim("─" * @width)
-            print_with_padding(content)
-            return
+            separator_width = [@width, 1].max
+            content = @pastel.dim("─" * separator_width)
+            print content
+            remaining = @width - separator_width
+            print " " * remaining if remaining > 0
+            return 1
           end
 
+          session_line = build_sessionbar_content
+          
+          # IMPORTANT: Always use print_with_padding which handles truncation
+          # to prevent terminal auto-wrap
+          print_with_padding(session_line)
+          1
+        end
+        
+        # Build the session bar content string
+        # @return [String] Formatted session bar content
+        private def build_sessionbar_content
           parts = []
           separator = @pastel.dim(" │ ")
 
@@ -998,8 +1097,47 @@ module Clacky
           cost_display = format("$%.1f", @sessionbar_info[:cost])
           parts << @pastel.dim(@pastel.white(cost_display))
 
-          session_line = " " + parts.join(separator)
-          print_with_padding(session_line)
+          " " + parts.join(separator)
+        end
+        
+        # Truncate session bar content to fit within max length
+        # @param content [String] Full session bar content with ANSI codes
+        # @param max_length [Integer] Maximum visible length
+        # @return [String] Truncated content
+        private def truncate_sessionbar_content(content, max_length)
+          # Strip ANSI codes to calculate visible length
+          visible_content = strip_ansi_codes(content)
+          visible_width = calculate_display_width(visible_content)
+          
+          return content if visible_width <= max_length
+          
+          # Truncate from the end with "..." indicator
+          chars = visible_content.chars
+          current_width = 0
+          truncate_at = 0
+          
+          chars.each_with_index do |char, idx|
+            char_width = char_display_width(char)
+            if current_width + char_width + 3 > max_length  # Reserve 3 for "..."
+              truncate_at = idx
+              break
+            end
+            current_width += char_width
+            truncate_at = idx + 1
+          end
+          
+          # For simplicity with ANSI codes, just show first part + ...
+          # This is a simplified version - proper implementation would preserve ANSI codes
+          visible_content[0...truncate_at] + "..."
+        end
+        
+        # Calculate how many rows the session bar will occupy
+        # @return [Integer] Number of rows needed
+        private def calculate_sessionbar_height
+          return 1 unless @sessionbar_info[:working_dir]
+          
+          # Session bar always renders on one line (we truncate if needed)
+          1
         end
 
         def shorten_path(path)