openclacky 0.5.4 → 0.5.6

data/lib/clacky/client.rb

@@ -55,12 +55,28 @@ module Clacky
       # Add tools if provided
       # For Claude API with caching: mark the last tool definition with cache_control
       if tools&.any?
-        if enable_caching && supports_prompt_caching?(model)
+        caching_supported = supports_prompt_caching?(model)
+        caching_enabled = enable_caching && caching_supported
+        
+        # Debug logging for caching decisions
+        if verbose || ENV["CLACKY_DEBUG"]
+          puts "\n[DEBUG] Prompt Caching Analysis:"
+          puts "  Model: #{model}"
+          puts "  Caching Requested: #{enable_caching}"
+          puts "  Caching Supported: #{caching_supported}"
+          puts "  Caching Enabled: #{caching_enabled}"
+        end
+        
+        if caching_enabled
           # Deep clone tools to avoid modifying original
           cached_tools = tools.map { |tool| deep_clone(tool) }
           # Mark the last tool for caching (Claude caches from cache breakpoint to end)
           cached_tools.last[:cache_control] = { type: "ephemeral" }
           body[:tools] = cached_tools
+          
+          if verbose || ENV["CLACKY_DEBUG"]
+            puts "  Cache Control Added: Last tool marked for caching"
+          end
         else
           body[:tools] = tools
         end
@@ -91,14 +107,28 @@ module Clacky
     private
 
     # Check if the model supports prompt caching
-    # Currently only Claude 3.5 Sonnet and newer Claude models support this
+    # Currently only Claude 3.5+ models support this feature
     def supports_prompt_caching?(model)
       model_str = model.to_s.downcase
-      # Claude 3.5 Sonnet (20241022 and newer) supports prompt caching
-      # Also Claude 3.7 Sonnet and Opus models when they're released
-      model_str.include?("claude-3.5-sonnet") ||
-        model_str.include?("claude-3-7") ||
-        model_str.include?("claude-4")
+      
+      # Only Claude models support prompt caching
+      return false unless model_str.include?("claude")
+      
+      # Pattern matching for supported Claude versions:
+      # - claude-3.5-*, claude-3-5-*, claude-3.5.*
+      # - claude-3.7-*, claude-3-7-*, claude-3.7.*  
+      # - claude-4*, claude-sonnet-4*
+      # - anthropic/claude-sonnet-4* (OpenRouter format)
+      cache_pattern = /
+        claude                        # Must contain "claude"
+        (?:                          # Non-capturing group for version patterns
+          (?:-3[-.]?[5-9])|          # 3.5, 3.6, 3.7, 3.8, 3.9 or 3-5, 3-6, etc
+          (?:-[4-9])|                # 4, 5, 6, 7, 8, 9 (future versions)
+          (?:-sonnet-[34])           # OpenRouter: claude-sonnet-3, claude-sonnet-4
+        )
+      /x
+      
+      model_str.match?(cache_pattern)
     end
 
     # Deep clone a hash/array structure (for tool definitions)
@@ -162,6 +192,11 @@ module Clacky
           total_tokens: usage["total_tokens"]
         }
         
+        # Add OpenRouter cost information if present
+        if usage["cost"]
+          usage_data[:api_cost] = usage["cost"]
+        end
+        
         # Add cache metrics if present (Claude API with prompt caching)
         if usage["cache_creation_input_tokens"]
           usage_data[:cache_creation_input_tokens] = usage["cache_creation_input_tokens"]
@@ -170,6 +205,17 @@ module Clacky
           usage_data[:cache_read_input_tokens] = usage["cache_read_input_tokens"]
         end
         
