openclacky 0.5.4 → 0.5.5

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/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
@@ -259,18 +259,30 @@ 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)
           
-          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 +291,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

data/lib/clacky/tools/shell.rb

@@ -22,6 +22,11 @@ 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"]
@@ -51,7 +56,7 @@ module Clacky
         'go build'
       ].freeze
 
-      def execute(command:, soft_timeout: nil, hard_timeout: nil)
+      def execute(command:, soft_timeout: nil, hard_timeout: nil, max_output_lines: 1000)
         require "open3"
         require "stringio"
 
@@ -82,7 +87,8 @@ module Clacky
                   stderr_buffer.string,
                   elapsed,
                   :hard_timeout,
-                  hard_timeout
+                  hard_timeout,
+                  max_output_lines
                 )
               end
 
@@ -97,7 +103,8 @@ module Clacky
                     command,
                     stdout_buffer.string,
                     stderr_buffer.string,
-                    interaction
+                    interaction,
+                    max_output_lines
                   )
                 end
 
@@ -114,7 +121,8 @@ module Clacky
                     command,
                     stdout_buffer.string,
                     stderr_buffer.string,
-                    elapsed
+                    elapsed,
+                    max_output_lines
                   )
                 end
               end
@@ -151,22 +159,30 @@ module Clacky
             rescue StandardError
             end
 
+            stdout_output = stdout_buffer.string
+            stderr_output = stderr_buffer.string
+            
             {
               command: command,
-              stdout: stdout_buffer.string,
-              stderr: stderr_buffer.string,
+              stdout: truncate_output(stdout_output, max_output_lines),
+              stderr: truncate_output(stderr_output, max_output_lines),
               exit_code: wait_thr.value.exitstatus,
               success: wait_thr.value.success?,
-              elapsed: Time.now - start_time
+              elapsed: Time.now - start_time,
+              output_truncated: output_truncated?(stdout_output, stderr_output, max_output_lines)
             }
           end
         rescue StandardError => e
+          stdout_output = stdout_buffer.string
+          stderr_output = "Error executing command: #{e.message}\n#{e.backtrace.first(3).join("\n")}"
+          
           {
             command: command,
-            stdout: stdout_buffer.string,
-            stderr: "Error executing command: #{e.message}\n#{e.backtrace.first(3).join("\n")}",
+            stdout: truncate_output(stdout_output, max_output_lines),
+            stderr: truncate_output(stderr_output, max_output_lines),
             exit_code: -1,
-            success: false
+            success: false,
+            output_truncated: output_truncated?(stdout_output, stderr_output, max_output_lines)
           }
         end
       end
@@ -206,16 +222,17 @@ module Clacky
         nil
       end
 
-      def format_waiting_input_result(command, stdout, stderr, interaction)
+      def format_waiting_input_result(command, stdout, stderr, interaction, max_output_lines)
         {
           command: command,
-          stdout: stdout,
-          stderr: stderr,
+          stdout: truncate_output(stdout, max_output_lines),
+          stderr: truncate_output(stderr, max_output_lines),
           exit_code: -2,
           success: false,
           state: 'WAITING_INPUT',
           interaction_type: interaction[:type],
-          message: format_waiting_message(stdout, interaction)
+          message: format_waiting_message(truncate_output(stdout, max_output_lines), interaction),
+          output_truncated: output_truncated?(stdout, stderr, max_output_lines)
         }
       end
 
@@ -238,16 +255,17 @@ module Clacky
         MSG
       end
 
-      def format_stuck_result(command, stdout, stderr, elapsed)
+      def format_stuck_result(command, stdout, stderr, elapsed, max_output_lines)
         {
           command: command,
-          stdout: stdout,
-          stderr: stderr,
+          stdout: truncate_output(stdout, max_output_lines),
+          stderr: truncate_output(stderr, max_output_lines),
           exit_code: -3,
           success: false,
           state: 'STUCK',
           elapsed: elapsed,
-          message: format_stuck_message(stdout, elapsed)
+          message: format_stuck_message(truncate_output(stdout, max_output_lines), elapsed),
+          output_truncated: output_truncated?(stdout, stderr, max_output_lines)
         }
       end
 
@@ -267,18 +285,38 @@ module Clacky
         MSG
       end
 
-      def format_timeout_result(command, stdout, stderr, elapsed, type, timeout)
+      def format_timeout_result(command, stdout, stderr, elapsed, type, timeout, max_output_lines)
         {
           command: command,
-          stdout: stdout,
-          stderr: stderr.empty? ? "Command timed out after #{elapsed.round(1)} seconds (#{type}=#{timeout}s)" : stderr,
+          stdout: truncate_output(stdout, max_output_lines),
+          stderr: truncate_output(stderr.empty? ? "Command timed out after #{elapsed.round(1)} seconds (#{type}=#{timeout}s)" : stderr, max_output_lines),
           exit_code: -1,
           success: false,
           state: 'TIMEOUT',
-          timeout_type: type
+          timeout_type: type,
+          output_truncated: output_truncated?(stdout, stderr, max_output_lines)
         }
       end
 
