erosolar-cli 1.7.14 → 1.7.16

package/dist/bin/core/toolRuntime.js

@@ -1,290 +0,0 @@
-import { ToolArgumentValidationError, validateToolArguments, } from './schemaValidator.js';
-// Idempotent tools that can be safely cached
-const CACHEABLE_TOOLS = new Set([
-    'Read',
-    'read_file',
-    'Glob',
-    'glob_search',
-    'Grep',
-    'grep_search',
-    'find_definition',
-    'analyze_code_quality',
-    'extract_exports',
-]);
-export class ToolRuntime {
-    constructor(baseTools = [], options = {}) {
-        this.registry = new Map();
-        this.registrationOrder = [];
-        this.cache = new Map();
-        this.observer = options.observer ?? null;
-        this.contextManager = options.contextManager ?? null;
-        this.enableCache = options.enableCache ?? true;
-        this.cacheTTLMs = options.cacheTTLMs ?? 5 * 60 * 1000; // 5 minutes default
-        if (baseTools.length) {
-            this.registerSuite({
-                id: 'runtime.core',
-                description: 'Core runtime metadata tools',
-                tools: baseTools,
-            });
-        }
-    }
-    registerSuite(suite) {
-        if (!suite?.id?.trim()) {
-            throw new Error('Tool suite id cannot be blank.');
-        }
-        this.unregisterSuite(suite.id);
-        for (const definition of suite.tools ?? []) {
-            this.addTool(definition, suite.id);
-        }
-    }
-    unregisterSuite(id) {
-        if (!id?.trim()) {
-            return;
-        }
-        for (const [name, record] of this.registry.entries()) {
-            if (record.suiteId === id) {
-                this.registry.delete(name);
-                this.removeFromOrder(name);
-            }
-        }
-    }
-    listProviderTools() {
-        return this.registrationOrder
-            .map((name) => this.registry.get(name))
-            .filter((record) => Boolean(record))
-            .map(({ definition }) => {
-            const tool = {
-                name: definition.name,
-                description: definition.description,
-            };
-            if (definition.parameters) {
-                tool.parameters = definition.parameters;
-            }
-            return tool;
-        });
-    }
-    async execute(call) {
-        const record = this.registry.get(call.name);
-        if (!record) {
-            const message = `Tool "${call.name}" is not available.`;
-            this.observer?.onToolError?.(call, message);
-            return message;
-        }
-        // Check if tool is cacheable
-        const isCacheable = record.definition.cacheable ?? CACHEABLE_TOOLS.has(call.name);
-        // Try to get from cache
-        if (this.enableCache && isCacheable) {
-            const cacheKey = this.getCacheKey(call);
-            const cached = this.cache.get(cacheKey);
-            if (cached && Date.now() - cached.timestamp < this.cacheTTLMs) {
-                this.observer?.onCacheHit?.(call);
-                this.observer?.onToolResult?.(call, cached.result);
-                return cached.result;
-            }
-        }
-        this.observer?.onToolStart?.(call);
-        try {
-            const args = normalizeToolArguments(call.arguments);
-            validateToolArguments(record.definition.name, record.definition.parameters, args);
-            const result = await record.definition.handler(args);
-            let output = typeof result === 'string' ? result : JSON.stringify(result, null, 2);
-            // Truncate output if context manager is available
-            if (this.contextManager) {
-                const truncated = this.contextManager.truncateToolOutput(output, call.name);
-                if (truncated.wasTruncated) {
-                    output = truncated.content;
-                    // Log truncation for debugging
-                    if (process.env['DEBUG_CONTEXT']) {
-                        console.warn(`[Context Manager] Truncated ${call.name} output: ${truncated.originalLength} -> ${truncated.truncatedLength} chars`);
-                    }
-                }
-            }
-            // Cache the result if cacheable
-            if (this.enableCache && isCacheable) {
-                const cacheKey = this.getCacheKey(call);
-                this.cache.set(cacheKey, {
-                    result: output,
-                    timestamp: Date.now(),
-                });
-            }
-            this.observer?.onToolResult?.(call, output);
-            return output;
-        }
-        catch (error) {
-            let formatted;
-            if (error instanceof ToolArgumentValidationError) {
-                formatted = error.message;
-            }
-            else {
-                const message = error instanceof Error ? error.message : String(error);
-                formatted = `Failed to run "${call.name}": ${message}`;
-            }
-            this.observer?.onToolError?.(call, formatted);
-            return formatted;
-        }
-    }
-    getCacheKey(call) {
-        return `${call.name}:${JSON.stringify(call.arguments)}`;
-    }
-    clearCache() {
-        this.cache.clear();
-    }
-    getCacheStats() {
-        let totalSize = 0;
-        for (const entry of this.cache.values()) {
-            totalSize += entry.result.length;
-        }
-        return {
-            size: totalSize,
-            entries: this.cache.size,
-        };
-    }
-    addTool(definition, suiteId) {
-        if (!definition?.name?.trim()) {
-            throw new Error(`Tool names cannot be blank (suite "${suiteId}").`);
-        }
-        if (this.registry.has(definition.name)) {
-            const owner = this.registry.get(definition.name)?.suiteId ?? 'unknown';
-            throw new Error(`Tool "${definition.name}" already registered by suite "${owner}".`);
-        }
-        this.registry.set(definition.name, {
-            suiteId,
-            definition,
-        });
-        this.registrationOrder.push(definition.name);
-    }
-    removeFromOrder(name) {
-        const index = this.registrationOrder.indexOf(name);
-        if (index >= 0) {
-            this.registrationOrder.splice(index, 1);
-        }
-    }
-}
-export function createDefaultToolRuntime(context, toolSuites = [], options = {}) {
-    const runtime = new ToolRuntime([
-        buildContextSnapshotTool(context.workspaceContext),
-        buildCapabilitiesTool(context),
-        buildProfileInspectorTool(context),
-    ], options);
-    for (const suite of toolSuites) {
-        runtime.registerSuite(suite);
-    }
-    return runtime;
-}
-function buildContextSnapshotTool(workspaceContext) {
-    return {
-        name: 'context_snapshot',
-        description: 'Returns a summary of the repository context. NOTE: Full context is already in your system prompt - only use this if you need to refresh or verify the context.',
-        parameters: {
-            type: 'object',
-            properties: {
-                format: {
-                    type: 'string',
-                    description: 'Use "plain" for raw text or "markdown" for a fenced block.',
-                    enum: ['plain', 'markdown'],
-                },
-            },
-        },
-        handler: (args) => {
-            if (!workspaceContext?.trim()) {
-                return 'Workspace context is unavailable.';
-            }
-            // CRITICAL: Return only summary to prevent context duplication
-            // Full context is already in system prompt
-            const lines = workspaceContext.trim().split('\n');
-            const totalLines = lines.length;
-            // Return just first 20 lines + summary
-            const preview = lines.slice(0, 20).join('\n');
-            const summary = [
-                preview,
-                '',
-                `[Workspace context: ${totalLines} total lines]`,
-                `[Full context already available in system prompt - use Read/Glob tools for specific files]`
-            ].join('\n');
-            const format = args['format'] === 'markdown' ? 'markdown' : 'plain';
-            if (format === 'markdown') {
-                return ['```text', summary, '```'].join('\n');
-            }
-            return summary;
-        },
-    };
-}
-function buildCapabilitiesTool(context) {
-    return {
-        name: 'capabilities_overview',
-        description: 'Summarizes the agent runtime capabilities including available tools and features.',
-        parameters: {
-            type: 'object',
-            properties: {
-                audience: {
-                    type: 'string',
-                    enum: ['developer', 'model'],
-                    description: 'Tailors the tone of the description.',
-                },
-            },
-        },
-        handler: (args) => {
-            const audience = args['audience'];
-            const adjective = audience === 'developer' ? 'Operator facing' : 'Model facing';
-            return [
-                `${adjective} capabilities summary:`,
-                '- Full file system access (read, write, list, search).',
-                '- Bash command execution for running scripts and tools.',
-                '- Advanced code search and pattern matching.',
-                '- Deterministic workspace context snapshot appended to the system prompt.',
-                '- Tool invocations are logged in realtime for transparency.',
-                `- Active provider: ${context.provider} (${context.model}).`,
-            ].join('\n');
-        },
-    };
-}
-function buildProfileInspectorTool(context) {
-    return {
-        name: 'profile_details',
-        description: 'Returns the configuration of the active CLI profile.',
-        parameters: {
-            type: 'object',
-            properties: {
-                includeWorkspaceContext: {
-                    type: 'boolean',
-                    description: 'Set true to append the workspace context snapshot if available.',
-                },
-            },
-            additionalProperties: false,
-        },
-        handler: (args) => {
-            const payload = {
-                profile: context.profileName,
-                provider: context.provider,
-                model: context.model,
-                workspaceContext: args['includeWorkspaceContext'] ? context.workspaceContext ?? null : null,
-            };
-            return JSON.stringify(payload, null, 2);
-        },
-    };
-}
-function normalizeToolArguments(value) {
-    if (value instanceof Map) {
-        return Object.fromEntries(value.entries());
-    }
-    if (isRecord(value)) {
-        return value;
-    }
-    if (typeof value === 'string') {
-        const trimmed = value.trim();
-        if (!trimmed) {
-            return {};
-        }
-        try {
-            const parsed = JSON.parse(trimmed);
-            return isRecord(parsed) ? parsed : {};
-        }
-        catch {
-            return {};
-        }
-    }
-    return {};
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}

