openclacky 0.5.3 → 0.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52ab39c40c69d821b45d01ed1d14086a50446309421891e9cd6724a9b32864cf
-  data.tar.gz: 0d61ef02a23f8a04157f8b7b2308a4f0c68fd37bba1407894b9841cd707c6873
+  metadata.gz: f86dc057b8fd69db07c40a5633ffe1350cf0ddb8509b6e26705464d9e127daa4
+  data.tar.gz: 58d3e6b89e129d6c7ef7dbc57ff57e95ee8d6acd96186491daa8670b6031c3b2
 SHA512:
-  metadata.gz: d654bd29a093bf23f1e0c162867251e08a28ec722deaae7a9d234f2aed913329d991df29391778612c458c51b6775881ee0867cb2d959c0f7072b14e662d0c38
-  data.tar.gz: 8056dff60d1c845751021e2c852e58071360c8d6a6b81cec72be238e647521ae36a211d72af88602239f8abcab5a15b7a345b8efd98e68b62a0a6dfde8a63b23
+  metadata.gz: 4d724c3d9404faed0bead1fb3e417782f15a9d89dde03709696120df87230d7a6d33250684e96e99f13b87f3993bfffd53dc5b52c87c34e79844a171429685af
+  data.tar.gz: 837b07953b38515d0c1bf0b6081a1fd10e7fffa46f9cbf1d1721744cabe494c5a018bcb1d0290e988782a534aad9ab24137978d7299d1908cb9fb248258de282

data/CHANGELOG.md

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.5.4] - 2026-01-16
+
+### Added
+- **Automatic Paste Detection**: Rapid input detection automatically identifies paste operations
+- **Word Wrap Display**: Long input lines automatically wrap with scroll indicators (up to 15 visible lines)
+- **Full-width Terminal Display**: Enhanced prompt box uses full terminal width for better visibility
+
+### Improved
+- **Smart Ctrl+C Handling**: First press clears content, second press (within 2s) exits
+- **UTF-8 Encoding**: Better handling of multi-byte characters in clipboard operations
+- **Cursor Positioning**: Improved cursor tracking in wrapped lines
+- **Multi-line Paste**: Better display for pasted content with placeholder support
+
 ## [0.5.0] - 2026-01-11
 
 ### Added

data/README.md

@@ -6,6 +6,8 @@ A command-line interface for interacting with AI models. OpenClacky supports Ope
 
 - 💬 Interactive chat sessions with AI models
 - 🤖 Autonomous AI agent with tool use capabilities
+- 📝 Enhanced input with multi-line support and Unicode (Chinese, etc.)
+- 🖼️ Paste images from clipboard (macOS/Linux)
 - 🚀 Single-message mode for quick queries
 - 🔐 Secure API key management
 - 📝 Multi-turn conversation support

data/Rakefile

@@ -5,10 +5,6 @@ require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
 
-require "rubocop/rake_task"
-
-RuboCop::RakeTask.new
-
 namespace :build do
   desc "Build both openclacky and clacky gems"
   task :all do
@@ -35,4 +31,4 @@ namespace :build do
   end
 end
 
-task default: %i[spec rubocop]
+task default: %i[spec]

data/lib/clacky/cli.rb

@@ -4,7 +4,7 @@ require "thor"
 require "tty-prompt"
 require "tty-spinner"
 require_relative "ui/banner"
-require_relative "ui/prompt"
+require_relative "ui/enhanced_prompt"
 require_relative "ui/statusbar"
 require_relative "ui/formatter"
 
@@ -409,7 +409,11 @@ module Clacky
             )
 
             # Use enhanced prompt with "You:" prefix
-            current_message = prompt.read_input(prefix: "You:")
+            result = prompt.read_input(prefix: "You:")
+            
+            # EnhancedPrompt returns { text: String, images: Array } or nil
+            # For now, we only use the text part
+            current_message = result.nil? ? nil : result[:text]
 
             break if current_message.nil? || %w[exit quit].include?(current_message&.downcase&.strip)
             next if current_message.strip.empty?
@@ -613,7 +617,7 @@ module Clacky
       end
 
       def ui_prompt
-        @ui_prompt ||= UI::Prompt.new
+        @ui_prompt ||= UI::EnhancedPrompt.new
       end
 
       def ui_statusbar

