openclacky 0.6.0 → 0.6.2

data/lib/clacky/agent.rb

@@ -4,8 +4,8 @@ require "securerandom"
 require "json"
 require "tty-prompt"
 require "set"
-require "base64"
 require_relative "utils/arguments_parser"
+require_relative "utils/file_processor"
 
 module Clacky
   class Agent
@@ -129,6 +129,33 @@ module Clacky
       end
     end
 
+    # Get recent user messages from conversation history
+    # @param limit [Integer] Number of recent user messages to retrieve (default: 5)
+    # @return [Array<String>] Array of recent user message contents
+    def get_recent_user_messages(limit: 5)
+      # Filter messages to only include real user messages (exclude system-injected ones)
+      user_messages = @messages.select do |m|
+        m[:role] == "user" && !m[:system_injected]
+      end
+
+      # Extract text content from the last N user messages
+      user_messages.last(limit).map do |msg|
+        extract_text_from_content(msg[:content])
+      end
+    end
+
+    private def extract_text_from_content(content)
+      if content.is_a?(String)
+        content
+      elsif content.is_a?(Array)
+        # Extract text from content array (may contain text and images)
+        text_parts = content.select { |c| c.is_a?(Hash) && c[:type] == "text" }
+        text_parts.map { |c| c[:text] }.join("\n")
+      else
+        content.to_s
+      end
+    end
+
     def add_hook(event, &block)
       @hooks.add(event, &block)
     end
@@ -136,7 +163,18 @@ module Clacky
     def run(user_input, images: [])
       @start_time = Time.now
       @task_cost_source = :estimated  # Reset for new task
-      @previous_total_tokens = 0  # Reset token tracking for new task
+      # Note: Do NOT reset @previous_total_tokens here - it should maintain the value from the last iteration
+      # across tasks to correctly calculate delta tokens in each iteration
+      @task_start_iterations = @iterations  # Track starting iterations for this task
+      @task_start_cost = @total_cost  # Track starting cost for this task
+
+      # Track cache stats for current task
+      @task_cache_stats = {
+        cache_creation_input_tokens: 0,
+        cache_read_input_tokens: 0,
+        total_requests: 0,
+        cache_hit_requests: 0
+      }
 
       # Add system prompt as the first message if this is the first run
       if @messages.empty?
@@ -193,16 +231,17 @@ module Clacky
           if action_result[:denied]
             # If user provided feedback, treat it as a user question/instruction
             if action_result[:feedback] && !action_result[:feedback].empty?
-              # Add user feedback as a new user message
+              # Add user feedback as a new user message with system_injected marker
               @messages << {
                 role: "user",
-                content: "STOP. The user has a question/feedback for you: #{action_result[:feedback]}\n\nPlease respond to the user's question/feedback before continuing with any actions."
+                content: "STOP. The user has a question/feedback for you: #{action_result[:feedback]}\n\nPlease respond to the user's question/feedback before continuing with any actions.",
+                system_injected: true  # Mark as system-injected message for filtering
               }
               # Continue loop to let agent respond to feedback
               next
             else
               # User just said "no" without feedback - stop and wait
-              @ui&.show_assistant_message("Tool execution was denied. Please provide further instructions.")
+              @ui&.show_assistant_message("Tool execution was denied. Please give more instructions...")
               break
             end
           end
@@ -221,8 +260,8 @@ module Clacky
         # Let CLI handle the interrupt message
         raise
       rescue StandardError => e
+        # Build error result for session data, but let CLI handle error display
         result = build_result(:error, error: e.message)
-        @ui&.show_error("Error: #{e.message}")
         raise
       end
     end
@@ -405,8 +444,8 @@ module Clacky
         end
       end
 
-      # Stop progress thread (but keep progress line visible)
-      @ui&.stop_progress_thread
+      # Clear progress indicator (change to gray and show final time)
+      @ui&.clear_progress
 
       track_cost(response[:usage], raw_api_usage: response[:raw_api_usage])
 
@@ -494,7 +533,13 @@ module Clacky
 
           confirmation = confirm_tool_use?(call)
           unless confirmation[:approved]
-            @ui&.show_warning("Tool #{call[:name]} denied")
+            # Show denial warning with user feedback if provided
+            denial_message = "Tool #{call[:name]} denied"
+            if confirmation[:feedback] && !confirmation[:feedback].empty?
+              denial_message += ": #{confirmation[:feedback]}"
+            end
+            @ui&.show_warning(denial_message)
+
             denied = true
             user_feedback = confirmation[:feedback]
             feedback = user_feedback if user_feedback