+      # Truncate output to max_lines, adding a truncation notice if needed
+      def truncate_output(output, max_lines)
+        return output if output.nil? || output.empty?
+        
+        lines = output.lines
+        return output if lines.length <= max_lines
+        
+        truncated_lines = lines.first(max_lines)
+        truncation_notice = "\n\n... [Output truncated: showing #{max_lines} of #{lines.length} lines] ...\n"
+        truncated_lines.join + truncation_notice
+      end
+
+      # Check if output was truncated
+      def output_truncated?(stdout, stderr, max_lines)
+        stdout_lines = stdout&.lines&.length || 0
+        stderr_lines = stderr&.lines&.length || 0
+        stdout_lines > max_lines || stderr_lines > max_lines
+      end
+
       def format_call(args)
         cmd = args[:command] || args['command'] || ''
         cmd_parts = cmd.split

data/lib/clacky/ui/banner.rb

@@ -9,10 +9,10 @@ module Clacky
       LOGO = <<~'LOGO'
          ██████╗ ██████╗ ███████╗███╗   ██╗ ██████╗██╗      █████╗  ██████╗██╗  ██╗██╗   ██╗
         ██╔═══██╗██╔══██╗██╔════╝████╗  ██║██╔════╝██║     ██╔══██╗██╔════╝██║ ██╔╝╚██╗ ██╔╝
-        ██║   ██║██████╔╝█████╗  ██╔██╗ ██║██║     ██║     ███████║██║     █████╔╝  ╚████╔╝ 
-        ██║   ██║██╔═══╝ ██╔══╝  ██║╚██╗██║██║     ██║     ██╔══██║██║     ██╔═██╗   ╚██╔╝  
-        ╚██████╔╝██║     ███████╗██║ ╚████║╚██████╗███████╗██║  ██║╚██████╗██║  ██╗   ██║   
-         ╚═════╝ ╚═╝     ╚══════╝╚═╝  ╚═══╝ ╚═════╝╚══════╝╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝   ╚═╝   
+        ██║   ██║██████╔╝█████╗  ██╔██╗ ██║██║     ██║     ███████║██║     █████╔╝  ╚████╔╝
+        ██║   ██║██╔═══╝ ██╔══╝  ██║╚██╗██║██║     ██║     ██╔══██║██║     ██╔═██╗   ╚██╔╝
+        ╚██████╔╝██║     ███████╗██║ ╚████║╚██████╗███████╗██║  ██║╚██████╗██║  ██╗   ██║
+         ╚═════╝ ╚═╝     ╚══════╝╚═╝  ╚═══╝ ╚═════╝╚══════╝╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝   ╚═╝
       LOGO
 
       TAGLINE = "[>] AI Coding Assistant & Technical Co-founder"
@@ -72,25 +72,36 @@ module Clacky
       end
 
       # Display task completion summary
-      def display_task_complete(iterations:, cost:, total_tasks:, total_cost:, cache_stats: {})
+      def display_task_complete(iterations:, cost:, total_tasks:, total_cost:, cost_source:, cache_stats: {})
         puts
         puts separator("-")
         puts @pastel.bright_green("[✓] TASK COMPLETED")
         puts info_line("Iterations", iterations)
-        puts info_line("Cost", "$#{cost}")
+
+        # Add cost source indicator
+        cost_suffix = case cost_source
+                      when :api
+                        " (by API)"
+                      when :price
+                        " (by PRICE)"
+                      when :default
+                        " (by DEFAULT)"
+                      else
+                        " (estimated)"
+                      end
+        puts info_line("Cost", "$#{cost}#{cost_suffix}")
         puts info_line("Session Total", "#{total_tasks} tasks, $#{total_cost}")
-        
+
         # Display cache statistics if available
         if cache_stats[:total_requests] && cache_stats[:total_requests] > 0
           puts
           puts @pastel.cyan("    [Prompt Caching]")
-          puts info_line("  Cache Writes", "#{cache_stats[:cache_creation_input_tokens]} tokens")
-          puts info_line("  Cache Reads", "#{cache_stats[:cache_read_input_tokens]} tokens")
-          
+          puts info_line("  Cache Reads/Writes", "#{cache_stats[:cache_read_input_tokens]}/#{cache_stats[:cache_creation_input_tokens]} tokens")
+
           hit_rate = (cache_stats[:cache_hit_requests].to_f / cache_stats[:total_requests] * 100).round(1)
           puts info_line("  Cache Hit Rate", "#{hit_rate}% (#{cache_stats[:cache_hit_requests]}/#{cache_stats[:total_requests]} requests)")
         end
-        
+
         puts separator("-")
         puts
       end