openclacky 0.5.3 → 0.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52ab39c40c69d821b45d01ed1d14086a50446309421891e9cd6724a9b32864cf
-  data.tar.gz: 0d61ef02a23f8a04157f8b7b2308a4f0c68fd37bba1407894b9841cd707c6873
+  metadata.gz: cc218b590b40d1a2301ef91a73b5a4ded7d6891da5b42eea62f4fa8bce200292
+  data.tar.gz: e828ac9fd724d0097f7557401127c513f35138c31d76a06e07c8c70db049cb1c
 SHA512:
-  metadata.gz: d654bd29a093bf23f1e0c162867251e08a28ec722deaae7a9d234f2aed913329d991df29391778612c458c51b6775881ee0867cb2d959c0f7072b14e662d0c38
-  data.tar.gz: 8056dff60d1c845751021e2c852e58071360c8d6a6b81cec72be238e647521ae36a211d72af88602239f8abcab5a15b7a345b8efd98e68b62a0a6dfde8a63b23
+  metadata.gz: 91db158259b243438e5af2fa26d257f30c4c5f755383e4bde6e20b71cf9e5481bc5b2d91cd5c63e5916ed8d6e373050e60dd16fd4b3a0231073702b75ad2702a
+  data.tar.gz: '0940f53a61a33f22de700c8609ede85e7d937f096688374eedef072758372f00e87fa6327050d323a7f5f3d869b487ff39bb942fe56534afe4a906b3b6cde494'

data/CHANGELOG.md

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.5.4] - 2026-01-16
+
+### Added
+- **Automatic Paste Detection**: Rapid input detection automatically identifies paste operations
+- **Word Wrap Display**: Long input lines automatically wrap with scroll indicators (up to 15 visible lines)
+- **Full-width Terminal Display**: Enhanced prompt box uses full terminal width for better visibility
+
+### Improved
+- **Smart Ctrl+C Handling**: First press clears content, second press (within 2s) exits
+- **UTF-8 Encoding**: Better handling of multi-byte characters in clipboard operations
+- **Cursor Positioning**: Improved cursor tracking in wrapped lines
+- **Multi-line Paste**: Better display for pasted content with placeholder support
+
 ## [0.5.0] - 2026-01-11
 
 ### Added

data/README.md

@@ -6,6 +6,8 @@ A command-line interface for interacting with AI models. OpenClacky supports Ope
 
 - 💬 Interactive chat sessions with AI models
 - 🤖 Autonomous AI agent with tool use capabilities
+- 📝 Enhanced input with multi-line support and Unicode (Chinese, etc.)
+- 🖼️ Paste images from clipboard (macOS/Linux)
 - 🚀 Single-message mode for quick queries
 - 🔐 Secure API key management
 - 📝 Multi-turn conversation support

data/Rakefile

@@ -5,10 +5,6 @@ require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
 
-require "rubocop/rake_task"
-
-RuboCop::RakeTask.new
-
 namespace :build do
   desc "Build both openclacky and clacky gems"
   task :all do
@@ -35,4 +31,4 @@ namespace :build do
   end
 end
 
-task default: %i[spec rubocop]
+task default: %i[spec]

data/lib/clacky/agent.rb

@@ -9,13 +9,7 @@ require_relative "utils/arguments_parser"
 module Clacky
   class Agent
     attr_reader :session_id, :messages, :iterations, :total_cost, :working_dir, :created_at, :total_tasks, :todos,
-                :cache_stats
-
-    # Pricing per 1M tokens (approximate - adjust based on actual model)
-    PRICING = {
-      input: 0.50,  # $0.50 per 1M input tokens
-      output: 1.50  # $1.50 per 1M output tokens
-    }.freeze
+                :cache_stats, :cost_source
 
     # System prompt for the coding agent
     SYSTEM_PROMPT = <<~PROMPT.freeze
@@ -76,6 +70,8 @@ module Clacky
       @working_dir = working_dir || Dir.pwd
       @created_at = Time.now.iso8601
       @total_tasks = 0
+      @cost_source = :estimated  # Track whether cost is from API or estimated
+      @task_cost_source = :estimated  # Track cost source for current task
 
       # Register built-in tools
       register_builtin_tools
@@ -133,6 +129,7 @@ module Clacky
 
     def run(user_input, &block)
       @start_time = Time.now
+      @task_cost_source = :estimated  # Reset for new task
 
       # Add system prompt as the first message if this is the first run
       if @messages.empty?
@@ -221,14 +218,14 @@ module Clacky
     # @param status [Symbol] Status of the last task: :success, :error, or :interrupted
     # @param error_message [String] Error message if status is :error
     def to_session_data(status: :success, error_message: nil)
