openclacky 0.5.4 → 0.5.6

data/lib/clacky/ui/enhanced_prompt.rb

@@ -9,7 +9,7 @@ require "base64"
 module Clacky
   module UI
     # Enhanced input prompt with multi-line support and image paste
-    # 
+    #
     # Features:
     # - Shift+Enter: Add new line
     # - Enter: Submit message
@@ -20,6 +20,7 @@ module Clacky
 
       def initialize
         @pastel = Pastel.new
+        @formatter = Formatter.new
         @images = [] # Array of image file paths
         @paste_counter = 0 # Counter for paste operations
         @paste_placeholders = {} # Map of placeholder text to actual pasted content
@@ -28,9 +29,13 @@ module Clacky
       end
 
       # Read user input with enhanced features
-      # @param prefix [String] Prompt prefix (default: "You:")
-      # @return [Hash, nil] { text: String, images: Array } or nil on EOF
-      def read_input(prefix: "You:")
+      # @param prefix [String] Prompt prefix (default: "❯")
+      # @param block [Proc] Optional callback when Shift+Tab is pressed (receives display_lines)
+      # @return [Hash, nil] Returns:
+      #   - { text: String, images: Array } for normal input
+      #   - { command: Symbol } for commands (:clear, :exit)
+      #   - nil on EOF
+      def read_input(prefix: "❯", &block)
         @images = []
         lines = []
         cursor_pos = 0
@@ -38,8 +43,8 @@ module Clacky
         @last_ctrl_c_time = nil  # Track when Ctrl+C was last pressed
 
         loop do
-          # Display the prompt box
-          display_prompt_box(lines, prefix, line_index, cursor_pos)
+          # Display the prompt (simplified version)
+          display_simple_prompt(lines, prefix, line_index, cursor_pos)
 
           # Read a single character/key
           begin
@@ -47,18 +52,18 @@ module Clacky
           rescue Interrupt
             return nil
           end
-          
+
           # Handle buffered rapid input (system paste detection)
           if key.is_a?(Hash) && key[:type] == :rapid_input
             pasted_text = key[:text]
-            pasted_lines = pasted_text.split("\n")
-            
+            pasted_lines = pasted_text.split(/\r\n|\r|\n/)
+
             if pasted_lines.size > 1
               # Multi-line rapid input - use placeholder for display
               @paste_counter += 1
               placeholder = "[##{@paste_counter} Paste Text]"
               @paste_placeholders[placeholder] = pasted_text
-              
+
               # Insert placeholder at cursor position
               chars = (lines[line_index] || "").chars
               placeholder_chars = placeholder.chars
@@ -91,9 +96,34 @@ module Clacky
             cursor_pos = 0
 
           when "\r" # Enter - submit
+            # Check if it's a command
+            input_text = lines.join("\n").strip
+
+            if input_text.start_with?('/')
+              clear_simple_prompt(lines.size)
+
+              # Parse command
+              case input_text
+              when '/clear'
+                @last_display_lines = 0  # Reset so CLI messages won't be cleared
+                return { command: :clear }
+              when '/exit', '/quit'
+                @last_display_lines = 0  # Reset before exit
+                return { command: :exit }
+              else
+                # Unknown command - show error and continue
+                @formatter.warning("Unknown command: #{input_text} (Available: /clear, /exit)")
+                @last_display_lines = 0  # Reset so next display won't clear these messages
+                lines = []
+                cursor_pos = 0
+                line_index = 0
+                next
+              end
+            end
+
             # Submit if not empty
-            unless lines.join.strip.empty? && @images.empty?
-              clear_prompt_display(lines.size)
+            unless input_text.empty? && @images.empty?
+              clear_simple_prompt(lines.size)
               # Replace placeholders with actual pasted content
               final_text = expand_placeholders(lines.join("\n"))
               return { text: final_text, images: @images.dup }
@@ -102,15 +132,15 @@ module Clacky
           when "\u0003" # Ctrl+C
             # Check if input is empty
             has_content = lines.any? { |line| !line.strip.empty? } || @images.any?
-            
+
             if has_content
               # Input has content - clear it on first Ctrl+C
               current_time = Time.now.to_f
               time_since_last = @last_ctrl_c_time ? (current_time - @last_ctrl_c_time) : Float::INFINITY
-              
+
               if time_since_last < 2.0  # Within 2 seconds of last Ctrl+C
                 # Second Ctrl+C within 2 seconds - exit
