openclacky 0.7.2 → 0.7.4

data/lib/clacky/ui2/layout_manager.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "screen_buffer"
+require_relative "../utils/limit_stack"
 
 module Clacky
   module UI2
@@ -16,6 +17,8 @@ module Clacky
         @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
+        @resize_pending = false  # Flag to indicate resize is pending
+        @output_buffer = Utils::LimitStack.new(max_size: 500)  # Buffer to store output lines with auto-rolling
 
         calculate_layout
         setup_resize_handler
@@ -88,6 +91,42 @@ module Clacky
         end
       end
 
+      # Re-render everything from scratch (useful after modal dialogs)
+      def rerender_all
+        @render_mutex.synchronize do
+          # Clear entire screen
+          screen.clear_screen
+          
+          # Re-render output from buffer
+          render_output_from_buffer
+          
+          # Re-render fixed areas at new positions
+          render_fixed_areas
+          screen.flush
+        end
+      end
+      
+      # Render output area from buffer (clears and re-renders last N lines)
+      private def render_output_from_buffer
+        max_output_row = fixed_area_start_row
+        
+        # Clear output area
+        (0...max_output_row).each do |row|
+          screen.move_cursor(row, 0)
+          screen.clear_line
+        end
+        
+        # Re-render from buffer (show last N lines that fit)
+        @output_row = 0
+        visible_lines = [@output_buffer.size, max_output_row].min
+        
+        @output_buffer.last(visible_lines).each do |line|
+          screen.move_cursor(@output_row, 0)
+          print line
+          @output_row += 1
+        end
+      end
+
       # Position cursor for inline input in output area
       # @param inline_input [Components::InlineInput] InlineInput component
       def position_inline_input_cursor(inline_input)
@@ -178,6 +217,9 @@ module Clacky
 
           # Reset output position to beginning
           @output_row = 0
+          
+          # Clear the output buffer so re-renders don't restore old content
+          @output_buffer.clear
 
           # Re-render fixed areas to ensure they stay in place
           render_fixed_areas
@@ -226,6 +268,11 @@ module Clacky
             screen.clear_line
           end
 
+          # Remove old lines from buffer
+          old_line_count.times do
+            @output_buffer.pop if @output_buffer.size > 0
+          end
+
           # Re-render the content
           lines = content.split("\n", -1)
           current_row = start_row
@@ -233,6 +280,8 @@ module Clacky
           lines.each_with_index do |line, idx|
             screen.move_cursor(current_row, 0)
             print line
+            # Add updated line to buffer
+            @output_buffer << line
             current_row += 1
           end
 
@@ -272,6 +321,11 @@ module Clacky
             screen.clear_line
           end
 
+          # Also remove from output buffer to prevent re-rendering
+          line_count.times do
+            @output_buffer.pop if @output_buffer.size > 0
+          end
+
           # Update output_row
           @output_row = start_row
 
@@ -294,24 +348,29 @@ module Clacky
       end
 
       # Handle window resize
-      def handle_resize
-        old_gap_row = @gap_row
-
+      private def handle_resize
+        # Update terminal dimensions and recalculate layout
         screen.update_dimensions
         calculate_layout
 
-        # 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 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
+        # Clear entire screen
+        screen.clear_screen
+        
+        # Re-render all output from buffer
+        @output_row = 0
+        max_output_row = fixed_area_start_row
+        
+        # Calculate how many lines we can show from the end of buffer
+        visible_lines = [@output_buffer.size, max_output_row].min
+        
+        # Render the last N lines that fit in the output area
+        @output_buffer.last(visible_lines).each do |line|
+          screen.move_cursor(@output_row, 0)
+          print line
+          @output_row += 1
         end
-
+        
+        # Re-render fixed areas at new positions
         render_fixed_areas
         screen.flush
       end
@@ -320,6 +379,9 @@ module Clacky
       # Handles scrolling when reaching fixed area
       # @param line [String] Single line to write (should not contain newlines)
       def write_output_line(line)
