@phuetz/code-buddy 0.1.0

package/dist/context/compaction/progressive-fallback.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Progressive Fallback
+ *
+ * Handles cases where summarization produces oversized results.
+ * Uses progressive strategies to reduce content size while
+ * preserving as much information as possible.
+ */
+import type { ChatMessage } from '../../types/index.js';
+import type { CompactionConfig, CompactionResult } from './types.js';
+/**
+ * Strategy for reducing content size
+ */
+export type FallbackStrategy = 'truncate' | 'remove-middle' | 'extract-key' | 'aggressive-truncate';
+/**
+ * Fallback result
+ */
+export interface FallbackResult {
+    content: string;
+    tokenCount: number;
+    strategy: FallbackStrategy;
+    originalTokens: number;
+    compressionRatio: number;
+}
+/**
+ * Apply truncation fallback
+ */
+export declare function applyTruncation(content: string, targetTokens: number, config?: Partial<CompactionConfig>, model?: string): FallbackResult;
+/**
+ * Remove middle content (keep head and tail with more aggressive ratios)
+ */
+export declare function removeMiddle(content: string, targetTokens: number, model?: string): FallbackResult;
+/**
+ * Extract only key information (most aggressive)
+ */
+export declare function extractKeyInfo(content: string, targetTokens: number, model?: string): FallbackResult;
+/**
+ * Aggressive truncation (last resort)
+ */
+export declare function aggressiveTruncate(content: string, targetTokens: number, model?: string): FallbackResult;
+/**
+ * Apply progressive fallback strategies until target is met
+ */
+export declare function applyProgressiveFallback(content: string, targetTokens: number, config?: Partial<CompactionConfig>, model?: string): FallbackResult;
+/**
+ * Apply fallback to messages if summarization failed
+ */
+export declare function applyMessageFallback(messages: ChatMessage[], targetTokens: number, config?: Partial<CompactionConfig>, model?: string): CompactionResult;

package/dist/context/compaction/progressive-fallback.js