@@ -526,8 +571,17 @@ module Clacky
             args[:todos_storage] = @todos
           end
 
+          # Show progress for potentially slow tools (no prefix newline)
+          if potentially_slow_tool?(call[:name], args)
+            progress_message = build_tool_progress_message(call[:name], args)
+            @ui&.show_progress(progress_message, prefix_newline: false)
+          end
+
           result = tool.execute(**args)
 
+          # Clear progress if shown
+          @ui&.clear_progress if potentially_slow_tool?(call[:name], args)
+
           # Hook: after_tool_use
           @hooks.trigger(:after_tool_use, call, result)
 
@@ -606,6 +660,49 @@ module Clacky
       false
     end
 
+    # Check if a tool is potentially slow and should show progress
+    private def potentially_slow_tool?(tool_name, args)
+      case tool_name.to_s.downcase
+      when 'shell', 'safe_shell'
+        # Check if the command is a slow command
+        command = args[:command] || args['command']
+        return false unless command
+
+        # List of slow command patterns
+        slow_patterns = [
+          /bundle\s+(install|exec\s+rspec|exec\s+rake)/,
+          /npm\s+(install|run\s+test|run\s+build)/,
+          /yarn\s+(install|test|build)/,
+          /pnpm\s+install/,
+          /cargo\s+(build|test)/,
+          /go\s+(build|test)/,
+          /make\s+(test|build)/,
+          /pytest/,
+          /jest/
+        ]
+
+        slow_patterns.any? { |pattern| command.match?(pattern) }
+      when 'web_fetch', 'web_search'
+        true  # Network operations can be slow
+      else
+        false  # Most file operations are fast
+      end
+    end
+
+    # Build progress message for tool execution
+    private def build_tool_progress_message(tool_name, args)
+      case tool_name.to_s.downcase
+      when 'shell', 'safe_shell'
+        "Running command"
+      when 'web_fetch'
+        "Fetching web page"
+      when 'web_search'
+        "Searching web"
+      else
+        "Executing #{tool_name}"
+      end
+    end
+
     def track_cost(usage, raw_api_usage: nil)
       # Priority 1: Use API-provided cost if available (OpenRouter, LiteLLM, etc.)
       iteration_cost = nil
@@ -637,7 +734,7 @@ module Clacky
       # Display token usage statistics for this iteration
       display_iteration_tokens(usage, iteration_cost)
 
-      # Track cache usage statistics
+      # Track cache usage statistics (global)
       @cache_stats[:total_requests] += 1
 
       if usage[:cache_creation_input_tokens]
@@ -655,6 +752,20 @@ module Clacky
         @cache_stats[:raw_api_usage_samples] << raw_api_usage
         @cache_stats[:raw_api_usage_samples] = @cache_stats[:raw_api_usage_samples].last(3)
       end
+
+      # Track cache usage for current task
+      if @task_cache_stats
+        @task_cache_stats[:total_requests] += 1
+
+        if usage[:cache_creation_input_tokens]
+          @task_cache_stats[:cache_creation_input_tokens] += usage[:cache_creation_input_tokens]
+        end
+
+        if usage[:cache_read_input_tokens]
+          @task_cache_stats[:cache_read_input_tokens] += usage[:cache_read_input_tokens]
+          @task_cache_stats[:cache_hit_requests] += 1
+        end
+      end
     end
 
     # Display token usage for current iteration
@@ -843,7 +954,8 @@ module Clacky
 
       {
         role: "user",
-        content: "[SYSTEM] " + summary_text
+        content: "[SYSTEM] " + summary_text,
+        system_injected: true
       }
     end
 
@@ -867,9 +979,14 @@ module Clacky
         when true
           { approved: true, feedback: nil }
         when false, nil
+          # User denied - add visual marker based on tool type
+          tool_name_capitalized = call[:name].capitalize
+          @ui&.show_info("  ↳ #{tool_name_capitalized} cancelled", prefix_newline: false)
           { approved: false, feedback: nil }
         else
-          # String feedback
+          # String feedback - also add visual marker
+          tool_name_capitalized = call[:name].capitalize
+          @ui&.show_info("  ↳ #{tool_name_capitalized} cancelled", prefix_newline: false)
           { approved: false, feedback: result.to_s }
         end
       else
@@ -1079,14 +1196,20 @@ module Clacky
     end
 
     def build_result(status, error: nil)
