openclacky 0.6.1 → 0.6.3

data/lib/clacky/ui2/layout_manager.rb

@@ -6,15 +6,15 @@ module Clacky
   module UI2
     # LayoutManager manages screen layout with split areas (output area on top, input area on bottom)
     class LayoutManager
-      attr_reader :screen, :output_area, :input_area, :todo_area
+      attr_reader :screen, :input_area, :todo_area
 
-      def initialize(output_area:, input_area:, todo_area: nil)
+      def initialize(input_area:, todo_area: nil)
         @screen = ScreenBuffer.new
-        @output_area = output_area
         @input_area = input_area
         @todo_area = todo_area
         @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
 
         calculate_layout
         setup_resize_handler
@@ -35,7 +35,6 @@ module Clacky
         @input_row = @todo_row + todo_height
 
         # Update component dimensions
-        @output_area.height = @output_height
         @input_area.row = @input_row
       end
 
@@ -93,10 +92,21 @@ module Clacky
       def position_inline_input_cursor(inline_input)
         return unless inline_input
 
-        # InlineInput renders its own visual cursor via render_line_with_cursor
-        # (white background on cursor character), so we don't need terminal cursor.
-        # Just hide the terminal cursor to avoid showing two cursors.
-        screen.hide_cursor
+        # Use the shared method from LineEditor to calculate cursor position with wrap
+        prompt = inline_input.prompt
+        width = screen.width
+        wrap_row, wrap_col = inline_input.cursor_position_with_wrap(prompt, width)
+
+        # Get the number of lines InlineInput occupies (considering wrapping)
+        line_count = inline_input.line_count(width)
+
+        # InlineInput starts at @output_row - line_count
+        # Cursor is at wrap_row within that
+        cursor_row = @output_row - line_count + wrap_row
+        cursor_col = wrap_col
+
+        # Move terminal cursor to the correct position
+        screen.move_cursor(cursor_row, cursor_col)
         screen.flush
       end
 
@@ -159,14 +169,16 @@ module Clacky
       # Clear output area (for /clear command)
       def clear_output
         @render_mutex.synchronize do
-          # Clear all lines in output area (from 0 to fixed_area_start - 1)
-          max_output_row = fixed_area_start_row
-          (0...max_output_row).each do |row|
+          # Clear all lines in output area (from 0 to where fixed area starts)
+          max_row = fixed_area_start_row
+          (0...max_row).each do |row|
             screen.move_cursor(row, 0)
             screen.clear_line
           end
-          # Reset output row position to start
+          
+          # Reset output position to beginning
           @output_row = 0
+          
           # Re-render fixed areas to ensure they stay in place
           render_fixed_areas
           screen.flush
@@ -174,89 +186,111 @@ module Clacky
       end
 
       # Append content to output area
-      # Track current row, scroll when reaching fixed area
-      # @param content [String] Content to append
+      # This is the main output method - handles scrolling and fixed area preservation
+      # @param content [String] Content to append (can be multi-line)
       def append_output(content)
         return if content.nil?
 
         @render_mutex.synchronize do
-          max_output_row = fixed_area_start_row - 1
-
-          # Special handling for empty string - just add a blank line
-          if content.empty?
-            print "\n"
-            @output_row += 1
-            render_fixed_areas
-            screen.flush
-            return
-          end
+          lines = content.split("\n", -1)  # -1 to keep trailing empty strings
 
-          content.split("\n").each do |line|
+          lines.each_with_index do |line, index|
             # Wrap long lines to prevent display issues
             wrapped_lines = wrap_long_line(line)
-            
-            wrapped_lines.each do |wrapped_line|
-              # If at max row, need to scroll before outputting
-              if @output_row > max_output_row
-                # Move to bottom of screen and print newline to trigger scroll
-                screen.move_cursor(screen.height - 1, 0)
-                print "\n"
-                # Stay at max_output_row for next output
-                @output_row = max_output_row
-              end
 
-              # Output line at current position
-              screen.move_cursor(@output_row, 0)
-              screen.clear_line
-              output_area.append(wrapped_line)
-              @output_row += 1
+            wrapped_lines.each do |wrapped_line|
+              write_output_line(wrapped_line)
             end
           end
 
-          # Re-render fixed areas at screen bottom
+          # Re-render fixed areas to ensure they stay at bottom
           render_fixed_areas
           screen.flush
         end
       end
 
-      # Update the last line in output area (for progress indicator)
-      # @param content [String] Content to update
-      def update_last_line(content)
+      # Update the last N lines in output area (for inline input updates)
+      # @param content [String] Content to update (may contain newlines for wrapped lines)
+      # @param old_line_count [Integer] Number of lines currently occupied (for clearing)
+      def update_last_line(content, old_line_count = 1)
         @render_mutex.synchronize do
