erosolar-cli 1.7.14 → 1.7.16

package/dist/bin/core/contextManager.js

@@ -1,412 +0,0 @@
-/**
- * ContextManager - Manages conversation context to prevent token limit leaks
- *
- * Responsibilities:
- * - Truncate tool outputs intelligently
- * - Prune old conversation history with LLM summarization
- * - Track and estimate token usage
- * - Keep conversation within budget based on model context windows
- * - Proactively shrink context before hitting limits
- */
-import { calculateContextThresholds } from './contextWindow.js';
-/**
- * Summarization prompt template
- */
-export const SUMMARIZATION_PROMPT = `You are a context summarization assistant. Your task is to create a concise but comprehensive summary of the earlier conversation history.
-
-IMPORTANT GUIDELINES:
-1. Preserve KEY INFORMATION that may be needed for future reference:
-   - File paths and locations mentioned
-   - Variable names, function names, class names
-   - Error messages and their solutions
-   - User preferences and decisions
-   - Important code snippets (keep brief)
-   - Task progress and what was accomplished
-
-2. Keep the summary CONCISE but COMPLETE:
-   - Focus on facts and outcomes, not back-and-forth dialogue
-   - Use bullet points for clarity
-   - Group related information together
-   - Skip pleasantries and redundant confirmations
-
-3. Format the summary as:
-   ## Key Context
-   - [Important decisions and preferences]
-
-   ## Work Completed
-   - [What was done, files modified, etc.]
-
-   ## Important Details
-   - [File paths, function names, error solutions, etc.]
-
-Summarize the following conversation history:
-
-{conversation}`;
-export class ContextManager {
-    constructor(config = {}) {
-        this.config = {
-            maxTokens: 130000, // Leave room below 131072 limit
-            targetTokens: 100000, // Target to trigger pruning
-            maxToolOutputLength: 10000, // 10k chars max per tool output
-            preserveRecentMessages: 10, // Keep last 10 user/assistant exchanges
-            estimatedCharsPerToken: 4,
-            ...config,
-        };
-    }
-    /**
-     * Truncate tool output intelligently
-     */
-    truncateToolOutput(output, toolName) {
-        const originalLength = output.length;
-        if (originalLength <= this.config.maxToolOutputLength) {
-            return {
-                content: output,
-                wasTruncated: false,
-                originalLength,
-                truncatedLength: originalLength,
-            };
-        }
-        // Intelligent truncation based on tool type
-        let truncated = this.intelligentTruncate(output, toolName);
-        const truncatedLength = truncated.length;
-        return {
-            content: truncated,
-            wasTruncated: true,
-            originalLength,
-            truncatedLength,
-        };
-    }
-    /**
-     * Intelligent truncation based on tool type
-     */
-    intelligentTruncate(output, toolName) {
-        const maxLength = this.config.maxToolOutputLength;
-        // For file reads, show beginning and end
-        if (toolName === 'Read' || toolName === 'read_file') {
-            return this.truncateFileOutput(output, maxLength);
-        }
-        // For search results, keep first N results
-        if (toolName === 'Grep' || toolName === 'grep_search' || toolName === 'Glob') {
-            return this.truncateSearchOutput(output, maxLength);
-        }
-        // For bash/command output, keep end (usually most relevant)
-        if (toolName === 'Bash' || toolName === 'bash' || toolName === 'execute_bash') {
-            return this.truncateBashOutput(output, maxLength);
-        }
-        // Default: show beginning with truncation notice
-        return this.truncateDefault(output, maxLength);
-    }
-    truncateFileOutput(output, maxLength) {
-        const lines = output.split('\n');
-        if (lines.length <= 100) {
-            // For small files, just truncate text
-            return this.truncateDefault(output, maxLength);
-        }
-        // Show first 50 and last 50 lines
-        const keepLines = Math.floor(maxLength / 100); // Rough estimate
-        const headLines = lines.slice(0, keepLines);
-        const tailLines = lines.slice(-keepLines);
-        const truncatedCount = lines.length - (keepLines * 2);
-        return [
-            ...headLines,
-            `\n... [${truncatedCount} lines truncated for context management] ...\n`,
-            ...tailLines,
-        ].join('\n');
-    }
-    truncateSearchOutput(output, maxLength) {
-        const lines = output.split('\n');
-        const keepLines = Math.floor(maxLength / 80); // Rough average line length
-        if (lines.length <= keepLines) {
-            return output;
-        }
-        const truncatedCount = lines.length - keepLines;
-        return [
-            ...lines.slice(0, keepLines),
-            `\n... [${truncatedCount} more results truncated for context management] ...`,
-        ].join('\n');
-    }
-    truncateBashOutput(output, maxLength) {
-        if (output.length <= maxLength) {
-            return output;
-        }
-        // For command output, the end is usually most important (errors, final status)
-        const keepChars = Math.floor(maxLength * 0.8); // 80% at end
-        const prefixChars = maxLength - keepChars - 100; // Small prefix
-        const prefix = output.slice(0, prefixChars);
-        const suffix = output.slice(-keepChars);
-        const truncatedChars = output.length - prefixChars - keepChars;
-        return `${prefix}\n\n... [${truncatedChars} characters truncated for context management] ...\n\n${suffix}`;
-    }
-    truncateDefault(output, maxLength) {
-        if (output.length <= maxLength) {
-            return output;
-        }
-        const truncatedChars = output.length - maxLength + 100; // Account for notice
-        return `${output.slice(0, maxLength - 100)}\n\n... [${truncatedChars} characters truncated for context management] ...`;
-    }
-    /**
-     * Estimate tokens in a message
-     */
-    estimateTokens(message) {
-        let charCount = 0;
-        if (message.content) {
-            charCount += message.content.length;
-        }
-        if (message.role === 'assistant' && message.toolCalls) {
-            // Tool calls add overhead
-            for (const call of message.toolCalls) {
-                charCount += call.name.length;
-                charCount += JSON.stringify(call.arguments).length;
-            }
-        }
-        return Math.ceil(charCount / this.config.estimatedCharsPerToken);
-    }
-    /**
-     * Estimate total tokens in conversation
-     */
-    estimateTotalTokens(messages) {
-        return messages.reduce((sum, msg) => sum + this.estimateTokens(msg), 0);
-    }
-    /**
-     * Prune old messages when approaching limit
-     *
-     * Synchronously removes old messages to stay within budget.
-     * If LLM summarization is available and enabled, this method will be async.
-     */
-    pruneMessages(messages) {
-        const totalTokens = this.estimateTotalTokens(messages);
-        // Only prune if we're above target
-        if (totalTokens < this.config.targetTokens) {
-            return { pruned: messages, removed: 0 };
-        }
-        // Always keep system message (first)
-        const firstMessage = messages[0];
-        const systemMessage = firstMessage?.role === 'system' ? firstMessage : null;
-        const conversationMessages = systemMessage ? messages.slice(1) : messages;
-        // Keep recent messages based on preserveRecentMessages
-        // Count user/assistant pairs
-        const recentMessages = [];
-        let exchangeCount = 0;
-        for (let i = conversationMessages.length - 1; i >= 0; i--) {
-            const msg = conversationMessages[i];
-            if (!msg)
-                continue;
-            recentMessages.unshift(msg);
-            if (msg.role === 'user') {
-                exchangeCount++;
-                if (exchangeCount >= this.config.preserveRecentMessages) {
-                    break;
-                }
-            }
-        }
-        // Build pruned message list
-        const pruned = [];
-        if (systemMessage) {
-            pruned.push(systemMessage);
-        }
-        // Add a context summary message if we removed messages
-        const removedCount = conversationMessages.length - recentMessages.length;
-        if (removedCount > 0) {
-            pruned.push({
-                role: 'system',
-                content: `[Context Manager: Removed ${removedCount} old messages to stay within token budget. Recent conversation history preserved.]`,
-            });
-        }
-        pruned.push(...recentMessages);
-        return {
-            pruned,
-            removed: removedCount,
-        };
-    }
-    /**
-     * Prune messages with LLM-based summarization
-     *
-     * This is an async version that uses the LLM to create intelligent summaries
-     * instead of just removing old messages. Should be called BEFORE generation.
-     */
-    async pruneMessagesWithSummary(messages) {
-        const totalTokens = this.estimateTotalTokens(messages);
-        // Only prune if we're above target
-        if (totalTokens < this.config.targetTokens) {
-            return { pruned: messages, removed: 0, summarized: false };
-        }
-        // If no summarization callback or disabled, fall back to simple pruning
-        if (!this.config.summarizationCallback || !this.config.useLLMSummarization) {
-            const result = this.pruneMessages(messages);
-            return { ...result, summarized: false };
-        }
-        // Partition messages
-        const firstMessage = messages[0];
-        const systemMessage = firstMessage?.role === 'system' ? firstMessage : null;
-        const conversationMessages = systemMessage ? messages.slice(1) : messages;
-        // Keep recent messages
-        const recentMessages = [];
-        let exchangeCount = 0;
-        for (let i = conversationMessages.length - 1; i >= 0; i--) {
-            const msg = conversationMessages[i];
-            if (!msg)
-                continue;
-            recentMessages.unshift(msg);
-            if (msg.role === 'user') {
-                exchangeCount++;
-                if (exchangeCount >= this.config.preserveRecentMessages) {
-                    break;
-                }
-            }
-        }
-        const toSummarize = conversationMessages.slice(0, conversationMessages.length - recentMessages.length);
-        // If nothing to summarize, return as-is
-        if (toSummarize.length === 0) {
-            return { pruned: messages, removed: 0, summarized: false };
-        }
-        try {
-            // Call the LLM to summarize old messages
-            const summary = await this.config.summarizationCallback(toSummarize);
-            // Build pruned message list with summary
-            const pruned = [];
-            if (systemMessage) {
-                pruned.push(systemMessage);
-            }
-            // Add intelligent summary
-            pruned.push({
-                role: 'system',
-                content: [
-                    '=== Context Summary (Auto-generated) ===',
-                    summary.trim(),
-                    '',
-                    `[Summarized ${toSummarize.length} earlier messages. Recent ${recentMessages.length} messages preserved below.]`,
-                ].join('\n'),
-            });
-            pruned.push(...recentMessages);
-            return {
-                pruned,
-                removed: toSummarize.length,
-                summarized: true,
-            };
-        }
-        catch (error) {
-            // If summarization fails, fall back to simple pruning
-            const result = this.pruneMessages(messages);
-            return { ...result, summarized: false };
-        }
-    }
-    /**
-     * Check if we're approaching the limit
-     */
-    isApproachingLimit(messages) {
-        const totalTokens = this.estimateTotalTokens(messages);
-        return totalTokens >= this.config.targetTokens;
-    }
-    /**
-     * Get warning level for current context usage
-     * Returns: null (no warning), 'info' (<70%), 'warning' (70-90%), 'danger' (>90%)
-     */
-    getWarningLevel(messages) {
-        const totalTokens = this.estimateTotalTokens(messages);
-        const percentage = (totalTokens / this.config.maxTokens) * 100;
-        if (percentage > 90) {
-            return 'danger';
-        }
-        else if (percentage > 70) {
-            return 'warning';
-        }
-        else if (percentage > 50) {
-            return 'info';
-        }
-        return null;
-    }
-    /**
-     * Get a human-readable warning message
-     */
-    getWarningMessage(messages) {
-        const stats = this.getStats(messages);
-        const warningLevel = this.getWarningLevel(messages);
-        if (warningLevel === 'danger') {
-            return `⚠️ Context usage critical (${stats.percentage}%). Consider starting a new session or the next request may fail.`;
-        }
-        else if (warningLevel === 'warning') {
-            return `Context usage high (${stats.percentage}%). Automatic cleanup will occur soon.`;
-        }
-        return null;
-    }
-    /**
-     * Get context stats
-     */
-    getStats(messages) {
-        const totalTokens = this.estimateTotalTokens(messages);
-        const percentage = Math.round((totalTokens / this.config.maxTokens) * 100);
-        return {
-            totalTokens,
-            percentage,
-            isOverLimit: totalTokens >= this.config.maxTokens,
-            isApproachingLimit: totalTokens >= this.config.targetTokens,
-        };
-    }
-    /**
-     * Update configuration
-     */
-    updateConfig(config) {
-        this.config = { ...this.config, ...config };
-    }
-}
-/**
- * Create a default context manager instance with model-aware limits
- */
-export function createDefaultContextManager(overrides, model) {
-    // Get model-specific thresholds
-    const thresholds = calculateContextThresholds(model);
-    return new ContextManager({
-        maxTokens: thresholds.maxTokens,
-        targetTokens: thresholds.targetTokens, // Start pruning at 60%
-        warningTokens: thresholds.warningTokens, // Warn at 50%
-        criticalTokens: thresholds.criticalTokens, // Critical at 75%
-        maxToolOutputLength: 5000, // 5k chars max per tool (reduced for safety)
-        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
-        model,
-        ...overrides,
-    });
-}
-/**
- * Format conversation messages into readable text for summarization
- */
-export function formatMessagesForSummary(messages) {
-    const lines = [];
-    for (const msg of messages) {
-        if (msg.role === 'user') {
-            lines.push(`USER: ${msg.content}`);
-        }
-        else if (msg.role === 'assistant') {
-            let content = msg.content || '';
-            if (msg.toolCalls && msg.toolCalls.length > 0) {
-                const toolNames = msg.toolCalls.map(tc => tc.name);
-                content += ` [Called tools: ${toolNames.join(', ')}]`;
-            }
-            lines.push(`ASSISTANT: ${content}`);
-        }
-        else if (msg.role === 'tool') {
-            // Truncate long tool outputs for summarization
-            const output = msg.content.length > 500
-                ? msg.content.slice(0, 500) + '...'
-                : msg.content;
-            lines.push(`TOOL (${msg.name}): ${output}`);
-        }
-        // Skip system messages in summary input
-    }
-    return lines.join('\n\n');
-}
-/**
- * Create a summarization callback using the given provider
- */
-export function createSummarizationCallback(provider) {
-    return async (messages) => {
-        // Format messages into readable conversation
-        const conversationText = formatMessagesForSummary(messages);
-        // Create summarization prompt
-        const prompt = SUMMARIZATION_PROMPT.replace('{conversation}', conversationText);
-        // Call provider to generate summary (no tools needed)
-        const response = await provider.generate([{ role: 'user', content: prompt }], []);
-        return response.content || '';
-    };
-}