@@ -0,0 +1,206 @@
+/**
+ * Progressive Fallback
+ *
+ * Handles cases where summarization produces oversized results.
+ * Uses progressive strategies to reduce content size while
+ * preserving as much information as possible.
+ */
+import { DEFAULT_COMPACTION_CONFIG } from './types.js';
+import { countTokens, countMessageTokens } from '../token-counter.js';
+import { truncateText } from './parallel-summarizer.js';
+import { logger } from '../../utils/logger.js';
+/**
+ * Apply truncation fallback
+ */
+export function applyTruncation(content, targetTokens, config = {}, model = 'gpt-4') {
+    const cfg = { ...DEFAULT_COMPACTION_CONFIG, ...config };
+    const originalTokens = countTokens(content, model);
+    // Calculate approximate char ratio
+    const charPerToken = content.length / originalTokens;
+    const targetChars = targetTokens * charPerToken;
+    // Split between head and tail
+    const headChars = Math.max(cfg.truncateHeadChars, Math.floor(targetChars * 0.6));
+    const tailChars = Math.max(cfg.truncateTailChars, Math.floor(targetChars * 0.4));
+    const truncated = truncateText(content, headChars, tailChars);
+    const tokenCount = countTokens(truncated, model);
+    return {
+        content: truncated,
+        tokenCount,
+        strategy: 'truncate',
+        originalTokens,
+        compressionRatio: 1 - (tokenCount / originalTokens),
+    };
+}
+/**
+ * Remove middle content (keep head and tail with more aggressive ratios)
+ */
+export function removeMiddle(content, targetTokens, model = 'gpt-4') {
+    const originalTokens = countTokens(content, model);
+    const charPerToken = content.length / originalTokens;
+    const targetChars = Math.floor(targetTokens * charPerToken);
+    // 70% head, 30% tail
+    const headChars = Math.floor(targetChars * 0.7);
+    const tailChars = Math.floor(targetChars * 0.3);
+    const head = content.slice(0, headChars);
+    const tail = content.slice(-tailChars);
+    const removedCount = content.length - headChars - tailChars;
+    const result = `${head}\n\n[... ${removedCount} characters removed ...]\n\n${tail}`;
+    const tokenCount = countTokens(result, model);
+    return {
+        content: result,
+        tokenCount,
+        strategy: 'remove-middle',
+        originalTokens,
+        compressionRatio: 1 - (tokenCount / originalTokens),
+    };
+}
+/**
+ * Extract only key information (most aggressive)
+ */
+export function extractKeyInfo(content, targetTokens, model = 'gpt-4') {
+    const originalTokens = countTokens(content, model);
+    const charPerToken = content.length / originalTokens;
+    const targetChars = Math.floor(targetTokens * charPerToken);
+    // Extract sentences with important keywords
+    const sentences = content.split(/[.!?]+/).filter(s => s.trim().length > 20);
+    const keywordScores = [];
+    for (const sentence of sentences) {
+        let score = 0;
+        const lower = sentence.toLowerCase();
+        // High importance keywords
+        if (lower.includes('error') || lower.includes('bug'))
+            score += 5;
+        if (lower.includes('fix') || lower.includes('solution'))
+            score += 4;
+        if (lower.includes('important') || lower.includes('critical'))
+            score += 4;
+        if (lower.includes('decided') || lower.includes('decision'))
+            score += 3;
+        if (lower.includes('todo') || lower.includes('need to'))
+            score += 3;
+        if (lower.includes('created') || lower.includes('added'))
+            score += 2;
+        if (lower.includes('modified') || lower.includes('changed'))
+            score += 2;
+        if (lower.includes('file') || lower.includes('function'))
+            score += 1;
+        // Code indicators
+        if (sentence.includes('`') || sentence.includes('()'))
+            score += 2;
+        if (score > 0) {
+            keywordScores.push({ sentence: sentence.trim(), score });
+        }
+    }
+    // Sort by score and build result within target
+    keywordScores.sort((a, b) => b.score - a.score);
+    const selected = [];
+    let currentLength = 0;
+    for (const item of keywordScores) {
+        if (currentLength + item.sentence.length + 2 <= targetChars) {
+            selected.push(item.sentence);
+            currentLength += item.sentence.length + 2;
+        }
+    }
+    // If no key sentences found, fall back to aggressive truncation
+    if (selected.length === 0) {
+        return aggressiveTruncate(content, targetTokens, model);
+    }
+    const result = `[Key information extracted]\n${selected.join('. ')}.`;
+    const tokenCount = countTokens(result, model);
+    return {
+        content: result,
+        tokenCount,
+        strategy: 'extract-key',
+        originalTokens,
+        compressionRatio: 1 - (tokenCount / originalTokens),
+    };
+}
+/**
+ * Aggressive truncation (last resort)
+ */
+export function aggressiveTruncate(content, targetTokens, model = 'gpt-4') {
+    const originalTokens = countTokens(content, model);
+    const charPerToken = content.length / originalTokens;
+    const targetChars = Math.floor(targetTokens * charPerToken * 0.9); // 10% margin
+    const truncated = content.slice(0, targetChars);
+    const result = `${truncated}\n\n[... content truncated ...]`;
+    const tokenCount = countTokens(result, model);
+    return {
+        content: result,
+        tokenCount,
+        strategy: 'aggressive-truncate',
+        originalTokens,
+        compressionRatio: 1 - (tokenCount / originalTokens),
+    };
+}
+// ============================================================================
+// Progressive Fallback Pipeline
+// ============================================================================
+/**
+ * Apply progressive fallback strategies until target is met
+ */
+export function applyProgressiveFallback(content, targetTokens, config = {}, model = 'gpt-4') {
+    const strategies = [
+        (c, t, m) => applyTruncation(c, t, config, m),
+        removeMiddle,
+        extractKeyInfo,
+        aggressiveTruncate,
+    ];
+    for (const strategy of strategies) {
+        const result = strategy(content, targetTokens, model);
+        if (result.tokenCount <= targetTokens) {
+            logger.debug('Fallback strategy succeeded', {
+                strategy: result.strategy,
+                targetTokens,
+                actualTokens: result.tokenCount,
+                compressionRatio: result.compressionRatio,
+            });
+            return result;
+        }
+        // Reduce target for next iteration
+        targetTokens = Math.floor(targetTokens * 0.8);
+    }
+    // Last resort: aggressive truncate with minimal target
+    return aggressiveTruncate(content, targetTokens, model);
+}
+/**
+ * Apply fallback to messages if summarization failed
+ */
+export function applyMessageFallback(messages, targetTokens, config = {}, model = 'gpt-4') {
+    const startTime = Date.now();
+    const cfg = { ...DEFAULT_COMPACTION_CONFIG, ...config };
+    // Calculate original tokens
+    let originalTokens = 0;
+    for (const message of messages) {
+        originalTokens += countMessageTokens(message, model);
+    }
+    // Format messages as text
+    const text = messages
+        .map(m => {
+        const role = m.role.toUpperCase();
+        const content = typeof m.content === 'string'
+            ? m.content
+            : JSON.stringify(m.content);
+        return `[${role}]: ${content}`;
+    })
+        .join('\n\n');
+    // Apply progressive fallback
+    const fallbackResult = applyProgressiveFallback(text, targetTokens, cfg, model);
+    // Create summary message
+    const summaryMessage = {
+        role: 'system',
+        content: `[Conversation Summary (fallback)]\n\n${fallbackResult.content}`,
+    };
+    const totalTokens = countMessageTokens(summaryMessage, model);
+    return {
+        messages: [summaryMessage],
+        totalTokens,
+        originalTokens,
+        compressionRatio: 1 - (totalTokens / originalTokens),
+        messagesCompacted: messages.length,
+        memoriesFlushed: 0,
+        usedFallback: true,
+        duration: Date.now() - startTime,
+    };
+}
+//# sourceMappingURL=progressive-fallback.js.map