data/lib/clacky/gitignore_parser.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Clacky
+  # Parser for .gitignore files to determine which files should be ignored
+  class GitignoreParser
+    attr_reader :patterns
+
+    def initialize(gitignore_path = nil)
+      @patterns = []
+      @negation_patterns = []
+      
+      if gitignore_path && File.exist?(gitignore_path)
+        parse_gitignore(gitignore_path)
+      end
+    end
+
+    # Check if a file path should be ignored
+    def ignored?(path)
+      relative_path = path.start_with?('./') ? path[2..] : path
+      
+      # Check negation patterns first (! prefix in .gitignore)
+      @negation_patterns.each do |pattern|
+        return false if match_pattern?(relative_path, pattern)
+      end
+      
+      # Then check ignore patterns
+      @patterns.each do |pattern|
+        return true if match_pattern?(relative_path, pattern)
+      end
+      
+      false
+    end
+
+    private
+
+    def parse_gitignore(path)
+      File.readlines(path, chomp: true).each do |line|
+        # Skip comments and empty lines
+        next if line.strip.empty? || line.start_with?('#')
+        
+        # Handle negation patterns (lines starting with !)
+        if line.start_with?('!')
+          @negation_patterns << normalize_pattern(line[1..])
+        else
+          @patterns << normalize_pattern(line)
+        end
+      end
+    rescue StandardError => e
+      # If we can't parse .gitignore, just continue with empty patterns
+      warn "Warning: Failed to parse .gitignore: #{e.message}"
+    end
+
+    def normalize_pattern(pattern)
+      pattern = pattern.strip
+      
+      # Remove trailing whitespace
+      pattern = pattern.rstrip
+      
+      # Store original for directory detection
+      is_directory = pattern.end_with?('/')
+      pattern = pattern.chomp('/')
+      
+      {
+        pattern: pattern,
+        is_directory: is_directory,
+        is_absolute: pattern.start_with?('/'),
+        has_wildcard: pattern.include?('*') || pattern.include?('?'),
+        has_double_star: pattern.include?('**')
+      }
+    end
+
+    def match_pattern?(path, pattern_info)
+      pattern = pattern_info[:pattern]
+      
+      # Remove leading slash for absolute patterns
+      pattern = pattern[1..] if pattern_info[:is_absolute]
+      
+      # Handle directory patterns
+      if pattern_info[:is_directory]
+        return false unless File.directory?(path)
+      end
+      
+      # Handle different wildcard patterns
+      if pattern_info[:has_double_star]
+        # Convert ** to match any number of directories
+        regex_pattern = pattern
+          .gsub('**/', '(.*/)?')  # **/ matches zero or more directories
+          .gsub('**', '.*')        # ** at end matches anything
+          .gsub('*', '[^/]*')      # * matches anything except /
+          .gsub('?', '[^/]')       # ? matches single character except /
+        
+        regex = Regexp.new("^#{regex_pattern}$")
+        return true if path.match?(regex)
+        return true if path.split('/').any? { |part| part.match?(regex) }
+      elsif pattern_info[:has_wildcard]
+        # Convert glob pattern to regex
+        regex_pattern = pattern
+          .gsub('*', '[^/]*')
+          .gsub('?', '[^/]')
+        
+        regex = Regexp.new("^#{regex_pattern}$")
+        return true if path.match?(regex)
+        return true if File.basename(path).match?(regex)
+      else
+        # Exact match
+        return true if path == pattern
+        return true if path.start_with?("#{pattern}/")
+        return true if File.basename(path) == pattern
+      end
+      
+      false
+    end
+  end
+end

data/lib/clacky/tools/grep.rb

@@ -3,6 +3,42 @@
 module Clacky
   module Tools
     class Grep < Base
+      # Default patterns to ignore when .gitignore is not available
+      DEFAULT_IGNORED_PATTERNS = [
+        'node_modules',
+        'vendor/bundle',
+        '.git',
+        '.svn',
+        'tmp',
+        'log',
+        'coverage',
+        'dist',
+        'build',
+        '.bundle',
+        '.sass-cache',
+        '.DS_Store',
+        '*.log'
+      ].freeze
+
+      # Config file patterns that should always be searchable
+      CONFIG_FILE_PATTERNS = [
+        /\.env/,
+        /\.ya?ml$/,
+        /\.json$/,
+        /\.toml$/,
+        /\.ini$/,
+        /\.conf$/,
+        /\.config$/,
+        /config\//,
+        /\.config\//
+      ].freeze
+
+      # Maximum file size to search (1MB)
+      MAX_FILE_SIZE = 1_048_576
+
+      # Maximum line length to display (to avoid huge outputs)
+      MAX_LINE_LENGTH = 500
+
       self.tool_name = "grep"
       self.tool_description = "Search file contents using regular expressions. Returns matching lines with context."
       self.tool_category = "file_system"
@@ -30,53 +66,144 @@ module Clacky
           },
           context_lines: {
             type: "integer",
-            description: "Number of context lines to show before and after each match",
+            description: "Number of context lines to show before and after each match (max: 10)",
             default: 0
           },
-          max_matches: {
+          max_files: {
             type: "integer",
             description: "Maximum number of matching files to return",
             default: 50
+          },
+          max_matches_per_file: {
+            type: "integer",
+            description: "Maximum number of matches to return per file",
+            default: 50
+          },
+          max_total_matches: {
+            type: "integer",
+            description: "Maximum total number of matches to return across all files",
+            default: 200
+          },
+          max_file_size: {
+            type: "integer",
+            description: "Maximum file size in bytes to search (default: 1MB)",
+            default: MAX_FILE_SIZE
+          },
+          max_files_to_search: {
+            type: "integer",
+            description: "Maximum number of files to search",
+            default: 500
           }
         },
         required: %w[pattern]
       }
 
-      def execute(pattern:, path: ".", file_pattern: "**/*", case_insensitive: false, context_lines: 0, max_matches: 50)
+      def execute(
+        pattern:,
+        path: ".",
+        file_pattern: "**/*",
+        case_insensitive: false,
+        context_lines: 0,
+        max_files: 50,
+        max_matches_per_file: 50,
+        max_total_matches: 200,
+        max_file_size: MAX_FILE_SIZE,
+        max_files_to_search: 500
+      )
         # Validate pattern
         if pattern.nil? || pattern.strip.empty?
           return { error: "Pattern cannot be empty" }
         end
 
-        # Validate path
-        unless File.exist?(path)
+        # Validate and expand path
+        begin
+          expanded_path = File.expand_path(path)
+        rescue StandardError => e
+          return { error: "Invalid path: #{e.message}" }
+        end
+
+        unless File.exist?(expanded_path)
           return { error: "Path does not exist: #{path}" }
         end
 
+        # Limit context_lines
+        context_lines = [[context_lines, 0].max, 10].min
+
         begin
           # Compile regex
           regex_options = case_insensitive ? Regexp::IGNORECASE : 0
           regex = Regexp.new(pattern, regex_options)
 
+          # Initialize gitignore parser
+          gitignore_path = find_gitignore(expanded_path)
+          gitignore = gitignore_path ? GitignoreParser.new(gitignore_path) : nil
+
           results = []
           total_matches = 0