+        # Add OpenRouter cache information from prompt_tokens_details
+        if usage["prompt_tokens_details"]
+          details = usage["prompt_tokens_details"]
+          if details["cached_tokens"] && details["cached_tokens"] > 0
+            usage_data[:cache_read_input_tokens] = details["cached_tokens"]
+          end
+          if details["cache_write_tokens"] && details["cache_write_tokens"] > 0
+            usage_data[:cache_creation_input_tokens] = details["cache_write_tokens"]
+          end
+        end
+        
         {
           content: message["content"],
           tool_calls: parse_tool_calls(message["tool_calls"]),

data/lib/clacky/model_pricing.rb

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+module Clacky
+  # Module for handling AI model pricing
+  # Supports different pricing tiers and prompt caching
+  module ModelPricing
+    # Pricing per 1M tokens (MTok) in USD
+    # All pricing is based on official API documentation
+    PRICING_TABLE = {
+      # Claude 4.5 models - tiered pricing based on prompt length
+      "claude-opus-4.5" => {
+        input: {
+          default: 5.00,              # $5/MTok for prompts ≤ 200K tokens
+          over_200k: 5.00             # same for all tiers
+        },
+        output: {
+          default: 25.00,             # $25/MTok for prompts ≤ 200K tokens
+          over_200k: 25.00            # same for all tiers
+        },
+        cache: {
+          write: 6.25,                # $6.25/MTok cache write
+          read: 0.50                  # $0.50/MTok cache read
+        }
+      },
+      
+      "claude-sonnet-4.5" => {
+        input: {
+          default: 3.00,              # $3/MTok for prompts ≤ 200K tokens
+          over_200k: 6.00             # $6/MTok for prompts > 200K tokens
+        },
+        output: {
+          default: 15.00,             # $15/MTok for prompts ≤ 200K tokens
+          over_200k: 22.50            # $22.50/MTok for prompts > 200K tokens
+        },
+        cache: {
+          write_default: 3.75,        # $3.75/MTok cache write (≤ 200K)
+          write_over_200k: 7.50,      # $7.50/MTok cache write (> 200K)
+          read_default: 0.30,         # $0.30/MTok cache read (≤ 200K)
+          read_over_200k: 0.60        # $0.60/MTok cache read (> 200K)
+        }
+      },
+      
+      "claude-haiku-4.5" => {
+        input: {
+          default: 1.00,              # $1/MTok
+          over_200k: 1.00             # same for all tiers
+        },
+        output: {
+          default: 5.00,              # $5/MTok
+          over_200k: 5.00             # same for all tiers
+        },
+        cache: {
+          write: 1.25,                # $1.25/MTok cache write
+          read: 0.10                  # $0.10/MTok cache read
+        }
+      },
+
+      # Claude 3.5 models (for backwards compatibility)
+      "claude-3-5-sonnet-20241022" => {
+        input: {
+          default: 3.00,
+          over_200k: 6.00
+        },
+        output: {
+          default: 15.00,
+          over_200k: 22.50
+        },
+        cache: {
+          write_default: 3.75,
+          write_over_200k: 7.50,
+          read_default: 0.30,
+          read_over_200k: 0.60
+        }
+      },
+
+      "claude-3-5-sonnet-20240620" => {
+        input: {
+          default: 3.00,
+          over_200k: 6.00
+        },
+        output: {
+          default: 15.00,
+          over_200k: 22.50
+        },
+        cache: {
+          write_default: 3.75,
+          write_over_200k: 7.50,
+          read_default: 0.30,
+          read_over_200k: 0.60
+        }
+      },
+
+      "claude-3-5-haiku-20241022" => {
+        input: {
+          default: 1.00,
+          over_200k: 1.00
+        },
+        output: {
+          default: 5.00,
+          over_200k: 5.00
+        },
+        cache: {
+          write: 1.25,
+          read: 0.10
+        }
+      },
+
+      # Default fallback pricing (conservative estimates)
+      "default" => {
+        input: {
+          default: 0.50,
+          over_200k: 0.50
+        },
+        output: {
+          default: 1.50,
+          over_200k: 1.50
+        },
+        cache: {
+          write: 0.625,
+          read: 0.05
+        }
+      }
+    }.freeze
+
+    # Threshold for tiered pricing (200K tokens)
+    TIERED_PRICING_THRESHOLD = 200_000
+
+    class << self
+      # Calculate cost for the given model and usage
+      # 
+      # @param model [String] Model identifier
+      # @param usage [Hash] Usage statistics containing:
+      #   - prompt_tokens: number of input tokens
+      #   - completion_tokens: number of output tokens
+      #   - cache_creation_input_tokens: tokens written to cache (optional)
+      #   - cache_read_input_tokens: tokens read from cache (optional)
+      # @return [Hash] Hash containing:
+      #   - cost: Cost in USD (Float)
+      #   - source: Cost source (:price or :default) (Symbol)
+      def calculate_cost(model:, usage:)
+        pricing_result = get_pricing_with_source(model)
+        pricing = pricing_result[:pricing]
+        source = pricing_result[:source]
+        
+        prompt_tokens = usage[:prompt_tokens] || 0
+        completion_tokens = usage[:completion_tokens] || 0
+        cache_write_tokens = usage[:cache_creation_input_tokens] || 0
+        cache_read_tokens = usage[:cache_read_input_tokens] || 0
+        
+        # Determine if we're in the over_200k tier
+        total_input_tokens = prompt_tokens + cache_write_tokens + cache_read_tokens
+        over_threshold = total_input_tokens > TIERED_PRICING_THRESHOLD
+        
+        # Calculate regular input cost (non-cached tokens)
+        regular_input_tokens = prompt_tokens - cache_write_tokens - cache_read_tokens
+        input_rate = over_threshold ? pricing[:input][:over_200k] : pricing[:input][:default]
+        input_cost = (regular_input_tokens / 1_000_000.0) * input_rate
+        
+        # Calculate output cost
+        output_rate = over_threshold ? pricing[:output][:over_200k] : pricing[:output][:default]
+        output_cost = (completion_tokens / 1_000_000.0) * output_rate
+        
+        # Calculate cache costs
+        cache_cost = calculate_cache_cost(
+          pricing: pricing,
+          cache_write_tokens: cache_write_tokens,
+          cache_read_tokens: cache_read_tokens,
+          over_threshold: over_threshold
+        )
+        
+        {
+          cost: input_cost + output_cost + cache_cost,
+          source: source
+        }
+      end
+      
+      # Get pricing for a specific model
+      # Falls back to default pricing if model not found
+      # 
+      # @param model [String] Model identifier
+      # @return [Hash] Pricing structure for the model
+      def get_pricing(model)
+        get_pricing_with_source(model)[:pricing]
+      end
+      
+      # Get pricing with source information
+      # 
+      # @param model [String] Model identifier
+      # @return [Hash] Hash containing:
+      #   - pricing: Pricing structure for the model
+      #   - source: :price (matched model) or :default (fallback)
+      def get_pricing_with_source(model)
+        # Normalize model name (remove version suffixes, handle variations)
+        normalized_model = normalize_model_name(model)
+        
+        if normalized_model == "default"
+          # Using default fallback pricing
+          {
+            pricing: PRICING_TABLE["default"],
+            source: :default
+          }
+        else
+          # Found specific pricing for this model
+          {
+            pricing: PRICING_TABLE[normalized_model],
+            source: :price
+          }
+        end
+      end
+      
+      private
+      
+      # Normalize model name to match pricing table keys
+      def normalize_model_name(model)
+        return "default" if model.nil? || model.empty?
+        
+        model = model.downcase.strip
+        
+        # Direct match
+        return model if PRICING_TABLE.key?(model)
+        
+        # Check for Claude model variations
+        # Support both dot and dash separators (e.g., "4.5" or "4-5")
+        case model
+        when /claude.*opus.*4[.-]?5/i
+          "claude-opus-4.5"
+        when /claude.*sonnet.*4[.-]?5/i
+          "claude-sonnet-4.5"
+        when /claude.*haiku.*4[.-]?5/i
+          "claude-haiku-4.5"
+        when /claude-3-5-sonnet-20241022/i
+          "claude-3-5-sonnet-20241022"
+        when /claude-3-5-sonnet-20240620/i
+          "claude-3-5-sonnet-20240620"
+        when /claude-3-5-haiku-20241022/i
+          "claude-3-5-haiku-20241022"
+        else
+          "default"
+        end
+      end
+      
+      # Calculate cache-related costs
+      def calculate_cache_cost(pricing:, cache_write_tokens:, cache_read_tokens:, over_threshold:)
+        cache_cost = 0.0
+        
+        # Cache write cost
+        if cache_write_tokens > 0
+          write_rate = if pricing[:cache].key?(:write)
+                         # Simple pricing (Opus 4.5, Haiku 4.5)
+                         pricing[:cache][:write]
+                       elsif over_threshold
+                         # Tiered pricing (Sonnet 4.5)
+                         pricing[:cache][:write_over_200k]
+                       else
+                         pricing[:cache][:write_default]
+                       end
+          
+          cache_cost += (cache_write_tokens / 1_000_000.0) * write_rate
+        end
+        
+        # Cache read cost
+        if cache_read_tokens > 0
+          read_rate = if pricing[:cache].key?(:read)
+                        # Simple pricing (Opus 4.5, Haiku 4.5)
+                        pricing[:cache][:read]
+                      elsif over_threshold
+                        # Tiered pricing (Sonnet 4.5)
+                        pricing[:cache][:read_over_200k]
+                      else
+                        pricing[:cache][:read_default]
+                      end
+          
+          cache_cost += (cache_read_tokens / 1_000_000.0) * read_rate
+        end
+        
+        cache_cost
+      end
+    end
+  end
+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

@@ -136,7 +136,7 @@ module Clacky
 
           # Initialize gitignore parser
           gitignore_path = find_gitignore(expanded_path)
-          gitignore = gitignore_path ? GitignoreParser.new(gitignore_path) : nil
+          gitignore = gitignore_path ? Clacky::GitignoreParser.new(gitignore_path) : nil
 
           results = []
           total_matches = 0
@@ -256,21 +256,77 @@ 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
+      # Only searches within the search path and up to the current working directory
       def find_gitignore(path)
         search_path = File.directory?(path) ? path : File.dirname(path)
         
         # Look for .gitignore in current and parent directories
         current = File.expand_path(search_path)
+        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)
+        search_limit = if current.start_with?(cwd)
+                        cwd
+                      else
+                        current
+                      end
+        
         loop do
           gitignore = File.join(current, '.gitignore')
           return gitignore if File.exist?(gitignore)
           
