openclacky 0.6.1 → 0.6.2

data/lib/clacky/tools/file_reader.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "base"
+require_relative "../utils/file_processor"
 
 module Clacky
   module Tools
@@ -23,6 +24,8 @@ module Clacky
         },
         required: ["path"]
       }
+      
+
 
       def execute(path:, max_lines: 1000)
         # Expand ~ to home directory
@@ -50,6 +53,12 @@ module Clacky
         end
 
         begin
+          # Check if file is binary
+          if binary_file?(expanded_path)
+            return handle_binary_file(expanded_path)
+          end
+          
+          # Read text file
           lines = File.readlines(expanded_path).first(max_lines)
           content = lines.join
           truncated = File.readlines(expanded_path).size > max_lines
@@ -86,16 +95,140 @@ module Clacky
           return "Listed #{entries} entries (#{dirs} directories, #{files} files)"
         end
 
-        # Handle file reading
+        # Handle binary file
+        if result[:binary] || result['binary']
+          format_type = result[:format] || result['format'] || 'unknown'
+          size = result[:size_bytes] || result['size_bytes'] || 0
+          
+          # Check if it has base64 data (LLM-compatible format)
+          if result[:base64_data] || result['base64_data']
+            size_warning = size > 5_000_000 ? " (WARNING: large file)" : ""
+            return "Binary file (#{format_type}, #{format_file_size(size)}) - sent to LLM#{size_warning}"
+          else
+            return "Binary file (#{format_type}, #{format_file_size(size)}) - cannot be read as text"
+          end
+        end
+
+        # Handle text file reading
         lines = result[:lines_read] || result['lines_read'] || 0
         truncated = result[:truncated] || result['truncated']
         "Read #{lines} lines#{truncated ? ' (truncated)' : ''}"
       end
+      
+      # Format result for LLM - handles both text and binary (image/PDF) content
+      # This method is called by the agent to format tool results before sending to LLM
+      def format_result_for_llm(result)
+        # For LLM-compatible binary files with base64 data, return as content blocks
+        if result[:binary] && result[:base64_data]
+          # Create a text description
+          description = "File: #{result[:path]}\nType: #{result[:format]}\nSize: #{format_file_size(result[:size_bytes])}"
+          
+          # Add size warning for large files
+          if result[:size_bytes] > 5_000_000
+            description += "\nWARNING: Large file (>5MB) - may consume significant tokens"
+          end
+          
+          # For images, return both description and image content
+          if result[:mime_type]&.start_with?("image/")
+            return {
+              type: "image",
+              path: result[:path],
+              format: result[:format],
+              size_bytes: result[:size_bytes],
+              mime_type: result[:mime_type],
+              base64_data: result[:base64_data],
+              description: description
+            }
+          end
+          
+          # For PDFs and other binary formats, just return metadata with base64
+          return {
+            type: "document",
+            path: result[:path],
+            format: result[:format],
+            size_bytes: result[:size_bytes],
+            mime_type: result[:mime_type],
+            base64_data: result[:base64_data],
+            description: description
+          }
+        end
+        
+        # For other cases, return the result as-is (agent will JSON.generate it)
+        result
+      end
+
+      private def binary_file?(path)
+        # Use FileProcessor to detect binary files
+        File.open(path, 'rb') do |file|
+          sample = file.read(8192) || ""
+          Utils::FileProcessor.binary_file?(sample)
+        end
+      rescue StandardError
+        # If we can't read the file, assume it's not binary
+        false
+      end
+      
+      private def handle_binary_file(path)
+        # Check if it's a supported format using FileProcessor
+        if Utils::FileProcessor.supported_binary_file?(path)
+          # Use FileProcessor to convert to base64
+          begin
+            result = Utils::FileProcessor.file_to_base64(path)
+            {
+              path: path,
+              binary: true,
+              format: result[:format],
+              mime_type: result[:mime_type],
+              size_bytes: result[:size_bytes],
+              base64_data: result[:base64_data],
+              error: nil
+            }
+          rescue ArgumentError => e
+            # File too large or other error
+            file_size = File.size(path)
+            ext = File.extname(path).downcase
+            {
+              path: path,
+              binary: true,
+              format: ext.empty? ? "unknown" : ext[1..-1],
+              size_bytes: file_size,
+              content: nil,
+              error: e.message
+            }
+          end
+        else
+          # Binary file that we can't send to LLM
+          file_size = File.size(path)
+          ext = File.extname(path).downcase
+          {
+            path: path,
+            binary: true,
+            format: ext.empty? ? "unknown" : ext[1..-1],
+            size_bytes: file_size,
+            content: nil,
+            error: "Binary file detected. This format cannot be read as text. File size: #{format_file_size(file_size)}"
+          }
+        end
+      end
+      
+      private def detect_mime_type(path, data)
+        Utils::FileProcessor.detect_mime_type(path, data)
+      end
+      
+      private def format_file_size(bytes)
+        if bytes < 1024
+          "#{bytes} bytes"
+        elsif bytes < 1024 * 1024
+          "#{(bytes / 1024.0).round(2)} KB"
+        else
+          "#{(bytes / (1024.0 * 1024)).round(2)} MB"
+        end
+      end
 
       private
 
       # List first-level directory contents (files and directories)