+          files_searched = 0
+          skipped = {
+            binary: 0,
+            too_large: 0,
+            ignored: 0
+          }
+          truncation_reason = nil
 
           # Get files to search
-          files = if File.file?(path)
-                    [path]
+          files = if File.file?(expanded_path)
+                    [expanded_path]
                   else
-                    Dir.glob(File.join(path, file_pattern))
+                    Dir.glob(File.join(expanded_path, file_pattern))
                        .select { |f| File.file?(f) }
-                       .reject { |f| binary_file?(f) }
                   end
 
           # Search each file
           files.each do |file|
-            break if results.length >= max_matches
+            # Check if we've searched enough files
+            if files_searched >= max_files_to_search
+              truncation_reason ||= "max_files_to_search limit reached"
+              break
+            end
+
+            # Skip if file should be ignored (unless it's a config file)
+            if should_ignore_file?(file, expanded_path, gitignore) && !is_config_file?(file)
+              skipped[:ignored] += 1
+              next
+            end
+
+            # Skip binary files
+            if binary_file?(file)
+              skipped[:binary] += 1
+              next
+            end
+
+            # Skip files that are too large
+            if File.size(file) > max_file_size
+              skipped[:too_large] += 1
+              next
+            end
+
+            files_searched += 1
+
+            # Check if we've found enough matching files
+            if results.length >= max_files
+              truncation_reason ||= "max_files limit reached"
+              break
+            end
+
+            # Check if we've found enough total matches
+            if total_matches >= max_total_matches
+              truncation_reason ||= "max_total_matches limit reached"
+              break
+            end
 
-            matches = search_file(file, regex, context_lines)
+            # Search the file
+            matches = search_file(file, regex, context_lines, max_matches_per_file)
             next if matches.empty?
 