+      # Calculate iterations for current task only
+      task_iterations = @iterations - (@task_start_iterations || 0)
+
+      # Calculate cost for current task only
+      task_cost = @total_cost - (@task_start_cost || 0)
+
       {
         status: status,
         session_id: @session_id,
-        iterations: @iterations,
+        iterations: task_iterations,  # Show only current task iterations
         duration_seconds: Time.now - @start_time,
-        total_cost_usd: @total_cost.round(4),
+        total_cost_usd: task_cost.round(4),  # Show only current task cost
         cost_source: @task_cost_source,  # Add cost source for this task
-        cache_stats: @cache_stats,
+        cache_stats: @task_cache_stats || @cache_stats,  # Use task cache stats if available
         messages: @messages,
         error: error
       }
@@ -1132,64 +1255,13 @@ module Clacky
       content << { type: "text", text: text } unless text.nil? || text.empty?
 
       images.each do |image_path|
-        image_url = image_path_to_data_url(image_path)
+        image_url = Utils::FileProcessor.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

@@ -32,6 +32,10 @@ module Clacky
         confirm_edits   - Auto-approve read-only tools, confirm edits
         plan_only       - Generate plan without executing
 
+      UI themes:
+        hacker          - Matrix/hacker-style with bracket symbols (default)
+        minimal         - Clean, simple symbols
+
       Session management:
         -c, --continue  - Continue the most recent session for this directory
         -l, --list      - List recent sessions
@@ -42,6 +46,8 @@ module Clacky
     LONGDESC
     option :mode, type: :string, default: "confirm_safes",
            desc: "Permission mode: auto_approve, confirm_safes, confirm_edits, plan_only"
+    option :theme, type: :string, default: "hacker",
+           desc: "UI theme: hacker, minimal (default: hacker)"
     option :verbose, type: :boolean, aliases: "-v", default: false, desc: "Show detailed output"
     option :path, type: :string, desc: "Project directory path (defaults to current directory)"
     option :continue, type: :boolean, aliases: "-c", desc: "Continue most recent session"
@@ -82,11 +88,14 @@ module Clacky
       # Handle session loading/continuation
       session_manager = Clacky::SessionManager.new
       agent = nil
+      is_session_load = false
 
       if options[:continue]
         agent = load_latest_session(client, agent_config, session_manager, working_dir)
+        is_session_load = !agent.nil?
       elsif options[:attach]
         agent = load_session_by_number(client, agent_config, session_manager, working_dir, options[:attach])
+        is_session_load = !agent.nil?
       end
 
       # Create new agent if no session loaded
@@ -98,7 +107,7 @@ module Clacky
       Dir.chdir(working_dir) if should_chdir
 
       begin
-        run_agent_with_ui2(agent, working_dir, agent_config, message, session_manager, client)
+        run_agent_with_ui2(agent, working_dir, agent_config, message, session_manager, client, is_session_load: is_session_load)
       rescue StandardError => e
         # Save session on error
         if session_manager
@@ -124,6 +133,80 @@ module Clacky
       end
     end
 
+    desc "new PROJECT_NAME", "Create a new Rails project from the official template"
+    long_desc <<-LONGDESC
+      Create a new Rails project from the official template.
+
+      This command will:
+        1. Clone the template from git@github.com:clacky-ai/rails-template-7x-starter.git
+        2. Change into the project directory
+        3. Run bin/setup to install dependencies and configure the project
+
+      Example:
+        $ clacky new my_rails_app
+    LONGDESC
+    def new(project_name = nil)
+      unless project_name
+        say "Error: Project name is required.", :red
+        say "Usage: clacky new <project_name>", :yellow
+        exit 1
+      end
+
+      # Validate project name
+      unless project_name.match?(/^[a-zA-Z][a-zA-Z0-9_-]*$/)
+        say "Error: Invalid project name. Use only letters, numbers, underscores, and hyphens.", :red
+        exit 1
+      end
+
+      template_repo = "git@github.com:clacky-ai/rails-template-7x-starter.git"
+      current_dir = Dir.pwd
+      target_dir = File.join(current_dir, project_name)
+
+      # Check if target directory already exists
+      if Dir.exist?(target_dir)
+        say "Error: Directory '#{project_name}' already exists.", :red
+        exit 1
+      end
+
+      say "Creating new Rails project: #{project_name}", :green
+
+      # Clone the template repository
+      say "\n📦 Cloning template repository...", :cyan
+      clone_command = "git clone #{template_repo} #{project_name}"
+
+      clone_result = system(clone_command)
+
+      unless clone_result
+        say "\n❌ Failed to clone repository. Please check your git configuration and network connection.", :red
+        exit 1
+      end
+
+      say "✓ Repository cloned successfully", :green
+
+      # Run bin/setup
+      say "\n⚙️  Running bin/setup...", :cyan
+
+      Dir.chdir(target_dir)
+
+      setup_command = "./bin/setup"
+
+      setup_result = system(setup_command)
+
+      Dir.chdir(current_dir)
+
+      unless setup_result
+        say "\n❌ Failed to run bin/setup. Please check the setup script for errors.", :red
+        say "You can try running it manually:", :yellow
+        say "  cd #{project_name} && ./bin/setup", :cyan
+        exit 1
+      end
+
+      say "\n✅ Project '#{project_name}' created successfully!", :green
+      say "\nNext steps:", :green
+      say "  cd #{project_name}", :cyan
+      say "  clacky agent", :cyan
+    end
+
     desc "price", "Show pricing information for AI models"
     def price
       say "\n💰 Model Pricing Information\n\n", :green
