openclacky 0.5.6 → 0.6.0

data/lib/clacky/client.rb

@@ -45,11 +45,24 @@ module Clacky
     # Send messages with function calling (tools) support
     # Options:
     #   - enable_caching: Enable prompt caching for system prompt and tools (default: false)
-    def send_messages_with_tools(messages, model:, tools:, max_tokens:, verbose: false, enable_caching: false)
+    def send_messages_with_tools(messages, model:, tools:, max_tokens:, enable_caching: false)
+      # Apply caching to messages if enabled
+      caching_supported = supports_prompt_caching?(model)
+      caching_enabled = enable_caching && caching_supported
+
+      # Deep clone messages to avoid modifying the original array
+      processed_messages = messages.map { |msg| deep_clone(msg) }
+
+      # Add cache control to messages if caching is enabled
+      # Strategy: Cache system prompt and first user message for stable prefix caching
+      if caching_enabled
+        processed_messages = apply_message_caching(processed_messages)
+      end
+
       body = {
         model: model,
         max_tokens: max_tokens,
-        messages: messages
+        messages: processed_messages
       }
 
       # Add tools if provided
@@ -57,44 +70,23 @@ module Clacky
       if tools&.any?
         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
       end
 
-      # Debug output
-      if verbose || ENV["CLACKY_DEBUG"]
-        puts "\n[DEBUG] Current directory: #{Dir.pwd}"
-        puts "[DEBUG] Request to API:"
-
-        # Create a simplified version of the body for display
-        display_body = body.dup
-        if display_body[:tools]&.any?
-          tool_names = display_body[:tools].map { |t| t.dig(:function, :name) }.compact
-          display_body[:tools] = "use tools: #{tool_names.join(', ')}"
-        end
-
-        puts JSON.pretty_generate(display_body)
+      # Debug: Save request body to see what we're actually sending
+      if ENV['CLACKY_DEBUG_REQUEST']
+        debug_file = "/tmp/clacky_request_#{Time.now.to_i}.json"
+        File.write(debug_file, JSON.pretty_generate(body))
+        puts "DEBUG: Request saved to #{debug_file}"
       end
 
       response = connection.post("chat/completions") do |req|
@@ -131,6 +123,49 @@ module Clacky
       model_str.match?(cache_pattern)
     end
 
+    # Apply cache_control to messages for prompt caching
+    # Strategy: Add cache_control on the LAST message before tools
+    # This ensures everything from start to the breakpoint gets cached
+    def apply_message_caching(messages)
+      return messages if messages.empty?
+
+      # Add cache_control to the last message (before tools are added)
+      # This will cache: system message + all conversation history
+      messages.map.with_index do |msg, idx|
+        if idx == messages.length - 1
+          # Last message: add cache_control in content block
+          add_cache_control_to_message(msg)
+        else
+          msg
+        end
+      end
+    end
+
+    # Convert message content to array format and add cache_control
+    # Claude API format: content: [{type: "text", text: "...", cache_control: {...}}]
+    def add_cache_control_to_message(msg)
+      content = msg[:content]
+
+      # Convert content to array format if it's a string
+      content_array = if content.is_a?(String)
+        [{ type: "text", text: content, cache_control: { type: "ephemeral" } }]
+      elsif content.is_a?(Array)
+        # Content is already an array, add cache_control to the last block
+        content.map.with_index do |block, idx|
+          if idx == content.length - 1
+            block.merge(cache_control: { type: "ephemeral" })
+          else
+            block
+          end
+        end
+      else
+        # Unknown format, return as-is
+        return msg
+      end
+
+      msg.merge(content: content_array)
+    end
+
     # Deep clone a hash/array structure (for tool definitions)
     def deep_clone(obj)
       case obj
@@ -178,12 +213,8 @@ module Clacky
         message = data["choices"].first["message"]
         usage = data["usage"]
 
-        # Debug: show raw API response content
-        if ENV["CLACKY_DEBUG"]
-          puts "\n[DEBUG] Raw API response content:"
-          puts "  content: #{message["content"].inspect}"
-          puts "  content length: #{message["content"]&.length || 0}"
-        end
+        # Store raw API usage for debugging
+        raw_api_usage = usage.dup
 
         # Parse usage with cache information
         usage_data = {
@@ -220,7 +251,8 @@ module Clacky
           content: message["content"],
           tool_calls: parse_tool_calls(message["tool_calls"]),
           finish_reason: data["choices"].first["finish_reason"],
-          usage: usage_data
+          usage: usage_data,
+          raw_api_usage: raw_api_usage
         }
       when 401
         raise Error, "Invalid API key"

