erosolar-cli 1.5.2 → 1.5.4

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

@@ -0,0 +1,403 @@
+/**
+ * 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

@@ -0,0 +1,38 @@
+/**
+ * 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

@@ -0,0 +1,183 @@
+/**
+ * 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;
+        }
+    }
+}