-      def list_directory_contents(path)
+      private def list_directory_contents(path)
         begin
           entries = Dir.entries(path).reject { |entry| entry == "." || entry == ".." }
           

data/lib/clacky/tools/safe_shell.rb

@@ -190,6 +190,24 @@ module Clacky
         end
       end
 
+      # Override format_result_for_llm to preserve security fields
+      def format_result_for_llm(result)
+        # If security blocked, return as-is (small and important)
+        return result if result[:security_blocked]
+        
+        # Call parent's format_result_for_llm to truncate output
+        compact = super(result)
+        
+        # Add security enhancement fields if present (they're small and important for LLM to understand)
+        if result[:security_enhanced]
+          compact[:security_enhanced] = true
+          compact[:original_command] = result[:original_command]
+          compact[:safe_command] = result[:safe_command]
+        end
+        
+        compact
+      end
+
       private def format_non_zero_exit(exit_code, stdout, stderr)
         stdout_lines = stdout.lines.size
         has_output = stdout_lines > 0
@@ -331,7 +349,12 @@ module Clacky
 
       def replace_chmod_command(command)
         # Parse chmod command to ensure it's safe
-        parts = Shellwords.split(command)
+        begin
+          parts = Shellwords.split(command)
+        rescue Shellwords::BadQuotedString => e
+          # If Shellwords.split fails, use simple split as fallback
+          parts = command.split(/\s+/)
+        end
 
         # Only allow chmod +x on files in project directory
         files = parts[2..-1] || []
@@ -340,8 +363,6 @@ module Clacky
         # Allow chmod +x as it's generally safe
         log_replacement("chmod", command, "chmod +x is allowed - file permissions will be modified")
         command
-      rescue Shellwords::BadQuotedString
-        raise SecurityError, "Invalid chmod command syntax: #{command}"
       end
 
       def replace_curl_pipe_command(command)
@@ -370,7 +391,14 @@ module Clacky
 
       def validate_and_allow(command)
         # Check basic file operation commands
-        parts = Shellwords.split(command)
+        begin
+          parts = Shellwords.split(command)
+        rescue Shellwords::BadQuotedString => e
+          # If Shellwords.split fails due to quote issues, try simple split as fallback
+          # This handles cases where paths don't actually need shell escaping
+          parts = command.split(/\s+/)
+        end
+        
         cmd = parts.first
         args = parts[1..-1]
 
@@ -384,8 +412,6 @@ module Clacky
         end
 
         command
-      rescue Shellwords::BadQuotedString
-        raise SecurityError, "Invalid command syntax: #{command}"
       end
 
       def validate_general_command(command)
@@ -419,11 +445,15 @@ module Clacky
       end
 
       def parse_rm_files(command)
-        parts = Shellwords.split(command)
+        begin
+          parts = Shellwords.split(command)
+        rescue Shellwords::BadQuotedString => e
+          # If Shellwords.split fails, use simple split as fallback
+          parts = command.split(/\s+/)
+        end
+        
         # Skip rm command itself and option parameters
         parts.drop(1).reject { |part| part.start_with?('-') }
