openclacky 0.7.0 → 0.7.2

data/lib/clacky/agent/message_compressor_helper.rb

@@ -0,0 +1,534 @@
+# frozen_string_literal: true
+
+module Clacky
+  class Agent
+    # Message compression functionality for managing conversation history
+    # Handles automatic compression when token limits are exceeded
+    module MessageCompressorHelper
+      # Compression thresholds
+      COMPRESSION_THRESHOLD = 150_000  # Trigger compression when exceeding this (in tokens)
+      MESSAGE_COUNT_THRESHOLD = 150   # Trigger compression when exceeding this (in message count)
+      MAX_RECENT_MESSAGES = 20  # Keep this many recent message pairs intact
+      TARGET_COMPRESSED_TOKENS = 10_000  # Target size after compression
+      IDLE_COMPRESSION_THRESHOLD = 20_000  # Minimum messages needed for idle compression
+
+      # Trigger compression during idle time (user-friendly, interruptible)
+      # Returns true if compression was performed, false otherwise
+      def trigger_idle_compression
+        # Check if we should compress (force mode)
+        compression_context = compress_messages_if_needed(force: true)
+        @ui&.show_info("Idle detected. Compressing conversation to optimize costs...")
+        if compression_context.nil?
+          @ui&.show_info("Idle skipped.")
+          return false
+        end
+
+        # Insert compression message
+        @messages << compression_context[:compression_message]
+
+        begin
+          # Execute compression using shared LLM call logic
+          response = call_llm
+          handle_compression_response(response, compression_context)
+          true
+        rescue Clacky::AgentInterrupted => e
+          @ui&.log("Idle compression canceled: #{e.message}", level: :info)
+          # Remove the compression message we added
+          @messages.pop if @messages.last == compression_context[:compression_message]
+          false
+        rescue => e
+          @ui&.log("Idle compression failed: #{e.message}", level: :error)
+          # Remove the compression message we added
+          @messages.pop if @messages.last == compression_context[:compression_message]
+          false
+        end
+      end
+
+      # Check if compression is needed and return compression context
+      # @param force [Boolean] Force compression even if thresholds not met
+      # @return [Hash, nil] Compression context or nil if not needed
+      def compress_messages_if_needed(force: false)
+        # Check if compression is enabled
+        return nil unless @config.enable_compression
+
+        # Calculate total tokens and message count
+        total_tokens = total_message_tokens[:total]
+        message_count = @messages.length
+
+        # Force compression (for idle compression) - use lower threshold
+        if force
+          # Only compress if we have more than MAX_RECENT_MESSAGES + system message
+          return nil unless message_count > MAX_RECENT_MESSAGES + 1
+          # Also require minimum message count to make compression worthwhile
+          return nil unless total_tokens >= IDLE_COMPRESSION_THRESHOLD
+        else
+          # Normal compression - check thresholds
+          # 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 nil unless token_threshold_exceeded || message_count_exceeded
+        end
+
+        # 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 (not for force mode)
+        if !force && token_threshold_exceeded && reduction_needed < (total_tokens * 0.1)
+          return nil
+        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)
+
+        # Increment compression level for progressive summarization
+        @compression_level += 1
+
+        # Get the most recent N messages, ensuring tool_calls/tool results pairs are kept together
+        recent_messages = get_recent_messages_with_tool_pairs(@messages, target_recent_count)
+        recent_messages = [] if recent_messages.nil?
+
+        # Build compression instruction message (to be inserted into conversation)
+        compression_message = @message_compressor.build_compression_message(@messages, recent_messages: recent_messages)
+
+        return nil if compression_message.nil?
+
+        # Return compression context for agent to handle
+        {
+          compression_message: compression_message,
+          recent_messages: recent_messages,
+          original_token_count: total_tokens,
+          original_message_count: @messages.length,
+          compression_level: @compression_level
+        }
+      end
+
+      # Handle compression response and rebuild message list
+      def handle_compression_response(response, compression_context)
+        # Extract compressed content from response
+        compressed_content = response[:content]
+
+        # Note: Cost tracking is already handled by call_llm, no need to track again here
+
+        # Rebuild message list with compression
+        # Note: we need to remove the compression instruction message we just added
+        original_messages = @messages[0..-2]  # All except the last (compression instruction)
+
+        @messages = @message_compressor.rebuild_with_compression(
+          compressed_content,
+          original_messages: original_messages,
+          recent_messages: compression_context[:recent_messages]
+        )
+
+        # Track this compression
+        @compressed_summaries << {
+          level: compression_context[:compression_level],
+          message_count: compression_context[:original_message_count],
+          timestamp: Time.now.iso8601,
+          strategy: :insert_then_compress
+        }
+
+        final_tokens = total_message_tokens[:total]
+
+        # Show compression info
+        @ui&.show_info(
+          "History compressed (~#{compression_context[:original_token_count]} -> ~#{final_tokens} tokens, " \
+          "level #{compression_context[:compression_level]})"
+        )
+      end
+
+      # Get recent messages while preserving tool_calls/tool_results pairs
+      # This ensures assistant messages with tool_calls are kept together with ALL their tool results
+      # @param messages [Array] All messages
+      # @param count [Integer] Target number of recent messages to keep
+      # @return [Array] Recent messages with complete tool pairs
+      def get_recent_messages_with_tool_pairs(messages, count)
+        # This method ensures that assistant messages with tool_calls are always kept together
+        # 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.nil? || messages.empty?
+
+        # Track which messages to include
+        messages_to_include = Set.new
+
+        # Start from the end and work backwards
+        i = messages.size - 1
+        messages_collected = 0
+
+        while i >= 0 && messages_collected < count
+          msg = messages[i]
+
+          # Skip if already marked for inclusion
+          if messages_to_include.include?(i)
+            i -= 1
+            next
+          end
+
+          # Mark this message for inclusion
+          messages_to_include.add(i)
+          messages_collected += 1
+
+          # If this is an assistant message with tool_calls, we MUST include ALL corresponding tool results
+          if msg[:role] == "assistant" && msg[:tool_calls]
+            tool_call_ids = msg[:tool_calls].map { |tc| tc[:id] }
+
+            # Find all tool results that belong to this assistant message
+            # They should be in the messages immediately following this assistant message
+            j = i + 1
+            while j < messages.size
+              next_msg = messages[j]
+
+              # If we find a tool result for one of our tool_calls, include it
+              if next_msg[:role] == "tool" && tool_call_ids.include?(next_msg[:tool_call_id])
+                messages_to_include.add(j)
+              elsif next_msg[:role] != "tool"
+                # Stop when we hit a non-tool message (start of next turn)
+                break
+              end
+
+              j += 1
+            end
+          end
+
+          # If this is a tool result, make sure its assistant message is also included
+          if msg[:role] == "tool"
+            # Find the corresponding assistant message
+            j = i - 1
+            while j >= 0
+              prev_msg = messages[j]
+              if prev_msg[:role] == "assistant" && prev_msg[:tool_calls]
+                # Check if this assistant has the matching tool_call
+                has_matching_call = prev_msg[:tool_calls].any? { |tc| tc[:id] == msg[:tool_call_id] }
+                if has_matching_call
+                  unless messages_to_include.include?(j)
+                    messages_to_include.add(j)
+                    messages_collected += 1
+                  end
+
+                  # Also include all other tool results for this assistant message
+                  tool_call_ids = prev_msg[:tool_calls].map { |tc| tc[:id] }
+                  k = j + 1
+                  while k < messages.size
+                    result_msg = messages[k]
+                    if result_msg[:role] == "tool" && tool_call_ids.include?(result_msg[:tool_call_id])
+                      messages_to_include.add(k)
+                    elsif result_msg[:role] != "tool"
+                      break
+                    end
+                    k += 1
+                  end
+
+                  break
+                end
+              end
+              j -= 1
+            end
+          end
+
+          i -= 1
+        end
+
+        # Extract the messages in their original order
+        recent_messages = messages_to_include.to_a.sort.map { |idx| messages[idx] }
+
+        # Truncate large tool results to prevent token bloat
+        recent_messages.map do |msg|
+          if msg[:role] == "tool" && msg[:content].is_a?(String) && msg[:content].length > 2000
+            msg.merge(content: msg[:content][0..2000] + "...\n[Content truncated - exceeded 2000 characters]")
+          else
+            msg
+          end
+        end
+      end
+
+      private
+
+      # Calculate how many recent messages to keep based on how much we need to compress
+      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)
+      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
+      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
+      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
+      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
+      def filter_write_results(result, action)
+        result && result[:action] == action ? result[:file] : nil
+      end
+
+      # Helper: filter todo results by status
+      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)
+      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
+      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
+      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
+
+      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
+
+      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
+
+      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)
+      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)
+      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)
+      def generate_level3_summary(data)
+        parts = []
+
+        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)
+      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
+    end
+  end
+end

