openclacky 0.6.0 → 0.6.1

data/lib/clacky/ui2/layout_manager.rb

@@ -177,26 +177,40 @@ module Clacky
       # Track current row, scroll when reaching fixed area
       # @param content [String] Content to append
       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
 
+          # 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
+
           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
+            # 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
             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
@@ -268,6 +282,98 @@ module Clacky
 
       private
 
+      # 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

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)

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

@@ -5,71 +5,43 @@ require "pastel"
 module Clacky
   module UI2
     module Themes
-      # BaseTheme defines the interface for all themes
-      # Subclasses should override SYMBOLS and color methods
+      # BaseTheme defines the abstract interface for all themes
+      # Subclasses MUST define SYMBOLS and COLORS constants
       class BaseTheme
-        SYMBOLS = {
-          user: "[>>]",
-          assistant: "[<<]",
-          tool_call: "[=>]",
-          tool_result: "[<=]",
-          tool_denied: "[!!]",
-          tool_planned: "[??]",
-          tool_error: "[XX]",
-          thinking: "[..]",
-          success: "[OK]",
-          error: "[ER]",
-          warning: "[!!]",
-          info: "[--]",
-          task: "[##]",
-          progress: "[>>]",
-          file: "[F]",
-          command: "[C]",
-          cached: "[*]"
-        }.freeze
-
-        # Color schemes for different elements
-        # Each returns [symbol_color, text_color]
-        COLORS = {
-          user: [:bright_blue, :blue],
-          assistant: [:bright_green, :white],
-          tool_call: [:bright_cyan, :cyan],
-          tool_result: [:cyan, :white],
-          tool_denied: [:bright_yellow, :yellow],
-          tool_planned: [:bright_blue, :blue],
-          tool_error: [:bright_red, :red],
-          thinking: [:dim, :dim],
-          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]
-        }.freeze
-
         def initialize
           @pastel = Pastel.new
+          validate_theme_definition!
         end
 
+        # Get all symbols defined by this theme
+        # @return [Hash] Symbol definitions
         def symbols
           self.class::SYMBOLS
         end
 
+        # Get all colors defined by this theme
+        # @return [Hash] Color definitions
         def colors
           self.class::COLORS
         end
 
+        # Get symbol for a specific key
+        # @param key [Symbol] Symbol key
+        # @return [String] Symbol string
         def symbol(key)
           symbols[key] || "[??]"
         end
 
+        # Get symbol color for a specific key
+        # @param key [Symbol] Color key
+        # @return [Symbol] Pastel color method name
         def symbol_color(key)
           colors.dig(key, 0) || :white
         end
 
+        # Get text color for a specific key
+        # @param key [Symbol] Color key
+        # @return [Symbol] Pastel color method name
         def text_color(key)
           colors.dig(key, 1) || :white
         end
@@ -89,9 +61,23 @@ module Clacky
           @pastel.public_send(text_color(key), text)
         end
 
-        # Theme name for display
+        # Theme name for display (subclasses should override)
+        # @return [String] Theme name
         def name
-          "base"
+          raise NotImplementedError, "Subclass must implement #name method"
+        end
+
+        private
+
+        # Validate that subclass has defined required constants
+        def validate_theme_definition!
+          unless self.class.const_defined?(:SYMBOLS)
+            raise NotImplementedError, "Theme #{self.class.name} must define SYMBOLS constant"
+          end
+
+          unless self.class.const_defined?(:COLORS)
+            raise NotImplementedError, "Theme #{self.class.name} must define COLORS constant"
+          end
         end
       end
     end

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

@@ -16,6 +16,7 @@ module Clacky
           tool_planned: "[??]",
           tool_error: "[XX]",
           thinking: "[..]",
+          working: "[..]",
           success: "[OK]",
           error: "[ER]",
           warning: "[!!]",
@@ -36,6 +37,7 @@ module Clacky
           tool_planned: [:bright_blue, :blue],
           tool_error: [:bright_red, :red],
           thinking: [:dim, :dim],
+          working: [:bright_yellow, :yellow],
           success: [:bright_green, :green],
           error: [:bright_red, :red],
           warning: [:bright_yellow, :yellow],

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

@@ -16,6 +16,7 @@ module Clacky
           tool_planned: "?",
           tool_error: "x",
           thinking: ".",