package/dist/bin/core/contextWindow.js

@@ -1,122 +0,0 @@
-/**
- * Model Context Window Management
- *
- * Maps models to their context window sizes and provides utilities
- * for dynamic context limit configuration.
- */
-const MODEL_CONTEXT_WINDOWS = [
-    // OpenAI GPT-5.x series (200K context)
-    { pattern: /^gpt-5\.1-?codex/i, contextWindow: 200000, targetTokens: 140000 },
-    { pattern: /^gpt-5(?:\.1|-?pro|-?mini|-?nano|-?max)/i, contextWindow: 200000, targetTokens: 140000 },
-    { pattern: /^gpt-5$/i, contextWindow: 200000, targetTokens: 140000 },
-    // OpenAI GPT-4o series (128K context)
-    { pattern: /^gpt-4o/i, contextWindow: 128000, targetTokens: 90000 },
-    { pattern: /^gpt-4-turbo/i, contextWindow: 128000, targetTokens: 90000 },
-    { pattern: /^gpt-4-(?:0125|1106)/i, contextWindow: 128000, targetTokens: 90000 },
-    // OpenAI GPT-4 (8K-32K context)
-    { pattern: /^gpt-4-32k/i, contextWindow: 32000, targetTokens: 24000 },
-    { pattern: /^gpt-4(?![o-])/i, contextWindow: 8192, targetTokens: 6000 },
-    // OpenAI o1/o3 reasoning models (200K context)
-    { pattern: /^o1(?:-pro|-mini)?/i, contextWindow: 200000, targetTokens: 140000 },
-    { pattern: /^o3(?:-pro|-mini)?/i, contextWindow: 200000, targetTokens: 140000 },
-    // OpenAI GPT-3.5 (16K context)
-    { pattern: /^gpt-3\.5-turbo-16k/i, contextWindow: 16000, targetTokens: 12000 },
-    { pattern: /^gpt-3\.5/i, contextWindow: 4096, targetTokens: 3000 },
-    // Anthropic Claude 4.x series (200K context)
-    { pattern: /^claude-(?:sonnet|opus|haiku)-4/i, contextWindow: 200000, targetTokens: 140000 },
-    { pattern: /^(?:sonnet|opus|haiku)-4/i, contextWindow: 200000, targetTokens: 140000 },
-    // Anthropic Claude 3.x series (200K context)
-    { pattern: /^claude-3/i, contextWindow: 200000, targetTokens: 140000 },
-    // Anthropic Claude 2.x (100K context)
-    { pattern: /^claude-2/i, contextWindow: 100000, targetTokens: 70000 },
-    // Google Gemini Pro (1M+ context, capped at 200K for safety)
-    { pattern: /^gemini-(?:1\.5|2\.0)-(?:pro|flash)/i, contextWindow: 1000000, targetTokens: 200000 },
-    { pattern: /^gemini-pro/i, contextWindow: 32000, targetTokens: 24000 },
-    // DeepSeek (64K-128K context)
-    { pattern: /^deepseek-(?:chat|coder|reasoner)/i, contextWindow: 128000, targetTokens: 90000 },
-    { pattern: /^deepseek/i, contextWindow: 64000, targetTokens: 45000 },
-    // xAI Grok (128K context)
-    { pattern: /^grok/i, contextWindow: 128000, targetTokens: 90000 },
-    // Ollama/Local models
-    { pattern: /^llama-?3\.?[12]?:?(?:70b|405b)/i, contextWindow: 128000, targetTokens: 90000 },
-    { pattern: /^llama-?3/i, contextWindow: 8192, targetTokens: 6000 },
-    { pattern: /^llama-?2/i, contextWindow: 4096, targetTokens: 3000 },
-    { pattern: /^mistral/i, contextWindow: 32000, targetTokens: 24000 },
-    { pattern: /^mixtral/i, contextWindow: 32000, targetTokens: 24000 },
-    { pattern: /^codellama/i, contextWindow: 16000, targetTokens: 12000 },
-    { pattern: /^qwen/i, contextWindow: 32000, targetTokens: 24000 },
-    { pattern: /^phi/i, contextWindow: 4096, targetTokens: 3000 },
-];
-// Default fallback values
-const DEFAULT_CONTEXT_WINDOW = 128000;
-const DEFAULT_TARGET_TOKENS = 90000;
-/**
- * Get context window information for a model.
- */
-export function getModelContextInfo(model) {
-    if (!model) {
-        return {
-            model: 'unknown',
-            contextWindow: DEFAULT_CONTEXT_WINDOW,
-            targetTokens: DEFAULT_TARGET_TOKENS,
-            isDefault: true,
-        };
-    }
-    const normalized = model.trim();
-    for (const entry of MODEL_CONTEXT_WINDOWS) {
-        if (entry.pattern.test(normalized)) {
-            return {
-                model,
-                contextWindow: entry.contextWindow,
-                targetTokens: entry.targetTokens,
-                isDefault: false,
-            };
-        }
-    }
-    return {
-        model,
-        contextWindow: DEFAULT_CONTEXT_WINDOW,
-        targetTokens: DEFAULT_TARGET_TOKENS,
-        isDefault: true,
-    };
-}
-/**
- * Returns the approximate context window (in tokens) for the provided model id.
- * Falls back to null when the model is unknown so callers can handle gracefully.
- */
-export function getContextWindowTokens(model) {
-    if (!model) {
-        return null;
-    }
-    const info = getModelContextInfo(model);
-    return info.isDefault ? null : info.contextWindow;
-}
-/**
- * Get safe target token count for a model.
- * This is the threshold at which context pruning should begin.
- */
-export function getSafeTargetTokens(model) {
-    const info = getModelContextInfo(model);
-    return info.targetTokens;
-}
-/**
- * Calculate all context management thresholds for a model.
- *
- * Thresholds are set conservatively to prevent context overflow errors:
- * - targetTokens: Start proactive pruning at 60% to leave ample room
- * - warningTokens: Show warning at 50% so user is aware
- * - criticalTokens: Aggressive pruning at 75%
- * - safetyBuffer: Reserve 5% for API overhead and response tokens
- */
-export function calculateContextThresholds(model) {
-    const info = getModelContextInfo(model);
-    const contextWindow = info.contextWindow;
-    // Apply 5% safety buffer to account for API overhead
-    const effectiveMax = Math.floor(contextWindow * 0.95);
-    return {
-        maxTokens: effectiveMax,
-        targetTokens: Math.floor(contextWindow * 0.60), // Start pruning at 60% (more aggressive)
-        warningTokens: Math.floor(contextWindow * 0.50), // Warn at 50%
-        criticalTokens: Math.floor(contextWindow * 0.75), // Critical at 75%
-    };
-}

