openclacky 0.6.1 → 0.6.2

data/lib/clacky/ui2/layout_manager.rb

@@ -6,11 +6,10 @@ module Clacky
   module UI2
     # LayoutManager manages screen layout with split areas (output area on top, input area on bottom)
     class LayoutManager
-      attr_reader :screen, :output_area, :input_area, :todo_area
+      attr_reader :screen, :input_area, :todo_area
 
-      def initialize(output_area:, input_area:, todo_area: nil)
+      def initialize(input_area:, todo_area: nil)
         @screen = ScreenBuffer.new
-        @output_area = output_area
         @input_area = input_area
         @todo_area = todo_area
         @render_mutex = Mutex.new
@@ -35,7 +34,6 @@ module Clacky
         @input_row = @todo_row + todo_height
 
         # Update component dimensions
-        @output_area.height = @output_height
         @input_area.row = @input_row
       end
 
@@ -93,10 +91,13 @@ module Clacky
       def position_inline_input_cursor(inline_input)
         return unless inline_input
 
-        # InlineInput renders its own visual cursor via render_line_with_cursor
-        # (white background on cursor character), so we don't need terminal cursor.
-        # Just hide the terminal cursor to avoid showing two cursors.
-        screen.hide_cursor
+        # Calculate the actual terminal cursor position considering multi-byte characters
+        # InlineInput is on the last output line (@output_row - 1)
+        cursor_row = @output_row - 1
+        cursor_col = inline_input.cursor_col  # This already considers display width
+        
+        # Move terminal cursor to the correct position
+        screen.move_cursor(cursor_row, cursor_col)
         screen.flush
       end
 
@@ -159,14 +160,16 @@ module Clacky
       # Clear output area (for /clear command)
       def clear_output
         @render_mutex.synchronize do
-          # Clear all lines in output area (from 0 to fixed_area_start - 1)
-          max_output_row = fixed_area_start_row
-          (0...max_output_row).each do |row|
+          # Clear all lines in output area (from 0 to where fixed area starts)
+          max_row = fixed_area_start_row
+          (0...max_row).each do |row|
             screen.move_cursor(row, 0)
             screen.clear_line
           end
-          # Reset output row position to start
+          
+          # Reset output position to beginning
           @output_row = 0
+          
           # Re-render fixed areas to ensure they stay in place
           render_fixed_areas
           screen.flush
@@ -174,46 +177,24 @@ module Clacky
       end
 
       # Append content to output area
-      # Track current row, scroll when reaching fixed area
-      # @param content [String] Content to append
+      # This is the main output method - handles scrolling and fixed area preservation
+      # @param content [String] Content to append (can be multi-line)
       def append_output(content)
         return if content.nil?
 
         @render_mutex.synchronize do
-          max_output_row = fixed_area_start_row - 1
-
-          # Special handling for empty string - just add a blank line
-          if content.empty?
-            print "\n"
-            @output_row += 1
-            render_fixed_areas
-            screen.flush
-            return
-          end
-
-          content.split("\n").each do |line|
+          lines = content.split("\n", -1)  # -1 to keep trailing empty strings
+          
+          lines.each_with_index do |line, index|
             # Wrap long lines to prevent display issues
             wrapped_lines = wrap_long_line(line)
             
             wrapped_lines.each do |wrapped_line|
-              # If at max row, need to scroll before outputting
-              if @output_row > max_output_row
-                # Move to bottom of screen and print newline to trigger scroll
-                screen.move_cursor(screen.height - 1, 0)
-                print "\n"
-                # Stay at max_output_row for next output
-                @output_row = max_output_row
-              end
-
-              # Output line at current position
-              screen.move_cursor(@output_row, 0)
-              screen.clear_line
-              output_area.append(wrapped_line)
-              @output_row += 1
+              write_output_line(wrapped_line)
             end
           end
 
-          # Re-render fixed areas at screen bottom
+          # Re-render fixed areas to ensure they stay at bottom
           render_fixed_areas
           screen.flush
         end
@@ -223,40 +204,52 @@ module Clacky
       # @param content [String] Content to update
       def update_last_line(content)
         @render_mutex.synchronize do