+          working: ".",
           success: "+",
           error: "x",
           warning: "!",
@@ -33,6 +34,7 @@ module Clacky
           tool_planned: [:blue, :blue],
           tool_error: [:red, :red],
           thinking: [:dim, :dim],
+          working: [:bright_yellow, :yellow],
           success: [:green, :green],
           error: [:red, :red],
           warning: [:yellow, :yellow],

data/lib/clacky/ui2/ui_controller.rb

@@ -59,7 +59,8 @@ module Clacky
       end
 
       # Initialize screen and show banner (separate from input loop)
-      def initialize_and_show_banner
+      # @param recent_user_messages [Array<String>, nil] Recent user messages when loading session
+      def initialize_and_show_banner(recent_user_messages: nil)
         @running = true
 
         # Set session bar data before initializing screen
@@ -73,8 +74,12 @@ module Clacky
 
         @layout.initialize_screen
 
-        # Display welcome banner
-        display_welcome_banner
+        # Display welcome banner or session history
+        if recent_user_messages && !recent_user_messages.empty?
+          display_session_history(recent_user_messages)
+        else
+          display_welcome_banner
+        end
       end
 
       # Start input loop (separate from initialization)
@@ -344,6 +349,10 @@ module Clacky
       def show_complete(iterations:, cost:, duration: nil, cache_stats: nil)
         # Update status back to 'idle' when task is complete
         update_sessionbar(status: 'idle')
+        
+        # Clear user tip when agent stops working
+        @input_area.clear_user_tip
+        @layout.render_input
 
         # Only show completion message for complex tasks (>5 iterations)
         return if iterations <= 5
@@ -351,7 +360,7 @@ module Clacky
         cache_tokens = cache_stats&.dig(:cache_read_input_tokens)
         cache_requests = cache_stats&.dig(:total_requests)
         cache_hits = cache_stats&.dig(:cache_hit_requests)