-          break if current == root
+          # Stop if we've reached the search limit or root
+          break if current == search_limit || current == root
           current = File.dirname(current)
         end
         
@@ -279,24 +335,35 @@ module Clacky
 
       # Check if file should be ignored based on .gitignore or default patterns
       def should_ignore_file?(file, base_path, gitignore)
+        # Always calculate path relative to base_path for consistency
+        # 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 file.start_with?(base_path)
-          relative_path = file[base_path.length + 1..] || file
+        if expanded_file.start_with?(expanded_base)
+          relative_path = expanded_file[(expanded_base.length + 1)..-1] || File.basename(expanded_file)
         else
-          relative_path = file
+          # 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
-        relative_path ||= file
         
         if gitignore
           # Use .gitignore rules
           gitignore.ignored?(relative_path)
         else
-          # Use default ignore patterns
+          # Use default ignore patterns - only match against relative path components
           DEFAULT_IGNORED_PATTERNS.any? do |pattern|
             if pattern.include?('*')
               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.include?("/#{pattern}/") ||
               relative_path == pattern ||

data/lib/clacky/tools/safe_shell.rb

@@ -26,12 +26,17 @@ module Clacky
           hard_timeout: {
             type: "integer",
             description: "Hard timeout in seconds (force kill)"
+          },
+          max_output_lines: {
+            type: "integer",
+            description: "Maximum number of output lines to return (default: 1000)",
+            default: 1000
           }
         },
         required: ["command"]
       }
 
-      def execute(command:, soft_timeout: nil, hard_timeout: nil)
+      def execute(command:, soft_timeout: nil, hard_timeout: nil, max_output_lines: 1000)
         # Get project root directory
         project_root = Dir.pwd
 
@@ -41,7 +46,7 @@ module Clacky
           safe_command = safety_replacer.make_command_safe(command)
 
           # 2. Call parent class execution method
-          result = super(command: safe_command, soft_timeout: soft_timeout, hard_timeout: hard_timeout)
+          result = super(command: safe_command, soft_timeout: soft_timeout, hard_timeout: hard_timeout, max_output_lines: max_output_lines)
 
           # 3. Enhance result information
           enhance_result(result, command, safe_command)
@@ -112,8 +117,8 @@ module Clacky
         return "safe_shell(<no command>)" if cmd.empty?
 
         # Truncate long commands intelligently
-        if cmd.length > 50
-          "safe_shell(\"#{cmd[0..47]}...\")"
+        if cmd.length > 150
+          "safe_shell(\"#{cmd[0..147]}...\")"
         else
           "safe_shell(\"#{cmd}\")"
         end