-                clear_prompt_display(lines.size)
+                clear_simple_prompt(lines.size)
                 return nil
               else
                 # First Ctrl+C - clear content
@@ -124,26 +154,58 @@ module Clacky
               end
             else
               # Input is empty - exit immediately
-              clear_prompt_display(lines.size)
+              clear_simple_prompt(lines.size)
               return nil
             end
 
           when "\u0016" # Ctrl+V - Paste
             pasted = paste_from_clipboard
             if pasted[:type] == :image
-              # Save image and add to list
-              @images << pasted[:path]
+              # Save image and add to list (max 3 images)
+              if @images.size < 3
+                @images << pasted[:path]
+              else
+                # Show warning below input box (without extra newline)
+                @formatter.warning("Maximum 3 images allowed. Delete an image first (Ctrl+D).")
+
+                # Wait a moment for user to see the message
+                sleep(1.5)
+
+                # Clear the warning line
+                print "\r\e[2K"  # Clear current line
+
+                # Now clear the entire input box using the saved line count
+                if @last_display_lines && @last_display_lines > 0
+                  # Move up to the first line of input box
+                  (@last_display_lines - 1).times do
+                    print "\e[1A"
+                  end
+                  # Clear all lines
+                  @last_display_lines.times do |i|
+                    print "\r\e[2K"
+                    print "\e[1B" if i < @last_display_lines - 1
+                  end
+                  # Move back to the first line
+                  (@last_display_lines - 1).times do
+                    print "\e[1A"
+                  end
+                  print "\r"
+                end
+
+                # Reset display state so next display will redraw
+                @last_display_lines = 0
+              end
             else
               # Handle pasted text
               pasted_text = pasted[:text]
-              pasted_lines = pasted_text.split("\n")
-              
+              pasted_lines = pasted_text.split(/\r\n|\r|\n/)
+
               if pasted_lines.size > 1
                 # Multi-line paste - use placeholder for display
                 @paste_counter += 1
                 placeholder = "[##{@paste_counter} Paste Text]"
                 @paste_placeholders[placeholder] = pasted_text
-                
+
                 # Insert placeholder at cursor position
                 chars = (lines[line_index] || "").chars
                 placeholder_chars = placeholder.chars
@@ -196,12 +258,140 @@ module Clacky
           when "\e[D" # Left arrow
             cursor_pos = [cursor_pos - 1, 0].max
 