-        
+
         output = @renderer.render_task_complete(
           iterations: iterations,
           cost: cost,
@@ -365,7 +374,8 @@ module Clacky
 
       # Show progress indicator with dynamic elapsed time
       # @param message [String] Progress message (optional, will use random thinking verb if nil)
-      def show_progress(message = nil)
+      # @param prefix_newline [Boolean] Whether to add a blank line before progress (default: true)
+      def show_progress(message = nil, prefix_newline: true)
         # Stop any existing progress thread
         stop_progress_thread
 
@@ -375,8 +385,9 @@ module Clacky
         @progress_message = message || Clacky::THINKING_VERBS.sample
         @progress_start_time = Time.now
 
-        # Show initial progress
-        output = @renderer.render_progress("#{@progress_message}… (ctrl+c to interrupt)")
+        # Show initial progress (yellow, active)
+        append_output("") if prefix_newline
+        output = @renderer.render_working("#{@progress_message}… (ctrl+c to interrupt)")
         append_output(output)
 
         # Start background thread to update elapsed time
@@ -386,7 +397,7 @@ module Clacky
             next unless @progress_start_time
 
             elapsed = (Time.now - @progress_start_time).to_i
-            update_progress_line(@renderer.render_progress("#{@progress_message}… (ctrl+c to interrupt · #{elapsed}s)"))
+            update_progress_line(@renderer.render_working("#{@progress_message}… (ctrl+c to interrupt · #{elapsed}s)"))
           end
         rescue => e
           # Silently handle thread errors
@@ -395,8 +406,19 @@ module Clacky
 
       # Clear progress indicator
       def clear_progress
+        # Calculate elapsed time before stopping
+        elapsed_time = @progress_start_time ? (Time.now - @progress_start_time).to_i : 0
+        
+        # Stop the progress thread
         stop_progress_thread
-        clear_progress_line
+        
+        # Update the final progress line to gray (stopped state)
+        if @progress_message && elapsed_time > 0
+          final_output = @renderer.render_progress("#{@progress_message}… (#{elapsed_time}s)")
+          update_progress_line(final_output)
+        else
+          clear_progress_line
+        end
       end
 
       # Stop the progress update thread
@@ -410,8 +432,9 @@ module Clacky
 
       # Show info message
       # @param message [String] Info message
-      def show_info(message)
-        output = @renderer.render_system_message(message)
+      # @param prefix_newline [Boolean] Whether to add newline before message (default: true)
+      def show_info(message, prefix_newline: true)
+        output = @renderer.render_system_message(message, prefix_newline: prefix_newline)
         append_output(output)
       end
 
@@ -432,11 +455,17 @@ module Clacky
       # Set workspace status to idle (called when agent stops working)
       def set_idle_status
         update_sessionbar(status: 'idle')
+        # Clear user tip when agent stops working
+        @input_area.clear_user_tip
+        @layout.render_input
       end
 
       # Set workspace status to working (called when agent starts working)
       def set_working_status
         update_sessionbar(status: 'working')
+        # Show a random user tip with 40% probability when agent starts working
+        @input_area.show_user_tip(probability: 0.4)
+        @layout.render_input
       end
 
       # Show help text
@@ -484,7 +513,7 @@ module Clacky
 
         # Create InlineInput with styled prompt
         inline_input = Components::InlineInput.new(
-          prompt: theme.format_text("  (y/n, or provide feedback): ", :thinking),
+          prompt: "  Press Enter to approve, 'n' to reject, or provide feedback: ",
           default: nil
         )
         @inline_input = inline_input
@@ -599,6 +628,35 @@ module Clacky
         append_output(content)
       end
 
+      # Display recent user messages when loading session
+      # @param user_messages [Array<String>] Array of recent user message texts
+      def display_session_history(user_messages)
+        theme = ThemeManager.current_theme
+
+        # Show logo banner only
+        append_output(@welcome_banner.render_logo)
+
+        # Show simple header
+        append_output(theme.format_text("Recent conversation:", :info))
+
+        # Display each user message with numbering
+        user_messages.each_with_index do |msg, index|
+          # Truncate long messages
+          display_msg = if msg.length > 140
+            "#{msg[0..137]}..."
+          else
+            msg
+          end
+
+          # Show with number and indentation
+          append_output("  #{index + 1}. #{display_msg}")
+        end
+
+        # Bottom spacing and continuation prompt
+        append_output("")
+        append_output(theme.format_text("Session restored. Feel free to continue with your next task.", :success))
+      end
+
       # Main input loop
       def input_loop
         @layout.screen.enable_raw_mode

data/lib/clacky/ui2/view_renderer.rb

@@ -3,6 +3,7 @@
 require_relative "components/message_component"
 require_relative "components/tool_component"
 require_relative "components/common_component"
+require_relative "markdown_renderer"
 
 module Clacky
   module UI2
@@ -31,9 +32,16 @@ module Clacky
       # @param timestamp [Time, nil] Optional timestamp
       # @return [String] Rendered message
       def render_assistant_message(content, timestamp: nil)
+        # Render markdown if content contains markdown syntax
+        rendered_content = if MarkdownRenderer.markdown?(content)
+          MarkdownRenderer.render(content)
+        else
+          content
+        end
+
         @message_component.render(
           role: "assistant",
-          content: content,
+          content: rendered_content,
           timestamp: timestamp
         )
       end
@@ -41,12 +49,14 @@ module Clacky
       # Render a system message
       # @param content [String] Message content
       # @param timestamp [Time, nil] Optional timestamp
+      # @param prefix_newline [Boolean] Whether to add newline before message
       # @return [String] Rendered message
-      def render_system_message(content, timestamp: nil)
+      def render_system_message(content, timestamp: nil, prefix_newline: true)
         @message_component.render(
           role: "system",
           content: content,
-          timestamp: timestamp
+          timestamp: timestamp,
+          prefix_newline: prefix_newline
         )
       end
 
@@ -108,13 +118,20 @@ module Clacky
         @common_component.render_thinking
       end
 
-      # Render progress message
+      # Render progress message (stopped state, gray)
       # @param message [String] Progress message
       # @return [String] Progress indicator
       def render_progress(message)
         @common_component.render_progress(message)
       end
 
+      # Render working message (active state, yellow)
+      # @param message [String] Progress message
+      # @return [String] Working indicator
+      def render_working(message)
+        @common_component.render_working(message)
+      end
+
       # Render success message
       # @param message [String] Success message
       # @return [String] Success message

data/lib/clacky/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Clacky
-  VERSION = "0.6.0"
+  VERSION = "0.6.1"
 end