erosolar-cli 2.1.171 → 2.1.172

package/dist/ui/display.js

@@ -1,223 +1,53 @@
-/**
- * Display - Simplified UI facade that routes all output through UnifiedUIRenderer
- *
- * This class now serves as a compatibility layer, providing the same API
- * but delegating all actual rendering to UnifiedUIRenderer.
- */
 import readline from 'node:readline';
-import { theme, icons } from './theme.js';
-import { renderMessagePanel, renderMessageBody } from './richText.js';
-import { getTerminalColumns } from './layout.js';
-import { highlightError } from './textHighlighter.js';
-import { renderSectionHeading } from './designSystem.js';
-import { isPlainOutputMode } from './outputMode.js';
-// Display configuration constants
-const DISPLAY_CONSTANTS = {
-    MIN_BANNER_WIDTH: 32,
-    MAX_BANNER_WIDTH: 120,
-    BANNER_PADDING: 4,
-    MIN_MESSAGE_WIDTH: 42,
-    MAX_MESSAGE_WIDTH: 110,
-    MESSAGE_PADDING: 4,
-    MIN_ACTION_WIDTH: 40,
-    MAX_ACTION_WIDTH: 90,
-    MIN_THOUGHT_WIDTH: 48,
-    MAX_THOUGHT_WIDTH: 96,
-    MIN_CONTENT_WIDTH: 10,
-    MIN_WRAP_WIDTH: 12,
-};
-/**
- * Display class - now a thin wrapper around UnifiedUIRenderer
- *
- * Provides backward-compatible API while routing all output through the renderer.
- */
+import { theme } from './theme.js';
 export class Display {
-    outputStream;
-    errorStream;
     renderer = null;
-    outputInterceptors = new Set();
+    outputStream;
     inlinePanelHandler = null;
-    constructor(stream = process.stdout, errorStream) {
+    thinkingStart = null;
+    lastToolResult = null;
+    activeSpinner = null;
+    constructor(stream = process.stdout, _errorStream) {
         this.outputStream = stream;
-        this.errorStream = errorStream ?? stream;
     }
     setRenderer(renderer) {
         this.renderer = renderer;
     }
-    hasRenderer() {
-        return Boolean(this.renderer);
-    }
     setInlinePanelHandler(handler) {
         this.inlinePanelHandler = handler;
     }
-    maybeHandleInlinePanel(content) {
-        if (!this.inlinePanelHandler) {
-            return false;
-        }
-        try {
-            return this.inlinePanelHandler(content) === true;
-        }
-        catch {
-            return false;
-        }
-    }
-    enqueueEvent(type, content) {
-        if (!this.renderer || !content) {
-            return false;
-        }
-        this.renderer.addEvent(type, content);
-        return true;
-    }
-    registerOutputInterceptor(interceptor) {
-        if (!interceptor) {
-            return () => { };
-        }
-        this.outputInterceptors.add(interceptor);
-        return () => {
-            this.outputInterceptors.delete(interceptor);
-        };
-    }
-    notifyBeforeOutput() {
-        for (const interceptor of this.outputInterceptors) {
-            interceptor.beforeWrite?.();
-        }
-    }
-    notifyAfterOutput(content) {
-        const interceptors = Array.from(this.outputInterceptors);
-        for (let index = interceptors.length - 1; index >= 0; index -= 1) {
-            interceptors[index]?.afterWrite?.(content);
-        }
-    }
-    /**
-     * Write raw content directly
-     */
-    writeRaw(content) {
+    emit(type, content, options) {
         if (!content)
             return;
-        this.notifyBeforeOutput();
-        if (this.enqueueEvent('raw', content)) {
-            this.notifyAfterOutput(content);
+        if (this.renderer) {
+            this.renderer.addEvent(type, content, options);
             return;
         }
-        // Fallback if no renderer
         this.outputStream.write(content);
-        this.notifyAfterOutput(content);
     }
-    /**
-     * Stream chunk (for streaming responses)
-     */
     stream(chunk) {
         if (!chunk)
             return;
-        this.notifyBeforeOutput();
-        if (this.enqueueEvent('streaming', chunk)) {
-            this.notifyAfterOutput(chunk);
-            return;
-        }
-        // Fallback
-        this.outputStream.write(chunk);
-        this.notifyAfterOutput(chunk);
-    }
-    /**
-     * Backward-compatible alias
-     */
-    writeStreamChunk(chunk) {
-        this.stream(chunk);
-    }
-    /**
-     * Get the output stream for direct access
-     */
-    getOutputStream() {
-        return this.outputStream;
-    }
-    /**
-     * Show thinking indicator
-     * NO-OP: Don't emit events during SSE streaming.
-     * The animated spinner in the status line shows thinking state.
-     */
-    showThinking(_message = 'Thinking…') {
-        // NO-OP: Spinner animation handles thinking state visually.
-        // No events emitted - final message handler renders complete content.
-    }
-    /**
-     * Update thinking indicator (status line only, not scrollback)
-     * This is called frequently during streaming to show progress snippets.
-     * The actual content will be rendered as a complete block later.
-     */
-    updateThinking(_message) {
-        // NO-OP: Don't emit events for transient thinking updates.
-        // Thinking snippets are shown only in the status indicator (animated spinner).
-        // The complete thought/response will be rendered as a block when ready.
+        this.emit('streaming', chunk);
     }
-    /**
-     * Stop thinking (no-op - renderer handles state)
-     */
-    stopThinking(_addNewLine = true) {
-        // No-op - renderer handles thinking state
+    parallelAgentStatus(content) {
+        if (!content)
+            return;
+        const payload = content.endsWith('\n') ? content : `${content}\n`;
+        this.emit('streaming', payload);
     }
-    /**
-     * Show assistant message
-     */
     showAssistantMessage(content, metadata) {
         const normalized = content.trim();
         if (!normalized)
             return;
+        this.clearActiveSpinner();
         const isThought = metadata?.isFinal === false;
-        const useRichBlock = !isThought && metadata?.wasStreamed !== true;
-        const wrapped = useRichBlock ? this.buildChatBox(normalized, metadata) : this.wrapForRenderer(normalized);
-        const telemetry = !useRichBlock && metadata?.isFinal !== false ? this.formatTelemetryLine(metadata) : '';
-        const payload = telemetry ? `${wrapped}\n${telemetry}` : wrapped;
-        const eventType = isThought ? 'thought' : useRichBlock ? 'banner' : 'response';
-        this.notifyBeforeOutput();
-        if (!this.enqueueEvent(eventType, payload)) {
-            this.outputStream.write(`${payload}\n`);
-        }
-        this.notifyAfterOutput(payload);
+        const eventType = isThought ? 'thought' : 'response';
+        this.emit(eventType, normalized);
     }
-    /**
-     * Show narrative (thought)
-     * NO-OP: Don't emit events during SSE streaming.
-     * Narratives are buffered and rendered as part of the final response.
-     */
-    showNarrative(_content) {
-        // NO-OP: Don't emit intermediate narrative events.
-        // Final message handler renders complete thought + response.
+    showNarrative(content) {
+        this.showAssistantMessage(content, { isFinal: false });
     }
-    /**
-     * Show action
-     */
-    showAction(text, status = 'info') {
-        if (!text.trim())
-            return;
-        const icon = this.formatActionIcon(status);
-        const rendered = this.wrapWithPrefix(text, `${icon} `);
-        this.enqueueEvent('raw', `${rendered}\n`);
-    }
-    /**
-     * Show sub-action
-     */
-    showSubAction(text, status = 'info') {
-        if (!text.trim())
-            return;
-        const lines = this.buildWrappedSubActionLines(text, status);
-        if (!lines.length)
-            return;
-        this.enqueueEvent('raw', `${lines.join('\n')}\n\n`);
-    }
-    /**
-     * Show message
-     */
-    showMessage(content, role = 'assistant') {
-        if (role === 'system') {
-            this.showSystemMessage(content);
-        }
-        else {
-            this.showAssistantMessage(content);
-        }
-    }
-    /**
-     * Show system message
-     */
     showSystemMessage(content) {
         const normalized = content.trim();
         if (!normalized)
@@ -225,29 +55,69 @@ export class Display {
         if (this.maybeHandleInlinePanel(normalized)) {
             return;
         }
-        const output = `${normalized}\n\n`;
-        this.notifyBeforeOutput();
-        if (!this.enqueueEvent('response', output)) {
-            this.outputStream.write(output);
+        this.emit('response', normalized);
+    }
+    showError(message, error) {
+        const parts = [`${theme.error('✗')} ${message}`];
+        if (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            parts.push(theme.ui.muted(detail));
         }
-        this.notifyAfterOutput(output);
+        this.emit('response', parts.join('\n'));
+    }
+    showWarning(message) {
+        this.emit('response', `${theme.warning('!')} ${message}`);
+    }
+    showInfo(message) {
+        this.emit('response', `${theme.info('•')} ${message}`);
+    }
+    showSuccess(message) {
+        this.emit('response', `${theme.success('✓')} ${message}`);
     }
-    /**
-     * Show test event (renders in unified UI "test" lane)
-     */
     showTestEvent(content) {
         const normalized = content.trim();
         if (!normalized)
             return;
-        this.notifyBeforeOutput();
-        if (!this.enqueueEvent('test', normalized)) {
-            this.outputStream.write(`${normalized}\n\n`);
+        this.emit('test', normalized);
+    }
+    showThinking(message = 'Thinking…') {
+        this.thinkingStart = Date.now();
+        this.emit('thought', message);
+    }
+    updateThinking(message) {
+        this.emit('thought', message);
+    }
+    stopThinking(addNewline = true) {
+        this.clearActiveSpinner(!addNewline);
+        this.thinkingStart = null;
+    }
+    clearActiveSpinner(useStop = false) {
+        if (!this.activeSpinner) {
+            return;
+        }
+        const spinner = this.activeSpinner;
+        this.activeSpinner = null;
+        try {
+            if (!useStop && typeof spinner.clear === 'function') {
+                spinner.clear();
+            }
+            else if (typeof spinner.stop === 'function') {
+                spinner.stop();
+            }
+        }
+        catch {
+            // ignore spinner errors
         }
-        this.notifyAfterOutput(normalized);
     }
-    /**
-     * Show an inline panel pinned below the prompt (overlay only, no scrollback).
-     */
+    isSpinnerActive() {
+        return false;
+    }
+    getThinkingElapsedMs() {
+        if (!this.thinkingStart) {
+            return null;
+        }
+        return Date.now() - this.thinkingStart;
+    }
     showInlinePanel(content) {
         const lines = Array.isArray(content) ? content : content.split('\n');
         const normalized = lines.map(line => line.trimEnd()).filter(line => line.trim().length > 0);
@@ -259,22 +129,15 @@ export class Display {
             this.renderer.setInlinePanel(normalized);
             return;
         }
-        // Fallback for plain mode: emit directly without routing through the inline handler
         const output = `${normalized.join('\n')}\n`;
-        this.notifyBeforeOutput();
         this.outputStream.write(output);
-        this.notifyAfterOutput(output);
     }
     clearInlinePanel() {
         if (this.renderer && typeof this.renderer.clearInlinePanel === 'function') {
             this.renderer.clearInlinePanel();
         }
     }
-    /**
-     * Capture a single line of user input without logging it to scrollback.
-     * Uses the unified renderer when available, with a readline fallback.
-     */
-    async captureUserInput(options = {}) {
+    captureUserInput(options = {}) {
         if (this.renderer && typeof this.renderer.captureInput === 'function') {
             return this.renderer.captureInput(options);
         }
@@ -295,180 +158,46 @@ export class Display {
             });
         });
     }
-    /**
-     * Show error
-     */
-    showError(message, error) {
-        const details = this.formatErrorDetails(error);
-        const parts = [`${theme.error('✗')} ${message}`];
-        if (details) {
-            parts.push(`  ${details}`);
-        }
-        const output = `${parts.join('\n')}\n`;
-        this.notifyBeforeOutput();
-        if (!this.enqueueEvent('response', output)) {
-            this.outputStream.write(output);
-        }
-        this.notifyAfterOutput(output);
-    }
-    /**
-     * Show warning
-     */
-    showWarning(message) {
-        const output = `${theme.warning('!')} ${message}\n`;
-        this.notifyBeforeOutput();
-        if (!this.enqueueEvent('response', output)) {
-            this.outputStream.write(output);
-        }
-        this.notifyAfterOutput(output);
-    }
-    /**
-     * Show info
-     */
-    showInfo(message) {
-        const output = `${theme.info('ℹ')} ${message}\n`;
-        this.notifyBeforeOutput();
-        if (!this.enqueueEvent('response', output)) {
-            this.outputStream.write(output);
-        }
-        this.notifyAfterOutput(output);
+    rememberToolResult(content, summary) {
+        const normalized = content.trim();
+        if (!normalized)
+            return;
+        this.lastToolResult = normalized;
+        this.renderer?.rememberToolResult(normalized, summary);
     }
-    /**
-     * Show success
-     */
-    showSuccess(message) {
-        const output = `${theme.success('✓')} ${message}\n`;
-        this.notifyBeforeOutput();
-        if (!this.enqueueEvent('response', output)) {
-            this.outputStream.write(output);
+    expandLastToolResult() {
+        if (this.renderer?.expandLastToolResult?.()) {
+            return;
         }
-        this.notifyAfterOutput(output);
-    }
-    /**
-     * Show progress badge
-     */
-    showProgressBadge(label, current, total) {
-        const percentage = Math.round((current / total) * 100);
-        const barWidth = 20;
-        const filled = Math.round((current / total) * barWidth);
-        const empty = barWidth - filled;
-        const progressBar = `${'█'.repeat(filled)}${'░'.repeat(empty)}`;
-        const badge = `[${label}] ${progressBar} ${percentage}%`;
-        this.stream(`\r${theme.info(badge)}`);
-        if (current >= total) {
-            this.stream('\n');
+        if (this.lastToolResult) {
+            this.emit('tool-result', this.lastToolResult);
         }
     }
-    /**
-     * Show status line
-     */
-    showStatusLine(status, elapsedMs, _context) {
+    showStatusLine(status, elapsedMs) {
         const normalized = status?.trim();
         if (!normalized)
             return;
         const elapsed = this.formatElapsed(elapsedMs);
-        const parts = [`• ${normalized}`];
+        const parts = [normalized];
         if (elapsed) {
             parts.push(elapsed);
         }
-        if (process.stdout.isTTY) {
-            parts.push('esc to interrupt');
-        }
-        // Status is kept internal; avoid forcing re-render of the overlay.
         this.renderer?.updateStatusBundle({ main: parts.join(' • ') }, { render: false });
     }
-    /**
-     * Show command palette
-     */
-    showCommandPalette(commands, options) {
-        if (!commands || commands.length === 0)
-            return;
-        const panel = this.buildCommandPalette(commands, options);
-        if (!panel.trim())
-            return;
-        const output = `\n${panel}\n\n`;
-        this.notifyBeforeOutput();
-        if (!this.enqueueEvent('response', output)) {
-            this.outputStream.write(output);
-        }
-        this.notifyAfterOutput(output);
-    }
-    /**
-     * Show planning step
-     */
-    showPlanningStep(step, index, total) {
-        if (!step?.trim() || index < 1 || total < 1 || index > total)
-            return;
-        const width = Math.max(DISPLAY_CONSTANTS.MIN_THOUGHT_WIDTH, Math.min(this.getColumnWidth(), DISPLAY_CONSTANTS.MAX_MESSAGE_WIDTH));
-        const heading = renderSectionHeading(`Plan ${index}/${total}`, {
-            subtitle: step,
-            icon: icons.arrow,
-            tone: 'info',
-            width,
-        });
-        this.enqueueEvent('raw', `${heading}\n`);
-    }
-    /**
-     * Show thinking block
-     */
-    showThinkingBlock(content, durationMs) {
-        const block = this.buildClaudeStyleThought(content, durationMs);
-        this.enqueueEvent('raw', `\n${block}\n\n`);
-    }
-    /**
-     * Clear screen
-     */
     clear() {
-        // Renderer handles this
-    }
-    /**
-     * Update streaming status (routes to renderer)
-     */
-    updateStreamingStatus(status) {
-        this.renderer?.updateStatus(status);
-    }
-    /**
-     * Clear streaming status
-     */
-    clearStreamingStatus() {
-        this.renderer?.updateStatus(null);
-    }
-    /**
-     * Check if streaming status is visible
-     */
-    isStreamingStatusVisible() {
-        return false; // Renderer manages this
+        // Renderer manages overlay cleanup; nothing to do here.
     }
-    parallelAgentStatus(content) {
-        if (!content)
-            return;
-        this.enqueueEvent('streaming', `${content}\n`);
-    }
-    // ==================== Private Helper Methods ====================
-    getColumnWidth() {
-        if (typeof this.outputStream.columns === 'number' &&
-            Number.isFinite(this.outputStream.columns) &&
-            this.outputStream.columns > 0) {
-            return this.outputStream.columns;
-        }
-        return getTerminalColumns();
+    registerOutputInterceptor(_interceptor) {
+        return () => { };
     }
-    formatErrorDetails(error) {
-        if (!error)
-            return null;
-        if (error instanceof Error) {
-            if (error.stack)
-                return highlightError(error.stack);
-            return highlightError(error.message);
-        }
-        if (typeof error === 'string') {
-            return highlightError(error);
-        }
+    maybeHandleInlinePanel(content) {
+        if (!this.inlinePanelHandler)
+            return false;
         try {
-            return highlightError(JSON.stringify(error, null, 2));
+            return this.inlinePanelHandler(content) === true;
         }
         catch {
-            return null;
+            return false;
         }
     }
     formatElapsed(elapsedMs) {
@@ -483,316 +212,6 @@ export class Display {
         }
         return `${seconds}s`;
     }
-    buildChatBox(content, metadata) {
-        const normalized = content.trim();
-        if (!normalized)
-            return '';
-        if (isPlainOutputMode()) {
-            const body = renderMessageBody(normalized, this.resolveMessageWidth());
-            const telemetry = this.formatTelemetryLine(metadata);
-            return telemetry ? `${body}\n${telemetry}` : body;
-        }
-        const width = this.resolveMessageWidth();
-        const panel = renderMessagePanel(normalized, {
-            width,
-            title: 'Assistant',
-            icon: icons.assistant,
-            accentColor: theme.assistant ?? theme.primary,
-            borderColor: theme.ui.border,
-        });
-        const telemetry = this.formatTelemetryLine(metadata);
-        return telemetry ? `${panel}\n${telemetry}` : panel;
-    }
-    resolveMessageWidth() {
-        const columns = this.getColumnWidth();
-        return Math.max(DISPLAY_CONSTANTS.MIN_MESSAGE_WIDTH, Math.min(columns - DISPLAY_CONSTANTS.MESSAGE_PADDING, DISPLAY_CONSTANTS.MAX_MESSAGE_WIDTH));
-    }
-    formatTelemetryLine(metadata) {
-        if (!metadata)
-            return '';
-        const parts = [];
-        const elapsed = this.formatElapsed(metadata.elapsedMs);
-        if (elapsed) {
-            const elapsedLabel = theme.metrics?.elapsedLabel ?? theme.accent;
-            const elapsedValue = theme.metrics?.elapsedValue ?? theme.secondary;
-            parts.push(`${elapsedLabel('elapsed')} ${elapsedValue(elapsed)}`);
-        }
-        if (!parts.length)
-            return '';
-        const separator = theme.ui.muted(' • ');
-        return `  ${parts.join(separator)}`;
-    }
-    buildClaudeStyleThought(content, durationMs) {
-        const thinkingStyle = theme.thinking || {
-            icon: theme.info,
-            text: theme.ui.muted,
-            border: theme.ui.border,
-            label: theme.info,
-        };
-        const width = Math.min(this.getColumnWidth() - 4, 70);
-        const lines = [];
-        // Header
-        if (durationMs !== undefined) {
-            const elapsed = this.formatElapsedTime(Math.floor(durationMs / 1000));
-            lines.push(`${theme.info('∴')} Thought for ${elapsed}`);
-        }
-        else {
-            lines.push(`${theme.info('✻')} ${thinkingStyle.label('Thinking…')}`);
-        }
-        // Content
-        const contentLines = content.split('\n');
-        const hasContent = contentLines.some(line => line.trim().length > 0);
-        if (hasContent) {
-            lines.push('');
-        }
-        for (const line of contentLines) {
-            const trimmed = line.replace(/\s+$/, '');
-            if (!trimmed.trim()) {
-                lines.push('');
-                continue;
-            }
-            const wrapped = this.wrapLine(trimmed, width - 4);
-            for (const wrappedLine of wrapped) {
-                lines.push(`  ${thinkingStyle.text(wrappedLine)}`);
-            }
-        }
-        return lines.join('\n');
-    }
-    formatElapsedTime(seconds) {
-        if (seconds < 60) {
-            return `${seconds}s`;
-        }
-        const mins = Math.floor(seconds / 60);
-        const secs = seconds % 60;
-        return secs > 0 ? `${mins}m ${secs}s` : `${mins}m`;
-    }
-    buildCommandPalette(commands, options) {
-        if (!commands.length)
-            return '';
-        const width = Math.max(DISPLAY_CONSTANTS.MIN_MESSAGE_WIDTH, Math.min(this.getColumnWidth() - 2, DISPLAY_CONSTANTS.MAX_MESSAGE_WIDTH));
-        const indent = '  ';
-        const grouped = this.groupPaletteCommands(commands);
-        const commandWidth = this.computeCommandColumnWidth(commands, width, indent.length);
-        const descWidth = Math.max(DISPLAY_CONSTANTS.MIN_WRAP_WIDTH, width - indent.length - commandWidth - 1);
-        const title = options?.title ?? 'Slash commands';
-        const intro = options?.intro ?? 'Describe a task or pick a command below:';
-        const lines = [];
-        lines.push(theme.gradient.primary(title));
-        const introLines = this.wrapLine(intro, width);
-        for (const line of introLines) {
-            lines.push(theme.ui.muted(line));
-        }
-        lines.push('');
-        grouped.forEach(({ category, items }, index) => {
-            const label = this.formatPaletteCategory(category);
-            if (label) {
-                lines.push(theme.bold(label));
-            }
-            for (const item of items) {
-                const wrappedDesc = this.wrapLine(item.description, descWidth);
-                const paddedCommand = item.command.padEnd(commandWidth);
-                const commandLabel = theme.primary(paddedCommand);
-                const firstLine = wrappedDesc[0] ?? '';
-                lines.push(`${indent}${commandLabel} ${this.colorizePaletteText(firstLine, item.tone)}`);
-                for (const extra of wrappedDesc.slice(1)) {
-                    lines.push(`${indent}${' '.repeat(commandWidth)} ${this.colorizePaletteText(extra, item.tone)}`);
-                }
-            }
-            if (index < grouped.length - 1) {
-                lines.push('');
-            }
-        });
-        return lines.join('\n').trimEnd();
-    }
-    groupPaletteCommands(commands) {
-        const FALLBACK = 'other';
-        const groups = new Map();
-        for (const item of commands) {
-            const key = (item.category ?? FALLBACK).toLowerCase();
-            const bucket = groups.get(key) ?? [];
-            bucket.push(item);
-            groups.set(key, bucket);
-        }
-        const order = ['configuration', 'workspace', 'diagnostics', 'other'];
-        const orderedKeys = [
-            ...order.filter((key) => groups.has(key)),
-            ...Array.from(groups.keys()).filter((key) => !order.includes(key)),
-        ];
-        return orderedKeys.map((category) => ({ category, items: groups.get(category) ?? [] }));
-    }
-    computeCommandColumnWidth(commands, totalWidth, indentWidth) {
-        const longest = commands.reduce((max, item) => Math.max(max, this.visibleLength(item.command)), 0);
-        const maxAllowed = Math.max(12, Math.min(longest + 2, Math.floor(totalWidth * 0.35)));
-        const budget = Math.max(10, totalWidth - indentWidth - DISPLAY_CONSTANTS.MIN_WRAP_WIDTH);
-        return Math.min(maxAllowed, budget);
-    }
-    formatPaletteCategory(category) {
-        if (!category)
-            return 'Other';
-        switch (category.toLowerCase()) {
-            case 'configuration': return 'Configuration';
-            case 'workspace': return 'Workspace';
-            case 'diagnostics': return 'Diagnostics';
-            case 'other': return 'Other';
-            default: return category[0]?.toUpperCase() + category.slice(1);
-        }
-    }
-    colorizePaletteText(text, tone) {
-        switch (tone) {
-            case 'warn': return theme.warning(text);
-            case 'success': return theme.success(text);
-            case 'info': return theme.info(text);
-            case 'muted':
-            default: return theme.ui.muted(text);
-        }
-    }
-    wrapWithPrefix(text, prefix, options) {
-        if (!text) {
-            return prefix.trimEnd();
-        }
-        const width = Math.max(DISPLAY_CONSTANTS.MIN_ACTION_WIDTH, Math.min(this.getColumnWidth(), DISPLAY_CONSTANTS.MAX_ACTION_WIDTH));
-        const prefixWidth = this.visibleLength(prefix);
-        const available = Math.max(DISPLAY_CONSTANTS.MIN_CONTENT_WIDTH, width - prefixWidth);
-        const indent = typeof options?.continuationPrefix === 'string'
-            ? options.continuationPrefix
-            : ' '.repeat(Math.max(0, prefixWidth));
-        const segments = text.split('\n');
-        const lines = [];
-        let usedPrefix = false;
-        for (const segment of segments) {
-            if (!segment.trim()) {
-                if (usedPrefix) {
-                    lines.push(indent);
-                }
-                else {
-                    lines.push(prefix.trimEnd());
-                    usedPrefix = true;
-                }
-                continue;
-            }
-            const wrapped = this.wrapLine(segment.trim(), available);
-            for (const line of wrapped) {
-                lines.push(!usedPrefix ? `${prefix}${line}` : `${indent}${line}`);
-                usedPrefix = true;
-            }
-        }
-        return lines.join('\n');
-    }
-    buildWrappedSubActionLines(text, status) {
-        const lines = text.split('\n').map((line) => line.trimEnd());
-        while (lines.length && !lines[lines.length - 1]?.trim()) {
-            lines.pop();
-        }
-        if (!lines.length)
-            return [];
-        const rendered = [];
-        for (let index = 0; index < lines.length; index += 1) {
-            const segment = lines[index] ?? '';
-            const isLast = index === lines.length - 1;
-            const { prefix, continuation } = this.buildSubActionPrefixes(status, isLast);
-            rendered.push(this.wrapWithPrefix(segment, prefix, { continuationPrefix: continuation }));
-        }
-        return rendered;
-    }
-    buildSubActionPrefixes(status, isLast) {
-        if (isLast) {
-            const colorize = this.resolveStatusColor(status);
-            return {
-                prefix: `  ${colorize(icons.subaction)} `,
-                continuation: '    ',
-            };
-        }
-        const branch = theme.ui.muted('│');
-        return {
-            prefix: `  ${branch} `,
-            continuation: `  ${branch} `,
-        };
-    }
-    resolveStatusColor(status) {
-        switch (status) {
-            case 'success': return theme.success;
-            case 'error': return theme.error;
-            case 'warning': return theme.warning;
-            case 'pending': return theme.info;
-            default: return theme.secondary;
-        }
-    }
-    formatActionIcon(status) {
-        const colorize = this.resolveStatusColor(status);
-        return colorize(`${icons.action}`);
-    }
-    wrapForRenderer(text) {
-        const width = Math.max(DISPLAY_CONSTANTS.MIN_WRAP_WIDTH, Math.min(this.getColumnWidth() - 4, DISPLAY_CONSTANTS.MAX_MESSAGE_WIDTH));
-        const lines = [];
-        for (const line of text.split('\n')) {
-            const trimmed = line.trimEnd();
-            const wrapped = this.wrapLine(trimmed, width);
-            lines.push(...wrapped);
-        }
-        return lines.join('\n').trimEnd();
-    }
-    wrapLine(text, width) {
-        if (width <= 0)
-            return [text];
-        if (!text)
-            return [''];
-        if (text.length <= width)
-            return [text];
-        const words = text.split(/\s+/).filter(Boolean);
-        if (!words.length)
-            return this.chunkWord(text, width);
-        const lines = [];
-        let current = '';
-        for (const word of words) {
-            if (!current) {
-                if (word.length <= width) {
-                    current = word;
-                }
-                else {
-                    const chunks = this.chunkWord(word, width);
-                    lines.push(...chunks.slice(0, -1));
-                    current = chunks[chunks.length - 1] ?? '';
-                }
-            }
-            else if (current.length + 1 + word.length <= width) {
-                current = `${current} ${word}`;
-            }
-            else {
-                lines.push(current);
-                if (word.length <= width) {
-                    current = word;
-                }
-                else {
-                    const chunks = this.chunkWord(word, width);
-                    lines.push(...chunks.slice(0, -1));
-                    current = chunks[chunks.length - 1] ?? '';
-                }
-            }
-        }
-        if (current) {
-            lines.push(current);
-        }
-        return lines.length ? lines : [''];
-    }
-    chunkWord(word, width) {
-        if (width <= 0 || !word)
-            return word ? [word] : [''];
-        const chunks = [];
-        for (let i = 0; i < word.length; i += width) {
-            chunks.push(word.slice(i, i + width));
-        }
-        return chunks.length > 0 ? chunks : [''];
-    }
-    visibleLength(value) {
-        if (!value)
-            return 0;
-        return this.stripAnsi(value).length;
-    }
-    stripAnsi(value) {
-        if (!value)
-            return '';
-        return value.replace(/\u001B\[[0-?]*[ -/]*[@-~]/g, '');
-    }
 }
 export const display = new Display();
 //# sourceMappingURL=display.js.map