openclacky 0.5.5 → 0.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc218b590b40d1a2301ef91a73b5a4ded7d6891da5b42eea62f4fa8bce200292
-  data.tar.gz: e828ac9fd724d0097f7557401127c513f35138c31d76a06e07c8c70db049cb1c
+  metadata.gz: 34f843ea474327ea95f88685111f1a86149730503625c5e971de239e63764969
+  data.tar.gz: 85f2e93d791d3f774aa4f0d29177d4999fd91306f3c441f21d89c11ab37f15d0
 SHA512:
-  metadata.gz: 91db158259b243438e5af2fa26d257f30c4c5f755383e4bde6e20b71cf9e5481bc5b2d91cd5c63e5916ed8d6e373050e60dd16fd4b3a0231073702b75ad2702a
-  data.tar.gz: '0940f53a61a33f22de700c8609ede85e7d937f096688374eedef072758372f00e87fa6327050d323a7f5f3d869b487ff39bb942fe56534afe4a906b3b6cde494'
+  metadata.gz: 8bcb13d8cb5ee790ff698fc9bd0be4d2b366e1d16216db6a2f24e56c0dc1954c3b82349473b49cdee7c66ae732e3b684ee1d249d54dabe0f7d9cb0cf1f59873b
+  data.tar.gz: 866e043424ca831364baba5a842b5554cc1da2309e2935a0458edbead75c5e89f9cdf146506df12fc04c87d78c5613e3b2e812b13a816864af5861b1f815c788

data/.clackyrules

@@ -25,6 +25,7 @@ It provides chat functionality and autonomous AI agent capabilities with tool us
 - **IMPORTANT**: All code comments must be written in English
 - Add descriptive comments for complex logic
 - Use clear, self-documenting code with English naming
+- **IMPORTANT**: Always use inline `private` with method definitions (e.g., `private def method_name`). Do NOT use standalone `private` keyword
 
 ### Architecture Patterns
 - Tools inherit from `Clacky::Tools::Base`
@@ -41,6 +42,9 @@ It provides chat functionality and autonomous AI agent capabilities with tool us
 - Maintain good test coverage
 - When modifying existing functionality, ensure related tests still pass
 - When adding new features, consider adding corresponding tests
+- **IMPORTANT**: When developing new features, write RSpec tests as needed and ensure they pass
+- **DO NOT** write custom test scripts unless explicitly requested by the user
+- **DO NOT** create markdown documentation unless explicitly requested by the user
 
 ### Tool Development
 When adding new tools:

data/README.md

@@ -1,6 +1,6 @@
 # OpenClacky
 
-A command-line interface for interacting with AI models. OpenClacky supports OpenAI-compatible APIs, making it easy to chat with various AI models directly from your terminal.
+OpenClacky = Lovable + Supabase
 
 ## Features
 

data/lib/clacky/agent.rb

@@ -4,6 +4,7 @@ require "securerandom"
 require "json"
 require "tty-prompt"
 require "set"
+require "base64"
 require_relative "utils/arguments_parser"
 
 module Clacky
@@ -72,6 +73,7 @@ module Clacky
       @total_tasks = 0
       @cost_source = :estimated  # Track whether cost is from API or estimated
       @task_cost_source = :estimated  # Track cost source for current task
+      @previous_total_tokens = 0  # Track tokens from previous iteration for delta calculation
 
       # Register built-in tools
       register_builtin_tools
@@ -127,9 +129,10 @@ module Clacky
       @hooks.add(event, &block)
     end
 
-    def run(user_input, &block)
+    def run(user_input, images: [], &block)
       @start_time = Time.now
       @task_cost_source = :estimated  # Reset for new task
+      @previous_total_tokens = 0  # Reset token tracking for new task
 
       # Add system prompt as the first message if this is the first run
       if @messages.empty?
@@ -144,7 +147,9 @@ module Clacky
         @messages << system_message
       end
 
-      @messages << { role: "user", content: user_input }
+      # Format user message with images if provided
+      user_content = format_user_content(user_input, images)
+      @messages << { role: "user", content: user_content }
       @total_tasks += 1
 
       emit_event(:on_start, { input: user_input }, &block)
@@ -611,22 +616,25 @@ module Clacky
 
     def track_cost(usage)
       # Priority 1: Use API-provided cost if available (OpenRouter, LiteLLM, etc.)
+      iteration_cost = nil
       if usage[:api_cost]
         @total_cost += usage[:api_cost]
         @cost_source = :api
         @task_cost_source = :api
