openclacky 0.6.1 → 0.6.3

data/lib/clacky/agent.rb

@@ -4,13 +4,13 @@ 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
     attr_reader :session_id, :messages, :iterations, :total_cost, :working_dir, :created_at, :total_tasks, :todos,
-                :cache_stats, :cost_source, :ui
+                :cache_stats, :cost_source, :ui, :skill_loader
 
     # System prompt for the coding agent
     SYSTEM_PROMPT = <<~PROMPT.freeze
@@ -49,6 +49,9 @@ module Clacky
       Adding todos is NOT completion - it's just the planning phase!
       Workflow: add todo 1 → add todo 2 → add todo 3 → START WORKING on todo 1 → complete(1) → work on todo 2 → complete(2) → etc.
       NEVER stop after just adding todos without executing them!
+
+      NOTE: Available skills are listed below in the AVAILABLE SKILLS section.
+      When a user's request matches a skill, you MUST use the skill tool instead of implementing it yourself.
     PROMPT
 
     def initialize(client, config = {}, working_dir: nil, ui: nil)
@@ -79,6 +82,13 @@ module Clacky
       @ui = ui  # UIController for direct UI interaction
       @debug_logs = []  # Debug logs for troubleshooting
 
+      # Compression tracking
+      @compression_level = 0  # Tracks how many times we've compressed (for progressive summarization)
+      @compressed_summaries = []  # Store summaries from previous compressions for reference
+
+      # Skill loader for skill management
+      @skill_loader = SkillLoader.new(@working_dir)
+
       # Register built-in tools
       register_builtin_tools
     end
@@ -108,6 +118,9 @@ module Clacky
         cache_hit_requests: 0
       }
 
+      # Restore previous_total_tokens for accurate delta calculation across sessions
+      @previous_total_tokens = session_data.dig(:stats, :previous_total_tokens) || 0
+
       # Check if the session ended with an error
       last_status = session_data.dig(:stats, :last_status)
       last_error = session_data.dig(:stats, :last_error)
@@ -137,7 +150,7 @@ module Clacky
       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])
@@ -163,10 +176,11 @@ 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,
@@ -265,6 +279,100 @@ module Clacky
       end
     end
 
+    # ===== Skill-related methods =====
+
+    # Get the skill loader instance
+    # @return [SkillLoader]
+    def skill_loader
+      @skill_loader
+    end
+
+    # Load all skills from configured locations
+    # @return [Array<Skill>]
+    def load_skills
+      @skill_loader.load_all
+    end
+
+    # Check if input is a skill command and process it
+    # @param input [String] User input
+    # @return [Hash, nil] Returns { skill: Skill, arguments: String } if skill command, nil otherwise
+    def parse_skill_command(input)
+      # Check for slash command pattern
+      if input.start_with?("/")
+        # Extract command and arguments
+        match = input.match(%r{^/(\S+)(?:\s+(.*))?$})
+        return nil unless match
+
+        skill_name = match[1]
+        arguments = match[2] || ""
+
+        # Find skill by command
+        skill = @skill_loader.find_by_command("/#{skill_name}")
+        return nil unless skill
+
+        # Check if user can invoke this skill
+        unless skill.user_invocable?
+          return nil
+        end
+
+        { skill: skill, arguments: arguments }
+      else
+        nil
+      end
+    end
+
+    # Execute a skill command
+    # @param input [String] User input (should be a skill command)
+    # @return [String] The expanded prompt with skill content
+    def execute_skill_command(input)
+      parsed = parse_skill_command(input)
+      return input unless parsed
+
+      skill = parsed[:skill]
+      arguments = parsed[:arguments]
+
+      # Process skill content with arguments
+      expanded_content = skill.process_content(arguments)
+
+      # Log skill usage
+      @ui&.log("Executing skill: #{skill.identifier}", level: :info)
+
+      expanded_content
+    end
+
+    # Generate skill context - loads all auto-invocable skills
+    # @return [String] Skill context to add to system prompt
+    def build_skill_context
+      # Load all auto-invocable skills
+      all_skills = @skill_loader.load_all
+      auto_invocable = all_skills.select(&:model_invocation_allowed?)
+
+      return "" if auto_invocable.empty?
+
+      context = "\n\n" + "=" * 80 + "\n"
+      context += "AVAILABLE SKILLS:\n"
+      context += "=" * 80 + "\n\n"
+      context += "CRITICAL SKILL USAGE RULES:\n"
+      context += "- When a user's request matches any available skill, this is a BLOCKING REQUIREMENT:\n"
+      context += "  invoke the relevant skill tool BEFORE generating any other response about the task\n"
+      context += "- NEVER mention a skill without actually calling the skill tool\n"
+      context += "- NEVER implement the skill's functionality yourself - always delegate to the skill\n"
+      context += "- Skills provide specialized capabilities - use them instead of manual implementation\n"
+      context += "- When users reference '/<skill-name>' (e.g., '/pptx'), they are requesting a skill\n\n"
+      context += "Workflow: Use file_reader to read the SKILL.md file, then follow its instructions.\n\n"
+      context += "Available skills:\n\n"
+
+      auto_invocable.each do |skill|
+        skill_md_path = skill.directory.join("SKILL.md")
+        context += "- name: #{skill.identifier}\n"
+        context += "  description: #{skill.context_description}\n"
+        context += "  SKILL.md: #{skill_md_path}\n\n"
+      end
+
+      context += "\n"
+      context
+    end
+
     # Generate session data for saving
     # @param status [Symbol] Status of the last task: :success, :error, or :interrupted
     # @param error_message [String] Error message if status is :error
