openclacky 0.5.4 → 0.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f86dc057b8fd69db07c40a5633ffe1350cf0ddb8509b6e26705464d9e127daa4
-  data.tar.gz: 58d3e6b89e129d6c7ef7dbc57ff57e95ee8d6acd96186491daa8670b6031c3b2
+  metadata.gz: 34f843ea474327ea95f88685111f1a86149730503625c5e971de239e63764969
+  data.tar.gz: 85f2e93d791d3f774aa4f0d29177d4999fd91306f3c441f21d89c11ab37f15d0
 SHA512:
-  metadata.gz: 4d724c3d9404faed0bead1fb3e417782f15a9d89dde03709696120df87230d7a6d33250684e96e99f13b87f3993bfffd53dc5b52c87c34e79844a171429685af
-  data.tar.gz: 837b07953b38515d0c1bf0b6081a1fd10e7fffa46f9cbf1d1721744cabe494c5a018bcb1d0290e988782a534aad9ab24137978d7299d1908cb9fb248258de282
+  metadata.gz: 8bcb13d8cb5ee790ff698fc9bd0be4d2b366e1d16216db6a2f24e56c0dc1954c3b82349473b49cdee7c66ae732e3b684ee1d249d54dabe0f7d9cb0cf1f59873b
+  data.tar.gz: 866e043424ca831364baba5a842b5554cc1da2309e2935a0458edbead75c5e89f9cdf146506df12fc04c87d78c5613e3b2e812b13a816864af5861b1f815c788

data/.clackyrules

@@ -25,6 +25,7 @@ It provides chat functionality and autonomous AI agent capabilities with tool us
 - **IMPORTANT**: All code comments must be written in English
 - Add descriptive comments for complex logic
 - Use clear, self-documenting code with English naming
+- **IMPORTANT**: Always use inline `private` with method definitions (e.g., `private def method_name`). Do NOT use standalone `private` keyword
 
 ### Architecture Patterns
 - Tools inherit from `Clacky::Tools::Base`
@@ -41,6 +42,9 @@ It provides chat functionality and autonomous AI agent capabilities with tool us
 - Maintain good test coverage
 - When modifying existing functionality, ensure related tests still pass
 - When adding new features, consider adding corresponding tests
+- **IMPORTANT**: When developing new features, write RSpec tests as needed and ensure they pass
+- **DO NOT** write custom test scripts unless explicitly requested by the user
+- **DO NOT** create markdown documentation unless explicitly requested by the user
 
 ### Tool Development
 When adding new tools:

data/README.md

@@ -1,6 +1,6 @@
 # OpenClacky
 
-A command-line interface for interacting with AI models. OpenClacky supports OpenAI-compatible APIs, making it easy to chat with various AI models directly from your terminal.
+OpenClacky = Lovable + Supabase
 
 ## Features
 

data/lib/clacky/agent.rb

@@ -4,18 +4,13 @@ require "securerandom"
 require "json"
 require "tty-prompt"
 require "set"
+require "base64"
 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 +71,9 @@ 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
+      @previous_total_tokens = 0  # Track tokens from previous iteration for delta calculation
 
       # Register built-in tools
       register_builtin_tools
@@ -131,8 +129,10 @@ module Clacky
       @hooks.add(event, &block)
     end
 
-    def run(user_input, &block)
+    def run(user_input, images: [], &block)
       @start_time = Time.now
+      @task_cost_source = :estimated  # Reset for new task
+      @previous_total_tokens = 0  # Reset token tracking for new task
 
       # Add system prompt as the first message if this is the first run
       if @messages.empty?
@@ -147,7 +147,9 @@ module Clacky
         @messages << system_message
       end
 
-      @messages << { role: "user", content: user_input }
+      # Format user message with images if provided
+      user_content = format_user_content(user_input, images)
+      @messages << { role: "user", content: user_content }
       @total_tasks += 1
 
       emit_event(:on_start, { input: user_input }, &block)
@@ -221,14 +223,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 +272,7 @@ module Clacky
         },
         stats: stats_data,
         messages: @messages,
-        first_user_message: first_message_preview
+        first_user_message: last_message_preview
       }
     end
 
@@ -613,9 +615,35 @@ 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.)
+      iteration_cost = nil
+      if usage[:api_cost]
+        @total_cost += usage[:api_cost]
+        @cost_source = :api
+        @task_cost_source = :api
+        iteration_cost = usage[:api_cost]
+        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
+        iteration_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
+
+      # Display token usage statistics for this iteration
+      display_iteration_tokens(usage, iteration_cost)
 
       # Track cache usage statistics
       @cache_stats[:total_requests] += 1
@@ -630,6 +658,66 @@ module Clacky
       end
     end
 