data/lib/clacky/gitignore_parser.rb

@@ -71,41 +71,55 @@ module Clacky
 
     def match_pattern?(path, pattern_info)
       pattern = pattern_info[:pattern]
+      is_absolute = pattern_info[:is_absolute]
       
-      # Remove leading slash for absolute patterns
-      pattern = pattern[1..] if pattern_info[:is_absolute]
+      # For absolute patterns (starting with /), remove the leading slash
+      # These patterns match from the root of the repository
+      if is_absolute
+        pattern = pattern[1..]
+        # Absolute patterns match exactly from the start of the path
+        return true if path == pattern
+        return true if path.start_with?("#{pattern}/")
+      end
       
       # Handle directory patterns
       if pattern_info[:is_directory]
-        return false unless File.directory?(path)
+        # Directory patterns should match the directory and all its contents
+        return true if path == pattern
+        return true if path.start_with?("#{pattern}/")
+        # Also check if any path component matches the directory pattern
+        return true if path.split('/').include?(pattern)
       end
       
       # Handle different wildcard patterns
       if pattern_info[:has_double_star]
         # Convert ** to match any number of directories
-        regex_pattern = pattern
-          .gsub('**/', '(.*/)?')  # **/ matches zero or more directories
-          .gsub('**', '.*')        # ** at end matches anything
-          .gsub('*', '[^/]*')      # * matches anything except /
-          .gsub('?', '[^/]')       # ? matches single character except /
+        regex_pattern = Regexp.escape(pattern)
+          .gsub('\*\*/', '(.*/)?')  # **/ matches zero or more directories
+          .gsub('\*\*', '.*')        # ** at end matches anything
+          .gsub('\*', '[^/]*')       # * matches anything except /
+          .gsub('\?', '[^/]')        # ? matches single character except /
         
         regex = Regexp.new("^#{regex_pattern}$")
         return true if path.match?(regex)
         return true if path.split('/').any? { |part| part.match?(regex) }
       elsif pattern_info[:has_wildcard]
         # Convert glob pattern to regex
-        regex_pattern = pattern
-          .gsub('*', '[^/]*')
-          .gsub('?', '[^/]')
+        regex_pattern = Regexp.escape(pattern)
+          .gsub('\*', '[^/]*')
+          .gsub('\?', '[^/]')
         
         regex = Regexp.new("^#{regex_pattern}$")
         return true if path.match?(regex)
         return true if File.basename(path).match?(regex)
       else
-        # Exact match
+        # Exact match - pattern without wildcards
+        # Match as basename or as path prefix
         return true if path == pattern
         return true if path.start_with?("#{pattern}/")
         return true if File.basename(path) == pattern
+        # Also check if pattern matches any path component
+        return true if path.split('/').include?(pattern)
       end
       
       false

data/lib/clacky/model_pricing.rb

@@ -148,11 +148,15 @@ module Clacky
         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
+        # Note: prompt_tokens includes cache_read_tokens but NOT cache_write_tokens
+        # cache_write_tokens are additional tokens that were written to cache
+        total_input_tokens = prompt_tokens + cache_write_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
+        # prompt_tokens already includes cache_read_tokens, so we need to subtract them
+        # cache_write_tokens are not part of prompt_tokens, so they're handled separately in cache_cost
+        regular_input_tokens = prompt_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
         

data/lib/clacky/session_manager.rb

@@ -20,6 +20,10 @@ module Clacky
       FileUtils.chmod(0o600, filepath)
 
       @last_saved_path = filepath
+
+      # Keep only the most recent 10 sessions
+      cleanup_by_count(keep: 10)
+
       filepath
     end
 
@@ -104,9 +108,9 @@ module Clacky
     end
 
     def generate_filename(session_id, created_at)
-      date = Time.parse(created_at).strftime("%Y-%m-%d")
+      datetime = Time.parse(created_at).strftime("%Y-%m-%d-%H-%M-%S")
       short_id = session_id[0..7]
