@bubblebrain-ai/bubble 0.0.7 → 0.0.9

package/dist/tui-ink/approval/approval-dialog.d.ts

@@ -0,0 +1,13 @@
+import type { ApprovalDecision, ApprovalRequest } from "../../approval/types.js";
+interface ApprovalDialogProps {
+    request: ApprovalRequest;
+    onDecision: (decision: ApprovalDecision) => void;
+    /**
+     * Selecting "Yes, and don't ask again for <prefix>" calls this with the
+     * (possibly user-edited) prefix so the harness can register it in the
+     * session-scoped bash allowlist.
+     */
+    onAllowBashPrefix?: (prefix: string) => void;
+}
+export declare function ApprovalDialog({ request, onDecision, onAllowBashPrefix, }: ApprovalDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/tui-ink/approval/approval-dialog.js

@@ -0,0 +1,132 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { useTheme } from "../theme.js";
+import { ApprovalSelect } from "./select.js";
+import { DiffView } from "./diff-view.js";
+import { inferBashPrefix } from "../../approval/session-cache.js";
+import { classifyBashDanger } from "../../approval/danger.js";
+export function ApprovalDialog({ request, onDecision, onAllowBashPrefix, }) {
+    const theme = useTheme();
+    const options = buildOptions(request);
+    const onSubmit = (id, extras) => {
+        switch (id) {
+            case "yes":
+                onDecision({ action: "approve", feedback: extras.feedback });
+                return;
+            case "yes-bash-prefix": {
+                const prefix = (extras.editedValue ?? "").trim();
+                if (prefix)
+                    onAllowBashPrefix?.(prefix);
+                onDecision({ action: "approve" });
+                return;
+            }
+            case "no":
+            default:
+                onDecision({ action: "reject", feedback: extras.feedback });
+                return;
+        }
+    };
+    const onCancel = () => onDecision({ action: "reject" });
+    const title = dialogTitle(request);
+    const question = dialogQuestion(request);
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.accent, paddingX: 1, marginY: 1, children: [_jsx(Text, { color: theme.accent, bold: true, children: title }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(RequestPreview, { request: request }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: question }) }), _jsx(Box, { marginTop: 1, children: _jsx(ApprovalSelect, { options: options, onSubmit: onSubmit, onCancel: onCancel, hint: "\u2191\u2193 choose \u00B7 Enter select \u00B7 Tab add feedback \u00B7 Esc reject" }) })] }));
+}
+function buildOptions(request) {
+    if (request.type === "bash") {
+        const prefix = inferBashPrefix(request.command);
+        return [
+            { id: "yes", label: "Yes", allowAmend: true, amendPlaceholder: "and tell Claude what to do next" },
+            {
+                id: "yes-bash-prefix",
+                label: "Yes, and don't ask again for",
+                editableValue: {
+                    initial: prefix,
+                    placeholder: "command prefix (e.g. npm run:*)",
+                },
+            },
+            {
+                id: "no",
+                label: "No",
+                description: "(tab to add feedback)",
+                allowAmend: true,
+                amendPlaceholder: "and tell Claude what to do differently",
+            },
+        ];
+    }
+    // edit / write
+    return [
+        { id: "yes", label: "Yes", allowAmend: true, amendPlaceholder: "and tell Claude what to do next" },
+        {
+            id: "no",
+            label: "No",
+            description: "(tab to add feedback)",
+            allowAmend: true,
+            amendPlaceholder: "and tell Claude what to do differently",
+        },
+    ];
+}
+function dialogTitle(req) {
+    switch (req.type) {
+        case "edit":
+            return "Edit file";
+        case "write":
+            return req.fileExists ? "Overwrite file" : "Create file";
+        case "bash":
+            return "Bash command";
+        case "lsp":
+            return "Language server operation";
+    }
+}
+function dialogQuestion(req) {
+    switch (req.type) {
+        case "edit":
+            return `Do you want to make this edit to ${basename(req.path)}?`;
+        case "write":
+            return `Do you want to ${req.fileExists ? "overwrite" : "create"} ${basename(req.path)}?`;
+        case "bash":
+            return "Do you want to proceed?";
+        case "lsp":
+            return `Do you want to run ${req.operation} on ${basename(req.path)}?`;
+    }
+}
+function basename(p) {
+    const idx = p.lastIndexOf("/");
+    return idx >= 0 ? p.slice(idx + 1) : p;
+}
+function RequestPreview({ request }) {
+    switch (request.type) {
+        case "bash":
+            return _jsx(BashPreview, { command: request.command, cwd: request.cwd });
+        case "edit":
+            return _jsx(DiffView, { diff: request.diff });
+        case "write":
+            return _jsx(WritePreview, { path: request.path, content: request.content });
+    }
+}
+function BashPreview({ command, cwd }) {
+    const theme = useTheme();
+    const danger = classifyBashDanger(command);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: theme.muted, children: "$ " }), _jsx(Text, { children: command })] }), _jsxs(Text, { color: theme.muted, children: ["cwd: ", compressHome(cwd)] }), danger && (_jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { color: theme.warning, bold: true, children: ["\u26A0 ", danger.pattern, ":"] }), _jsxs(Text, { color: theme.warning, children: [" ", danger.message] })] }))] }));
+}
+const MAX_WRITE_PREVIEW_LINES = 20;
+function WritePreview({ path, content }) {
+    const theme = useTheme();
+    const lines = content.split("\n");
+    const shown = lines.slice(0, MAX_WRITE_PREVIEW_LINES);
+    const overflow = lines.length - shown.length;
+    const totalBytes = Buffer.byteLength(content, "utf-8");
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: theme.muted, children: compressHome(path) }), _jsxs(Text, { color: theme.muted, children: [" \u00B7 ", lines.length, " line", lines.length === 1 ? "" : "s", " \u00B7 ", formatBytes(totalBytes)] })] }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [shown.map((line, i) => (_jsxs(Text, { color: "green", children: ["+ ", line || " "] }, i))), overflow > 0 && (_jsxs(Text, { color: theme.muted, children: ["\u2026 ", overflow, " more line", overflow === 1 ? "" : "s"] }))] })] }));
+}
+function formatBytes(n) {
+    if (n < 1024)
+        return `${n}B`;
+    if (n < 1024 * 1024)
+        return `${(n / 1024).toFixed(1)}KB`;
+    return `${(n / (1024 * 1024)).toFixed(1)}MB`;
+}
+function compressHome(p) {
+    const home = process.env.HOME || "";
+    if (home && p.startsWith(home))
+        return `~${p.slice(home.length)}`;
+    return p;
+}

