erosolar-cli 1.7.194 → 1.7.195

package/dist/ui/display.js

@@ -1,1469 +0,0 @@
-import { createSpinner } from 'nanospinner';
-import { clearScreenDown, cursorTo, moveCursor } from 'node:readline';
-import { theme, icons } from './theme.js';
-import { formatRichContent, renderMessagePanel, renderMessageBody } from './richText.js';
-import { getTerminalColumns, wrapPreformatted } from './layout.js';
-import { highlightError } from './textHighlighter.js';
-import { renderCallout, renderSectionHeading } from './designSystem.js';
-import { isPlainOutputMode } from './outputMode.js';
-/**
- * Output lock to prevent race conditions during spinner/stream output.
- * Ensures that spinner frames don't interleave with streamed content.
- * Uses a simple lock mechanism suitable for Node.js single-threaded event loop.
- */
-class OutputLock {
-    static instance = null;
-    locked = false;
-    pendingCallbacks = [];
-    static getInstance() {
-        if (!OutputLock.instance) {
-            OutputLock.instance = new OutputLock();
-        }
-        return OutputLock.instance;
-    }
-    /**
-     * Synchronously check if output is locked (spinner is active).
-     * Used to prevent stream writes during spinner animation.
-     */
-    isLocked() {
-        return this.locked;
-    }
-    /**
-     * Lock output during spinner animation.
-     */
-    lock() {
-        this.locked = true;
-    }
-    /**
-     * Unlock output and process any pending callbacks.
-     */
-    unlock() {
-        this.locked = false;
-        // Process any pending writes
-        while (this.pendingCallbacks.length > 0) {
-            const callback = this.pendingCallbacks.shift();
-            if (callback) {
-                callback();
-            }
-        }
-    }
-    /**
-     * Execute a callback safely, queueing if output is locked.
-     */
-    safeWrite(callback) {
-        if (this.locked) {
-            this.pendingCallbacks.push(callback);
-            return;
-        }
-        callback();
-    }
-}
-/**
- * Tracks line output to stdout for banner rewriting and cursor positioning.
- * Instances are cached per stream to keep banner calculations consistent.
- */
-class StdoutLineTracker {
-    static instances = new WeakMap();
-    static getInstance(stream = process.stdout) {
-        const existing = StdoutLineTracker.instances.get(stream);
-        if (existing) {
-            return existing;
-        }
-        const tracker = new StdoutLineTracker(stream);
-        StdoutLineTracker.instances.set(stream, tracker);
-        return tracker;
-    }
-    linesWritten = 0;
-    suspended = false;
-    stream;
-    originalWrite;
-    constructor(stream) {
-        this.stream = stream;
-        this.originalWrite = stream.write.bind(stream);
-        this.patchStream();
-    }
-    get totalLines() {
-        return this.linesWritten;
-    }
-    /**
-     * Temporarily suspends line tracking while executing a function.
-     * Useful for rewriting content without incrementing line count.
-     */
-    withSuspended(fn) {
-        const wasSuspended = this.suspended;
-        this.suspended = true;
-        try {
-            return fn();
-        }
-        finally {
-            this.suspended = wasSuspended;
-        }
-    }
-    reset() {
-        this.linesWritten = 0;
-    }
-    patchStream() {
-        const tracker = this;
-        this.stream.write = function patched(chunk, encoding, callback) {
-            const actualEncoding = typeof encoding === 'function' ? undefined : encoding;
-            tracker.recordChunk(chunk, actualEncoding);
-            return tracker.originalWrite.call(this, chunk, encoding, callback);
-        };
-    }
-    recordChunk(chunk, encoding) {
-        if (this.suspended) {
-            return;
-        }
-        const text = this.chunkToString(chunk, encoding);
-        if (!text) {
-            return;
-        }
-        this.countNewlines(text);
-    }
-    countNewlines(text) {
-        for (const char of text) {
-            if (char === '\n') {
-                this.linesWritten += 1;
-            }
-        }
-    }
-    chunkToString(chunk, encoding) {
-        if (typeof chunk === 'string') {
-            return chunk;
-        }
-        if (chunk instanceof Uint8Array) {
-            const enc = encoding ?? 'utf8';
-            return Buffer.from(chunk).toString(enc);
-        }
-        return null;
-    }
-}
-// 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,
-    SPINNER_INTERVAL: 80,
-};
-// Enhanced spinner frames with smooth animation
-const SPINNER_FRAMES = ['◐', '◓', '◑', '◒', '⣾', '⣽', '⣻', '⢿', '⡿', '⣟', '⣯', '⣷'];
-const INDEPENDENT_SECURITY_MANDATE = 'Independent security research CLI for third-party, ethics-reviewed assessments and vulnerability discovery.';
-/**
- * Display class manages all terminal UI output for the application.
- *
- * Architecture:
- * - Per-stream line tracking via StdoutLineTracker for consistent banner updates
- * - Output interceptor pattern for live update integration
- * - Banner state management for in-place updates
- * - Configurable width constraints via DISPLAY_CONSTANTS
- *
- * Claude Code Style Formatting:
- * - ⏺ prefix for tool calls, actions, and thinking/reasoning
- * - ⎿ prefix for results, details, and nested information
- * - ─ horizontal separators for dividing sections (edit diffs, etc.)
- * - > prefix for user prompts (handled in theme.ts formatUserPrompt)
- * - Compact epsilon spinner: ∴, ε, ✻
- *
- * Key responsibilities:
- * - Welcome banners and session information display
- * - Message formatting (assistant, system, errors, warnings)
- * - Spinner/thinking indicators
- * - Action and sub-action formatting with tree-style prefixes
- * - Text wrapping and layout management
- *
- * Error handling:
- * - Graceful degradation for non-TTY environments
- * - Input validation on public methods
- * - Safe cursor manipulation with fallback
- */
-export class Display {
-    stdoutTracker;
-    outputStream;
-    errorStream;
-    activeSpinner = null;
-    outputInterceptors = new Set();
-    outputLock = OutputLock.getInstance();
-    spinnerFrames = [...SPINNER_FRAMES];
-    thinkingStartTime = null;
-    thinkingElapsedTimer = null;
-    thinkingBaseMessage = 'Thinking...';
-    // Streaming status line (Claude Code style - single line at bottom)
-    streamingStatusVisible = false;
-    constructor(stream = process.stdout, errorStream) {
-        this.outputStream = stream;
-        this.errorStream = errorStream ?? stream;
-        this.stdoutTracker = StdoutLineTracker.getInstance(stream);
-    }
-    registerOutputInterceptor(interceptor) {
-        if (!interceptor) {
-            return () => { };
-        }
-        this.outputInterceptors.add(interceptor);
-        return () => {
-            this.outputInterceptors.delete(interceptor);
-        };
-    }
-    withOutput(fn) {
-        this.notifyBeforeOutput();
-        try {
-            return fn();
-        }
-        finally {
-            this.notifyAfterOutput();
-        }
-    }
-    notifyBeforeOutput() {
-        for (const interceptor of this.outputInterceptors) {
-            interceptor.beforeWrite?.();
-        }
-    }
-    notifyAfterOutput() {
-        const interceptors = Array.from(this.outputInterceptors);
-        for (let index = interceptors.length - 1; index >= 0; index -= 1) {
-            interceptors[index]?.afterWrite?.();
-        }
-    }
-    write(value, target = this.outputStream) {
-        target.write(value);
-    }
-    writeLine(value = '', target = this.outputStream) {
-        this.write(`${value}\n`, target);
-    }
-    /**
-     * Write raw content directly to output stream.
-     * Goes through interceptors and output lock so overlays refresh safely.
-     * Use this for streaming output chunks.
-     */
-    writeRaw(content) {
-        if (typeof content !== 'string') {
-            return;
-        }
-        this.outputLock.safeWrite(() => {
-            this.withOutput(() => {
-                this.write(content);
-            });
-        });
-    }
-    /**
-     * Stream chunk helper (alias for writeRaw).
-     */
-    stream(chunk) {
-        this.writeRaw(chunk);
-    }
-    /**
-     * Backward-compatible alias for stream().
-     */
-    writeStreamChunk(chunk) {
-        this.stream(chunk);
-    }
-    /**
-     * Get the output stream for direct access.
-     * Prefer writeRaw/writeStreamChunk for interceptor support.
-     */
-    getOutputStream() {
-        return this.outputStream;
-    }
-    getColumnWidth() {
-        if (typeof this.outputStream.columns === 'number' &&
-            Number.isFinite(this.outputStream.columns) &&
-            this.outputStream.columns > 0) {
-            return this.outputStream.columns;
-        }
-        return getTerminalColumns();
-    }
-    bannerState = null;
-    /**
-     * Displays the welcome banner with session information.
-     * Stores banner state for potential in-place updates.
-     */
-    showWelcome(profileLabel, profileName, model, provider, workingDir, version) {
-        // Validate required inputs
-        if (!model?.trim() || !provider?.trim() || !workingDir?.trim()) {
-            return;
-        }
-        const width = this.getBannerWidth();
-        const banner = this.buildClaudeStyleBanner(profileLabel ?? '', profileName ?? '', model, provider, workingDir, width, version);
-        if (!banner) {
-            return;
-        }
-        const startLine = this.stdoutTracker.totalLines;
-        this.withOutput(() => {
-            this.writeLine(banner);
-        });
-        const nextState = {
-            startLine,
-            height: this.measureBannerHeight(banner),
-            width,
-            workingDir,
-            model,
-            provider,
-            profileLabel: profileLabel ?? '',
-            profileName: profileName ?? '',
-        };
-        if (version?.trim()) {
-            nextState.version = version.trim();
-        }
-        this.bannerState = nextState;
-    }
-    /**
-     * Updates the session information banner with new model/provider.
-     * Attempts in-place update if possible, otherwise re-renders.
-     */
-    updateSessionInfo(model, provider) {
-        const state = this.bannerState;
-        if (!state) {
-            return;
-        }
-        // Validate inputs
-        if (!model?.trim() || !provider?.trim()) {
-            return;
-        }
-        const width = this.getBannerWidth();
-        const banner = this.buildClaudeStyleBanner(state.profileLabel, state.profileName, model, provider, state.workingDir, width, state.version);
-        const height = this.measureBannerHeight(banner);
-        // If height changed or rewrite failed, do full re-render
-        if (height !== state.height || !this.tryRewriteBanner(state, banner)) {
-            this.renderAndStoreBanner(state, model, provider);
-            return;
-        }
-        // Update succeeded, update state
-        state.model = model;
-        state.provider = provider;
-        state.width = width;
-        state.height = height;
-    }
-    showThinking(message = 'Thinking...') {
-        // If we already have a spinner, just update its text instead of creating a new one
-        if (this.activeSpinner) {
-            this.thinkingBaseMessage = message;
-            this.activeSpinner.update({ text: message });
-            return;
-        }
-        // Lock output to prevent stream writes from interleaving with spinner frames
-        this.outputLock.lock();
-        // Track when thinking started for elapsed time display
-        this.thinkingStartTime = Date.now();
-        this.thinkingBaseMessage = message;
-        // Use Claude Code style spinner with epsilon: ∴, ε, and ✻
-        this.activeSpinner = createSpinner(message, {
-            stream: this.outputStream,
-            spinner: {
-                interval: DISPLAY_CONSTANTS.SPINNER_INTERVAL,
-                frames: this.spinnerFrames,
-            },
-        }).start();
-        // Update spinner with elapsed time every second (Claude Code style)
-        this.thinkingElapsedTimer = setInterval(() => {
-            if (this.activeSpinner && this.thinkingStartTime) {
-                const elapsed = Math.floor((Date.now() - this.thinkingStartTime) / 1000);
-                if (elapsed > 0) {
-                    const elapsedText = this.formatElapsedTime(elapsed);
-                    this.activeSpinner.update({ text: `${this.thinkingBaseMessage} ${theme.ui.muted(`(${elapsedText})`)}` });
-                }
-            }
-        }, 1000);
-    }
-    /**
-     * Format elapsed seconds as human-readable time (e.g., "5s", "1m 23s")
-     */
-    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`;
-    }
-    updateThinking(message) {
-        this.thinkingBaseMessage = message;
-        if (this.activeSpinner) {
-            // If we have elapsed time, include it in the update
-            if (this.thinkingStartTime) {
-                const elapsed = Math.floor((Date.now() - this.thinkingStartTime) / 1000);
-                if (elapsed > 0) {
-                    const elapsedText = this.formatElapsedTime(elapsed);
-                    this.activeSpinner.update({ text: `${message} ${theme.ui.muted(`(${elapsedText})`)}` });
-                    return;
-                }
-            }
-            this.activeSpinner.update({ text: message });
-        }
-        else {
-            this.showThinking(message);
-        }
-    }
-    stopThinking(addNewLine = true) {
-        this.clearSpinnerIfActive(addNewLine);
-    }
-    /**
-     * Get current thinking elapsed time in milliseconds, or null if not thinking.
-     */
-    getThinkingElapsedMs() {
-        if (!this.thinkingStartTime) {
-            return null;
-        }
-        return Date.now() - this.thinkingStartTime;
-    }
-    isSpinnerActive() {
-        return this.activeSpinner !== null;
-    }
-    /**
-     * Check if output is currently locked (e.g., spinner is active).
-     * Used by external callers to coordinate output timing.
-     */
-    isOutputLocked() {
-        return this.outputLock.isLocked();
-    }
-    /**
-     * Execute a write callback safely, ensuring it doesn't interleave with spinner output.
-     * If spinner is active, the write will be queued until spinner stops.
-     */
-    safeWrite(callback) {
-        this.outputLock.safeWrite(callback);
-    }
-    /**
-     * Update the streaming status line (Claude Code style).
-     * Shows a single muted line at the bottom that updates in-place.
-     * Call with null to clear the status line.
-     */
-    updateStreamingStatus(status) {
-        if (!status) {
-            // Clear the status line
-            if (this.streamingStatusVisible) {
-                // Move to start of line and clear it
-                this.outputStream.write('\r\x1b[2K');
-                this.streamingStatusVisible = false;
-            }
-            return;
-        }
-        // Build the status line (Claude Code style: separator + status)
-        const cols = this.getColumnWidth();
-        const separatorWidth = Math.min(cols - 2, 72);
-        const separator = theme.ui.border('─'.repeat(separatorWidth));
-        // Truncate status if needed
-        const maxStatusLen = cols - 4;
-        const displayStatus = status.length > maxStatusLen
-            ? `${status.slice(0, maxStatusLen - 3)}...`
-            : status;
-        // Move to start of line, clear it, write status
-        // Use carriage return to overwrite the current line
-        if (this.streamingStatusVisible) {
-            // Already showing status - move up 2 lines to overwrite
-            this.outputStream.write('\x1b[2A\r\x1b[2K');
-            this.outputStream.write(`${separator}\n`);
-            this.outputStream.write(`\x1b[2K${theme.ui.muted(displayStatus)}\n`);
-        }
-        else {
-            // First time showing - just write on new lines
-            this.outputStream.write(`\n${separator}\n`);
-            this.outputStream.write(`${theme.ui.muted(displayStatus)}\n`);
-            this.streamingStatusVisible = true;
-        }
-    }
-    /**
-     * Check if streaming status is currently visible.
-     */
-    isStreamingStatusVisible() {
-        return this.streamingStatusVisible;
-    }
-    /**
-     * Clear streaming status and reset state.
-     */
-    clearStreamingStatus() {
-        if (this.streamingStatusVisible) {
-            // Clear the 2 lines (separator + status)
-            this.outputStream.write('\x1b[2A\r\x1b[J');
-            this.streamingStatusVisible = false;
-        }
-    }
-    clearSpinnerIfActive(addNewLine = true) {
-        if (!this.activeSpinner) {
-            return;
-        }
-        // Clear the elapsed time update timer
-        if (this.thinkingElapsedTimer) {
-            clearInterval(this.thinkingElapsedTimer);
-            this.thinkingElapsedTimer = null;
-        }
-        this.thinkingStartTime = null;
-        const spinner = this.activeSpinner;
-        this.activeSpinner = null;
-        // Use stop() instead of clear() so nanospinner removes its SIGINT/SIGTERM listeners.
-        // clear() leaves the listeners attached, which triggers MaxListenersExceededWarning over time.
-        spinner.stop();
-        // Unlock output to process any pending writes
-        this.outputLock.unlock();
-        if (addNewLine) {
-            this.withOutput(() => {
-                this.writeLine();
-            });
-        }
-    }
-    showAssistantMessage(content, metadata) {
-        if (!content.trim()) {
-            return;
-        }
-        this.clearSpinnerIfActive();
-        const isThought = metadata?.isFinal === false;
-        const body = isThought ? this.buildClaudeStyleThought(content) : this.buildChatBox(content, metadata);
-        if (!body.trim()) {
-            return;
-        }
-        this.withOutput(() => {
-            this.writeLine(); // Ensure clean start for the box
-            this.writeLine(body);
-            this.writeLine();
-        });
-    }
-    showNarrative(content) {
-        if (!content.trim()) {
-            return;
-        }
-        this.showAssistantMessage(content, { isFinal: false });
-    }
-    showAction(text, status = 'info') {
-        if (!text.trim()) {
-            return;
-        }
-        this.clearSpinnerIfActive();
-        // Claude Code style: always use ⏺ prefix for actions
-        const icon = this.formatActionIcon(status);
-        this.withOutput(() => {
-            this.writeLine(this.wrapWithPrefix(text, `${icon} `));
-        });
-    }
-    showSubAction(text, status = 'info') {
-        if (!text.trim()) {
-            return;
-        }
-        this.clearSpinnerIfActive();
-        const prefersRich = text.includes('```');
-        let rendered = prefersRich ? this.buildRichSubActionLines(text, status) : this.buildWrappedSubActionLines(text, status);
-        if (!rendered.length && prefersRich) {
-            rendered = this.buildWrappedSubActionLines(text, status);
-        }
-        if (!rendered.length) {
-            return;
-        }
-        this.withOutput(() => {
-            this.writeLine(rendered.join('\n'));
-            this.writeLine();
-        });
-    }
-    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;
-    }
-    buildRichSubActionLines(text, status) {
-        const normalized = text.trim();
-        if (!normalized) {
-            return [];
-        }
-        const width = Math.max(DISPLAY_CONSTANTS.MIN_ACTION_WIDTH, Math.min(this.getColumnWidth(), DISPLAY_CONSTANTS.MAX_ACTION_WIDTH));
-        const samplePrefix = this.buildSubActionPrefixes(status, true).prefix;
-        const contentWidth = Math.max(DISPLAY_CONSTANTS.MIN_CONTENT_WIDTH, width - this.visibleLength(samplePrefix));
-        const blocks = formatRichContent(normalized, contentWidth);
-        if (!blocks.length) {
-            return [];
-        }
-        return blocks.map((line, index) => {
-            const isLast = index === blocks.length - 1;
-            const { prefix } = this.buildSubActionPrefixes(status, isLast);
-            if (!line.trim()) {
-                return prefix.trimEnd();
-            }
-            return `${prefix}${line}`;
-        });
-    }
-    showMessage(content, role = 'assistant') {
-        if (role === 'system') {
-            this.showSystemMessage(content);
-        }
-        else {
-            this.showAssistantMessage(content);
-        }
-    }
-    showSystemMessage(content) {
-        this.clearSpinnerIfActive();
-        this.withOutput(() => {
-            this.writeLine(content.trim());
-            this.writeLine();
-        });
-    }
-    showError(message, error) {
-        this.clearSpinnerIfActive();
-        const callout = renderCallout(message, {
-            tone: 'danger',
-            icon: icons.error,
-            title: 'Error',
-            width: this.getBannerWidth(),
-        });
-        const details = this.formatErrorDetails(error);
-        this.withOutput(() => {
-            this.writeLine(`\n${callout}`, this.errorStream);
-            if (details) {
-                this.writeLine(details, this.errorStream);
-            }
-            this.writeLine('', this.errorStream);
-        });
-    }
-    showWarning(message) {
-        this.clearSpinnerIfActive();
-        const callout = renderCallout(message, {
-            tone: 'warning',
-            icon: icons.warning,
-            title: 'Warning',
-            width: this.getBannerWidth(),
-        });
-        this.withOutput(() => {
-            this.writeLine(`${callout}`, this.errorStream);
-        });
-    }
-    showInfo(message) {
-        this.clearSpinnerIfActive();
-        const callout = renderCallout(message, {
-            tone: 'info',
-            icon: icons.info,
-            title: 'Info',
-            width: this.getBannerWidth(),
-        });
-        this.withOutput(() => {
-            this.writeLine(callout);
-        });
-    }
-    /**
-     * Show a success message with enhanced styling
-     */
-    showSuccess(message) {
-        this.clearSpinnerIfActive();
-        const box = { tl: '╭', tr: '╮', bl: '╰', br: '╯', h: '─', v: '│' };
-        const width = Math.min(this.getColumnWidth() - 4, 60);
-        const innerWidth = width - 2;
-        const icon = '✓';
-        const title = ` ${icon} Success `;
-        const headerPad = Math.floor((innerWidth - title.length) / 2);
-        this.withOutput(() => {
-            this.writeLine(theme.success(`${box.tl}${box.h.repeat(headerPad)}${title}${box.h.repeat(innerWidth - headerPad - title.length)}${box.tr}`));
-            const msgLines = this.wrapLine(message, innerWidth - 2);
-            for (const line of msgLines) {
-                const padding = Math.max(0, innerWidth - line.length - 1);
-                this.writeLine(`${theme.success(box.v)} ${line}${' '.repeat(padding)}${theme.success(box.v)}`);
-            }
-            this.writeLine(theme.success(`${box.bl}${box.h.repeat(innerWidth)}${box.br}`));
-        });
-    }
-    /**
-     * Show a stylish progress indicator for long operations
-     */
-    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.withOutput(() => {
-            this.write(`\r${theme.info(badge)}`);
-            if (current >= total) {
-                this.writeLine();
-            }
-        });
-    }
-    showStatusLine(status, elapsedMs, context) {
-        this.clearSpinnerIfActive();
-        const normalized = status?.trim();
-        if (!normalized) {
-            return;
-        }
-        const parts = [];
-        // Show session elapsed time first (Claude Code style: "Session 5m 23s")
-        if (context?.sessionElapsedMs && context.sessionElapsedMs > 0) {
-            const sessionElapsed = this.formatElapsedTime(Math.floor(context.sessionElapsedMs / 1000));
-            parts.push(theme.ui.muted(`Session ${sessionElapsed}`));
-        }
-        const contextSummary = this.formatContextSummary(context);
-        if (contextSummary) {
-            parts.push(contextSummary);
-        }
-        const elapsed = this.formatElapsed(elapsedMs);
-        const statusText = elapsed
-            ? `${theme.success(normalized)} ${theme.ui.muted(`(${elapsed})`)}`
-            : theme.success(normalized);
-        parts.push(statusText);
-        const bulletSep = theme.ui.muted(` ${icons.bullet} `);
-        this.withOutput(() => {
-            // Claude Code style: show status line then separator
-            this.writeLine(parts.join(bulletSep));
-            this.writeLine();
-            // Add separator line above prompt (Claude Code style)
-            const cols = getTerminalColumns();
-            const separatorLine = theme.ui.border('─'.repeat(Math.min(cols - 2, 72)));
-            this.writeLine(separatorLine);
-        });
-    }
-    showAvailableTools(_tools) {
-        // Hidden by default to match Claude Code style
-        // Tools are available but not listed verbosely on startup
-        // Parameter prefixed with underscore to indicate intentionally unused
-    }
-    /**
-     * Show ready message with keyboard shortcuts hint (compact)
-     */
-    showReadyWithHints() {
-        const cols = this.getColumnWidth();
-        const width = Math.max(32, Math.min(cols - 6, DISPLAY_CONSTANTS.MAX_BANNER_WIDTH - 4));
-        this.withOutput(() => {
-            const readyLine = `${theme.success('Ready')} ${theme.ui.muted('• /help • /model')}`;
-            this.writeLine(this.renderCompactRow(readyLine, width, true));
-            this.writeLine();
-        });
-    }
-    /**
-     * Show available providers and their status on launch (compact inline)
-     */
-    showProvidersStatus(providers) {
-        const available = providers.filter(p => p.available);
-        if (available.length === 0) {
-            return;
-        }
-        const width = Math.max(32, Math.min(this.getColumnWidth() - 6, DISPLAY_CONSTANTS.MAX_BANNER_WIDTH - 4));
-        this.withOutput(() => {
-            const providerList = available
-                .map(p => `${theme.success('●')} ${p.provider} ${theme.ui.muted(`(${this.truncateModel(p.latestModel)})`)}`)
-                .join(theme.ui.muted(' │ '));
-            const line = `${theme.ui.muted('models')} ${providerList}`;
-            this.writeLine(this.renderCompactRow(line, width));
-            this.writeLine();
-        });
-    }
-    /**
-     * Truncate model name for compact display
-     */
-    truncateModel(model) {
-        if (model.length <= 20)
-            return model;
-        // Extract the meaningful part of model names
-        const parts = model.split('-');
-        if (parts.length > 2) {
-            return `${parts[0]}-${parts[1]}...`;
-        }
-        return `${model.slice(0, 17)}...`;
-    }
-    /**
-     * Show unified status bar - Claude Code style
-     *
-     * Format:
-     * ▌ models ● anthropic (claude-opus...) │ ● openai (gpt-5.1-codex)
-     * ▌ Ready • /help • /model
-     *
-     * Called both at startup and after streaming ends to provide consistent UI.
-     */
-    showUnifiedStatusBar(providers) {
-        const cols = this.getColumnWidth();
-        const width = Math.max(32, Math.min(cols - 6, DISPLAY_CONSTANTS.MAX_BANNER_WIDTH - 4));
-        this.withOutput(() => {
-            // Show providers line if available
-            if (providers && providers.length > 0) {
-                const available = providers.filter(p => p.available);
-                if (available.length > 0) {
-                    const providerList = available
-                        .map(p => `${theme.success('●')} ${p.provider} ${theme.ui.muted(`(${this.truncateModel(p.latestModel)})`)}`)
-                        .join(theme.ui.muted(' │ '));
-                    const providerLine = `${theme.ui.muted('models')} ${providerList}`;
-                    this.writeLine(this.renderCompactRow(providerLine, width));
-                    this.writeLine();
-                }
-            }
-            const readyLine = `${theme.success('Ready')} ${theme.ui.muted('• /help • /model')}`;
-            this.writeLine(this.renderCompactRow(readyLine, width, true));
-            this.writeLine();
-        });
-    }
-    /**
-     * Show streaming header - Claude Code style
-     *
-     * Displays a unified streaming status bar before AI response starts.
-     * This provides visual consistency with the startup Ready bar.
-     *
-     * Format:
-     * ▌ ● Responding...
-     */
-    showStreamingHeader() {
-        const cols = this.getColumnWidth();
-        const width = Math.max(32, Math.min(cols - 6, DISPLAY_CONSTANTS.MAX_BANNER_WIDTH - 4));
-        this.withOutput(() => {
-            const indicator = `${theme.info('●')} ${theme.ui.muted('Responding...')}`;
-            this.writeLine(this.renderCompactRow(indicator, width, true));
-        });
-    }
-    /**
-     * Show model commands help
-     */
-    showModelCommands() {
-        this.withOutput(() => {
-            this.writeLine(theme.ui.muted(`${icons.info} Model commands:`));
-            this.writeLine(theme.ui.muted('  /model <name>     - Switch to a specific model'));
-            this.writeLine(theme.ui.muted('  /model            - Show current model'));
-            this.writeLine(theme.ui.muted('  /providers        - List all available providers'));
-            this.writeLine(theme.ui.muted('  /discover         - Discover models from provider APIs'));
-            this.writeLine();
-        });
-    }
-    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);
-        }
-        try {
-            return highlightError(JSON.stringify(error, null, 2));
-        }
-        catch {
-            return null;
-        }
-    }
-    showPlanningStep(step, index, total) {
-        // Validate inputs
-        if (!step?.trim()) {
-            return;
-        }
-        if (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.withOutput(() => {
-            this.writeLine(heading);
-        });
-    }
-    clear() {
-        this.withOutput(() => {
-            try {
-                cursorTo(this.outputStream, 0, 0);
-                clearScreenDown(this.outputStream);
-            }
-            catch {
-                this.write('\x1Bc');
-            }
-        });
-        this.stdoutTracker.reset();
-        if (this.bannerState) {
-            this.renderAndStoreBanner(this.bannerState, this.bannerState.model, this.bannerState.provider);
-        }
-    }
-    newLine() {
-        this.withOutput(() => {
-            this.writeLine();
-        });
-    }
-    getBannerWidth() {
-        const availableColumns = this.getColumnWidth();
-        const effectiveWidth = Math.max(DISPLAY_CONSTANTS.MIN_BANNER_WIDTH, availableColumns - DISPLAY_CONSTANTS.BANNER_PADDING);
-        return Math.min(Math.max(effectiveWidth, DISPLAY_CONSTANTS.MIN_BANNER_WIDTH), DISPLAY_CONSTANTS.MAX_BANNER_WIDTH);
-    }
-    measureBannerHeight(banner) {
-        if (!banner) {
-            return 0;
-        }
-        const lines = banner.split('\n').length;
-        return lines;
-    }
-    /**
-     * Attempts to rewrite the banner in place using terminal cursor manipulation.
-     * Returns true if successful, false if rewrite is not possible.
-     */
-    tryRewriteBanner(state, banner) {
-        // Validate TTY availability
-        if (!this.outputStream.isTTY) {
-            return false;
-        }
-        // Validate banner state
-        if (!banner || state.height <= 0) {
-            return false;
-        }
-        const linesWritten = this.stdoutTracker.totalLines;
-        const linesAfterBanner = linesWritten - (state.startLine + state.height);
-        // Cannot rewrite if banner position is invalid
-        if (linesAfterBanner < 0) {
-            return false;
-        }
-        const totalOffset = linesAfterBanner + state.height;
-        const maxRows = this.outputStream.rows;
-        // Cannot rewrite if offset exceeds terminal height
-        if (typeof maxRows === 'number' && maxRows > 0 && totalOffset > maxRows) {
-            return false;
-        }
-        try {
-            this.withOutput(() => {
-                // Move cursor up to banner start
-                moveCursor(this.outputStream, 0, -totalOffset);
-                cursorTo(this.outputStream, 0);
-                // Write new banner without tracking
-                this.stdoutTracker.withSuspended(() => {
-                    this.outputStream.write(`${banner}\n`);
-                });
-                // Restore cursor position
-                if (linesAfterBanner > 0) {
-                    moveCursor(this.outputStream, 0, linesAfterBanner);
-                }
-                cursorTo(this.outputStream, 0);
-            });
-            return true;
-        }
-        catch (error) {
-            // Cursor manipulation failed (e.g., terminal doesn't support it)
-            if (error instanceof Error) {
-                // Could log error in debug mode if needed
-            }
-            return false;
-        }
-    }
-    renderAndStoreBanner(state, model, provider) {
-        const width = this.getBannerWidth();
-        const banner = this.buildClaudeStyleBanner(state.profileLabel, state.profileName, model, provider, state.workingDir, width, state.version);
-        const startLine = this.stdoutTracker.totalLines;
-        this.withOutput(() => {
-            this.writeLine(banner);
-        });
-        state.startLine = startLine;
-        state.height = this.measureBannerHeight(banner);
-        state.width = width;
-        state.model = model;
-        state.provider = provider;
-    }
-    formatModelLabel(model) {
-        if (/gpt-5\.1-?codex/i.test(model)) {
-            return model;
-        }
-        if (/sonnet-4[-.]?5/i.test(model)) {
-            return 'Sonnet 4.5';
-        }
-        if (/opus-4[-.]?1/i.test(model)) {
-            return 'Opus 4.1';
-        }
-        if (/haiku-4[-.]?5/i.test(model)) {
-            return 'Haiku 4.5';
-        }
-        if (/gpt-5\.1/i.test(model)) {
-            return 'GPT-5.1';
-        }
-        if (/gpt-5-?pro/i.test(model)) {
-            return 'GPT-5 Pro';
-        }
-        if (/gpt-5-?mini/i.test(model)) {
-            return 'GPT-5 Mini';
-        }
-        if (/gpt-5-?nano/i.test(model)) {
-            return 'GPT-5 Nano';
-        }
-        return model;
-    }
-    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);
-        if (!telemetry) {
-            return panel;
-        }
-        return `${panel}\n${telemetry}`;
-    }
-    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));
-    }
-    /**
-     * Legacy method for appending thought blocks with tree-like formatting.
-     * Kept for backwards compatibility but not actively used.
-     * @deprecated Use buildClaudeStyleThought instead
-     */
-    // @ts-expect-error - Legacy method kept for backwards compatibility
-    _appendThoughtBlock(block, format, output) {
-        const rawLines = block.split('\n');
-        const indices = rawLines
-            .map((line, index) => (line.trim().length ? index : -1))
-            .filter((index) => index >= 0);
-        if (!indices.length) {
-            return;
-        }
-        const lastIndex = indices[indices.length - 1];
-        let usedFirst = false;
-        for (let index = 0; index < rawLines.length; index += 1) {
-            const rawLine = rawLines[index] ?? '';
-            if (!rawLine.trim()) {
-                continue;
-            }
-            const segments = this.wrapThoughtLine(rawLine, format.available);
-            if (!segments.length) {
-                continue;
-            }
-            const isLastLine = index === lastIndex;
-            segments.forEach((segment, segmentIndex) => {
-                const prefix = this.resolveThoughtPrefix({
-                    usedFirst,
-                    segmentIndex,
-                    isLastLine,
-                    format,
-                });
-                output.push(`${prefix}${segment}`);
-            });
-            usedFirst = true;
-        }
-    }
-    resolveThoughtPrefix(options) {
-        if (!options.usedFirst) {
-            return options.segmentIndex === 0 ? options.format.bullet : options.format.spacer;
-        }
-        if (options.segmentIndex === 0) {
-            return options.isLastLine ? options.format.last : options.format.branch;
-        }
-        return options.format.spacer;
-    }
-    /**
-     * Legacy method for generating thought formatting configuration.
-     * Kept for backwards compatibility but not actively used.
-     * @deprecated Use buildClaudeStyleThought instead
-     */
-    // @ts-expect-error - Legacy method kept for backwards compatibility
-    _getThoughtFormat() {
-        const totalWidth = Math.max(DISPLAY_CONSTANTS.MIN_THOUGHT_WIDTH, Math.min(this.getColumnWidth(), DISPLAY_CONSTANTS.MAX_THOUGHT_WIDTH));
-        const prefixWidth = Math.max(3, this.visibleLength(`${icons.bullet} `));
-        const available = Math.max(DISPLAY_CONSTANTS.MIN_WRAP_WIDTH, totalWidth - prefixWidth);
-        return {
-            totalWidth,
-            prefixWidth,
-            available,
-            bullet: theme.secondary(this.padPrefix(`${icons.bullet} `, prefixWidth)),
-            branch: theme.ui.muted(this.padPrefix('│ ', prefixWidth)),
-            last: theme.ui.muted(this.padPrefix('└ ', prefixWidth)),
-            spacer: ' '.repeat(prefixWidth),
-        };
-    }
-    wrapThoughtLine(line, width) {
-        const preserveIndentation = /^\s/.test(line);
-        const normalized = preserveIndentation ? line.replace(/\s+$/, '') : line.trim();
-        if (!normalized) {
-            return [];
-        }
-        if (preserveIndentation) {
-            return wrapPreformatted(normalized, width);
-        }
-        return this.wrapLine(normalized, 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)}`;
-    }
-    formatContextSummary(context) {
-        if (!context) {
-            return null;
-        }
-        const hasPercentage = typeof context.percentage === 'number' && Number.isFinite(context.percentage);
-        const hasTokens = typeof context.tokens === 'number' && Number.isFinite(context.tokens);
-        if (!hasPercentage && !hasTokens) {
-            return null;
-        }
-        if (hasPercentage) {
-            const normalizedPercent = Math.max(0, Math.min(100, Math.round(context.percentage)));
-            const tokenDetails = hasTokens ? ` (${context.tokens} tokens)` : '';
-            return `${theme.info('Context')} ${theme.ui.muted(`${normalizedPercent}% used${tokenDetails}`)}`;
-        }
-        return theme.ui.muted(`${context.tokens} tokens`);
-    }
-    formatElapsed(elapsedMs) {
-        if (typeof elapsedMs !== 'number' || !Number.isFinite(elapsedMs) || elapsedMs < 0) {
-            return null;
-        }
-        const totalSeconds = Math.max(0, Math.round(elapsedMs / 1000));
-        const minutes = Math.floor(totalSeconds / 60);
-        const seconds = totalSeconds % 60;
-        if (minutes > 0) {
-            return `${minutes}m ${seconds.toString().padStart(2, '0')}s`;
-        }
-        return `${seconds}s`;
-    }
-    buildClaudeStyleBanner(profileLabel, profileName, model, provider, workingDir, width, version) {
-        const effectiveWidth = Math.min(Math.max(width, 52), DISPLAY_CONSTANTS.MAX_BANNER_WIDTH);
-        const contentWidth = Math.max(32, effectiveWidth - 6);
-        const normalizedProfile = profileName?.trim();
-        const agentLabel = profileLabel?.trim() || normalizedProfile || 'Active agent';
-        const headerSegments = [
-            `${theme.gradient.cool('Erosolar CLI')}${version ? theme.ui.muted(` v${version}`) : ''}`,
-            `${theme.success('●')} ${this.formatModelLabel(model)}`,
-            `${theme.ui.muted('via')} ${provider}`,
-            `${theme.ui.muted('agent')} ${agentLabel}`,
-        ];
-        const detailSegments = [
-            `${theme.ui.muted('workspace')} ${this.abbreviatePath(workingDir, contentWidth - 12)}`,
-            `${theme.ui.muted('mandate')} ${this.buildMandateSnippet(contentWidth)}`,
-        ];
-        const rows = [
-            ...this.buildSegmentRows(headerSegments, contentWidth),
-            ...this.buildSegmentRows(detailSegments, contentWidth),
-        ];
-        if (!rows.length) {
-            return '';
-        }
-        const renderedRows = rows.map((row, index) => this.renderCompactRow(row, contentWidth, index === 0));
-        const availableColumns = Math.max(0, this.getColumnWidth() - 2);
-        const dividerWidth = Math.max(0, Math.min(effectiveWidth, availableColumns));
-        const divider = !dividerWidth || isPlainOutputMode()
-            ? ''
-            : theme.ui.border('─'.repeat(Math.max(24, dividerWidth)));
-        return divider ? `${renderedRows.join('\n')}\n${divider}` : renderedRows.join('\n');
-    }
-    buildSegmentRows(segments, width) {
-        const separator = theme.ui.muted(' │ ');
-        const rows = [];
-        let current = '';
-        for (const segment of segments) {
-            if (!segment?.trim()) {
-                continue;
-            }
-            const candidate = current ? `${current}${separator}${segment}` : segment;
-            if (this.visibleLength(candidate) > width && current) {
-                rows.push(current);
-                current = segment;
-            }
-            else {
-                current = candidate;
-            }
-        }
-        if (current) {
-            rows.push(current);
-        }
-        return rows;
-    }
-    renderCompactRow(line, width, highlight = false) {
-        const padded = this.padLine(line, width);
-        if (isPlainOutputMode()) {
-            return padded;
-        }
-        const prefix = highlight ? theme.accent('▌') : theme.ui.border('▌');
-        const body = theme.ui.background(theme.ui.text(` ${padded} `));
-        return `${prefix}${body}`;
-    }
-    buildMandateSnippet(width) {
-        const maxLen = Math.max(28, width - 20);
-        return this.truncateVisible(INDEPENDENT_SECURITY_MANDATE, maxLen);
-    }
-    abbreviatePath(path, maxLen) {
-        if (path.length <= maxLen)
-            return path;
-        const parts = path.split('/');
-        if (parts.length <= 2)
-            return path;
-        return `${parts[0]}/.../${parts[parts.length - 1]}`;
-    }
-    padLine(text, width) {
-        const visible = this.visibleLength(text);
-        if (visible >= width) {
-            return this.truncateVisible(text, width);
-        }
-        const padding = Math.max(0, width - visible);
-        return `${text}${' '.repeat(padding)}`;
-    }
-    /**
-     * Wraps text with a prefix on the first line and optional continuation prefix.
-     * Handles multi-line text and word wrapping intelligently.
-     */
-    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');
-    }
-    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}`);
-    }
-    buildClaudeStyleThought(content) {
-        // Rich thinking block display with box frame
-        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 innerWidth = width - 2;
-        const lines = [];
-        // Header with thinking icon
-        const header = ' 💭 Thinking ';
-        const headerPad = Math.floor((innerWidth - header.length) / 2);
-        lines.push(thinkingStyle.border(`╭${'─'.repeat(headerPad)}${thinkingStyle.label(header)}${'─'.repeat(innerWidth - headerPad - header.length)}╮`));
-        // Parse and format the thinking content
-        const contentLines = content.split('\n').filter(line => line.trim());
-        for (const line of contentLines) {
-            // Wrap each line to fit
-            const wrapped = this.wrapLine(line.trim(), innerWidth - 2);
-            for (const wrappedLine of wrapped) {
-                const padding = Math.max(0, innerWidth - wrappedLine.length - 1);
-                lines.push(`${thinkingStyle.border('│')} ${thinkingStyle.text(wrappedLine)}${' '.repeat(padding)}${thinkingStyle.border('│')}`);
-            }
-        }
-        // Bottom border
-        lines.push(thinkingStyle.border(`╰${'─'.repeat(innerWidth)}╯`));
-        return lines.join('\n');
-    }
-    /**
-     * Show a thinking block with rich formatting (public method for external use)
-     */
-    showThinkingBlock(content) {
-        this.clearSpinnerIfActive();
-        const block = this.buildClaudeStyleThought(content);
-        this.withOutput(() => {
-            this.writeLine();
-            this.writeLine(block);
-            this.writeLine();
-        });
-    }
-    // @ts-ignore - Legacy method kept for compatibility
-    // Keep legacy method to avoid breaking changes
-    buildSubActionPrefixes(status, isLast) {
-        if (isLast) {
-            const colorize = this.resolveStatusColor(status);
-            // Claude Code style: use ⎿ for sub-action result/detail prefix
-            return {
-                prefix: `  ${colorize(icons.subaction)} `,
-                continuation: '    ',
-            };
-        }
-        const branch = theme.ui.muted('│');
-        return {
-            prefix: `  ${branch} `,
-            continuation: `  ${branch} `,
-        };
-    }
-    /**
-     * Wraps a single line of text to fit within the specified width.
-     * Intelligently handles word breaking and preserves spaces.
-     */
-    wrapLine(text, width) {
-        // Handle edge cases
-        if (width <= 0) {
-            return [text];
-        }
-        if (!text) {
-            return [''];
-        }
-        if (text.length <= width) {
-            return [text];
-        }
-        const words = text.split(/\s+/).filter(Boolean);
-        // If no words, chunk the entire text
-        if (!words.length) {
-            return this.chunkWord(text, width);
-        }
-        const lines = [];
-        let current = '';
-        for (const word of words) {
-            const appendResult = this.tryAppendWord(current, word, width);
-            if (appendResult.shouldFlush) {
-                lines.push(current);
-            }
-            if (appendResult.chunks.length > 0) {
-                // Word was too long and was chunked
-                lines.push(...appendResult.chunks.slice(0, -1));
-                current = appendResult.chunks[appendResult.chunks.length - 1] ?? '';
-            }
-            else {
-                current = appendResult.newCurrent;
-            }
-        }
-        if (current) {
-            lines.push(current);
-        }
-        return lines.length ? lines : [''];
-    }
-    /**
-     * Attempts to append a word to the current line.
-     * Returns instructions on how to handle the word.
-     */
-    tryAppendWord(current, word, width) {
-        if (!word) {
-            return { shouldFlush: false, newCurrent: current, chunks: [] };
-        }
-        // Empty current line - start new line with word
-        if (!current) {
-            if (word.length <= width) {
-                return { shouldFlush: false, newCurrent: word, chunks: [] };
-            }
-            // Word too long, need to chunk it
-            return { shouldFlush: false, newCurrent: '', chunks: this.chunkWord(word, width) };
-        }
-        // Word fits on current line with space
-        if (current.length + 1 + word.length <= width) {
-            return { shouldFlush: false, newCurrent: `${current} ${word}`, chunks: [] };
-        }
-        // Word doesn't fit - flush current and start new line
-        if (word.length <= width) {
-            return { shouldFlush: true, newCurrent: word, chunks: [] };
-        }
-        // Word doesn't fit and is too long - flush current and chunk word
-        return { shouldFlush: true, newCurrent: '', chunks: this.chunkWord(word, width) };
-    }
-    /**
-     * Splits a long word into chunks that fit within the specified width.
-     * Used when a single word is too long to fit on one line.
-     */
-    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 : [''];
-    }
-    /**
-     * Pads a prefix string to the specified width with spaces.
-     */
-    padPrefix(value, width) {
-        if (!value || value.length >= width || width <= 0) {
-            return value;
-        }
-        return value.padEnd(width, ' ');
-    }
-    /**
-     * Truncates a string to fit within the specified width,
-     * accounting for ANSI color codes and adding ellipsis.
-     */
-    truncateVisible(value, width) {
-        if (width <= 0) {
-            return '';
-        }
-        if (!value) {
-            return '';
-        }
-        const plain = this.stripAnsi(value);
-        if (plain.length <= width) {
-            return value;
-        }
-        const slice = plain.slice(0, Math.max(1, width - 1));
-        return `${slice}…`;
-    }
-    /**
-     * Returns the visible length of a string, excluding ANSI escape codes.
-     */
-    visibleLength(value) {
-        if (!value) {
-            return 0;
-        }
-        return this.stripAnsi(value).length;
-    }
-    /**
-     * Removes ANSI escape codes from a string to get the visible text.
-     * Uses the standard ANSI escape sequence pattern.
-     */
-    stripAnsi(value) {
-        if (!value) {
-            return '';
-        }
-        return value.replace(/\u001B\[[0-?]*[ -/]*[@-~]/g, '');
-    }
-}
-export const display = new Display();
-//# sourceMappingURL=display.js.map