+          # Ignore Shift+Arrow keys (they produce sequences like \e[1;2A, \e[1;2B, etc.)
+          when /\e\[1;2[ABCD]/
+            # Do nothing - ignore Shift+Arrow keys
+
+          when "\e[Z" # Shift+Tab - Toggle auto-approve mode
+            # Call the block to update status bar if provided
+            if block
+              block.call(@last_display_lines)
+            end
+            # Continue the input loop, don't return
+
+          when "\u0001" # Ctrl+A - Move to beginning of line
+            cursor_pos = 0
+
+          when "\u0005" # Ctrl+E - Move to end of line
+            current_line = lines[line_index] || ""
+            cursor_pos = current_line.chars.length
+
+          when "\u0006" # Ctrl+F - Move forward one character
+            current_line = lines[line_index] || ""
+            cursor_pos = [cursor_pos + 1, current_line.chars.length].min
+
+          when "\u0002" # Ctrl+B - Move backward one character
+            cursor_pos = [cursor_pos - 1, 0].max
+
+          when "\u000B" # Ctrl+K - Delete from cursor to end of line
+            current_line = lines[line_index] || ""
+            chars = current_line.chars
+            lines[line_index] = chars[0...cursor_pos].join
+
+          when "\u0015" # Ctrl+U - Delete from beginning of line to cursor
+            current_line = lines[line_index] || ""
+            chars = current_line.chars
+            lines[line_index] = chars[cursor_pos..-1].join || ""
+            cursor_pos = 0
+
+          when "\u0017" # Ctrl+W - Delete previous word
+            current_line = lines[line_index] || ""
+            chars = current_line.chars
+
+            # Find the start of the previous word
+            pos = cursor_pos - 1
+
+            # Skip trailing whitespace
+            while pos >= 0 && chars[pos] =~ /\s/
+              pos -= 1
+            end
+
+            # Delete word characters
+            while pos >= 0 && chars[pos] =~ /\S/
+              pos -= 1
+            end
+
+            # Delete from pos+1 to cursor_pos
+            delete_start = pos + 1
+            chars.slice!(delete_start...cursor_pos)
+            lines[line_index] = chars.join
+            cursor_pos = delete_start
+
           when "\u0004" # Ctrl+D - Delete image by number
             if @images.any?
-              print "\nEnter image number to delete (1-#{@images.size}): "
-              num = STDIN.gets.to_i
-              if num > 0 && num <= @images.size
-                @images.delete_at(num - 1)
+              # If only one image, delete it directly
+              if @images.size == 1
+                @images.clear
+
+                # Clear the entire input box
+                if @last_display_lines && @last_display_lines > 0
+                  # Move up to the first line of input box
+                  (@last_display_lines - 1).times do
+                    print "\e[1A"
+                  end
+                  # Clear all lines
+                  @last_display_lines.times do |i|
+                    print "\r\e[2K"
+                    print "\e[1B" if i < @last_display_lines - 1
+                  end
+                  # Move back to the first line
+                  (@last_display_lines - 1).times do
+                    print "\e[1A"
+                  end
+                  print "\r"
+                end
+
+                # Reset so next display starts fresh
+                @last_display_lines = 0
+              else
+                # Multiple images - ask which one to delete
+                # Move cursor to after the input box to show prompt
+                print "\n"
+                print "Delete image (1-#{@images.size}): "
+                $stdout.flush
+
+                # Read single character without waiting for Enter
+                deleted = false
+                $stdin.raw do |io|
+                  char = io.getc
+                  num = char.to_i
+
+                  # Delete if valid number
+                  if num > 0 && num <= @images.size
+                    @images.delete_at(num - 1)
+                    print "#{num} ✓"
+                    deleted = true
+                  else
+                    print "✗"
+                  end
+                end
+
+                # Clear the prompt lines
+                print "\r\e[2K"  # Clear current line
+                print "\e[1A"    # Move up one line
+                print "\r\e[2K"  # Clear the prompt line
+
+                # Now clear the entire input box using the saved line count
+                if @last_display_lines && @last_display_lines > 0
+                  # We're now at the position where the input box ends
+                  # Move up to the first line of input box
+                  (@last_display_lines - 1).times do
+                    print "\e[1A"
+                  end
+                  # Clear all lines
+                  @last_display_lines.times do |i|
+                    print "\r\e[2K"
+                    print "\e[1B" if i < @last_display_lines - 1
+                  end
+                  # Move back to the first line
+                  (@last_display_lines - 1).times do
+                    print "\e[1A"
+                  end
+                  print "\r"
+                end
+
+                # Reset so next display starts fresh
+                @last_display_lines = 0
               end
             end
 
@@ -210,7 +400,7 @@ module Clacky
             if key.length >= 1 && key != "\e" && !key.start_with?("\e") && key.ord >= 32
               lines[line_index] ||= ""
               current_line = lines[line_index]
-              
+
               # Insert character at cursor position (using character index, not byte index)
               chars = current_line.chars
               chars.insert(cursor_pos, key)
@@ -226,203 +416,139 @@ module Clacky
 
       private
 
-      # Expand placeholders to actual pasted content
-      def expand_placeholders(text)
-        result = text.dup
-        @paste_placeholders.each do |placeholder, actual_content|
-          result.gsub!(placeholder, actual_content)
-        end
-        result
-      end
+      # Display simplified prompt (just prefix and input, no box)
+      def display_simple_prompt(lines, prefix, line_index, cursor_pos)
+        # Hide terminal cursor (we render our own)
+        print "\e[?25l"
 
-      # Display the prompt box with images and input
-      def display_prompt_box(lines, prefix, line_index, cursor_pos)
-        width = TTY::Screen.width - 4  # Use full terminal width (minus 4 for borders)
+        lines_to_display = []
 
-        # Clear previous display if exists
-        if @last_display_lines && @last_display_lines > 0
-          # Move cursor up and clear each line
-          @last_display_lines.times do
-            print "\e[1A"  # Move up one line
-            print "\e[2K"  # Clear entire line
-          end
-          print "\r"  # Move to beginning of line
-        end
+        # Get terminal width for full-width separator
+        term_width = TTY::Screen.width
 
-        lines_to_display = []
+        # Top separator line (full width)
+        lines_to_display << @pastel.dim("─" * term_width)
 
-        # Display images if any
+        # Show images if any
         if @images.any?
-          lines_to_display << @pastel.dim("╭─ Attached Images " + "─" * (width - 19) + "╮")
           @images.each_with_index do |img_path, idx|
             filename = File.basename(img_path)
-            # Check if file exists before getting size
             filesize = File.exist?(img_path) ? format_filesize(File.size(img_path)) : "N/A"
-            line_content = " #{idx + 1}. #{filename} (#{filesize})"
-            display_content = line_content.ljust(width - 2)
-            lines_to_display << @pastel.dim("│ ") + display_content + @pastel.dim(" │")
+            line = @pastel.dim("[Image #{idx + 1}] #{filename} (#{filesize}) (Ctrl+D to delete)")
+            lines_to_display << line
           end
-          lines_to_display << @pastel.dim("╰" + "─" * width + "╯")
-          lines_to_display << ""
         end
 
-        # Display input box
-        hint = "Shift+Enter:newline | Enter:submit | Ctrl+C:cancel"
-        lines_to_display << @pastel.dim("╭─ Message " + "─" * (width - 10) + "╮")
-        hint_line = @pastel.dim(hint)
-        padding = " " * [(width - hint.length - 2), 0].max
-        lines_to_display << @pastel.dim("│ ") + hint_line + padding + @pastel.dim(" │")
-        lines_to_display << @pastel.dim("├" + "─" * width + "┤")
-
-        # Display input lines with word wrap
+        # Display input lines
         display_lines = lines.empty? ? [""] : lines
-        max_display_lines = 15 # Show up to 15 wrapped lines
-        
-        # Flatten all lines with word wrap
-        wrapped_display_lines = []
-        line_to_wrapped_mapping = [] # Track which original line each wrapped line belongs to
-        
-        display_lines.each_with_index do |line, original_idx|
-          line_chars = line.chars
-          content_width = width - 2 # Available width for content (excluding borders)
-          
-          if line_chars.length <= content_width
-            # Line fits in one display line
-            wrapped_display_lines << { text: line, original_line: original_idx, start_pos: 0 }
+
+        display_lines.each_with_index do |line, idx|
+          if idx == 0
+            # First line with prefix
+            if idx == line_index
+              # Show cursor on this line
+              chars = line.chars
+              before_cursor = chars[0...cursor_pos].join
+              cursor_char = chars[cursor_pos] || " "
+              after_cursor = chars[(cursor_pos + 1)..-1]&.join || ""
+
+              line_display = "#{prefix} #{before_cursor}#{@pastel.on_white(@pastel.black(cursor_char))}#{after_cursor}"
+              lines_to_display << line_display
+            else
+              lines_to_display << "#{prefix} #{line}"
+            end
           else
-            # Line needs wrapping
-            start_pos = 0
-            while start_pos < line_chars.length
-              chunk_chars = line_chars[start_pos...[start_pos + content_width, line_chars.length].min]
-              wrapped_display_lines << { 
-                text: chunk_chars.join, 
-                original_line: original_idx, 
-                start_pos: start_pos 
-              }
-              start_pos += content_width
+            # Continuation lines (indented to align with first line content)
+            indent = " " * (prefix.length + 1)
+            if idx == line_index
+              # Show cursor on this line
+              chars = line.chars
+              before_cursor = chars[0...cursor_pos].join
+              cursor_char = chars[cursor_pos] || " "
+              after_cursor = chars[(cursor_pos + 1)..-1]&.join || ""
+
+              line_display = "#{indent}#{before_cursor}#{@pastel.on_white(@pastel.black(cursor_char))}#{after_cursor}"
+              lines_to_display << line_display
+            else
+              lines_to_display << "#{indent}#{line}"
             end
           end
         end
-        
-        # Find which wrapped line contains the cursor
-        cursor_wrapped_line_idx = 0
-        cursor_in_wrapped_pos = cursor_pos
-        content_width = width - 2
-        
-        # Find all wrapped lines for the current line_index
-        current_line_wrapped = wrapped_display_lines.select.with_index { |wl, idx| wl[:original_line] == line_index }
-        
-        if current_line_wrapped.any?
-          # Iterate through wrapped lines to find where cursor belongs
-          accumulated_chars = 0
-          found = false
-          
-          current_line_wrapped.each_with_index do |wrapped_line, local_idx|
-            line_start = wrapped_line[:start_pos]
-            line_length = wrapped_line[:text].chars.length
-            line_end = line_start + line_length
-            
-            # Find global index of this wrapped line
-            global_idx = wrapped_display_lines.index { |wl| wl == wrapped_line }
-            
-            if cursor_pos >= line_start && cursor_pos < line_end
-              # Cursor is within this wrapped line
-              cursor_wrapped_line_idx = global_idx
-              cursor_in_wrapped_pos = cursor_pos - line_start
-              found = true
-              break
-            elsif cursor_pos == line_end && local_idx == current_line_wrapped.length - 1
-              # Cursor is at the very end of the last wrapped line for this line_index
-              cursor_wrapped_line_idx = global_idx
-              cursor_in_wrapped_pos = line_length
-              found = true
-              break
-            end
-          end
-          
-          # Fallback: if not found, place cursor at the end of the last wrapped line
-          unless found
-            last_wrapped = current_line_wrapped.last
-            cursor_wrapped_line_idx = wrapped_display_lines.index { |wl| wl == last_wrapped }
-            cursor_in_wrapped_pos = last_wrapped[:text].chars.length
+
+        # Bottom separator line (full width)
+        lines_to_display << @pastel.dim("─" * term_width)
+
+        # Different rendering strategy for first display vs updates
+        if @last_display_lines && @last_display_lines > 0
+          # Update mode: move to start and overwrite (no flicker)
+          # Move up to the first line (N-1 times since we're on line N)
+          (@last_display_lines - 1).times do
+            print "\e[1A"  # Move up one line
           end
-        end
-        
-        # Determine which wrapped lines to display (centered around cursor)
-        if wrapped_display_lines.size <= max_display_lines
-          display_start = 0
-          display_end = wrapped_display_lines.size - 1
-        else
-          # Center view around cursor line
-          half_display = max_display_lines / 2
-          display_start = [cursor_wrapped_line_idx - half_display, 0].max
-          display_end = [display_start + max_display_lines - 1, wrapped_display_lines.size - 1].min
-          
-          # Adjust if we're near the end
-          if display_end - display_start < max_display_lines - 1
-            display_start = [display_end - max_display_lines + 1, 0].max
+          print "\r"  # Move to beginning of line
+
+          # Output lines by overwriting
+          lines_to_display.each_with_index do |line, idx|
+            print "\r\e[K"  # Clear current line from cursor to end
+            print line
+            print "\n" if idx < lines_to_display.size - 1  # Newline except last line
           end
-        end
-        
-        # Display the wrapped lines
-        (display_start..display_end).each do |idx|
-          wrapped_line = wrapped_display_lines[idx]
-          line_text = wrapped_line[:text]
-          line_chars = line_text.chars
-          content_width = width - 2
-          
-          # Pad to full width
-          display_line = line_text.ljust(content_width)
-          
-          if idx == cursor_wrapped_line_idx
-            # Show cursor on this wrapped line
-            before_cursor = line_chars[0...cursor_in_wrapped_pos].join
-            cursor_char = line_chars[cursor_in_wrapped_pos] || " "
-            after_cursor_chars = line_chars[(cursor_in_wrapped_pos + 1)..-1]
-            after_cursor = after_cursor_chars ? after_cursor_chars.join : ""
-            
-            # Calculate padding
-            content_length = before_cursor.length + 1 + after_cursor.length
-            padding = " " * [content_width - content_length, 0].max
-            
-            line_display = before_cursor + @pastel.on_white(@pastel.black(cursor_char)) + after_cursor + padding
-            lines_to_display << @pastel.dim("│ ") + line_display + @pastel.dim(" │")
-          else
-            lines_to_display << @pastel.dim("│ ") + display_line + @pastel.dim(" │")
+
+          # If new display has fewer lines than old, clear the extra lines
+          if lines_to_display.size < @last_display_lines - 1
+            extra_lines = @last_display_lines - 1 - lines_to_display.size
+            extra_lines.times do
+              print "\n\r\e[K"  # Move down and clear line
+            end
+            # Move back up to the last line of new display
+            extra_lines.times do
+              print "\e[1A"
+            end
           end
+
+          print "\n"  # Move cursor to next line
+        else
+          # First display: use simple newline approach
+          print lines_to_display.join("\n")
+          print "\n"
         end
-        
-        # Show scroll indicator if needed
-        if wrapped_display_lines.size > max_display_lines
-          scroll_info = " (#{display_start + 1}-#{display_end + 1}/#{wrapped_display_lines.size} lines) "
-          lines_to_display << @pastel.dim("│#{scroll_info.center(width)}│")
-        end
 
-        # Footer - calculate width properly
-        footer_text = "Line #{line_index + 1}/#{display_lines.size} | Char #{cursor_pos}/#{(display_lines[line_index] || "").chars.length}"
-        # Total width = "╰─ " (3) + footer_text + " ─...─╯" (width - 3 - footer_text.length)
-        remaining_width = width - footer_text.length - 3  # 3 = "╰─ " length
-        footer_line = @pastel.dim("╰─ ") + @pastel.dim(footer_text) + @pastel.dim(" ") + @pastel.dim("─" * [remaining_width - 1, 0].max) + @pastel.dim("╯")
-        lines_to_display << footer_line
-        
-        # Output all lines at once (use print to avoid extra newline at the end)
-        print lines_to_display.join("\n")
-        print "\n"  # Add one controlled newline
-        
-        # Remember how many lines we displayed
-        @last_display_lines = lines_to_display.size
+        # Flush output to ensure it's displayed immediately
+        $stdout.flush
+
+        # Remember how many lines we displayed (including the newline)
+        @last_display_lines = lines_to_display.size + 1
       end
 
-      # Clear prompt display after submission
-      def clear_prompt_display(num_lines)
-        # Clear the prompt box we just displayed
+      # Clear simple prompt display
+      def clear_simple_prompt(num_lines)
         if @last_display_lines && @last_display_lines > 0
-          @last_display_lines.times do
+          # Move up to the first line (N-1 times since we're on line N)
+          (@last_display_lines - 1).times do
             print "\e[1A"  # Move up one line
-            print "\e[2K"  # Clear entire line
+          end
+          # Now we're on the first line, clear all N lines
+          @last_display_lines.times do |i|
+            print "\r\e[2K"  # Move to beginning and clear entire line
+            print "\e[1B" if i < @last_display_lines - 1  # Move down (except last line)
+          end
+          # Move back to the first line
+          (@last_display_lines - 1).times do
+            print "\e[1A"
           end
           print "\r"  # Move to beginning of line
         end
+        # Show terminal cursor again
+        print "\e[?25h"
+      end
+
+      # Expand placeholders to actual pasted content
+      def expand_placeholders(text)
+        result = text.dup
+        @paste_placeholders.each do |placeholder, actual_content|
+          result.gsub!(placeholder, actual_content)
+        end
+        result
       end
 
       # Read a single key press with escape sequence handling
@@ -430,74 +556,91 @@ module Clacky
       # Also detects rapid input (paste-like behavior)
       def read_key_with_rapid_detection
         $stdin.set_encoding('UTF-8')
-        
+
         current_time = Time.now.to_f
         is_rapid_input = @last_input_time && (current_time - @last_input_time) < @rapid_input_threshold
         @last_input_time = current_time
-        
+
         $stdin.raw do |io|
           io.set_encoding('UTF-8')  # Ensure IO encoding is UTF-8
           c = io.getc
-          
+
           # Ensure character is UTF-8 encoded
           c = c.force_encoding('UTF-8') if c.is_a?(String) && c.encoding != Encoding::UTF_8
-          
+
           # Handle escape sequences (arrow keys, special keys)
           if c == "\e"
-            # Read the next 2 characters for escape sequences
+            # Read the next character to determine sequence type
             begin
-              extra = io.read_nonblock(2)
-              extra = extra.force_encoding('UTF-8') if extra.encoding != Encoding::UTF_8
-              c = c + extra
+              next_char = io.read_nonblock(1)
+              next_char = next_char.force_encoding('UTF-8') if next_char.encoding != Encoding::UTF_8
+              c = c + next_char
+
+              # If it's a CSI sequence (starts with [)
+              if next_char == "["
+                # Read until we get a letter (the final character of CSI sequence)
+                # This handles both simple sequences like \e[A and complex ones like \e[1;2D
+                loop do
+                  if IO.select([io], nil, nil, 0.01)  # 10ms timeout
+                    char = io.read_nonblock(1)
+                    char = char.force_encoding('UTF-8') if char.encoding != Encoding::UTF_8
+                    c = c + char
+                    # Break if we got a letter (final character of CSI sequence)
+                    break if char =~ /[A-Za-z~]/
+                  else
+                    break
+                  end
+                end
+              end
             rescue IO::WaitReadable, Errno::EAGAIN
               # No more characters available
             end
             return c
           end
-          
+
           # Check if there are more characters available using IO.select with timeout 0
           has_more_input = IO.select([io], nil, nil, 0)
-          
+
           # If this is rapid input or there are more characters available
           if is_rapid_input || has_more_input
             # Buffer rapid input
             buffer = c.to_s.dup
             buffer.force_encoding('UTF-8')
-            
+
             # Keep reading available characters
             loop do
               begin
                 next_char = io.read_nonblock(1)
                 next_char = next_char.force_encoding('UTF-8') if next_char.encoding != Encoding::UTF_8
                 buffer << next_char
-                
+
                 # Continue only if more characters are immediately available
                 break unless IO.select([io], nil, nil, 0)
               rescue IO::WaitReadable, Errno::EAGAIN
                 break
               end
             end
-            
+
             # Ensure buffer is UTF-8
             buffer.force_encoding('UTF-8')
-            
+
             # If we buffered multiple characters or newlines, treat as rapid input (paste)
             if buffer.length > 1 || buffer.include?("\n") || buffer.include?("\r")
               # Remove any trailing \r or \n from rapid input buffer
               cleaned_buffer = buffer.gsub(/[\r\n]+\z/, '')
               return { type: :rapid_input, text: cleaned_buffer } if cleaned_buffer.length > 0
             end
-            
+
             # Single character rapid input, return as-is
             return buffer[0] if buffer.length == 1
           end
-          
+
           c
         end
       rescue Errno::EINTR
         "\u0003" # Treat interrupt as Ctrl+C
       end
-      
+
       # Legacy method for compatibility
       def read_key
         read_key_with_rapid_detection
@@ -522,17 +665,17 @@ module Clacky
       def paste_from_clipboard_macos
         require 'shellwords'
         require 'fileutils'
-        
+
         # First check if there's an image in clipboard
         # Use osascript to check clipboard content type
         has_image = system("osascript -e 'try' -e 'the clipboard as «class PNGf»' -e 'on error' -e 'return false' -e 'end try' >/dev/null 2>&1")
-        
+
         if has_image
           # Create a persistent temporary file (won't be auto-deleted)
           temp_dir = Dir.tmpdir
           temp_filename = "clipboard-#{Time.now.to_i}-#{rand(10000)}.png"
           temp_path = File.join(temp_dir, temp_filename)
-          
+
           # Extract image using osascript
           script = <<~APPLESCRIPT
             set png_data to the clipboard as «class PNGf»
@@ -540,9 +683,9 @@ module Clacky
             write png_data to the_file
             close access the_file
           APPLESCRIPT
-          
+
           success = system("osascript", "-e", script, out: File::NULL, err: File::NULL)
-          
+
           if success && File.exist?(temp_path) && File.size(temp_path) > 0
             return { type: :image, path: temp_path }
           end
@@ -562,13 +705,13 @@ module Clacky
       # Paste from Linux clipboard
       def paste_from_clipboard_linux
         require 'shellwords'
-        
+
         # Check if xclip is available
         if system("which xclip >/dev/null 2>&1")
           # Try to get image first
           temp_file = Tempfile.new(["clipboard-", ".png"])
           temp_file.close
-          
+
           # Try different image MIME types
           ["image/png", "image/jpeg", "image/jpg"].each do |mime_type|
             if system("xclip -selection clipboard -t #{mime_type} -o > #{Shellwords.escape(temp_file.path)} 2>/dev/null")
@@ -577,7 +720,7 @@ module Clacky
               end
             end
           end
-          
+
           # No image, get text - ensure UTF-8 encoding
           text = `xclip -selection clipboard -o 2>/dev/null`.to_s
           text.force_encoding('UTF-8')
@@ -601,7 +744,7 @@ module Clacky
         # Try to get image using PowerShell
         temp_file = Tempfile.new(["clipboard-", ".png"])
         temp_file.close
-        
+
         ps_script = <<~POWERSHELL
           Add-Type -AssemblyName System.Windows.Forms
           $img = [Windows.Forms.Clipboard]::GetImage()
@@ -612,9 +755,9 @@ module Clacky
             exit 1
           }
         POWERSHELL
-        
+
         success = system("powershell", "-NoProfile", "-Command", ps_script, out: File::NULL, err: File::NULL)
-        
+
         if success && File.exist?(temp_file.path) && File.size(temp_file.path) > 0
           return { type: :image, path: temp_file.path }
         end