data/lib/clacky/agent/session_serializer.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Clacky
+  class Agent
+    # Session serialization for saving and restoring agent state
+    # Handles session data serialization and deserialization
+    module SessionSerializer
+      # Restore from a saved session
+      # @param session_data [Hash] Saved session data
+      def restore_session(session_data)
+        @session_id = session_data[:session_id]
+        @messages = session_data[:messages]
+        @todos = session_data[:todos] || []  # Restore todos from session
+        @iterations = session_data.dig(:stats, :total_iterations) || 0
+        @total_cost = session_data.dig(:stats, :total_cost_usd) || 0.0
+        @working_dir = session_data[:working_dir]
+        @created_at = session_data[:created_at]
+        @total_tasks = session_data.dig(:stats, :total_tasks) || 0
+
+        # Restore cache statistics if available
+        @cache_stats = session_data.dig(:stats, :cache_stats) || {
+          cache_creation_input_tokens: 0,
+          cache_read_input_tokens: 0,
+          total_requests: 0,
+          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
+
+        # Restore Time Machine state
+        @task_parents = session_data.dig(:time_machine, :task_parents) || {}
+        @current_task_id = session_data.dig(:time_machine, :current_task_id) || 0
+        @active_task_id = session_data.dig(:time_machine, :active_task_id) || 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)
+
+        if last_status == "error" && last_error
+          # Find and remove the last user message that caused the error
+          # This allows the user to retry with a different prompt
+          last_user_index = @messages.rindex { |m| m[:role] == "user" }
+          if last_user_index
+            @messages = @messages[0...last_user_index]
+
+            # Trigger a hook to notify about the rollback
+            @hooks.trigger(:session_rollback, {
+              reason: "Previous session ended with error",
+              error_message: last_error,
+              rolled_back_message_index: last_user_index
+            })
+          end
+        end
+      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
+      # @return [Hash] Session data ready for serialization
+      def to_session_data(status: :success, error_message: nil)
+        # 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 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
+          else
+            "User message (non-string content)"
+          end
+        else
+          "No messages"
+        end
+
+        stats_data = {
+          total_tasks: @total_tasks,
+          total_iterations: @iterations,
+          total_cost_usd: @total_cost.round(4),
+          duration_seconds: @start_time ? (Time.now - @start_time).round(2) : 0,
+          last_status: status.to_s,
+          cache_stats: @cache_stats,
+          debug_logs: @debug_logs,
+          previous_total_tokens: @previous_total_tokens
+        }
+
+        # Add error message if status is error
+        stats_data[:last_error] = error_message if status == :error && error_message
+
+        {
+          session_id: @session_id,
+          created_at: @created_at,
+          updated_at: Time.now.iso8601,
+          working_dir: @working_dir,
+          todos: @todos,  # Include todos in session data
+          time_machine: {  # Include Time Machine state
+            task_parents: @task_parents || {},
+            current_task_id: @current_task_id || 0,
+            active_task_id: @active_task_id || 0
+          },
+          config: {
+            models: @config.models,
+            permission_mode: @config.permission_mode.to_s,
+            enable_compression: @config.enable_compression,
+            enable_prompt_caching: @config.enable_prompt_caching,
+            max_tokens: @config.max_tokens,
+            verbose: @config.verbose
+          },
+          stats: stats_data,
+          messages: @messages,
+          last_user_message: last_message_preview
+        }
+      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
+
+      # Extract text from message content (handles string and array formats)
+      # @param content [String, Array, Object] Message content
+      # @return [String] Extracted text
+      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
+    end
+  end
+end