+            # Add remaining matches respecting max_total_matches
+            remaining_matches = max_total_matches - total_matches
+            matches = matches.take(remaining_matches) if remaining_matches < matches.length
+
             results << {
               file: File.expand_path(file),
               matches: matches
@@ -87,9 +214,11 @@ module Clacky
           {
             results: results,
             total_matches: total_matches,
-            files_searched: files.length,
+            files_searched: files_searched,
             files_with_matches: results.length,
-            truncated: results.length >= max_matches,
+            skipped_files: skipped,
+            truncated: !truncation_reason.nil?,
+            truncation_reason: truncation_reason,
             error: nil
           }
         rescue RegexpError => e
@@ -116,36 +245,96 @@ module Clacky
         else
           matches = result[:total_matches] || 0
           files = result[:files_with_matches] || 0
-          "✓ Found #{matches} matches in #{files} files"
+          msg = "✓ Found #{matches} matches in #{files} files"
+          
+          # Add truncation info if present
+          if result[:truncated] && result[:truncation_reason]
+            msg += " (truncated: #{result[:truncation_reason]})"
+          end
+          
+          msg
         end
       end
 
       private
 
-      def search_file(file, regex, context_lines)
-        matches = []
-        lines = File.readlines(file, chomp: true)
+      # Find .gitignore file in the search path or parent directories
+      def find_gitignore(path)
+        search_path = File.directory?(path) ? path : File.dirname(path)
+        
+        # Look for .gitignore in current and parent directories
+        current = File.expand_path(search_path)
+        root = File.expand_path('/')
+        
+        loop do
+          gitignore = File.join(current, '.gitignore')
+          return gitignore if File.exist?(gitignore)
+          
+          break if current == root
+          current = File.dirname(current)
+        end
+        
+        nil
+      end
+
+      # Check if file should be ignored based on .gitignore or default patterns
+      def should_ignore_file?(file, base_path, gitignore)
+        # Calculate relative path
+        if file.start_with?(base_path)
+          relative_path = file[base_path.length + 1..] || file
+        else
+          relative_path = file
+        end
+        relative_path = relative_path.sub(/^\.\//, '') if relative_path
+        relative_path ||= file
+        
+        if gitignore
+          # Use .gitignore rules
+          gitignore.ignored?(relative_path)
+        else
+          # Use default ignore patterns
+          DEFAULT_IGNORED_PATTERNS.any? do |pattern|
+            if pattern.include?('*')
+              File.fnmatch(pattern, relative_path, File::FNM_PATHNAME | File::FNM_DOTMATCH)
+            else
+              relative_path.start_with?("#{pattern}/") || 
+              relative_path.include?("/#{pattern}/") ||
+              relative_path == pattern ||
+              File.basename(relative_path) == pattern
+            end
+          end
+        end
+      end
 
-        lines.each_with_index do |line, index|
+      # Check if file is a config file (should not be ignored even if in .gitignore)
+      def is_config_file?(file)
+        CONFIG_FILE_PATTERNS.any? { |pattern| file.match?(pattern) }
+      end
+
+      def search_file(file, regex, context_lines, max_matches)
+        matches = []
+        
+        # Use File.foreach for memory-efficient line-by-line reading
+        File.foreach(file, chomp: true).with_index do |line, index|
+          # Stop if we have enough matches for this file
+          break if matches.length >= max_matches
+          
           next unless line.match?(regex)
 
-          # Get context
-          start_line = [0, index - context_lines].max
-          end_line = [lines.length - 1, index + context_lines].min
+          # Truncate long lines
+          display_line = line.length > MAX_LINE_LENGTH ? "#{line[0...MAX_LINE_LENGTH]}..." : line
 
-          context = []
-          (start_line..end_line).each do |i|
-            context << {
-              line_number: i + 1,
-              content: lines[i],
-              is_match: i == index
-            }
+          # Get context if requested
+          if context_lines > 0
+            context = get_line_context(file, index, context_lines)
+          else
+            context = nil
           end
 
           matches << {
             line_number: index + 1,
-            line: line,
-            context: context_lines > 0 ? context : nil
+            line: display_line,
+            context: context
           }
         end
 
@@ -154,6 +343,32 @@ module Clacky
         []
       end
 
+      # Get context lines around a match
+      def get_line_context(file, match_index, context_lines)
+        lines = File.readlines(file, chomp: true)
+        start_line = [0, match_index - context_lines].max
+        end_line = [lines.length - 1, match_index + context_lines].min
+
+        context = []
+        (start_line..end_line).each do |i|
+          line_content = lines[i]
+          # Truncate long lines in context too
+          display_content = line_content.length > MAX_LINE_LENGTH ? 
+                          "#{line_content[0...MAX_LINE_LENGTH]}..." : 
+                          line_content
+          
+          context << {
+            line_number: i + 1,
+            content: display_content,
+            is_match: i == match_index
+          }
+        end
+
+        context
+      rescue StandardError
+        nil
+      end
+
       def binary_file?(file)
         # Simple heuristic: check if file contains null bytes in first 8KB
         return false unless File.exist?(file)

data/lib/clacky/ui/enhanced_prompt.rb

@@ -0,0 +1,643 @@
+# frozen_string_literal: true
+
+require "io/console"
+require "pastel"
+require "tty-screen"
+require "tempfile"
+require "base64"
+
+module Clacky
+  module UI
+    # Enhanced input prompt with multi-line support and image paste
+    # 
+    # Features:
+    # - Shift+Enter: Add new line
+    # - Enter: Submit message
+    # - Ctrl+V: Paste text or images from clipboard
+    # - Image preview and management
+    class EnhancedPrompt
+      attr_reader :images
+
+      def initialize
+        @pastel = Pastel.new
+        @images = [] # Array of image file paths
+        @paste_counter = 0 # Counter for paste operations
+        @paste_placeholders = {} # Map of placeholder text to actual pasted content
+        @last_input_time = nil # Track last input time for rapid input detection
+        @rapid_input_threshold = 0.01 # 10ms threshold for detecting paste-like rapid input
+      end
+
+      # Read user input with enhanced features
+      # @param prefix [String] Prompt prefix (default: "You:")
+      # @return [Hash, nil] { text: String, images: Array } or nil on EOF
+      def read_input(prefix: "You:")
+        @images = []
+        lines = []
+        cursor_pos = 0
+        line_index = 0
+        @last_ctrl_c_time = nil  # Track when Ctrl+C was last pressed
+
+        loop do
+          # Display the prompt box
+          display_prompt_box(lines, prefix, line_index, cursor_pos)
+
+          # Read a single character/key
+          begin
+            key = read_key_with_rapid_detection
+          rescue Interrupt
+            return nil
+          end
+          
+          # Handle buffered rapid input (system paste detection)
+          if key.is_a?(Hash) && key[:type] == :rapid_input
+            pasted_text = key[:text]
+            pasted_lines = pasted_text.split("\n")
+            
+            if pasted_lines.size > 1
+              # Multi-line rapid input - use placeholder for display
+              @paste_counter += 1
+              placeholder = "[##{@paste_counter} Paste Text]"
+              @paste_placeholders[placeholder] = pasted_text
+              
+              # Insert placeholder at cursor position
+              chars = (lines[line_index] || "").chars
+              placeholder_chars = placeholder.chars
+              chars.insert(cursor_pos, *placeholder_chars)
+              lines[line_index] = chars.join
+              cursor_pos += placeholder_chars.length
+            else
+              # Single line rapid input - insert at cursor (use chars for UTF-8)
+              chars = (lines[line_index] || "").chars
+              pasted_chars = pasted_text.chars
+              chars.insert(cursor_pos, *pasted_chars)
+              lines[line_index] = chars.join
+              cursor_pos += pasted_chars.length
+            end
+            next
+          end
+
+          case key
+          when "\n" # Shift+Enter - newline (Linux/Mac sends \n for Shift+Enter in some terminals)
+            # Add new line
+            if lines[line_index]
+              # Split current line at cursor (use chars for UTF-8)
+              chars = lines[line_index].chars
+              lines[line_index] = chars[0...cursor_pos].join
+              lines.insert(line_index + 1, chars[cursor_pos..-1].join || "")
+            else
+              lines.insert(line_index + 1, "")
+            end
+            line_index += 1
+            cursor_pos = 0
+
+          when "\r" # Enter - submit
+            # Submit if not empty
+            unless lines.join.strip.empty? && @images.empty?
+              clear_prompt_display(lines.size)
+              # Replace placeholders with actual pasted content
+              final_text = expand_placeholders(lines.join("\n"))
+              return { text: final_text, images: @images.dup }
+            end
+
+          when "\u0003" # Ctrl+C
+            # Check if input is empty
+            has_content = lines.any? { |line| !line.strip.empty? } || @images.any?
+            
+            if has_content
+              # Input has content - clear it on first Ctrl+C
+              current_time = Time.now.to_f
+              time_since_last = @last_ctrl_c_time ? (current_time - @last_ctrl_c_time) : Float::INFINITY
+              
+              if time_since_last < 2.0  # Within 2 seconds of last Ctrl+C
+                # Second Ctrl+C within 2 seconds - exit
+                clear_prompt_display(lines.size)
+                return nil
+              else
+                # First Ctrl+C - clear content
+                @last_ctrl_c_time = current_time
+                lines = []
+                @images = []
+                cursor_pos = 0
+                line_index = 0
+                @paste_counter = 0
+                @paste_placeholders = {}
+              end
+            else
+              # Input is empty - exit immediately
+              clear_prompt_display(lines.size)
+              return nil
+            end
+
+          when "\u0016" # Ctrl+V - Paste
+            pasted = paste_from_clipboard
+            if pasted[:type] == :image
+              # Save image and add to list
+              @images << pasted[:path]
+            else
+              # Handle pasted text
+              pasted_text = pasted[:text]
+              pasted_lines = pasted_text.split("\n")
+              
+              if pasted_lines.size > 1
+                # Multi-line paste - use placeholder for display
+                @paste_counter += 1
+                placeholder = "[##{@paste_counter} Paste Text]"
+                @paste_placeholders[placeholder] = pasted_text
+                
+                # Insert placeholder at cursor position
+                chars = (lines[line_index] || "").chars
+                placeholder_chars = placeholder.chars
+                chars.insert(cursor_pos, *placeholder_chars)
+                lines[line_index] = chars.join
+                cursor_pos += placeholder_chars.length
+              else
+                # Single line paste - insert at cursor (use chars for UTF-8)
+                chars = (lines[line_index] || "").chars
+                pasted_chars = pasted_text.chars
+                chars.insert(cursor_pos, *pasted_chars)
+                lines[line_index] = chars.join
+                cursor_pos += pasted_chars.length
+              end
+            end
+
+          when "\u007F", "\b" # Backspace
+            if cursor_pos > 0
+              # Delete character before cursor (use chars for UTF-8)
+              chars = (lines[line_index] || "").chars
+              chars.delete_at(cursor_pos - 1)
+              lines[line_index] = chars.join
+              cursor_pos -= 1
+            elsif line_index > 0
+              # Join with previous line
+              prev_line = lines[line_index - 1]
+              current_line = lines[line_index]
+              lines.delete_at(line_index)
+              line_index -= 1
+              cursor_pos = prev_line.chars.length
+              lines[line_index] = prev_line + current_line
+            end
+
+          when "\e[A" # Up arrow
+            if line_index > 0
+              line_index -= 1
+              cursor_pos = [cursor_pos, (lines[line_index] || "").chars.length].min
+            end
+
+          when "\e[B" # Down arrow
+            if line_index < lines.size - 1
+              line_index += 1
+              cursor_pos = [cursor_pos, (lines[line_index] || "").chars.length].min
+            end
+
+          when "\e[C" # Right arrow
+            current_line = lines[line_index] || ""
+            cursor_pos = [cursor_pos + 1, current_line.chars.length].min
+
+          when "\e[D" # Left arrow
+            cursor_pos = [cursor_pos - 1, 0].max
+
+          when "\u0004" # Ctrl+D - Delete image by number
+            if @images.any?
+              print "\nEnter image number to delete (1-#{@images.size}): "
+              num = STDIN.gets.to_i
+              if num > 0 && num <= @images.size
+                @images.delete_at(num - 1)
+              end
+            end
+
+          else
+            # Regular character input - support UTF-8
+            if key.length >= 1 && key != "\e" && !key.start_with?("\e") && key.ord >= 32
+              lines[line_index] ||= ""
+              current_line = lines[line_index]
+              
+              # Insert character at cursor position (using character index, not byte index)
+              chars = current_line.chars
+              chars.insert(cursor_pos, key)
+              lines[line_index] = chars.join
+              cursor_pos += 1
+            end
+          end
+
+          # Ensure we have at least one line
+          lines << "" if lines.empty?
+        end
+      end
+
+      private
+
+      # Expand placeholders to actual pasted content
+      def expand_placeholders(text)
+        result = text.dup
+        @paste_placeholders.each do |placeholder, actual_content|
+          result.gsub!(placeholder, actual_content)
+        end
+        result
+      end
+
+      # Display the prompt box with images and input
+      def display_prompt_box(lines, prefix, line_index, cursor_pos)
+        width = TTY::Screen.width - 4  # Use full terminal width (minus 4 for borders)
+
+        # Clear previous display if exists
+        if @last_display_lines && @last_display_lines > 0
+          # Move cursor up and clear each line
+          @last_display_lines.times do
+            print "\e[1A"  # Move up one line
+            print "\e[2K"  # Clear entire line
+          end
+          print "\r"  # Move to beginning of line
+        end
+
+        lines_to_display = []
+
+        # Display images if any
+        if @images.any?
+          lines_to_display << @pastel.dim("╭─ Attached Images " + "─" * (width - 19) + "╮")
+          @images.each_with_index do |img_path, idx|
+            filename = File.basename(img_path)
+            # Check if file exists before getting size
+            filesize = File.exist?(img_path) ? format_filesize(File.size(img_path)) : "N/A"
+            line_content = " #{idx + 1}. #{filename} (#{filesize})"
+            display_content = line_content.ljust(width - 2)
+            lines_to_display << @pastel.dim("│ ") + display_content + @pastel.dim(" │")
+          end
+          lines_to_display << @pastel.dim("╰" + "─" * width + "╯")
+          lines_to_display << ""
+        end
+
+        # Display input box
+        hint = "Shift+Enter:newline | Enter:submit | Ctrl+C:cancel"
+        lines_to_display << @pastel.dim("╭─ Message " + "─" * (width - 10) + "╮")
+        hint_line = @pastel.dim(hint)
+        padding = " " * [(width - hint.length - 2), 0].max
+        lines_to_display << @pastel.dim("│ ") + hint_line + padding + @pastel.dim(" │")
+        lines_to_display << @pastel.dim("├" + "─" * width + "┤")
+
+        # Display input lines with word wrap
+        display_lines = lines.empty? ? [""] : lines
+        max_display_lines = 15 # Show up to 15 wrapped lines
+        
+        # Flatten all lines with word wrap
+        wrapped_display_lines = []
+        line_to_wrapped_mapping = [] # Track which original line each wrapped line belongs to
+        
+        display_lines.each_with_index do |line, original_idx|
+          line_chars = line.chars
+          content_width = width - 2 # Available width for content (excluding borders)
+          
+          if line_chars.length <= content_width
+            # Line fits in one display line
+            wrapped_display_lines << { text: line, original_line: original_idx, start_pos: 0 }
+          else
+            # Line needs wrapping
+            start_pos = 0
+            while start_pos < line_chars.length
+              chunk_chars = line_chars[start_pos...[start_pos + content_width, line_chars.length].min]
+              wrapped_display_lines << { 
+                text: chunk_chars.join, 
+                original_line: original_idx, 
+                start_pos: start_pos 
+              }
+              start_pos += content_width
+            end
+          end
+        end
+        
+        # Find which wrapped line contains the cursor
+        cursor_wrapped_line_idx = 0
+        cursor_in_wrapped_pos = cursor_pos
+        content_width = width - 2
+        
+        # Find all wrapped lines for the current line_index
+        current_line_wrapped = wrapped_display_lines.select.with_index { |wl, idx| wl[:original_line] == line_index }
+        
+        if current_line_wrapped.any?
+          # Iterate through wrapped lines to find where cursor belongs
+          accumulated_chars = 0
+          found = false
+          
+          current_line_wrapped.each_with_index do |wrapped_line, local_idx|
+            line_start = wrapped_line[:start_pos]
+            line_length = wrapped_line[:text].chars.length
+            line_end = line_start + line_length
+            
+            # Find global index of this wrapped line
+            global_idx = wrapped_display_lines.index { |wl| wl == wrapped_line }
+            
+            if cursor_pos >= line_start && cursor_pos < line_end
+              # Cursor is within this wrapped line
+              cursor_wrapped_line_idx = global_idx
+              cursor_in_wrapped_pos = cursor_pos - line_start
+              found = true
+              break
+            elsif cursor_pos == line_end && local_idx == current_line_wrapped.length - 1
+              # Cursor is at the very end of the last wrapped line for this line_index
+              cursor_wrapped_line_idx = global_idx
+              cursor_in_wrapped_pos = line_length
+              found = true
+              break
+            end
+          end
+          
+          # Fallback: if not found, place cursor at the end of the last wrapped line
+          unless found
+            last_wrapped = current_line_wrapped.last
+            cursor_wrapped_line_idx = wrapped_display_lines.index { |wl| wl == last_wrapped }
+            cursor_in_wrapped_pos = last_wrapped[:text].chars.length
+          end
+        end
+        
+        # Determine which wrapped lines to display (centered around cursor)
+        if wrapped_display_lines.size <= max_display_lines
+          display_start = 0
+          display_end = wrapped_display_lines.size - 1
+        else
+          # Center view around cursor line
+          half_display = max_display_lines / 2
+          display_start = [cursor_wrapped_line_idx - half_display, 0].max
+          display_end = [display_start + max_display_lines - 1, wrapped_display_lines.size - 1].min
+          
+          # Adjust if we're near the end
+          if display_end - display_start < max_display_lines - 1
+            display_start = [display_end - max_display_lines + 1, 0].max
+          end
+        end
+        
+        # Display the wrapped lines
+        (display_start..display_end).each do |idx|
+          wrapped_line = wrapped_display_lines[idx]
+          line_text = wrapped_line[:text]
+          line_chars = line_text.chars
+          content_width = width - 2
+          
+          # Pad to full width
+          display_line = line_text.ljust(content_width)
+          
+          if idx == cursor_wrapped_line_idx
+            # Show cursor on this wrapped line
+            before_cursor = line_chars[0...cursor_in_wrapped_pos].join
+            cursor_char = line_chars[cursor_in_wrapped_pos] || " "
+            after_cursor_chars = line_chars[(cursor_in_wrapped_pos + 1)..-1]
+            after_cursor = after_cursor_chars ? after_cursor_chars.join : ""
+            
+            # Calculate padding
+            content_length = before_cursor.length + 1 + after_cursor.length
+            padding = " " * [content_width - content_length, 0].max
+            
+            line_display = before_cursor + @pastel.on_white(@pastel.black(cursor_char)) + after_cursor + padding
+            lines_to_display << @pastel.dim("│ ") + line_display + @pastel.dim(" │")
+          else
+            lines_to_display << @pastel.dim("│ ") + display_line + @pastel.dim(" │")
+          end
+        end
+        
+        # Show scroll indicator if needed
+        if wrapped_display_lines.size > max_display_lines
+          scroll_info = " (#{display_start + 1}-#{display_end + 1}/#{wrapped_display_lines.size} lines) "
+          lines_to_display << @pastel.dim("│#{scroll_info.center(width)}│")
+        end
+
+        # Footer - calculate width properly
+        footer_text = "Line #{line_index + 1}/#{display_lines.size} | Char #{cursor_pos}/#{(display_lines[line_index] || "").chars.length}"
+        # Total width = "╰─ " (3) + footer_text + " ─...─╯" (width - 3 - footer_text.length)
+        remaining_width = width - footer_text.length - 3  # 3 = "╰─ " length
+        footer_line = @pastel.dim("╰─ ") + @pastel.dim(footer_text) + @pastel.dim(" ") + @pastel.dim("─" * [remaining_width - 1, 0].max) + @pastel.dim("╯")
+        lines_to_display << footer_line
+        
+        # Output all lines at once (use print to avoid extra newline at the end)
+        print lines_to_display.join("\n")
+        print "\n"  # Add one controlled newline
+        
+        # Remember how many lines we displayed
+        @last_display_lines = lines_to_display.size
+      end
+
+      # Clear prompt display after submission
+      def clear_prompt_display(num_lines)
+        # Clear the prompt box we just displayed
+        if @last_display_lines && @last_display_lines > 0
+          @last_display_lines.times do
+            print "\e[1A"  # Move up one line
+            print "\e[2K"  # Clear entire line
+          end
+          print "\r"  # Move to beginning of line
+        end
+      end
+
+      # Read a single key press with escape sequence handling
+      # Handles UTF-8 multi-byte characters correctly
+      # Also detects rapid input (paste-like behavior)
+      def read_key_with_rapid_detection
+        $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
+        
+        $stdin.raw do |io|
+          io.set_encoding('UTF-8')  # Ensure IO encoding is UTF-8
+          c = io.getc
+          
+          # Ensure character is UTF-8 encoded
+          c = c.force_encoding('UTF-8') if c.is_a?(String) && c.encoding != Encoding::UTF_8
+          
+          # Handle escape sequences (arrow keys, special keys)
+          if c == "\e"
+            # Read the next 2 characters for escape sequences
+            begin
+              extra = io.read_nonblock(2)
+              extra = extra.force_encoding('UTF-8') if extra.encoding != Encoding::UTF_8
+              c = c + extra
+            rescue IO::WaitReadable, Errno::EAGAIN
+              # No more characters available
+            end
+            return c
+          end
+          
+          # Check if there are more characters available using IO.select with timeout 0
+          has_more_input = IO.select([io], nil, nil, 0)
+          
+          # If this is rapid input or there are more characters available
+          if is_rapid_input || has_more_input
+            # Buffer rapid input
+            buffer = c.to_s.dup
+            buffer.force_encoding('UTF-8')
+            
+            # Keep reading available characters
+            loop do
+              begin
+                next_char = io.read_nonblock(1)
+                next_char = next_char.force_encoding('UTF-8') if next_char.encoding != Encoding::UTF_8
+                buffer << next_char
+                
+                # Continue only if more characters are immediately available
+                break unless IO.select([io], nil, nil, 0)
+              rescue IO::WaitReadable, Errno::EAGAIN
+                break
+              end
+            end
+            
+            # Ensure buffer is UTF-8
+            buffer.force_encoding('UTF-8')
+            
+            # 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 rapid input, return as-is
+            return buffer[0] if buffer.length == 1
+          end
+          
+          c
+        end
+      rescue Errno::EINTR
+        "\u0003" # Treat interrupt as Ctrl+C
+      end
+      
+      # Legacy method for compatibility
+      def read_key
+        read_key_with_rapid_detection
+      end
+
+      # Paste from clipboard (cross-platform)
+      # @return [Hash] { type: :text/:image, text: String, path: String }
+      def paste_from_clipboard
+        case RbConfig::CONFIG["host_os"]
+        when /darwin/i
+          paste_from_clipboard_macos
+        when /linux/i
+          paste_from_clipboard_linux
+        when /mswin|mingw|cygwin/i
+          paste_from_clipboard_windows
+        else
+          { type: :text, text: "" }
+        end
+      end
+
+      # Paste from macOS clipboard
+      def paste_from_clipboard_macos
+        require 'shellwords'
+        require 'fileutils'
+        
+        # First check if there's an image in clipboard
+        # Use osascript to check clipboard content type
+        has_image = system("osascript -e 'try' -e 'the clipboard as «class PNGf»' -e 'on error' -e 'return false' -e 'end try' >/dev/null 2>&1")
+        
+        if has_image
+          # Create a persistent temporary file (won't be auto-deleted)
+          temp_dir = Dir.tmpdir
+          temp_filename = "clipboard-#{Time.now.to_i}-#{rand(10000)}.png"
+          temp_path = File.join(temp_dir, temp_filename)
+          
+          # Extract image using osascript
+          script = <<~APPLESCRIPT
+            set png_data to the clipboard as «class PNGf»
+            set the_file to open for access POSIX file "#{temp_path}" with write permission
+            write png_data to the_file
+            close access the_file
+          APPLESCRIPT
+          
+          success = system("osascript", "-e", script, out: File::NULL, err: File::NULL)
+          
+          if success && File.exist?(temp_path) && File.size(temp_path) > 0
+            return { type: :image, path: temp_path }
+          end
+        end
+
+        # No image, try text - ensure UTF-8 encoding
+        text = `pbpaste 2>/dev/null`.to_s
+        text.force_encoding('UTF-8')
+        # Replace invalid UTF-8 sequences with replacement character
+        text = text.encode('UTF-8', invalid: :replace, undef: :replace)
+        { type: :text, text: text }
+      rescue => e
+        # Fallback to empty text on error
+        { type: :text, text: "" }
+      end
+
+      # Paste from Linux clipboard
+      def paste_from_clipboard_linux
+        require 'shellwords'
+        
+        # Check if xclip is available
+        if system("which xclip >/dev/null 2>&1")
+          # Try to get image first
+          temp_file = Tempfile.new(["clipboard-", ".png"])
+          temp_file.close
+          
+          # Try different image MIME types
+          ["image/png", "image/jpeg", "image/jpg"].each do |mime_type|
+            if system("xclip -selection clipboard -t #{mime_type} -o > #{Shellwords.escape(temp_file.path)} 2>/dev/null")
+              if File.size(temp_file.path) > 0
+                return { type: :image, path: temp_file.path }
+              end
+            end
+          end
+          
+          # No image, get text - ensure UTF-8 encoding
+          text = `xclip -selection clipboard -o 2>/dev/null`.to_s
+          text.force_encoding('UTF-8')
+          text = text.encode('UTF-8', invalid: :replace, undef: :replace)
+          { type: :text, text: text }
+        elsif system("which xsel >/dev/null 2>&1")
+          # Fallback to xsel for text only
+          text = `xsel --clipboard --output 2>/dev/null`.to_s
+          text.force_encoding('UTF-8')
+          text = text.encode('UTF-8', invalid: :replace, undef: :replace)
+          { type: :text, text: text }
+        else
+          { type: :text, text: "" }
+        end
+      rescue => e
+        { type: :text, text: "" }
+      end
+
+      # Paste from Windows clipboard
+      def paste_from_clipboard_windows
+        # Try to get image using PowerShell
+        temp_file = Tempfile.new(["clipboard-", ".png"])
+        temp_file.close
+        
+        ps_script = <<~POWERSHELL
+          Add-Type -AssemblyName System.Windows.Forms
+          $img = [Windows.Forms.Clipboard]::GetImage()
+          if ($img) {
+            $img.Save('#{temp_file.path.gsub("'", "''")}', [System.Drawing.Imaging.ImageFormat]::Png)
+            exit 0
+          } else {
+            exit 1
+          }
+        POWERSHELL
+        
+        success = system("powershell", "-NoProfile", "-Command", ps_script, out: File::NULL, err: File::NULL)
+        
+        if success && File.exist?(temp_file.path) && File.size(temp_file.path) > 0
+          return { type: :image, path: temp_file.path }
+        end
+
+        # No image, get text - ensure UTF-8 encoding
+        text = `powershell -NoProfile -Command "Get-Clipboard" 2>nul`.to_s
+        text.force_encoding('UTF-8')
+        text = text.encode('UTF-8', invalid: :replace, undef: :replace)
+        { type: :text, text: text }
+      rescue => e
+        { type: :text, text: "" }
+      end
+
+      # Format file size for display
+      def format_filesize(size)
+        if size < 1024
+          "#{size}B"
+        elsif size < 1024 * 1024
+          "#{(size / 1024.0).round(1)}KB"
+        else
+          "#{(size / 1024.0 / 1024.0).round(1)}MB"
+        end
+      end
+    end
+  end
+end

data/lib/clacky/version.rb

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

data/lib/clacky.rb

@@ -12,6 +12,7 @@ require_relative "clacky/tool_registry"
 require_relative "clacky/thinking_verbs"
 require_relative "clacky/progress_indicator"
 require_relative "clacky/session_manager"
+require_relative "clacky/gitignore_parser"
 require_relative "clacky/utils/limit_stack"
 require_relative "clacky/utils/path_helper"
 require_relative "clacky/tools/base"
@@ -32,7 +33,7 @@ require_relative "clacky/agent"
 
 # UI components
 require_relative "clacky/ui/banner"
-require_relative "clacky/ui/prompt"
+require_relative "clacky/ui/enhanced_prompt"
 require_relative "clacky/ui/statusbar"
 require_relative "clacky/ui/formatter"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openclacky
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.5.4
 platform: ruby
 authors:
 - windy
@@ -137,6 +137,7 @@ files:
 - lib/clacky/client.rb
 - lib/clacky/config.rb
 - lib/clacky/conversation.rb
+- lib/clacky/gitignore_parser.rb
 - lib/clacky/hook_manager.rb
 - lib/clacky/progress_indicator.rb
 - lib/clacky/session_manager.rb
@@ -157,8 +158,8 @@ files:
 - lib/clacky/tools/write.rb
 - lib/clacky/trash_directory.rb
 - lib/clacky/ui/banner.rb
+- lib/clacky/ui/enhanced_prompt.rb
 - lib/clacky/ui/formatter.rb
-- lib/clacky/ui/prompt.rb
 - lib/clacky/ui/statusbar.rb
 - lib/clacky/utils/arguments_parser.rb
 - lib/clacky/utils/limit_stack.rb

data/lib/clacky/ui/prompt.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-require "tty-prompt"
-require "pastel"
-require "tty-screen"
-
-module Clacky
-  module UI
-    # Enhanced input prompt with box drawing and status info
-    class Prompt
-      def initialize
-        @pastel = Pastel.new
-        @tty_prompt = TTY::Prompt.new(interrupt: :exit)
-      end
-
-      # Read user input with enhanced prompt box
-      # @param prefix [String] Prompt prefix (default: "You:")
-      # @param placeholder [String] Placeholder text (not shown when using TTY::Prompt)
-      # @return [String, nil] User input or nil on EOF
-      def read_input(prefix: "You:", placeholder: nil)
-        width = [TTY::Screen.width - 5, 70].min
-
-        # Display complete box frame first
-        puts @pastel.dim("╭" + "─" * width + "╮")
-
-        # Empty input line - NO left border, just spaces and right border
-        padding = " " * width
-        puts @pastel.dim("#{padding} │")
-
-        # Bottom border
-        puts @pastel.dim("╰" + "─" * width + "╯")
-
-        # Move cursor back up to input line (2 lines up)
-        print "\e[2A"  # Move up 2 lines
-        print "\r"     # Move to beginning of line
-
-        # Read input with TTY::Prompt
-        prompt_text = @pastel.bright_blue("#{prefix}")
-        input = read_with_tty_prompt(prompt_text)
-
-        # After input, clear the input box completely
-        # Move cursor up 2 lines to the top of the box
-        print "\e[2A"
-        print "\r"
-
-        # Clear all 3 lines of the box
-        3.times do
-          print "\e[2K"  # Clear entire line
-          print "\e[1B"  # Move down 1 line
-          print "\r"     # Move to beginning of line
-        end
-
-        # Move cursor back up to where the box started
-        print "\e[3A"
-        print "\r"
-
-        input
-      end
-
-      private
-
-      def read_with_tty_prompt(prompt)
-        @tty_prompt.ask(prompt, required: false, echo: true) do |q|
-          q.modify :strip
-        end
-      rescue TTY::Reader::InputInterrupt
-        puts
-        nil
-      end
-    end
-  end
-end