package/dist/bin/core/types.js

@@ -1 +0,0 @@
-export {};

package/dist/bin/shell/bracketedPasteManager.js

@@ -1,350 +0,0 @@
-/**
- * Bracketed paste manager for handling terminal paste operations.
- *
- * This class handles the bracketed paste mode in terminals, which allows
- * pasted text to be distinguished from typed input. This is particularly
- * useful for handling multi-line pastes and preventing unwanted execution
- * of commands during paste operations.
- */
-export class BracketedPasteManager {
-    constructor(enabled) {
-        this.inPaste = false;
-        this.pasteBuffer = [];
-        /** Tracks accumulated multi-line input even without bracketed paste support */
-        this.multiLineBuffer = [];
-        this.multiLineMode = false;
-        this.lastInputTime = 0;
-        /** Time threshold (ms) to consider rapid input as paste */
-        this.PASTE_THRESHOLD_MS = 50;
-        /** Raw data buffer for capturing complete bracketed paste content */
-        this.rawPasteBuffer = '';
-        /** Callback for when raw paste is complete */
-        this.onRawPasteComplete = null;
-        /** Whether we're currently capturing raw data */
-        this.capturingRaw = false;
-        this.enabled = enabled;
-    }
-    /**
-     * Process raw data from stdin before readline handles it.
-     * This intercepts bracketed paste content and captures it in full.
-     * Returns true if the data was consumed (should not be passed to readline).
-     */
-    processRawData(data) {
-        if (!this.enabled) {
-            return { consumed: false };
-        }
-        const startIdx = data.indexOf(BracketedPasteManager.START_MARKER);
-        const endIdx = data.indexOf(BracketedPasteManager.END_MARKER);
-        // Case 1: Not in paste mode and no start marker - pass through
-        if (!this.capturingRaw && startIdx === -1) {
-            return { consumed: false };
-        }
-        // Case 2: Found start marker - begin capturing
-        if (!this.capturingRaw && startIdx !== -1) {
-            this.capturingRaw = true;
-            const beforeStart = data.substring(0, startIdx);
-            const afterStart = data.substring(startIdx + BracketedPasteManager.START_MARKER.length);
-            // Check if end marker is in same chunk
-            const endInAfter = afterStart.indexOf(BracketedPasteManager.END_MARKER);
-            if (endInAfter !== -1) {
-                // Complete paste in single chunk
-                const pasteContent = afterStart.substring(0, endInAfter);
-                const afterEnd = afterStart.substring(endInAfter + BracketedPasteManager.END_MARKER.length);
-                this.capturingRaw = false;
-                this.rawPasteBuffer = '';
-                // Emit the complete paste
-                if (this.onRawPasteComplete) {
-                    this.onRawPasteComplete(pasteContent);
-                }
-                // Return any content before/after markers to be passed through
-                const passThrough = beforeStart + afterEnd;
-                return { consumed: true, passThrough: passThrough || undefined };
-            }
-            // Start marker found but no end marker yet
-            this.rawPasteBuffer = afterStart;
-            // Pass through anything before the start marker
-            return { consumed: true, passThrough: beforeStart || undefined };
-        }
-        // Case 3: Currently capturing and found end marker
-        if (this.capturingRaw && endIdx !== -1) {
-            const beforeEnd = data.substring(0, endIdx);
-            const afterEnd = data.substring(endIdx + BracketedPasteManager.END_MARKER.length);
-            const pasteContent = this.rawPasteBuffer + beforeEnd;
-            this.capturingRaw = false;
-            this.rawPasteBuffer = '';
-            // Emit the complete paste
-            if (this.onRawPasteComplete) {
-                this.onRawPasteComplete(pasteContent);
-            }
-            // Pass through anything after end marker
-            return { consumed: true, passThrough: afterEnd || undefined };
-        }
-        // Case 4: Currently capturing, no end marker - accumulate
-        if (this.capturingRaw) {
-            this.rawPasteBuffer += data;
-            return { consumed: true };
-        }
-        return { consumed: false };
-    }
-    /**
-     * Set callback for when a complete paste is captured via raw data processing
-     */
-    setRawPasteCallback(callback) {
-        this.onRawPasteComplete = callback;
-    }
-    /**
-     * Check if currently capturing raw paste data
-     */
-    isCapturingRaw() {
-        return this.capturingRaw;
-    }
-    /**
-     * Get current raw buffer size (for display)
-     */
-    getRawBufferLineCount() {
-        if (!this.rawPasteBuffer)
-            return 0;
-        return this.rawPasteBuffer.split('\n').length;
-    }
-    /**
-     * Get preview of raw buffer content
-     */
-    getRawBufferPreview() {
-        if (!this.rawPasteBuffer)
-            return '';
-        const lines = this.rawPasteBuffer.split('\n');
-        return this.getPreview(lines);
-    }
-    /**
-     * Process input text, handling bracketed paste sequences
-     */
-    process(input) {
-        if (!this.enabled) {
-            return this.processWithoutBracketed(input);
-        }
-        const startMarker = '\u001b[200~';
-        const endMarker = '\u001b[201~';
-        // If we're already in a paste, look for end marker
-        if (this.inPaste) {
-            const endIndex = input.indexOf(endMarker);
-            if (endIndex !== -1) {
-                // End of paste found
-                const beforeEnd = input.substring(0, endIndex);
-                const afterEnd = input.substring(endIndex + endMarker.length);
-                this.pasteBuffer.push(beforeEnd);
-                const result = this.pasteBuffer.join('\n');
-                const lineCount = this.pasteBuffer.length;
-                const preview = this.getPreview(this.pasteBuffer);
-                // Reset state
-                this.inPaste = false;
-                this.pasteBuffer = [];
-                // If there's text after the end marker, process it normally
-                if (afterEnd) {
-                    const afterResult = this.process(afterEnd);
-                    if (afterResult.handled && afterResult.result !== undefined) {
-                        return {
-                            handled: true,
-                            result: result + afterResult.result,
-                            lineCount,
-                            preview,
-                        };
-                    }
-                    return {
-                        handled: true,
-                        result: result + afterEnd,
-                        lineCount,
-                        preview,
-                    };
-                }
-                return {
-                    handled: true,
-                    result,
-                    lineCount,
-                    preview,
-                };
-            }
-            else {
-                // Still in paste, no end marker found
-                this.pasteBuffer.push(input);
-                return {
-                    handled: true,
-                    isPending: true,
-                    lineCount: this.pasteBuffer.length,
-                    preview: this.getPreview(this.pasteBuffer),
-                };
-            }
-        }
-        // Not in paste, look for start marker
-        const startIndex = input.indexOf(startMarker);
-        if (startIndex !== -1) {
-            // Start of paste found
-            const beforeStart = input.substring(0, startIndex);
-            const afterStart = input.substring(startIndex + startMarker.length);
-            // Start paste mode
-            this.inPaste = true;
-            this.pasteBuffer = [];
-            // Process the text after the start marker
-            if (afterStart) {
-                const afterResult = this.process(afterStart);
-                if (afterResult.handled && afterResult.result !== undefined) {
-                    return {
-                        handled: true,
-                        result: beforeStart + afterResult.result,
-                        lineCount: afterResult.lineCount,
-                        preview: afterResult.preview,
-                    };
-                }
-                // Still pending
-                return {
-                    handled: true,
-                    result: beforeStart,
-                    isPending: this.inPaste,
-                    lineCount: this.pasteBuffer.length,
-                    preview: this.getPreview(this.pasteBuffer),
-                };
-            }
-            return {
-                handled: true,
-                result: beforeStart,
-                isPending: true,
-                lineCount: 0,
-            };
-        }
-        // No paste markers found
-        return { handled: false };
-    }
-    /**
-     * Process input when bracketed paste is not enabled
-     * Uses timing heuristics to detect rapid multi-line input (likely paste)
-     */
-    processWithoutBracketed(input) {
-        const now = Date.now();
-        const timeSinceLastInput = now - this.lastInputTime;
-        this.lastInputTime = now;
-        // Check if this looks like part of a rapid paste
-        if (timeSinceLastInput < this.PASTE_THRESHOLD_MS && this.multiLineBuffer.length > 0) {
-            // Continue accumulating
-            this.multiLineBuffer.push(input);
-            this.multiLineMode = true;
-            return {
-                handled: true,
-                isPending: true,
-                lineCount: this.multiLineBuffer.length,
-                preview: this.getPreview(this.multiLineBuffer),
-            };
-        }
-        // If we were in multi-line mode and there's a pause, finalize
-        if (this.multiLineMode && this.multiLineBuffer.length > 0) {
-            this.multiLineBuffer.push(input);
-            const result = this.multiLineBuffer.join('\n');
-            const lineCount = this.multiLineBuffer.length;
-            const preview = this.getPreview(this.multiLineBuffer);
-            this.multiLineBuffer = [];
-            this.multiLineMode = false;
-            return {
-                handled: true,
-                result,
-                lineCount,
-                preview,
-            };
-        }
-        // Check for embedded newlines in a single input (indicates paste)
-        if (input.includes('\n')) {
-            const lines = input.split('\n');
-            return {
-                handled: true,
-                result: input,
-                lineCount: lines.length,
-                preview: this.getPreview(lines),
-            };
-        }
-        // Start tracking for potential multi-line paste
-        this.multiLineBuffer = [input];
-        return { handled: false };
-    }
-    /**
-     * Generate a preview string for multi-line content
-     */
-    getPreview(lines) {
-        if (lines.length === 0) {
-            return '';
-        }
-        const firstLine = lines[0] || '';
-        const truncatedFirst = firstLine.length > 50
-            ? firstLine.slice(0, 47) + '...'
-            : firstLine;
-        if (lines.length === 1) {
-            return truncatedFirst;
-        }
-        return `${truncatedFirst} [+${lines.length - 1} more lines]`;
-    }
-    /**
-     * Get current multi-line state for display purposes
-     */
-    getMultiLineState() {
-        const buffer = this.inPaste ? this.pasteBuffer :
-            this.multiLineMode ? this.multiLineBuffer : null;
-        if (!buffer || buffer.length === 0) {
-            return null;
-        }
-        const firstLine = buffer[0] || '';
-        const lastLine = buffer[buffer.length - 1] || '';
-        return {
-            content: buffer.join('\n'),
-            lineCount: buffer.length,
-            firstLinePreview: firstLine.length > 40 ? firstLine.slice(0, 37) + '...' : firstLine,
-            lastLinePreview: lastLine.length > 40 ? lastLine.slice(0, 37) + '...' : lastLine,
-        };
-    }
-    /**
-     * Format a multi-line paste as a collapsed block for display
-     */
-    static formatCollapsedBlock(content, maxPreviewLength = 60) {
-        const lines = content.split('\n');
-        if (lines.length <= 1) {
-            return content;
-        }
-        const firstLine = (lines[0] || '').trim();
-        const truncatedFirst = firstLine.length > maxPreviewLength
-            ? firstLine.slice(0, maxPreviewLength - 3) + '...'
-            : firstLine;
-        return `📋 ${truncatedFirst} [${lines.length} lines]`;
-    }
-    /**
-     * Check if currently processing a paste
-     */
-    isInPaste() {
-        return this.inPaste || this.multiLineMode;
-    }
-    /**
-     * Get the current paste buffer
-     */
-    getPasteBuffer() {
-        return this.inPaste ? [...this.pasteBuffer] : [...this.multiLineBuffer];
-    }
-    /**
-     * Finalize any pending multi-line input
-     */
-    finalize() {
-        if (this.multiLineMode && this.multiLineBuffer.length > 1) {
-            const result = this.multiLineBuffer.join('\n');
-            this.multiLineBuffer = [];
-            this.multiLineMode = false;
-            return result;
-        }
-        return null;
-    }
-    /**
-     * Reset the paste state
-     */
-    reset() {
-        this.inPaste = false;
-        this.pasteBuffer = [];
-        this.multiLineMode = false;
-        this.multiLineBuffer = [];
-        this.rawPasteBuffer = '';
-        this.capturingRaw = false;
-    }
-}
-BracketedPasteManager.START_MARKER = '\u001b[200~';
-BracketedPasteManager.END_MARKER = '\u001b[201~';