openclacky 0.6.0 → 0.6.2

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

@@ -10,7 +10,7 @@ module Clacky
         attr_accessor :height
         attr_reader :todos
 
-        MAX_DISPLAY_TASKS = 2  # Show at most 2 tasks (Next + After)
+        MAX_DISPLAY_TASKS = 3  # Show current + next 2 tasks
 
         def initialize
           @todos = []
@@ -27,12 +27,11 @@ module Clacky
           @completed_count = @todos.count { |t| t[:status] == "completed" }
           @total_count = @todos.size
 
-          # Height: 1 line for header + min(pending_count, MAX_DISPLAY_TASKS) lines for tasks
-          if @pending_todos.empty? && @completed_count == 0
+          # Calculate height: 0 if no pending, otherwise 1 line per task (up to MAX_DISPLAY_TASKS)
+          if @pending_todos.empty?
             @height = 0
           else
-            display_count = [@pending_todos.size, MAX_DISPLAY_TASKS].min
-            @height = 1 + display_count
+            @height = [@pending_todos.size, MAX_DISPLAY_TASKS].min
           end
         end
 
@@ -48,21 +47,37 @@ module Clacky
 
           update_width
 
-          # Render header: [##] Tasks [0/4]: ████
-          move_cursor(start_row, 0)
-          clear_line
-          header = render_header
-          print header
-
-          # Render tasks (Next and After)
-          @pending_todos.take(MAX_DISPLAY_TASKS).each_with_index do |todo, i|
-            move_cursor(start_row + i + 1, 0)
-            clear_line
-
-            label = i == 0 ? "Next" : "After"
-            task_text = truncate_text("##{todo[:id]} - #{todo[:task]}", @width - 12)
-            line = "  #{@pastel.dim("->")} #{@pastel.yellow(label)}: #{task_text}"
-            print line
+          # Render each task on separate line
+          tasks_to_show = @pending_todos.take(MAX_DISPLAY_TASKS)
+          
+          tasks_to_show.each_with_index do |task, index|
+            move_cursor(start_row + index, 0)
+            
+            # Build the line content
+            line_content = if index == 0
+              # First line: Task [2/4]: #3 - Current task description
+              progress = "#{@completed_count}/#{@total_count}"
+              prefix = "Task [#{progress}]: "
+              task_text = "##{task[:id]} - #{task[:task]}"
+              available_width = @width - prefix.length - 2
+              truncated_task = truncate_text(task_text, available_width)
+              
+              "#{@pastel.cyan(prefix)}#{truncated_task}"
+            else
+              # Subsequent lines: -> Next: #4 - Next task description
+              label = index == 1 ? "Next" : "After"
+              prefix = "-> #{label}: "
+              task_text = "##{task[:id]} - #{task[:task]}"
+              available_width = @width - prefix.length - 2
+              truncated_task = truncate_text(task_text, available_width)
+              
+              "#{@pastel.dim(prefix)}#{@pastel.dim(truncated_task)}"
+            end
+
+            # Use carriage return and print content directly (overwrite existing content)
+            print "\r#{line_content}"
+            # Clear any remaining characters from previous render if line is shorter
+            clear_to_end_of_line
           end
 
           flush
@@ -79,28 +94,6 @@ module Clacky
 
         private
 