package/dist/tui-ink/approval/diff-view.d.ts

@@ -0,0 +1,7 @@
+interface DiffViewProps {
+    diff: string;
+    /** Hard cap on total rendered lines across all hunks. Excess is truncated. */
+    maxLines?: number;
+}
+export declare function DiffView({ diff, maxLines }: DiffViewProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/tui-ink/approval/diff-view.js

@@ -0,0 +1,44 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { useTheme } from "../theme.js";
+import { parseDiffHunks } from "../../approval/diff-hunks.js";
+const DEFAULT_MAX_LINES = 40;
+export function DiffView({ diff, maxLines = DEFAULT_MAX_LINES }) {
+    const theme = useTheme();
+    const hunks = parseDiffHunks(diff);
+    if (hunks.length === 0) {
+        return (_jsx(Text, { color: theme.muted, children: "(no diff body to display)" }));
+    }
+    // Distribute the line budget across hunks. Simple approach: render hunks in
+    // order until the budget is exhausted; if a hunk overflows, keep its header,
+    // show as many body lines as fit, then emit a "… N more" marker.
+    let remaining = maxLines;
+    const rendered = [];
+    let trailingSkipped = 0;
+    for (let i = 0; i < hunks.length; i++) {
+        const hunk = hunks[i];
+        if (remaining <= 1) {
+            trailingSkipped += hunk.lines.length + 1;
+            continue;
+        }
+        remaining -= 1; // header line
+        const available = Math.max(0, remaining);
+        if (hunk.lines.length <= available) {
+            rendered.push({ hunk, shown: hunk.lines, truncatedBy: 0 });
+            remaining -= hunk.lines.length;
+        }
+        else {
+            const shown = hunk.lines.slice(0, available);
+            rendered.push({ hunk, shown, truncatedBy: hunk.lines.length - available });
+            remaining = 0;
+        }
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [rendered.map(({ hunk, shown, truncatedBy }, i) => (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: theme.accent, children: hunk.header }), shown.map((line, j) => (_jsx(Text, { color: colorForDiffLine(line), children: line || " " }, j))), truncatedBy > 0 && (_jsxs(Text, { color: theme.muted, children: ["\u2026 ", truncatedBy, " more line", truncatedBy === 1 ? "" : "s", " in this hunk"] }))] }, i))), trailingSkipped > 0 && (_jsxs(Text, { color: theme.muted, children: ["\u2026 ", trailingSkipped, " more line", trailingSkipped === 1 ? "" : "s", " across later hunks"] }))] }));
+}
+function colorForDiffLine(line) {
+    if (line.startsWith("+"))
+        return "green";
+    if (line.startsWith("-"))
+        return "red";
+    return undefined;
+}