package/dist/context/compaction/progressive-fallback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"progressive-fallback.js","sourceRoot":"","sources":["../../../src/context/compaction/progressive-fallback.ts"],"names":[],"mappings":"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"}

package/dist/context/compaction/types.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Multi-stage Compaction Types
+ *
+ * Types for the multi-stage context compaction system that uses
+ * parallel summarization, adaptive chunking, and memory flushing.
+ */
+import type { ChatMessage } from '../../types/index.js';
+/**
+ * Compaction configuration
+ */
+export interface CompactionConfig {
+    /** Number of parallel chunks for summarization (default: 4) */
+    parallelChunks: number;
+    /** Target compression ratio (default: 0.5 = 50% reduction) */
+    targetRatio: number;
+    /** Minimum messages required for compaction */
+    minMessages: number;
+    /** Maximum retries for oversized results */
+    maxRetries: number;
+    /** Whether to flush to memory before compaction */
+    flushToMemory: boolean;
+    /** Fallback truncation head characters */
+    truncateHeadChars: number;
+    /** Fallback truncation tail characters */
+    truncateTailChars: number;
+}
+/**
+ * Default compaction configuration
+ */
+export declare const DEFAULT_COMPACTION_CONFIG: CompactionConfig;
+/**
+ * A chunk of messages to be summarized
+ */
+export interface MessageChunk {
+    /** Chunk index */
+    index: number;
+    /** Messages in this chunk */
+    messages: ChatMessage[];
+    /** Total tokens in chunk */
+    tokenCount: number;
+}
+/**
+ * Result of summarizing a chunk
+ */
+export interface ChunkSummary {
+    /** Chunk index */
+    index: number;
+    /** Summary text */
+    summary: string;
+    /** Token count of summary */
+    tokenCount: number;
+    /** Original token count */
+    originalTokenCount: number;
+    /** Compression ratio achieved */
+    compressionRatio: number;
+}
+/**
+ * Compaction result
+ */
+export interface CompactionResult {
+    /** Compacted messages (system + summary + recent) */
+    messages: ChatMessage[];
+    /** Total tokens after compaction */
+    totalTokens: number;
+    /** Original token count */
+    originalTokens: number;
+    /** Compression ratio achieved */
+    compressionRatio: number;
+    /** Number of messages compacted */
+    messagesCompacted: number;
+    /** Memories flushed (if enabled) */
+    memoriesFlushed: number;
+    /** Whether fallback was used */
+    usedFallback: boolean;
+    /** Duration in milliseconds */
+    duration: number;
+}
+/**
+ * Memory entry to flush
+ */
+export interface FlushableMemory {
+    /** Content to store */
+    content: string;
+    /** Type of memory */
+    type: 'summary' | 'decision' | 'fact' | 'context';
+    /** Importance score */
+    importance: number;
+    /** Associated tags */
+    tags: string[];
+}
+/**
+ * Adaptive chunk configuration based on message statistics
+ */
+export interface AdaptiveChunkConfig {
+    /** Target tokens per chunk */
+    targetTokensPerChunk: number;
+    /** Minimum chunk size */
+    minChunkSize: number;
+    /** Maximum chunk size */
+    maxChunkSize: number;
+    /** Whether to preserve message boundaries */
+    preserveMessageBoundaries: boolean;
+}
+/**
+ * Message statistics for adaptive chunking
+ */
+export interface MessageStats {
+    /** Total messages */
+    totalMessages: number;
+    /** Total tokens */
+    totalTokens: number;
+    /** Average tokens per message */
+    avgTokensPerMessage: number;
+    /** Max tokens in a message */
+    maxTokensPerMessage: number;
+    /** Min tokens in a message */
+    minTokensPerMessage: number;
+}
+/**
+ * Compaction events
+ */
+export interface CompactionEvents {
+    'compaction:started': {
+        messageCount: number;
+        tokenCount: number;
+    };
+    'compaction:chunk-summarized': ChunkSummary;
+    'compaction:memory-flushed': {
+        count: number;
+    };
+    'compaction:completed': CompactionResult;
+    'compaction:fallback': {
+        reason: string;
+    };
+    'compaction:error': {
+        error: Error;
+    };
+}