-      "#{date}_#{short_id}.json"
+      "#{datetime}-#{short_id}.json"
     end
 
     def all_sessions

data/lib/clacky/tools/glob.rb

@@ -5,9 +5,12 @@ require "pathname"
 module Clacky
   module Tools
     class Glob < Base
+      # Maximum file size to search (1MB)
+      MAX_FILE_SIZE = 1_048_576
+
       self.tool_name = "glob"
       self.tool_description = "Find files matching a glob pattern (e.g., '**/*.rb', 'src/**/*.js'). " \
-                              "Returns file paths sorted by modification time."
+                              "Returns file paths sorted by modification time. Respects .gitignore patterns."
       self.tool_category = "file_system"
       self.tool_parameters = {
         type: "object",
@@ -23,14 +26,14 @@ module Clacky
           },
           limit: {
             type: "integer",
-            description: "Maximum number of results to return (default: 100)",
-            default: 100
+            description: "Maximum number of results to return (default: 10)",
+            default: 10
           }
         },
         required: %w[pattern]
       }
 
-      def execute(pattern:, base_path: ".", limit: 100)
+      def execute(pattern:, base_path: ".", limit: 10)
         # Validate pattern
         if pattern.nil? || pattern.strip.empty?
           return { error: "Pattern cannot be empty" }
@@ -42,11 +45,49 @@ module Clacky
         end
 
         begin
+          # Expand base path
+          expanded_path = File.expand_path(base_path)
+
+          # Initialize gitignore parser
+          gitignore_path = Clacky::Utils::FileIgnoreHelper.find_gitignore(expanded_path)
+          gitignore = gitignore_path ? Clacky::GitignoreParser.new(gitignore_path) : nil
+
+          # Track skipped files
+          skipped = {
+            binary: 0,
+            too_large: 0,
+            ignored: 0
+          }
+
           # Change to base path and find matches
           full_pattern = File.join(base_path, pattern)
-          matches = Dir.glob(full_pattern, File::FNM_DOTMATCH)
-                       .reject { |path| File.directory?(path) }
-                       .reject { |path| path.end_with?(".", "..") }
+          all_matches = Dir.glob(full_pattern, File::FNM_DOTMATCH)
+                           .reject { |path| File.directory?(path) }
+                           .reject { |path| path.end_with?(".", "..") }
+
+          # Filter out ignored, binary, and too large files
+          matches = all_matches.select do |file|
+            # Skip if file should be ignored (unless it's a config file)
+            if Clacky::Utils::FileIgnoreHelper.should_ignore_file?(file, expanded_path, gitignore) && 
+               !Clacky::Utils::FileIgnoreHelper.is_config_file?(file)
+              skipped[:ignored] += 1
+              next false
+            end
+
+            # Skip binary files
+            if Clacky::Utils::FileIgnoreHelper.binary_file?(file)
+              skipped[:binary] += 1
+              next false
+            end
+
+            # Skip files that are too large
+            if File.size(file) > MAX_FILE_SIZE
+              skipped[:too_large] += 1
+              next false
+            end
+
+            true
+          end
 
           # Sort by modification time (most recent first)
           matches = matches.sort_by { |path| -File.mtime(path).to_i }
@@ -55,7 +96,7 @@ module Clacky
           total_matches = matches.length
           matches = matches.take(limit)
 
-          # Convert to relative or absolute paths
+          # Convert to absolute paths
           matches = matches.map { |path| File.expand_path(path) }
 
           {
@@ -63,6 +104,7 @@ module Clacky
             total_matches: total_matches,
             returned: matches.length,
             truncated: total_matches > limit,
+            skipped_files: skipped,
             error: nil
           }
         rescue StandardError => e
@@ -85,7 +127,21 @@ module Clacky
           count = result[:returned] || 0
           total = result[:total_matches] || 0
           truncated = result[:truncated] ? " (truncated)" : ""