package/dist/bin/core/customCommands.js

@@ -1,80 +0,0 @@
-import { existsSync, readdirSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-const dataRoot = process.env['EROSOLAR_DATA_DIR']?.trim() || join(homedir(), '.erosolar');
-const defaultCommandsDir = process.env['EROSOLAR_COMMANDS_DIR']?.trim() || join(dataRoot, 'commands');
-export function loadCustomSlashCommands(dir = defaultCommandsDir) {
-    if (!existsSync(dir)) {
-        return [];
-    }
-    const files = readdirSync(dir).filter((file) => file.toLowerCase().endsWith('.json'));
-    const commands = [];
-    const seen = new Set();
-    for (const file of files) {
-        const filePath = join(dir, file);
-        try {
-            const raw = readFileSync(filePath, 'utf8');
-            const parsed = JSON.parse(raw);
-            if (Array.isArray(parsed)) {
-                for (const entry of parsed) {
-                    const cmd = normalizeCommand(entry, filePath);
-                    if (cmd && !seen.has(cmd.command)) {
-                        seen.add(cmd.command);
-                        commands.push(cmd);
-                    }
-                }
-            }
-            else {
-                const cmd = normalizeCommand(parsed, filePath);
-                if (cmd && !seen.has(cmd.command)) {
-                    seen.add(cmd.command);
-                    commands.push(cmd);
-                }
-            }
-        }
-        catch (error) {
-            console.warn(`[custom commands] Failed to load ${filePath}:`, error);
-        }
-    }
-    return commands;
-}
-export function buildCustomCommandPrompt(command, input, context) {
-    const replacements = {
-        input,
-        workspace: context.workspace,
-        profile: context.profile,
-        provider: context.provider,
-        model: context.model,
-    };
-    return command.template.replace(/\{\{\s*(\w+)\s*\}\}/g, (_, key) => {
-        const normalized = key.toLowerCase();
-        return replacements[normalized] ?? replacements[key] ?? '';
-    });
-}
-function normalizeCommand(entry, source) {
-    if (!entry || typeof entry !== 'object') {
-        return null;
-    }
-    const record = entry;
-    const rawCommandValue = record['command'];
-    const rawCommand = typeof rawCommandValue === 'string' ? rawCommandValue.trim() : '';
-    const command = rawCommand ? (rawCommand.startsWith('/') ? rawCommand : `/${rawCommand}`) : '';
-    const descriptionValue = record['description'];
-    const description = typeof descriptionValue === 'string' && descriptionValue.trim()
-        ? descriptionValue.trim()
-        : 'Custom command';
-    const templateEntry = record['template'] ?? record['prompt'];
-    const templateValue = typeof templateEntry === 'string' ? templateEntry : '';
-    if (!command || !templateValue.trim()) {
-        return null;
-    }
-    const requireInputEntry = record['requireInput'] ?? record['inputRequired'];
-    const requireInput = typeof requireInputEntry === 'boolean' ? requireInputEntry : false;
-    return {
-        command,
-        description,
-        template: templateValue,
-        requireInput,
-        source,
-    };
-}