+    # Display token usage for current iteration
+    private def display_iteration_tokens(usage, cost)
+      prompt_tokens = usage[:prompt_tokens] || 0
+      completion_tokens = usage[:completion_tokens] || 0
+      total_tokens = usage[:total_tokens] || (prompt_tokens + completion_tokens)
+      cache_write = usage[:cache_creation_input_tokens] || 0
+      cache_read = usage[:cache_read_input_tokens] || 0
+
+      # Calculate token delta from previous iteration
+      delta_tokens = total_tokens - @previous_total_tokens
+      @previous_total_tokens = total_tokens  # Update for next iteration
+      
+      # Build token summary string
+      token_info = []
+
+      # Delta tokens with color coding at the beginning
+      require 'pastel'
+      pastel = Pastel.new
+      
+      delta_str = "+#{delta_tokens}"
+      colored_delta = if delta_tokens > 10000
+        pastel.red.bold(delta_str)  # Error level: red for > 10k
+      elsif delta_tokens > 5000
+        pastel.yellow.bold(delta_str)  # Warn level: yellow for > 5k
+      else
+        pastel.green(delta_str)  # Normal: green for <= 5k
+      end
+      
+      token_info << colored_delta
+
+      # Cache status indicator
+      cache_used = cache_read > 0 || cache_write > 0
+      if cache_used
+        cache_indicator = "✓ Cached"
+        token_info << pastel.cyan(cache_indicator)
+      end
+
+      # Input tokens (with cache breakdown if available)
+      if cache_write > 0 || cache_read > 0
+        input_detail = "#{prompt_tokens} (cache: #{cache_read} read, #{cache_write} write)"
+        token_info << "Input: #{input_detail}"
+      else
+        token_info << "Input: #{prompt_tokens}"
+      end
+
+      # Output tokens
+      token_info << "Output: #{completion_tokens}"
+
+      # Total
+      token_info << "Total: #{total_tokens}"
+
+      # Cost for this iteration
+      if cost
+        token_info << "Cost: $#{cost.round(6)}"
+      end
+
+      # Display with color
+      puts pastel.dim("    [Tokens] #{token_info.join(' | ')}")
+    end
+
     def compress_messages_if_needed
       # Check if compression is enabled
       return unless @config.enable_compression
@@ -1038,9 +1126,20 @@ module Clacky
     end
 
     def build_success_result(call, result)
+      # Try to get tool instance to use its format_result_for_llm method
+      tool = @tool_registry.get(call[:name]) rescue nil
+      
+      formatted_result = if tool && tool.respond_to?(:format_result_for_llm)
+        # Tool provides a custom LLM-friendly format
+        tool.format_result_for_llm(result)
+      else
+        # Fallback: use the original result
+        result
+      end
+      
       {
         id: call[:id],
-        content: JSON.generate(result)
+        content: JSON.generate(formatted_result)
       }
     end
 
@@ -1081,6 +1180,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
@@ -1115,5 +1215,76 @@ module Clacky
       @tool_registry.register(Tools::TodoManager.new)
       @tool_registry.register(Tools::RunProject.new)
     end
+
+    # Format user content with optional images
+    # @param text [String] User's text input
+    # @param images [Array<String>] Array of image file paths
+    # @return [String|Array] String if no images, Array with text and image_url objects if images present
+    def format_user_content(text, images)
+      return text if images.nil? || images.empty?
+
+      content = []
+      content << { type: "text", text: text } unless text.nil? || text.empty?
+
+      images.each do |image_path|
+        image_url = image_path_to_data_url(image_path)
+        content << { type: "image_url", image_url: { url: image_url } }
+      end
+
+      content
+    end
+
+    # Convert image file path to base64 data URL
+    # @param path [String] File path to image
+    # @return [String] base64 data URL (e.g., "data:image/png;base64,...")
+    def image_path_to_data_url(path)
+      unless File.exist?(path)
+        raise ArgumentError, "Image file not found: #{path}"
+      end
+
+      # Read file as binary
+      image_data = File.binread(path)
+
+      # Detect MIME type from file extension or content
+      mime_type = detect_image_mime_type(path, image_data)
+
+      # Encode to base64
+      base64_data = Base64.strict_encode64(image_data)
+
+      "data:#{mime_type};base64,#{base64_data}"
+    end
+
+    # Detect image MIME type
+    # @param path [String] File path
+    # @param data [String] Binary image data
+    # @return [String] MIME type (e.g., "image/png")
+    def detect_image_mime_type(path, data)
+      # Try to detect from file extension first
+      ext = File.extname(path).downcase
+      case ext
+      when ".png"
+        "image/png"
+      when ".jpg", ".jpeg"
+        "image/jpeg"
+      when ".gif"
+        "image/gif"
+      when ".webp"
+        "image/webp"
+      else
+        # Try to detect from file signature (magic bytes)
+        if data.start_with?("\x89PNG".b)
+          "image/png"
+        elsif data.start_with?("\xFF\xD8\xFF".b)
+          "image/jpeg"
+        elsif data.start_with?("GIF87a".b) || data.start_with?("GIF89a".b)
+          "image/gif"
+        elsif data.start_with?("RIFF".b) && data[8..11] == "WEBP".b
+          "image/webp"
+        else
+          # Default to png if unknown
+          "image/png"
+        end
+      end
+    end
   end
 end