@@ -231,7 +314,7 @@ module Clacky
           return nil
         end
 
-        say "Loading latest session: #{session_data[:session_id][0..7]}", :green
+        # Don't print message here - will be shown by UI after banner
         Clacky::Agent.from_session(client, agent_config, session_data)
       end
 
@@ -276,7 +359,7 @@ module Clacky
           end
         end
 
-        say "Loading session: #{session_data[:session_id][0..7]}", :green
+        # Don't print message here - will be shown by UI after banner
         Clacky::Agent.from_session(client, agent_config, session_data)
       end
 
@@ -296,12 +379,21 @@ module Clacky
       end
 
       # Run agent with UI2 split-screen interface
-      def run_agent_with_ui2(agent, working_dir, agent_config, initial_message = nil, session_manager = nil, client = nil)
+      def run_agent_with_ui2(agent, working_dir, agent_config, initial_message = nil, session_manager = nil, client = nil, is_session_load: false)
+        # Validate theme
+        theme_name = options[:theme] || "hacker"
+        available_themes = UI2::ThemeManager.available_themes.map(&:to_s)
+        unless available_themes.include?(theme_name)
+          say "Error: Unknown theme '#{theme_name}'. Available themes: #{available_themes.join(', ')}", :red
+          exit 1
+        end
+
         # Create UI2 controller with configuration
         ui_controller = UI2::UIController.new(
           working_dir: working_dir,
           mode: agent_config.permission_mode.to_s,
-          model: agent_config.model
+          model: agent_config.model,
+          theme: theme_name
         )
 
         # Inject UI into agent
@@ -359,6 +451,8 @@ module Clacky
             ui_controller.show_info("Session cleared. Starting fresh.")
             # Update session bar with reset values
             ui_controller.update_sessionbar(tasks: agent.total_tasks, cost: agent.total_cost)
+            # Clear todo area display
+            ui_controller.update_todos([])
             next
           when "/exit", "/quit"
             ui_controller.stop
@@ -400,7 +494,12 @@ module Clacky
         end
 
         # Initialize UI screen first
-        ui_controller.initialize_and_show_banner
+        if is_session_load
+          recent_user_messages = agent.get_recent_user_messages(limit: 5)
+          ui_controller.initialize_and_show_banner(recent_user_messages: recent_user_messages)
+        else
+          ui_controller.initialize_and_show_banner
+        end
 
         # If there's an initial message, process it
         if initial_message && !initial_message.strip.empty?

data/lib/clacky/tools/file_reader.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "base"
+require_relative "../utils/file_processor"
 
 module Clacky
   module Tools
@@ -23,6 +24,8 @@ module Clacky
         },
         required: ["path"]
       }
+      
+
 
       def execute(path:, max_lines: 1000)
         # Expand ~ to home directory
@@ -50,6 +53,12 @@ module Clacky
         end
 
         begin
+          # Check if file is binary
+          if binary_file?(expanded_path)
+            return handle_binary_file(expanded_path)
+          end
+          
+          # Read text file
           lines = File.readlines(expanded_path).first(max_lines)
           content = lines.join
           truncated = File.readlines(expanded_path).size > max_lines
@@ -86,16 +95,140 @@ module Clacky
           return "Listed #{entries} entries (#{dirs} directories, #{files} files)"
         end
 
