openclacky 0.6.1 → 0.6.3

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
         )
@@ -150,6 +147,12 @@ module Clacky
         @mode_toggle_callback = block
       end
 
+      # Set skill loader for command suggestions
+      # @param skill_loader [Clacky::SkillLoader] The skill loader instance
+      def set_skill_loader(skill_loader)
+        @input_area.set_skill_loader(skill_loader)
+      end
+
       # Append output to the output area
       # @param content [String] Content to append
       def append_output(content)
@@ -211,18 +214,24 @@ 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)
+        delta_str = delta_tokens.negative? ? "#{delta_tokens}" : "+#{delta_tokens}"
+        color_style = if delta_tokens > 10000
+          :red
         elsif delta_tokens > 5000
-          theme.format_text(delta_str, :warning)
+          :yellow
+        else
+          :green
+        end
+        colored_delta = if delta_tokens.negative?
+          pastel.cyan(delta_str)
         else
-          theme.format_text(delta_str, :success)
+          pastel.decorate(delta_str, color_style, :dim)
         end
         token_info << colored_delta
 
@@ -231,31 +240,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 +335,32 @@ 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 multiple empty lines left behind (max 2 consecutive newlines)
+        filtered.gsub!(/\n{3,}/, "\n\n")
+
+        # Remove leading and trailing whitespace
+        filtered.strip
+      end
+
       # Show tool call
       # @param name [String] Tool name
       # @param args [String, Hash] Tool arguments (JSON string or Hash)
@@ -525,8 +569,9 @@ module Clacky
         # Collect input (blocks until user presses Enter)
         result_text = inline_input.collect
 
-        # Clean up - remove the inline input line (use layout to track position)
-        @layout.remove_last_line
+        # Clean up - remove the inline input lines (handle wrapped lines)
+        line_count = inline_input.line_count
+        @layout.remove_last_line(line_count)
 
         # Append the final response to output
         if result_text.nil?
@@ -563,12 +608,15 @@ module Clacky
         require 'diffy'
 
         diff = Diffy::Diff.new(old_content, new_content, context: 3)
-        all_lines = diff.to_s(:color).lines
-        display_lines = all_lines.first(max_lines)
+        diff_lines = diff.to_s(:color).lines
+
+        # Show diff without line numbers
+        diff_lines.take(max_lines).each do |line|
+          append_output(line.chomp)
+        end
 
-        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)")
+        if diff_lines.size > max_lines
+          append_output("\n... (#{diff_lines.size - max_lines} more lines, diff truncated)")
         end
       rescue LoadError
         # Fallback if diffy is not available
@@ -728,16 +776,19 @@ module Clacky
 
       # Handle key input for InlineInput
       def handle_inline_input_key(key)
+        # Get old line count BEFORE modification
+        old_line_count = @inline_input.line_count
+
         result = @inline_input.handle_key(key)
 
         case result[:action]
         when :update
-          # Update the last line of output with current input (use layout to track position)
-          @layout.update_last_line(@inline_input.render)
+          # Update the output area with current input (considering wrapped lines)
+          @layout.update_last_line(@inline_input.render, old_line_count)
           # Position cursor for inline input
           @layout.position_inline_input_cursor(@inline_input)
         when :submit, :cancel
-          # InlineInput is done, will be cleaned up by request_confirmation
+          # InlineInput is done, will be cleaned up by request_confirmation after collect returns
           nil
         when :toggle_mode
           # Update mode and session bar info, but don't render yet

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_ignore_helper.rb

@@ -30,20 +30,18 @@ module Clacky
         /\.ini$/,
         /\.conf$/,
         /\.config$/,
-        /config\//,
-        /\.config\//
       ].freeze
 
       # Find .gitignore file in the search path or parent directories
       # Only searches within the search path and up to the current working directory
       def self.find_gitignore(path)
         search_path = File.directory?(path) ? path : File.dirname(path)
-        
+
         # Look for .gitignore in current and parent directories
         current = File.expand_path(search_path)
         cwd = File.expand_path(Dir.pwd)
         root = File.expand_path('/')
-        
+
         # Limit search: only go up to current working directory
         # This prevents finding .gitignore files from unrelated parent directories
         # when searching in temporary directories (like /tmp in tests)
@@ -52,16 +50,16 @@ module Clacky
                       else
                         current
                       end
-        
+
         loop do
           gitignore = File.join(current, '.gitignore')
           return gitignore if File.exist?(gitignore)
-          
+
           # Stop if we've reached the search limit or root
           break if current == search_limit || current == root
           current = File.dirname(current)
         end
-        
+
         nil
       end
 
@@ -71,10 +69,10 @@ module Clacky
         # Expand both paths to handle symlinks and relative paths correctly
         expanded_file = File.expand_path(file)
         expanded_base = File.expand_path(base_path)
-        
+
         # For files, use the directory as base
         expanded_base = File.dirname(expanded_base) if File.file?(expanded_base)
-        
+
         # Calculate relative path
         if expanded_file.start_with?(expanded_base)
           relative_path = expanded_file[(expanded_base.length + 1)..-1] || File.basename(expanded_file)
@@ -82,10 +80,10 @@ module Clacky
           # File is outside base path - use just the filename
           relative_path = File.basename(expanded_file)
         end
-        
+
         # Clean up relative path
         relative_path = relative_path.sub(/^\.\//, '') if relative_path
-        
+
         if gitignore
           # Use .gitignore rules
           gitignore.ignored?(relative_path)
@@ -96,7 +94,7 @@ module Clacky
               File.fnmatch(pattern, relative_path, File::FNM_PATHNAME | File::FNM_DOTMATCH)
             else
               # Match pattern as a path component (not substring of absolute path)
-              relative_path.start_with?("#{pattern}/") || 
+              relative_path.start_with?("#{pattern}/") ||
               relative_path.include?("/#{pattern}/") ||
               relative_path == pattern ||
               File.basename(relative_path) == pattern

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

data/lib/clacky/version.rb

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

data/lib/clacky.rb

@@ -3,6 +3,8 @@
 require_relative "clacky/version"
 require_relative "clacky/config"
 require_relative "clacky/client"
+require_relative "clacky/skill"
+require_relative "clacky/skill_loader"
 
 # Agent system
 require_relative "clacky/model_pricing"