erosolar-cli 1.7.14 → 1.7.16

package/dist/bin/ui/ShellUIAdapter.js

@@ -1,459 +0,0 @@
-/**
- * ShellUIAdapter - Bridges the UnifiedUIController with the existing shell infrastructure
- * Provides compatibility layer and migration path from old to new UI system
- */
-import { UnifiedUIController } from './UnifiedUIController.js';
-import { InterruptPriority } from './interrupts/InterruptManager.js';
-import { getTerminalColumns } from './layout.js';
-import { ToolDisplayAdapter } from './toolDisplayAdapter.js';
-export class ShellUIAdapter {
-    constructor(writeStream, display, config = {}) {
-        this.isProcessing = false;
-        this.contextUsage = 0;
-        this.display = display;
-        this.toolDisplay = new ToolDisplayAdapter(display);
-        this.config = {
-            useUnifiedUI: true,
-            preserveCompatibility: true,
-            enableTelemetry: true,
-            debugMode: false,
-            ...config,
-        };
-        // Initialize unified UI controller
-        this.uiController = new UnifiedUIController(writeStream, {
-            enableOverlay: true,
-            enableAnimations: true,
-            enableTelemetry: this.config.enableTelemetry,
-            adaptivePerformance: true,
-            debugMode: this.config.debugMode,
-        });
-        // Legacy components are optional and should be passed in if needed
-        // They require a readline.Interface which we don't have here
-        this.setupDisplayIntegration();
-    }
-    /**
-     * Setup display integration
-     */
-    setupDisplayIntegration() {
-        // Register output interceptor to coordinate with overlay
-        this.display.registerOutputInterceptor({
-            beforeWrite: () => {
-                if (this.config.useUnifiedUI) {
-                    this.uiController.beginOutput();
-                }
-            },
-            afterWrite: () => {
-                if (this.config.useUnifiedUI) {
-                    this.uiController.endOutput();
-                }
-            },
-        });
-    }
-    /**
-     * Create a tool observer for the agent
-     */
-    createToolObserver() {
-        return {
-            onToolStart: (call) => {
-                // Use safe write to coordinate with spinner output
-                this.display.safeWrite(() => {
-                    this.toolDisplay.showToolStart(call);
-                    const actionDesc = this.getToolActionDescription(call);
-                    if (actionDesc) {
-                        this.updateSpinnerMessage(actionDesc);
-                    }
-                });
-                if (this.config.useUnifiedUI) {
-                    this.uiController.onToolStart(call);
-                }
-            },
-            onToolProgress: (call, progress) => {
-                if (this.config.useUnifiedUI) {
-                    this.uiController.onToolProgress(call.id, {
-                        current: progress.current,
-                        total: progress.total ?? progress.current,
-                        message: progress.message,
-                    });
-                }
-                this.display.safeWrite(() => {
-                    const description = this.getToolActionDescription(call, progress);
-                    if (description) {
-                        this.updateSpinnerMessage(description);
-                    }
-                });
-            },
-            onToolResult: (call, output) => {
-                // Use safe write to coordinate with spinner output
-                this.display.safeWrite(() => {
-                    // Temporarily stop spinner to show result
-                    const wasSpinning = this.display.isSpinnerActive();
-                    if (wasSpinning) {
-                        this.display.stopThinking(false);
-                    }
-                    // Track file changes for Edit/Write tools
-                    if (this.fileChangeCallback && (call.name === 'Edit' || call.name === 'Write')) {
-                        const fileChange = this.parseFileChange(call, output);
-                        if (fileChange) {
-                            this.fileChangeCallback(fileChange.path, fileChange.type, fileChange.additions, fileChange.removals);
-                        }
-                    }
-                    this.toolDisplay.showToolResult(call.id, output, 'success');
-                    // Update spinner for next action (reuse existing if it was running)
-                    if (wasSpinning) {
-                        this.display.showThinking('Analyzing results...');
-                    }
-                });
-                if (this.config.useUnifiedUI) {
-                    this.uiController.onToolComplete(call.id, output);
-                }
-            },
-            onToolError: (call, message) => {
-                // Use safe write to coordinate with spinner output
-                this.display.safeWrite(() => {
-                    // Temporarily stop spinner to show error
-                    const wasSpinning = this.display.isSpinnerActive();
-                    if (wasSpinning) {
-                        this.display.stopThinking(false);
-                    }
-                    this.toolDisplay.showToolResult(call.id, message, 'error');
-                    // Update spinner (reuse existing if it was running)
-                    if (wasSpinning) {
-                        this.display.showThinking('Handling error...');
-                    }
-                });
-                if (this.config.useUnifiedUI) {
-                    this.uiController.onToolError(call.id, { message });
-                }
-            },
-            onCacheHit: (call) => {
-                if (this.config.useUnifiedUI) {
-                    this.uiController.onToolStart(call);
-                    this.uiController.onToolComplete(call.id, 'cache-hit');
-                }
-                this.display.safeWrite(() => {
-                    this.display.showSubAction(`Cache hit: ${call.name}`, 'info');
-                });
-            },
-        };
-    }
-    /**
-     * Start processing a request
-     */
-    startProcessing(message = 'Working on your request') {
-        this.isProcessing = true;
-        if (this.config.useUnifiedUI) {
-            this.uiController.startProcessing();
-            this.uiController.setBaseStatus(message, 'info');
-        }
-        else {
-            if (this.legacyStatusTracker) {
-                this.legacyStatusTracker.setBase(message, { tone: 'info' });
-            }
-        }
-    }
-    /**
-     * End processing
-     */
-    endProcessing(message = 'Ready for prompts') {
-        this.isProcessing = false;
-        if (this.config.useUnifiedUI) {
-            this.uiController.endProcessing();
-            this.uiController.setBaseStatus(message, 'success');
-        }
-        else {
-            if (this.legacyStatusTracker) {
-                this.legacyStatusTracker.setBase(message, { tone: 'success' });
-            }
-        }
-    }
-    /**
-     * Update context usage
-     */
-    updateContextUsage(percentage) {
-        this.contextUsage = percentage;
-        if (this.config.useUnifiedUI) {
-            // Determine tone based on usage
-            let tone = 'info';
-            if (percentage > 90)
-                tone = 'danger';
-            else if (percentage > 70)
-                tone = 'warning';
-            const message = `Context ${percentage}% used`;
-            this.uiController.pushStatusOverride('context', message, undefined, tone);
-        }
-    }
-    /**
-     * Show a user interrupt
-     */
-    showInterrupt(message, type = 'alert', handler) {
-        if (this.config.useUnifiedUI) {
-            const priority = type === 'alert'
-                ? InterruptPriority.HIGH
-                : InterruptPriority.NORMAL;
-            return this.uiController.queueInterrupt(type, message, priority, handler ? async () => handler() : undefined);
-        }
-        else {
-            // For legacy, just show the message immediately
-            this.display.showWarning(message);
-            if (handler) {
-                setTimeout(() => handler(), 0);
-            }
-            return 'legacy-interrupt';
-        }
-    }
-    /**
-     * Complete an interrupt
-     */
-    completeInterrupt(id) {
-        if (this.config.useUnifiedUI) {
-            this.uiController.completeInterrupt(id);
-        }
-    }
-    /**
-     * Show slash command preview with dynamic overlay
-     */
-    showSlashCommandPreview(commands) {
-        if (this.config.useUnifiedUI) {
-            // Build a Claude Code-style command menu without duplicate separators
-            // Build command lines with proper indentation
-            const commandLines = commands.map(cmd => {
-                return `  ${cmd.command}\n      ${cmd.description}`;
-            }).join('\n');
-            // Create command content
-            const content = commandLines;
-            // Use the unified UI overlay system
-            this.uiController.updateCommandsOverlay(content);
-        }
-        else if (this.legacyStatusTracker) {
-            // Legacy fallback - just show command names
-            const preview = commands.map(c => c.command).join(' | ');
-            this.legacyStatusTracker.pushOverride('slash-preview', `Commands: ${preview}`, {
-                tone: 'info',
-            });
-        }
-    }
-    /**
-     * Hide slash command preview
-     */
-    hideSlashCommandPreview() {
-        if (this.config.useUnifiedUI) {
-            this.uiController.hideCommandsOverlay();
-        }
-        else if (this.legacyStatusTracker) {
-            this.legacyStatusTracker.clearOverride('slash-preview');
-        }
-    }
-    /**
-     * Show profile switcher (Shift+Tab)
-     */
-    showProfileSwitcher(profiles, currentProfile) {
-        if (this.config.useUnifiedUI) {
-            // Build profile switcher overlay
-            const terminalWidth = getTerminalColumns();
-            const separator = '─'.repeat(terminalWidth - 1);
-            // Build profile lines
-            const profileLines = profiles.map(profile => {
-                return `  ${profile.command}\n      ${profile.description}`;
-            }).join('\n');
-            // Create overlay content
-            const header = `Switch Profile (Shift+Tab)`;
-            const content = `${separator}\n${header}\n${separator}\n${profileLines}\n\nPress number to switch or Esc to cancel`;
-            // Use the unified UI overlay system
-            this.uiController.updateCommandsOverlay(content);
-            // Auto-hide after 5 seconds (track timeout to allow cleanup)
-            if (this.profileSwitcherTimeout) {
-                clearTimeout(this.profileSwitcherTimeout);
-            }
-            this.profileSwitcherTimeout = setTimeout(() => {
-                this.uiController.hideCommandsOverlay();
-                this.profileSwitcherTimeout = undefined;
-            }, 5000);
-        }
-        else if (this.legacyStatusTracker) {
-            // Legacy fallback
-            const preview = `Current: ${currentProfile} | Press Shift+Tab to switch`;
-            this.legacyStatusTracker.pushOverride('profile-switch', preview, {
-                tone: 'info',
-            });
-        }
-    }
-    /**
-     * Enable or disable overlay
-     */
-    setOverlayEnabled(enabled) {
-        if (this.config.useUnifiedUI) {
-            this.uiController.updateConfig({ enableOverlay: enabled });
-        }
-    }
-    /**
-     * Get telemetry data (only available in unified mode)
-     */
-    getTelemetry() {
-        if (this.config.useUnifiedUI) {
-            return {
-                snapshot: this.uiController.getTelemetrySnapshot(),
-                performance: this.uiController.getPerformanceSummary(),
-            };
-        }
-        return null;
-    }
-    /**
-     * Switch between UI modes
-     */
-    switchUIMode(useUnified) {
-        this.config.useUnifiedUI = useUnified;
-        if (useUnified) {
-            // Clear legacy status tracker if it exists
-            if (this.legacyStatusTracker) {
-                this.legacyStatusTracker.reset();
-            }
-        }
-        else {
-            // Hide unified UI overlays
-            this.uiController.updateConfig({ enableOverlay: false });
-        }
-    }
-    /**
-     * Helper methods
-     */
-    updateSpinnerMessage(message) {
-        if (!message?.trim()) {
-            return;
-        }
-        if (this.display.isSpinnerActive()) {
-            this.display.updateThinking(message);
-        }
-        else {
-            this.display.showThinking(message);
-        }
-    }
-    /**
-     * Get action description for tool execution (Claude Code style)
-     * Returns a human-readable description of what the tool is doing
-     */
-    getToolActionDescription(call, progress) {
-        let description;
-        switch (call.name) {
-            case 'Read':
-                description = `Reading file...`;
-                break;
-            case 'Write':
-                description = `Writing file...`;
-                break;
-            case 'Edit':
-                description = `Editing file...`;
-                break;
-            case 'Bash':
-                description = `Executing command...`;
-                break;
-            case 'Grep':
-                description = `Searching code...`;
-                break;
-            case 'Glob':
-                description = `Finding files...`;
-                break;
-            case 'WebFetch':
-                description = `Fetching web content...`;
-                break;
-            case 'WebSearch':
-                description = `Searching web...`;
-                break;
-            case 'Task':
-                description = `Running task...`;
-                break;
-            default:
-                description = `Executing ${call.name}...`;
-        }
-        if (progress) {
-            const details = [];
-            if (progress.message?.trim()) {
-                details.push(progress.message.trim());
-            }
-            if (typeof progress.total === 'number' && progress.total > 0) {
-                const pct = Math.max(0, Math.min(100, Math.round((progress.current / progress.total) * 100)));
-                details.push(`${pct}%`);
-            }
-            if (details.length) {
-                return `${description} (${details.join(' ')})`;
-            }
-        }
-        return description;
-    }
-    /**
-     * Set file change tracking callback
-     */
-    setFileChangeCallback(callback) {
-        this.fileChangeCallback = callback;
-    }
-    /**
-     * Parse file changes from Edit/Write tool output
-     */
-    parseFileChange(call, output) {
-        const args = call.arguments;
-        const path = args.file_path || args.path;
-        if (!path)
-            return null;
-        // Parse additions and removals from output
-        let additions = 0;
-        let removals = 0;
-        // For Edit tool: parse "Lines changed: +X / -Y" or "+X addition -Y removal"
-        const editMatch = output.match(/\+(\d+).*-(\d+)/);
-        if (editMatch) {
-            additions = parseInt(editMatch[1] || '0', 10);
-            removals = parseInt(editMatch[2] || '0', 10);
-        }
-        // Alternative format: "X addition" and "Y removal"
-        const addMatch = output.match(/(\d+)\s+addition/);
-        const remMatch = output.match(/(\d+)\s+removal/);
-        if (addMatch)
-            additions = parseInt(addMatch[1] || '0', 10);
-        if (remMatch)
-            removals = parseInt(remMatch[1] || '0', 10);
-        // For Write tool: estimate as all additions (new file or full rewrite)
-        if (call.name === 'Write' && additions === 0 && removals === 0) {
-            const lines = (args.content || '').split('\n').length;
-            additions = lines;
-        }
-        return {
-            path,
-            type: call.name === 'Edit' ? 'edit' : 'write',
-            additions,
-            removals
-        };
-    }
-    /**
-     * Get current UI mode
-     */
-    getCurrentMode() {
-        return this.config.useUnifiedUI ? 'unified' : 'legacy';
-    }
-    /**
-     * Get UI state
-     */
-    getState() {
-        if (this.config.useUnifiedUI) {
-            return this.uiController.getState();
-        }
-        else {
-            return {
-                isProcessing: this.isProcessing,
-                contextUsage: this.contextUsage,
-            };
-        }
-    }
-    /**
-     * Dispose of resources
-     */
-    dispose() {
-        // Clear any pending timeouts to prevent process hang
-        if (this.profileSwitcherTimeout) {
-            clearTimeout(this.profileSwitcherTimeout);
-            this.profileSwitcherTimeout = undefined;
-        }
-        this.uiController.dispose();
-        if (this.legacyStatusTracker) {
-            // Clear all status
-            this.legacyStatusTracker.reset();
-        }
-    }
-}