+        iteration_cost = usage[:api_cost]
         puts "[DEBUG] Using API-provided cost: $#{usage[:api_cost]}" if @config.verbose
       else
         # Priority 2: Calculate from tokens using ModelPricing
         result = ModelPricing.calculate_cost(model: @config.model, usage: usage)
         cost = result[:cost]
         pricing_source = result[:source]
-        
+
         @total_cost += cost
+        iteration_cost = cost
         # Map pricing source to cost source: :price or :default
         @cost_source = pricing_source
         @task_cost_source = pricing_source
-        
+
         if @config.verbose
           source_label = pricing_source == :price ? "model pricing" : "default pricing"
           puts "[DEBUG] Calculated cost for #{@config.model} using #{source_label}: $#{cost.round(6)}"
@@ -634,6 +642,9 @@ module Clacky
         end
       end
 
+      # Display token usage statistics for this iteration
+      display_iteration_tokens(usage, iteration_cost)
+
       # Track cache usage statistics
       @cache_stats[:total_requests] += 1
 
@@ -647,6 +658,66 @@ module Clacky
       end
     end
 
+    # Display token usage for current iteration
+    private def display_iteration_tokens(usage, cost)
+      prompt_tokens = usage[:prompt_tokens] || 0
+      completion_tokens = usage[:completion_tokens] || 0
+      total_tokens = usage[:total_tokens] || (prompt_tokens + completion_tokens)
+      cache_write = usage[:cache_creation_input_tokens] || 0
+      cache_read = usage[:cache_read_input_tokens] || 0
+
+      # Calculate token delta from previous iteration
+      delta_tokens = total_tokens - @previous_total_tokens
+      @previous_total_tokens = total_tokens  # Update for next iteration
+      
+      # Build token summary string
+      token_info = []
+
+      # Delta tokens with color coding at the beginning
+      require 'pastel'
+      pastel = Pastel.new
+      
+      delta_str = "+#{delta_tokens}"
+      colored_delta = if delta_tokens > 10000
+        pastel.red.bold(delta_str)  # Error level: red for > 10k
+      elsif delta_tokens > 5000
+        pastel.yellow.bold(delta_str)  # Warn level: yellow for > 5k
+      else
+        pastel.green(delta_str)  # Normal: green for <= 5k
+      end
+      
+      token_info << colored_delta
+
+      # Cache status indicator
+      cache_used = cache_read > 0 || cache_write > 0
+      if cache_used
+        cache_indicator = "✓ Cached"
+        token_info << pastel.cyan(cache_indicator)
+      end
+
+      # Input tokens (with cache breakdown if available)
+      if cache_write > 0 || cache_read > 0
+        input_detail = "#{prompt_tokens} (cache: #{cache_read} read, #{cache_write} write)"
+        token_info << "Input: #{input_detail}"
+      else
+        token_info << "Input: #{prompt_tokens}"
+      end
+
+      # Output tokens
+      token_info << "Output: #{completion_tokens}"
+
+      # Total
+      token_info << "Total: #{total_tokens}"
+
+      # Cost for this iteration
+      if cost
+        token_info << "Cost: $#{cost.round(6)}"
+      end
+
+      # Display with color
+      puts pastel.dim("    [Tokens] #{token_info.join(' | ')}")
+    end
+
     def compress_messages_if_needed
       # Check if compression is enabled
       return unless @config.enable_compression
@@ -1055,9 +1126,20 @@ module Clacky
     end
 
     def build_success_result(call, result)
+      # Try to get tool instance to use its format_result_for_llm method
+      tool = @tool_registry.get(call[:name]) rescue nil
+      
+      formatted_result = if tool && tool.respond_to?(:format_result_for_llm)
+        # Tool provides a custom LLM-friendly format
+        tool.format_result_for_llm(result)
+      else
+        # Fallback: use the original result
+        result
+      end
+      
       {
         id: call[:id],
-        content: JSON.generate(result)
+        content: JSON.generate(formatted_result)
       }
     end
 
@@ -1133,5 +1215,76 @@ module Clacky
       @tool_registry.register(Tools::TodoManager.new)
       @tool_registry.register(Tools::RunProject.new)
     end