-          # Last output line is at @output_row - 1
-          last_row = [@output_row - 1, 0].max
+          return if @output_row == 0  # No output yet
+          
+          # Last written line is at @output_row - 1
+          last_row = @output_row - 1
           screen.move_cursor(last_row, 0)
           screen.clear_line
-          output_area.append(content)
-          render_fixed_areas
+          print content
+          
+          # Hide terminal cursor to avoid showing two cursors
+          # InlineInput uses visual cursor (white background) which is better for multi-byte chars
+          screen.hide_cursor
           screen.flush
+          
+          # Don't re-render fixed areas - we're just updating existing content
         end
       end
 
       # Remove the last line from output area
       def remove_last_line
         @render_mutex.synchronize do
-          last_row = [@output_row - 1, 0].max
+          return if @output_row == 0  # No output to remove
+          
+          # Clear the last written line
+          last_row = @output_row - 1
           screen.move_cursor(last_row, 0)
           screen.clear_line
-          @output_row = last_row if @output_row > 0
+          
+          # Move output row back
+          @output_row = last_row
+          
+          # Re-render fixed areas to ensure consistency
           render_fixed_areas
           screen.flush
         end
       end
 
-      # Scroll output area up
+      # Scroll output area up (legacy no-op)
       # @param lines [Integer] Number of lines to scroll
       def scroll_output_up(lines = 1)
-        output_area.scroll_up(lines)
-        render_output
+        # No-op - terminal handles scrolling natively
       end
 
-      # Scroll output area down
+      # Scroll output area down (legacy no-op)
       # @param lines [Integer] Number of lines to scroll
       def scroll_output_down(lines = 1)
-        output_area.scroll_down(lines)
-        render_output
+        # No-op - terminal handles scrolling natively
       end
 
       # Handle window resize
@@ -266,12 +259,14 @@ module Clacky
         screen.update_dimensions
         calculate_layout
 
-        # Adjust output_row if it exceeds new max
-        max_row = fixed_area_start_row - 1
-        @output_row = [@output_row, max_row].min
+        # Adjust @output_row if it exceeds new layout
+        # After resize, @output_row should not exceed fixed_area_start_row
+        max_allowed = fixed_area_start_row
+        @output_row = [@output_row, max_allowed].min
 
-        # Clear old fixed area lines
-        ([old_gap_row, 0].max...screen.height).each do |row|
+        # Clear old fixed area and some lines above (terminal may have wrapped content)
+        clear_start = [old_gap_row - 5, 0].max
+        (clear_start...screen.height).each do |row|
           screen.move_cursor(row, 0)
           screen.clear_line
         end
@@ -282,6 +277,35 @@ module Clacky
 
       private
 
+      # Write a single line to output area
+      # Handles scrolling when reaching fixed area
+      # @param line [String] Single line to write (should not contain newlines)
+      def write_output_line(line)
+        # Calculate where fixed area starts (this is where output area ends)
+        max_output_row = fixed_area_start_row
+        
+        # If we're about to write into the fixed area, scroll first
+        if @output_row >= max_output_row
+          # Trigger terminal scroll by printing newline at bottom
+          screen.move_cursor(screen.height - 1, 0)
+          print "\n"
+          
+          # After scroll, position to write at the last row of output area
+          @output_row = max_output_row - 1
+          
+          # Important: Re-render fixed areas after scroll to prevent corruption
+          render_fixed_areas
+        end
+        
+        # Now write the line at current position
+        screen.move_cursor(@output_row, 0)
+        screen.clear_line
+        print line
+        
+        # Move to next row for next write
+        @output_row += 1
+      end
+
       # Wrap a long line into multiple lines based on terminal width
       # Considers display width of multi-byte characters (e.g., Chinese characters)
       # @param line [String] Line to wrap
@@ -412,7 +436,7 @@ module Clacky
 
       # Internal render all (without mutex)
       def render_all_internal
-        output_area.render(start_row: 0)
+        # Output flows naturally, just render fixed areas
         render_fixed_areas
         screen.flush
       end

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