package/dist/bin/ui/UnifiedUIController.js

@@ -1,183 +0,0 @@
-/**
- * UnifiedUIController - Minimal stub for unified UI system
- *
- * The overlay-based implementation has been removed in favor of simple,
- * stable terminal output that doesn't fight with readline.
- */
-import { EventEmitter } from 'events';
-import { StatusOrchestrator } from './orchestration/StatusOrchestrator.js';
-import { AnimationScheduler } from './animation/AnimationScheduler.js';
-import { InterruptManager, InterruptPriority } from './interrupts/InterruptManager.js';
-import { UITelemetry } from './telemetry/UITelemetry.js';
-export class UnifiedUIController extends EventEmitter {
-    constructor(_writeStream, config = {}) {
-        super();
-        this.activeSpinners = new Map();
-        this.activeElapsed = new Map();
-        this.config = {
-            enableOverlay: false, // Disabled - no complex overlay
-            enableAnimations: true,
-            enableTelemetry: true,
-            adaptivePerformance: false,
-            debugMode: false,
-            ...config,
-        };
-        this.state = {
-            isProcessing: false,
-            hasActiveTools: false,
-            hasActiveInterrupts: false,
-            overlayVisible: false,
-            currentStatus: null,
-            activeAnimations: 0,
-            performanceMode: 'balanced',
-        };
-        // Initialize components (no overlay manager)
-        this.statusOrchestrator = new StatusOrchestrator();
-        this.animationScheduler = new AnimationScheduler(30);
-        this.interruptManager = new InterruptManager();
-        this.telemetry = new UITelemetry({ enabled: config.enableTelemetry });
-        this.setupEventHandlers();
-        this.emit('ui.initialized');
-    }
-    setupEventHandlers() {
-        this.statusOrchestrator.subscribe((event) => {
-            this.handleStatusEvent(event);
-        });
-        this.interruptManager.on('interrupt:activated', () => {
-            this.state.hasActiveInterrupts = true;
-            this.emit('ui.state.changed', { hasActiveInterrupts: true });
-        });
-        this.interruptManager.on('interrupt:completed', () => {
-            const activeCount = this.interruptManager.getInterruptsByStatus('active').length;
-            this.state.hasActiveInterrupts = activeCount > 0;
-        });
-    }
-    handleStatusEvent(event) {
-        this.telemetry.recordEvent(event.type, event.data);
-        switch (event.type) {
-            case 'tool.start':
-                this.handleToolStart(event.data);
-                break;
-            case 'tool.complete':
-                this.handleToolComplete(event.data);
-                break;
-            case 'tool.error':
-                this.handleToolError(event.data);
-                break;
-        }
-    }
-    handleToolStart(data) {
-        const { toolCall, toolStatus } = data;
-        this.telemetry.markStart(`tool.${toolCall.name}`);
-        if (this.config.enableAnimations) {
-            const spinner = this.animationScheduler.createSpinner(`tool-${toolCall.id}`, toolStatus.description);
-            this.activeSpinners.set(toolCall.id, spinner);
-        }
-        const elapsed = this.animationScheduler.createElapsed(`elapsed-${toolCall.id}`, toolStatus.startedAt);
-        this.activeElapsed.set(toolCall.id, elapsed);
-        this.state.hasActiveTools = true;
-    }
-    handleToolComplete(data) {
-        this.activeSpinners.delete(data.toolId);
-        this.activeElapsed.delete(data.toolId);
-        this.animationScheduler.unregister(`tool-${data.toolId}`);
-        this.animationScheduler.unregister(`elapsed-${data.toolId}`);
-        if (this.statusOrchestrator.getContext().tools.size === 0) {
-            this.state.hasActiveTools = false;
-        }
-    }
-    handleToolError(data) {
-        this.telemetry.recordError(data.error, { toolId: data.toolId });
-        this.activeSpinners.delete(data.toolId);
-        this.activeElapsed.delete(data.toolId);
-        this.animationScheduler.unregister(`tool-${data.toolId}`);
-        this.animationScheduler.unregister(`elapsed-${data.toolId}`);
-    }
-    // Public API
-    startProcessing() {
-        this.state.isProcessing = true;
-        this.emit('ui.state.changed', { isProcessing: true });
-    }
-    endProcessing() {
-        this.state.isProcessing = false;
-        this.emit('ui.state.changed', { isProcessing: false });
-    }
-    setBaseStatus(text, tone) {
-        this.statusOrchestrator.setBaseStatus({
-            text,
-            tone,
-            startedAt: Date.now(),
-        });
-    }
-    pushStatusOverride(id, text, detail, tone) {
-        this.statusOrchestrator.pushOverride(id, {
-            text,
-            detail,
-            tone,
-            startedAt: Date.now(),
-        });
-    }
-    clearStatusOverride(id) {
-        this.statusOrchestrator.clearOverride(id);
-    }
-    updateCommandsOverlay(_content) {
-        // No-op - overlay removed
-    }
-    hideCommandsOverlay() {
-        // No-op - overlay removed
-    }
-    onToolStart(toolCall) {
-        this.statusOrchestrator.onToolStart(toolCall);
-    }
-    onToolProgress(toolId, progress) {
-        this.statusOrchestrator.onToolProgress(toolId, progress);
-    }
-    onToolComplete(toolId, result) {
-        this.statusOrchestrator.onToolComplete(toolId, result);
-    }
-    onToolError(toolId, error) {
-        this.statusOrchestrator.onToolError(toolId, error);
-    }
-    queueInterrupt(type, message, priority = InterruptPriority.NORMAL, handler) {
-        return this.interruptManager.queue({
-            type,
-            priority,
-            message,
-            handler,
-        });
-    }
-    completeInterrupt(id) {
-        this.interruptManager.completeInterrupt(id);
-    }
-    beginOutput() {
-        // No-op - overlay removed
-    }
-    endOutput() {
-        // No-op - overlay removed
-    }
-    getState() {
-        return { ...this.state };
-    }
-    getTelemetrySnapshot() {
-        return this.telemetry.getSnapshot();
-    }
-    getPerformanceSummary() {
-        return this.telemetry.getPerformanceSummary();
-    }
-    updateConfig(config) {
-        this.config = { ...this.config, ...config };
-        this.telemetry.setEnabled(this.config.enableTelemetry);
-        if (!this.config.enableAnimations) {
-            this.animationScheduler.clearAll();
-        }
-    }
-    dispose() {
-        this.statusOrchestrator.reset();
-        this.animationScheduler.dispose();
-        this.interruptManager.dispose();
-        this.telemetry.dispose();
-        this.activeSpinners.clear();
-        this.activeElapsed.clear();
-        this.removeAllListeners();
-    }
-}