@@ -294,7 +402,8 @@ module Clacky
         duration_seconds: @start_time ? (Time.now - @start_time).round(2) : 0,
         last_status: status.to_s,
         cache_stats: @cache_stats,
-        debug_logs: @debug_logs
+        debug_logs: @debug_logs,
+        previous_total_tokens: @previous_total_tokens
       }
 
       # Add error message if status is error
@@ -406,6 +515,10 @@ module Clacky
         prompt += "=" * 80
       end
 
+      # Add all loaded skills to system prompt
+      skill_context = build_skill_context
+      prompt += skill_context if skill_context && !skill_context.empty?
+
       prompt
     end
 
@@ -538,7 +651,7 @@ module Clacky
               denial_message += ": #{confirmation[:feedback]}"
             end
             @ui&.show_warning(denial_message)
-            
+
             denied = true
             user_feedback = confirmation[:feedback]
             feedback = user_feedback if user_feedback
@@ -570,6 +683,11 @@ module Clacky
             args[:todos_storage] = @todos
           end
 
+          # For safe_shell, skip safety check if user has already confirmed
+          if call[:name] == "safe_shell" || call[:name] == "shell"
+            args[:skip_safety_check] = true
+          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)
@@ -592,6 +710,17 @@ module Clacky
           @ui&.show_tool_result(tool.format_result(result))
           results << build_success_result(call, result)
         rescue StandardError => e
+          # Log complete error information to debug_logs for troubleshooting
+          @debug_logs << {
+            timestamp: Time.now.iso8601,
+            event: "tool_execution_error",
+            tool_name: call[:name],
+            tool_args: call[:arguments],
+            error_class: e.class.name,
+            error_message: e.message,
+            backtrace: e.backtrace&.first(20) # Keep first 20 lines of backtrace
+          }
+          
           @hooks.trigger(:on_tool_error, call, e)
           @ui&.show_tool_error(e)
           results << build_error_result(call, e.message)
@@ -666,7 +795,7 @@ module Clacky
         # 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)/,
@@ -679,7 +808,7 @@ module Clacky
           /pytest/,
           /jest/
         ]
-        
+
         slow_patterns.any? { |pattern| command.match?(pattern) }
       when 'web_fetch', 'web_search'
         true  # Network operations can be slow