-      # Get first real user message for preview (skip compressed system messages)
-      first_user_msg = @messages.find do |m|
+      # Get last real user message for preview (skip compressed system messages)
+      last_user_msg = @messages.reverse.find do |m|
         m[:role] == "user" && !m[:content].to_s.start_with?("[SYSTEM]")
       end
 
-      # Extract preview text from first user message
-      first_message_preview = if first_user_msg
-        content = first_user_msg[:content]
+      # Extract preview text from last user message
+      last_message_preview = if last_user_msg
+        content = last_user_msg[:content]
         if content.is_a?(String)
           # Truncate to 100 characters for preview
           content.length > 100 ? "#{content[0..100]}..." : content
@@ -270,7 +267,7 @@ module Clacky
         },
         stats: stats_data,
         messages: @messages,
-        first_user_message: first_message_preview
+        first_user_message: last_message_preview
       }
     end
 
@@ -613,9 +610,29 @@ module Clacky
     end
 
     def track_cost(usage)
-      input_cost = (usage[:prompt_tokens] / 1_000_000.0) * PRICING[:input]
-      output_cost = (usage[:completion_tokens] / 1_000_000.0) * PRICING[:output]
-      @total_cost += input_cost + output_cost
+      # Priority 1: Use API-provided cost if available (OpenRouter, LiteLLM, etc.)
+      if usage[:api_cost]
+        @total_cost += usage[:api_cost]
+        @cost_source = :api
+        @task_cost_source = :api
+        puts "[DEBUG] Using API-provided cost: $#{usage[:api_cost]}" if @config.verbose
+      else
+        # Priority 2: Calculate from tokens using ModelPricing
+        result = ModelPricing.calculate_cost(model: @config.model, usage: usage)
+        cost = result[:cost]
+        pricing_source = result[:source]
+        
+        @total_cost += cost
+        # Map pricing source to cost source: :price or :default
+        @cost_source = pricing_source
+        @task_cost_source = pricing_source
+        
+        if @config.verbose
+          source_label = pricing_source == :price ? "model pricing" : "default pricing"
+          puts "[DEBUG] Calculated cost for #{@config.model} using #{source_label}: $#{cost.round(6)}"
+          puts "[DEBUG] Usage breakdown: prompt=#{usage[:prompt_tokens]}, completion=#{usage[:completion_tokens]}, cache_write=#{usage[:cache_creation_input_tokens] || 0}, cache_read=#{usage[:cache_read_input_tokens] || 0}"
+        end
+      end
 
       # Track cache usage statistics
       @cache_stats[:total_requests] += 1
@@ -1081,6 +1098,7 @@ module Clacky
         iterations: @iterations,
         duration_seconds: Time.now - @start_time,
         total_cost_usd: @total_cost.round(4),
+        cost_source: @task_cost_source,  # Add cost source for this task
         cache_stats: @cache_stats,
         messages: @messages,
         error: error

data/lib/clacky/cli.rb

@@ -4,7 +4,7 @@ require "thor"
 require "tty-prompt"
 require "tty-spinner"
 require_relative "ui/banner"
-require_relative "ui/prompt"
+require_relative "ui/enhanced_prompt"
 require_relative "ui/statusbar"
 require_relative "ui/formatter"
 
@@ -14,41 +14,15 @@ module Clacky
       true
     end
 
-    desc "chat [MESSAGE]", "Start a chat with Claude or send a single message"
-    long_desc <<-LONGDESC
-      Start an interactive chat session with Claude AI.
-
-      If MESSAGE is provided, send it as a single message and exit.
-      If no MESSAGE is provided, start an interactive chat session.
-
-      Examples:
-        $ clacky chat "What is Ruby?"
-        $ clacky chat
-    LONGDESC
-    option :model, type: :string, desc: "Model to use (default from config)"
-    def chat(message = nil)
-      config = Clacky::Config.load
-
-      unless config.api_key
-        say "Error: API key not found. Please run 'clacky config set' first.", :red
-        exit 1
-      end
-
-      if message
-        # Single message mode
-        send_single_message(message, config)
-      else
-        # Interactive mode
-        start_interactive_chat(config)
-      end
-    end
+    # Set agent as the default command
+    default_task :agent
 
     desc "version", "Show clacky version"
     def version
       say "Clacky version #{Clacky::VERSION}"
     end
 
-    desc "agent [MESSAGE]", "Run agent in interactive mode with autonomous tool use"
+    desc "agent [MESSAGE]", "Run agent in interactive mode with autonomous tool use (default)"
     long_desc <<-LONGDESC
       Run an AI agent in interactive mode that can autonomously use tools to complete tasks.
 