@@ -29,12 +29,12 @@ module Clacky
         }.freeze
 
         COLORS = {
-          user: [:bright_blue, :blue],
+          user: [:white, :white],
           assistant: [:bright_green, :white],
           tool_call: [:bright_cyan, :cyan],
           tool_result: [:cyan, :white],
           tool_denied: [:bright_yellow, :yellow],
-          tool_planned: [:bright_blue, :blue],
+          tool_planned: [:bright_cyan, :cyan],
           tool_error: [:bright_red, :red],
           thinking: [:dim, :dim],
           working: [:bright_yellow, :yellow],

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

@@ -26,12 +26,12 @@ module Clacky
         }.freeze
 
         COLORS = {
-          user: [:blue, :blue],
+          user: [:white, :white],
           assistant: [:green, :white],
           tool_call: [:cyan, :cyan],
           tool_result: [:white, :white],
           tool_denied: [:yellow, :yellow],
-          tool_planned: [:blue, :blue],
+          tool_planned: [:cyan, :cyan],
           tool_error: [:red, :red],
           thinking: [:dim, :dim],
           working: [:bright_yellow, :yellow],

data/lib/clacky/ui2/ui_controller.rb

@@ -2,7 +2,6 @@
 
 require_relative "layout_manager"
 require_relative "view_renderer"
-require_relative "components/output_area"
 require_relative "components/input_area"
 require_relative "components/todo_area"
 require_relative "components/welcome_banner"
@@ -31,13 +30,11 @@ module Clacky
         }
 
         # Initialize layout components
-        @output_area = Components::OutputArea.new(height: 20) # Will be recalculated
         @input_area = Components::InputArea.new
         @todo_area = Components::TodoArea.new
         @welcome_banner = Components::WelcomeBanner.new
         @inline_input = nil  # Created when needed
         @layout = LayoutManager.new(
-          output_area: @output_area,
           input_area: @input_area,
           todo_area: @todo_area
         )
@@ -211,19 +208,21 @@ module Clacky
       #   - cost: cost for this iteration
       def show_token_usage(token_data)
         theme = ThemeManager.current_theme
+        pastel = Pastel.new
 
         token_info = []
 
-        # Delta tokens with color coding
+        # Delta tokens with color coding (green/yellow/red + dim)
         delta_tokens = token_data[:delta_tokens]
         delta_str = "+#{delta_tokens}"
-        colored_delta = if delta_tokens > 10000
-          theme.format_text(delta_str, :error)
+        color_style = if delta_tokens > 10000
+          :red
         elsif delta_tokens > 5000
-          theme.format_text(delta_str, :warning)
+          :yellow
         else
-          theme.format_text(delta_str, :success)
+          :green
         end
+        colored_delta = pastel.decorate(delta_str, color_style, :dim)
         token_info << colored_delta
 
         # Cache status indicator (using theme)
@@ -231,31 +230,44 @@ module Clacky
         cache_read = token_data[:cache_read]
         cache_used = cache_read > 0 || cache_write > 0
         if cache_used
-          token_info << theme.format_symbol(:cached)
+          token_info << pastel.dim(theme.symbol(:cached))
         end
 
         # Input tokens (with cache breakdown if available)
         prompt_tokens = token_data[:prompt_tokens]
         if cache_write > 0 || cache_read > 0
           input_detail = "#{prompt_tokens} (cache: #{cache_read} read, #{cache_write} write)"
-          token_info << "Input: #{input_detail}"
+          token_info << pastel.dim("Input: #{input_detail}")
         else
-          token_info << "Input: #{prompt_tokens}"
+          token_info << pastel.dim("Input: #{prompt_tokens}")
         end
 
         # Output tokens
-        token_info << "Output: #{token_data[:completion_tokens]}"
+        token_info << pastel.dim("Output: #{token_data[:completion_tokens]}")
 
         # Total
-        token_info << "Total: #{token_data[:total_tokens]}"
+        token_info << pastel.dim("Total: #{token_data[:total_tokens]}")
 