-          # Last output line is at @output_row - 1
-          last_row = [@output_row - 1, 0].max
-          screen.move_cursor(last_row, 0)
-          screen.clear_line
-          output_area.append(content)
+          return if @output_row == 0  # No output yet
+
+          # Calculate start row (last N lines)
+          start_row = @output_row - old_line_count
+          start_row = 0 if start_row < 0
+
+          # Clear all lines that will be updated
+          (start_row...@output_row).each do |row|
+            screen.move_cursor(row, 0)
+            screen.clear_line
+          end
+
+          # Re-render the content
+          lines = content.split("\n", -1)
+          current_row = start_row
+
+          lines.each_with_index do |line, idx|
+            screen.move_cursor(current_row, 0)
+            print line
+            current_row += 1
+          end
+
+          # Update output_row to new line count
+          @output_row = start_row + lines.length
+
+          # Clear any remaining old lines if new content has fewer lines
+          # This handles the case where content shrinks (e.g., delete from 2 lines to 1 line)
+          old_end_row = @output_row + (old_line_count - lines.length)
+          if old_end_row > @output_row && old_end_row <= start_row + old_line_count
+            # Clear the extra old lines
+            (@output_row...old_end_row).each do |row|
+              screen.move_cursor(row, 0)
+              screen.clear_line
+            end
+          end
+
+          # Re-render fixed areas to restore cursor position in input area
           render_fixed_areas
           screen.flush
         end
       end
 
-      # Remove the last line from output area
-      def remove_last_line
+      # Remove the last N lines from output area
+      # @param line_count [Integer] Number of lines to remove (default: 1)
+      def remove_last_line(line_count = 1)
         @render_mutex.synchronize do
-          last_row = [@output_row - 1, 0].max
-          screen.move_cursor(last_row, 0)
-          screen.clear_line
-          @output_row = last_row if @output_row > 0
+          return if @output_row == 0  # No output to remove
+
+          # Calculate start row for removal
+          start_row = @output_row - line_count
+          start_row = 0 if start_row < 0
+
+          # Clear all lines being removed
+          (start_row...@output_row).each do |row|
+            screen.move_cursor(row, 0)
+            screen.clear_line
+          end
+
+          # Update output_row
+          @output_row = start_row
+
+          # Re-render fixed areas to ensure consistency
           render_fixed_areas
           screen.flush
         end
       end
 
-      # Scroll output area up
+      # Scroll output area up (legacy no-op)
       # @param lines [Integer] Number of lines to scroll
       def scroll_output_up(lines = 1)
-        output_area.scroll_up(lines)
-        render_output
+        # No-op - terminal handles scrolling natively
       end
 
-      # Scroll output area down
+      # Scroll output area down (legacy no-op)
       # @param lines [Integer] Number of lines to scroll
       def scroll_output_down(lines = 1)
-        output_area.scroll_down(lines)
-        render_output
+        # No-op - terminal handles scrolling natively
       end
 
       # Handle window resize
@@ -266,12 +300,14 @@ module Clacky
         screen.update_dimensions
         calculate_layout
 
-        # Adjust output_row if it exceeds new max
-        max_row = fixed_area_start_row - 1
-        @output_row = [@output_row, max_row].min
+        # Adjust @output_row if it exceeds new layout
+        # After resize, @output_row should not exceed fixed_area_start_row
+        max_allowed = fixed_area_start_row
+        @output_row = [@output_row, max_allowed].min
 
-        # Clear old fixed area lines
-        ([old_gap_row, 0].max...screen.height).each do |row|
+        # Clear old fixed area and some lines above (terminal may have wrapped content)
+        clear_start = [old_gap_row - 5, 0].max
+        (clear_start...screen.height).each do |row|
           screen.move_cursor(row, 0)
           screen.clear_line
         end
@@ -282,6 +318,35 @@ module Clacky
 
       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
+
       # Wrap a long line into multiple lines based on terminal width
       # Considers display width of multi-byte characters (e.g., Chinese characters)
       # @param line [String] Line to wrap
@@ -392,11 +457,26 @@ module Clacky
         # The InlineInput is rendered inline with output
         return if input_area.paused?
 
+        current_fixed_height = fixed_area_height
         start_row = fixed_area_start_row
         gap_row = start_row
         todo_row = gap_row + 1
         input_row = todo_row + (@todo_area&.height || 0)
 