-      rescue Shellwords::BadQuotedString
-        raise SecurityError, "Invalid command syntax: #{command}"
       end
 
       def validate_file_path(path)

data/lib/clacky/tools/shell.rb

@@ -290,6 +290,73 @@ module Clacky
           "[Exit #{exit_code}] #{error_msg[0..50]}"
         end
       end
+
+      # Format result for LLM consumption - limit output size to save tokens
+      # Maximum characters to include in LLM output
+      MAX_LLM_OUTPUT_CHARS = 2000
+      
+      def format_result_for_llm(result)
+        # Return error info as-is if command failed or timed out
+        return result if result[:error] || result[:state] == 'TIMEOUT' || result[:state] == 'WAITING_INPUT'
+        
+        stdout = result[:stdout] || ""
+        stderr = result[:stderr] || ""
+        exit_code = result[:exit_code] || 0
+        
+        # Build compact result with truncated output
+        compact = {
+          command: result[:command],
+          exit_code: exit_code,
+          success: result[:success]
+        }
+        
+        # Add elapsed time if available
+        compact[:elapsed] = result[:elapsed] if result[:elapsed]
+        
+        # Truncate stdout to save tokens
+        if stdout.empty?
+          compact[:stdout] = ""
+        else
+          stdout_lines = stdout.lines
+          stdout_line_count = stdout_lines.length
+          
+          if stdout.length <= MAX_LLM_OUTPUT_CHARS
+            compact[:stdout] = stdout
+          else
+            # Take first N lines that fit within the character limit
+            accumulated_chars = 0
+            lines_to_include = []
+            
+            stdout_lines.each do |line|
+              break if accumulated_chars + line.length > MAX_LLM_OUTPUT_CHARS
+              lines_to_include << line
+              accumulated_chars += line.length
+            end
+            
+            compact[:stdout] = lines_to_include.join
+            compact[:stdout] += "\n\n... [Output truncated for LLM: showing #{lines_to_include.length} of #{stdout_line_count} lines, #{accumulated_chars} of #{stdout.length} chars] ...\n"
+          end
+        end
+        
+        # Truncate stderr to save tokens (usually more important than stdout, so keep more)
+        if stderr.empty?
+          compact[:stderr] = ""
+        else
+          stderr_line_count = stderr.lines.length
+          
+          if stderr.length <= MAX_LLM_OUTPUT_CHARS
+            compact[:stderr] = stderr
+          else
+            compact[:stderr] = stderr[0...MAX_LLM_OUTPUT_CHARS]
+            compact[:stderr] += "\n\n... [Error output truncated for LLM: showing #{MAX_LLM_OUTPUT_CHARS} of #{stderr.length} chars, #{stderr_line_count} lines] ...\n"
+          end
+        end
+        
+        # Add output_truncated flag
+        compact[:output_truncated] = result[:output_truncated] if result[:output_truncated]
+        
+        compact
+      end
     end
   end
 end

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

@@ -84,8 +84,15 @@ module Clacky
           # When paused (InlineInput active), don't take up any space
           return 0 if @paused
 
-          height = 1  # Session bar (top)
-          height += 1  # Separator after session bar
+          height = 0
+          
+          # Session bar - calculate actual wrapped height
+          height += calculate_sessionbar_height
+          
+          # Separator after session bar
+          height += 1
+          
+          # Images
           height += @images.size
           
           # Calculate height considering wrapped lines
@@ -101,9 +108,13 @@ module Clacky
             height += wrapped_segments.size
           end
           
-          height += 1  # Bottom separator
+          # Bottom separator
+          height += 1
+          
+          # Tips and user tips
           height += 1 if @tips_message
           height += 1 if @user_tip
+          
           height
         end
 
@@ -202,49 +213,7 @@ module Clacky
           end
 
           # Input lines with auto-wrap support