+        # Add to buffer for potential re-rendering
+        @output_buffer << line
+        
         # Calculate where fixed area starts (this is where output area ends)
         max_output_row = fixed_area_start_row
 
@@ -461,15 +523,12 @@ module Clacky
         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
+        # Detect height changes and re-render output area if needed
+        if @last_fixed_area_height > 0 && @last_fixed_area_height != current_fixed_height
+          # Fixed area height changed - re-render output area from buffer
+          # This prevents output content from being hidden when fixed area grows
+          # (e.g., multi-line input, command suggestions appearing)
+          render_output_from_buffer
         end
 
         # Update last height for next comparison
@@ -555,12 +614,34 @@ module Clacky
       end
 
       # Setup handler for window resize
-      def setup_resize_handler
+      # Note: Signal handlers run in trap context where many operations are restricted
+      private def setup_resize_handler
         Signal.trap("WINCH") do
+          # Simply set a flag - actual resize handling happens in main thread
+          @resize_pending = true
+        end
+      rescue ArgumentError => e
+        # Signal already trapped (shouldn't happen now)
+        warn "WINCH signal already trapped: #{e.message}"
+      end
+
+      # Check and process pending resize (should be called from main thread periodically)
+      def process_pending_resize
+        return unless @resize_pending
+        
+        @resize_pending = false
+        handle_resize_safely
+      end
+
+      # Thread-safe wrapper for handle_resize
+      private def handle_resize_safely
+        @render_mutex.synchronize do
           handle_resize
         end
-      rescue ArgumentError
-        # Signal already trapped, ignore
+      rescue => e
+        # Catch and log errors to prevent resize from crashing the app
+        warn "Resize error: #{e.message}"
+        warn e.backtrace.first(5).join("\n") if e.backtrace
       end
     end
   end

data/lib/clacky/ui2/line_editor.rb

@@ -334,7 +334,7 @@ module Clacky
       # @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
+      # @return [String] Rendered segment with cursor if applicable (without text color, only cursor highlight)
       def render_line_segment_with_cursor(line, segment_start, segment_end)
         chars = line.chars
         segment_chars = chars[segment_start...segment_end]
@@ -347,14 +347,15 @@ module Clacky
           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)}"
+          # Only apply cursor highlight, let subclasses apply text color
+          "#{before_cursor}#{@pastel.on_white(@pastel.black(cursor_char))}#{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(' '))}"
+          "#{segment_text}#{@pastel.on_white(@pastel.black(' '))}"
         else
-          # Cursor is not in this segment, just format normally
-          @pastel.white(segment_chars.join)
+          # Cursor is not in this segment, return plain text without color
+          segment_chars.join
         end
       end
     end

data/lib/clacky/ui2/screen_buffer.rb

@@ -15,7 +15,6 @@ module Clacky
         @buffer = []
         @last_input_time = nil
         @rapid_input_threshold = 0.01 # 10ms threshold for detecting paste-like rapid input
-        setup_resize_handler
       end
 
       # Move cursor to specific position (0-indexed)
@@ -240,20 +239,6 @@ module Clacky
       end
 
       private
-
-      # Setup handler for terminal resize (SIGWINCH)
-      def setup_resize_handler
-        Signal.trap("WINCH") do
-          update_dimensions
-          @resize_callback&.call(@width, @height)
-        end
-      end
-
-      # Register callback for resize events
-      # @param block [Proc] Callback to execute on resize
-      def on_resize(&block)
-        @resize_callback = block
-      end
     end
   end
 end

