openclacky 0.5.6 → 0.6.1

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

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+require "tty-screen"
+require "io/console"
+
+module Clacky
+  module UI2
+    # ScreenBuffer manages terminal screen state and provides low-level rendering primitives
+    class ScreenBuffer
+      attr_reader :width, :height
+
+      def initialize
+        @width = TTY::Screen.width
+        @height = TTY::Screen.height
+        @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)
+      # @param row [Integer] Row position
+      # @param col [Integer] Column position
+      def move_cursor(row, col)
+        print "\e[#{row + 1};#{col + 1}H"
+      end
+
+      # Clear entire screen
+      def clear_screen
+        print "\e[2J"
+        move_cursor(0, 0)
+      end
+
+      # Clear current line
+      def clear_line
+        print "\e[2K"
+      end
+
+      # Clear from cursor to end of line
+      def clear_to_eol
+        print "\e[K"
+      end
+
+      # Hide cursor
+      def hide_cursor
+        print "\e[?25l"
+      end
+
+      # Show cursor
+      def show_cursor
+        print "\e[?25h"
+      end
+
+      # Save cursor position
+      def save_cursor
+        print "\e[s"
+      end
+
+      # Restore cursor position
+      def restore_cursor
+        print "\e[u"
+      end
+
+      # Enable alternative screen buffer (like vim/less)
+      def enable_alt_screen
+        print "\e[?1049h"
+      end
+
+      # Disable alternative screen buffer
+      def disable_alt_screen
+        print "\e[?1049l"
+      end
+
+      # Set scroll region (DECSTBM - DEC Set Top and Bottom Margins)
+      # Content written in this region will scroll, content outside will stay fixed
+      # @param top [Integer] Top row (1-indexed)
+      # @param bottom [Integer] Bottom row (1-indexed)
+      def set_scroll_region(top, bottom)
+        print "\e[#{top};#{bottom}r"
+      end
+
+      # Reset scroll region to full screen
+      def reset_scroll_region
+        print "\e[r"
+      end
+
+      # Scroll the scroll region up by n lines
+      # @param n [Integer] Number of lines to scroll
+      def scroll_up(n = 1)
+        print "\e[#{n}S"
+      end
+
+      # Scroll the scroll region down by n lines
+      # @param n [Integer] Number of lines to scroll
+      def scroll_down(n = 1)
+        print "\e[#{n}T"
+      end
+
+      # Get current screen dimensions
+      def update_dimensions
+        @width = TTY::Screen.width
+        @height = TTY::Screen.height
+      end
+
+      # Enable raw mode (disable line buffering)
+      def enable_raw_mode
+        $stdin.raw!
+      end
+
+      # Disable raw mode
+      def disable_raw_mode
+        $stdin.cooked!
+      end
+
+      # Read a single character without echo
+      # @param timeout [Float] Timeout in seconds (nil for blocking)
+      # @return [String, nil] Character or nil if timeout
+      def read_char(timeout: nil)
+        if timeout
+          return nil unless IO.select([$stdin], nil, nil, timeout)
+        end
+        
+        $stdin.getc
+      end
+
+      # Read a key including special keys (arrows, etc.)
+      # @param timeout [Float] Timeout in seconds
+      # @return [Symbol, String, Hash, nil] Key symbol, character, or { type: :rapid_input, text: String }
+      def read_key(timeout: nil)
+        $stdin.set_encoding('UTF-8')
+
+        current_time = Time.now.to_f
+        is_rapid_input = @last_input_time && (current_time - @last_input_time) < @rapid_input_threshold
+        @last_input_time = current_time
+
+        char = read_char(timeout: timeout)
+        return nil unless char
+
+        # Ensure character is UTF-8 encoded
+        char = char.force_encoding('UTF-8') if char.is_a?(String) && char.encoding != Encoding::UTF_8
+
+        # Handle escape sequences for special keys
+        if char == "\e"
+          # Non-blocking read for escape sequence
+          char2 = read_char(timeout: 0.01)
+          return :escape unless char2
+
+          if char2 == "["
+            char3 = read_char(timeout: 0.01)
+            case char3
+            when "A" then return :up_arrow
+            when "B" then return :down_arrow
+            when "C" then return :right_arrow
+            when "D" then return :left_arrow
+            when "H" then return :home
+            when "F" then return :end
+            when "Z" then return :shift_tab
+            when "3"
+              char4 = read_char(timeout: 0.01)
+              return :delete if char4 == "~"
+            end
+          end
+        end
+
+        # Check if there are more characters available (for rapid input detection)
+        has_more_input = IO.select([$stdin], nil, nil, 0)
+
+        # If this is rapid input or there are more characters available
+        if is_rapid_input || has_more_input
+          buffer = char.to_s.dup
+          buffer.force_encoding('UTF-8')
+
+          # Keep reading available characters
+          loop_count = 0
+          empty_checks = 0
+          
+          loop do
+            # 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)
+          if buffer.length > 1 || buffer.include?("\n") || buffer.include?("\r")
+            # Remove any trailing \r or \n from rapid input buffer
+            cleaned_buffer = buffer.gsub(/[\r\n]+\z/, '')
+            return { type: :rapid_input, text: cleaned_buffer } if cleaned_buffer.length > 0
+          end
+
+          # Single character, continue to normal handling
+          char = buffer[0] if buffer.length == 1
+        end
+
+        # Handle control characters
+        case char
+        when "\r" then :enter
+        when "\n" then :newline  # Shift+Enter sends \n
+        when "\u007F", "\b" then :backspace
+        when "\u0001" then :ctrl_a
+        when "\u0002" then :ctrl_b
+        when "\u0003" then :ctrl_c
+        when "\u0004" then :ctrl_d
+        when "\u0005" then :ctrl_e
+        when "\u0006" then :ctrl_f
+        when "\u000B" then :ctrl_k
+        when "\u000C" then :ctrl_l
+        when "\u0012" then :ctrl_r
+        when "\u0015" then :ctrl_u
+        when "\u0016" then :ctrl_v
+        when "\u0017" then :ctrl_w
+        else char
+        end
+      end
+
+      # Flush output
+      def flush
+        $stdout.flush
+      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/theme_manager.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "themes/base_theme"
+require_relative "themes/hacker_theme"
+require_relative "themes/minimal_theme"
+
+module Clacky
+  module UI2
+    # ThemeManager handles theme registration and switching
+    class ThemeManager
+      class << self
+        def instance
+          @instance ||= new
+        end
+
+        # Delegate methods to instance
+        def current_theme
+          instance.current_theme
+        end
+
+        def set_theme(name)
+          instance.set_theme(name)
+        end
+
+        def available_themes
+          instance.available_themes
+        end
+
+        def register_theme(name, theme_class)
+          instance.register_theme(name, theme_class)
+        end
+      end
+
+      def initialize
+        @themes = {}
+        @current_theme = nil
+        register_default_themes
+        set_theme(:hacker)
+      end
+
+      def current_theme
+        @current_theme
+      end
+
+      def set_theme(name)
+        name = name.to_sym
+        raise ArgumentError, "Unknown theme: #{name}" unless @themes.key?(name)
+
+        @current_theme = @themes[name].new
+      end
+
+      def available_themes
+        @themes.keys
+      end
+
+      def register_theme(name, theme_class)
+        @themes[name.to_sym] = theme_class
+      end
+
+      private
+
+      def register_default_themes
+        register_theme(:hacker, Themes::HackerTheme)
+        register_theme(:minimal, Themes::MinimalTheme)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "pastel"
+
+module Clacky
+  module UI2
+    module Themes
+      # BaseTheme defines the abstract interface for all themes
+      # Subclasses MUST define SYMBOLS and COLORS constants
+      class BaseTheme
+        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
+
+        # Format symbol with its color
+        # @param key [Symbol] Symbol key (e.g., :user, :assistant)
+        # @return [String] Colored symbol
+        def format_symbol(key)
+          @pastel.public_send(symbol_color(key), symbol(key))
+        end
+
+        # Format text with color for given key
+        # @param text [String] Text to format
+        # @param key [Symbol] Color key (e.g., :user, :assistant)
+        # @return [String] Colored text
+        def format_text(text, key)
+          @pastel.public_send(text_color(key), text)
+        end
+
+        # Theme name for display (subclasses should override)
+        # @return [String] Theme name
+        def name
+          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
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "base_theme"
+
+module Clacky
+  module UI2
+    module Themes
+      # HackerTheme - Matrix/hacker-style with bracket symbols
+      class HackerTheme < BaseTheme
+        SYMBOLS = {
+          user: "[>>]",
+          assistant: "[<<]",
+          tool_call: "[=>]",
+          tool_result: "[<=]",
+          tool_denied: "[!!]",
+          tool_planned: "[??]",
+          tool_error: "[XX]",
+          thinking: "[..]",
+          working: "[..]",
+          success: "[OK]",
+          error: "[ER]",
+          warning: "[!!]",
+          info: "[--]",
+          task: "[##]",
+          progress: "[>>]",
+          file: "[F]",
+          command: "[C]",
+          cached: "[*]"
+        }.freeze
+
+        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],
+          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]
+        }.freeze
+
+        def name
+          "hacker"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "base_theme"
+
+module Clacky
+  module UI2
+    module Themes
+      # MinimalTheme - Clean, simple symbols
+      class MinimalTheme < BaseTheme
+        SYMBOLS = {
+          user: ">",
+          assistant: "<",
+          tool_call: "*",
+          tool_result: "-",
+          tool_denied: "!",
+          tool_planned: "?",
+          tool_error: "x",
+          thinking: ".",
+          working: ".",
+          success: "+",
+          error: "x",
+          warning: "!",
+          info: "-",
+          task: "#",
+          progress: ">"
+        }.freeze
+
+        COLORS = {
+          user: [:blue, :blue],
+          assistant: [:green, :white],
+          tool_call: [:cyan, :cyan],
+          tool_result: [:white, :white],
+          tool_denied: [:yellow, :yellow],
+          tool_planned: [:blue, :blue],
+          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]
+        }.freeze
+
+        def name
+          "minimal"
+        end
+      end
+    end
+  end
+end