@@ -692,11 +821,7 @@ module Clacky
     private def build_tool_progress_message(tool_name, args)
       case tool_name.to_s.downcase
       when 'shell', 'safe_shell'
-        command = args[:command] || args['command']
-        # Extract the main command for display
-        cmd_parts = command.to_s.split
-        main_cmd = cmd_parts.first(2).join(' ')
-        "Running #{main_cmd}"
+        "Running command"
       when 'web_fetch'
         "Fetching web page"
       when 'web_search'
@@ -755,15 +880,15 @@ 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
@@ -798,41 +923,430 @@ module Clacky
       @ui&.show_token_usage(token_data)
     end
 
+    # Estimate token count for a message content
+    # Simple approximation: characters / 4 (English text)
+    # For Chinese/other languages, characters / 2 is more accurate
+    # This is a rough estimate for compression triggering purposes
+    private def estimate_tokens(content)
+      return 0 if content.nil?
+
+      text = if content.is_a?(String)
+               content
+             elsif content.is_a?(Array)
+               # Handle content arrays (e.g., with images)
+               # Add safety check to prevent nil.compact error
+               mapped = content.map { |c| c[:text] if c.is_a?(Hash) }
+               (mapped || []).compact.join
+             else
+               content.to_s
+             end
+
+      return 0 if text.empty?
+
+      # Detect language mix - count non-ASCII characters
+      ascii_count = text.bytes.count { |b| b < 128 }
+      total_bytes = text.bytes.length
+
+      # Mix ratio (1.0 = all English, 0.5 = all Chinese)
+      mix_ratio = total_bytes > 0 ? ascii_count.to_f / total_bytes : 1.0
+
+      # English: ~4 chars/token, Chinese: ~2 chars/token
+      base_chars_per_token = mix_ratio * 4 + (1 - mix_ratio) * 2
+
+      (text.length / base_chars_per_token).to_i + 50 # Add overhead for message structure
+    end
+
+    # Calculate total token count for all messages
+    # Returns estimated tokens and breakdown by category
+    private def total_message_tokens
+      system_tokens = 0
+      user_tokens = 0
+      assistant_tokens = 0
+      tool_tokens = 0
+      summary_tokens = 0
+
+      @messages.each do |msg|
+        tokens = estimate_tokens(msg[:content])
+        case msg[:role]
+        when "system"
+          system_tokens += tokens
+        when "user"
+          user_tokens += tokens
+        when "assistant"
+          assistant_tokens += tokens
+        when "tool"
+          tool_tokens += tokens
+        end
+      end
+
+      {
+        total: system_tokens + user_tokens + assistant_tokens + tool_tokens,
+        system: system_tokens,
+        user: user_tokens,
+        assistant: assistant_tokens,
+        tool: tool_tokens
+      }
+    end
+
+    # Compression thresholds
+    COMPRESSION_THRESHOLD = 80_000  # Trigger compression when exceeding this (in tokens)
+    MESSAGE_COUNT_THRESHOLD = 100   # Trigger compression when exceeding this (in message count)
+    TARGET_COMPRESSED_TOKENS = 70_000  # Target size after compression
+    MAX_RECENT_MESSAGES = 30  # Keep this many recent message pairs intact
+
     def compress_messages_if_needed
       # Check if compression is enabled
       return unless @config.enable_compression
 
-      # Only compress if we have more messages than threshold
-      threshold = @config.keep_recent_messages + 80 # +80 to trigger at ~100 messages
-      return if @messages.size <= threshold
+      # Calculate total tokens and message count
+      token_counts = total_message_tokens
+      total_tokens = token_counts[:total]
+      message_count = @messages.length
+
+      # Check if we should trigger compression
+      # Either: token count exceeds threshold OR message count exceeds threshold
+      token_threshold_exceeded = total_tokens >= COMPRESSION_THRESHOLD
+      message_count_exceeded = message_count >= MESSAGE_COUNT_THRESHOLD
+
+      # Only compress if we exceed at least one threshold
+      return unless token_threshold_exceeded || message_count_exceeded
+
+      # Calculate how much we need to reduce
+      reduction_needed = total_tokens - TARGET_COMPRESSED_TOKENS
+
+      # Don't compress if reduction is minimal (< 10% of current size)
+      # Only apply this check when triggered by token threshold
+      if token_threshold_exceeded && reduction_needed < (total_tokens * 0.1)
+        return
+      end
+
+      # If only message count threshold is exceeded, force compression
+      # to keep conversation history manageable
+
+      # Calculate target size for recent messages based on compression level
+      target_recent_count = calculate_target_recent_count(reduction_needed)
 