-        # Cost for this iteration
+        # Cost for this iteration with color coding (red/yellow for high cost, dim for normal)
         if token_data[:cost]
-          token_info << "Cost: $#{token_data[:cost].round(6)}"
+          cost = token_data[:cost]
+          cost_value = "$#{cost.round(6)}"
+          if cost >= 0.1
+            # High cost - red warning
+            colored_cost = pastel.decorate(cost_value, :red, :dim)
+            token_info << pastel.dim("Cost: ") + colored_cost
+          elsif cost >= 0.05
+            # Medium cost - yellow warning
+            colored_cost = pastel.decorate(cost_value, :yellow, :dim)
+            token_info << pastel.dim("Cost: ") + colored_cost
+          else
+            # Low cost - normal gray
+            token_info << pastel.dim("Cost: #{cost_value}")
+          end
         end
 
-        # Display through output system
-        token_display = theme.format_text("    [Tokens] #{token_info.join(' | ')}", :thinking)
+        # Display through output system (already all dimmed, just add prefix)
+        token_display = pastel.dim("    [Tokens] ") + token_info.join(pastel.dim(' | '))
         append_output(token_display)
       end
 
@@ -313,10 +325,29 @@ module Clacky
       # Show assistant message
       # @param content [String] Message content
       def show_assistant_message(content)
-        output = @renderer.render_assistant_message(content)
+        # Filter out thinking tags from models like MiniMax M2.1 that use <think>...</think>
+        filtered_content = filter_thinking_tags(content)
+        return if filtered_content.nil? || filtered_content.strip.empty?
+
+        output = @renderer.render_assistant_message(filtered_content)
         append_output(output)
       end
 
+      # Filter out thinking tags from content
+      # Some models (e.g., MiniMax M2.1) wrap their reasoning in <think>...</think> tags
+      # @param content [String] Raw content from model
+      # @return [String] Content with thinking tags removed
+      def filter_thinking_tags(content)
+        return content if content.nil?
+
+        # Remove <think>...</think> blocks (multiline, case-insensitive)
+        # Also handles variations like <thinking>...</thinking>
+        filtered = content.gsub(%r{<think(?:ing)?>\s*.*?\s*</think(?:ing)?>}mi, '')
+
+        # Clean up extra whitespace left behind
+        filtered.gsub(/\n{3,}/, "\n\n").strip
+      end
+
       # Show tool call
       # @param name [String] Tool name
       # @param args [String, Hash] Tool arguments (JSON string or Hash)
@@ -564,9 +595,38 @@ module Clacky
 
         diff = Diffy::Diff.new(old_content, new_content, context: 3)
         all_lines = diff.to_s(:color).lines