-        # Handle file reading
+        # Handle binary file
+        if result[:binary] || result['binary']
+          format_type = result[:format] || result['format'] || 'unknown'
+          size = result[:size_bytes] || result['size_bytes'] || 0
+          
+          # Check if it has base64 data (LLM-compatible format)
+          if result[:base64_data] || result['base64_data']
+            size_warning = size > 5_000_000 ? " (WARNING: large file)" : ""
+            return "Binary file (#{format_type}, #{format_file_size(size)}) - sent to LLM#{size_warning}"
+          else
+            return "Binary file (#{format_type}, #{format_file_size(size)}) - cannot be read as text"
+          end
+        end
+
+        # Handle text file reading
         lines = result[:lines_read] || result['lines_read'] || 0
         truncated = result[:truncated] || result['truncated']
         "Read #{lines} lines#{truncated ? ' (truncated)' : ''}"
       end
+      
+      # Format result for LLM - handles both text and binary (image/PDF) content
+      # This method is called by the agent to format tool results before sending to LLM
+      def format_result_for_llm(result)
+        # For LLM-compatible binary files with base64 data, return as content blocks
+        if result[:binary] && result[:base64_data]
+          # Create a text description
+          description = "File: #{result[:path]}\nType: #{result[:format]}\nSize: #{format_file_size(result[:size_bytes])}"
+          
+          # Add size warning for large files
+          if result[:size_bytes] > 5_000_000
+            description += "\nWARNING: Large file (>5MB) - may consume significant tokens"
+          end
+          
+          # For images, return both description and image content
+          if result[:mime_type]&.start_with?("image/")
+            return {
+              type: "image",
+              path: result[:path],
+              format: result[:format],
+              size_bytes: result[:size_bytes],
+              mime_type: result[:mime_type],
+              base64_data: result[:base64_data],
+              description: description
+            }
+          end
+          
+          # For PDFs and other binary formats, just return metadata with base64
+          return {
+            type: "document",
+            path: result[:path],
+            format: result[:format],
+            size_bytes: result[:size_bytes],
+            mime_type: result[:mime_type],
+            base64_data: result[:base64_data],
+            description: description
+          }
+        end
+        
+        # For other cases, return the result as-is (agent will JSON.generate it)
+        result
+      end
+
+      private def binary_file?(path)
+        # Use FileProcessor to detect binary files
+        File.open(path, 'rb') do |file|
+          sample = file.read(8192) || ""
+          Utils::FileProcessor.binary_file?(sample)
+        end
+      rescue StandardError
+        # If we can't read the file, assume it's not binary
+        false
+      end
+      
+      private def handle_binary_file(path)
+        # Check if it's a supported format using FileProcessor
+        if Utils::FileProcessor.supported_binary_file?(path)
+          # Use FileProcessor to convert to base64
+          begin
+            result = Utils::FileProcessor.file_to_base64(path)
+            {
+              path: path,
+              binary: true,
+              format: result[:format],
+              mime_type: result[:mime_type],
+              size_bytes: result[:size_bytes],
+              base64_data: result[:base64_data],
+              error: nil
+            }
+          rescue ArgumentError => e
+            # File too large or other error
+            file_size = File.size(path)
+            ext = File.extname(path).downcase
+            {
+              path: path,
+              binary: true,
+              format: ext.empty? ? "unknown" : ext[1..-1],
+              size_bytes: file_size,
+              content: nil,
+              error: e.message
+            }
+          end
+        else
+          # Binary file that we can't send to LLM
+          file_size = File.size(path)
+          ext = File.extname(path).downcase
+          {
+            path: path,
+            binary: true,
+            format: ext.empty? ? "unknown" : ext[1..-1],
+            size_bytes: file_size,
+            content: nil,
+            error: "Binary file detected. This format cannot be read as text. File size: #{format_file_size(file_size)}"
+          }
+        end
+      end
+      
+      private def detect_mime_type(path, data)
+        Utils::FileProcessor.detect_mime_type(path, data)
+      end
+      
+      private def format_file_size(bytes)
+        if bytes < 1024
+          "#{bytes} bytes"
+        elsif bytes < 1024 * 1024
+          "#{(bytes / 1024.0).round(2)} KB"
+        else
+          "#{(bytes / (1024.0 * 1024)).round(2)} MB"
+        end
+      end
 
       private
 
       # List first-level directory contents (files and directories)
-      def list_directory_contents(path)
+      private def list_directory_contents(path)
         begin
           entries = Dir.entries(path).reject { |entry| entry == "." || entry == ".." }