pi-ui-extend 0.1.1

package/dist/app/terminal-controller.d.ts

@@ -0,0 +1,40 @@
+import type { AgentSessionRuntime } from "@earendil-works/pi-coding-agent";
+export type AppTerminalControllerHost = {
+    isRunning(): boolean;
+    setRunning(running: boolean): void;
+    runtime(): AgentSessionRuntime | undefined;
+    saveInputStateForQuit(): Promise<void>;
+    disposeInactiveRuntimesForQuit(): Promise<void>;
+    render(): void;
+    handleInputChunk(chunk: Buffer): void;
+    closeSdkMenuForStop(): void;
+    clearToastTimers(): void;
+    stopBlinking(): void;
+    stopSubagentsPolling(): void;
+    stopModelUsagePolling(): void;
+    stopVoiceInput(): Promise<void>;
+    stopShellCommand(): void;
+    unsubscribeSession(): void;
+    clearExtensionWidgets(): void;
+    resetRenderOutputBuffer(): void;
+};
+export declare class AppTerminalController {
+    private readonly host;
+    private terminalEnabled;
+    private interactiveSuspended;
+    private stopPromise;
+    constructor(host: AppTerminalControllerHost);
+    isSuspended(): boolean;
+    enableTerminal(): void;
+    stop(): Promise<void>;
+    disposeRuntimeForQuit(runtime: AgentSessionRuntime): Promise<void>;
+    disposeRuntime(runtime: AgentSessionRuntime): Promise<void>;
+    runWithInteractiveTerminal<T>(callback: () => Promise<T>): Promise<T>;
+    private readonly restoreTerminal;
+    private suspendForInteractiveProcess;
+    private resumeAfterInteractiveProcess;
+    private stopInternal;
+    private scheduleForcedProcessExit;
+    private readonly onResize;
+    private readonly onInputData;
+}

package/dist/app/terminal-controller.js