package/dist/tui-ink/approval/select.d.ts

@@ -0,0 +1,35 @@
+export interface ApprovalOption {
+    /** Stable identifier returned to the parent. */
+    id: string;
+    /** Primary label shown in the menu. */
+    label: string;
+    /** Dim description appended after the label. */
+    description?: string;
+    /** If true, Tab on this option turns it into a feedback input. */
+    allowAmend?: boolean;
+    /** Placeholder shown in the amend input. */
+    amendPlaceholder?: string;
+    /**
+     * If set, this option has an inline-editable data value (rendered right
+     * after `label`). When the option is focused, typing modifies the value;
+     * backspace removes the last character. Use-case: "Yes, and don't ask
+     * again for `<prefix>`" — the prefix is editable before submit.
+     */
+    editableValue?: {
+        initial: string;
+        placeholder?: string;
+    };
+}
+export type ApprovalSubmit = (optionId: string, extras: {
+    feedback?: string;
+    editedValue?: string;
+}) => void;
+interface ApprovalSelectProps {
+    options: ApprovalOption[];
+    onSubmit: ApprovalSubmit;
+    onCancel: () => void;
+    hint?: string;
+    initialIndex?: number;
+}
+export declare function ApprovalSelect({ options, onSubmit, onCancel, hint, initialIndex, }: ApprovalSelectProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/tui-ink/approval/select.js

@@ -0,0 +1,88 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { useTheme } from "../theme.js";
+export function ApprovalSelect({ options, onSubmit, onCancel, hint, initialIndex = 0, }) {
+    const theme = useTheme();
+    const [focusIndex, setFocusIndex] = useState(Math.max(0, Math.min(initialIndex, options.length - 1)));
+    const [amending, setAmending] = useState(false);
+    const [amendText, setAmendText] = useState("");
+    // Map of option.id → current edited value. Populated lazily so navigating
+    // away and back preserves edits.
+    const [editedValues, setEditedValues] = useState(() => {
+        const seed = {};
+        for (const opt of options) {
+            if (opt.editableValue)
+                seed[opt.id] = opt.editableValue.initial;
+        }
+        return seed;
+    });
+    const focused = options[focusIndex];
+    const canAmend = !!focused?.allowAmend;
+    const hasEditableValue = !!focused?.editableValue;
+    const currentValue = focused?.editableValue ? editedValues[focused.id] ?? "" : "";
+    useInput((input, key) => {
+        if (amending) {
+            if (key.escape) {
+                setAmending(false);
+                setAmendText("");
+                return;
+            }
+            if (key.return) {
+                const editedValue = focused.editableValue ? currentValue : undefined;
+                onSubmit(focused.id, { feedback: amendText.trim() || undefined, editedValue });
+                return;
+            }
+            if (key.backspace || key.delete) {
+                setAmendText((prev) => prev.slice(0, -1));
+                return;
+            }
+            if (input) {
+                setAmendText((prev) => prev + input);
+            }
+            return;
+        }
+        if (key.escape) {
+            onCancel();
+            return;
+        }
+        // Vertical nav always works regardless of editable value, so the user can
+        // still move off an option they don't want.
+        if (key.upArrow) {
+            setFocusIndex((i) => (i - 1 + options.length) % options.length);
+            return;
+        }
+        if (key.downArrow) {
+            setFocusIndex((i) => (i + 1) % options.length);
+            return;
+        }
+        if (key.return) {
+            const editedValue = focused.editableValue ? currentValue : undefined;
+            onSubmit(focused.id, { editedValue });
+            return;
+        }
+        if (key.tab && canAmend) {
+            setAmending(true);
+            setAmendText("");
+            return;
+        }
+        // When the focused option has an editable value, plain keypresses mutate it.
+        if (hasEditableValue) {
+            if (key.backspace || key.delete) {
+                setEditedValues((prev) => ({ ...prev, [focused.id]: (prev[focused.id] ?? "").slice(0, -1) }));
+                return;
+            }
+            if (input && !key.ctrl && !key.meta) {
+                setEditedValues((prev) => ({ ...prev, [focused.id]: (prev[focused.id] ?? "") + input }));
+            }
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", children: [options.map((option, idx) => {
+                const isFocused = idx === focusIndex;
+                const value = option.editableValue ? editedValues[option.id] ?? "" : undefined;
+                if (isFocused && amending) {
+                    return (_jsxs(Box, { children: [_jsx(Text, { color: theme.accent, children: "› " }), _jsxs(Text, { bold: true, children: [option.label, ":"] }), _jsx(Text, { children: " " }), _jsx(Text, { color: amendText ? undefined : theme.muted, children: amendText || option.amendPlaceholder || "type feedback…" }), _jsx(Text, { backgroundColor: "white", color: "black", children: " " })] }, option.id));
+                }
+                return (_jsxs(Box, { children: [_jsx(Text, { color: isFocused ? theme.accent : theme.muted, children: isFocused ? "› " : "  " }), _jsx(Text, { bold: isFocused, color: isFocused ? undefined : theme.muted, children: option.label }), option.editableValue && (_jsxs(_Fragment, { children: [_jsx(Text, { color: theme.muted, children: " " }), _jsx(Text, { color: isFocused ? theme.accent : theme.muted, children: "[" }), _jsx(Text, { color: isFocused ? undefined : theme.muted, children: value || option.editableValue.placeholder || "" }), isFocused && (_jsx(Text, { backgroundColor: "white", color: "black", children: " " })), _jsx(Text, { color: isFocused ? theme.accent : theme.muted, children: "]" })] })), option.description && (_jsxs(_Fragment, { children: [_jsx(Text, { children: " " }), _jsx(Text, { color: theme.muted, children: option.description })] }))] }, option.id));
+            }), hint && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.muted, children: hint }) }))] }));
+}