-          @lines.each_with_index do |line, idx|
-            prefix = if idx == 0
-              prompt_text = theme.format_symbol(:user) + " "
-              prompt_text
-            else
-              " " * prompt.length
-            end
-
-            # Calculate available width for text (excluding prefix)
-            prefix_width = calculate_display_width(strip_ansi_codes(prefix))
-            available_width = @width - prefix_width
-
-            # Wrap line if needed
-            wrapped_segments = wrap_line(line, available_width)
-
-            wrapped_segments.each_with_index do |segment_info, wrap_idx|
-              move_cursor(current_row, 0)
-
-              segment_text = segment_info[:text]
-              segment_start = segment_info[:start]
-              segment_end = segment_info[:end]
-
-              content = if wrap_idx == 0
-                # First wrapped line includes prefix
-                if idx == @line_index
-                  "#{prefix}#{render_line_segment_with_cursor(line, segment_start, segment_end)}"
-                else
-                  "#{prefix}#{theme.format_text(segment_text, :user)}"
-                end
-              else
-                # Continuation lines have indent matching prefix width
-                continuation_indent = " " * prefix_width
-                if idx == @line_index
-                  "#{continuation_indent}#{render_line_segment_with_cursor(line, segment_start, segment_end)}"
-                else
-                  "#{continuation_indent}#{theme.format_text(segment_text, :user)}"
-                end
-              end
-              
-              print_with_padding(content)
-              current_row += 1
-            end
-          end
+          current_row = render_input_lines(current_row)
 
           # Bottom separator
           render_separator(current_row)
@@ -561,6 +530,73 @@ module Clacky
 
         private
 
+        # Render all input lines with auto-wrap support
+        # @param start_row [Integer] Starting row position
+        # @return [Integer] Next available row after rendering all lines
+        def render_input_lines(start_row)
+          current_row = start_row
+          
+          @lines.each_with_index do |line, line_idx|
+            prefix = calculate_line_prefix(line_idx)
+            prefix_width = calculate_display_width(strip_ansi_codes(prefix))
+            available_width = @width - prefix_width
+            wrapped_segments = wrap_line(line, available_width)
+
+            wrapped_segments.each_with_index do |segment_info, wrap_idx|
+              content = render_line_segment(line, line_idx, segment_info, wrap_idx, prefix, prefix_width)
+              move_cursor(current_row, 0)
+              print_with_padding(content)
+              current_row += 1
+            end
+          end
+          
+          current_row
+        end
+
+        # Calculate the prefix (prompt or indent) for a given line index
+        # @param line_idx [Integer] Index of the line
+        # @return [String] Prefix string (with formatting)
+        private def calculate_line_prefix(line_idx)
+          if line_idx == 0
+            theme.format_symbol(:user) + " "
+          else
+            " " * prompt.length
+          end
+        end
+
+        # Render a single segment of a line (handling cursor and wrapping)
+        # @param line [String] Full line text
+        # @param line_idx [Integer] Index of the line in @lines
+        # @param segment_info [Hash] Segment information from wrap_line
+        # @param wrap_idx [Integer] Index of this segment in wrapped segments
+        # @param prefix [String] Line prefix (prompt or indent)
+        # @param prefix_width [Integer] Display width of the prefix
+        # @return [String] Formatted content for this segment
+        private def render_line_segment(line, line_idx, segment_info, wrap_idx, prefix, prefix_width)
+          segment_text = segment_info[:text]
+          segment_start = segment_info[:start]
+          segment_end = segment_info[:end]
+          
+          is_current_line = (line_idx == @line_index)
+          is_first_segment = (wrap_idx == 0)
+          
+          # Determine the line prefix
+          line_prefix = if is_first_segment
+            prefix
+          else
+            " " * prefix_width  # Continuation indent
+          end
+          
+          # Render the segment content (with or without cursor)
+          segment_content = if is_current_line
+            render_line_segment_with_cursor(line, segment_start, segment_end)
+          else
+            theme.format_text(segment_text, :user)
+          end
+          
+          "#{line_prefix}#{segment_content}"
+        end
+
         # Wrap a line into multiple segments based on available width
         # Considers display width of characters (multi-byte characters like Chinese)
         # @param line [String] The line to wrap