@@ -159,44 +133,48 @@ module Clacky
       end
     end
 
-    desc "tools", "List available tools"
-    option :category, type: :string, desc: "Filter by category"
-    def tools
-      registry = ToolRegistry.new
-
-      registry.register(Tools::Shell.new)
-      registry.register(Tools::FileReader.new)
-      registry.register(Tools::Write.new)
-      registry.register(Tools::Edit.new)
-      registry.register(Tools::Glob.new)
-      registry.register(Tools::Grep.new)
-      registry.register(Tools::WebSearch.new)
-      registry.register(Tools::WebFetch.new)
-
-      say "\n📦 Available Tools:\n\n", :green
-
-      tools_to_show = if options[:category]
-                        registry.by_category(options[:category])
-                      else
-                        registry.all
-                      end
-
-      tools_to_show.each do |tool|
-        say "  #{tool.name}", :cyan
-        say "    #{tool.description}", :white
-        say "    Category: #{tool.category}", :yellow
-
-        if tool.parameters[:properties]
-          say "    Parameters:", :yellow
-          tool.parameters[:properties].each do |name, spec|
-            required = tool.parameters[:required]&.include?(name.to_s) ? " (required)" : ""
-            say "      - #{name}: #{spec[:description]}#{required}", :white
-          end
-        end
-        say ""
-      end
-
-      say "Total: #{tools_to_show.size} tools\n", :green
+    desc "price", "Show pricing information for AI models"
+    def price
+      say "\n💰 Model Pricing Information\n\n", :green
+      
+      say "Clacky supports three pricing modes when calculating API costs:\n\n", :white
+      
+      say "  1. ", :cyan
+      say "API-provided cost", :bold
+      say " (", :white
+      say ":api", :yellow
+      say ")", :white
+      say "\n     The most accurate - uses actual cost data from the API response", :white
+      say "\n     Supported by: OpenRouter, LiteLLM, and other compatible proxies\n\n"
+      
+      say "  2. ", :cyan
+      say "Model-specific pricing", :bold
+      say " (", :white
+      say ":price", :yellow
+      say ")", :white
+      say "\n     Uses official pricing from model providers (Claude models)", :white
+      say "\n     Includes tiered pricing and prompt caching discounts\n\n"
+      
+      say "  3. ", :cyan
+      say "Default fallback pricing", :bold
+      say " (", :white
+      say ":default", :yellow
+      say ")", :white
+      say "\n     Conservative estimates for unknown models", :white
+      say "\n     Input: $0.50/MTok, Output: $1.50/MTok\n\n"
+      
+      say "Priority order: API cost > Model pricing > Default pricing\n\n", :yellow
+      
+      say "Supported models with official pricing:\n", :green
+      say "  • claude-opus-4.5\n", :cyan
+      say "  • claude-sonnet-4.5\n", :cyan
+      say "  • claude-haiku-4.5\n", :cyan
+      say "  • claude-3-5-sonnet-20241022\n", :cyan
+      say "  • claude-3-5-sonnet-20240620\n", :cyan
+      say "  • claude-3-5-haiku-20241022\n\n", :cyan
+      
+      say "For detailed pricing information, visit:\n", :white
+      say "https://www.anthropic.com/pricing\n\n", :blue
     end
 
     no_commands do
@@ -408,8 +386,12 @@ module Clacky
               cost: total_cost
             )
 
-            # Use enhanced prompt with "You:" prefix
-            current_message = prompt.read_input(prefix: "You:")
+            # Use enhanced prompt with "❯" prefix
+            result = prompt.read_input(prefix: "❯")
+            
+            # EnhancedPrompt returns { text: String, images: Array } or nil
+            # For now, we only use the text part
+            current_message = result.nil? ? nil : result[:text]
 
             break if current_message.nil? || %w[exit quit].include?(current_message&.downcase&.strip)
             next if current_message.strip.empty?
@@ -438,6 +420,7 @@ module Clacky
               cost: result[:total_cost_usd].round(4),
               total_tasks: total_tasks,
               total_cost: total_cost.round(4),
+              cost_source: result[:cost_source],
               cache_stats: result[:cache_stats]
             )
           rescue Clacky::AgentInterrupted
@@ -613,7 +596,7 @@ module Clacky
       end
 
       def ui_prompt
-        @ui_prompt ||= UI::Prompt.new
+        @ui_prompt ||= UI::EnhancedPrompt.new
       end
 
       def ui_statusbar
@@ -628,68 +611,6 @@ module Clacky
         @pastel ||= Pastel.new
       end
     end
