@aria-cli/cli 1.0.50 → 1.0.51

package/dist/ui/components/text-input/TextInput.js

@@ -0,0 +1,231 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+import { Text, useInput } from "ink";
+import chalk from "chalk";
+import { useTextInput } from "./useTextInput.js";
+import { getTheme } from "../../theme/index.js";
+// Bracketed paste mode markers.
+// Terminals wrap pasted text in \x1b[200~ ... \x1b[201~ sequences.
+// Ink's useInput strips the leading \x1b from the start of the first chunk,
+// so the start marker appears as "[200~" in the input string.
+// The end marker may appear as "\x1b[201~" (mid-string) or "[201~" (if in its own chunk).
+const BRACKET_PASTE_START = "[200~";
+const BRACKET_PASTE_END_RAW = "\x1b[201~";
+const BRACKET_PASTE_END_STRIPPED = "[201~";
+function stripBracketPasteMarkers(input) {
+    let text = input;
+    let hasBracketStart = false;
+    let hasBracketEnd = false;
+    if (text.startsWith(BRACKET_PASTE_START)) {
+        text = text.slice(BRACKET_PASTE_START.length);
+        hasBracketStart = true;
+    }
+    if (text.endsWith(BRACKET_PASTE_END_RAW)) {
+        text = text.slice(0, -BRACKET_PASTE_END_RAW.length);
+        hasBracketEnd = true;
+    }
+    else if (text.endsWith(BRACKET_PASTE_END_STRIPPED)) {
+        text = text.slice(0, -BRACKET_PASTE_END_STRIPPED.length);
+        hasBracketEnd = true;
+    }
+    else {
+        // End marker might be mid-string (before trailing content in same chunk)
+        const rawIdx = text.indexOf(BRACKET_PASTE_END_RAW);
+        if (rawIdx !== -1) {
+            text = text.slice(0, rawIdx) + text.slice(rawIdx + BRACKET_PASTE_END_RAW.length);
+            hasBracketEnd = true;
+        }
+        else {
+            const strippedIdx = text.indexOf(BRACKET_PASTE_END_STRIPPED);
+            if (strippedIdx !== -1) {
+                text =
+                    text.slice(0, strippedIdx) + text.slice(strippedIdx + BRACKET_PASTE_END_STRIPPED.length);
+                hasBracketEnd = true;
+            }
+        }
+    }
+    return { text, hasBracketStart, hasBracketEnd };
+}
+export default function TextInput({ value: originalValue, placeholder = "", focus = true, mask, multiline = false, highlightPastedText = false, showCursor = true, onChange, onSubmit, onExit, onHistoryUp, onHistoryDown, onExitMessage, onMessage, onHistoryReset, onDoubleEscape, columns: columnsProp, onImagePaste, onPaste, isDimmed = false, disableCursorMovementForUpDownKeys = false, cursorOffset: cursorOffsetProp, onChangeCursorOffset: onChangeCursorOffsetProp, }) {
+    const PASTE_CHUNK_THRESHOLD = 800;
+    const PASTE_IDLE_TIMEOUT_MS = 100;
+    // Internal cursor state used when external cursor control is not provided
+    const [internalOffset, setInternalOffset] = useState(0);
+    const columns = columnsProp ?? process.stdout.columns ?? 80;
+    const cursorOffset = cursorOffsetProp ?? internalOffset;
+    const onChangeCursorOffset = onChangeCursorOffsetProp ?? setInternalOffset;
+    const { onInput, renderedValue } = useTextInput({
+        value: originalValue,
+        onChange,
+        onSubmit,
+        onExit,
+        onExitMessage,
+        onMessage,
+        onHistoryReset,
+        onHistoryUp,
+        onHistoryDown,
+        onDoubleEscape,
+        focus,
+        mask,
+        multiline,
+        cursorChar: showCursor ? " " : "",
+        highlightPastedText,
+        invert: chalk.inverse,
+        themeText: (text) => chalk.hex(getTheme().colors.text)(text),
+        columns,
+        onImagePaste,
+        disableCursorMovementForUpDownKeys,
+        externalOffset: cursorOffset,
+        onOffsetChange: onChangeCursorOffset,
+    });
+    // Paste detection state.
+    // Use refs (not React state) so back-to-back stdin chunks are handled
+    // synchronously without render-timing races.
+    const pasteChunksRef = useRef([]);
+    const pasteTimeoutRef = useRef(null);
+    // Track whether we're inside a bracketed paste (\x1b[200~ ... \x1b[201~).
+    // This is more reliable than the 800-char heuristic for terminals that send
+    // bracketed paste sequences (iTerm2, most modern terminals in raw mode).
+    const bracketedPasteActiveRef = useRef(false);
+    const clearPasteTimeout = () => {
+        if (pasteTimeoutRef.current) {
+            clearTimeout(pasteTimeoutRef.current);
+            pasteTimeoutRef.current = null;
+        }
+    };
+    const flushPaste = () => {
+        const pastedText = pasteChunksRef.current.join("");
+        pasteChunksRef.current = [];
+        clearPasteTimeout();
+        bracketedPasteActiveRef.current = false;
+        if (!pastedText || !onPaste) {
+            return;
+        }
+        // Schedule callback after current render to avoid state updates during render
+        Promise.resolve().then(() => onPaste(pastedText));
+    };
+    const schedulePasteFlush = () => {
+        clearPasteTimeout();
+        pasteTimeoutRef.current = setTimeout(() => {
+            flushPaste();
+        }, PASTE_IDLE_TIMEOUT_MS);
+    };
+    const enqueuePasteChunk = (chunk) => {
+        pasteChunksRef.current.push(chunk);
+        schedulePasteFlush();
+    };
+    const isPasteInProgress = () => pasteTimeoutRef.current !== null || bracketedPasteActiveRef.current;
+    useEffect(() => () => {
+        clearPasteTimeout();
+        pasteChunksRef.current = [];
+        bracketedPasteActiveRef.current = false;
+    }, []);
+    const isControlKey = (key) => {
+        return Boolean(key.return ||
+            key.escape ||
+            key.tab ||
+            key.ctrl ||
+            key.meta ||
+            key.upArrow ||
+            key.downArrow ||
+            key.leftArrow ||
+            key.rightArrow ||
+            key.pageUp ||
+            key.pageDown ||
+            key.backspace ||
+            key.delete);
+    };
+    const wrappedOnInput = (input, key) => {
+        // --- Bracketed paste marker stripping ---
+        // Terminals wrap pasted text in escape sequences that Ink doesn't understand.
+        // Strip them to prevent marker pollution in the text buffer.
+        const { text: cleanInput, hasBracketStart, hasBracketEnd } = stripBracketPasteMarkers(input);
+        // If bracket start detected, enter bracketed paste mode — but only when
+        // onPaste is provided. Without onPaste, bracket markers are just stripped
+        // and the content falls through to normal onInput insertion.
+        if (hasBracketStart && onPaste) {
+            bracketedPasteActiveRef.current = true;
+        }
+        // During bracketed paste, collect all content.
+        // Control keys (Enter, Escape, etc.) flush the paste immediately — this
+        // prevents input from being swallowed during an orphaned bracket start
+        // (when \x1b[201~ end marker never arrives).
+        if (bracketedPasteActiveRef.current && onPaste) {
+            if (isControlKey(key)) {
+                flushPaste();
+                return;
+            }
+            if (cleanInput) {
+                enqueuePasteChunk(cleanInput);
+            }
+            // If bracket end detected, flush immediately (no 100ms wait)
+            if (hasBracketEnd) {
+                flushPaste();
+            }
+            return;
+        }
+        // If bracket end arrives outside active paste (edge case), flush any pending
+        if (hasBracketEnd && isPasteInProgress()) {
+            if (cleanInput) {
+                enqueuePasteChunk(cleanInput);
+            }
+            flushPaste();
+            return;
+        }
+        // Special handling for backspace or delete.
+        // Must come BEFORE the empty-input guard: Ink sets input='' for
+        // backspace/delete keys (they're in nonAlphanumericKeys), so we
+        // detect them via key flags, not input content.
+        if (key.backspace ||
+            key.delete ||
+            cleanInput === "\b" ||
+            cleanInput === "\x7f" ||
+            cleanInput === "\x08") {
+            onInput(cleanInput, {
+                ...key,
+                backspace: true,
+            });
+            return;
+        }
+        // No content AND no meaningful key flags — nothing to do.
+        // Arrow keys, Ctrl combos, etc. have empty input but meaningful key flags
+        // that onInput needs to process (e.g., up arrow → history navigation).
+        if (!cleanInput && !isControlKey(key))
+            return;
+        // Handle pastes (>800 chars) — heuristic fallback for terminals without
+        // bracketed paste mode.
+        // Usually we get one or two input characters at a time. If we
+        // get a bunch, the user has probably pasted.
+        // Unfortunately node batches long pastes, so it's possible
+        // that we would see e.g. 1024 characters and then just a few
+        // more in the next frame that belong with the original paste.
+        // This batching number is not consistent.
+        // While collecting a paste, flush on control keys and wait for the next
+        // keypress. This prevents Enter/Escape/etc from being appended into paste
+        // text or acting against stale pre-paste value.
+        if (onPaste && isPasteInProgress() && isControlKey(key)) {
+            flushPaste();
+            return;
+        }
+        if (onPaste && (cleanInput.length > PASTE_CHUNK_THRESHOLD || isPasteInProgress())) {
+            enqueuePasteChunk(cleanInput);
+            return;
+        }
+        onInput(cleanInput, key);
+    };
+    useInput(wrappedOnInput, { isActive: focus });
+    let renderedPlaceholder = placeholder
+        ? chalk.hex(getTheme().colors.textMuted)(placeholder)
+        : undefined;
+    // Fake mouse cursor, because we like punishment
+    if (showCursor && focus) {
+        renderedPlaceholder =
+            placeholder.length > 0
+                ? chalk.inverse(placeholder[0]) +
+                    chalk.hex(getTheme().colors.textMuted)(placeholder.slice(1))
+                : chalk.inverse(" ");
+    }
+    const showPlaceholder = originalValue.length == 0 && placeholder;
+    return (_jsx(Text, { wrap: "truncate-end", dimColor: isDimmed, children: showPlaceholder ? renderedPlaceholder : renderedValue }));
+}
+//# sourceMappingURL=TextInput.js.map