-          "✓ Found #{count}/#{total} files#{truncated}"
+          
+          msg = "✓ Found #{count}/#{total} files#{truncated}"
+          
+          # Add skipped files info if present
+          if result[:skipped_files]
+            skipped = result[:skipped_files]
+            skipped_parts = []
+            skipped_parts << "#{skipped[:ignored]} ignored" if skipped[:ignored] > 0
+            skipped_parts << "#{skipped[:binary]} binary" if skipped[:binary] > 0
+            skipped_parts << "#{skipped[:too_large]} too large" if skipped[:too_large] > 0
+            
+            msg += " (skipped: #{skipped_parts.join(', ')})" unless skipped_parts.empty?
+          end
+          
+          msg
         end
       end
     end

data/lib/clacky/tools/grep.rb

@@ -3,36 +3,6 @@
 module Clacky
   module Tools
     class Grep < Base
-      # Default patterns to ignore when .gitignore is not available
-      DEFAULT_IGNORED_PATTERNS = [
-        'node_modules',
-        'vendor/bundle',
-        '.git',
-        '.svn',
-        'tmp',
-        'log',
-        'coverage',
-        'dist',
-        'build',
-        '.bundle',
-        '.sass-cache',
-        '.DS_Store',
-        '*.log'
-      ].freeze
-
-      # Config file patterns that should always be searchable
-      CONFIG_FILE_PATTERNS = [
-        /\.env/,
-        /\.ya?ml$/,
-        /\.json$/,
-        /\.toml$/,
-        /\.ini$/,
-        /\.conf$/,
-        /\.config$/,
-        /config\//,
-        /\.config\//
-      ].freeze
-
       # Maximum file size to search (1MB)
       MAX_FILE_SIZE = 1_048_576
 
@@ -135,7 +105,7 @@ module Clacky
           regex = Regexp.new(pattern, regex_options)
 
           # Initialize gitignore parser
-          gitignore_path = find_gitignore(expanded_path)
+          gitignore_path = Clacky::Utils::FileIgnoreHelper.find_gitignore(expanded_path)
           gitignore = gitignore_path ? Clacky::GitignoreParser.new(gitignore_path) : nil
 
           results = []
@@ -165,13 +135,14 @@ module Clacky
             end
 
             # Skip if file should be ignored (unless it's a config file)
-            if should_ignore_file?(file, expanded_path, gitignore) && !is_config_file?(file)
+            if Clacky::Utils::FileIgnoreHelper.should_ignore_file?(file, expanded_path, gitignore) && 
+               !Clacky::Utils::FileIgnoreHelper.is_config_file?(file)
               skipped[:ignored] += 1
               next
             end
 
             # Skip binary files
-            if binary_file?(file)
+            if Clacky::Utils::FileIgnoreHelper.binary_file?(file)
               skipped[:binary] += 1
               next
             end
@@ -302,82 +273,6 @@ module Clacky
 
       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)
-          
-          # Stop if we've reached the search limit or root
-          break if current == search_limit || current == root
-          current = File.dirname(current)
-        end
-        
-        nil
-      end
-
-      # 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 expanded_file.start_with?(expanded_base)
-          relative_path = expanded_file[(expanded_base.length + 1)..-1] || File.basename(expanded_file)
-        else
-          # 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)
-        else
-          # 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 ||
-              File.basename(relative_path) == pattern
-            end
-          end
-        end
-      end
-
-      # Check if file is a config file (should not be ignored even if in .gitignore)
-      def is_config_file?(file)
-        CONFIG_FILE_PATTERNS.any? { |pattern| file.match?(pattern) }
-      end
-
       def search_file(file, regex, context_lines, max_matches)
         matches = []
         
@@ -435,17 +330,6 @@ module Clacky
       rescue StandardError
         nil
       end
-
-      def binary_file?(file)
-        # Simple heuristic: check if file contains null bytes in first 8KB
-        return false unless File.exist?(file)
-        return false if File.size(file).zero?
-
-        sample = File.read(file, 8192, encoding: "ASCII-8BIT")
-        sample.include?("\x00")
-      rescue StandardError
-        true
-      end
     end
   end
 end

data/lib/clacky/tools/run_project.rb

@@ -255,6 +255,11 @@ module Clacky
                 ready[0].each do |io|
                   begin
                     data = io.read_nonblock(4096)
+                    # Force UTF-8 encoding to avoid incompatible encoding errors
+                    data.force_encoding('UTF-8')
+                    # Replace invalid UTF-8 sequences with replacement character
+                    data = data.scrub('?') unless data.valid_encoding?
+                    
                     if io == stdout
                       stdout_buf.push_lines(data)
                     else