-        # Render header line with progress bar
-        def render_header
-          progress = "#{@completed_count}/#{@total_count}"
-          progress_bar = render_progress_bar(@completed_count, @total_count)
-
-          "#{@pastel.cyan("[##]")} Tasks [#{progress}]: #{progress_bar}"
-        end
-
-        # Render a simple progress bar
-        def render_progress_bar(completed, total)
-          return "" if total == 0
-
-          bar_width = 10
-          filled = total > 0 ? (completed.to_f / total * bar_width).round : 0
-          empty = bar_width - filled
-
-          filled_bar = @pastel.green("█" * filled)
-          empty_bar = @pastel.dim("░" * empty)
-
-          "#{filled_bar}#{empty_bar}"
-        end
-
         # Truncate text to fit width
         def truncate_text(text, max_width)
           return "" if text.nil?
@@ -122,9 +115,9 @@ module Clacky
           print "\e[#{row + 1};#{col + 1}H"
         end
 
-        # Clear current line
-        def clear_line
-          print "\e[2K"
+        # Clear from cursor to end of line
+        def clear_to_end_of_line
+          print "\e[0K"
         end
 
         # Flush output

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

@@ -29,6 +29,16 @@ module Clacky
           @pastel = Pastel.new
         end
 
+        # Render only the logo (ASCII art)
+        # @return [String] Formatted logo only
+        def render_logo
+          lines = []
+          lines << ""
+          lines << @pastel.bright_green(LOGO)
+          lines << ""
+          lines.join("\n")
+        end
+
         # Render startup banner
         # @return [String] Formatted startup banner
         def render_startup

data/lib/clacky/ui2/layout_manager.rb

@@ -6,11 +6,10 @@ 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
@@ -35,7 +34,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 +91,13 @@ 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
+        # Calculate the actual terminal cursor position considering multi-byte characters
+        # InlineInput is on the last output line (@output_row - 1)
+        cursor_row = @output_row - 1
+        cursor_col = inline_input.cursor_col  # This already considers display width
+        
+        # Move terminal cursor to the correct position
+        screen.move_cursor(cursor_row, cursor_col)
         screen.flush
       end
 
@@ -159,14 +160,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,32 +177,24 @@ 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? || content.empty?
+        return if content.nil?
 
         @render_mutex.synchronize do
-          max_output_row = fixed_area_start_row - 1
-
-          content.split("\n").each do |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
+          lines = content.split("\n", -1)  # -1 to keep trailing empty strings
+          
+          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|
+              write_output_line(wrapped_line)
             end
-
-            # Output line at current position
-            screen.move_cursor(@output_row, 0)
-            screen.clear_line
-            output_area.append(line)
-            @output_row += 1
           end
 
-          # Re-render fixed areas at screen bottom
+          # Re-render fixed areas to ensure they stay at bottom
           render_fixed_areas
           screen.flush
         end
@@ -209,40 +204,52 @@ module Clacky
       # @param content [String] Content to update
       def update_last_line(content)
         @render_mutex.synchronize do
-          # Last output line is at @output_row - 1
-          last_row = [@output_row - 1, 0].max
+          return if @output_row == 0  # No output yet
+          
+          # Last written line is at @output_row - 1
+          last_row = @output_row - 1
           screen.move_cursor(last_row, 0)
           screen.clear_line
-          output_area.append(content)
-          render_fixed_areas
+          print content
+          
+          # Hide terminal cursor to avoid showing two cursors
+          # InlineInput uses visual cursor (white background) which is better for multi-byte chars
+          screen.hide_cursor
           screen.flush
+          
+          # Don't re-render fixed areas - we're just updating existing content
         end
       end
 
       # Remove the last line from output area
       def remove_last_line
         @render_mutex.synchronize do
-          last_row = [@output_row - 1, 0].max
+          return if @output_row == 0  # No output to remove
+          
+          # Clear the last written line
+          last_row = @output_row - 1
           screen.move_cursor(last_row, 0)
           screen.clear_line
-          @output_row = last_row if @output_row > 0
+          
+          # Move output row back
+          @output_row = last_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
@@ -252,12 +259,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
@@ -268,6 +277,127 @@ 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
+      # @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
+            ansi_codes << segment
+            current_line += segment
+          else
+            # 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
+                # Start new line with carried-over ANSI codes
+                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)
+      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
+      
+      # Calculate display width of a string (considering multi-byte characters)
+      # @param text [String] Text to calculate
+      # @return [Integer] Display width
+      def calculate_display_width(text)
+        width = 0
+        text.each_char do |char|
+          width += char_display_width(char)
+        end
+        width
+      end
+
       # Calculate fixed area height (gap + todo + input)
       def fixed_area_height
         todo_height = @todo_area&.height || 0
