erosolar-cli 1.7.13 → 1.7.15

package/dist/bin/ui/orchestration/StatusOrchestrator.js

@@ -1,403 +0,0 @@
-/**
- * StatusOrchestrator - Unified status management system
- * Coordinates between tool execution, live status tracking, and overlay display
- */
-import { EventEmitter } from 'events';
-export class StatusOrchestrator extends EventEmitter {
-    constructor() {
-        super();
-        this.statusListeners = new Set();
-        this.context = {
-            base: null,
-            overrides: new Map(),
-            tools: new Map(),
-            animations: new Map(),
-            interrupts: {
-                pending: [],
-                active: null,
-            },
-        };
-        // Default priority resolver
-        this.priorityResolver = (a, b) => {
-            const tonePriority = {
-                danger: 4,
-                warning: 3,
-                success: 2,
-                info: 1,
-            };
-            const aPriority = tonePriority[a.tone || 'info'];
-            const bPriority = tonePriority[b.tone || 'info'];
-            return bPriority - aPriority;
-        };
-    }
-    /**
-     * Set base status
-     */
-    setBaseStatus(status) {
-        this.context.base = status;
-        this.emitEvent({
-            type: 'status.base.changed',
-            timestamp: Date.now(),
-            data: { status },
-        });
-    }
-    /**
-     * Push status override
-     */
-    pushOverride(id, status) {
-        this.context.overrides.set(id, status);
-        this.emitEvent({
-            type: 'status.override.pushed',
-            timestamp: Date.now(),
-            data: { id, status },
-        });
-    }
-    /**
-     * Clear status override
-     */
-    clearOverride(id) {
-        const removed = this.context.overrides.delete(id);
-        if (removed) {
-            this.emitEvent({
-                type: 'status.override.cleared',
-                timestamp: Date.now(),
-                data: { id },
-            });
-        }
-    }
-    /**
-     * Handle tool lifecycle events
-     */
-    onToolStart(toolCall) {
-        const toolStatus = {
-            toolId: toolCall.id,
-            tool: toolCall.name,
-            status: 'starting',
-            description: this.describeToolOperation(toolCall),
-            startedAt: Date.now(),
-            updatedAt: Date.now(),
-            tone: this.getToolTone(toolCall.name),
-        };
-        this.context.tools.set(toolCall.id, toolStatus);
-        this.emitEvent({
-            type: 'tool.start',
-            timestamp: Date.now(),
-            data: { toolCall, toolStatus },
-        });
-        // Update to running status after a brief delay
-        setTimeout(() => {
-            const status = this.context.tools.get(toolCall.id);
-            if (status && status.status === 'starting') {
-                status.status = 'running';
-                status.updatedAt = Date.now();
-                this.emitEvent({
-                    type: 'tool.progress',
-                    timestamp: Date.now(),
-                    data: { toolCall, toolStatus: status },
-                });
-            }
-        }, 100);
-    }
-    /**
-     * Update tool progress
-     */
-    onToolProgress(toolId, progress) {
-        const toolStatus = this.context.tools.get(toolId);
-        if (!toolStatus)
-            return;
-        toolStatus.progress = {
-            current: progress.current,
-            total: progress.total,
-            percentage: Math.round((progress.current / progress.total) * 100),
-        };
-        if (progress.message) {
-            toolStatus.detail = progress.message;
-        }
-        toolStatus.updatedAt = Date.now();
-        this.emitEvent({
-            type: 'tool.progress',
-            timestamp: Date.now(),
-            data: { toolId, toolStatus, progress },
-        });
-    }
-    /**
-     * Handle tool completion
-     */
-    onToolComplete(toolId, result) {
-        const toolStatus = this.context.tools.get(toolId);
-        if (!toolStatus)
-            return;
-        toolStatus.status = 'completed';
-        toolStatus.updatedAt = Date.now();
-        this.emitEvent({
-            type: 'tool.complete',
-            timestamp: Date.now(),
-            data: { toolId, toolStatus, result },
-        });
-        // Remove from active tools after animation
-        setTimeout(() => {
-            this.context.tools.delete(toolId);
-        }, 1000);
-    }
-    /**
-     * Handle tool error
-     */
-    onToolError(toolId, error) {
-        const toolStatus = this.context.tools.get(toolId);
-        if (!toolStatus)
-            return;
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        toolStatus.status = 'error';
-        toolStatus.tone = 'danger';
-        toolStatus.detail = errorMessage || 'An error occurred';
-        toolStatus.updatedAt = Date.now();
-        this.emitEvent({
-            type: 'tool.error',
-            timestamp: Date.now(),
-            data: { toolId, toolStatus, error },
-        });
-        // Remove from active tools after delay
-        setTimeout(() => {
-            this.context.tools.delete(toolId);
-        }, 2000);
-    }
-    /**
-     * Queue an interrupt
-     */
-    queueInterrupt(interrupt) {
-        const id = `interrupt-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-        const fullInterrupt = {
-            ...interrupt,
-            id,
-            timestamp: Date.now(),
-        };
-        // Insert based on priority
-        const index = this.context.interrupts.pending.findIndex((i) => i.priority < interrupt.priority);
-        if (index === -1) {
-            this.context.interrupts.pending.push(fullInterrupt);
-        }
-        else {
-            this.context.interrupts.pending.splice(index, 0, fullInterrupt);
-        }
-        this.emitEvent({
-            type: 'interrupt.received',
-            timestamp: Date.now(),
-            data: { interrupt: fullInterrupt },
-        });
-        // Process interrupt queue
-        this.processInterrupts();
-        return id;
-    }
-    /**
-     * Process pending interrupts
-     */
-    processInterrupts() {
-        if (this.context.interrupts.active || this.context.interrupts.pending.length === 0) {
-            return;
-        }
-        const interrupt = this.context.interrupts.pending.shift();
-        if (!interrupt)
-            return;
-        this.context.interrupts.active = interrupt;
-        // Auto-clear interrupt after 3 seconds if not cleared manually
-        setTimeout(() => {
-            if (this.context.interrupts.active?.id === interrupt.id) {
-                this.clearInterrupt(interrupt.id);
-            }
-        }, 3000);
-    }
-    /**
-     * Clear an active interrupt
-     */
-    clearInterrupt(id) {
-        if (this.context.interrupts.active?.id === id) {
-            this.context.interrupts.active = null;
-            this.processInterrupts(); // Process next in queue
-        }
-    }
-    /**
-     * Get the current aggregated status
-     */
-    getCurrentStatus() {
-        // Priority order:
-        // 1. Active interrupt
-        // 2. Active tools
-        // 3. Overrides
-        // 4. Base status
-        if (this.context.interrupts.active) {
-            return {
-                text: this.context.interrupts.active.message,
-                tone: 'warning',
-                startedAt: this.context.interrupts.active.timestamp,
-            };
-        }
-        // Get most important tool status
-        if (this.context.tools.size > 0) {
-            const toolStatuses = Array.from(this.context.tools.values());
-            const activeTools = toolStatuses.filter((t) => t.status === 'running');
-            if (activeTools.length > 0) {
-                const mostRecent = activeTools.sort((a, b) => b.updatedAt - a.updatedAt)[0];
-                if (mostRecent) {
-                    return {
-                        text: mostRecent.description,
-                        detail: mostRecent.detail,
-                        tone: mostRecent.tone,
-                        startedAt: mostRecent.startedAt,
-                    };
-                }
-            }
-        }
-        // Get highest priority override
-        if (this.context.overrides.size > 0) {
-            const overrides = Array.from(this.context.overrides.values());
-            const sorted = overrides.sort(this.priorityResolver);
-            return sorted[0] || null;
-        }
-        return this.context.base;
-    }
-    /**
-     * Register animation
-     */
-    registerAnimation(id, type, data) {
-        this.context.animations.set(id, {
-            id,
-            type,
-            frame: 0,
-            startedAt: Date.now(),
-            data,
-        });
-    }
-    /**
-     * Update animation frame
-     */
-    updateAnimationFrame(id) {
-        const animation = this.context.animations.get(id);
-        if (animation) {
-            animation.frame++;
-            this.emitEvent({
-                type: 'animation.frame',
-                timestamp: Date.now(),
-                data: { animation },
-            });
-        }
-    }
-    /**
-     * Clear animation
-     */
-    clearAnimation(id) {
-        this.context.animations.delete(id);
-    }
-    /**
-     * Subscribe to status events
-     */
-    subscribe(listener) {
-        this.statusListeners.add(listener);
-        return () => this.statusListeners.delete(listener);
-    }
-    /**
-     * Emit status event
-     */
-    emitEvent(event) {
-        this.emit(event.type, event);
-        this.statusListeners.forEach((listener) => listener(event));
-    }
-    /**
-     * Get tool operation description
-     */
-    describeToolOperation(toolCall) {
-        const params = toolCall.arguments;
-        switch (toolCall.name) {
-            case 'read_file':
-                return `Reading ${this.truncatePath(params.path)}`;
-            case 'write_file':
-                return `Writing ${this.truncatePath(params.path)}`;
-            case 'edit_file':
-                return `Editing ${this.truncatePath(params.path)}`;
-            case 'bash':
-                return `Running: ${this.truncateCommand(params.command)}`;
-            case 'search_files':
-                return `Searching for: ${this.truncateQuery(params.query)}`;
-            case 'list_directory':
-                return `Listing ${this.truncatePath(params.path || '.')}`;
-            default:
-                return `Running ${toolCall.name}`;
-        }
-    }
-    /**
-     * Get tone for tool type
-     */
-    getToolTone(tool) {
-        const dangerousTools = ['bash', 'write_file', 'edit_file', 'delete_file'];
-        const warningTools = ['install', 'uninstall', 'update'];
-        if (dangerousTools.includes(tool)) {
-            return 'warning';
-        }
-        if (warningTools.includes(tool)) {
-            return 'warning';
-        }
-        return 'info';
-    }
-    /**
-     * Helper to truncate paths
-     */
-    truncatePath(path, maxLength = 40) {
-        if (!path)
-            return '';
-        if (path.length <= maxLength)
-            return path;
-        const parts = path.split('/');
-        if (parts.length <= 2) {
-            return '...' + path.slice(-(maxLength - 3));
-        }
-        // Keep first and last parts
-        const first = parts[0] || '';
-        const last = parts[parts.length - 1] || '';
-        const middle = '...';
-        const result = `${first}/${middle}/${last}`;
-        if (result.length > maxLength) {
-            return '...' + last.slice(-(maxLength - 3));
-        }
-        return result;
-    }
-    /**
-     * Helper to truncate commands
-     */
-    truncateCommand(command, maxLength = 40) {
-        if (!command)
-            return '';
-        if (command.length <= maxLength)
-            return command;
-        return command.slice(0, maxLength - 3) + '...';
-    }
-    /**
-     * Helper to truncate search queries
-     */
-    truncateQuery(query, maxLength = 30) {
-        if (!query)
-            return '';
-        if (query.length <= maxLength)
-            return query;
-        return query.slice(0, maxLength - 3) + '...';
-    }
-    /**
-     * Get full context for debugging
-     */
-    getContext() {
-        return { ...this.context };
-    }
-    /**
-     * Reset all status
-     */
-    reset() {
-        this.context = {
-            base: null,
-            overrides: new Map(),
-            tools: new Map(),
-            animations: new Map(),
-            interrupts: {
-                pending: [],
-                active: null,
-            },
-        };
-    }
-}

package/dist/bin/ui/outputMode.js

@@ -1,38 +0,0 @@
-/**
- * Output mode configuration for terminal UI
- *
- * Controls whether to use decorative box-drawing characters or plain text.
- * Plain mode outputs clipboard-friendly text without Unicode borders.
- *
- * Environment variable: EROSOLAR_PLAIN_OUTPUT=true
- */
-let _plainMode = null;
-/**
- * Check if plain output mode is enabled.
- * Plain mode outputs text without box-drawing characters for clean clipboard copying.
- */
-export function isPlainOutputMode() {
-    if (_plainMode !== null) {
-        return _plainMode;
-    }
-    const envValue = process.env['EROSOLAR_PLAIN_OUTPUT'];
-    if (envValue !== undefined) {
-        _plainMode = ['true', '1', 'yes', 'on'].includes(envValue.toLowerCase());
-        return _plainMode;
-    }
-    // Default to plain output unless explicitly disabled
-    _plainMode = true;
-    return _plainMode;
-}
-/**
- * Override the plain output mode setting (useful for testing)
- */
-export function setPlainOutputMode(enabled) {
-    _plainMode = enabled;
-}
-/**
- * Reset plain output mode to check environment variable again
- */
-export function resetPlainOutputMode() {
-    _plainMode = null;
-}

package/dist/bin/ui/persistentPrompt.js

@@ -1,183 +0,0 @@
-/**
- * PersistentPrompt - Minimal, stable chat input at bottom of terminal
- *
- * Design principles:
- * - Simple: No complex cursor manipulation or multi-line rendering
- * - Stable: Uses standard readline without fighting it
- * - Reliable: Clear separation between output area and input area
- */
-import * as readline from 'node:readline';
-import { theme } from './theme.js';
-/**
- * Minimal prompt manager that doesn't fight with readline
- */
-export class PersistentPrompt {
-    constructor(writeStream, promptText = '> ') {
-        this.isEnabled = true;
-        this.writeStream = writeStream;
-        this.promptText = promptText;
-        this.statusBarState = {};
-        this.promptState = {
-            userInput: '',
-            cursorPosition: 0,
-            isVisible: true,
-        };
-    }
-    /**
-     * Update the prompt text
-     */
-    setPromptText(text) {
-        this.promptText = text;
-    }
-    /**
-     * Get the formatted prompt string
-     */
-    getPrompt() {
-        return this.promptText;
-    }
-    /**
-     * Update user input state (for tracking only - readline handles display)
-     */
-    updateInput(input, cursorPos) {
-        this.promptState.userInput = input;
-        this.promptState.cursorPosition = cursorPos;
-    }
-    /**
-     * Update status bar information
-     */
-    updateStatusBar(state) {
-        this.statusBarState = { ...this.statusBarState, ...state };
-    }
-    /**
-     * Show a status line above the prompt (call before readline.prompt())
-     */
-    showStatus() {
-        if (!this.isEnabled)
-            return;
-        const status = this.buildStatusLine();
-        if (status) {
-            this.writeStream.write('\n' + status + '\n');
-        }
-    }
-    /**
-     * Show the prompt
-     */
-    show() {
-        this.promptState.isVisible = true;
-    }
-    /**
-     * Hide the prompt
-     */
-    hide() {
-        this.promptState.isVisible = false;
-    }
-    /**
-     * Enable or disable
-     */
-    setEnabled(enabled) {
-        this.isEnabled = enabled;
-    }
-    /**
-     * Clear - no-op for minimal implementation
-     */
-    clear() {
-        // Intentionally minimal - let readline handle clearing
-    }
-    /**
-     * Build status line string
-     */
-    buildStatusLine() {
-        const parts = [];
-        if (this.statusBarState.fileChanges) {
-            parts.push(this.statusBarState.fileChanges);
-        }
-        if (typeof this.statusBarState.contextUsage === 'number') {
-            const remaining = Math.max(0, 100 - this.statusBarState.contextUsage);
-            parts.push(`${remaining}% context`);
-        }
-        if (this.statusBarState.message?.trim()) {
-            parts.push(this.statusBarState.message.trim());
-        }
-        if (!parts.length) {
-            return null;
-        }
-        return theme.ui.muted(parts.join(' • '));
-    }
-    /**
-     * Handle terminal resize - no-op for minimal implementation
-     */
-    handleResize() {
-        // Readline handles resize
-    }
-    /**
-     * Dispose
-     */
-    dispose() {
-        // Nothing to clean up in minimal implementation
-    }
-}
-/**
- * Simple input box that wraps readline with stable behavior
- */
-export class SimpleInputBox {
-    constructor(promptText = '> ') {
-        this.rl = null;
-        this.statusText = '';
-        this.promptText = promptText;
-    }
-    /**
-     * Initialize readline interface
-     */
-    init(input, output) {
-        this.rl = readline.createInterface({
-            input,
-            output,
-            prompt: this.promptText,
-            terminal: true,
-        });
-        return this.rl;
-    }
-    /**
-     * Set prompt text
-     */
-    setPrompt(text) {
-        this.promptText = text;
-        if (this.rl) {
-            this.rl.setPrompt(text);
-        }
-    }
-    /**
-     * Set status text (shown above prompt on next prompt())
-     */
-    setStatus(text) {
-        this.statusText = text;
-    }
-    /**
-     * Show prompt with optional status line
-     */
-    prompt(preserveCursor) {
-        if (!this.rl)
-            return;
-        // Show status line if set
-        if (this.statusText) {
-            process.stdout.write('\n' + theme.ui.muted(this.statusText) + '\n');
-            this.statusText = '';
-        }
-        this.rl.prompt(preserveCursor);
-    }
-    /**
-     * Get readline interface
-     */
-    getInterface() {
-        return this.rl;
-    }
-    /**
-     * Close and cleanup
-     */
-    close() {
-        if (this.rl) {
-            this.rl.close();
-            this.rl = null;
-        }
-    }
-}