@@ -0,0 +1,135 @@
+import { ANSI_RESET } from "../theme.js";
+import { DISABLE_BRACKETED_PASTE, DISABLE_TERMINAL_KEY_REPORTING, DISABLE_TERMINAL_WRAP, CLEAR_TERMINAL, ENABLE_BRACKETED_PASTE, ENABLE_TERMINAL_KEY_REPORTING, ENABLE_TERMINAL_WRAP, HIDE_CURSOR, RUNTIME_DISPOSE_GRACE_MS, SHOW_CURSOR, } from "./constants.js";
+export class AppTerminalController {
+    host;
+    terminalEnabled = false;
+    interactiveSuspended = false;
+    stopPromise;
+    constructor(host) {
+        this.host = host;
+    }
+    isSuspended() {
+        return this.interactiveSuspended;
+    }
+    enableTerminal() {
+        if (this.terminalEnabled)
+            return;
+        this.terminalEnabled = true;
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.on("data", this.onInputData);
+        process.stdout.on("resize", this.onResize);
+        process.stdout.write(`${ANSI_RESET}${CLEAR_TERMINAL}\x1b[?1049h${CLEAR_TERMINAL}${ENABLE_TERMINAL_KEY_REPORTING}${ENABLE_BRACKETED_PASTE}${DISABLE_TERMINAL_WRAP}\x1b[?1002h\x1b[?1006h${HIDE_CURSOR}`);
+        process.on("exit", this.restoreTerminal);
+    }
+    async stop() {
+        if (this.stopPromise) {
+            await this.stopPromise;
+            return;
+        }
+        this.stopPromise = this.stopInternal();
+        await this.stopPromise;
+    }
+    async disposeRuntimeForQuit(runtime) {
+        let timeout;
+        const dispose = runtime.dispose().then(() => "disposed", () => "failed");
+        const timeoutPromise = new Promise((resolveTimeout) => {
+            timeout = setTimeout(() => resolveTimeout("timeout"), RUNTIME_DISPOSE_GRACE_MS);
+        });
+        const result = await Promise.race([dispose, timeoutPromise]);
+        if (timeout)
+            clearTimeout(timeout);
+        if (result !== "disposed")
+            runtime.session.dispose();
+    }
+    async disposeRuntime(runtime) {
+        try {
+            await runtime.dispose();
+        }
+        catch {
+            // Best-effort tab cleanup: extension shutdown errors are surfaced through
+            // the SDK onError path, and tab switching should not produce unhandled
+            // promise rejections if a disposed runtime is already half-torn down.
+        }
+    }
+    async runWithInteractiveTerminal(callback) {
+        this.suspendForInteractiveProcess();
+        try {
+            return await callback();
+        }
+        finally {
+            this.resumeAfterInteractiveProcess();
+        }
+    }
+    restoreTerminal = () => {
+        if (!this.terminalEnabled)
+            return;
+        this.terminalEnabled = false;
+        this.interactiveSuspended = false;
+        process.stdout.write(`${ANSI_RESET}${DISABLE_TERMINAL_KEY_REPORTING}${DISABLE_BRACKETED_PASTE}${ENABLE_TERMINAL_WRAP}\x1b[?1006l\x1b[?1002l\x1b[?1049l${SHOW_CURSOR}`);
+        if (process.stdin.isTTY)
+            process.stdin.setRawMode(false);
+    };
+    suspendForInteractiveProcess() {
+        if (!this.terminalEnabled || this.interactiveSuspended)
+            return;
+        this.interactiveSuspended = true;
+        process.stdin.off("data", this.onInputData);
+        process.stdin.pause();
+        process.stdout.off("resize", this.onResize);
+        process.stdout.write(`${ANSI_RESET}${DISABLE_TERMINAL_KEY_REPORTING}${DISABLE_BRACKETED_PASTE}${ENABLE_TERMINAL_WRAP}\x1b[?1006l\x1b[?1002l\x1b[?1049l${SHOW_CURSOR}`);
+        if (process.stdin.isTTY)
+            process.stdin.setRawMode(false);
+    }
+    resumeAfterInteractiveProcess() {
+        if (!this.terminalEnabled || !this.interactiveSuspended)
+            return;
+        this.interactiveSuspended = false;
+        if (process.stdin.isTTY)
+            process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.on("data", this.onInputData);
+        process.stdout.on("resize", this.onResize);
+        this.host.resetRenderOutputBuffer();
+        process.stdout.write(`${ANSI_RESET}${CLEAR_TERMINAL}\x1b[?1049h${CLEAR_TERMINAL}${ENABLE_TERMINAL_KEY_REPORTING}${ENABLE_BRACKETED_PASTE}${DISABLE_TERMINAL_WRAP}\x1b[?1002h\x1b[?1006h${HIDE_CURSOR}`);
+        this.host.render();
+    }
+    async stopInternal() {
+        if (!this.host.isRunning())
+            return;
+        this.host.setRunning(false);
+        this.host.closeSdkMenuForStop();
+        this.host.clearToastTimers();
+        this.host.stopBlinking();
+        this.host.stopSubagentsPolling();
+        this.host.stopModelUsagePolling();
+        await this.host.stopVoiceInput();
+        this.host.stopShellCommand();
+        process.stdin.off("data", this.onInputData);
+        process.stdin.pause();
+        process.stdout.off("resize", this.onResize);
+        process.off("exit", this.restoreTerminal);
+        this.host.unsubscribeSession();
+        this.host.clearExtensionWidgets();
+        await this.host.saveInputStateForQuit();
+        this.restoreTerminal();
+        this.scheduleForcedProcessExit();
+        await this.host.disposeInactiveRuntimesForQuit();
+        const runtime = this.host.runtime();
+        if (runtime)
+            await this.disposeRuntimeForQuit(runtime);
+    }
+    scheduleForcedProcessExit() {
+        const exitCode = typeof process.exitCode === "number" ? process.exitCode : 0;
+        const timer = setTimeout(() => {
+            process.exit(exitCode);
+        }, RUNTIME_DISPOSE_GRACE_MS);
+        timer.unref();
+    }
+    onResize = () => {
+        this.host.render();
+    };
+    onInputData = (chunk) => {
+        this.host.handleInputChunk(chunk);
+    };
+}