package/dist/ui/components/text-input/imagePaste.js

@@ -0,0 +1,28 @@
+import { execSync } from "child_process";
+import { readFileSync } from "fs";
+const SCREENSHOT_PATH = "/tmp/claude_cli_latest_screenshot.png";
+export const CLIPBOARD_ERROR_MESSAGE = "No image found in clipboard. Use Cmd + Ctrl + Shift + 4 to copy a screenshot to clipboard.";
+export function getImageFromClipboard() {
+    if (process.platform !== "darwin") {
+        // only support image paste on macOS for now
+        return null;
+    }
+    try {
+        // Check if clipboard has image
+        execSync(`osascript -e 'the clipboard as «class PNGf»'`, {
+            stdio: "ignore",
+        });
+        // Save the image
+        execSync(`osascript -e 'set png_data to (the clipboard as «class PNGf»)' -e 'set fp to open for access POSIX file "${SCREENSHOT_PATH}" with write permission' -e 'write png_data to fp' -e 'close access fp'`, { stdio: "ignore" });
+        // Read the image and convert to base64
+        const imageBuffer = readFileSync(SCREENSHOT_PATH);
+        const base64Image = imageBuffer.toString("base64");
+        // Cleanup
+        execSync(`rm -f "${SCREENSHOT_PATH}"`, { stdio: "ignore" });
+        return base64Image;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=imagePaste.js.map

package/dist/ui/components/text-input/index.js

@@ -0,0 +1,6 @@
+export { default as TextInput } from "./TextInput.js";
+export { Cursor, MeasuredText } from "./Cursor.js";
+export { useTextInput } from "./useTextInput.js";
+export { useDoublePress } from "./useDoublePress.js";
+export { getImageFromClipboard } from "./imagePaste.js";
+//# sourceMappingURL=index.js.map

package/dist/ui/components/text-input/useDoublePress.js

@@ -0,0 +1,30 @@
+// Creates a function that calls one function on the first call and another
+// function on the second call within a certain timeout
+import { useRef } from "react";
+export const DOUBLE_PRESS_TIMEOUT_MS = 2000;
+export function useDoublePress(setPending, onDoublePress, onFirstPress) {
+    const lastPressRef = useRef(0);
+    const timeoutRef = useRef(undefined);
+    return () => {
+        const now = Date.now();
+        const timeSinceLastPress = now - lastPressRef.current;
+        // For this to count as a double-call, be sure to check that
+        // timeoutRef.current exists so we don't trigger on triple call
+        // (e.g. of Esc to clear the text input)
+        if (timeSinceLastPress <= DOUBLE_PRESS_TIMEOUT_MS && timeoutRef.current) {
+            if (timeoutRef.current) {
+                clearTimeout(timeoutRef.current);
+                timeoutRef.current = undefined;
+            }
+            onDoublePress();
+            setPending(false);
+        }
+        else {
+            onFirstPress?.();
+            setPending(true);
+            timeoutRef.current = setTimeout(() => setPending(false), DOUBLE_PRESS_TIMEOUT_MS);
+        }
+        lastPressRef.current = now;
+    };
+}
+//# sourceMappingURL=useDoublePress.js.map

package/dist/ui/components/text-input/useTextInput.js

@@ -0,0 +1,245 @@
+import { useState } from "react";
+import { useDoublePress } from "./useDoublePress.js";
+import { Cursor } from "./Cursor.js";
+import { getImageFromClipboard, CLIPBOARD_ERROR_MESSAGE } from "./imagePaste.js";
+import { isEscapeInput } from "../../utils/keys.js";
+const IMAGE_PLACEHOLDER = "[Image pasted]";
+function mapInput(input_map) {
+    return function (input) {
+        const handler = new Map(input_map).get(input) ?? (() => { });
+        return handler(input);
+    };
+}
+export function useTextInput({ value: originalValue, onChange, onSubmit, onExit, onExitMessage, onMessage, onHistoryUp, onHistoryDown, onHistoryReset, onDoubleEscape, mask = "", multiline = false, cursorChar, invert, columns, onImagePaste, disableCursorMovementForUpDownKeys = false, externalOffset, onOffsetChange, }) {
+    const offset = externalOffset;
+    const setOffset = onOffsetChange;
+    const cursor = Cursor.fromText(originalValue, columns, offset);
+    const [imagePasteErrorTimeout, setImagePasteErrorTimeout] = useState(null);
+    function maybeClearImagePasteErrorTimeout() {
+        if (!imagePasteErrorTimeout) {
+            return;
+        }
+        clearTimeout(imagePasteErrorTimeout);
+        setImagePasteErrorTimeout(null);
+        onMessage?.(false);
+    }
+    const handleCtrlC = useDoublePress((show) => {
+        maybeClearImagePasteErrorTimeout();
+        onExitMessage?.(show, "Ctrl-C");
+    }, () => onExit?.(), () => {
+        if (originalValue) {
+            onChange("");
+            onHistoryReset?.();
+        }
+    });
+    // Keep Escape for clearing input (or open message-edit overlay via onDoubleEscape)
+    const handleEscape = useDoublePress((show) => {
+        maybeClearImagePasteErrorTimeout();
+        onMessage?.(!!originalValue && show, `Press Escape again to clear`);
+    }, () => {
+        // Try message-edit overlay first; if handled, skip default clear
+        if (onDoubleEscape?.())
+            return;
+        if (originalValue) {
+            onChange("");
+        }
+    });
+    function clear() {
+        return Cursor.fromText("", columns, 0);
+    }
+    const handleEmptyCtrlD = useDoublePress((show) => onExitMessage?.(show, "Ctrl-D"), () => onExit?.());
+    function handleCtrlD() {
+        maybeClearImagePasteErrorTimeout();
+        if (cursor.text === "") {
+            // When input is empty, handle double-press
+            handleEmptyCtrlD();
+            return cursor;
+        }
+        // When input is not empty, delete forward like iPython
+        return cursor.del();
+    }
+    function tryImagePaste() {
+        const base64Image = getImageFromClipboard();
+        if (base64Image === null) {
+            if (process.platform !== "darwin") {
+                return cursor;
+            }
+            onMessage?.(true, CLIPBOARD_ERROR_MESSAGE);
+            maybeClearImagePasteErrorTimeout();
+            setImagePasteErrorTimeout(setTimeout(() => {
+                onMessage?.(false);
+            }, 4000));
+            return cursor;
+        }
+        onImagePaste?.(base64Image);
+        return cursor.insert(IMAGE_PLACEHOLDER);
+    }
+    const handleCtrl = mapInput([
+        ["a", () => cursor.startOfLine()],
+        ["b", () => cursor.left()],
+        ["c", handleCtrlC],
+        ["d", handleCtrlD],
+        ["e", () => cursor.endOfLine()],
+        ["f", () => cursor.right()],
+        [
+            "h",
+            () => {
+                maybeClearImagePasteErrorTimeout();
+                return cursor.backspace();
+            },
+        ],
+        ["k", () => cursor.deleteToLineEnd()],
+        ["l", () => clear()],
+        ["n", () => downOrHistoryDown()],
+        ["p", () => upOrHistoryUp()],
+        ["u", () => cursor.deleteToLineStart()],
+        ["v", tryImagePaste],
+        ["w", () => cursor.deleteWordBefore()],
+    ]);
+    const handleMeta = mapInput([
+        ["b", () => cursor.prevWord()],
+        ["f", () => cursor.nextWord()],
+        ["d", () => cursor.deleteWordAfter()],
+    ]);
+    function handleEnter(key) {
+        if (multiline && cursor.offset > 0 && cursor.text[cursor.offset - 1] === "\\") {
+            return cursor.backspace().insert("\n");
+        }
+        if (key.meta || key.shift) {
+            return cursor.insert("\n");
+        }
+        onSubmit?.(originalValue);
+    }
+    function upOrHistoryUp() {
+        if (disableCursorMovementForUpDownKeys) {
+            onHistoryUp?.();
+            return cursor;
+        }
+        const cursorUp = cursor.up();
+        if (cursorUp.equals(cursor)) {
+            // already at beginning
+            onHistoryUp?.();
+        }
+        return cursorUp;
+    }
+    function downOrHistoryDown() {
+        if (disableCursorMovementForUpDownKeys) {
+            onHistoryDown?.();
+            return cursor;
+        }
+        const cursorDown = cursor.down();
+        if (cursorDown.equals(cursor)) {
+            onHistoryDown?.();
+        }
+        return cursorDown;
+    }
+    function onInput(input, key) {
+        // Shift+Delete — delete whole word backward.
+        // Many terminals report this as key.shift+key.delete, while some surface the
+        // raw CSI sequence directly.
+        if ((key.shift && key.delete) || input === "\x1b[3;2~") {
+            const nextCursor = cursor.deleteWordBefore();
+            if (!cursor.equals(nextCursor)) {
+                setOffset(nextCursor.offset);
+                if (cursor.text !== nextCursor.text) {
+                    onChange(nextCursor.text);
+                }
+            }
+            return;
+        }
+        // Option+Delete (meta+backspace) — delete whole word backward
+        if (key.meta && (key.backspace || key.delete || input === "\x7f")) {
+            const nextCursor = cursor.deleteWordBefore();
+            if (!cursor.equals(nextCursor)) {
+                setOffset(nextCursor.offset);
+                if (cursor.text !== nextCursor.text) {
+                    onChange(nextCursor.text);
+                }
+            }
+            return;
+        }
+        // Direct handling for backspace or delete (which is being detected as delete)
+        if (key.backspace || key.delete || input === "\b" || input === "\x7f" || input === "\x08") {
+            const nextCursor = cursor.backspace();
+            if (!cursor.equals(nextCursor)) {
+                setOffset(nextCursor.offset);
+                if (cursor.text !== nextCursor.text) {
+                    onChange(nextCursor.text);
+                }
+            }
+            return;
+        }
+        const nextCursor = mapKey(input, key)(input);
+        if (nextCursor) {
+            if (!cursor.equals(nextCursor)) {
+                setOffset(nextCursor.offset);
+                if (cursor.text !== nextCursor.text) {
+                    onChange(nextCursor.text);
+                }
+            }
+        }
+    }
+    function mapKey(input, key) {
+        if (isEscapeInput(input, key)) {
+            return handleEscape;
+        }
+        // Direct handling for backspace or delete
+        if (key.backspace || key.delete) {
+            maybeClearImagePasteErrorTimeout();
+            return () => cursor.backspace();
+        }
+        switch (true) {
+            case key.leftArrow && (key.ctrl || key.meta || key.fn):
+                return () => cursor.prevWord();
+            case key.rightArrow && (key.ctrl || key.meta || key.fn):
+                return () => cursor.nextWord();
+            case key.ctrl:
+                return handleCtrl;
+            case key.home:
+                return () => cursor.startOfLine();
+            case key.end:
+                return () => cursor.endOfLine();
+            case key.pageDown:
+                return () => cursor.endOfLine();
+            case key.pageUp:
+                return () => cursor.startOfLine();
+            case key.return:
+                return () => handleEnter(key);
+            case key.meta:
+                return handleMeta;
+            case key.tab:
+                return () => { };
+            case key.upArrow:
+                return upOrHistoryUp;
+            case key.downArrow:
+                return downOrHistoryDown;
+            case key.leftArrow:
+                return () => cursor.left();
+            case key.rightArrow:
+                return () => cursor.right();
+        }
+        return function (input) {
+            switch (true) {
+                // Home key
+                case input == "\x1b[H" || input == "\x1b[1~":
+                    return cursor.startOfLine();
+                // End key
+                case input == "\x1b[F" || input == "\x1b[4~":
+                    return cursor.endOfLine();
+                // Handle backspace character explicitly - this is the key fix
+                case input === "\b" || input === "\x7f" || input === "\x08":
+                    maybeClearImagePasteErrorTimeout();
+                    return cursor.backspace();
+                default:
+                    return cursor.insert(input.replace(/\r/g, "\n"));
+            }
+        };
+    }
+    return {
+        onInput,
+        renderedValue: cursor.render(cursorChar, mask, invert),
+        offset,
+        setOffset,
+    };
+}
+//# sourceMappingURL=useTextInput.js.map

package/dist/ui/components/tool-types.js

@@ -0,0 +1,9 @@
+// packages/cli/src/ui/components/tool-types.ts
+export function isBashOutput(data) {
+    return (typeof data === "object" &&
+        data !== null &&
+        "stdout" in data &&
+        "stderr" in data &&
+        "exitCode" in data);
+}
+//# sourceMappingURL=tool-types.js.map

package/dist/ui/constants/figures.js

@@ -0,0 +1,4 @@
+// Change: replaced env.platform with process.platform check
+// The former is better vertically aligned, but isn't usually supported on Windows/Linux
+export const BLACK_CIRCLE = process.platform === "darwin" ? "\u23FA" : "\u25CF";
+//# sourceMappingURL=figures.js.map

package/dist/ui/constants/index.js

@@ -0,0 +1,3 @@
+// packages/cli/src/ui/constants/index.ts
+export { BLACK_CIRCLE } from "./figures.js";
+//# sourceMappingURL=index.js.map

package/dist/ui/display-mode.js

@@ -0,0 +1,93 @@
+// packages/cli/src/ui/display-mode.ts
+//
+// Display modes control UI presentation density. All data is always collected
+// by ObservabilityContext — modes only affect what gets rendered.
+//
+// This is UI presentation state, not feature toggling. Consistent with the
+// "no opt-in, no opt-out" principle: features are always ON, modes are
+// analogous to collapsing a sidebar.
+/**
+ * Mode presets — the base defaults for each display mode.
+ * Each key controls UI presentation density, not feature availability.
+ */
+export const MODE_PRESETS = {
+    minimal: {
+        showThinking: false,
+        showCosts: false,
+        showToolArgs: false,
+        toolOutput: "hidden",
+        showTraces: false,
+        showPipelineTiming: false,
+        showStatusBar: false,
+    },
+    standard: {
+        showThinking: true,
+        showCosts: true,
+        showToolArgs: true,
+        toolOutput: "standard",
+        showTraces: false,
+        showPipelineTiming: false,
+        showStatusBar: true,
+    },
+    debug: {
+        showThinking: true,
+        showCosts: true,
+        showToolArgs: true,
+        toolOutput: "expanded",
+        showTraces: true,
+        showPipelineTiming: true,
+        showStatusBar: true,
+    },
+};
+/**
+ * All display modes in cycle order. Used by the 'd' hotkey.
+ */
+export const DISPLAY_MODE_CYCLE = ["minimal", "standard", "debug"];
+/**
+ * Get the next display mode in the cycle.
+ * minimal -> standard -> debug -> minimal
+ */
+export function nextDisplayMode(current) {
+    const idx = DISPLAY_MODE_CYCLE.indexOf(current);
+    return DISPLAY_MODE_CYCLE[(idx + 1) % DISPLAY_MODE_CYCLE.length];
+}
+/**
+ * Get the DisplayConfig for a given mode.
+ */
+export function getDisplayConfig(mode) {
+    return { ...MODE_PRESETS[mode] };
+}
+/**
+ * Compute explicit overrides relative to a mode preset.
+ * Useful for preserving layered config/hotkey choices across mode cycling.
+ */
+export function deriveDisplayOverrides(mode, config) {
+    const preset = MODE_PRESETS[mode];
+    const overrides = {};
+    if (config.showThinking !== preset.showThinking)
+        overrides.showThinking = config.showThinking;
+    if (config.showCosts !== preset.showCosts)
+        overrides.showCosts = config.showCosts;
+    if (config.showToolArgs !== preset.showToolArgs)
+        overrides.showToolArgs = config.showToolArgs;
+    if (config.toolOutput !== preset.toolOutput)
+        overrides.toolOutput = config.toolOutput;
+    if (config.showTraces !== preset.showTraces)
+        overrides.showTraces = config.showTraces;
+    if (config.showPipelineTiming !== preset.showPipelineTiming) {
+        overrides.showPipelineTiming = config.showPipelineTiming;
+    }
+    if (config.showStatusBar !== preset.showStatusBar)
+        overrides.showStatusBar = config.showStatusBar;
+    return overrides;
+}
+/**
+ * Apply explicit overrides on top of a mode preset.
+ */
+export function resolveDisplayConfig(mode, overrides) {
+    return {
+        ...MODE_PRESETS[mode],
+        ...(overrides ?? {}),
+    };
+}
+//# sourceMappingURL=display-mode.js.map

package/dist/ui/display-policy.js

@@ -0,0 +1,19 @@
+export function applyDisplayPolicy(items, mode) {
+    if (mode === "debug")
+        return items;
+    return items.flatMap((item) => {
+        if (item.kind === "thinking") {
+            if (mode === "minimal")
+                return [];
+            // Standard mode: show collapsed "Thought for Xs" only when duration is known.
+            // Items without durationSec would render as null from RenderItemView, but the
+            // wrapping <Box marginTop={1}> in App.tsx still renders — producing a blank line
+            // per invisible item. With thousands of messages this creates a massive gap.
+            if (item.durationSec == null)
+                return [];
+            return [{ ...item, content: "" }];
+        }
+        return [item];
+    });
+}
+//# sourceMappingURL=display-policy.js.map