-      original_size = @messages.size
-      target_size = @config.keep_recent_messages + 2
+      # Increment compression level for progressive summarization
+      @compression_level += 1
 
-      @ui&.show_info("Compressing history (#{original_size} -> ~#{target_size} messages)...")
+      original_tokens = total_tokens
+
+      @ui&.show_info("Compressing history (~#{original_tokens} tokens -> ~#{TARGET_COMPRESSED_TOKENS} tokens)...")
+      @ui&.show_info("Compression level: #{@compression_level}")
 
       # Find the system message (should be first)
       system_msg = @messages.find { |m| m[:role] == "system" }
 
       # Get the most recent N messages, ensuring tool_calls/tool results pairs are kept together
-      recent_messages = get_recent_messages_with_tool_pairs(@messages, @config.keep_recent_messages)
+      recent_messages = get_recent_messages_with_tool_pairs(@messages, target_recent_count)
+      recent_messages = [] if recent_messages.nil?
 
       # Get messages to compress (everything except system and recent)
       messages_to_compress = @messages.reject { |m| m[:role] == "system" || recent_messages.include?(m) }
 
+      @ui&.show_info("  debug: total=#{@messages.size}, recent=#{recent_messages.size}, to_compress=#{messages_to_compress.size}")
+
       return if messages_to_compress.empty?
 
-      # Create summary of compressed messages
-      summary = summarize_messages(messages_to_compress)
+      # Create hierarchical summary based on compression level
+      summary = generate_hierarchical_summary(messages_to_compress)
 
       # Rebuild messages array: [system, summary, recent_messages]
       rebuilt_messages = [system_msg, summary, *recent_messages].compact
 
       @messages = rebuilt_messages
 