package/dist/app/terminal-edit-shortcuts.d.ts

@@ -0,0 +1,23 @@
+export type TerminalEditShortcut = "undo" | "redo";
+export type TerminalEditShortcutSequenceResult = {
+    readonly kind: "shortcut";
+    readonly shortcut: TerminalEditShortcut;
+    readonly length: number;
+} | {
+    readonly kind: "ignore";
+    readonly length: number;
+} | {
+    readonly kind: "pending";
+} | {
+    readonly kind: "none";
+};
+export declare function parseTerminalEditShortcutSequence(input: string): TerminalEditShortcutSequenceResult;
+export declare function parseTerminalInterruptSequence(input: string): {
+    readonly kind: "interrupt";
+    readonly length: number;
+} | {
+    readonly kind: "pending";
+} | {
+    readonly kind: "none";
+};
+export declare function terminalEditShortcutForControlChar(char: string, shiftPressed: boolean): TerminalEditShortcut | undefined;

package/dist/app/terminal-edit-shortcuts.js

@@ -0,0 +1,138 @@
+const SHIFT_MODIFIER_FLAG = 1;
+const CONTROL_MODIFIER_FLAG = 4;
+const COMMAND_MODIFIER_FLAG = 8;
+const LOCK_MODIFIER_MASK = 64 + 128;
+const KEY_CODE_C = 99;
+const KEY_CODE_Y = 121;
+const KEY_CODE_Z = 122;
+const CYRILLIC_SMALL_ES_CODE = 1089;
+const CYRILLIC_CAPITAL_ES_CODE = 1057;
+const KITTY_CSI_U_SEQUENCE = /^\x1b\[(\d+)(?::(\d*))?(?::(\d+))?(?:;(\d+))?(?::(\d+))?u/;
+const XTERM_MODIFY_OTHER_KEYS_SEQUENCE = /^\x1b\[27;(\d+);(\d+)~/;
+export function parseTerminalEditShortcutSequence(input) {
+    const kitty = parseKittyCsiUSequence(input);
+    if (kitty)
+        return terminalEditShortcutResult(kitty);
+    const xterm = parseXtermModifyOtherKeysSequence(input);
+    if (xterm)
+        return terminalEditShortcutResult(xterm);
+    if (isPotentialEditShortcutPrefix(input))
+        return { kind: "pending" };
+    return { kind: "none" };
+}
+export function parseTerminalInterruptSequence(input) {
+    const kitty = parseKittyCsiUSequence(input);
+    if (kitty && terminalKeyIsControlC(kitty))
+        return { kind: "interrupt", length: kitty.length };
+    const xterm = parseXtermModifyOtherKeysSequence(input);
+    if (xterm && terminalKeyIsControlC(xterm))
+        return { kind: "interrupt", length: xterm.length };
+    if (isPotentialInterruptPrefix(input))
+        return { kind: "pending" };
+    return { kind: "none" };
+}
+export function terminalEditShortcutForControlChar(char, shiftPressed) {
+    if (char === "\u001a")
+        return shiftPressed ? "redo" : "undo";
+    if (char === "\u0019")
+        return "redo";
+    return undefined;
+}
+function parseKittyCsiUSequence(input) {
+    const match = KITTY_CSI_U_SEQUENCE.exec(input);
+    if (!match)
+        return undefined;
+    const codepoint = Number.parseInt(match[1] ?? "", 10);
+    const baseLayoutKey = match[3] ? Number.parseInt(match[3], 10) : undefined;
+    const modifierValue = match[4] ? Number.parseInt(match[4], 10) : 1;
+    const eventType = match[5] ? Number.parseInt(match[5], 10) : undefined;
+    if (!Number.isFinite(codepoint) || !Number.isFinite(modifierValue))
+        return undefined;
+    return {
+        codepoint,
+        baseLayoutKey: Number.isFinite(baseLayoutKey) ? baseLayoutKey : undefined,
+        modifier: modifierValue - 1,
+        eventType: Number.isFinite(eventType) ? eventType : undefined,
+        length: match[0].length,
+    };
+}
+function parseXtermModifyOtherKeysSequence(input) {
+    const match = XTERM_MODIFY_OTHER_KEYS_SEQUENCE.exec(input);
+    if (!match)
+        return undefined;
+    const modifierValue = Number.parseInt(match[1] ?? "", 10);
+    const codepoint = Number.parseInt(match[2] ?? "", 10);
+    if (!Number.isFinite(codepoint) || !Number.isFinite(modifierValue))
+        return undefined;
+    return {
+        codepoint,
+        baseLayoutKey: undefined,
+        modifier: modifierValue - 1,
+        eventType: undefined,
+        length: match[0].length,
+    };
+}
+function terminalEditShortcutResult(key) {
+    const effectiveModifier = key.modifier & ~LOCK_MODIFIER_MASK;
+    if ((effectiveModifier & COMMAND_MODIFIER_FLAG) === 0)
+        return { kind: "none" };
+    // Kitty keyboard protocol flag 2 appends event types. Press/repeat are action-worthy;
+    // release must be swallowed so the release packet is not inserted into the editor.
+    if (key.eventType === 3)
+        return { kind: "ignore", length: key.length };
+    const shortcut = terminalEditShortcutForKey(key, effectiveModifier);
+    if (!shortcut)
+        return { kind: "ignore", length: key.length };
+    return { kind: "shortcut", shortcut, length: key.length };
+}
+function terminalKeyIsControlC(key) {
+    const effectiveModifier = key.modifier & ~LOCK_MODIFIER_MASK;
+    if ((effectiveModifier & CONTROL_MODIFIER_FLAG) === 0)
+        return false;
+    return interruptCodepointIsC(key.codepoint) || interruptCodepointIsC(key.baseLayoutKey ?? key.codepoint);
+}
+function interruptCodepointIsC(codepoint) {
+    const normalized = normalizeLetterCodepoint(codepoint);
+    return normalized === KEY_CODE_C || normalized === CYRILLIC_SMALL_ES_CODE || normalized === CYRILLIC_CAPITAL_ES_CODE;
+}
+function terminalEditShortcutForKey(key, effectiveModifier) {
+    const codepoint = editShortcutCodepoint(key);
+    if (codepoint === KEY_CODE_Y)
+        return "redo";
+    if (codepoint !== KEY_CODE_Z)
+        return undefined;
+    return (effectiveModifier & SHIFT_MODIFIER_FLAG) !== 0 ? "redo" : "undo";
+}
+function editShortcutCodepoint(key) {
+    const primary = normalizeLetterCodepoint(key.codepoint);
+    if (primary === KEY_CODE_Z || primary === KEY_CODE_Y)
+        return primary;
+    return normalizeLetterCodepoint(key.baseLayoutKey ?? key.codepoint);
+}
+function normalizeLetterCodepoint(codepoint) {
+    if (codepoint >= 65 && codepoint <= 90)
+        return codepoint + 32;
+    return codepoint;
+}
+function isPotentialEditShortcutPrefix(input) {
+    if (!input.startsWith("\x1b["))
+        return false;
+    if (input.includes("u") || input.includes("~"))
+        return false;
+    const body = input.slice(2);
+    if (!/^[\d:;]*$/.test(body))
+        return false;
+    const possibleStarts = ["122", "121", "90", "27;"];
+    return possibleStarts.some((start) => start.startsWith(body) || body.startsWith(start));
+}
+function isPotentialInterruptPrefix(input) {
+    if (!input.startsWith("\x1b["))
+        return false;
+    if (input.includes("u") || input.includes("~"))
+        return false;
+    const body = input.slice(2);
+    if (!/^[\d:;]*$/.test(body))
+        return false;
+    const possibleStarts = ["99", "67", "1089", "1057", "27;"];
+    return possibleStarts.some((start) => start.startsWith(body) || body.startsWith(start));
+}

package/dist/app/terminal-output-buffer.d.ts

@@ -0,0 +1,20 @@
+export declare const DISABLE_TERMINAL_OUTPUT_BUFFER_ENV = "PIX_DISABLE_TERMINAL_OUTPUT_BUFFER";
+export declare const TERMINAL_OUTPUT_BUFFER_ENV = "PIX_TERMINAL_OUTPUT_BUFFER";
+declare const FRAME_REGIONS: readonly ["tabs", "conversation", "inputStatus"];
+export type TerminalOutputFrameRegion = typeof FRAME_REGIONS[number];
+export type TerminalOutputRegion = TerminalOutputFrameRegion | "statusLine";
+export type TerminalOutputFrame = Partial<Record<TerminalOutputFrameRegion, string>>;
+export type TerminalOutputBufferOptions = {
+    enabled?: boolean;
+    env?: Record<string, string | undefined>;
+};
+export declare class TerminalOutputBuffer {
+    private readonly enabled;
+    private readonly previousByRegion;
+    constructor(options?: TerminalOutputBufferOptions);
+    diffFrame(frame: TerminalOutputFrame): string;
+    diff(region: TerminalOutputRegion, output: string): string;
+    reset(): void;
+}
+export declare function terminalOutputBufferDisabled(env?: Record<string, string | undefined>): boolean;
+export {};

package/dist/app/terminal-output-buffer.js

@@ -0,0 +1,52 @@
+export const DISABLE_TERMINAL_OUTPUT_BUFFER_ENV = "PIX_DISABLE_TERMINAL_OUTPUT_BUFFER";
+export const TERMINAL_OUTPUT_BUFFER_ENV = "PIX_TERMINAL_OUTPUT_BUFFER";
+const FRAME_REGIONS = ["tabs", "conversation", "inputStatus"];
+export class TerminalOutputBuffer {
+    enabled;
+    previousByRegion = new Map();
+    constructor(options = {}) {
+        this.enabled = options.enabled ?? !terminalOutputBufferDisabled(options.env ?? process.env);
+    }
+    diffFrame(frame) {
+        const outputByRegion = {
+            tabs: frame.tabs ?? "",
+            conversation: frame.conversation ?? "",
+            inputStatus: frame.inputStatus ?? "",
+        };
+        if (!this.enabled)
+            return FRAME_REGIONS.map((region) => outputByRegion[region]).join("");
+        const chunks = [];
+        for (const region of FRAME_REGIONS) {
+            const output = outputByRegion[region];
+            if (this.previousByRegion.get(region) === output)
+                continue;
+            this.previousByRegion.set(region, output);
+            if (output.length > 0)
+                chunks.push(output);
+        }
+        return chunks.join("");
+    }
+    diff(region, output) {
+        if (!this.enabled)
+            return output;
+        if (this.previousByRegion.get(region) === output)
+            return "";
+        this.previousByRegion.set(region, output);
+        return output;
+    }
+    reset() {
+        this.previousByRegion.clear();
+    }
+}
+export function terminalOutputBufferDisabled(env = process.env) {
+    const disabled = env[DISABLE_TERMINAL_OUTPUT_BUFFER_ENV];
+    if (disabled !== undefined)
+        return !isFalseEnvValue(disabled);
+    const enabled = env[TERMINAL_OUTPUT_BUFFER_ENV];
+    if (enabled !== undefined)
+        return isFalseEnvValue(enabled);
+    return false;
+}
+function isFalseEnvValue(value) {
+    return /^(?:0|false|off|no)$/iu.test(value.trim());
+}

package/dist/app/toast-controller.d.ts

@@ -0,0 +1,13 @@
+import { Toast, type ToastKind } from "../ui.js";
+export type AppToastControllerHost = {
+    render(): void;
+};
+export declare class AppToastController {
+    private readonly host;
+    readonly toast: Toast;
+    private readonly timers;
+    constructor(host: AppToastControllerHost);
+    showToast(message: string, kind?: ToastKind): void;
+    dismissToast(toastId: number): void;
+    clearToastTimers(): void;
+}

package/dist/app/toast-controller.js

@@ -0,0 +1,40 @@
+import { Toast } from "../ui.js";
+import { TOAST_DURATION_MS } from "./constants.js";
+export class AppToastController {
+    host;
+    toast = new Toast();
+    timers = new Map();
+    constructor(host) {
+        this.host = host;
+    }
+    showToast(message, kind = "info") {
+        const toastId = this.toast.show(message, kind);
+        if (kind === "error") {
+            this.host.render();
+            return;
+        }
+        const timer = setTimeout(() => {
+            this.toast.hide(toastId);
+            this.timers.delete(toastId);
+            this.host.render();
+        }, TOAST_DURATION_MS);
+        this.timers.set(toastId, timer);
+        timer.unref();
+        this.host.render();
+    }
+    dismissToast(toastId) {
+        const timer = this.timers.get(toastId);
+        if (timer) {
+            clearTimeout(timer);
+            this.timers.delete(toastId);
+        }
+        this.toast.hide(toastId);
+        this.host.render();
+    }
+    clearToastTimers() {
+        for (const timer of this.timers.values())
+            clearTimeout(timer);
+        this.timers.clear();
+        this.toast.hide();
+    }
+}

package/dist/app/toast-renderer.d.ts

@@ -0,0 +1,9 @@
+import { type Theme } from "../theme.js";
+import type { ToastEntry } from "../ui.js";
+export type ToastOverlay = {
+    id: number;
+    row: number;
+    text: string;
+    output: string;
+};
+export declare function renderToastOverlays(states: readonly ToastEntry[], width: number, maxRows: number, theme: Theme): ToastOverlay[];

package/dist/app/toast-renderer.js

@@ -0,0 +1,79 @@
+import { colorLine } from "../theme.js";
+import { stringDisplayWidth, wrapDisplayLine } from "../terminal-width.js";
+import { APP_ICONS } from "./icons.js";
+import { padOrTrimPlain, sanitizeText } from "./render-text.js";
+export function renderToastOverlays(states, width, maxRows, theme) {
+    if (maxRows <= 0)
+        return [];
+    const overlays = [];
+    for (const state of [...states].reverse()) {
+        if (overlays.length >= maxRows)
+            break;
+        const icon = toastKindIcon(state.kind);
+        const lines = toastMessageLines(state.message, icon, Math.max(1, width - 6));
+        const visibleLines = lines.slice(0, Math.max(0, maxRows - overlays.length));
+        if (visibleLines.length === 0)
+            continue;
+        const contentWidth = Math.max(...visibleLines.map((line) => stringDisplayWidth(line)));
+        const toastWidth = Math.min(Math.max(12, contentWidth + 2), Math.max(1, width - 4));
+        const leftWidth = Math.max(0, width - toastWidth - 2);
+        const rightWidth = Math.max(0, width - leftWidth - toastWidth);
+        for (const line of visibleLines) {
+            const message = ` ${padOrTrimPlain(line, Math.max(0, toastWidth - 2))} `;
+            const text = `${" ".repeat(leftWidth)}${padOrTrimPlain(message, toastWidth)}${" ".repeat(rightWidth)}`;
+            const output = [
+                colorLine("", leftWidth, { background: theme.colors.background }),
+                colorLine(message, toastWidth, {
+                    ...toastKindStyle(state.kind, theme),
+                    bold: true,
+                }),
+                colorLine("", rightWidth, { background: theme.colors.background }),
+            ].join("");
+            overlays.push({ id: state.id, row: overlays.length + 1, text, output });
+        }
+    }
+    return overlays;
+}
+function toastMessageLines(message, icon, maxWidth) {
+    const firstPrefix = `${icon} `;
+    const continuationPrefix = " ".repeat(stringDisplayWidth(firstPrefix));
+    const safeMaxWidth = Math.max(1, maxWidth);
+    const safeContinuationPrefix = stringDisplayWidth(continuationPrefix) < safeMaxWidth ? continuationPrefix : "";
+    const lines = [];
+    const logicalLines = sanitizeText(message).split("\n");
+    for (const [index, logicalLine] of logicalLines.entries()) {
+        const prefix = index === 0 ? firstPrefix : continuationPrefix;
+        const prefixWidth = stringDisplayWidth(prefix);
+        const effectivePrefix = prefixWidth < safeMaxWidth ? prefix : "";
+        const wrapWidth = Math.max(1, safeMaxWidth - stringDisplayWidth(effectivePrefix));
+        const wrappedLines = wrapDisplayLine(logicalLine, wrapWidth);
+        for (const [wrappedIndex, wrappedLine] of wrappedLines.entries()) {
+            lines.push(`${wrappedIndex === 0 ? effectivePrefix : safeContinuationPrefix}${wrappedLine}`);
+        }
+    }
+    return lines.length > 0 ? lines : [firstPrefix.trimEnd()];
+}
+function toastKindIcon(kind) {
+    switch (kind) {
+        case "success":
+            return APP_ICONS.checkCircle;
+        case "error":
+            return APP_ICONS.closeCircle;
+        case "warning":
+            return APP_ICONS.alert;
+        case "info":
+            return APP_ICONS.info;
+    }
+}
+function toastKindStyle(kind, theme) {
+    switch (kind) {
+        case "success":
+            return { foreground: theme.colors.toastForeground, background: theme.colors.toastBackground };
+        case "error":
+            return { foreground: theme.colors.background, background: theme.colors.error };
+        case "warning":
+            return { foreground: theme.colors.background, background: theme.colors.warning };
+        case "info":
+            return { foreground: theme.colors.background, background: theme.colors.info };
+    }
+}

package/dist/app/todo-model.d.ts

@@ -0,0 +1,22 @@
+import type { StyledSegment, TodoAction, TodoDetails, TodoLiveStateEvent, TodoPriority, TodoStatus, TodoTask, TodoTaskLinePart, TodoTaskRow } from "./types.js";
+export declare function isTodoAction(value: unknown): value is TodoAction;
+export declare function isTodoStatus(value: unknown): value is TodoStatus;
+export declare function isTodoPriority(value: unknown): value is TodoPriority;
+export declare function isTodoTask(value: unknown): value is TodoTask;
+export declare function isTodoDetails(value: unknown): value is TodoDetails;
+export declare function isTodoLiveStateEvent(value: unknown): value is TodoLiveStateEvent;
+export declare function todoStatusIcon(status: TodoStatus): string;
+export declare function visibleTodoTasks(details: TodoDetails, showDeleted?: boolean): TodoTask[];
+export declare function hasOpenTodoTasks(details: TodoDetails): boolean;
+export declare function visibleTodoTaskRows(details: TodoDetails, showDeleted?: boolean): TodoTaskRow[];
+export declare function todoTaskLineParts(task: TodoTask, options?: {
+    depth?: number;
+}): TodoTaskLinePart[];
+export declare function formatTodoTaskLine(task: TodoTask, options?: {
+    depth?: number;
+}): string;
+export declare function todoTaskLineSegments(task: TodoTask, mutedColor: string, options?: {
+    depth?: number;
+}): StyledSegment[];
+export declare function shiftSegmentsToSlice(segments: readonly StyledSegment[], start: number, length: number): StyledSegment[];
+export declare function formatTodoPanelStats(tasks: readonly TodoTask[]): string;