package/dist/tui-ink/code-highlight.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Lightweight code highlighting for TUI using Shiki.
+ * Converts token colors to ANSI escape codes for Ink rendering.
+ */
+export declare function warmHighlighter(): void;
+export declare function highlightCode(code: string, lang: string): Promise<string>;
+export declare function highlightCodeSync(code: string, lang: string): string | null;
+export declare function inferLang(path?: string): string;

package/dist/tui-ink/code-highlight.js

@@ -0,0 +1,122 @@
+/**
+ * Lightweight code highlighting for TUI using Shiki.
+ * Converts token colors to ANSI escape codes for Ink rendering.
+ */
+import { createHighlighter } from "shiki";
+let highlighterPromise = null;
+let highlighterReady = null;
+function getHighlighter() {
+    if (!highlighterPromise) {
+        highlighterPromise = createHighlighter({
+            themes: ["github-dark"],
+            langs: [
+                "bash",
+                "css",
+                "diff",
+                "dockerfile",
+                "go",
+                "html",
+                "ini",
+                "javascript",
+                "json",
+                "jsx",
+                "markdown",
+                "python",
+                "rust",
+                "shell",
+                "sql",
+                "typescript",
+                "tsx",
+                "yaml",
+            ],
+        }).then((h) => {
+            highlighterReady = h;
+            return h;
+        });
+    }
+    return highlighterPromise;
+}
+// Fire-and-forget warmup so synchronous callers can use highlightCodeSync once
+// shiki has finished loading. Safe to call multiple times.
+export function warmHighlighter() {
+    getHighlighter().catch(() => { });
+}
+function hexToAnsiFg(hex) {
+    if (!hex)
+        return "";
+    const r = parseInt(hex.slice(1, 3), 16);
+    const g = parseInt(hex.slice(3, 5), 16);
+    const b = parseInt(hex.slice(5, 7), 16);
+    return `\x1b[38;2;${r};${g};${b}m`;
+}
+function tokensToAnsi(tokens) {
+    const lines = [];
+    for (const line of tokens) {
+        let lineStr = "";
+        for (const token of line) {
+            lineStr += hexToAnsiFg(token.color) + token.content;
+        }
+        lineStr += "\x1b[0m";
+        lines.push(lineStr);
+    }
+    return lines.join("\n");
+}
+function runHighlight(h, code, lang) {
+    const loaded = h.getLoadedLanguages();
+    const safeLang = loaded.includes(lang) ? lang : "text";
+    const { tokens } = h.codeToTokens(code, { lang: safeLang, theme: "github-dark" });
+    return tokensToAnsi(tokens);
+}
+export async function highlightCode(code, lang) {
+    const h = await getHighlighter();
+    return runHighlight(h, code, lang);
+}
+// Synchronous variant that returns null when shiki hasn't finished loading yet.
+// Used by code paths that render into Ink's <Static> (which only paints once)
+// so the first frame can already carry highlighted output.
+export function highlightCodeSync(code, lang) {
+    if (!highlighterReady) {
+        // Ensure warmup is in flight for future renders.
+        warmHighlighter();
+        return null;
+    }
+    try {
+        return runHighlight(highlighterReady, code, lang);
+    }
+    catch {
+        return null;
+    }
+}
+const LANG_MAP = {
+    bash: "bash",
+    css: "css",
+    diff: "diff",
+    dockerfile: "dockerfile",
+    go: "go",
+    html: "html",
+    htm: "html",
+    ini: "ini",
+    cfg: "ini",
+    toml: "ini",
+    js: "javascript",
+    json: "json",
+    jsx: "jsx",
+    md: "markdown",
+    mdx: "markdown",
+    py: "python",
+    rs: "rust",
+    sh: "bash",
+    shell: "shell",
+    sql: "sql",
+    ts: "typescript",
+    tsx: "tsx",
+    yaml: "yaml",
+    yml: "yaml",
+    zsh: "bash",
+};
+export function inferLang(path) {
+    if (!path)
+        return "text";
+    const ext = path.split(".").pop()?.toLowerCase();
+    return (ext && LANG_MAP[ext]) || "text";
+}