package/dist/context/compaction/types.js

@@ -0,0 +1,19 @@
+/**
+ * Multi-stage Compaction Types
+ *
+ * Types for the multi-stage context compaction system that uses
+ * parallel summarization, adaptive chunking, and memory flushing.
+ */
+/**
+ * Default compaction configuration
+ */
+export const DEFAULT_COMPACTION_CONFIG = {
+    parallelChunks: 4,
+    targetRatio: 0.5,
+    minMessages: 10,
+    maxRetries: 3,
+    flushToMemory: true,
+    truncateHeadChars: 1500,
+    truncateTailChars: 1500,
+};
+//# sourceMappingURL=types.js.map

package/dist/context/compaction/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/context/compaction/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA4BH;;GAEG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAqB;IACzD,cAAc,EAAE,CAAC;IACjB,WAAW,EAAE,GAAG;IAChB,WAAW,EAAE,EAAE;IACf,UAAU,EAAE,CAAC;IACb,aAAa,EAAE,IAAI;IACnB,iBAAiB,EAAE,IAAI;IACvB,iBAAiB,EAAE,IAAI;CACxB,CAAC"}

package/dist/context/compression.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Context Compression
+ *
+ * Provides various strategies to reduce the token count of a conversation
+ * while maintaining its coherence and essential instructions.
+ */
+import { CodeBuddyMessage } from '../codebuddy/client.js';
+import { TokenCounter } from './token-counter.js';
+import { CompressionResult } from './types.js';
+/**
+ * Options to control the compression process.
+ */
+export interface CompressionOptions {
+    /** Target ratio to compress the older parts of the conversation. */
+    targetRatio?: number;
+    /** Whether to ensure the system prompt is never removed. */
+    preserveSystemPrompt?: boolean;
+    /** Number of most recent messages to protect from any compression. */
+    preserveRecentMessages?: number;
+}
+/**
+ * Context Compression Engine.
+ * Implements a multi-stage approach to context reduction:
+ * 1. Tool Truncation: Shortens long tool outputs (logs, file contents).
+ * 2. Sliding Window: Removes the oldest non-system messages.
+ * 3. Hard Truncation: Emergency strategy to force-fit into the limit.
+ */
+export declare class ContextCompressor {
+    private tokenCounter;
+    /**
+     * Creates a new ContextCompressor.
+     * @param tokenCounter - Implementation used to measure the impact of compression.
+     */
+    constructor(tokenCounter: TokenCounter);
+    /**
+     * Compresses a list of messages to fit within a specific token limit.
+     *
+     * @param messages - The messages to compress.
+     * @param tokenLimit - The maximum allowed tokens.
+     * @param options - Compression constraints.
+     * @returns A result object containing the new message list and compression stats.
+     */
+    compress(messages: CodeBuddyMessage[], tokenLimit: number, options?: CompressionOptions): CompressionResult;
+    /**
+     * Helper to count tokens for a list of messages.
+     */
+    private countTotalTokens;
+    /**
+     * Helper to count tokens for a single message (for incremental calculations).
+     */
+    private countSingleMessageTokens;
+    /**
+     * Strategy: Truncate long content from tool messages.
+     */
+    private truncateToolOutputs;
+    /**
+     * Emergency strategy: remove messages from the middle/end until limit is met.
+     * Prioritizes keeping the system prompt and the very latest messages.
+     */
+    private hardTruncate;
+}