-      final_size = @messages.size
+      # Track this compression for progressive summarization
+      @compressed_summaries << {
+        level: @compression_level,
+        message_count: messages_to_compress.size,
+        timestamp: Time.now.iso8601
+      }
+
+      final_tokens = total_message_tokens[:total]
+
+      @ui&.show_info("Compressed (~#{original_tokens} -> ~#{final_tokens} tokens, level #{@compression_level})")
+    end
+
+    # Calculate how many recent messages to keep based on how much we need to compress
+    private def calculate_target_recent_count(reduction_needed)
+      # We want recent messages to be around 20-30% of the total target
+      # This keeps the context window useful without being too large
+      tokens_per_message = 500  # Average estimate for a message with content
+
+      # Target recent messages budget (~20% of target compressed size)
+      recent_budget = (TARGET_COMPRESSED_TOKENS * 0.2).to_i
+      target_messages = (recent_budget / tokens_per_message).to_i
+
+      # Clamp to reasonable bounds
+      [[target_messages, 20].max, MAX_RECENT_MESSAGES].min
+    end
+
+    # Generate hierarchical summary based on compression level
+    # Level 1: Detailed summary with files, decisions, features
+    # Level 2: Concise summary with key items
+    # Level 3: Minimal summary (just project type)
+    # Level 4+: Ultra-minimal (single line)
+    private def generate_hierarchical_summary(messages)
+      level = @compression_level
+
+      # Extract key information from messages
+      extracted = extract_key_information(messages)
+
+      summary_text = case level
+      when 1
+        generate_level1_summary(extracted)
+      when 2
+        generate_level2_summary(extracted)
+      when 3
+        generate_level3_summary(extracted)
+      else
+        generate_level4_summary(extracted)
+      end
+
+      {
+        role: "user",
+        content: "[SYSTEM][COMPRESSION LEVEL #{level}] #{summary_text}",
+        system_injected: true,
+        compression_level: level
+      }
+    end
+
+    # Extract key information from messages for summarization
+    private def extract_key_information(messages)
+      return empty_extraction_data if messages.nil?
+
+      {
+        # Message counts
+        user_msgs: messages.count { |m| m[:role] == "user" },
+        assistant_msgs: messages.count { |m| m[:role] == "assistant" },
+        tool_msgs: messages.count { |m| m[:role] == "tool" },
+
+        # Tools used
+        tools_used: extract_from_messages(messages, :assistant) { |m| extract_tool_names(m[:tool_calls]) },
+
+        # Files created/modified
+        files_created: extract_from_messages(messages, :tool) { |m| filter_write_results(parse_write_result(m[:content]), :created) },
+        files_modified: extract_from_messages(messages, :tool) { |m| filter_write_results(parse_write_result(m[:content]), :modified) },
+
+        # Key decisions (limit to first 5)
+        decisions: extract_from_messages(messages, :assistant) { |m| extract_decision_text(m[:content]) }.first(5),
+
+        # Completed tasks (from TODO results)
+        completed_tasks: extract_from_messages(messages, :tool) { |m| filter_todo_results(parse_todo_result(m[:content]), :completed) },
+
+        # Current in-progress work
+        in_progress: find_in_progress(messages),
+
+        # Key results from shell commands
+        shell_results: extract_from_messages(messages, :tool) { |m| parse_shell_result(m[:content]) }
+      }
+    end
+
+    # Helper: safely extract from messages with proper nil handling
+    private def extract_from_messages(messages, role_filter = nil, &block)
+      return [] if messages.nil?
+
+      results = messages
+        .select { |m| role_filter.nil? || m[:role] == role_filter.to_s }
+        .map(&block)
+        .compact
+
+      # Flatten if we have nested arrays (from methods returning arrays of items)
+      results.any? { |r| r.is_a?(Array) } ? results.flatten.uniq : results.uniq
+    end
+
+    # Helper: extract tool names from tool_calls
+    private def extract_tool_names(tool_calls)
+      return [] unless tool_calls.is_a?(Array)
+      tool_calls.map { |tc| tc.dig(:function, :name) }
+    end
+
+    # Helper: filter write results by action
+    private def filter_write_results(result, action)
+      result && result[:action] == action ? result[:file] : nil
+    end
+
+    # Helper: filter todo results by status
+    private def filter_todo_results(result, status)
+      result && result[:status] == status ? result[:task] : nil
+    end
+
+    # Helper: extract decision text from content (returns array of decisions or empty array)
+    private def extract_decision_text(content)
+      return [] unless content.is_a?(String)
+      return [] unless content.include?("decision") || content.include?("chose to") || content.include?("using")
+
+      sentences = content.split(/[.!?]/).select do |s|
+        s.include?("decision") || s.include?("chose") || s.include?("using") ||
+        s.include?("decided") || s.include?("will use") || s.include?("selected")
+      end
+      sentences.map(&:strip).map { |s| s[0..100] }
+    end
+
+    # Helper: find in-progress task
+    private def find_in_progress(messages)
+      return nil if messages.nil?
+
+      messages.reverse_each do |m|
+        if m[:role] == "tool"
+          content = m[:content].to_s
+          if content.include?("in progress") || content.include?("working on")
+            return content[/[Tt]ODO[:\s]+(.+)/, 1]&.strip || content[/[Ww]orking[Oo]n[:\s]+(.+)/, 1]&.strip
+          end
+        end
+      end
+      nil
+    end
+
+    # Helper: empty extraction data
+    private def empty_extraction_data
+      {
+        user_msgs: 0,
+        assistant_msgs: 0,
+        tool_msgs: 0,
+        tools_used: [],
+        files_created: [],
+        files_modified: [],
+        decisions: [],
+        completed_tasks: [],
+        in_progress: nil,
+        shell_results: []
+      }
+    end
+
+    private def parse_write_result(content)
+      return nil unless content.is_a?(String)
+
+      # Check for "Created: path" or "Updated: path" patterns
+      if content.include?("Created:")
+        { action: "created", file: content[/Created:\s*(.+)/, 1]&.strip }
+      elsif content.include?("Updated:") || content.include?("modified")
+        { action: "modified", file: content[/Updated:\s*(.+)/, 1]&.strip || content[/File written to:\s*(.+)/, 1]&.strip }
+      else
+        nil
+      end
+    end
+
+    private def parse_todo_result(content)
+      return nil unless content.is_a?(String)
+
+      if content.include?("completed")
+        { status: "completed", task: content[/completed[:\s]*(.+)/i, 1]&.strip || "task" }
+      elsif content.include?("added")
+        { status: "added", task: content[/added[:\s]*(.+)/i, 1]&.strip || "task" }
+      else
+        nil
+      end
+    end
+
+    private def parse_shell_result(content)
+      return nil unless content.is_a?(String)
+
+      if content.include?("passed") || content.include?("success")
+        "tests passed"
+      elsif content.include?("failed") || content.include?("error")
+        "command failed"
+      elsif content =~ /bundle install|npm install|go mod download/
+        "dependencies installed"
+      elsif content.include?("Installed")
+        content[/Installed:\s*(.+)/, 1]&.strip
+      else
+        nil
+      end
+    end
+
+    # Level 1: Detailed summary (for first compression)
+    private def generate_level1_summary(data)
+      parts = []
+
+      parts << "Previous conversation summary (#{data[:user_msgs]} user requests, #{data[:assistant_msgs]} responses, #{data[:tool_msgs]} tool calls):"
+
+      # Files created
+      if data[:files_created].any?
+        files_list = data[:files_created].map { |f| File.basename(f) }.join(", ")
+        parts << "Created: #{files_list}"
+      end
+
+      # Files modified
+      if data[:files_modified].any?
+        files_list = data[:files_modified].map { |f| File.basename(f) }.join(", ")
+        parts << "Modified: #{files_list}"
+      end
+
+      # Completed tasks
+      if data[:completed_tasks].any?
+        tasks_list = data[:completed_tasks].first(3).join(", ")
+        parts << "Completed: #{tasks_list}"
+      end
+
+      # In progress
+      if data[:in_progress]
+        parts << "In Progress: #{data[:in_progress]}"
+      end
+
+      # Key decisions
+      if data[:decisions].any?
+        decisions_text = data[:decisions].map { |d| d.gsub(/\n/, " ").strip }.join("; ")
+        parts << "Decisions: #{decisions_text}"
+      end
+
+      # Tools used
+      if data[:tools_used].any?
+        parts << "Tools: #{data[:tools_used].join(', ')}"
+      end
+
+      parts << "Continuing with recent conversation..."
+      parts.join("\n")
+    end
+
+    # Level 2: Concise summary (for second compression)
+    private def generate_level2_summary(data)
+      parts = []
+
+      parts << "Conversation summary:"
+
+      # Key files (limit to most important)
+      all_files = (data[:files_created] + data[:files_modified]).uniq
+      if all_files.any?
+        key_files = all_files.first(5).map { |f| File.basename(f) }.join(", ")
+        parts << "Files: #{key_files}"
+      end
+
+      # Key accomplishments
+      accomplishments = []
+      accomplishments << "#{data[:completed_tasks].size} tasks completed" if data[:completed_tasks].any?
+      accomplishments << "#{data[:tool_msgs]} tools executed" if data[:tool_msgs] > 0
+      accomplishments << "Level #{data[:completed_tasks].size + 1} progress" if data[:in_progress]
+
+      parts << accomplishments.join(", ") if accomplishments.any?
+
+      parts << "Recent context follows..."
+      parts.join("\n")
+    end
+
+    # Level 3: Minimal summary (for third compression)
+    private def generate_level3_summary(data)
+      parts = []
 