-
-    private
-
-    def send_single_message(message, config)
-      spinner = TTY::Spinner.new("[:spinner] Thinking...", format: :dots)
-      spinner.auto_spin
-
-      client = Clacky::Client.new(config.api_key, base_url: config.base_url)
-      response = client.send_message(message, model: options[:model] || config.model)
-
-      spinner.success("Done!")
-      say "\n#{response}", :cyan
-    rescue StandardError => e
-      spinner.error("Failed!")
-      say "Error: #{e.message}", :red
-      exit 1
-    end
-
-    def start_interactive_chat(config)
-      say "Starting interactive chat with Claude...", :green
-      say "Type 'exit' or 'quit' to end the session.\n\n", :yellow
-
-      conversation = Clacky::Conversation.new(
-        config.api_key,
-        model: options[:model] || config.model,
-        base_url: config.base_url
-      )
-
-      # Use TTY::Prompt for input
-      tty_prompt = TTY::Prompt.new(interrupt: :exit)
-
-      loop do
-        # Use TTY::Prompt for better input handling
-        begin
-          message = tty_prompt.ask("You:", required: false) do |q|
-            q.modify :strip
-          end
-        rescue TTY::Reader::InputInterrupt
-          # Handle Ctrl+C
-          puts
-          break
-        end
-
-        break if message.nil? || %w[exit quit].include?(message&.downcase&.strip)
-        next if message.nil? || message.strip.empty?
-
-        spinner = TTY::Spinner.new("[:spinner] Claude is thinking...", format: :dots)
-        spinner.auto_spin
-
-        begin
-          response = conversation.send_message(message)
-          spinner.success("Claude:")
-          say response, :cyan
-          say "\n"
-        rescue StandardError => e
-          spinner.error("Error!")
-          say "Error: #{e.message}", :red
-        end
-      end
-
-      say "\nGoodbye!", :green
-    end
   end
 
   class ConfigCommand < Thor

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/gitignore_parser.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Clacky
+  # Parser for .gitignore files to determine which files should be ignored
+  class GitignoreParser
+    attr_reader :patterns
+
+    def initialize(gitignore_path = nil)
+      @patterns = []
+      @negation_patterns = []
+      
+      if gitignore_path && File.exist?(gitignore_path)
+        parse_gitignore(gitignore_path)
+      end
+    end
+
+    # Check if a file path should be ignored
+    def ignored?(path)
+      relative_path = path.start_with?('./') ? path[2..] : path
+      
+      # Check negation patterns first (! prefix in .gitignore)
+      @negation_patterns.each do |pattern|
+        return false if match_pattern?(relative_path, pattern)
+      end
+      
+      # Then check ignore patterns
+      @patterns.each do |pattern|
+        return true if match_pattern?(relative_path, pattern)
+      end
+      
+      false
+    end
+
+    private
+
+    def parse_gitignore(path)
+      File.readlines(path, chomp: true).each do |line|
+        # Skip comments and empty lines
+        next if line.strip.empty? || line.start_with?('#')
+        
+        # Handle negation patterns (lines starting with !)
+        if line.start_with?('!')
+          @negation_patterns << normalize_pattern(line[1..])
+        else
+          @patterns << normalize_pattern(line)
+        end
+      end
+    rescue StandardError => e
+      # If we can't parse .gitignore, just continue with empty patterns
+      warn "Warning: Failed to parse .gitignore: #{e.message}"
+    end
+
+    def normalize_pattern(pattern)
+      pattern = pattern.strip
+      
+      # Remove trailing whitespace
+      pattern = pattern.rstrip
+      
+      # Store original for directory detection
+      is_directory = pattern.end_with?('/')
+      pattern = pattern.chomp('/')
+      
+      {
+        pattern: pattern,
+        is_directory: is_directory,
+        is_absolute: pattern.start_with?('/'),
+        has_wildcard: pattern.include?('*') || pattern.include?('?'),
+        has_double_star: pattern.include?('**')
+      }
+    end
+
+    def match_pattern?(path, pattern_info)
+      pattern = pattern_info[:pattern]
+      
+      # Remove leading slash for absolute patterns
+      pattern = pattern[1..] if pattern_info[:is_absolute]
+      
+      # Handle directory patterns
+      if pattern_info[:is_directory]
+        return false unless File.directory?(path)
+      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 = 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 = Regexp.new("^#{regex_pattern}$")
+        return true if path.match?(regex)
+        return true if File.basename(path).match?(regex)
+      else
+        # Exact match
+        return true if path == pattern
+        return true if path.start_with?("#{pattern}/")
+        return true if File.basename(path) == pattern
+      end
+      
+      false
+    end
+  end
+end