package/dist/context/compression.js

@@ -0,0 +1,179 @@
+/**
+ * Context Compression
+ *
+ * Provides various strategies to reduce the token count of a conversation
+ * while maintaining its coherence and essential instructions.
+ */
+/**
+ * Context Compression Engine.
+ * Implements a multi-stage approach to context reduction:
+ * 1. Tool Truncation: Shortens long tool outputs (logs, file contents).
+ * 2. Sliding Window: Removes the oldest non-system messages.
+ * 3. Hard Truncation: Emergency strategy to force-fit into the limit.
+ */
+export class ContextCompressor {
+    tokenCounter;
+    /**
+     * Creates a new ContextCompressor.
+     * @param tokenCounter - Implementation used to measure the impact of compression.
+     */
+    constructor(tokenCounter) {
+        this.tokenCounter = tokenCounter;
+    }
+    /**
+     * Compresses a list of messages to fit within a specific token limit.
+     *
+     * @param messages - The messages to compress.
+     * @param tokenLimit - The maximum allowed tokens.
+     * @param options - Compression constraints.
+     * @returns A result object containing the new message list and compression stats.
+     */
+    compress(messages, tokenLimit, options = {}) {
+        const initialTokens = this.countTotalTokens(messages);
+        if (initialTokens <= tokenLimit) {
+            return {
+                compressed: false,
+                messages,
+                tokensReduced: 0,
+                strategy: 'none'
+            };
+        }
+        // Clone to avoid mutation
+        let processedMessages = [...messages];
+        const systemMessage = options.preserveSystemPrompt ? processedMessages.find(m => m.role === 'system') : null;
+        const recentCount = options.preserveRecentMessages !== undefined ? options.preserveRecentMessages : 2;
+        // Filter out system message if we're preserving it separately to add back later
+        if (systemMessage) {
+            processedMessages = processedMessages.filter(m => m.role !== 'system');
+        }
+        // Separate recent messages
+        const recentMessages = recentCount > 0 ? processedMessages.slice(-recentCount) : [];
+        let olderMessages = recentCount > 0 ? processedMessages.slice(0, -recentCount) : processedMessages;
+        // Strategy 1: Truncate tool outputs (often very large)
+        olderMessages = this.truncateToolOutputs(olderMessages);
+        // Reassemble to check if we're good
+        let currentSet = [];
+        if (systemMessage) {
+            currentSet.push(systemMessage);
+        }
+        currentSet.push(...olderMessages, ...recentMessages);
+        let currentTokens = this.countTotalTokens(currentSet);
+        if (currentTokens <= tokenLimit) {
+            return {
+                compressed: true,
+                messages: currentSet,
+                tokensReduced: initialTokens - currentTokens,
+                strategy: 'tool_truncation'
+            };
+        }
+        // Strategy 2: Sliding Window (Aggressive) - O(n) optimization
+        // Pre-calculate token counts for older messages to enable O(1) updates
+        // Instead of rebuilding array and recounting on each iteration
+        const olderMessageTokens = olderMessages.map(msg => this.countSingleMessageTokens(msg));
+        let olderStartIndex = 0;
+        while (olderStartIndex < olderMessages.length && currentTokens > tokenLimit) {
+            // Subtract tokens of removed message instead of recounting all
+            currentTokens -= olderMessageTokens[olderStartIndex];
+            olderStartIndex++;
+        }
+        // Build final array only once after we know which messages to keep
+        if (olderStartIndex > 0) {
+            olderMessages = olderMessages.slice(olderStartIndex);
+            currentSet = [];
+            if (systemMessage) {
+                currentSet.push(systemMessage);
+            }
+            currentSet.push(...olderMessages, ...recentMessages);
+        }
+        // If still over limit (extreme case where recent messages are huge), truncate recent messages content
+        if (currentTokens > tokenLimit) {
+            // This is a hard truncation scenario
+            return {
+                compressed: true,
+                messages: this.hardTruncate(currentSet, tokenLimit),
+                tokensReduced: initialTokens - tokenLimit, // Approximate
+                strategy: 'hard_truncation'
+            };
+        }
+        return {
+            compressed: true,
+            messages: currentSet,
+            tokensReduced: initialTokens - currentTokens,
+            strategy: 'sliding_window'
+        };
+    }
+    /**
+     * Helper to count tokens for a list of messages.
+     */
+    countTotalTokens(messages) {
+        const tokenMessages = messages.map(msg => ({
+            role: msg.role,
+            content: typeof msg.content === 'string' ? msg.content : null,
+            tool_calls: 'tool_calls' in msg ? msg.tool_calls : undefined,
+        }));
+        return this.tokenCounter.countMessageTokens(tokenMessages);
+    }
+    /**
+     * Helper to count tokens for a single message (for incremental calculations).
+     */
+    countSingleMessageTokens(msg) {
+        return this.tokenCounter.countMessageTokens([{
+                role: msg.role,
+                content: typeof msg.content === 'string' ? msg.content : null,
+                tool_calls: 'tool_calls' in msg ? msg.tool_calls : undefined,
+            }]);
+    }
+    /**
+     * Strategy: Truncate long content from tool messages.
+     */
+    truncateToolOutputs(messages) {
+        const MAX_TOOL_OUTPUT = 500;
+        return messages.map(msg => {
+            if (msg.role === 'tool' && typeof msg.content === 'string' && msg.content.length > MAX_TOOL_OUTPUT) {
+                return {
+                    ...msg,
+                    content: msg.content.slice(0, MAX_TOOL_OUTPUT) + '... [truncated]'
+                };
+            }
+            return msg;
+        });
+    }
+    /**
+     * Emergency strategy: remove messages from the middle/end until limit is met.
+     * Prioritizes keeping the system prompt and the very latest messages.
+     */
+    hardTruncate(messages, limit) {
+        // Basic implementation: just return what fits, priority to system then recent
+        // This is a "save the ship" strategy
+        const result = [];
+        let currentTokens = 0;
+        // Always keep system if present
+        const system = messages.find(m => m.role === 'system');
+        if (system) {
+            result.push(system);
+            currentTokens += this.countTotalTokens([system]);
+        }
+        // Try to add from most recent backwards
+        const reverseMsgs = [...messages].reverse().filter(m => m.role !== 'system');
+        for (const msg of reverseMsgs) {
+            const msgTokens = this.countTotalTokens([msg]);
+            if (currentTokens + msgTokens <= limit) {
+                result.unshift(msg);
+                currentTokens += msgTokens;
+            }
+            else {
+                break;
+            }
+        }
+        // Ensure system is first
+        if (system && result[0] !== system) {
+            // Should already be handled but safety check
+            const idx = result.indexOf(system);
+            if (idx >= 0)
+                result.splice(idx, 1);
+            result.unshift(system);
+        }
+        return result;
+    }
+}
+//# sourceMappingURL=compression.js.map