data/lib/clacky/ui2/terminal_detector.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Clacky
+  module UI2
+    # TerminalDetector - Detect terminal background color before UI starts
+    class TerminalDetector
+      # Detect if terminal has dark background
+      # Uses multiple strategies to determine background color
+      # @return [Boolean] true if dark background, false if light background
+      def self.detect_dark_background
+        # Strategy 1: Check $COLORFGBG environment variable (fast, set by some terminals)
+        if ENV.key?('COLORFGBG')
+          # Format is like "15;0" where second number is background ANSI code
+          # 0-7 are dark, 8-15 are light
+          parts = ENV['COLORFGBG'].split(';')
+          if parts.size >= 2
+            bg_code = parts.last.to_i
+            if bg_code >= 0 && bg_code <= 15
+              return bg_code < 8
+            end
+          end
+        end
+        
+        # Strategy 2: Query terminal background using OSC 11 sequence
+        begin
+          rgb = query_terminal_background_color
+          if rgb
+            # Calculate luma (perceived brightness): 0.0 (black) to 1.0 (white)
+            # Formula: 0.299*R + 0.587*G + 0.114*B
+            luma = (0.299 * rgb[:r] + 0.587 * rgb[:g] + 0.114 * rgb[:b]) / 255.0
+            return luma < 0.5
+          end
+        rescue => e
+          # Silently fall through to default
+        end
+        
+        # Default: assume dark background (most common for terminals)
+        true
+      end
+
+      # Query terminal background color using OSC 11 sequence
+      # This should be called BEFORE UI starts to avoid interference
+      # @return [Hash, nil] RGB hash like {r: 26, g: 43, b: 60} or nil if failed
+      def self.query_terminal_background_color
+        require 'io/console'
+        
+        # Only works on TTY
+        return nil unless $stdin.tty?
+        return nil unless $stdout.tty?
+        
+        old_state = nil
+        begin
+          # Save current terminal state
+          old_state = $stdin.raw!
+          
+          # Clear any pending input first
+          while IO.select([$stdin], nil, nil, 0)
+            $stdin.read_nonblock(1000) rescue break
+          end
+          
+          # Send OSC 11 query: ESC ] 11 ; ? ST
+          # Use ST terminator (ESC \) instead of BEL for better compatibility
+          $stdout.print "\e]11;?\e\\\\"
+          $stdout.flush
+          
+          # Read response with timeout (terminal should respond quickly)
+          response = String.new  # Use String.new to create mutable string
+          timeout = 0.1  # 100ms timeout
+          start_time = Time.now
+          
+          while Time.now - start_time < timeout
+            if IO.select([$stdin], nil, nil, 0.01)
+              char = $stdin.read_nonblock(1) rescue nil
+              break unless char
+              response << char
+              
+              # Look for complete response pattern
+              # Response format: ESC ] 11 ; rgb:RRRR/GGGG/BBBB BEL or ST
+              if response.match?(/\e\]11;rgb:[0-9a-fA-F]+\/[0-9a-fA-F]+\/[0-9a-fA-F]+(\e\\|\a)/)
+                break
+              end
+              
+              # Safety: stop if response gets too long (probably garbage)
+              break if response.length > 100
+            end
+          end
+          
+          # Parse response: look for rgb:RRRR/GGGG/BBBB
+          # Example: ]11;rgb:1a2b/3c4d/5e6f or ]11;rgb:ffff/ffff/ffff
+          if response =~ /rgb:([0-9a-fA-F]+)\/([0-9a-fA-F]+)\/([0-9a-fA-F]+)/
+            r_hex, g_hex, b_hex = $1, $2, $3
+            # Take first 2 hex digits (terminals may return 4 or 2 hex digits per channel)
+            r = r_hex[0, 2].to_i(16)
+            g = g_hex[0, 2].to_i(16)
+            b = b_hex[0, 2].to_i(16)
+            return { r: r, g: g, b: b }
+          end
+          
+          nil
+        rescue => e
+          # If anything goes wrong, return nil to fall back to default
+          nil
+        ensure
+          # Make sure we restore terminal state even if error occurs
+          old_state.restore if old_state rescue nil
+          
+          # Clear any remaining input to prevent leakage
+          begin
+            while IO.select([$stdin], nil, nil, 0)
+              $stdin.read_nonblock(1000) rescue break
+            end
+          rescue
+            # Ignore cleanup errors
+          end
+        end
+      end
+    end
+  end
+end