package/dist/tui-ink/detect-theme.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Detect whether the host terminal is using a light or dark background so we
+ * can pick a sensible default palette when the user has theme set to "auto".
+ *
+ * Resolution order:
+ *   1. `COLORFGBG` env var — synchronous, set by VTE-family terminals (GNOME
+ *      Terminal, Konsole) and iTerm2 (when enabled). Format is "fg;bg" or
+ *      "fg;aux;bg" with each value being an ANSI color index 0–15.
+ *   2. OSC 11 query — write `ESC ] 11 ; ? BEL`, listen on stdin for a reply
+ *      shaped like `ESC ] 11 ; rgb:RRRR/GGGG/BBBB BEL`. Capped at ~150 ms so
+ *      we don't stall startup on terminals that swallow the query.
+ *   3. Fallback to "dark" — most coding terminals are dark, so this is the
+ *      least surprising default when detection fails.
+ *
+ * Must run BEFORE Ink's `render()` takes over stdin. Ink puts stdin into raw
+ * mode and consumes input itself, so the OSC 11 reply would never reach us.
+ */
+import type { ResolvedTheme } from "./theme.js";
+export declare function detectTerminalTheme(timeoutMs?: number): Promise<ResolvedTheme>;

package/dist/tui-ink/detect-theme.js