+
+    # Format user content with optional images
+    # @param text [String] User's text input
+    # @param images [Array<String>] Array of image file paths
+    # @return [String|Array] String if no images, Array with text and image_url objects if images present
+    def format_user_content(text, images)
+      return text if images.nil? || images.empty?
+
+      content = []
+      content << { type: "text", text: text } unless text.nil? || text.empty?
+
+      images.each do |image_path|
+        image_url = image_path_to_data_url(image_path)
+        content << { type: "image_url", image_url: { url: image_url } }
+      end
+
+      content
+    end
+
+    # Convert image file path to base64 data URL
+    # @param path [String] File path to image
+    # @return [String] base64 data URL (e.g., "data:image/png;base64,...")
+    def image_path_to_data_url(path)
+      unless File.exist?(path)
+        raise ArgumentError, "Image file not found: #{path}"
+      end
+
+      # Read file as binary
+      image_data = File.binread(path)
+
+      # Detect MIME type from file extension or content
+      mime_type = detect_image_mime_type(path, image_data)
+
+      # Encode to base64
+      base64_data = Base64.strict_encode64(image_data)
+
+      "data:#{mime_type};base64,#{base64_data}"
+    end
+
+    # Detect image MIME type
+    # @param path [String] File path
+    # @param data [String] Binary image data
+    # @return [String] MIME type (e.g., "image/png")
+    def detect_image_mime_type(path, data)
+      # Try to detect from file extension first
+      ext = File.extname(path).downcase
+      case ext
+      when ".png"
+        "image/png"
+      when ".jpg", ".jpeg"
+        "image/jpeg"
+      when ".gif"
+        "image/gif"
+      when ".webp"
+        "image/webp"
+      else
+        # Try to detect from file signature (magic bytes)
+        if data.start_with?("\x89PNG".b)
+          "image/png"
+        elsif data.start_with?("\xFF\xD8\xFF".b)
+          "image/jpeg"
+        elsif data.start_with?("GIF87a".b) || data.start_with?("GIF89a".b)
+          "image/gif"
+        elsif data.start_with?("RIFF".b) && data[8..11] == "WEBP".b
+          "image/webp"
+        else
+          # Default to png if unknown
+          "image/png"
+        end
+      end
+    end
   end
 end

data/lib/clacky/cli.rb

@@ -107,7 +107,7 @@ module Clacky
 
       begin
         # Always run in interactive mode
-        run_agent_interactive(agent, working_dir, agent_config, message, session_manager)
+        run_agent_interactive(agent, working_dir, agent_config, message, session_manager, client)
       rescue StandardError => e
         # Save session on error
         if session_manager
@@ -331,7 +331,7 @@ module Clacky
         end
       end
 
-      def run_agent_interactive(agent, working_dir, agent_config, initial_message = nil, session_manager = nil)
+      def run_agent_interactive(agent, working_dir, agent_config, initial_message = nil, session_manager = nil, client = nil)
         # Store agent as instance variable for access in display methods
         @current_agent = agent
 
@@ -371,10 +371,13 @@ module Clacky
 
         # Process initial message if provided
         current_message = initial_message
+        current_images = []
 
         loop do
           # Get message from user if not provided
           unless current_message && !current_message.strip.empty?
+            # Only show newline separator if we've completed tasks
+            # (but not right after /clear since we just showed a message)
             say "\n" if total_tasks > 0
 
             # Show status bar before input
@@ -387,23 +390,86 @@ module Clacky
             )
 
             # Use enhanced prompt with "❯" prefix
-            result = prompt.read_input(prefix: "❯")
+            result = prompt.read_input(prefix: "❯") do |display_lines|
+              # Shift+Tab pressed - toggle mode and update status bar
+              if agent_config.permission_mode == :confirm_safes
+                agent_config.permission_mode = :auto_approve
+              else
+                agent_config.permission_mode = :confirm_safes
+              end
+
+              # Update status bar (it's above the input box)
+              # display_lines includes the final newline, so we need display_lines moves to reach status bar
+              print "\e[#{display_lines}A"  # Move up to status bar line
+              print "\r\e[2K"  # Clear the status bar line
+
+              # Redisplay status bar with new mode (puts adds newline, cursor moves to next line)
+              statusbar.display(
+                working_dir: working_dir,
+                mode: agent_config.permission_mode.to_s,
+                model: agent_config.model,
+                tasks: total_tasks,
+                cost: total_cost
+              )
+
+              # Move back down to original position (display_lines - 1 because puts moved us down 1)
+              print "\e[#{display_lines - 1}B"
+            end
             
