erosolar-cli 2.1.282 → 2.1.284

package/dist/ui/orchestration/OrchestrationUIBridge.js

@@ -0,0 +1,681 @@
+/**
+ * OrchestrationUIBridge - Claude Code / Codex CLI Style UI Rendering
+ *
+ * This module provides real-time integration between the UnifiedOrchestrator and the UI system,
+ * rendering output in the Claude Code / Codex CLI visual style:
+ *
+ * Visual Style:
+ * - ⏺ [tool_name] description    (tool start, with spinner during execution)
+ * - ⎿ output/result              (tool result, indented under action)
+ * - ✓ success indicator          (green checkmark on completion)
+ * - ✗ error indicator            (red X on failure)
+ *
+ * Architecture:
+ * - Subscribes to orchestrator events (tool:*, phase:*, finding:*)
+ * - Renders each event type with appropriate visual treatment
+ * - Uses UIUpdateCoordinator for serialized, non-interleaved output
+ * - Uses StatusOrchestrator for status line management
+ *
+ * Key Features:
+ * - Real-time tool execution feedback with spinners
+ * - Progressive output streaming
+ * - Findings displayed inline as discovered
+ * - Status line shows current operation
+ * - Clean separation between execution and rendering
+ */
+import { EventEmitter } from 'node:events';
+import { UnifiedOrchestrator, } from '../../core/unifiedOrchestrator.js';
+import { UIUpdateCoordinator } from './UIUpdateCoordinator.js';
+import { StatusOrchestrator } from './StatusOrchestrator.js';
+import { theme } from '../theme.js';
+// Claude Code / Codex CLI style icons
+const ICONS = {
+    action: '⏺', // Tool action indicator
+    subaction: '⎿', // Result/subaction indicator
+    success: '✓', // Success checkmark
+    error: '✗', // Error X
+    warning: '⚠', // Warning indicator
+    info: 'ℹ', // Info indicator
+    spinner: ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'], // Spinner frames
+    bullet: '•', // Bullet point
+    arrow: '→', // Arrow indicator
+};
+// ============================================================================
+// OrchestrationUIBridge
+// ============================================================================
+export class OrchestrationUIBridge extends EventEmitter {
+    display;
+    updateCoordinator;
+    statusOrchestrator;
+    config;
+    orchestrator = null;
+    currentState;
+    startTime = 0;
+    commandResults = [];
+    findings = [];
+    heartbeatId = null;
+    disposed = false;
+    // Claude Code-style active tool tracking
+    activeTools = new Map();
+    spinnerInterval = null;
+    orchestratorUnsubscribe = null;
+    constructor(config) {
+        super();
+        this.display = config.display;
+        this.updateCoordinator = config.updateCoordinator ?? new UIUpdateCoordinator('idle');
+        this.statusOrchestrator = config.statusOrchestrator ?? new StatusOrchestrator();
+        this.config = {
+            showRealTimeOutput: config.showRealTimeOutput ?? true,
+            showProgressBar: config.showProgressBar ?? true,
+            maxVisibleFindings: config.maxVisibleFindings ?? 5,
+            verboseMode: config.verboseMode ?? false,
+        };
+        this.currentState = this.createInitialState();
+        this.setupStatusListeners();
+    }
+    // --------------------------------------------------------------------------
+    // Public API
+    // --------------------------------------------------------------------------
+    /**
+     * Execute an orchestration operation with Claude Code-style real-time UI updates.
+     *
+     * Renders tool executions as:
+     * ⏺ [tool_name] description
+     *   ⎿ output line 1
+     *   ⎿ output line 2
+     * ✓ tool_name (duration)
+     */
+    async execute(objective, options) {
+        if (this.disposed) {
+            throw new Error('OrchestrationUIBridge has been disposed');
+        }
+        this.reset();
+        this.startTime = Date.now();
+        this.orchestrator = new UnifiedOrchestrator(options?.target);
+        try {
+            this.setPhase('initializing');
+            this.updateCoordinator.setMode('processing');
+            // Subscribe to orchestrator events for Claude Code-style rendering
+            this.subscribeToOrchestratorEvents();
+            this.startHeartbeat();
+            this.showStartBanner(objective);
+            this.setPhase('analyzing');
+            this.updateStatus(`Analyzing: ${this.truncate(objective, 50)}`);
+            this.setPhase('executing');
+            const report = await this.executeWithProgress(objective, options);
+            this.setPhase('reporting');
+            this.displayReport(report);
+            this.setPhase('complete');
+            return report;
+        }
+        catch (error) {
+            this.setPhase('error');
+            this.handleError(error);
+            throw error;
+        }
+        finally {
+            this.unsubscribeFromOrchestratorEvents();
+            this.stopHeartbeat();
+            this.stopSpinner();
+            this.updateCoordinator.setMode('idle');
+            this.orchestrator = null;
+        }
+    }
+    /**
+     * Subscribe to orchestrator events for real-time Claude Code-style rendering.
+     */
+    subscribeToOrchestratorEvents() {
+        if (!this.orchestrator)
+            return;
+        this.orchestratorUnsubscribe = this.orchestrator.onEvent((event) => {
+            this.handleOrchestratorEvent(event);
+        });
+        // Start spinner for active tools
+        this.startSpinner();
+    }
+    /**
+     * Unsubscribe from orchestrator events.
+     */
+    unsubscribeFromOrchestratorEvents() {
+        if (this.orchestratorUnsubscribe) {
+            this.orchestratorUnsubscribe();
+            this.orchestratorUnsubscribe = null;
+        }
+    }
+    /**
+     * Handle an orchestrator event and render it in Claude Code style.
+     */
+    handleOrchestratorEvent(event) {
+        switch (event.type) {
+            case 'tool:start':
+                this.renderToolStart(event.data);
+                break;
+            case 'tool:progress':
+                this.renderToolProgress(event.data);
+                break;
+            case 'tool:complete':
+            case 'tool:error':
+                this.renderToolComplete(event.data);
+                break;
+            case 'phase:change':
+                this.renderPhaseChange(event.data);
+                break;
+            case 'finding:detected':
+                this.renderFinding(event.data);
+                break;
+            default:
+                // Legacy events are handled for backward compatibility
+                break;
+        }
+    }
+    /**
+     * Render tool start in Claude Code style:
+     * ⏺ [tool_name] description
+     */
+    renderToolStart(event) {
+        this.activeTools.set(event.toolId, {
+            startEvent: event,
+            startTime: Date.now(),
+            spinnerFrame: 0,
+        });
+        const line = `${ICONS.action} ${theme.tool?.(`[${event.toolName}]`) ?? `[${event.toolName}]`} ${event.description}`;
+        this.enqueueUIUpdate('tool', () => {
+            this.display.writeRaw(`${line}\n`);
+        }, `tool-start-${event.toolId}`);
+        // Update status line
+        this.updateStatus(event.description);
+    }
+    /**
+     * Render tool progress (streaming output) in Claude Code style:
+     *   ⎿ output line
+     */
+    renderToolProgress(event) {
+        if (!event.output?.trim())
+            return;
+        const lines = event.output.trim().split('\n').slice(0, 5); // Limit to 5 lines
+        const formatted = lines.map(line => `  ${ICONS.subaction} ${theme.ui?.muted?.(this.truncate(line, 80)) ?? this.truncate(line, 80)}`).join('\n');
+        this.enqueueUIUpdate('tool', () => {
+            this.display.writeRaw(`${formatted}\n`);
+        }, `tool-progress-${event.toolId}-${Date.now()}`);
+    }
+    /**
+     * Render tool completion in Claude Code style:
+     * ✓ tool_name (1.2s) or ✗ tool_name - error
+     */
+    renderToolComplete(event) {
+        this.activeTools.delete(event.toolId);
+        const duration = event.duration < 1000
+            ? `${event.duration}ms`
+            : `${(event.duration / 1000).toFixed(1)}s`;
+        let line;
+        if (event.success) {
+            line = `  ${theme.success?.(ICONS.success) ?? ICONS.success} ${theme.tool?.(`${event.toolName}`) ?? event.toolName} ${theme.ui?.muted?.(`(${duration})`) ?? `(${duration})`}`;
+        }
+        else {
+            const errorMsg = event.output?.split('\n')[0]?.slice(0, 60) || 'Unknown error';
+            line = `  ${theme.error?.(ICONS.error) ?? ICONS.error} ${theme.tool?.(`${event.toolName}`) ?? event.toolName} ${theme.error?.(` - ${errorMsg}`) ?? ` - ${errorMsg}`}`;
+        }
+        this.enqueueUIUpdate('tool', () => {
+            this.display.writeRaw(`${line}\n`);
+        }, `tool-complete-${event.toolId}`);
+        // Show output preview for verbose mode
+        if (this.config.verboseMode && event.output?.trim()) {
+            const outputLines = event.output.trim().split('\n').slice(0, 3);
+            const outputFormatted = outputLines.map(l => `    ${ICONS.subaction} ${theme.ui?.muted?.(this.truncate(l, 70)) ?? this.truncate(l, 70)}`).join('\n');
+            this.enqueueUIUpdate('tool', () => {
+                this.display.writeRaw(`${outputFormatted}\n`);
+            }, `tool-output-${event.toolId}`);
+        }
+    }
+    /**
+     * Render phase change notification.
+     */
+    renderPhaseChange(event) {
+        // Only show major phase transitions
+        const majorPhases = ['executing', 'reporting', 'complete'];
+        if (!majorPhases.includes(event.phase))
+            return;
+        const phaseLabels = {
+            executing: 'Executing tasks...',
+            reporting: 'Generating report...',
+            complete: 'Complete',
+        };
+        const label = phaseLabels[event.phase] || event.phase;
+        const line = `\n${theme.secondary?.(`${ICONS.info} ${label}`) ?? `${ICONS.info} ${label}`}`;
+        this.enqueueUIUpdate('prompt', () => {
+            this.display.writeRaw(`${line}\n`);
+        }, `phase-${event.phase}`);
+    }
+    /**
+     * Render a finding in Claude Code style:
+     * ⚠ [SEVERITY] title
+     *   Recommendation: ...
+     */
+    renderFinding(finding) {
+        const severityColors = {
+            critical: theme.error ?? ((t) => t),
+            high: theme.error ?? ((t) => t),
+            medium: theme.warning ?? ((t) => t),
+            low: theme.ui?.muted ?? ((t) => t),
+            info: theme.ui?.muted ?? ((t) => t),
+        };
+        const color = severityColors[finding.severity] || ((t) => t);
+        const icon = finding.severity === 'critical' || finding.severity === 'high' ? ICONS.error : ICONS.warning;
+        const lines = [
+            `${color(`${icon} [${finding.severity.toUpperCase()}]`)} ${finding.title}`,
+        ];
+        if (finding.recommendation) {
+            lines.push(`  ${ICONS.subaction} ${theme.ui?.muted?.(`Recommendation: ${finding.recommendation}`) ?? `Recommendation: ${finding.recommendation}`}`);
+        }
+        this.enqueueUIUpdate('tool', () => {
+            this.display.writeRaw(`${lines.join('\n')}\n`);
+        }, `finding-${Date.now()}`);
+        // Also emit as event for external listeners
+        this.emitEvent('finding', finding);
+    }
+    /**
+     * Start the spinner animation for active tools.
+     */
+    startSpinner() {
+        if (this.spinnerInterval)
+            return;
+        this.spinnerInterval = setInterval(() => {
+            for (const [, tool] of this.activeTools) {
+                tool.spinnerFrame = (tool.spinnerFrame + 1) % ICONS.spinner.length;
+            }
+        }, 80);
+    }
+    /**
+     * Stop the spinner animation.
+     */
+    stopSpinner() {
+        if (this.spinnerInterval) {
+            clearInterval(this.spinnerInterval);
+            this.spinnerInterval = null;
+        }
+        this.activeTools.clear();
+    }
+    /**
+     * Execute a specific command with UI feedback.
+     */
+    async executeCommand(command, timeout) {
+        if (!this.orchestrator) {
+            this.orchestrator = new UnifiedOrchestrator();
+        }
+        this.currentState.currentCommand = command;
+        this.updateStatus(`Running: ${this.truncate(command, 40)}`);
+        const startTime = Date.now();
+        const result = this.orchestrator.exec(command, timeout);
+        const duration = Date.now() - startTime;
+        this.commandResults.push(result);
+        this.currentState.currentCommand = null;
+        // Analyze for findings
+        const newFindings = this.orchestrator.analyze(result.output, command);
+        this.findings.push(...newFindings);
+        // Emit events
+        this.emitEvent('command', { command, result, duration });
+        for (const finding of newFindings) {
+            this.emitEvent('finding', finding);
+        }
+        // Update UI
+        if (this.config.showRealTimeOutput) {
+            this.displayCommandResult(command, result);
+        }
+        return result;
+    }
+    /**
+     * Get current orchestration state.
+     */
+    getState() {
+        return { ...this.currentState };
+    }
+    /**
+     * Check if orchestration is currently running.
+     */
+    isRunning() {
+        return this.currentState.isRunning;
+    }
+    /**
+     * Dispose the bridge and clean up resources.
+     */
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.stopHeartbeat();
+        this.statusOrchestrator.dispose();
+        this.updateCoordinator.dispose();
+        this.removeAllListeners();
+    }
+    // --------------------------------------------------------------------------
+    // Execution with Progress
+    // --------------------------------------------------------------------------
+    async executeWithProgress(objective, options) {
+        if (!this.orchestrator) {
+            throw new Error('Orchestrator not initialized');
+        }
+        // Use the orchestrator's execute method but intercept progress
+        const report = await this.orchestrator.execute({
+            objective,
+            ...options,
+        });
+        // Collect results and findings
+        this.commandResults = this.orchestrator.getResults();
+        this.findings = this.orchestrator.getFindings();
+        // Update state
+        this.currentState.findingsCount = this.findings.length;
+        this.currentState.errorsCount = this.commandResults.filter(r => !r.success).length;
+        this.currentState.progress = 100;
+        return report;
+    }
+    // --------------------------------------------------------------------------
+    // UI Updates
+    // --------------------------------------------------------------------------
+    /**
+     * Show start banner in Claude Code style - minimal and clean.
+     */
+    showStartBanner(objective) {
+        const lines = [
+            '',
+            `${ICONS.action} ${theme.bold?.('Assistant') ?? 'Assistant'}`,
+            '',
+            `${theme.secondary?.('Objective:') ?? 'Objective:'} ${objective}`,
+            '',
+        ];
+        this.enqueueUIUpdate('prompt', () => {
+            this.display.writeRaw(lines.join('\n'));
+        }, 'orchestration-banner');
+    }
+    displayCommandResult(command, result) {
+        const status = result.success
+            ? theme.success?.('✓') ?? '✓'
+            : theme.error?.('✗') ?? '✗';
+        const duration = result.duration < 1000
+            ? `${result.duration}ms`
+            : `${(result.duration / 1000).toFixed(1)}s`;
+        const line = `  ${status} ${this.truncate(command, 60)} ${theme.ui?.muted?.(`(${duration})`) ?? `(${duration})`}`;
+        this.enqueueUIUpdate('tool', () => {
+            this.display.writeRaw(`${line}\n`);
+        }, `cmd-${Date.now()}`);
+        // Show errors inline
+        if (!result.success && result.error) {
+            const errorLine = `    ${theme.error?.(result.error) ?? result.error}`;
+            this.enqueueUIUpdate('tool', () => {
+                this.display.writeRaw(`${errorLine}\n`);
+            }, `cmd-err-${Date.now()}`);
+        }
+    }
+    /**
+     * Display final report in Claude Code style:
+     *
+     * ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+     * ✓ Operation Complete
+     * ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+     *
+     * Status: ✓ Success  Duration: 2.3s  Commands: 5/5 succeeded
+     *
+     * Findings
+     *   • [CRITICAL] Potential secrets in code
+     *     ⎿ Recommendation: Use environment variables
+     *
+     * Failed Commands
+     *   ✗ npm run lint - Command failed
+     *
+     * Summary
+     *   5/5 succeeded, 2 findings (1 critical)
+     */
+    displayReport(report) {
+        const lines = [''];
+        // Visual separator
+        const separator = theme.gradient?.primary?.('━'.repeat(50)) ?? '━'.repeat(50);
+        lines.push(separator);
+        // Header with status
+        const statusIcon = report.success
+            ? theme.success?.(ICONS.success) ?? ICONS.success
+            : theme.warning?.(ICONS.warning) ?? ICONS.warning;
+        const statusText = report.success ? 'Operation Complete' : 'Operation Incomplete';
+        lines.push(`${statusIcon} ${theme.bold?.(statusText) ?? statusText}`);
+        lines.push(separator);
+        lines.push('');
+        // Metrics line - compact Claude Code style
+        const duration = report.duration < 1000
+            ? `${report.duration}ms`
+            : `${(report.duration / 1000).toFixed(1)}s`;
+        const successCount = report.results.filter(r => r.success).length;
+        const failedCount = report.results.length - successCount;
+        const criticalCount = report.findings.filter(f => f.severity === 'critical').length;
+        const statusBadge = report.success
+            ? theme.success?.(`${ICONS.success} Success`) ?? `${ICONS.success} Success`
+            : theme.warning?.(`${ICONS.warning} Issues Found`) ?? `${ICONS.warning} Issues Found`;
+        const metricsLine = [
+            `Status: ${statusBadge}`,
+            `Duration: ${theme.ui?.muted?.(duration) ?? duration}`,
+            `Commands: ${successCount}/${report.results.length} succeeded`,
+        ].join('  ');
+        lines.push(metricsLine);
+        lines.push('');
+        // Findings section (Claude Code style bullet list)
+        if (report.findings.length > 0) {
+            lines.push(theme.bold?.('Findings') ?? 'Findings');
+            for (const finding of report.findings.slice(0, this.config.maxVisibleFindings)) {
+                const severityColor = this.getSeverityColor(finding.severity);
+                const icon = finding.severity === 'critical' || finding.severity === 'high' ? ICONS.error : ICONS.bullet;
+                lines.push(`  ${icon} ${severityColor(`[${finding.severity.toUpperCase()}]`)} ${finding.title}`);
+                if (finding.recommendation) {
+                    lines.push(`    ${ICONS.subaction} ${theme.ui?.muted?.(`Recommendation: ${finding.recommendation}`) ?? `Recommendation: ${finding.recommendation}`}`);
+                }
+            }
+            if (report.findings.length > this.config.maxVisibleFindings) {
+                lines.push(`  ${theme.ui?.muted?.(`... and ${report.findings.length - this.config.maxVisibleFindings} more`) ?? `... and ${report.findings.length - this.config.maxVisibleFindings} more`}`);
+            }
+            lines.push('');
+        }
+        // Failed commands (Claude Code style)
+        const failed = report.results.filter(r => !r.success);
+        if (failed.length > 0) {
+            lines.push(theme.bold?.('Failed Commands') ?? 'Failed Commands');
+            for (const result of failed.slice(0, 5)) {
+                const cmd = this.truncate(result.command ?? 'unknown', 50);
+                const errorMsg = result.error ? ` - ${this.truncate(result.error, 30)}` : '';
+                lines.push(`  ${theme.error?.(ICONS.error) ?? ICONS.error} ${cmd}${theme.error?.(errorMsg) ?? errorMsg}`);
+            }
+            if (failed.length > 5) {
+                lines.push(`  ${theme.ui?.muted?.(`... and ${failed.length - 5} more`) ?? `... and ${failed.length - 5} more`}`);
+            }
+            lines.push('');
+        }
+        // Summary line
+        lines.push(theme.bold?.('Summary') ?? 'Summary');
+        const summaryParts = [`${successCount}/${report.results.length} succeeded`];
+        if (report.findings.length > 0) {
+            summaryParts.push(`${report.findings.length} finding${report.findings.length === 1 ? '' : 's'}${criticalCount > 0 ? ` (${criticalCount} critical)` : ''}`);
+        }
+        if (failedCount > 0) {
+            summaryParts.push(`${failedCount} failed`);
+        }
+        lines.push(`  ${summaryParts.join(', ')}`);
+        lines.push('');
+        this.enqueueUIUpdate('prompt', () => {
+            this.display.writeRaw(lines.join('\n'));
+        }, 'orchestration-report');
+    }
+    handleError(error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.currentState.errorsCount++;
+        this.enqueueUIUpdate('prompt', () => {
+            this.display.showError('Orchestration Error', error);
+        }, 'orchestration-error');
+        this.emitEvent('error', { error: message });
+    }
+    // --------------------------------------------------------------------------
+    // Status Management
+    // --------------------------------------------------------------------------
+    setPhase(phase) {
+        this.currentState.phase = phase;
+        this.currentState.isRunning = phase !== 'complete' && phase !== 'error';
+        this.currentState.elapsedMs = Date.now() - this.startTime;
+        const phaseDescriptions = {
+            initializing: 'Initializing orchestration...',
+            analyzing: 'Analyzing objective...',
+            executing: 'Executing commands...',
+            reporting: 'Generating report...',
+            complete: 'Orchestration complete',
+            error: 'Orchestration error',
+        };
+        this.updateStatus(phaseDescriptions[phase]);
+        this.emitEvent('progress', this.getProgress());
+    }
+    updateStatus(status) {
+        this.statusOrchestrator.setBaseStatus({
+            text: status,
+            tone: 'info',
+            startedAt: this.startTime,
+        });
+    }
+    getProgress() {
+        return {
+            phase: this.currentState.phase,
+            currentCommand: this.currentState.currentCommand ?? undefined,
+            commandIndex: this.commandResults.length,
+            totalCommands: this.commandResults.length,
+            elapsedMs: Date.now() - this.startTime,
+            findings: [...this.findings],
+            errors: this.commandResults.filter(r => !r.success).map(r => r.error ?? 'Unknown error'),
+        };
+    }
+    // --------------------------------------------------------------------------
+    // Heartbeat & Status Updates
+    // --------------------------------------------------------------------------
+    startHeartbeat() {
+        if (this.heartbeatId)
+            return;
+        this.heartbeatId = `orchestration-heartbeat-${Date.now()}`;
+        this.updateCoordinator.startHeartbeat(this.heartbeatId, {
+            intervalMs: 1000,
+            run: () => {
+                if (this.currentState.isRunning) {
+                    this.updateElapsedTime();
+                }
+            },
+            mode: ['processing', 'tooling'],
+            immediate: false,
+        });
+    }
+    stopHeartbeat() {
+        if (this.heartbeatId) {
+            this.updateCoordinator.stopHeartbeat(this.heartbeatId);
+            this.heartbeatId = null;
+        }
+    }
+    updateElapsedTime() {
+        this.currentState.elapsedMs = Date.now() - this.startTime;
+        const elapsed = this.formatElapsed(this.currentState.elapsedMs);
+        const statusText = this.currentState.currentCommand
+            ? `Running: ${this.truncate(this.currentState.currentCommand, 40)} (${elapsed})`
+            : `Orchestrating... (${elapsed})`;
+        this.statusOrchestrator.setBaseStatus({
+            text: statusText,
+            tone: 'info',
+            startedAt: this.startTime,
+        });
+    }
+    // --------------------------------------------------------------------------
+    // Event Handling
+    // --------------------------------------------------------------------------
+    setupStatusListeners() {
+        this.statusOrchestrator.subscribe((event) => {
+            if (event.type.startsWith('tool.')) {
+                this.handleToolStatusEvent(event.type, event.data);
+            }
+        });
+    }
+    handleToolStatusEvent(type, status) {
+        // Bridge tool status to orchestration progress
+        if (type === 'tool.start') {
+            this.currentState.currentCommand = status.description;
+        }
+        else if (type === 'tool.complete' || type === 'tool.error') {
+            this.currentState.currentCommand = null;
+        }
+    }
+    emitEvent(type, data) {
+        const event = {
+            type,
+            timestamp: Date.now(),
+            data,
+        };
+        this.emit(type, event);
+        this.emit('event', event);
+    }
+    // --------------------------------------------------------------------------
+    // UI Update Coordination
+    // --------------------------------------------------------------------------
+    enqueueUIUpdate(lane, run, coalesceKey) {
+        this.updateCoordinator.enqueue({
+            lane,
+            run,
+            description: 'orchestration-update',
+            priority: 'normal',
+            coalesceKey,
+        });
+    }
+    // --------------------------------------------------------------------------
+    // Helpers
+    // --------------------------------------------------------------------------
+    createInitialState() {
+        return {
+            isRunning: false,
+            phase: 'initializing',
+            progress: 0,
+            currentCommand: null,
+            findingsCount: 0,
+            errorsCount: 0,
+            elapsedMs: 0,
+        };
+    }
+    reset() {
+        this.currentState = this.createInitialState();
+        this.commandResults = [];
+        this.findings = [];
+        this.startTime = 0;
+    }
+    truncate(text, maxLength) {
+        if (text.length <= maxLength)
+            return text;
+        return `${text.slice(0, maxLength - 3)}...`;
+    }
+    formatElapsed(ms) {
+        const seconds = Math.floor(ms / 1000);
+        if (seconds < 60)
+            return `${seconds}s`;
+        const minutes = Math.floor(seconds / 60);
+        const remainingSeconds = seconds % 60;
+        return `${minutes}m ${remainingSeconds}s`;
+    }
+    getSeverityColor(severity) {
+        switch (severity) {
+            case 'critical':
+            case 'high':
+                return theme.error ?? ((t) => t);
+            case 'medium':
+                return theme.warning ?? ((t) => t);
+            case 'low':
+            case 'info':
+            default:
+                return theme.ui?.muted ?? ((t) => t);
+        }
+    }
+}
+// ============================================================================
+// Factory Function
+// ============================================================================
+/**
+ * Create an OrchestrationUIBridge with default configuration.
+ */
+export function createOrchestrationUIBridge(display, options) {
+    return new OrchestrationUIBridge({
+        display,
+        ...options,
+    });
+}
+//# sourceMappingURL=OrchestrationUIBridge.js.map