data/lib/clacky/tools/safe_shell.rb

@@ -19,13 +19,9 @@ module Clacky
             type: "string",
             description: "Shell command to execute"
           },
-          soft_timeout: {
+          timeout: {
             type: "integer",
-            description: "Soft timeout in seconds (for interaction detection)"
-          },
-          hard_timeout: {
-            type: "integer",
-            description: "Hard timeout in seconds (force kill)"
+            description: "Command timeout in seconds (auto-detected if not specified: 60s for normal commands, 180s for build/install commands)"
           },
           max_output_lines: {
             type: "integer",
@@ -36,19 +32,29 @@ module Clacky
         required: ["command"]
       }
 
-      def execute(command:, soft_timeout: nil, hard_timeout: nil, max_output_lines: 1000)
+      def execute(command:, timeout: nil, max_output_lines: 1000)
         # Get project root directory
         project_root = Dir.pwd
 
         begin
-          # 1. Use safety replacer to process command
+          # 1. Extract timeout from command if it starts with "timeout N"
+          command, extracted_timeout = extract_timeout_from_command(command)
+          
+          # Use extracted timeout if not explicitly provided
+          timeout ||= extracted_timeout
+
+          # 2. Use safety replacer to process command
           safety_replacer = CommandSafetyReplacer.new(project_root)
           safe_command = safety_replacer.make_command_safe(command)
 
-          # 2. Call parent class execution method
+          # 3. Calculate timeouts: soft_timeout is fixed at 5s, hard_timeout from timeout parameter
+          soft_timeout = 5
+          hard_timeout = calculate_hard_timeout(command, timeout)
+
+          # 4. Call parent class execution method
           result = super(command: safe_command, soft_timeout: soft_timeout, hard_timeout: hard_timeout, max_output_lines: max_output_lines)
 
-          # 3. Enhance result information
+          # 5. Enhance result information
           enhance_result(result, command, safe_command)
 
         rescue SecurityError => e
@@ -64,6 +70,30 @@ module Clacky
         end
       end
 
+      private def extract_timeout_from_command(command)
+        # Match patterns: "timeout 30 ...", "timeout 30s ...", etc.
+        # Supports: timeout N command, timeout Ns command, timeout -s SIGNAL N command
+        match = command.match(/^timeout\s+(?:-s\s+\w+\s+)?(\d+)s?\s+(.+)$/i)
+        
+        if match
+          timeout_value = match[1].to_i
+          actual_command = match[2]
+          return [actual_command, timeout_value]
+        end
+        
+        # No timeout prefix found, return original command
+        [command, nil]
+      end
+
+      private def calculate_hard_timeout(command, timeout)
+        # If timeout is provided, use it directly
+        return timeout if timeout
+
+        # Otherwise, auto-detect based on command type
+        is_slow = SLOW_COMMANDS.any? { |slow_cmd| command.include?(slow_cmd) }
+        is_slow ? 180 : 60
+      end
+
       # Safe read-only commands that don't modify system state
       SAFE_READONLY_COMMANDS = %w[
         ls pwd cat less more head tail
@@ -267,12 +297,18 @@ module Clacky
 
       def validate_general_command(command)
         # Check general command security
+        # Note: We need to be careful not to match patterns inside quoted strings
+        
+        # First, remove quoted strings to avoid false positives
+        # This is a simplified approach - removes both single and double quoted content
+        cmd_without_quotes = command.gsub(/'[^']*'|"[^"]*"/, '')
+        
         dangerous_patterns = [
           /eval\s*\(/,
           /exec\s*\(/,
           /system\s*\(/,
-          /`.*`/,
-          /\$\(.*\)/,
+          /`[^`]+`/,  # Command substitution with backticks (but only if not in quotes)
+          /\$\([^)]+\)/,  # Command substitution with $() (but only if not in quotes)
           /\|\s*sh\s*$/,
           /\|\s*bash\s*$/,
           />\s*\/etc\//,
@@ -281,7 +317,7 @@ module Clacky
         ]
 
         dangerous_patterns.each do |pattern|
-          if command.match?(pattern)
+          if cmd_without_quotes.match?(pattern)
             raise SecurityError, "Dangerous command pattern detected: #{pattern.source}"
           end
         end