-            # EnhancedPrompt returns { text: String, images: Array } or nil
-            # For now, we only use the text part
-            current_message = result.nil? ? nil : result[:text]
+            # EnhancedPrompt returns:
+            # - { text: String, images: Array } for normal input
+            # - { command: Symbol } for commands
+            # - nil on EOF
+            if result.nil?
+              current_message = nil
+              current_images = []
+              break
+            elsif result[:command]
+              # Handle commands
+              case result[:command]
+              when :clear
+                # Clear session by creating a new agent
+                agent = Clacky::Agent.new(client, agent_config, working_dir: working_dir)
+                @current_agent = agent
+                total_tasks = 0
+                total_cost = 0.0
+                ui_formatter.info("Session cleared. Starting fresh.")
+                current_message = nil
+                current_images = []
+                next
+              when :exit
+                current_message = nil
+                current_images = []
+                break
+              end
+            else
+              # Normal input with text and optional images
+              current_message = result[:text]
+              current_images = result[:images] || []
+            end
 
             break if current_message.nil? || %w[exit quit].include?(current_message&.downcase&.strip)
-            next if current_message.strip.empty?
+            next if current_message.strip.empty? && current_images.empty?
 
             # Display user's message after input
             ui_formatter.user_message(current_message)
+
+            # Display image info if images were pasted (without extra newline)
+            if current_images.any?
+              current_images.each_with_index do |img_path, idx|
+                filename = File.basename(img_path)
+                say "  📎 Image #{idx + 1}: #{filename}", :cyan
+              end
+              puts  # Add newline after all images
+            else
+              puts  # Add newline after user message if no images
+            end
           end
 
           total_tasks += 1
 
           begin
-            result = agent.run(current_message) do |event|
+            result = agent.run(current_message, images: current_images) do |event|
               display_agent_event(event)
             end
 
@@ -449,12 +515,14 @@ module Clacky
             say "\nOr you can continue with a new task or type 'exit' to quit.", :yellow
           end
 
-          # Clear current_message to prompt for next input
+          # Clear current_message and current_images to prompt for next input
           current_message = nil
+          current_images = []
         end
 
-        # Save final session state
-        if session_manager
+        # Save final session state only if there were actual tasks
+        # Don't save empty sessions where user just started and exited
+        if session_manager && total_tasks > 0
           session_manager.save(agent.to_session_data)
         end
 

data/lib/clacky/progress_indicator.rb

@@ -21,7 +21,7 @@ module Clacky
       # Start background thread to update elapsed time
       @update_thread = Thread.new do
         while @running
-          sleep 1
+          sleep 0.1
           update if @running
         end
       end

data/lib/clacky/tools/file_reader.rb

@@ -25,29 +25,37 @@ module Clacky
       }
 
       def execute(path:, max_lines: 1000)
-        unless File.exist?(path)
+        # Expand ~ to home directory
+        expanded_path = File.expand_path(path)
+        
+        unless File.exist?(expanded_path)
           return {
-            path: path,
+            path: expanded_path,
             content: nil,
-            error: "File not found: #{path}"
+            error: "File not found: #{expanded_path}"
           }
         end
 
-        unless File.file?(path)
+        # If path is a directory, list its first-level contents (similar to filetree)
+        if File.directory?(expanded_path)
+          return list_directory_contents(expanded_path)
+        end
+
+        unless File.file?(expanded_path)
           return {
-            path: path,
+            path: expanded_path,
             content: nil,
-            error: "Path is not a file: #{path}"
+            error: "Path is not a file: #{expanded_path}"
           }
         end
 
         begin
-          lines = File.readlines(path).first(max_lines)
+          lines = File.readlines(expanded_path).first(max_lines)
           content = lines.join
-          truncated = File.readlines(path).size > max_lines
+          truncated = File.readlines(expanded_path).size > max_lines
 
           {
-            path: path,
+            path: expanded_path,
             content: content,
             lines_read: lines.size,
             truncated: truncated,
@@ -55,7 +63,7 @@ module Clacky
           }
         rescue StandardError => e
           {
-            path: path,
+            path: expanded_path,
             content: nil,
             error: "Error reading file: #{e.message}"
           }
@@ -70,10 +78,65 @@ module Clacky
       def format_result(result)
         return result[:error] if result[:error]
 
+        # Handle directory listing
+        if result[:is_directory] || result['is_directory']
+          entries = result[:entries_count] || result['entries_count'] || 0
+          dirs = result[:directories_count] || result['directories_count'] || 0
+          files = result[:files_count] || result['files_count'] || 0
+          return "Listed #{entries} entries (#{dirs} directories, #{files} files)"
+        end
+
+        # Handle file reading
         lines = result[:lines_read] || result['lines_read'] || 0
         truncated = result[:truncated] || result['truncated']
         "Read #{lines} lines#{truncated ? ' (truncated)' : ''}"
       end