@@ -306,7 +436,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/markdown_renderer.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "tty-markdown"
+require_relative "theme_manager"
+
+module Clacky
+  module UI2
+    # MarkdownRenderer handles rendering Markdown content with syntax highlighting
+    module MarkdownRenderer
+      class << self
+        # Render markdown content with theme-aware colors
+        # @param content [String] Markdown content to render
+        # @return [String] Rendered content with ANSI colors
+        def render(content)
+          return content if content.nil? || content.empty?
+
+          # 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
+          parsed = TTY::Markdown.parse(content, 
+            colors: theme_colors,
+            width: TTY::Screen.width - 4  # Leave some margin
+          )
+
+          parsed
+        rescue StandardError => e
+          # Fallback to plain content if rendering fails
+          content
+        end
+
+        # Check if content looks like markdown
+        # @param content [String] Content to check
+        # @return [Boolean] true if content appears to be markdown
+        def markdown?(content)
+          return false if content.nil? || content.empty?
+
+          # Check for common markdown patterns
+          content.match?(/^#+ /) ||           # Headers
+            content.match?(/```/) ||          # Code blocks
+            content.match?(/^\s*[-*+] /) ||   # Unordered lists
+            content.match?(/^\s*\d+\. /) ||   # Ordered lists
+            content.match?(/\[.+\]\(.+\)/) || # Links
+            content.match?(/^\s*> /) ||       # Blockquotes
+            content.match?(/\*\*.+\*\*/) ||   # Bold
+            content.match?(/`.+`/) ||         # Inline code
+            content.match?(/^\s*\|.+\|/) ||   # Tables
+            content.match?(/^---+$/)          # Horizontal rules
+        end
+
+        private
+
+        # Get theme-aware colors for markdown rendering
+        # @return [Hash] Color configuration for tty-markdown
+        def theme_colors
+          theme = ThemeManager.current_theme
+
+          # Map our theme colors to tty-markdown's expected format
+          {
+            # Headers use info color (cyan/blue)
+            header: theme.colors[:info],
+            # Code blocks use dim color
+            code: theme.colors[:thinking],
+            # Links use success color (green)
+            link: theme.colors[:success],
+            # Lists use default text color
+            list: :bright_white,
+            # Strong/bold use bright white
+            strong: :bright_white,
+            # Emphasis/italic use white
+            em: :white,
+            # Note/blockquote use dim color
+            note: theme.colors[:thinking],
+          }
+        end
+      end
+    end
+  end
+end

data/lib/clacky/ui2/screen_buffer.rb

@@ -171,14 +171,33 @@ module Clacky
           buffer.force_encoding('UTF-8')
 
           # Keep reading available characters
+          loop_count = 0
+          empty_checks = 0
+          
           loop do
-            break unless IO.select([$stdin], nil, nil, 0)
-
-            next_char = $stdin.getc
-            break unless next_char
-
-            next_char = next_char.force_encoding('UTF-8') if next_char.encoding != Encoding::UTF_8
-            buffer << next_char
+            # Check if there's data available immediately
+            has_data = IO.select([$stdin], nil, nil, 0)
+            
+            if has_data
+              next_char = $stdin.getc
+              break unless next_char
+
+              next_char = next_char.force_encoding('UTF-8') if next_char.encoding != Encoding::UTF_8
+              buffer << next_char
+              loop_count += 1
+              empty_checks = 0  # Reset empty check counter
+            else
+              # No immediate data, but wait a bit to see if more is coming
+              # This handles the case where paste data arrives in chunks
+              empty_checks += 1
+              if empty_checks == 1
+                # First empty check - wait 10ms for more data
+                sleep 0.01
+              else
+                # Second empty check - really no more data
+                break
+              end
+            end
           end
 
           # If we buffered multiple characters or newlines, treat as rapid input (paste)