@compass-ai/nova 1.0.73 → 1.0.74

package/dist/services/conversation-compactor.js

@@ -0,0 +1,750 @@
+/**
+ * Conversation compaction service using Claude to intelligently summarize
+ * conversation history while preserving key decisions and context.
+ *
+ * This module provides functionality to reduce token usage by compacting
+ * long conversation histories into concise summaries that retain essential
+ * information for continued development assistance.
+ */
+import { getAnthropicClient } from './anthropic-client.js';
+import { getSessionManager } from './session-manager.js';
+import { getTokenTracker } from './token-tracker.js';
+import { logger } from '../utils/logger.js';
+import { estimateTokens } from '../utils/token-counter.js';
+import { formatTimestamp } from '../utils/format.js';
+import { AUTO_COMPACT_TRIGGER, COMPACTION_MODEL } from '../constants/defaults.js';
+import { getSystemEventLogger } from './system-event-logger.js';
+import { CONVERSATION_COMPACTION_SYSTEM_PROMPT, PLAN_APPROVAL_COMPACTION_SYSTEM_PROMPT } from '../prompts/index.js';
+/**
+ * Default compaction options
+ */
+const DEFAULT_COMPACTION_OPTIONS = {
+    maxSummaryTokens: 2000,
+    minMessagesForCompaction: 10,
+    preserveRecentMessages: 2,
+    customPrompt: '',
+    includeCodeSnippets: true,
+    includeFilePaths: true,
+};
+// COMPACTION_SYSTEM_PROMPT imported from '../prompts/index.js'
+// Local alias for backward compatibility
+const COMPACTION_SYSTEM_PROMPT = CONVERSATION_COMPACTION_SYSTEM_PROMPT;
+/**
+ * ConversationCompactor class provides intelligent conversation summarization
+ * using Claude to reduce token usage while preserving essential context.
+ */
+class ConversationCompactor {
+    client = null;
+    autoCompactThreshold;
+    constructor(autoCompactThreshold) {
+        this.autoCompactThreshold = autoCompactThreshold ?? AUTO_COMPACT_TRIGGER;
+    }
+    /**
+     * Initializes the compactor with an Anthropic client
+     */
+    async initialize() {
+        try {
+            this.client = await getAnthropicClient();
+            if (!this.client.isInitialized()) {
+                const initialized = await this.client.initialize();
+                if (!initialized) {
+                    logger.warn('Failed to initialize Anthropic client for compaction');
+                    return false;
+                }
+            }
+            return true;
+        }
+        catch (error) {
+            logger.error('Failed to initialize conversation compactor', error);
+            return false;
+        }
+    }
+    /**
+     * Compacts a conversation history into a summary
+     *
+     * @param messages - Array of conversation messages to compact
+     * @param options - Compaction options
+     * @returns CompactionResult with the summary and statistics
+     */
+    async compact(messages, options = {}) {
+        const opts = { ...DEFAULT_COMPACTION_OPTIONS, ...options };
+        // Validate minimum messages
+        if (messages.length < opts.minMessagesForCompaction) {
+            throw new Error(`Not enough messages to compact. Minimum required: ${opts.minMessagesForCompaction}, got: ${messages.length}`);
+        }
+        // Ensure client is initialized
+        if (!this.client) {
+            const initialized = await this.initialize();
+            if (!initialized) {
+                throw new Error('Failed to initialize Anthropic client for compaction');
+            }
+        }
+        // Separate messages to compact from recent messages to preserve
+        const messagesToCompact = messages.slice(0, -opts.preserveRecentMessages);
+        // Calculate tokens before compaction
+        const tokensBefore = this.calculateMessageTokens(messagesToCompact);
+        // Build the compaction prompt
+        const compactionPrompt = this.buildCompactionPrompt(messagesToCompact, opts);
+        // Generate summary using Claude
+        const systemPrompt = opts.customPrompt || COMPACTION_SYSTEM_PROMPT;
+        logger.debug(`Compacting ${messagesToCompact.length} messages (${tokensBefore} tokens)`);
+        try {
+            const result = await this.client.sendMessage([{ role: 'user', content: compactionPrompt }], {
+                system: systemPrompt,
+                maxTokens: opts.maxSummaryTokens,
+                temperature: 0.3, // Lower temperature for more consistent summaries
+                model: COMPACTION_MODEL, // Use Haiku for cost efficiency - 12-60x cheaper
+                callType: 'compaction', // Tag as compaction for cost tracking
+            });
+            const summary = result.content.trim();
+            const tokensAfter = estimateTokens(summary);
+            const tokensSaved = tokensBefore - tokensAfter;
+            const savingsPercent = Math.round((tokensSaved / tokensBefore) * 100);
+            const compactionResult = {
+                summary,
+                messagesCompacted: messagesToCompact.length,
+                tokensBefore,
+                tokensAfter,
+                tokensSaved,
+                savingsPercent,
+                timestamp: formatTimestamp(),
+                apiUsage: result.usage,
+            };
+            logger.info(`Compacted ${messagesToCompact.length} messages: ${tokensBefore} → ${tokensAfter} tokens (${savingsPercent}% saved)`);
+            // Log the compaction event
+            const systemEventLogger = getSystemEventLogger();
+            await systemEventLogger.logContextCompacted({
+                contextType: 'conversation',
+                messageCount: messagesToCompact.length,
+                tokenCount: tokensBefore,
+                compactionRatio: savingsPercent / 100,
+            });
+            return compactionResult;
+        }
+        catch (error) {
+            logger.error('Failed to compact conversation', error);
+            throw error;
+        }
+    }
+    /**
+     * Compacts the current session's conversation history
+     *
+     * @param options - Compaction options
+     * @returns CompactionResult with the summary and statistics
+     */
+    async compactCurrentSession(options = {}) {
+        const sessionManager = getSessionManager();
+        const session = sessionManager.getSession();
+        if (!session) {
+            throw new Error('No active session to compact');
+        }
+        const messages = session.state.conversationHistory;
+        const result = await this.compact(messages, options);
+        // Update session with compacted summary
+        sessionManager.setCompactedSummary(result.summary);
+        // Track the compaction in token usage
+        try {
+            const tokenTracker = await getTokenTracker();
+            await tokenTracker.recordUsage(this.client?.getCurrentModelId() || 'unknown', result.apiUsage, 'conversation_compaction');
+        }
+        catch (trackingError) {
+            logger.debug('Failed to track compaction token usage', trackingError);
+        }
+        return result;
+    }
+    /**
+     * Checks if the current session should be auto-compacted based on token usage
+     *
+     * @returns True if auto-compaction is recommended
+     */
+    async shouldAutoCompact() {
+        const sessionManager = getSessionManager();
+        const session = sessionManager.getSession();
+        if (!session) {
+            logger.debug('Compaction check: no active session');
+            return false;
+        }
+        const messages = session.state.conversationHistory;
+        // Don't compact if already compacted (has summary and few messages)
+        if (session.state.compactedSummary && messages.length < 10) {
+            logger.debug(`Compaction check: skipped - already compacted with ${messages.length} messages`);
+            return false;
+        }
+        // Use the synced estimated context tokens if available (more accurate during agentic loops)
+        // Fall back to calculating from session history if not set
+        const estimatedContextTokens = sessionManager.getEstimatedContextTokens();
+        const historyTokens = this.calculateMessageTokens(messages);
+        const totalTokens = estimatedContextTokens > 0 ? Math.max(estimatedContextTokens, historyTokens) : historyTokens;
+        const shouldCompact = totalTokens >= this.autoCompactThreshold;
+        logger.debug(`Compaction check: ${totalTokens.toLocaleString()} tokens ` +
+            `(estimated=${estimatedContextTokens.toLocaleString()}, history=${historyTokens.toLocaleString()}) ` +
+            `vs ${this.autoCompactThreshold.toLocaleString()} threshold ` +
+            `(${messages.length} messages) -> ${shouldCompact ? 'TRIGGER' : 'skip'}`);
+        return shouldCompact;
+    }
+    /**
+     * Performs auto-compaction if the threshold is exceeded
+     *
+     * @param options - Compaction options
+     * @returns CompactionResult if compaction was performed, null otherwise
+     */
+    async autoCompactIfNeeded(options = {}) {
+        const shouldCompact = await this.shouldAutoCompact();
+        if (!shouldCompact) {
+            return null;
+        }
+        logger.info('Auto-compaction triggered due to token threshold');
+        return this.compactCurrentSession(options);
+    }
+    /**
+     * Sets the auto-compact threshold
+     *
+     * @param threshold - Token count threshold for auto-compaction
+     */
+    setAutoCompactThreshold(threshold) {
+        this.autoCompactThreshold = threshold;
+    }
+    /**
+     * Gets the current auto-compact threshold
+     *
+     * @returns The current threshold value
+     */
+    getAutoCompactThreshold() {
+        return this.autoCompactThreshold;
+    }
+    /**
+     * Estimates the token savings from compacting the given messages
+     *
+     * @param messages - Messages to estimate compaction for
+     * @returns Estimated token savings
+     */
+    estimateSavings(messages) {
+        const currentTokens = this.calculateMessageTokens(messages);
+        // Estimate summary will be roughly 10-20% of original
+        // This is a heuristic based on typical compaction ratios
+        const compressionRatio = 0.15;
+        const estimatedAfter = Math.ceil(currentTokens * compressionRatio);
+        const estimatedSavings = currentTokens - estimatedAfter;
+        const estimatedSavingsPercent = Math.round((estimatedSavings / currentTokens) * 100);
+        return {
+            currentTokens,
+            estimatedAfter,
+            estimatedSavings,
+            estimatedSavingsPercent,
+        };
+    }
+    /**
+     * Formats a compacted summary for display
+     *
+     * @param result - The compaction result
+     * @returns Formatted string for display
+     */
+    formatCompactionSummary(result) {
+        const lines = [
+            '📦 Conversation Compacted',
+            '',
+            `Messages compacted: ${result.messagesCompacted}`,
+            `Tokens before: ${result.tokensBefore.toLocaleString()}`,
+            `Tokens after: ${result.tokensAfter.toLocaleString()}`,
+            `Tokens saved: ${result.tokensSaved.toLocaleString()} (${result.savingsPercent}%)`,
+            '',
+            '─'.repeat(50),
+            '',
+            result.summary,
+        ];
+        return lines.join('\n');
+    }
+    /**
+     * Builds the prompt for compaction
+     */
+    buildCompactionPrompt(messages, options) {
+        const parts = [
+            'Please summarize the following conversation history between a user and Compass (an AI development assistant).',
+            '',
+            'Focus on preserving:',
+            '- Key decisions and their rationale',
+            '- Code changes and file modifications',
+            '- Technical requirements and constraints',
+            '- Current project state and pending tasks',
+        ];
+        if (options.includeCodeSnippets) {
+            parts.push('- Important code snippets that provide essential context');
+        }
+        if (options.includeFilePaths) {
+            parts.push('- File paths that were discussed or modified');
+        }
+        parts.push('');
+        parts.push('---');
+        parts.push('CONVERSATION HISTORY:');
+        parts.push('---');
+        parts.push('');
+        // Format messages for the prompt
+        for (const message of messages) {
+            const role = message.role === 'user' ? 'User' : 'Compass';
+            const timestamp = message.timestamp ? ` [${message.timestamp}]` : '';
+            parts.push(`**${role}**${timestamp}:`);
+            parts.push(message.content);
+            parts.push('');
+        }
+        parts.push('---');
+        parts.push('');
+        parts.push('Please provide a structured summary that captures all essential information needed to continue this development session effectively.');
+        return parts.join('\n');
+    }
+    /**
+     * Calculates the total token count for an array of messages
+     */
+    calculateMessageTokens(messages) {
+        // Use the message token counts if available, otherwise estimate
+        let total = 0;
+        for (const message of messages) {
+            if (message.tokenCount !== undefined) {
+                total += message.tokenCount;
+            }
+            else {
+                total += estimateTokens(message.content);
+            }
+        }
+        // Add overhead for message structure
+        total += messages.length * 4;
+        return total;
+    }
+    /**
+     * Extracts key information from messages for quick reference
+     */
+    extractKeyInfo(messages) {
+        const filesModified = new Set();
+        let decisionsCount = 0;
+        let codeBlocksCount = 0;
+        // Patterns to detect file paths
+        const filePathPattern = /(?:^|\s)([a-zA-Z0-9_\-./]+\.[a-zA-Z0-9]+)(?:\s|$|:|\))/g;
+        const codeBlockPattern = /```[\s\S]*?```/g;
+        const decisionPatterns = [
+            /\b(?:decided|decision|chose|choosing|will use|going with|opted for)\b/i,
+            /\b(?:let's|we should|I recommend|the approach)\b/i,
+        ];
+        for (const message of messages) {
+            const content = message.content;
+            // Extract file paths
+            const fileMatches = content.matchAll(filePathPattern);
+            for (const match of fileMatches) {
+                const filePath = match[1];
+                // Filter out common false positives
+                if (filePath.includes('/') ||
+                    filePath.match(/\.(ts|js|tsx|jsx|py|go|rs|java|json|yaml|yml|md|css|html)$/)) {
+                    filesModified.add(filePath);
+                }
+            }
+            // Count code blocks
+            const codeBlocks = content.match(codeBlockPattern);
+            if (codeBlocks) {
+                codeBlocksCount += codeBlocks.length;
+            }
+            // Count decisions (rough heuristic)
+            for (const pattern of decisionPatterns) {
+                if (pattern.test(content)) {
+                    decisionsCount++;
+                    break;
+                }
+            }
+        }
+        return {
+            filesModified: Array.from(filesModified),
+            decisionsCount,
+            codeBlocksCount,
+        };
+    }
+    /**
+     * Compacts an array of API messages (Message[] format used in agentic loops).
+     * This handles the complex content blocks from Anthropic API format.
+     *
+     * @param messages - Array of API messages to compact
+     * @param preserveRecentCount - Number of recent messages to preserve uncompacted (default: 4)
+     * @param maxSummaryTokens - Maximum tokens for the summary (default: 3000)
+     * @returns Object with the summary and the reconstructed messages array
+     */
+    async compactApiMessages(messages, preserveRecentCount = 4, maxSummaryTokens = 3000, systemPrompt) {
+        // Ensure client is initialized
+        if (!this.client) {
+            const initialized = await this.initialize();
+            if (!initialized) {
+                throw new Error('Failed to initialize Anthropic client for compaction');
+            }
+        }
+        // Keep first message (original user request) and recent messages
+        // Validate preserveRecentCount to avoid invalid slice ranges
+        let actualPreserveCount = Math.min(preserveRecentCount, Math.max(0, messages.length - 2));
+        // Ensure the preserved boundary doesn't split a tool_use/tool_result pair.
+        // If the first preserved message is a user message with tool_result blocks,
+        // its matching assistant tool_use message was compacted away — bump the count
+        // to include the preceding assistant message.
+        if (actualPreserveCount > 0 && actualPreserveCount < messages.length - 1) {
+            const firstPreserved = messages[messages.length - actualPreserveCount];
+            const hasToolResults = firstPreserved.role === 'user' &&
+                Array.isArray(firstPreserved.content) &&
+                firstPreserved.content.some((block) => block.type === 'tool_result');
+            if (hasToolResults) {
+                actualPreserveCount = Math.min(actualPreserveCount + 1, messages.length - 2);
+            }
+        }
+        if (actualPreserveCount < 1) {
+            // Not enough messages to preserve anything meaningful
+            return {
+                summary: '',
+                compactedMessages: messages,
+                tokensBefore: this.estimateApiMessageTokens(messages),
+                tokensAfter: this.estimateApiMessageTokens(messages),
+                messagesCompacted: 0,
+            };
+        }
+        const originalFirstMessage = messages[0];
+        // Filter out old compaction summaries — they'll be replaced by the new one.
+        // For messages that are fully summary-only, remove them entirely.
+        // For messages that contain a summary mixed with other content (e.g., plan context
+        // appended by reinjectPlanContextAfterCompaction), strip the summary portion but
+        // preserve any non-summary content like [ACTIVE PLAN CONTEXT blocks.
+        const isSummaryMessage = (msg) => msg.role === 'user' &&
+            typeof msg.content === 'string' &&
+            msg.content.includes('[CONTEXT SUMMARY');
+        const stripStaleSummaryContent = (msg) => {
+            if (!isSummaryMessage(msg))
+                return msg;
+            const content = msg.content;
+            // Check if there's plan context or other non-summary content appended after the summary
+            const planContextMatch = content.match(/(\[ACTIVE PLAN CONTEXT[\s\S]*)/);
+            if (planContextMatch) {
+                // Preserve the plan context portion, discard the stale summary
+                return { ...msg, content: planContextMatch[1] };
+            }
+            // Pure summary message — remove entirely
+            return null;
+        };
+        const rawMessagesToCompact = messages.slice(1, -actualPreserveCount);
+        const messagesToCompact = rawMessagesToCompact.filter(msg => !isSummaryMessage(msg));
+        const recentMessages = messages.slice(-actualPreserveCount)
+            .map(stripStaleSummaryContent)
+            .filter((msg) => msg !== null);
+        if (messagesToCompact.length < 3) {
+            // Not enough to compact - return as is
+            return {
+                summary: '',
+                compactedMessages: messages,
+                tokensBefore: this.estimateApiMessageTokens(messages),
+                tokensAfter: this.estimateApiMessageTokens(messages),
+                messagesCompacted: 0,
+            };
+        }
+        const tokensBefore = this.estimateApiMessageTokens(messages);
+        // Convert API messages to text for summarization
+        const formattedHistory = this.formatApiMessagesForCompaction(messagesToCompact);
+        logger.debug(`Compacting ${messagesToCompact.length} API messages (${tokensBefore} tokens estimated)`);
+        const compactionPrompt = `Please summarize the following conversation history between a user and an AI development assistant.
+
+Focus on preserving:
+- Key decisions and their rationale
+- Code changes and file modifications made
+- Technical requirements and constraints discussed
+- Current task state and any pending work
+- Important file paths that were modified or discussed
+- Any errors encountered and their resolutions
+- Active plan IDs and task IDs VERBATIM (e.g., plan ID, task-1, task-2) — these reference on-disk state and must be preserved exactly
+
+---
+CONVERSATION HISTORY TO SUMMARIZE:
+---
+
+${formattedHistory}
+
+---
+
+Provide a structured, concise summary that captures all essential information needed to continue this development session effectively. Include specific file paths, code patterns, and decisions made.`;
+        try {
+            const effectiveSystemPrompt = systemPrompt || COMPACTION_SYSTEM_PROMPT;
+            const result = await this.client.sendMessage([{ role: 'user', content: compactionPrompt }], {
+                system: effectiveSystemPrompt,
+                maxTokens: maxSummaryTokens,
+                temperature: 0.3,
+                model: COMPACTION_MODEL, // Use Haiku for cost efficiency - 12-60x cheaper
+                callType: 'compaction', // Tag as compaction for cost tracking
+            });
+            const summary = result.content.trim();
+            // Validate summary is not empty
+            if (!summary) {
+                logger.warn('Compaction resulted in empty summary, returning original messages');
+                return {
+                    summary: '',
+                    compactedMessages: messages,
+                    tokensBefore,
+                    tokensAfter: tokensBefore,
+                    messagesCompacted: 0,
+                };
+            }
+            // Reconstruct messages with summary injected
+            const compactedMessages = [
+                originalFirstMessage,
+                {
+                    role: 'user',
+                    content: `[CONTEXT SUMMARY - Previous ${messagesToCompact.length} messages compacted]\n\n${summary}\n\n[END SUMMARY - Continue from recent context below]`,
+                },
+                ...recentMessages,
+            ];
+            const tokensAfter = this.estimateApiMessageTokens(compactedMessages);
+            logger.info(`Compacted ${messagesToCompact.length} API messages: ${tokensBefore} → ${tokensAfter} tokens (${Math.round(((tokensBefore - tokensAfter) / tokensBefore) * 100)}% saved)`);
+            // Log the compaction event
+            const systemEventLogger = getSystemEventLogger();
+            await systemEventLogger.logContextCompacted({
+                contextType: 'conversation',
+                messageCount: messagesToCompact.length,
+                tokenCount: tokensBefore,
+                compactionRatio: (tokensBefore - tokensAfter) / tokensBefore,
+            });
+            return {
+                summary,
+                compactedMessages,
+                tokensBefore,
+                tokensAfter,
+                messagesCompacted: messagesToCompact.length,
+            };
+        }
+        catch (error) {
+            logger.error('Failed to compact API messages', error);
+            throw error;
+        }
+    }
+    /**
+     * Compacts API messages specifically for plan approval transitions.
+     * Uses a plan-focused summarization prompt that preserves architectural decisions
+     * and file paths while discarding raw exploration data (file contents, grep results).
+     *
+     * @param messages - Array of API messages to compact
+     * @param preserveRecentCount - Number of recent messages to preserve (default: 3)
+     * @param maxSummaryTokens - Maximum tokens for the summary (default: 3000)
+     * @returns Object with the summary and the reconstructed messages array
+     */
+    async compactForPlanApproval(messages, preserveRecentCount = 3, maxSummaryTokens = 3000) {
+        return this.compactApiMessages(messages, preserveRecentCount, maxSummaryTokens, PLAN_APPROVAL_COMPACTION_SYSTEM_PROMPT);
+    }
+    /**
+     * Estimates token count for API Message[] array
+     */
+    estimateApiMessageTokens(messages) {
+        let total = 0;
+        const MESSAGE_OVERHEAD = 4;
+        for (const message of messages) {
+            total += MESSAGE_OVERHEAD;
+            if (typeof message.content === 'string') {
+                total += estimateTokens(message.content);
+            }
+            else if (Array.isArray(message.content)) {
+                for (const block of message.content) {
+                    total += this.estimateContentBlockTokens(block);
+                }
+            }
+        }
+        return total;
+    }
+    /**
+     * Estimates tokens for a single content block
+     */
+    estimateContentBlockTokens(block) {
+        const BLOCK_OVERHEAD = 10; // JSON structure overhead
+        switch (block.type) {
+            case 'text':
+                return BLOCK_OVERHEAD + estimateTokens(block.text || '');
+            case 'tool_use':
+                return BLOCK_OVERHEAD + estimateTokens(block.name || '') +
+                    estimateTokens(typeof block.input === 'string' ? block.input : JSON.stringify(block.input || {}));
+            case 'tool_result':
+                if (typeof block.content === 'string') {
+                    return BLOCK_OVERHEAD + estimateTokens(block.content);
+                }
+                else if (Array.isArray(block.content)) {
+                    return BLOCK_OVERHEAD + block.content.reduce((sum, c) => sum + estimateTokens(typeof c === 'string' ? c : (c.text || '')), 0);
+                }
+                return BLOCK_OVERHEAD;
+            default:
+                return BLOCK_OVERHEAD;
+        }
+    }
+    /**
+     * Formats API messages into a text representation for compaction.
+     * Empty tool results (no matches, no files found) are stripped from the
+     * per-message output and replaced with a single terse summary line at the
+     * top, saving significant tokens when the LLM performed many exploratory
+     * searches that returned nothing.
+     */
+    formatApiMessagesForCompaction(messages) {
+        // Pre-scan: identify tool_use IDs whose results were empty
+        const emptyToolIds = this.collectEmptyToolResultIds(messages);
+        const parts = [];
+        // Emit a compact summary of all empty searches at the top
+        if (emptyToolIds.size > 0) {
+            const emptySearches = [];
+            for (const msg of messages) {
+                if (msg.role !== 'assistant' || !Array.isArray(msg.content))
+                    continue;
+                for (const block of msg.content) {
+                    if (block.type === 'tool_use' && block.id && emptyToolIds.has(block.id)) {
+                        const input = block.input;
+                        const pattern = input?.pattern || input?.path || '';
+                        const shortPattern = pattern.length > 80 ? pattern.substring(0, 80) + '…' : pattern;
+                        emptySearches.push(`${block.name || 'tool'}("${shortPattern}")`);
+                    }
+                }
+            }
+            if (emptySearches.length > 0) {
+                parts.push(`[${emptySearches.length} tool calls returned no results: ${emptySearches.join('; ')}]`);
+                parts.push('');
+            }
+        }
+        for (const message of messages) {
+            const role = message.role === 'user' ? 'User' : 'Assistant';
+            if (typeof message.content === 'string') {
+                parts.push(`**${role}**:`);
+                parts.push(message.content);
+                parts.push('');
+            }
+            else if (Array.isArray(message.content)) {
+                // Filter out blocks belonging to empty tool pairs
+                const filteredBlocks = message.content.filter(block => {
+                    if (block.type === 'tool_use' && block.id && emptyToolIds.has(block.id))
+                        return false;
+                    if (block.type === 'tool_result' && block.tool_use_id && emptyToolIds.has(block.tool_use_id))
+                        return false;
+                    return true;
+                });
+                // Skip messages that become empty after filtering
+                if (filteredBlocks.length === 0)
+                    continue;
+                parts.push(`**${role}**:`);
+                for (const block of filteredBlocks) {
+                    parts.push(this.formatContentBlock(block));
+                }
+                parts.push('');
+            }
+        }
+        return parts.join('\n');
+    }
+    /**
+     * Scans messages for tool_result blocks that indicate empty/no-match results
+     * and returns the set of their corresponding tool_use IDs.
+     */
+    collectEmptyToolResultIds(messages) {
+        const emptyIds = new Set();
+        for (const msg of messages) {
+            if (msg.role !== 'user' || !Array.isArray(msg.content))
+                continue;
+            for (const block of msg.content) {
+                if (block.type !== 'tool_result' || !block.tool_use_id)
+                    continue;
+                if (block.is_error)
+                    continue; // Keep errors — they're always informative
+                const text = this.extractToolResultText(block);
+                if (this.isEmptyToolResult(text)) {
+                    emptyIds.add(block.tool_use_id);
+                }
+            }
+        }
+        return emptyIds;
+    }
+    /**
+     * Extracts the text content from a tool_result block.
+     */
+    extractToolResultText(block) {
+        if (typeof block.content === 'string')
+            return block.content;
+        if (Array.isArray(block.content)) {
+            return block.content.map(c => typeof c === 'string' ? c : (c.text || '')).join('\n');
+        }
+        return '';
+    }
+    /**
+     * Determines if a tool result's text content indicates an empty/no-match result.
+     * Matches common patterns from search_code, find_files, and list_files tools.
+     */
+    isEmptyToolResult(text) {
+        // JSON results with matchCount: 0 or totalFound: 0
+        if (/"matchCount"\s*:\s*0\b/.test(text))
+            return true;
+        if (/"totalFound"\s*:\s*0\b/.test(text))
+            return true;
+        // Plain-text "no matches" indicators
+        if (/no\s+matches\s+found/i.test(text))
+            return true;
+        if (/no\s+results\s+found/i.test(text))
+            return true;
+        if (/0\s+matches/i.test(text))
+            return true;
+        return false;
+    }
+    /**
+     * Formats a content block to text representation
+     */
+    formatContentBlock(block) {
+        switch (block.type) {
+            case 'text':
+                return block.text || '';
+            case 'tool_use': {
+                // Summarize tool calls - don't include full input for large ones
+                const inputStr = typeof block.input === 'string'
+                    ? block.input
+                    : JSON.stringify(block.input || {});
+                const truncatedInput = inputStr.length > 500
+                    ? inputStr.substring(0, 500) + '...[truncated]'
+                    : inputStr;
+                return `[Tool Call: ${block.name}] Input: ${truncatedInput}`;
+            }
+            case 'tool_result': {
+                // Summarize tool results - focus on errors and key outcomes
+                let resultContent = '';
+                if (typeof block.content === 'string') {
+                    resultContent = block.content;
+                }
+                else if (Array.isArray(block.content)) {
+                    resultContent = block.content.map(c => typeof c === 'string' ? c : (c.text || '')).join('\n');
+                }
+                // Truncate long results but preserve error information
+                if (resultContent.length > 1000) {
+                    const hasError = /error|fail|exception/i.test(resultContent);
+                    if (hasError) {
+                        // Keep more context for errors
+                        resultContent = resultContent.substring(0, 2000) + '\n...[result truncated, errors preserved]';
+                    }
+                    else {
+                        resultContent = resultContent.substring(0, 500) + '\n...[result truncated]';
+                    }
+                }
+                return `[Tool Result: ${block.is_error ? 'ERROR' : 'success'}] ${resultContent}`;
+            }
+            default:
+                return `[${block.type}]`;
+        }
+    }
+}
+// Singleton instance
+let conversationCompactorInstance = null;
+/**
+ * Gets the singleton ConversationCompactor instance.
+ * Creates the instance on first call.
+ *
+ * @param autoCompactThreshold - Optional threshold for auto-compaction
+ * @returns Promise resolving to the ConversationCompactor instance
+ */
+export async function getConversationCompactor(autoCompactThreshold) {
+    if (!conversationCompactorInstance) {
+        conversationCompactorInstance = new ConversationCompactor(autoCompactThreshold);
+    }
+    return conversationCompactorInstance;
+}
+/**
+ * Creates a new ConversationCompactor instance with custom configuration.
+ * Use this when you need a separate instance from the singleton.
+ *
+ * @param autoCompactThreshold - Optional threshold for auto-compaction
+ * @returns A new ConversationCompactor instance
+ */
+export function createConversationCompactor(autoCompactThreshold) {
+    return new ConversationCompactor(autoCompactThreshold);
+}
+export { ConversationCompactor, COMPACTION_SYSTEM_PROMPT };
+//# sourceMappingURL=conversation-compactor.js.map