+
+      private
+
+      # List first-level directory contents (files and directories)
+      def list_directory_contents(path)
+        begin
+          entries = Dir.entries(path).reject { |entry| entry == "." || entry == ".." }
+          
+          # Separate files and directories
+          files = []
+          directories = []
+          
+          entries.each do |entry|
+            full_path = File.join(path, entry)
+            if File.directory?(full_path)
+              directories << entry + "/"
+            else
+              files << entry
+            end
+          end
+          
+          # Sort directories and files separately, then combine
+          directories.sort!
+          files.sort!
+          all_entries = directories + files
+          
+          # Format as a tree-like structure
+          content = all_entries.map { |entry| "  #{entry}" }.join("\n")
+          
+          {
+            path: path,
+            content: "Directory listing:\n#{content}",
+            entries_count: all_entries.size,
+            directories_count: directories.size,
+            files_count: files.size,
+            is_directory: true,
+            error: nil
+          }
+        rescue StandardError => e
+          {
+            path: path,
+            content: nil,
+            error: "Error reading directory: #{e.message}"
+          }
+        end
+      end
     end
   end
 end

data/lib/clacky/tools/grep.rb

@@ -256,6 +256,50 @@ module Clacky
         end
       end
 
+      # Format result for LLM consumption - return a compact version to save tokens
+      def format_result_for_llm(result)
+        # If there's an error, return it as-is
+        return result if result[:error]
+
+        # Build a compact summary with file list and sample matches
+        compact = {
+          summary: {
+            total_matches: result[:total_matches],
+            files_with_matches: result[:files_with_matches],
+            files_searched: result[:files_searched],
+            truncated: result[:truncated],
+            truncation_reason: result[:truncation_reason]
+          }
+        }
+
+        # Include list of files with match counts
+        if result[:results] && !result[:results].empty?
+          compact[:files] = result[:results].map do |file_result|
+            {
+              file: file_result[:file],
+              match_count: file_result[:matches].length
+            }
+          end
+
+          # Include sample matches (first 2 matches from first 3 files) for context
+          sample_results = result[:results].take(3)
+          compact[:sample_matches] = sample_results.map do |file_result|
+            {
+              file: file_result[:file],
+              matches: file_result[:matches].take(2).map do |match|
+                {
+                  line_number: match[:line_number],
+                  line: match[:line]
+                  # Omit context to save space - it's rarely needed by LLM
+                }
+              end
+            }
+          end
+        end
+
+        compact
+      end
+
       private
 
       # Find .gitignore file in the search path or parent directories

data/lib/clacky/ui/enhanced_prompt.rb

@@ -9,7 +9,7 @@ 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
@@ -20,6 +20,7 @@ module Clacky
 
       def initialize
         @pastel = Pastel.new
+        @formatter = Formatter.new
         @images = [] # Array of image file paths
         @paste_counter = 0 # Counter for paste operations
         @paste_placeholders = {} # Map of placeholder text to actual pasted content
@@ -29,8 +30,12 @@ module Clacky
 
       # Read user input with enhanced features
       # @param prefix [String] Prompt prefix (default: "❯")
-      # @return [Hash, nil] { text: String, images: Array } or nil on EOF
-      def read_input(prefix: "❯")
+      # @param block [Proc] Optional callback when Shift+Tab is pressed (receives display_lines)
+      # @return [Hash, nil] Returns:
+      #   - { text: String, images: Array } for normal input
+      #   - { command: Symbol } for commands (:clear, :exit)
+      #   - nil on EOF
+      def read_input(prefix: "❯", &block)
         @images = []
         lines = []
         cursor_pos = 0
@@ -47,18 +52,18 @@ module Clacky
           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")
