openclacky 0.7.0 → 0.7.2

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

@@ -17,20 +17,39 @@ module Clacky
           @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
+        # @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" }
-        # @return [Hash, nil] Hash of field values, or nil if cancelled
-        def show(title:, fields:, validator: nil)
+        # @return [Hash, nil] Hash of field values or selected value, or nil if cancelled
+        def show(title:, fields: nil, choices: nil, validator: nil)
           @title = title
-          @fields = fields
+          @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 for menu mode
+          if @mode == :menu
+            visible_items = [@choices.length, 15].min
+            @height = visible_items + 4  # +4 for title, borders, and instructions
+          end
 
           # Get terminal size
           term_height, term_width = IO.console.winsize
@@ -40,60 +59,12 @@ module Clacky
           start_col = [(term_width - @width) / 2, 1].max
 
           begin
-            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|
-                value = collect_field_input(field, 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 @pastel.cyan("⏳ Testing connection...")
-                STDOUT.flush
-                
-                validation_result = validator.call(@values)
-                
-                # Clear testing message
-                print "\e[#{testing_row};#{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
-                  @error_message = validation_result[:error] || "Validation failed"
-                  # Clear modal to redraw with error
-                  clear_modal(start_row, start_col)
-                  sleep 1.5  # Give user time to read the error
-                end
-              else
-                # No validator - return immediately
-                print "\e[?25l"
-                return @values
-              end
+            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
@@ -109,6 +80,101 @@ module Clacky
 
         private
 
+        # 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"
+            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
@@ -167,8 +233,9 @@ module Clacky
               # Show placeholder in dim gray
               display_text = @pastel.dim(placeholder)
             elsif field[:mask]
-              # Show masked input
-              display_text = @pastel.cyan('*' * buffer.length)
+              # 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)
@@ -232,13 +299,17 @@ module Clacky
 
         # 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
           
-          formatted = @pastel.red("⚠ #{error_text}")
-          print "\e[#{row};#{error_col}H#{formatted}"
+          # 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
@@ -257,6 +328,72 @@ module Clacky
             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

data/lib/clacky/ui2/layout_manager.rb

@@ -15,6 +15,7 @@ module Clacky
         @render_mutex = Mutex.new
         @output_row = 0  # Track current output row position
         @last_fixed_area_height = 0  # Track previous fixed area height to detect shrinkage
+        @fullscreen_mode = false  # Track if in fullscreen mode
 
         calculate_layout
         setup_resize_handler
@@ -92,10 +93,9 @@ module Clacky
       def position_inline_input_cursor(inline_input)
         return unless inline_input
 
-        # Use the shared method from LineEditor to calculate cursor position with wrap
-        prompt = inline_input.prompt
+        # Use InlineInput's method to calculate cursor position (handles continuation prompt correctly)
         width = screen.width
-        wrap_row, wrap_col = inline_input.cursor_position_with_wrap(prompt, width)
+        wrap_row, wrap_col = inline_input.cursor_position_for_display(width)
 
         # Get the number of lines InlineInput occupies (considering wrapping)
         line_count = inline_input.line_count(width)
@@ -156,7 +156,7 @@ module Clacky
             screen.move_cursor(row, 0)
             screen.clear_line
           end
-          
+
           # Move cursor to start of a new line after last output
           # Use \r to ensure we're at column 0, then move down
           screen.move_cursor([@output_row, 0].max, 0)
@@ -175,10 +175,10 @@ module Clacky
             screen.move_cursor(row, 0)
             screen.clear_line
           end
-          
+
           # Reset output position to beginning
           @output_row = 0
-          
+
           # Re-render fixed areas to ensure they stay in place
           render_fixed_areas
           screen.flush
@@ -316,33 +316,31 @@ module Clacky
         screen.flush
       end
 
-      private
-
       # Write a single line to output area
       # Handles scrolling when reaching fixed area
       # @param line [String] Single line to write (should not contain newlines)
       def write_output_line(line)
         # Calculate where fixed area starts (this is where output area ends)
         max_output_row = fixed_area_start_row
-        
+
         # If we're about to write into the fixed area, scroll first
         if @output_row >= max_output_row
           # Trigger terminal scroll by printing newline at bottom
           screen.move_cursor(screen.height - 1, 0)
           print "\n"
-          
+
           # After scroll, position to write at the last row of output area
           @output_row = max_output_row - 1
-          
+
           # Important: Re-render fixed areas after scroll to prevent corruption
           render_fixed_areas
         end
-        
+
         # Now write the line at current position
         screen.move_cursor(@output_row, 0)
         screen.clear_line
         print line
-        
+
         # Move to next row for next write
         @output_row += 1
       end
@@ -353,26 +351,26 @@ module Clacky
       # @return [Array<String>] Array of wrapped lines
       def wrap_long_line(line)
         return [""] if line.nil? || line.empty?
-        
+
         max_width = screen.width
         return [line] if max_width <= 0
-        
+
         # Strip ANSI codes for width calculation
         visible_line = line.gsub(/\e\[[0-9;]*m/, '')
-        
+
         # Check if line needs wrapping
         display_width = calculate_display_width(visible_line)
         return [line] if display_width <= max_width
-        
+
         # Line needs wrapping - split by considering display width
         wrapped = []
         current_line = ""
         current_width = 0
         ansi_codes = []  # Track ANSI codes to carry over
-        
+
         # Extract ANSI codes and text segments
         segments = line.split(/(\e\[[0-9;]*m)/)
-        
+
         segments.each do |segment|
           if segment =~ /^\e\[[0-9;]*m$/
             # ANSI code - add to current codes
@@ -382,7 +380,7 @@ module Clacky
             # Text segment - process character by character
             segment.each_char do |char|
               char_width = char_display_width(char)
-              
+
               if current_width + char_width > max_width && !current_line.empty?
                 # Complete current line
                 wrapped << current_line
@@ -390,19 +388,19 @@ module Clacky
                 current_line = ansi_codes.join
                 current_width = 0
               end
-              
+
               current_line += char
               current_width += char_width
             end
           end
         end
-        
+
         # Add remaining content
         wrapped << current_line unless current_line.empty? || current_line == ansi_codes.join
-        
+
         wrapped.empty? ? [""] : wrapped
       end
-      
+
       # Calculate display width of a single character
       # @param char [String] Single character
       # @return [Integer] Display width (1 or 2)
@@ -427,7 +425,7 @@ module Clacky
           1
         end
       end
-      
+
       # Calculate display width of a string (considering multi-byte characters)
       # @param text [String] Text to calculate
       # @return [Integer] Display width
@@ -504,6 +502,58 @@ module Clacky
         screen.show_cursor
       end
 
+      # Restore screen from fullscreen mode (re-render everything)
+      def restore_screen
+        @render_mutex.synchronize do
+          screen.clear_screen
+          screen.hide_cursor
+          render_all_internal
+        end
+      end
+
+      # Check if in fullscreen mode
+      # @return [Boolean]
+      def fullscreen_mode?
+        @fullscreen_mode
+      end
+
+      # Enter fullscreen mode with alternate screen buffer
+      # @param lines [Array<String>] Lines to display
+      # @param hint [String] Hint message at bottom
+      def enter_fullscreen(lines, hint: "Press Ctrl+O to return")
+        return if @fullscreen_mode
+        
+        @fullscreen_mode = true
+        
+        # Enter alternate screen buffer
+        print "\e[?1049h"
+        # Clear screen and move cursor to top
+        print "\e[2J\e[H"
+        $stdout.flush
+        
+        # Show all lines with proper line endings (CR+LF)
+        lines.each do |line|
+          # Strip trailing newline and print with CR+LF
+          print line.chomp + "\r\n"
+        end
+        
+        # Show hint at bottom
+        print "\r\n"
+        print "\e[36m#{hint}\e[0m\r\n"
+        $stdout.flush
+      end
+
+      # Exit fullscreen mode and restore previous screen
+      def exit_fullscreen
+        return unless @fullscreen_mode
+        
+        @fullscreen_mode = false
+        
+        # Exit alternate screen buffer (automatically restores previous screen)
+        print "\e[?1049l"
+        $stdout.flush
+      end
+
       # Setup handler for window resize
       def setup_resize_handler
         Signal.trap("WINCH") do

data/lib/clacky/ui2/line_editor.rb

@@ -7,6 +7,11 @@ module Clacky
     # LineEditor module provides single-line text editing functionality
     # Shared by InputArea and InlineInput components
     module LineEditor
+      # Maximum content width ratio (percentage of terminal width)
+      # Use 90% of terminal width for better readability on wide screens
+      # This dynamically adjusts based on terminal size
+      MAX_CONTENT_WIDTH_RATIO = 0.9
+
       attr_reader :cursor_position
 
       def initialize_line_editor
@@ -200,8 +205,9 @@ module Clacky
       # Get cursor position considering line wrapping
       # @param prompt [String] Prompt string before the line (may contain ANSI codes)
       # @param width [Integer] Terminal width for wrapping
+      # @param continuation_prompt [String] Prompt for continuation lines (default: "> ")
       # @return [Array<Integer>] Row and column position (0-indexed)
-      def cursor_position_with_wrap(prompt = "", width = TTY::Screen.width)
+      def cursor_position_with_wrap(prompt = "", width = TTY::Screen.width, continuation_prompt = "> ")
         return [0, cursor_column(prompt)] if width <= 0
 
         prompt_width = calculate_display_width(strip_ansi_codes(prompt))
@@ -232,7 +238,15 @@ module Clacky
         text_in_segment_before_cursor = chars[segment_start...(segment_start + cursor_pos_in_segment)].join
         display_width = calculate_display_width(text_in_segment_before_cursor)
 
-        col = prompt_width + display_width
+        # Use appropriate prompt width based on which segment (row) we're on
+        # First line uses original prompt, subsequent lines use continuation prompt
+        actual_prompt_width = if cursor_segment_idx == 0
+          prompt_width
+        else
+          calculate_display_width(strip_ansi_codes(continuation_prompt))
+        end
+
+        col = actual_prompt_width + display_width
         row = cursor_segment_idx
 
         [row, col]
@@ -309,6 +323,13 @@ module Clacky
         end
       end
 
+      # Calculate effective content width (respecting MAX_CONTENT_WIDTH_RATIO)
+      # @param screen_width [Integer] Terminal screen width
+      # @return [Integer] Effective content width to use
+      private def effective_content_width(screen_width)
+        (screen_width * MAX_CONTENT_WIDTH_RATIO).to_i
+      end
+
       # Render a segment of a line with cursor if cursor is in this segment
       # @param line [String] Full line text
       # @param segment_start [Integer] Start position of segment in line (char index)

data/lib/clacky/ui2/markdown_renderer.rb

@@ -17,10 +17,10 @@ module Clacky
           # Get current theme colors
           theme = ThemeManager.current_theme
 
-          # Configure tty-markdown colors based on current theme
-          # tty-markdown uses Pastel internally, we can configure symbols
+          # Configure tty-markdown with custom theme and symbols
           parsed = TTY::Markdown.parse(content, 
-            colors: theme_colors,
+            theme: theme_colors,
+            symbols: custom_symbols,
             width: TTY::Screen.width - 4  # Leave some margin
           )
 
@@ -57,21 +57,42 @@ module Clacky
           theme = ThemeManager.current_theme
 
           # Map our theme colors to tty-markdown's expected format
+          # Note: theme.colors values are already arrays, so we need to flatten when adding styles
           {
             # Headers use info color (cyan/blue)
-            header: theme.colors[:info],
+            h1: Array(theme.colors[:info]) + [:bold],
+            h2: Array(theme.colors[:info]) + [:bold],
+            h3: Array(theme.colors[:info]),
+            h4: Array(theme.colors[:info]),
+            h5: Array(theme.colors[:info]),
+            h6: Array(theme.colors[:info]),
+            # Horizontal rule - make it subtle (dim gray)
+            hr: [:bright_black],
             # Code blocks use dim color
-            code: theme.colors[:thinking],
+            code: Array(theme.colors[:thinking]),
             # Links use success color (green)
-            link: theme.colors[:success],
+            link: Array(theme.colors[:success]),
             # Lists use default text color
-            list: :bright_white,
+            list: [:bright_white],
             # Strong/bold use bright white
-            strong: :bright_white,
+            strong: [:bright_white, :bold],
             # Emphasis/italic use white
-            em: :white,
+            em: [:white],
             # Note/blockquote use dim color
-            note: theme.colors[:thinking],
+            note: Array(theme.colors[:thinking]),
+            quote: Array(theme.colors[:thinking]),
+          }
+        end
+
+        # Get custom symbols for markdown rendering
+        # @return [Hash] Symbol configuration for tty-markdown
+        def custom_symbols
+          {
+            override: {
+              # Make horizontal rule simpler - just a line without decorative diamonds
+              diamond: "",
+              line: "-"
+            }
           }
         end
       end

data/lib/clacky/ui2/screen_buffer.rb

@@ -224,10 +224,12 @@ module Clacky
         when "\u0006" then :ctrl_f
         when "\u000B" then :ctrl_k
         when "\u000C" then :ctrl_l
+        when "\u000F" then :ctrl_o
         when "\u0012" then :ctrl_r
         when "\u0015" then :ctrl_u
         when "\u0016" then :ctrl_v
         when "\u0017" then :ctrl_w
+        when "\t"     then :tab
         else char
         end
       end