@@ -646,12 +682,29 @@ module Clacky
           visible_content = content.gsub(/\e\[[0-9;]*m/, '')
           visible_width = calculate_display_width(visible_content)
           
-          # Print content
-          print content
-          
-          # Pad with spaces if needed to clear old content
-          remaining = @width - visible_width
-          print " " * remaining if remaining > 0
+          # IMPORTANT: If content exceeds screen width, truncate to prevent terminal auto-wrap
+          if visible_width > @width
+            # Content too long - truncate to fit (loses ANSI colors but prevents wrapping)
+            truncate_at = 0
+            current_width = 0
+            visible_content.each_char.with_index do |char, idx|
+              char_width = char_display_width(char)
+              break if current_width + char_width + 3 > @width  # Reserve 3 for "..."
+              current_width += char_width
+              truncate_at = idx + 1
+            end
+            print visible_content[0...truncate_at]
+            print "..."
+            # Pad remaining
+            remaining = @width - current_width - 3
+            print " " * remaining if remaining > 0
+          else
+            # Content fits - print normally
+            print content
+            # Pad with spaces if needed to clear old content
+            remaining = @width - visible_width
+            print " " * remaining if remaining > 0
+          end
         end
 
         def handle_enter
@@ -948,22 +1001,46 @@ module Clacky
           end
         end
 
+        # Render a separator line (ensures it doesn't exceed screen width)
+        # @param row [Integer] Row position to render
         def render_separator(row)
           move_cursor(row, 0)
-          content = @pastel.dim("─" * @width)
-          print_with_padding(content)
+          # Ensure separator doesn't exceed screen width to prevent wrapping
+          separator_width = [@width, 1].max
+          content = @pastel.dim("─" * separator_width)
+          print content
+          # Clear any remaining space
+          remaining = @width - separator_width
+          print " " * remaining if remaining > 0
         end
 
+        # Render session bar with wrapping support
+        # @param row [Integer] Starting row position
+        # @return [Integer] Number of rows actually used
         def render_sessionbar(row)
           move_cursor(row, 0)
 
           # If no sessionbar info, just render a separator
           unless @sessionbar_info[:working_dir]
-            content = @pastel.dim("─" * @width)
-            print_with_padding(content)
-            return
+            separator_width = [@width, 1].max
+            content = @pastel.dim("─" * separator_width)
+            print content
+            remaining = @width - separator_width
+            print " " * remaining if remaining > 0
+            return 1
           end
 
+          session_line = build_sessionbar_content
+          
+          # IMPORTANT: Always use print_with_padding which handles truncation
+          # to prevent terminal auto-wrap
+          print_with_padding(session_line)
+          1
+        end
+        
+        # Build the session bar content string
+        # @return [String] Formatted session bar content
+        private def build_sessionbar_content
           parts = []
           separator = @pastel.dim(" │ ")
 
@@ -998,8 +1075,47 @@ module Clacky
           cost_display = format("$%.1f", @sessionbar_info[:cost])
           parts << @pastel.dim(@pastel.white(cost_display))
 
-          session_line = " " + parts.join(separator)
-          print_with_padding(session_line)
+          " " + parts.join(separator)
+        end
+        
+        # Truncate session bar content to fit within max length
+        # @param content [String] Full session bar content with ANSI codes
+        # @param max_length [Integer] Maximum visible length
+        # @return [String] Truncated content
+        private def truncate_sessionbar_content(content, max_length)
+          # Strip ANSI codes to calculate visible length
+          visible_content = strip_ansi_codes(content)
+          visible_width = calculate_display_width(visible_content)
+          
+          return content if visible_width <= max_length
+          
+          # Truncate from the end with "..." indicator
+          chars = visible_content.chars
+          current_width = 0
+          truncate_at = 0
+          
+          chars.each_with_index do |char, idx|
+            char_width = char_display_width(char)
+            if current_width + char_width + 3 > max_length  # Reserve 3 for "..."
+              truncate_at = idx
+              break
+            end
+            current_width += char_width
+            truncate_at = idx + 1
+          end
+          
+          # For simplicity with ANSI codes, just show first part + ...
+          # This is a simplified version - proper implementation would preserve ANSI codes
+          visible_content[0...truncate_at] + "..."
+        end
+        
+        # Calculate how many rows the session bar will occupy
+        # @return [Integer] Number of rows needed
+        private def calculate_sessionbar_height
+          return 1 unless @sessionbar_info[:working_dir]
+          
+          # Session bar always renders on one line (we truncate if needed)
+          1
         end
 
         def shorten_path(path)