data/lib/clacky/cli.rb

@@ -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.
 
@@ -133,7 +107,7 @@ module Clacky
 
       begin
         # Always run in interactive mode
-        run_agent_interactive(agent, working_dir, agent_config, message, session_manager)
+        run_agent_interactive(agent, working_dir, agent_config, message, session_manager, client)
       rescue StandardError => e
         # Save session on error
         if session_manager
@@ -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
@@ -353,7 +331,7 @@ module Clacky
         end
       end
 
-      def run_agent_interactive(agent, working_dir, agent_config, initial_message = nil, session_manager = nil)
+      def run_agent_interactive(agent, working_dir, agent_config, initial_message = nil, session_manager = nil, client = nil)
         # Store agent as instance variable for access in display methods
         @current_agent = agent
 
@@ -393,10 +371,13 @@ module Clacky
 
         # Process initial message if provided
         current_message = initial_message
+        current_images = []
 
         loop do
           # Get message from user if not provided
           unless current_message && !current_message.strip.empty?
+            # Only show newline separator if we've completed tasks
+            # (but not right after /clear since we just showed a message)
             say "\n" if total_tasks > 0
 
             # Show status bar before input
@@ -408,24 +389,87 @@ module Clacky
               cost: total_cost
             )
 
-            # Use enhanced prompt with "You:" prefix
-            result = prompt.read_input(prefix: "You:")
+            # Use enhanced prompt with "❯" prefix
+            result = prompt.read_input(prefix: "❯") do |display_lines|
+              # Shift+Tab pressed - toggle mode and update status bar
+              if agent_config.permission_mode == :confirm_safes
+                agent_config.permission_mode = :auto_approve
+              else
+                agent_config.permission_mode = :confirm_safes
+              end
+
+              # Update status bar (it's above the input box)
+              # display_lines includes the final newline, so we need display_lines moves to reach status bar
+              print "\e[#{display_lines}A"  # Move up to status bar line
+              print "\r\e[2K"  # Clear the status bar line
+
+              # Redisplay status bar with new mode (puts adds newline, cursor moves to next line)
+              statusbar.display(
+                working_dir: working_dir,
+                mode: agent_config.permission_mode.to_s,
+                model: agent_config.model,
+                tasks: total_tasks,
+                cost: total_cost
+              )
+
+              # Move back down to original position (display_lines - 1 because puts moved us down 1)
+              print "\e[#{display_lines - 1}B"
+            end
             
-            # EnhancedPrompt returns { text: String, images: Array } or nil
-            # For now, we only use the text part
-            current_message = result.nil? ? nil : result[:text]
+            # EnhancedPrompt returns:
+            # - { text: String, images: Array } for normal input
+            # - { command: Symbol } for commands
+            # - nil on EOF
+            if result.nil?
+              current_message = nil
+              current_images = []
+              break
+            elsif result[:command]
+              # Handle commands
+              case result[:command]
+              when :clear
+                # Clear session by creating a new agent
+                agent = Clacky::Agent.new(client, agent_config, working_dir: working_dir)
+                @current_agent = agent
+                total_tasks = 0
+                total_cost = 0.0
+                ui_formatter.info("Session cleared. Starting fresh.")
+                current_message = nil
+                current_images = []
+                next
+              when :exit
+                current_message = nil
+                current_images = []
+                break
+              end
+            else
+              # Normal input with text and optional images
+              current_message = result[:text]
+              current_images = result[:images] || []
+            end
 
             break if current_message.nil? || %w[exit quit].include?(current_message&.downcase&.strip)
-            next if current_message.strip.empty?
+            next if current_message.strip.empty? && current_images.empty?
 
             # Display user's message after input
             ui_formatter.user_message(current_message)
+
+            # Display image info if images were pasted (without extra newline)
+            if current_images.any?
+              current_images.each_with_index do |img_path, idx|
+                filename = File.basename(img_path)
+                say "  📎 Image #{idx + 1}: #{filename}", :cyan
+              end
+              puts  # Add newline after all images
+            else
+              puts  # Add newline after user message if no images
+            end
           end
 
           total_tasks += 1
 
           begin
-            result = agent.run(current_message) do |event|
+            result = agent.run(current_message, images: current_images) do |event|
               display_agent_event(event)
             end
 
@@ -442,6 +486,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
@@ -470,12 +515,14 @@ module Clacky
             say "\nOr you can continue with a new task or type 'exit' to quit.", :yellow
           end
 
-          # Clear current_message to prompt for next input
+          # Clear current_message and current_images to prompt for next input
           current_message = nil
+          current_images = []
         end
 
-        # Save final session state
-        if session_manager
+        # Save final session state only if there were actual tasks
+        # Don't save empty sessions where user just started and exited
+        if session_manager && total_tasks > 0
           session_manager.save(agent.to_session_data)
         end
 
@@ -632,68 +679,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