@@ -0,0 +1,123 @@
+/**
+ * Detect whether the host terminal is using a light or dark background so we
+ * can pick a sensible default palette when the user has theme set to "auto".
+ *
+ * Resolution order:
+ *   1. `COLORFGBG` env var — synchronous, set by VTE-family terminals (GNOME
+ *      Terminal, Konsole) and iTerm2 (when enabled). Format is "fg;bg" or
+ *      "fg;aux;bg" with each value being an ANSI color index 0–15.
+ *   2. OSC 11 query — write `ESC ] 11 ; ? BEL`, listen on stdin for a reply
+ *      shaped like `ESC ] 11 ; rgb:RRRR/GGGG/BBBB BEL`. Capped at ~150 ms so
+ *      we don't stall startup on terminals that swallow the query.
+ *   3. Fallback to "dark" — most coding terminals are dark, so this is the
+ *      least surprising default when detection fails.
+ *
+ * Must run BEFORE Ink's `render()` takes over stdin. Ink puts stdin into raw
+ * mode and consumes input itself, so the OSC 11 reply would never reach us.
+ */
+export async function detectTerminalTheme(timeoutMs = 150) {
+    const fromEnv = parseColorFgBg(process.env.COLORFGBG);
+    if (fromEnv)
+        return fromEnv;
+    if (process.stdout.isTTY && process.stdin.isTTY) {
+        const fromOsc = await queryOsc11(timeoutMs);
+        if (fromOsc)
+            return fromOsc;
+    }
+    return "dark";
+}
+/**
+ * COLORFGBG examples:
+ *   "15;0"     → bright-white fg on black bg → dark
+ *   "0;15"     → black fg on bright-white bg → light
+ *   "15;default;0" → some terminals add a default-bg sentinel in the middle.
+ *
+ * ANSI indices 0–6 are typically dark (black, red, green, yellow, blue,
+ * magenta, cyan); 7–15 are typically light (gray-to-white-ish). 7 itself
+ * (white) is ambiguous on some terminals but more often points to light.
+ */
+function parseColorFgBg(value) {
+    if (!value)
+        return null;
+    const parts = value.split(";");
+    const last = parts[parts.length - 1];
+    if (!last)
+        return null;
+    const bg = parseInt(last, 10);
+    if (Number.isNaN(bg))
+        return null;
+    if (bg >= 0 && bg <= 6)
+        return "dark";
+    if (bg >= 7 && bg <= 15)
+        return "light";
+    return null;
+}
+function queryOsc11(timeoutMs) {
+    return new Promise((resolve) => {
+        const stdin = process.stdin;
+        const stdout = process.stdout;
+        let settled = false;
+        const originalRaw = stdin.isRaw;
+        let buffer = "";
+        const cleanup = () => {
+            stdin.removeListener("data", onData);
+            try {
+                stdin.setRawMode(originalRaw);
+            }
+            catch {
+                // ignore — terminal may have already restored
+            }
+            stdin.pause();
+        };
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            cleanup();
+            resolve(result);
+        };
+        const onData = (chunk) => {
+            buffer += chunk.toString("utf8");
+            // Match `ESC ] 11 ; rgb:RRRR/GGGG/BBBB ST` where ST is BEL (\x07) or
+            // ESC \\. Some terminals reply with shorter hex (rgb:rr/gg/bb).
+            const match = buffer.match(/\x1b\]11;rgb:([0-9a-fA-F]+)\/([0-9a-fA-F]+)\/([0-9a-fA-F]+)(?:\x07|\x1b\\)/);
+            if (!match)
+                return;
+            const [, r, g, b] = match;
+            const lum = relativeLuminance(parseHexChannel(r), parseHexChannel(g), parseHexChannel(b));
+            finish(lum > 0.5 ? "light" : "dark");
+        };
+        try {
+            stdin.setRawMode(true);
+        }
+        catch {
+            resolve(null);
+            return;
+        }
+        stdin.resume();
+        stdin.on("data", onData);
+        const timer = setTimeout(() => finish(null), timeoutMs);
+        try {
+            stdout.write("\x1b]11;?\x07");
+        }
+        catch {
+            finish(null);
+        }
+    });
+}
+/** Normalize a hex channel string of arbitrary length to a 0–1 float. */
+function parseHexChannel(hex) {
+    const max = (1 << (hex.length * 4)) - 1;
+    return parseInt(hex, 16) / max;
+}
+/**
+ * sRGB relative luminance per WCAG 2.x. Output range is 0 (black) to 1 (white).
+ * We treat ≥ 0.5 as "light"; the actual threshold is forgiving because real
+ * terminal backgrounds tend to be near-pure black (≈0.0) or near-pure white
+ * (≈1.0).
+ */
+function relativeLuminance(r, g, b) {
+    const channel = (c) => c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+    return 0.2126 * channel(r) + 0.7152 * channel(g) + 0.0722 * channel(b);
+}

