@compass-ai/nova 1.0.74 → 1.0.75

package/dist/services/conversation-compactor.js

@@ -1,750 +0,0 @@
-/**
- * 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