erosolar-cli 1.5.12 → 1.5.14

package/dist/core/contextManager.d.ts

@@ -14,6 +14,25 @@ import type { ConversationMessage } from './types.js';
  * Takes messages to summarize and returns a concise summary string
  */
 export type SummarizationCallback = (messages: ConversationMessage[]) => Promise<string>;
+/**
+ * Signals that indicate a good compaction point in the conversation
+ */
+export interface CompactionSignal {
+    type: 'task_boundary' | 'topic_shift' | 'milestone' | 'context_saturation' | 'user_pivot';
+    confidence: number;
+    messageIndex: number;
+    reason: string;
+}
+/**
+ * Result of intelligent compaction analysis
+ */
+export interface CompactionAnalysis {
+    shouldCompact: boolean;
+    signals: CompactionSignal[];
+    recommendedCompactionPoint: number | null;
+    urgency: 'none' | 'low' | 'medium' | 'high' | 'critical';
+    preserveFromIndex: number;
+}
 /**
  * Summarization prompt template
  */
@@ -29,6 +48,11 @@ export interface ContextManagerConfig {
     useLLMSummarization?: boolean;
     summarizationCallback?: SummarizationCallback;
     model?: string;
+    enableIntelligentCompaction?: boolean;
+    compactionThreshold?: number;
+    minSignalConfidence?: number;
+    taskBoundaryPatterns?: string[];
+    topicShiftSensitivity?: number;
 }
 export interface TruncationResult {
     content: string;
@@ -106,6 +130,80 @@ export declare class ContextManager {
      * Update configuration
      */
     updateConfig(config: Partial<ContextManagerConfig>): void;
+    /**
+     * Default patterns that indicate task boundaries
+     */
+    private static readonly DEFAULT_TASK_BOUNDARY_PATTERNS;
+    /**
+     * Patterns indicating topic/task shifts
+     */
+    private static readonly TOPIC_SHIFT_PATTERNS;
+    /**
+     * Patterns indicating user pivots (abandoning current direction)
+     */
+    private static readonly USER_PIVOT_PATTERNS;
+    /**
+     * Analyze the conversation to detect intelligent compaction points
+     */
+    analyzeCompactionPoints(messages: ConversationMessage[]): CompactionAnalysis;
+    /**
+     * Detect task boundary signals
+     */
+    private detectTaskBoundary;
+    /**
+     * Detect topic shift signals
+     */
+    private detectTopicShift;
+    /**
+     * Detect user pivot signals (abandoning current direction)
+     */
+    private detectUserPivot;
+    /**
+     * Detect context saturation (heavy tool output regions)
+     */
+    private detectContextSaturation;
+    /**
+     * Detect milestone signals (significant accomplishments)
+     */
+    private detectMilestone;
+    /**
+     * Check if content looks like a task conclusion
+     */
+    private looksLikeConclusion;
+    /**
+     * Check if two contents represent different topics (simple heuristic)
+     */
+    private isNewTopic;
+    /**
+     * Calculate urgency level based on token percentage
+     */
+    private calculateUrgency;
+    /**
+     * Find the best compaction point from signals
+     */
+    private findBestCompactionPoint;
+    /**
+     * Find a safe preservation point that doesn't break tool call chains
+     */
+    private findSafePreservePoint;
+    /**
+     * Perform intelligent compaction based on analysis
+     * This method analyzes the conversation and compacts at the optimal point
+     */
+    intelligentCompact(messages: ConversationMessage[]): Promise<{
+        compacted: ConversationMessage[];
+        analysis: CompactionAnalysis;
+        summarized: boolean;
+    }>;
+    /**
+     * Check if intelligent compaction should be triggered
+     * Call this before generation to proactively manage context
+     */
+    shouldTriggerCompaction(messages: ConversationMessage[]): {
+        shouldCompact: boolean;
+        urgency: CompactionAnalysis['urgency'];
+        reason: string | null;
+    };
 }
 /**
  * Create a default context manager instance with model-aware limits

package/dist/core/contextManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contextManager.d.ts","sourceRoot":"","sources":["../../src/core/contextManager.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"contextManager.d.ts","sourceRoot":"","sources":["../../src/core/contextManager.ts"],"names":[],"mappings":"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"}

package/dist/core/contextManager.js

@@ -468,6 +468,471 @@ export class ContextManager {
     updateConfig(config) {
         this.config = { ...this.config, ...config };
     }
+    // ============================================================================
+    // INTELLIGENT COMPACTION SYSTEM
+    // Automatically detects optimal points for conversation compaction
+    // ============================================================================
+    /**
+     * Default patterns that indicate task boundaries
+     */
+    static DEFAULT_TASK_BOUNDARY_PATTERNS = [
+        // Completion indicators
+        /\b(done|completed|finished|fixed|resolved|implemented|added|created|updated)\b/i,
+        /\b(all\s+(?:tests?\s+)?pass(?:ing|ed)?)\b/i,
+        /\b(successfully|works?\s+(?:now|correctly))\b/i,
+        // Transition indicators
+        /\b(next|now\s+(?:let's|we\s+can)|moving\s+on)\b/i,
+        /\b(that's\s+(?:it|all|done))\b/i,
+        // Acknowledgment patterns
+        /^(?:great|perfect|thanks|thank\s+you|got\s+it|understood)\b/i,
+    ];
+    /**
+     * Patterns indicating topic/task shifts
+     */
+    static TOPIC_SHIFT_PATTERNS = [
+        /\b(different|another|new|separate|unrelated)\s+(?:task|thing|topic|issue|question)\b/i,
+        /\b(can\s+you|could\s+you|please|now|let's)\s+(?:also|help|do|make|create|fix|add)\b/i,
+        /\b(switching|changing|moving)\s+to\b/i,
+        /\b(forget|ignore|never\s*mind)\s+(?:that|the|about)\b/i,
+        /^(?:ok|okay|alright|anyway|so)\s*[,.]?\s*(?:can|could|now|let|please)/i,
+    ];
+    /**
+     * Patterns indicating user pivots (abandoning current direction)
+     */
+    static USER_PIVOT_PATTERNS = [
+        /\b(actually|wait|hold\s+on|stop|cancel|scratch\s+that)\b/i,
+        /\b(let's\s+(?:try|do)\s+(?:something|it)\s+(?:else|differently))\b/i,
+        /\b(go\s+back|revert|undo|start\s+over)\b/i,
+        /\b(wrong|not\s+(?:what|right)|that's\s+not)\b/i,
+    ];
+    /**
+     * Analyze the conversation to detect intelligent compaction points
+     */
+    analyzeCompactionPoints(messages) {
+        const signals = [];
+        const totalTokens = this.estimateTotalTokens(messages);
+        const tokenPercentage = totalTokens / this.config.maxTokens;
+        const compactionThreshold = this.config.compactionThreshold ?? 0.5;
+        const minConfidence = this.config.minSignalConfidence ?? 0.6;
+        // Don't analyze if below threshold
+        if (tokenPercentage < compactionThreshold) {
+            return {
+                shouldCompact: false,
+                signals: [],
+                recommendedCompactionPoint: null,
+                urgency: 'none',
+                preserveFromIndex: 0,
+            };
+        }
+        // Analyze each message for compaction signals
+        for (let i = 0; i < messages.length; i++) {
+            const msg = messages[i];
+            if (!msg)
+                continue;
+            // Detect task boundaries
+            const taskBoundary = this.detectTaskBoundary(msg, i, messages);
+            if (taskBoundary && taskBoundary.confidence >= minConfidence) {
+                signals.push(taskBoundary);
+            }
+            // Detect topic shifts
+            const topicShift = this.detectTopicShift(msg, i, messages);
+            if (topicShift && topicShift.confidence >= minConfidence) {
+                signals.push(topicShift);
+            }
+            // Detect user pivots
+            const userPivot = this.detectUserPivot(msg, i);
+            if (userPivot && userPivot.confidence >= minConfidence) {
+                signals.push(userPivot);
+            }
+            // Detect context saturation (tool output heavy regions)
+            const saturation = this.detectContextSaturation(msg, i, messages);
+            if (saturation && saturation.confidence >= minConfidence) {
+                signals.push(saturation);
+            }
+            // Detect milestones
+            const milestone = this.detectMilestone(msg, i, messages);
+            if (milestone && milestone.confidence >= minConfidence) {
+                signals.push(milestone);
+            }
+        }
+        // Determine urgency based on token percentage
+        const urgency = this.calculateUrgency(tokenPercentage);
+        // Find the best compaction point
+        const recommendedPoint = this.findBestCompactionPoint(signals, messages, urgency);
+        // Calculate preserve index (everything after this should be kept)
+        const preserveFromIndex = recommendedPoint !== null
+            ? this.findSafePreservePoint(recommendedPoint, messages)
+            : messages.length;
+        return {
+            shouldCompact: signals.length > 0 && urgency !== 'none',
+            signals,
+            recommendedCompactionPoint: recommendedPoint,
+            urgency,
+            preserveFromIndex,
+        };
+    }
+    /**
+     * Detect task boundary signals
+     */
+    detectTaskBoundary(msg, index, messages) {
+        if (msg.role !== 'user' && msg.role !== 'assistant')
+            return null;
+        const content = msg.content || '';
+        const patterns = this.config.taskBoundaryPatterns
+            ? this.config.taskBoundaryPatterns.map(p => new RegExp(p, 'i'))
+            : ContextManager.DEFAULT_TASK_BOUNDARY_PATTERNS;
+        let matchCount = 0;
+        const reasons = [];
+        for (const pattern of patterns) {
+            if (pattern.test(content)) {
+                matchCount++;
+                reasons.push(pattern.source.slice(0, 30));
+            }
+        }
+        if (matchCount === 0)
+            return null;
+        // Higher confidence if followed by a new user message with different intent
+        let confidence = Math.min(0.4 + matchCount * 0.2, 0.9);
+        // Boost confidence if this looks like a conclusion
+        if (msg.role === 'assistant' && this.looksLikeConclusion(content)) {
+            confidence = Math.min(confidence + 0.2, 0.95);
+        }
+        // Boost if next user message starts a new topic
+        const nextUserMsg = messages.slice(index + 1).find(m => m.role === 'user');
+        if (nextUserMsg && this.isNewTopic(content, nextUserMsg.content || '')) {
+            confidence = Math.min(confidence + 0.15, 0.95);
+        }
+        return {
+            type: 'task_boundary',
+            confidence,
+            messageIndex: index,
+            reason: `Task completion detected: ${reasons.slice(0, 2).join(', ')}`,
+        };
+    }
+    /**
+     * Detect topic shift signals
+     */
+    detectTopicShift(msg, index, messages) {
+        if (msg.role !== 'user')
+            return null;
+        const content = msg.content || '';
+        const sensitivity = this.config.topicShiftSensitivity ?? 0.7;
+        // Check explicit shift patterns
+        for (const pattern of ContextManager.TOPIC_SHIFT_PATTERNS) {
+            if (pattern.test(content)) {
+                return {
+                    type: 'topic_shift',
+                    confidence: 0.7 + sensitivity * 0.2,
+                    messageIndex: index,
+                    reason: 'Explicit topic shift language detected',
+                };
+            }
+        }
+        // Check semantic shift from previous context
+        const prevMessages = messages.slice(Math.max(0, index - 5), index);
+        const prevContent = prevMessages
+            .filter(m => m.role === 'user' || m.role === 'assistant')
+            .map(m => m.content || '')
+            .join(' ');
+        if (prevContent && this.isNewTopic(prevContent, content)) {
+            return {
+                type: 'topic_shift',
+                confidence: 0.6 + sensitivity * 0.2,
+                messageIndex: index,
+                reason: 'Semantic topic shift detected',
+            };
+        }
+        return null;
+    }
+    /**
+     * Detect user pivot signals (abandoning current direction)
+     */
+    detectUserPivot(msg, index) {
+        if (msg.role !== 'user')
+            return null;
+        const content = msg.content || '';
+        for (const pattern of ContextManager.USER_PIVOT_PATTERNS) {
+            if (pattern.test(content)) {
+                return {
+                    type: 'user_pivot',
+                    confidence: 0.85,
+                    messageIndex: index,
+                    reason: 'User pivot/direction change detected',
+                };
+            }
+        }
+        return null;
+    }
+    /**
+     * Detect context saturation (heavy tool output regions)
+     */
+    detectContextSaturation(msg, index, messages) {
+        if (msg.role !== 'tool')
+            return null;
+        // Look at the surrounding region
+        const windowStart = Math.max(0, index - 10);
+        const windowEnd = Math.min(messages.length, index + 5);
+        const window = messages.slice(windowStart, windowEnd);
+        // Count tool messages and their sizes
+        let toolCount = 0;
+        let totalToolSize = 0;
+        for (const m of window) {
+            if (m.role === 'tool') {
+                toolCount++;
+                totalToolSize += (m.content || '').length;
+            }
+        }
+        // High saturation if many tool outputs with large content
+        if (toolCount >= 5 && totalToolSize > 20000) {
+            // Find the last tool message in this cluster as compaction point
+            let lastToolIndex = index;
+            for (let i = index + 1; i < windowEnd; i++) {
+                if (messages[i]?.role === 'tool') {
+                    lastToolIndex = i;
+                }
+                else if (messages[i]?.role === 'user') {
+                    break; // Stop at next user message
+                }
+            }
+            return {
+                type: 'context_saturation',
+                confidence: Math.min(0.5 + toolCount * 0.05, 0.85),
+                messageIndex: lastToolIndex,
+                reason: `Heavy tool output region (${toolCount} tools, ${Math.round(totalToolSize / 1000)}k chars)`,
+            };
+        }
+        return null;
+    }
+    /**
+     * Detect milestone signals (significant accomplishments)
+     */
+    detectMilestone(msg, index, _messages) {
+        if (msg.role !== 'assistant')
+            return null;
+        const content = msg.content || '';
+        // Look for milestone indicators
+        const milestonePatterns = [
+            /\b(commit(?:ted)?|pushed|deployed|merged|released)\b/i,
+            /\b(all\s+tests?\s+pass(?:ing|ed)?)\b/i,
+            /\b(build\s+(?:succeed|success|pass))\b/i,
+            /\b(feature\s+(?:complete|done|ready))\b/i,
+            /\b(pr\s+(?:created|opened|merged))\b/i,
+        ];
+        for (const pattern of milestonePatterns) {
+            if (pattern.test(content)) {
+                return {
+                    type: 'milestone',
+                    confidence: 0.9,
+                    messageIndex: index,
+                    reason: 'Significant milestone achieved',
+                };
+            }
+        }
+        return null;
+    }
+    /**
+     * Check if content looks like a task conclusion
+     */
+    looksLikeConclusion(content) {
+        const conclusionPatterns = [
+            /\b(let\s+me\s+know|feel\s+free|if\s+you\s+(?:need|have|want))\b/i,
+            /\b(anything\s+else|other\s+questions?)\b/i,
+            /\b(should\s+be\s+(?:good|working|ready|done))\b/i,
+            /\b(that\s+should|this\s+(?:should|will))\s+(?:fix|solve|work)/i,
+        ];
+        return conclusionPatterns.some(p => p.test(content));
+    }
+    /**
+     * Check if two contents represent different topics (simple heuristic)
+     */
+    isNewTopic(prevContent, newContent) {
+        // Extract key terms (simple tokenization)
+        const extractTerms = (text) => {
+            const words = text.toLowerCase()
+                .replace(/[^a-z0-9\s]/g, ' ')
+                .split(/\s+/)
+                .filter(w => w.length > 3);
+            return new Set(words);
+        };
+        const prevTerms = extractTerms(prevContent);
+        const newTerms = extractTerms(newContent);
+        if (prevTerms.size === 0 || newTerms.size === 0)
+            return false;
+        // Calculate overlap
+        let overlap = 0;
+        for (const term of newTerms) {
+            if (prevTerms.has(term))
+                overlap++;
+        }
+        const overlapRatio = overlap / Math.min(prevTerms.size, newTerms.size);
+        // Low overlap suggests new topic
+        return overlapRatio < 0.2;
+    }
+    /**
+     * Calculate urgency level based on token percentage
+     */
+    calculateUrgency(tokenPercentage) {
+        if (tokenPercentage >= 0.9)
+            return 'critical';
+        if (tokenPercentage >= 0.75)
+            return 'high';
+        if (tokenPercentage >= 0.6)
+            return 'medium';
+        if (tokenPercentage >= 0.5)
+            return 'low';
+        return 'none';
+    }
+    /**
+     * Find the best compaction point from signals
+     */
+    findBestCompactionPoint(signals, messages, urgency) {
+        if (signals.length === 0)
+            return null;
+        // Score each signal based on type priority and confidence
+        const typePriority = {
+            milestone: 1.0,
+            task_boundary: 0.9,
+            user_pivot: 0.85,
+            topic_shift: 0.8,
+            context_saturation: 0.7,
+        };
+        // Urgency affects how far back we're willing to compact
+        const urgencyDepth = {
+            none: 0,
+            low: 0.3, // Compact only recent 30%
+            medium: 0.5,
+            high: 0.7,
+            critical: 0.9,
+        };
+        const maxDepth = urgencyDepth[urgency] ?? 0.5;
+        const minIndex = Math.floor(messages.length * (1 - maxDepth));
+        // Find highest scoring signal within allowed depth
+        let bestSignal = null;
+        let bestScore = 0;
+        for (const signal of signals) {
+            if (signal.messageIndex < minIndex)
+                continue;
+            const score = signal.confidence * typePriority[signal.type];
+            if (score > bestScore) {
+                bestScore = score;
+                bestSignal = signal;
+            }
+        }
+        return bestSignal?.messageIndex ?? null;
+    }
+    /**
+     * Find a safe preservation point that doesn't break tool call chains
+     */
+    findSafePreservePoint(compactionPoint, messages) {
+        // Start from compaction point and move forward to find a safe break
+        for (let i = compactionPoint + 1; i < messages.length; i++) {
+            const msg = messages[i];
+            if (!msg)
+                continue;
+            // Safe if it's a user message
+            if (msg.role === 'user') {
+                return i;
+            }
+            // Safe if it's an assistant without pending tool calls
+            if (msg.role === 'assistant' && !msg.toolCalls?.length) {
+                return i;
+            }
+        }
+        // If no safe point found, keep more messages
+        return Math.min(compactionPoint + 1, messages.length);
+    }
+    /**
+     * Perform intelligent compaction based on analysis
+     * This method analyzes the conversation and compacts at the optimal point
+     */
+    async intelligentCompact(messages) {
+        // Analyze for compaction points
+        const analysis = this.analyzeCompactionPoints(messages);
+        // If no compaction needed or no good point found
+        if (!analysis.shouldCompact || analysis.recommendedCompactionPoint === null) {
+            return {
+                compacted: messages,
+                analysis,
+                summarized: false,
+            };
+        }
+        // Separate messages to summarize and preserve
+        const firstMessage = messages[0];
+        const systemMessage = firstMessage?.role === 'system' ? firstMessage : null;
+        const startIndex = systemMessage ? 1 : 0;
+        const toSummarize = messages.slice(startIndex, analysis.preserveFromIndex);
+        const toPreserve = messages.slice(analysis.preserveFromIndex);
+        // If nothing to summarize, return as-is
+        if (toSummarize.length === 0) {
+            return {
+                compacted: messages,
+                analysis,
+                summarized: false,
+            };
+        }
+        // Build result
+        const compacted = [];
+        if (systemMessage) {
+            compacted.push(systemMessage);
+        }
+        // Try LLM summarization if available
+        if (this.config.summarizationCallback && this.config.useLLMSummarization !== false) {
+            try {
+                const summary = await this.config.summarizationCallback(toSummarize);
+                compacted.push({
+                    role: 'system',
+                    content: [
+                        '=== Intelligent Context Summary ===',
+                        `Compaction triggered: ${analysis.signals[0]?.reason || 'Context optimization'}`,
+                        '',
+                        summary.trim(),
+                        '',
+                        `[Summarized ${toSummarize.length} messages. ${toPreserve.length} recent messages preserved.]`,
+                    ].join('\n'),
+                });
+                compacted.push(...toPreserve);
+                return {
+                    compacted,
+                    analysis,
+                    summarized: true,
+                };
+            }
+            catch {
+                // Fall through to simple compaction
+            }
+        }
+        // Simple compaction without LLM
+        compacted.push({
+            role: 'system',
+            content: `[Context Manager: Intelligently compacted ${toSummarize.length} messages at "${analysis.signals[0]?.reason || 'optimal point'}". ${toPreserve.length} recent messages preserved.]`,
+        });
+        compacted.push(...toPreserve);
+        return {
+            compacted,
+            analysis,
+            summarized: false,
+        };
+    }
+    /**
+     * Check if intelligent compaction should be triggered
+     * Call this before generation to proactively manage context
+     */
+    shouldTriggerCompaction(messages) {
+        if (this.config.enableIntelligentCompaction === false) {
+            return { shouldCompact: false, urgency: 'none', reason: null };
+        }
+        const analysis = this.analyzeCompactionPoints(messages);
+        if (!analysis.shouldCompact) {
+            return { shouldCompact: false, urgency: analysis.urgency, reason: null };
+        }
+        const topSignal = analysis.signals
+            .sort((a, b) => b.confidence - a.confidence)[0];
+        return {
+            shouldCompact: true,
+            urgency: analysis.urgency,
+            reason: topSignal?.reason || 'Context optimization recommended',
+        };
+    }
 }
 /**
  * Create a default context manager instance with model-aware limits
@@ -484,6 +949,11 @@ export function createDefaultContextManager(overrides, model) {
         preserveRecentMessages: 5, // Keep last 5 exchanges
         estimatedCharsPerToken: 3.5, // More aggressive estimate (accounts for special tokens, JSON overhead)
         useLLMSummarization: true, // Enable LLM summarization by default
+        // Intelligent compaction defaults
+        enableIntelligentCompaction: true,
+        compactionThreshold: 0.5, // Start analyzing at 50% context usage
+        minSignalConfidence: 0.6, // Require 60% confidence for compaction signals
+        topicShiftSensitivity: 0.7, // Moderately sensitive to topic changes
         model,
         ...overrides,
     });