package/dist/tui-ink/display-history.d.ts

@@ -0,0 +1,38 @@
+import type { ToolResultMetadata } from "../types.js";
+export interface DisplayMessage {
+    /** Stable identity, used as Static/list key. Generated by the UI layer. */
+    key?: string;
+    role: "user" | "assistant" | "error";
+    content: string;
+    reasoning?: string;
+    toolCalls?: DisplayToolCall[];
+    parts?: DisplayMessagePart[];
+    syntheticKind?: "ui_summary";
+    hiddenCount?: number;
+}
+export type DisplayMessagePart = DisplayTextPart | DisplayToolsPart;
+export interface DisplayTextPart {
+    type: "text";
+    content: string;
+}
+export interface DisplayToolsPart {
+    type: "tools";
+    toolCalls: DisplayToolCall[];
+}
+export interface DisplayToolCall {
+    id: string;
+    name: string;
+    args: Record<string, any>;
+    result?: string;
+    isError?: boolean;
+    metadata?: ToolResultMetadata;
+    /** Set when the tool_start event was received. Used to render elapsed time. */
+    startedAt?: number;
+}
+export declare function nextDisplayMessageKey(prefix?: string): string;
+export declare function appendTextPart(parts: DisplayMessagePart[], content: string): void;
+export declare function appendToolPart(parts: DisplayMessagePart[], toolCall: DisplayToolCall): void;
+export declare function snapshotDisplayParts(parts: DisplayMessagePart[]): DisplayMessagePart[];
+export declare function contentFromParts(parts: DisplayMessagePart[]): string;
+export declare function toolCallsFromParts(parts: DisplayMessagePart[]): DisplayToolCall[];
+export declare function compactDisplayMessages(messages: DisplayMessage[]): DisplayMessage[];