@aria-cli/cli 1.0.57 → 1.0.58

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

@@ -1,231 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,30 +0,0 @@
-// 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

@@ -1,245 +0,0 @@
-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

@@ -1,9 +0,0 @@
-// 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

@@ -1,4 +0,0 @@
-// 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

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

package/dist/ui/display-mode.js

@@ -1,93 +0,0 @@
-// 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

@@ -1,19 +0,0 @@
-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