-        display_lines = all_lines.first(max_lines)
+        plain_lines = diff.to_s.lines
+
+        # Add line numbers to diff output
+        old_line_num = 0
+        new_line_num = 0
+
+        numbered_lines = all_lines.each_with_index.map do |line, index|
+          # Use plain text to detect line type (remove ANSI codes)
+          plain_line = plain_lines[index]&.chomp || line.gsub(/\e\[[0-9;]*m/, '').chomp
+
+          # Remove trailing newline from colored line to avoid double newlines
+          colored_line = line.chomp
+
+          # Determine line type and number (use single line number for simplicity)
+          if plain_line.start_with?('+') || plain_line.start_with?('-') || plain_line.start_with?(' ')
+            new_line_num += 1
+            sprintf("%4d | %s", new_line_num, colored_line)
+          elsif plain_line.start_with?('@@')
+            # Diff header: extract line numbers from @@ -old_start,old_count +new_start,new_count @@
+            if plain_line =~ /@@ -(\d+)(?:,\d+)? (\d+)(?:,\d+)? @@/
+              new_line_num = $2.to_i - 1
+            end
+            sprintf("%4s | %s", "", colored_line)
+          else
+            # Other lines (headers, etc.)
+            sprintf("%4s | %s", "", colored_line)
+          end
+        end
+
+        display_lines = numbered_lines.first(max_lines)
+        display_lines.each { |line| append_output(line) }
 
-        display_lines.each { |line| append_output(line.chomp) }
         if all_lines.size > max_lines
           append_output("\n... (#{all_lines.size - max_lines} more lines, diff truncated)")
         end

data/lib/clacky/ui2.rb

@@ -10,7 +10,6 @@ require_relative "ui2/view_renderer"
 require_relative "ui2/ui_controller"
 
 require_relative "ui2/components/base_component"
-require_relative "ui2/components/output_area"
 require_relative "ui2/components/input_area"
 require_relative "ui2/components/message_component"
 require_relative "ui2/components/tool_component"

data/lib/clacky/utils/arguments_parser.rb

@@ -44,10 +44,11 @@ module Clacky
         result
       end
 
-      # Validate required parameters
+      # Validate required parameters and filter unknown parameters
       def self.validate_required_params(call, args, tool_registry)
         tool = tool_registry.get(call[:name])
         required = tool.parameters&.dig(:required) || []
+        properties = tool.parameters&.dig(:properties) || {}
 
         missing = required.reject { |param|
           args.key?(param.to_sym) || args.key?(param.to_s)
@@ -57,7 +58,11 @@ module Clacky
           raise MissingRequiredParamsError.new(call[:name], missing, args.keys)
         end
 
-        args
+        # Filter out unknown parameters to prevent errors when LLM sends extra arguments
+        known_params = properties.keys.map(&:to_sym) + properties.keys.map(&:to_s)
+        filtered_args = args.select { |key, _| known_params.include?(key) }
+
+        filtered_args
       end
 
       # Generate error message with tool definition

data/lib/clacky/utils/file_processor.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require "base64"
+
+module Clacky
+  module Utils
+    # File processing utilities for binary files, images, and PDFs
+    class FileProcessor
+      # Maximum file size for binary files (5MB)
+      MAX_FILE_SIZE = 5 * 1024 * 1024
+
+      # Supported image formats
+      IMAGE_FORMATS = {
+        "png" => "image/png",
+        "jpg" => "image/jpeg",
+        "jpeg" => "image/jpeg",
+        "gif" => "image/gif",
+        "webp" => "image/webp"
+      }.freeze
+
+      # Supported document formats
+      DOCUMENT_FORMATS = {
+        "pdf" => "application/pdf"
+      }.freeze
+
+      # All supported formats
+      SUPPORTED_FORMATS = IMAGE_FORMATS.merge(DOCUMENT_FORMATS).freeze
+
+      # File signatures (magic bytes) for format detection
+      FILE_SIGNATURES = {
+        "\x89PNG\r\n\x1a\n".b => "png",
+        "\xFF\xD8\xFF".b => "jpg",
+        "GIF87a".b => "gif",
+        "GIF89a".b => "gif",
+        "%PDF".b => "pdf"
+      }.freeze
+
+      class << self
+        # 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,...")
+        # @raise [ArgumentError] If file not found or unsupported format
+        def image_path_to_data_url(path)
+          unless File.exist?(path)
+            raise ArgumentError, "Image file not found: #{path}"
+          end
+
+          # Check file size
+          file_size = File.size(path)
+          if file_size > MAX_FILE_SIZE
+            raise ArgumentError, "File too large: #{file_size} bytes (max: #{MAX_FILE_SIZE} bytes)"
+          end
+
+          # Read file as binary
+          image_data = File.binread(path)
+
+          # Detect MIME type from file extension or content
+          mime_type = detect_mime_type(path, image_data)
+
+          # Verify it's an image format
+          unless IMAGE_FORMATS.values.include?(mime_type)
+            raise ArgumentError, "Unsupported image format: #{mime_type}"
+          end
+
+          # Encode to base64
+          base64_data = Base64.strict_encode64(image_data)
+
+          "data:#{mime_type};base64,#{base64_data}"
+        end
+
+        # Convert file to base64 with format detection
+        # @param path [String] File path
+        # @return [Hash] Hash with :format, :mime_type, :base64_data, :size_bytes
+        # @raise [ArgumentError] If file not found or too large
+        def file_to_base64(path)
+          unless File.exist?(path)
+            raise ArgumentError, "File not found: #{path}"
+          end
+
+          # Check file size
+          file_size = File.size(path)
+          if file_size > MAX_FILE_SIZE
+            raise ArgumentError, "File too large: #{file_size} bytes (max: #{MAX_FILE_SIZE} bytes)"
+          end
+
+          # Read file as binary
+          file_data = File.binread(path)
+
+          # Detect format and MIME type
+          format = detect_format(path, file_data)
+          mime_type = detect_mime_type(path, file_data)
+
+          # Encode to base64
+          base64_data = Base64.strict_encode64(file_data)
+
+          {
+            format: format,
+            mime_type: mime_type,
+            base64_data: base64_data,
+            size_bytes: file_size
+          }
+        end
+
+        # Detect file format from path and content
+        # @param path [String] File path
+        # @param data [String] Binary file data
+        # @return [String] Format (e.g., "png", "jpg", "pdf")
+        def detect_format(path, data)
+          # Try to detect from file extension first
+          ext = File.extname(path).downcase.delete_prefix(".")
+          return ext if SUPPORTED_FORMATS.key?(ext)
+
+          # Try to detect from file signature (magic bytes)
+          FILE_SIGNATURES.each do |signature, format|
+            return format if data.start_with?(signature)
+          end
+
+          # Special case for WebP (RIFF format)
+          if data.start_with?("RIFF".b) && data[8..11] == "WEBP".b
+            return "webp"
+          end
+
+          nil
+        end
+
+        # Detect MIME type from file path and content
+        # @param path [String] File path
+        # @param data [String] Binary file data
+        # @return [String] MIME type (e.g., "image/png")
+        def detect_mime_type(path, data)
+          format = detect_format(path, data)
+          return SUPPORTED_FORMATS[format] if format && SUPPORTED_FORMATS[format]
+
+          # Default to application/octet-stream for unknown formats
+          "application/octet-stream"
+        end
+
+        # Check if file is a supported binary format
+        # @param path [String] File path
+        # @return [Boolean] True if supported binary format
+        def supported_binary_file?(path)
+          return false unless File.exist?(path)
+
+          ext = File.extname(path).downcase.delete_prefix(".")
+          SUPPORTED_FORMATS.key?(ext)
+        end
+
+        # Check if file is an image
+        # @param path [String] File path
+        # @return [Boolean] True if image format
+        def image_file?(path)
+          return false unless File.exist?(path)
+
+          ext = File.extname(path).downcase.delete_prefix(".")
+          IMAGE_FORMATS.key?(ext)
+        end
+
+        # Check if file is a PDF
+        # @param path [String] File path
+        # @return [Boolean] True if PDF format
+        def pdf_file?(path)
+          return false unless File.exist?(path)
+
+          ext = File.extname(path).downcase.delete_prefix(".")
+          ext == "pdf"
+        end
+
+        # Check if file is binary (not text)
+        # @param data [String] File content
+        # @param sample_size [Integer] Number of bytes to check (default: 8192)
+        # @return [Boolean] True if file appears to be binary
+        def binary_file?(data, sample_size: 8192)
+          # Check first N bytes for null bytes or high ratio of non-printable characters
+          sample = data[0, sample_size] || ""
+          return false if sample.empty?
+
+          # Check for known binary signatures first
+          FILE_SIGNATURES.each do |signature, _format|
+            return true if sample.start_with?(signature)
+          end
+
+          # Check for WebP (RIFF format)
+          if sample.start_with?("RIFF".b) && sample.length >= 12 && sample[8..11] == "WEBP".b
+            return true
+          end
+
+          # If contains null bytes, it's binary
+          return true if sample.include?("\x00")
+
+          # Count non-printable characters (excluding common whitespace)
+          non_printable = sample.bytes.count do |byte|
+            byte < 32 && ![9, 10, 13].include?(byte) || byte >= 127
+          end
+
+          # If more than 30% non-printable, consider it binary
+          (non_printable.to_f / sample.size) > 0.3
+        end
+      end
+    end
+  end
+end