-            
+            pasted_lines = pasted_text.split(/\r\n|\r|\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
@@ -91,8 +96,33 @@ module Clacky
             cursor_pos = 0
 
           when "\r" # Enter - submit
+            # Check if it's a command
+            input_text = lines.join("\n").strip
+
+            if input_text.start_with?('/')
+              clear_simple_prompt(lines.size)
+
+              # Parse command
+              case input_text
+              when '/clear'
+                @last_display_lines = 0  # Reset so CLI messages won't be cleared
+                return { command: :clear }
+              when '/exit', '/quit'
+                @last_display_lines = 0  # Reset before exit
+                return { command: :exit }
+              else
+                # Unknown command - show error and continue
+                @formatter.warning("Unknown command: #{input_text} (Available: /clear, /exit)")
+                @last_display_lines = 0  # Reset so next display won't clear these messages
+                lines = []
+                cursor_pos = 0
+                line_index = 0
+                next
+              end
+            end
+
             # Submit if not empty
-            unless lines.join.strip.empty? && @images.empty?
+            unless input_text.empty? && @images.empty?
               clear_simple_prompt(lines.size)
               # Replace placeholders with actual pasted content
               final_text = expand_placeholders(lines.join("\n"))
@@ -102,12 +132,12 @@ module Clacky
           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_simple_prompt(lines.size)
@@ -131,19 +161,51 @@ module Clacky
           when "\u0016" # Ctrl+V - Paste
             pasted = paste_from_clipboard
             if pasted[:type] == :image
-              # Save image and add to list
-              @images << pasted[:path]
+              # Save image and add to list (max 3 images)
+              if @images.size < 3
+                @images << pasted[:path]
+              else
+                # Show warning below input box (without extra newline)
+                @formatter.warning("Maximum 3 images allowed. Delete an image first (Ctrl+D).")
+
+                # Wait a moment for user to see the message
+                sleep(1.5)
+
+                # Clear the warning line
+                print "\r\e[2K"  # Clear current line
+
+                # Now clear the entire input box using the saved line count
+                if @last_display_lines && @last_display_lines > 0
+                  # Move up to the first line of input box
+                  (@last_display_lines - 1).times do
+                    print "\e[1A"
+                  end
+                  # Clear all lines
+                  @last_display_lines.times do |i|
+                    print "\r\e[2K"
+                    print "\e[1B" if i < @last_display_lines - 1
+                  end
+                  # Move back to the first line
+                  (@last_display_lines - 1).times do
+                    print "\e[1A"
+                  end
+                  print "\r"
+                end
+
+                # Reset display state so next display will redraw
+                @last_display_lines = 0
+              end
             else
               # Handle pasted text
               pasted_text = pasted[:text]
-              pasted_lines = pasted_text.split("\n")
-              
+              pasted_lines = pasted_text.split(/\r\n|\r|\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
@@ -196,12 +258,140 @@ module Clacky
           when "\e[D" # Left arrow
             cursor_pos = [cursor_pos - 1, 0].max
 
+          # Ignore Shift+Arrow keys (they produce sequences like \e[1;2A, \e[1;2B, etc.)
+          when /\e\[1;2[ABCD]/
+            # Do nothing - ignore Shift+Arrow keys
+
+          when "\e[Z" # Shift+Tab - Toggle auto-approve mode
+            # Call the block to update status bar if provided
+            if block
+              block.call(@last_display_lines)
+            end
+            # Continue the input loop, don't return
+
+          when "\u0001" # Ctrl+A - Move to beginning of line
+            cursor_pos = 0
+
+          when "\u0005" # Ctrl+E - Move to end of line
+            current_line = lines[line_index] || ""
+            cursor_pos = current_line.chars.length
+
+          when "\u0006" # Ctrl+F - Move forward one character
+            current_line = lines[line_index] || ""
+            cursor_pos = [cursor_pos + 1, current_line.chars.length].min
+
+          when "\u0002" # Ctrl+B - Move backward one character
+            cursor_pos = [cursor_pos - 1, 0].max
+
+          when "\u000B" # Ctrl+K - Delete from cursor to end of line
+            current_line = lines[line_index] || ""
+            chars = current_line.chars
+            lines[line_index] = chars[0...cursor_pos].join
+
+          when "\u0015" # Ctrl+U - Delete from beginning of line to cursor
+            current_line = lines[line_index] || ""
+            chars = current_line.chars
+            lines[line_index] = chars[cursor_pos..-1].join || ""
+            cursor_pos = 0
+
+          when "\u0017" # Ctrl+W - Delete previous word
+            current_line = lines[line_index] || ""
+            chars = current_line.chars
+
+            # Find the start of the previous word
+            pos = cursor_pos - 1
+
+            # Skip trailing whitespace
+            while pos >= 0 && chars[pos] =~ /\s/
+              pos -= 1
+            end
+
+            # Delete word characters
+            while pos >= 0 && chars[pos] =~ /\S/
+              pos -= 1
+            end
+
+            # Delete from pos+1 to cursor_pos
+            delete_start = pos + 1
+            chars.slice!(delete_start...cursor_pos)
+            lines[line_index] = chars.join
+            cursor_pos = delete_start
+
           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)
+              # If only one image, delete it directly
+              if @images.size == 1
+                @images.clear
+
+                # Clear the entire input box
+                if @last_display_lines && @last_display_lines > 0
+                  # Move up to the first line of input box
+                  (@last_display_lines - 1).times do
+                    print "\e[1A"
+                  end
+                  # Clear all lines
+                  @last_display_lines.times do |i|
+                    print "\r\e[2K"
+                    print "\e[1B" if i < @last_display_lines - 1
+                  end
+                  # Move back to the first line
+                  (@last_display_lines - 1).times do
+                    print "\e[1A"
+                  end
+                  print "\r"
+                end
+
+                # Reset so next display starts fresh
+                @last_display_lines = 0
+              else
+                # Multiple images - ask which one to delete
+                # Move cursor to after the input box to show prompt
+                print "\n"
+                print "Delete image (1-#{@images.size}): "
+                $stdout.flush
+
+                # Read single character without waiting for Enter
+                deleted = false
+                $stdin.raw do |io|
+                  char = io.getc
+                  num = char.to_i
+
+                  # Delete if valid number
+                  if num > 0 && num <= @images.size
+                    @images.delete_at(num - 1)
+                    print "#{num} ✓"
+                    deleted = true
+                  else
+                    print "✗"
+                  end
+                end
+
+                # Clear the prompt lines
+                print "\r\e[2K"  # Clear current line
+                print "\e[1A"    # Move up one line
+                print "\r\e[2K"  # Clear the prompt line
+
+                # Now clear the entire input box using the saved line count
+                if @last_display_lines && @last_display_lines > 0
+                  # We're now at the position where the input box ends
+                  # Move up to the first line of input box
+                  (@last_display_lines - 1).times do
+                    print "\e[1A"
+                  end
+                  # Clear all lines
+                  @last_display_lines.times do |i|
+                    print "\r\e[2K"
+                    print "\e[1B" if i < @last_display_lines - 1
+                  end
+                  # Move back to the first line
+                  (@last_display_lines - 1).times do
+                    print "\e[1A"
+                  end
+                  print "\r"
+                end
+
+                # Reset so next display starts fresh
+                @last_display_lines = 0
               end
             end
 
@@ -210,7 +400,7 @@ module Clacky
             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)
@@ -228,17 +418,11 @@ module Clacky
 
       # Display simplified prompt (just prefix and input, no box)
       def display_simple_prompt(lines, prefix, line_index, cursor_pos)
-        # Clear previous display if exists
-        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
+        # Hide terminal cursor (we render our own)
+        print "\e[?25l"
 
         lines_to_display = []
-        
+
         # Get terminal width for full-width separator
         term_width = TTY::Screen.width
 
@@ -250,14 +434,14 @@ module Clacky
           @images.each_with_index do |img_path, idx|
             filename = File.basename(img_path)
             filesize = File.exist?(img_path) ? format_filesize(File.size(img_path)) : "N/A"
-            lines_to_display << @pastel.dim("[Image #{idx + 1}] #{filename} (#{filesize})")
+            line = @pastel.dim("[Image #{idx + 1}] #{filename} (#{filesize}) (Ctrl+D to delete)")
+            lines_to_display << line
           end
-          lines_to_display << ""
         end
 
         # Display input lines
         display_lines = lines.empty? ? [""] : lines
-        
+
         display_lines.each_with_index do |line, idx|
           if idx == 0
             # First line with prefix
@@ -267,7 +451,7 @@ module Clacky
               before_cursor = chars[0...cursor_pos].join
               cursor_char = chars[cursor_pos] || " "
               after_cursor = chars[(cursor_pos + 1)..-1]&.join || ""
-              
+
               line_display = "#{prefix} #{before_cursor}#{@pastel.on_white(@pastel.black(cursor_char))}#{after_cursor}"
               lines_to_display << line_display
             else
@@ -282,7 +466,7 @@ module Clacky
               before_cursor = chars[0...cursor_pos].join
               cursor_char = chars[cursor_pos] || " "
               after_cursor = chars[(cursor_pos + 1)..-1]&.join || ""
-              
+
               line_display = "#{indent}#{before_cursor}#{@pastel.on_white(@pastel.black(cursor_char))}#{after_cursor}"
               lines_to_display << line_display
             else
@@ -290,27 +474,72 @@ module Clacky
             end
           end
         end
-        
+
         # Bottom separator line (full width)
         lines_to_display << @pastel.dim("─" * term_width)
 
-        # Output all lines
-        print lines_to_display.join("\n")
-        print "\n"
-        
-        # Remember how many lines we displayed
-        @last_display_lines = lines_to_display.size
+        # Different rendering strategy for first display vs updates
+        if @last_display_lines && @last_display_lines > 0
+          # Update mode: move to start and overwrite (no flicker)
+          # Move up to the first line (N-1 times since we're on line N)
+          (@last_display_lines - 1).times do
+            print "\e[1A"  # Move up one line
+          end
+          print "\r"  # Move to beginning of line
+
+          # Output lines by overwriting
+          lines_to_display.each_with_index do |line, idx|
+            print "\r\e[K"  # Clear current line from cursor to end
+            print line
+            print "\n" if idx < lines_to_display.size - 1  # Newline except last line
+          end
+
+          # If new display has fewer lines than old, clear the extra lines
+          if lines_to_display.size < @last_display_lines - 1
+            extra_lines = @last_display_lines - 1 - lines_to_display.size
+            extra_lines.times do
+              print "\n\r\e[K"  # Move down and clear line
+            end
+            # Move back up to the last line of new display
+            extra_lines.times do
+              print "\e[1A"
+            end
+          end
+
+          print "\n"  # Move cursor to next line
+        else
+          # First display: use simple newline approach
+          print lines_to_display.join("\n")
+          print "\n"
+        end
+
+        # Flush output to ensure it's displayed immediately
+        $stdout.flush
+
+        # Remember how many lines we displayed (including the newline)
+        @last_display_lines = lines_to_display.size + 1
       end
 
       # Clear simple prompt display
       def clear_simple_prompt(num_lines)
         if @last_display_lines && @last_display_lines > 0
-          @last_display_lines.times do
+          # Move up to the first line (N-1 times since we're on line N)
+          (@last_display_lines - 1).times do
             print "\e[1A"  # Move up one line
-            print "\e[2K"  # Clear entire line
+          end
+          # Now we're on the first line, clear all N lines
+          @last_display_lines.times do |i|
+            print "\r\e[2K"  # Move to beginning and clear entire line
+            print "\e[1B" if i < @last_display_lines - 1  # Move down (except last line)
+          end
+          # Move back to the first line
+          (@last_display_lines - 1).times do
+            print "\e[1A"
           end
           print "\r"  # Move to beginning of line
         end
+        # Show terminal cursor again
+        print "\e[?25h"
       end
 
       # Expand placeholders to actual pasted content
@@ -327,74 +556,91 @@ module Clacky
       # 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
+            # Read the next character to determine sequence type
             begin
-              extra = io.read_nonblock(2)
-              extra = extra.force_encoding('UTF-8') if extra.encoding != Encoding::UTF_8
-              c = c + extra
+              next_char = io.read_nonblock(1)
+              next_char = next_char.force_encoding('UTF-8') if next_char.encoding != Encoding::UTF_8
+              c = c + next_char
+
+              # If it's a CSI sequence (starts with [)
+              if next_char == "["
+                # Read until we get a letter (the final character of CSI sequence)
+                # This handles both simple sequences like \e[A and complex ones like \e[1;2D
+                loop do
+                  if IO.select([io], nil, nil, 0.01)  # 10ms timeout
+                    char = io.read_nonblock(1)
+                    char = char.force_encoding('UTF-8') if char.encoding != Encoding::UTF_8
+                    c = c + char
+                    # Break if we got a letter (final character of CSI sequence)
+                    break if char =~ /[A-Za-z~]/
+                  else
+                    break
+                  end
+                end
+              end
             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
@@ -419,17 +665,17 @@ module Clacky
       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»
@@ -437,9 +683,9 @@ module Clacky
             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
@@ -459,13 +705,13 @@ module Clacky
       # 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")
@@ -474,7 +720,7 @@ module Clacky
               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')
@@ -498,7 +744,7 @@ module Clacky
         # 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()
@@ -509,9 +755,9 @@ module Clacky
             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

data/lib/clacky/ui/formatter.rb

@@ -32,7 +32,7 @@ module Clacky
       def user_message(content)
         symbol = @pastel.bright_blue(SYMBOLS[:user])
         text = @pastel.blue(content)
-        puts "\n#{symbol} #{text}"
+        print "\n#{symbol} #{text}"
       end
 
       # Format assistant message

data/lib/clacky/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openclacky
 version: !ruby/object:Gem::Version
-  version: 0.5.5
+  version: 0.5.6
 platform: ruby
 authors:
 - windy