+        # If fixed area shrank, clear the extra lines at the top to remove residual content
+        if @last_fixed_area_height > current_fixed_height
+          height_diff = @last_fixed_area_height - current_fixed_height
+          old_start_row = screen.height - @last_fixed_area_height
+          # Clear the extra lines that are no longer part of fixed area
+          (old_start_row...(old_start_row + height_diff)).each do |row|
+            screen.move_cursor(row, 0)
+            screen.clear_line
+          end
+        end
+
+        # Update last height for next comparison
+        @last_fixed_area_height = current_fixed_height
+
         # Render gap line
         screen.move_cursor(gap_row, 0)
         screen.clear_line
@@ -412,7 +492,7 @@ module Clacky
 
       # Internal render all (without mutex)
       def render_all_internal
-        output_area.render(start_row: 0)
+        # Output flows naturally, just render fixed areas
         render_fixed_areas
         screen.flush
       end

data/lib/clacky/ui2/line_editor.rb

@@ -188,14 +188,154 @@ module Clacky
         # Strip ANSI codes from prompt to get actual display width
         visible_prompt = strip_ansi_codes(prompt)
         prompt_display_width = calculate_display_width(visible_prompt)
-        
+
         # Calculate display width of text before cursor
         chars = @line.chars
         text_before_cursor = chars[0...@cursor_position].join
         text_display_width = calculate_display_width(text_before_cursor)
-        
+
         prompt_display_width + text_display_width
       end
+
+      # 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
+      # @return [Array<Integer>] Row and column position (0-indexed)
+      def cursor_position_with_wrap(prompt = "", width = TTY::Screen.width)
+        return [0, cursor_column(prompt)] if width <= 0
+
+        prompt_width = calculate_display_width(strip_ansi_codes(prompt))
+        available_width = width - prompt_width
+
+        # Get wrapped segments for current line
+        wrapped_segments = wrap_line(@line, available_width)
+
+        # Find which segment contains cursor
+        cursor_segment_idx = 0
+        cursor_pos_in_segment = @cursor_position
+
+        wrapped_segments.each_with_index do |segment, idx|
+          if @cursor_position >= segment[:start] && @cursor_position < segment[:end]
+            cursor_segment_idx = idx
+            cursor_pos_in_segment = @cursor_position - segment[:start]
+            break
+          elsif @cursor_position >= segment[:end] && idx == wrapped_segments.size - 1
+            cursor_segment_idx = idx
+            cursor_pos_in_segment = segment[:end] - segment[:start]
+            break
+          end
+        end
+
+        # Calculate display width of text before cursor in this segment
+        chars = @line.chars
+        segment_start = wrapped_segments[cursor_segment_idx][:start]
+        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
+        row = cursor_segment_idx
+
+        [row, col]
+      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)
+        return [{ text: "", start: 0, end: 0 }] if line.empty?
+        return [{ text: line, start: 0, end: line.length }] if max_width <= 0
+
+        segments = []
+        chars = line.chars
+        segment_start = 0
+        current_width = 0
+        current_end = 0
+
+        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
+          end
+        end
+
+        # Add the last segment
+        if current_end > segment_start
+          segments << {
+            text: chars[segment_start...current_end].join,
+            start: segment_start,
+            end: current_end
+          }
+        end
+
+        segments.empty? ? [{ text: "", start: 0, end: 0 }] : segments
+      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
+      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)
+      # @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
+          @pastel.white(segment_chars.join)
+        end
+      end
     end
   end
 end

data/lib/clacky/ui2/themes/hacker_theme.rb

@@ -29,12 +29,12 @@ module Clacky
         }.freeze
 
         COLORS = {
-          user: [:bright_blue, :blue],
+          user: [:white, :white],
           assistant: [:bright_green, :white],
           tool_call: [:bright_cyan, :cyan],
-          tool_result: [:cyan, :white],
+          tool_result: [:bright_cyan, :cyan],
           tool_denied: [:bright_yellow, :yellow],
-          tool_planned: [:bright_blue, :blue],
+          tool_planned: [:bright_cyan, :cyan],
           tool_error: [:bright_red, :red],
           thinking: [:dim, :dim],
           working: [:bright_yellow, :yellow],

data/lib/clacky/ui2/themes/minimal_theme.rb

@@ -26,12 +26,12 @@ module Clacky
         }.freeze
 
         COLORS = {
-          user: [:blue, :blue],
+          user: [:white, :white],
           assistant: [:green, :white],
           tool_call: [:cyan, :cyan],
-          tool_result: [:white, :white],
+          tool_result: [:cyan, :cyan],
           tool_denied: [:yellow, :yellow],
-          tool_planned: [:blue, :blue],
+          tool_planned: [:cyan, :cyan],
           tool_error: [:red, :red],
           thinking: [:dim, :dim],
           working: [:bright_yellow, :yellow],