data/lib/clacky/ui2/theme_manager.rb

@@ -34,10 +34,26 @@ module Clacky
       def initialize
         @themes = {}
         @current_theme = nil
+        @is_dark_background = nil  # Store detected background mode
         register_default_themes
         set_theme(:hacker)
       end
 
+      # Set the detected terminal background mode
+      # This should be called BEFORE UI starts (from CLI)
+      # @param is_dark [Boolean] true if dark background, false if light
+      def set_background_mode(is_dark)
+        @is_dark_background = is_dark
+        # Pass to current theme if already initialized
+        @current_theme&.set_background_mode(is_dark)
+      end
+
+      # Get the detected background mode
+      # @return [Boolean, nil] true if dark, false if light, nil if not detected
+      def dark_background?
+        @is_dark_background
+      end
+
       def current_theme
         @current_theme
       end
@@ -47,6 +63,8 @@ module Clacky
         raise ArgumentError, "Unknown theme: #{name}" unless @themes.key?(name)
 
         @current_theme = @themes[name].new
+        # Pass background mode to new theme if already detected
+        @current_theme.set_background_mode(@is_dark_background) unless @is_dark_background.nil?
       end
 
       def available_themes

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

@@ -10,9 +10,16 @@ module Clacky
       class BaseTheme
         def initialize
           @pastel = Pastel.new
+          @is_dark_background = nil  # Will be set by ThemeManager
           validate_theme_definition!
         end
 
+        # Set background mode (called by ThemeManager after detection)
+        # @param is_dark [Boolean] true if dark background, false if light
+        def set_background_mode(is_dark)
+          @is_dark_background = is_dark
+        end
+
         # Get all symbols defined by this theme
         # @return [Hash] Symbol definitions
         def symbols
@@ -40,10 +47,16 @@ module Clacky
         end
 
         # Get text color for a specific key
+        # Automatically selects appropriate color based on terminal background
+        # Color format: [symbol_color, dark_bg_text_color, light_bg_text_color]
         # @param key [Symbol] Color key
         # @return [Symbol] Pastel color method name
         def text_color(key)
-          colors.dig(key, 1) || :white
+          color_def = colors[key]
+          return :white unless color_def
+          
+          # Use index 1 for dark background, index 2 for light background
+          dark_background? ? color_def[1] : color_def[2]
         end
 
         # Format symbol with its color
@@ -67,6 +80,14 @@ module Clacky
           raise NotImplementedError, "Subclass must implement #name method"
         end
 
+        # Check if terminal has dark background
+        # Uses pre-detected value from ThemeManager, or defaults to true
+        # @return [Boolean] true if dark background, false if light background
+        def dark_background?
+          # Use pre-detected value if available, otherwise default to dark
+          @is_dark_background.nil? ? true : @is_dark_background
+        end
+
         private
 
         # Validate that subclass has defined required constants

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