-      @ui&.show_info("Compressed (#{original_size} -> #{final_size} messages)")
+      parts << "Project progress:"
+
+      # Just counts and key items
+      all_files = (data[:files_created] + data[:files_modified]).uniq
+      parts << "#{all_files.size} files modified, #{data[:completed_tasks].size} tasks done"
+
+      if data[:in_progress]
+        parts << "Currently: #{data[:in_progress]}"
+      end
+
+      parts << "See recent messages for details."
+      parts.join("\n")
+    end
+
+    # Level 4: Ultra-minimal summary (for fourth+ compression)
+    private def generate_level4_summary(data)
+      all_files = (data[:files_created] + data[:files_modified]).uniq
+      "Progress: #{data[:completed_tasks].size} tasks, #{all_files.size} files. Recent: #{data[:tools_used].last(3).join(', ')}"
     end
 
     def get_recent_messages_with_tool_pairs(messages, count)
@@ -840,7 +1354,7 @@ module Clacky
       # with ALL their corresponding tool_results, maintaining the correct order.
       # This is critical for Bedrock Claude API which validates the tool_calls/tool_results pairing.
 
-      return [] if messages.empty?
+      return [] if messages.nil? || messages.empty?
 
       # Track which messages to include
       messages_to_include = Set.new
@@ -926,41 +1440,6 @@ module Clacky
       messages_to_include.to_a.sort.map { |idx| messages[idx] }
     end
 