@@ -29,24 +29,28 @@ module Clacky
         }.freeze
 
         COLORS = {
-          user: [:white, :white],
-          assistant: [:bright_green, :white],
-          tool_call: [:bright_cyan, :cyan],
-          tool_result: [:bright_cyan, :cyan],
-          tool_denied: [:bright_yellow, :yellow],
-          tool_planned: [:bright_cyan, :cyan],
-          tool_error: [:bright_red, :red],
-          thinking: [:dim, :dim],
-          working: [:bright_yellow, :yellow],
-          success: [:bright_green, :green],
-          error: [:bright_red, :red],
-          warning: [:bright_yellow, :yellow],
-          info: [:bright_white, :white],
-          task: [:bright_yellow, :white],
-          progress: [:bright_cyan, :cyan],
-          file: [:cyan, :white],
-          command: [:cyan, :white],
-          cached: [:cyan, :cyan]
+          # Format: [symbol_color, dark_bg_text, light_bg_text]
+          user: [:bright_black, :white, :black],           # User prompt and input
+          assistant: [:bright_green, :bright_black, :bright_black], # AI response - keep green hacker style
+          tool_call: [:bright_cyan, :cyan, :cyan],                # Tool execution
+          tool_result: [:bright_cyan, :bright_black, :bright_black], # Tool output
+          tool_denied: [:bright_yellow, :yellow, :yellow],        # Denied actions
+          tool_planned: [:bright_cyan, :cyan, :cyan],             # Planned actions
+          tool_error: [:bright_red, :red, :red],                  # Errors
+          thinking: [:bright_black, :bright_black, :bright_black], # Thinking status
+          working: [:bright_yellow, :yellow, :yellow],            # Working status
+          success: [:bright_green, :green, :green],               # Success messages
+          error: [:bright_red, :red, :red],                       # Error messages
+          warning: [:bright_yellow, :yellow, :yellow],            # Warnings
+          info: [:bright_black, :bright_black, :bright_black],    # Info messages
+          task: [:bright_yellow, :bright_black, :bright_black],   # Task items
+          progress: [:bright_cyan, :cyan, :cyan],                 # Progress indicators
+          file: [:cyan, :bright_black, :bright_black],            # File references
+          command: [:cyan, :bright_black, :bright_black],         # Command references
+          cached: [:cyan, :cyan, :cyan],                          # Cached indicators
+          # Status bar colors
+          statusbar_path: [:bright_black, :bright_black, :bright_black],        # Path
+          statusbar_secondary: [:bright_black, :bright_black, :bright_black]    # Model/tasks/cost
         }.freeze
 
         def name

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

@@ -26,21 +26,25 @@ module Clacky
         }.freeze
 
         COLORS = {
-          user: [:white, :white],
-          assistant: [:green, :white],
-          tool_call: [:cyan, :cyan],
-          tool_result: [:cyan, :cyan],
-          tool_denied: [:yellow, :yellow],
-          tool_planned: [:cyan, :cyan],
-          tool_error: [:red, :red],
-          thinking: [:dim, :dim],
-          working: [:bright_yellow, :yellow],
-          success: [:green, :green],
-          error: [:red, :red],
-          warning: [:yellow, :yellow],
-          info: [:white, :white],
-          task: [:yellow, :white],
-          progress: [:cyan, :cyan]
+          # Format: [symbol_color, dark_bg_text, light_bg_text]
+          user: [:bright_black, :bright_black, :black],           # User prompt and input
+          assistant: [:green, :bright_black, :bright_black],      # AI response
+          tool_call: [:cyan, :cyan, :cyan],                       # Tool execution
+          tool_result: [:cyan, :bright_black, :bright_black],     # Tool output
+          tool_denied: [:yellow, :yellow, :yellow],               # Denied actions
+          tool_planned: [:cyan, :cyan, :cyan],                    # Planned actions
+          tool_error: [:red, :red, :red],                         # Errors
+          thinking: [:bright_black, :bright_black, :bright_black], # Thinking status
+          working: [:bright_yellow, :yellow, :yellow],            # Working status
+          success: [:green, :green, :green],                      # Success messages
+          error: [:red, :red, :red],                              # Error messages
+          warning: [:yellow, :yellow, :yellow],                   # Warnings
+          info: [:bright_black, :bright_black, :bright_black],    # Info messages
+          task: [:yellow, :bright_black, :bright_black],          # Task items
+          progress: [:cyan, :cyan, :cyan],                        # Progress indicators
+          # Status bar colors
+          statusbar_path: [:bright_black, :bright_black, :bright_black],        # Path
+          statusbar_secondary: [:bright_black, :bright_black, :bright_black]    # Model/tasks/cost
         }.freeze
 
         def name