-    def summarize_messages(messages)
-      # Count different message types
-      user_msgs = messages.count { |m| m[:role] == "user" }
-      assistant_msgs = messages.count { |m| m[:role] == "assistant" }
-      tool_msgs = messages.count { |m| m[:role] == "tool" }
-
-      # Extract key information
-      tools_used = messages
-        .select { |m| m[:role] == "assistant" && m[:tool_calls] }
-        .flat_map { |m| m[:tool_calls].map { |tc| tc.dig(:function, :name) } }
-        .compact
-        .uniq
-
-      # Count completed tasks from tool results
-      completed_todos = messages
-        .select { |m| m[:role] == "tool" }
-        .map { |m| JSON.parse(m[:content]) rescue nil }
-        .compact
-        .select { |data| data.is_a?(Hash) && data["message"]&.include?("completed") }
-        .size
-
-      summary_text = "Previous conversation summary (#{messages.size} messages compressed):\n"
-      summary_text += "- User requests: #{user_msgs}\n"
-      summary_text += "- Assistant responses: #{assistant_msgs}\n"
-      summary_text += "- Tool executions: #{tool_msgs}\n"
-      summary_text += "- Tools used: #{tools_used.join(', ')}\n" if tools_used.any?
-      summary_text += "- Completed tasks: #{completed_todos}\n" if completed_todos > 0
-      summary_text += "\nContinuing with recent conversation context..."
-
-      {
-        role: "user",
-        content: "[SYSTEM] " + summary_text
-      }
-    end
-
     def confirm_tool_use?(call)
       # Show preview first and check for errors
       preview_error = show_tool_preview(call)
@@ -1181,12 +1660,19 @@ module Clacky
                   "Tool use denied by user"
                 end
 
+      # For edit tool, remind AI to use the exact same old_string from the previous tool call
+      tool_content = {
+        error: message,
+        user_feedback: user_feedback
+      }
+
+      if call[:name] == "edit"
+        tool_content[:hint] = "Keep old_string unchanged. Simply re-read the file if needed and retry with the exact same old_string."
+      end
+
       {
         id: call[:id],
-        content: JSON.generate({
-          error: message,
-          user_feedback: user_feedback
-        })
+        content: JSON.generate(tool_content)
       }
     end
 
@@ -1200,10 +1686,10 @@ module Clacky
     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,
@@ -1257,64 +1743,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