praana 0.5.0

package/dist/ui/tui/app.js

@@ -0,0 +1,270 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useReducer, useState, useMemo, useCallback, useEffect, useRef } from "react";
+import { Box, Text, useApp, useInput } from "ink";
+import { PromptInput } from "./components/prompt-input.js";
+import { TurnAbortedError } from "../../turn-control.js";
+import { createInitialTranscriptState, transcriptReducer, } from "./reducer.js";
+import { createTuiTurnSink } from "./sink.js";
+import { PALETTE } from "./palette.js";
+import { TranscriptLine } from "./transcript-line.js";
+import { BusyIndicator } from "./busy-indicator.js";
+import { LogoBanner } from "./logo-banner.js";
+import { StatusBarView } from "./status-bar-view.js";
+import { ToastLine } from "./components/toast-line.js";
+export function TuiApp({ controller, initialStatus, recentLines, transcriptBootstrap = [], bootSummary, markdownRendering = true, syntaxHighlighting = true, syntaxTheme = "solarized-dark", }) {
+    const { exit } = useApp();
+    const [input, setInput] = useState("");
+    const [status, setStatus] = useState(initialStatus);
+    const [toast, setToast] = useState("");
+    const [showBusy, setShowBusy] = useState(false);
+    const [scrollOffset, setScrollOffset] = useState(0);
+    const atBottomRef = useRef(true);
+    const SCROLL_WINDOW = 30;
+    const toastTimerRef = useRef(null);
+    const inputHistoryRef = useRef([]);
+    const historyIndexRef = useRef(-1);
+    const showToast = useCallback((message) => {
+        if (toastTimerRef.current)
+            clearTimeout(toastTimerRef.current);
+        setToast(message);
+        toastTimerRef.current = setTimeout(() => {
+            setToast("");
+            toastTimerRef.current = null;
+        }, 4000);
+    }, []);
+    const bootLenRef = useRef(0);
+    const [transcript, dispatch] = useReducer(transcriptReducer, undefined, () => {
+        const bootstrap = [];
+        let nextId = 1;
+        const add = (role, text) => {
+            bootstrap.push({ id: `boot-${nextId++}`, role, text, group: 0 });
+        };
+        if (recentLines.length > 0) {
+            for (const line of recentLines)
+                add("system", line);
+        }
+        if (transcriptBootstrap.length > 0) {
+            return {
+                ...createInitialTranscriptState(),
+                completed: transcriptBootstrap,
+                nextId: transcriptBootstrap.length + 1,
+                groupCounter: transcriptBootstrap.reduce((max, e) => Math.max(max, e.group), 0),
+            };
+        }
+        bootLenRef.current = bootstrap.length;
+        return {
+            ...createInitialTranscriptState(),
+            completed: bootstrap,
+            nextId,
+        };
+    });
+    const sink = useMemo(() => createTuiTurnSink(dispatch), []);
+    const refreshStatus = useCallback(() => {
+        setStatus(controller.getStatusBarInput());
+    }, [controller]);
+    const showLogo = transcriptBootstrap.length === 0 && transcript.completed.length <= bootLenRef.current;
+    /* ── Scrolling window (entry-based — preserves terminal scrollback) ── */
+    const totalCompleted = transcript.completed.length;
+    const showScrolling = totalCompleted > SCROLL_WINDOW;
+    const visibleSlice = useMemo(() => {
+        if (!showScrolling) {
+            return { entries: transcript.completed, startIndex: 0 };
+        }
+        const end = Math.max(0, totalCompleted - scrollOffset);
+        const start = Math.max(0, end - SCROLL_WINDOW);
+        return { entries: transcript.completed.slice(start, end), startIndex: start };
+    }, [transcript.completed, scrollOffset, showScrolling, totalCompleted]);
+    const visibleEntries = visibleSlice.entries;
+    const liveAssistantEmpty = transcript.live?.role === "assistant" && !transcript.live.text.trim();
+    useEffect(() => {
+        if (totalCompleted > 0 && atBottomRef.current) {
+            setScrollOffset(0);
+        }
+    }, [totalCompleted]);
+    useEffect(() => {
+        if (!transcript.busy) {
+            setShowBusy(false);
+            return;
+        }
+        const waitingForOutput = !transcript.live ||
+            (transcript.live.role === "assistant" && !transcript.live.text.trim());
+        if (!waitingForOutput) {
+            setShowBusy(false);
+            return;
+        }
+        const t = setTimeout(() => setShowBusy(true), 450);
+        return () => {
+            clearTimeout(t);
+            setShowBusy(false);
+        };
+    }, [transcript.busy, transcript.live]);
+    const scrollUp = useCallback((amount) => {
+        setScrollOffset((prev) => {
+            const maxOffset = Math.max(0, totalCompleted - SCROLL_WINDOW);
+            const next = Math.min(prev + amount, maxOffset);
+            atBottomRef.current = next === 0;
+            return next;
+        });
+    }, [totalCompleted]);
+    const scrollDown = useCallback((amount) => {
+        setScrollOffset((prev) => {
+            const next = Math.max(0, prev - amount);
+            atBottomRef.current = next === 0;
+            return next;
+        });
+    }, []);
+    const scrollToBottom = useCallback(() => {
+        setScrollOffset(0);
+        atBottomRef.current = true;
+    }, []);
+    const scrollToTop = useCallback(() => {
+        const maxOffset = Math.max(0, totalCompleted - SCROLL_WINDOW);
+        setScrollOffset(maxOffset);
+        atBottomRef.current = false;
+    }, [totalCompleted]);
+    /* Busy ref avoids recreating handleSubmit on every transcript change */
+    const busyRef = useRef(transcript.busy);
+    busyRef.current = transcript.busy;
+    const handleSubmit = useCallback(async (value) => {
+        const trimmed = value.trim();
+        setInput("");
+        if (!trimmed || busyRef.current)
+            return;
+        if (trimmed.startsWith("/")) {
+            const result = await controller.executeSlashCommand(trimmed);
+            if (result.lines.length > 0) {
+                if (result.display === "toast") {
+                    showToast(result.lines.join(" "));
+                }
+                else {
+                    dispatch({ type: "system_lines", lines: result.lines });
+                }
+            }
+            if (result.action === "refresh_status")
+                refreshStatus();
+            if (result.action === "exit")
+                exit();
+            return;
+        }
+        inputHistoryRef.current = [
+            trimmed,
+            ...inputHistoryRef.current.filter((h) => h !== trimmed),
+        ].slice(0, 50);
+        historyIndexRef.current = -1;
+        dispatch({ type: "user_message", text: trimmed });
+        dispatch({ type: "set_busy", busy: true });
+        const turnStartedAt = Date.now();
+        try {
+            await controller.runUserTurn(trimmed, sink);
+            sink.flushText?.();
+            dispatch({ type: "assistant_complete" });
+            const bar = controller.getStatusBarInput();
+            dispatch({
+                type: "turn_footer",
+                model: bar.model,
+                durationMs: Date.now() - turnStartedAt,
+                stats: sink.consumeTurnStats?.() ?? undefined,
+            });
+        }
+        catch (err) {
+            if (err instanceof TurnAbortedError) {
+                showToast("Turn interrupted");
+                const bar = controller.getStatusBarInput();
+                dispatch({
+                    type: "turn_footer",
+                    model: bar.model,
+                    durationMs: Date.now() - turnStartedAt,
+                    stats: sink.consumeTurnStats?.() ?? undefined,
+                });
+            }
+            else {
+                const message = err.message;
+                controller.session.getLogger().error("Turn failed", {
+                    code: "TURN_FAILED",
+                    cause: err,
+                });
+                dispatch({ type: "error", message });
+            }
+        }
+        finally {
+            dispatch({ type: "set_busy", busy: false });
+            refreshStatus();
+        }
+    }, [controller, sink, refreshStatus, exit, showToast]);
+    const handleNavigationKey = useCallback((key, input) => {
+        if (transcript.busy && key.escape) {
+            controller.abortTurn();
+            return true;
+        }
+        return false;
+    }, [transcript.busy, controller, showToast]);
+    useInput((input, key) => {
+        if (transcript.busy && key.escape)
+            return;
+        if (!showScrolling)
+            return;
+        if (key.pageUp) {
+            scrollUp(Math.floor(SCROLL_WINDOW * 0.4));
+        }
+        else if (key.pageDown) {
+            scrollDown(Math.floor(SCROLL_WINDOW * 0.4));
+        }
+        else if (input === "" && key.upArrow) {
+            scrollUp(1);
+        }
+        else if (input === "" && key.downArrow) {
+            scrollDown(1);
+        }
+        else if (key.home) {
+            scrollToTop();
+        }
+        else if (key.end) {
+            scrollToBottom();
+        }
+    });
+    useEffect(() => {
+        const onSigint = () => {
+            controller.handleUserInterrupt(() => {
+                showToast("Use /exit to save and quit.");
+            });
+        };
+        process.on("SIGINT", onSigint);
+        return () => {
+            process.removeListener("SIGINT", onSigint);
+        };
+    }, [controller, showToast]);
+    useEffect(() => {
+        return () => {
+            if (toastTimerRef.current)
+                clearTimeout(toastTimerRef.current);
+        };
+    }, []);
+    return (_jsxs(Box, { flexDirection: "column", height: "100%", padding: 1, gap: 1, children: [showLogo && _jsx(LogoBanner, { bootSummary: bootSummary }), _jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [showScrolling && scrollOffset > 0 && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: PALETTE.muted, dimColor: true, children: "\u2191 showing older messages (PgUp/PgDn to scroll, End for latest)" }) })), visibleEntries.map((entry, index) => (_jsx(TranscriptLine, { entry: entry, prevRole: index > 0
+                            ? visibleEntries[index - 1]?.role
+                            : visibleSlice.startIndex > 0
+                                ? transcript.completed[visibleSlice.startIndex - 1]?.role
+                                : undefined, showThinking: status.thinking, markdownRendering: markdownRendering, syntaxHighlighting: syntaxHighlighting, syntaxTheme: syntaxTheme }, entry.id))), transcript.live ? (_jsxs(_Fragment, { children: [_jsx(TranscriptLine, { entry: transcript.live, prevRole: visibleEntries.length > 0
+                                    ? visibleEntries[visibleEntries.length - 1]?.role
+                                    : undefined, live: true, showThinking: status.thinking, markdownRendering: markdownRendering, syntaxHighlighting: syntaxHighlighting, syntaxTheme: syntaxTheme }), transcript.busy && liveAssistantEmpty && showBusy ? (_jsx(BusyIndicator, {})) : null] })) : transcript.busy && showBusy ? (_jsx(BusyIndicator, {})) : null] }), toast ? _jsx(ToastLine, { message: toast }) : null, _jsxs(Box, { padding: 1, gap: 1, children: [_jsx(Text, { color: PALETTE.assistant, children: "\u276F " }), _jsx(PromptInput, { value: input, onChange: setInput, onSubmit: handleSubmit, placeholder: transcript.busy ? "running…" : "message or /command", onEmptyShortcut: (key) => {
+                            if (key !== "t" || transcript.busy)
+                                return false;
+                            controller.showThinking = !controller.showThinking;
+                            refreshStatus();
+                            showToast(controller.showThinking ? "Thinking enabled." : "Thinking disabled.");
+                            return true;
+                        }, onNavigationKey: handleNavigationKey, onHistoryPrev: () => {
+                            const history = inputHistoryRef.current;
+                            if (history.length === 0)
+                                return null;
+                            const nextIndex = Math.min(historyIndexRef.current + 1, history.length - 1);
+                            historyIndexRef.current = nextIndex;
+                            return history[nextIndex] ?? null;
+                        }, onHistoryNext: () => {
+                            if (historyIndexRef.current <= 0) {
+                                historyIndexRef.current = -1;
+                                return "";
+                            }
+                            historyIndexRef.current -= 1;
+                            return inputHistoryRef.current[historyIndexRef.current] ?? "";
+                        } })] }), _jsx(StatusBarView, { status: status })] }));
+}

package/dist/ui/tui/busy-indicator.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare function BusyIndicator(): React.JSX.Element;

package/dist/ui/tui/busy-indicator.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useState, useEffect } from "react";
+import { Box, Text } from "ink";
+import { PALETTE } from "./palette.js";
+export function BusyIndicator() {
+    const [frame, setFrame] = useState(0);
+    useEffect(() => {
+        const t = setInterval(() => setFrame((f) => (f + 1) % 4), 400);
+        return () => clearInterval(t);
+    }, []);
+    const dots = [".  ", ".. ", "...", " .."][frame] ?? "...";
+    return (_jsx(Box, { children: _jsx(Text, { color: PALETTE.thinking, dimColor: true, children: dots }) }));
+}

package/dist/ui/tui/components/gutter-rule.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+/** Full-width horizontal rule between turns. */
+export declare function GutterRule({ marginTop }: {
+    marginTop?: boolean;
+}): React.JSX.Element;

package/dist/ui/tui/components/gutter-rule.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { PALETTE } from "../palette.js";
+import { getTerminalWidth } from "../terminal-width.js";
+/** Full-width horizontal rule between turns. */
+export function GutterRule({ marginTop }) {
+    const width = Math.max(20, getTerminalWidth() - 2);
+    return (_jsx(Box, { marginTop: marginTop ? 1 : 0, children: _jsx(Text, { color: PALETTE.gutter, children: "─".repeat(width) }) }));
+}

package/dist/ui/tui/components/inline-tool-row.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+export interface InlineToolRowProps {
+    icon: string;
+    label: string;
+    pending?: string;
+    complete?: boolean;
+    isError?: boolean;
+    marginTop: boolean;
+}
+export declare function InlineToolRow({ icon, label, pending, complete, isError, marginTop, }: InlineToolRowProps): React.JSX.Element;

package/dist/ui/tui/components/inline-tool-row.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { PALETTE } from "../palette.js";
+const ICON_WIDTH = 2;
+export function InlineToolRow({ icon, label, pending, complete = true, isError = false, marginTop, }) {
+    const color = isError ? PALETTE.error : complete ? PALETTE.muted : PALETTE.tool;
+    return (_jsx(Box, { flexDirection: "column", marginTop: marginTop ? 1 : 0, paddingLeft: 1, children: complete ? (_jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { width: ICON_WIDTH, children: _jsx(Text, { color: isError ? PALETTE.error : PALETTE.tool, children: icon }) }), _jsx(Text, { wrap: "wrap", color: color, dimColor: !isError, children: label })] })) : (_jsxs(Text, { wrap: "wrap", color: PALETTE.muted, dimColor: true, children: ["~ ", pending ?? "Running…"] })) }));
+}

package/dist/ui/tui/components/prompt-input.d.ts

@@ -0,0 +1,20 @@
+import React from "react";
+import { type Key } from "ink";
+export interface PromptInputProps {
+    value: string;
+    onChange: (value: string) => void;
+    onSubmit: (value: string) => void;
+    placeholder?: string;
+    focus?: boolean;
+    /** Called for single-char keys when the input is empty. Return true to consume. */
+    onEmptyShortcut?: (key: string) => boolean;
+    /** Scroll / escape keys — PromptInput owns stdin so these must be routed here. */
+    onNavigationKey?: (key: Key, input: string) => boolean;
+    onHistoryPrev?: () => string | null;
+    onHistoryNext?: () => string | null;
+}
+/**
+ * Prompt line input — ink-text-input fork with empty-input shortcut support.
+ * Ink TextInput captures all keystrokes; shortcuts like `t` must be handled here.
+ */
+export declare function PromptInput({ value: originalValue, placeholder, focus, onChange, onSubmit, onEmptyShortcut, onNavigationKey, onHistoryPrev, onHistoryNext, }: PromptInputProps): React.JSX.Element;

package/dist/ui/tui/components/prompt-input.js

@@ -0,0 +1,120 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useState, useEffect } from "react";
+import { Text, useInput } from "ink";
+import chalk from "chalk";
+/**
+ * Prompt line input — ink-text-input fork with empty-input shortcut support.
+ * Ink TextInput captures all keystrokes; shortcuts like `t` must be handled here.
+ */
+export function PromptInput({ value: originalValue, placeholder = "", focus = true, onChange, onSubmit, onEmptyShortcut, onNavigationKey, onHistoryPrev, onHistoryNext, }) {
+    const [state, setState] = useState({
+        cursorOffset: originalValue.length,
+        cursorWidth: 0,
+    });
+    const { cursorOffset, cursorWidth } = state;
+    useEffect(() => {
+        setState((previousState) => {
+            if (!focus)
+                return previousState;
+            const newValue = originalValue;
+            if (previousState.cursorOffset > newValue.length - 1) {
+                return { cursorOffset: newValue.length, cursorWidth: 0 };
+            }
+            return previousState;
+        });
+    }, [originalValue, focus]);
+    const cursorActualWidth = 0;
+    const value = originalValue;
+    let renderedValue = value;
+    let renderedPlaceholder = placeholder ? chalk.grey(placeholder) : undefined;
+    if (focus) {
+        renderedPlaceholder =
+            placeholder.length > 0
+                ? chalk.inverse(placeholder[0]) + chalk.grey(placeholder.slice(1))
+                : chalk.inverse(" ");
+        renderedValue = value.length > 0 ? "" : chalk.inverse(" ");
+        let i = 0;
+        for (const char of value) {
+            renderedValue +=
+                i >= cursorOffset - cursorActualWidth && i <= cursorOffset
+                    ? chalk.inverse(char)
+                    : char;
+            i++;
+        }
+        if (value.length > 0 && cursorOffset === value.length) {
+            renderedValue += chalk.inverse(" ");
+        }
+    }
+    useInput((input, key) => {
+        if (onNavigationKey?.(key, input)) {
+            return;
+        }
+        if (key.upArrow && onHistoryPrev) {
+            const prev = onHistoryPrev();
+            if (prev !== null) {
+                onChange(prev);
+                setState({ cursorOffset: prev.length, cursorWidth: 0 });
+                return;
+            }
+        }
+        if (key.downArrow && onHistoryNext) {
+            const next = onHistoryNext() ?? "";
+            onChange(next);
+            setState({ cursorOffset: next.length, cursorWidth: 0 });
+            return;
+        }
+        if (key.upArrow ||
+            key.downArrow ||
+            (key.ctrl && input === "c") ||
+            key.tab ||
+            (key.shift && key.tab)) {
+            return;
+        }
+        if (key.return) {
+            onSubmit?.(originalValue);
+            return;
+        }
+        if (!key.ctrl &&
+            !key.meta &&
+            input.length === 1 &&
+            originalValue.length === 0 &&
+            onEmptyShortcut?.(input)) {
+            return;
+        }
+        let nextCursorOffset = cursorOffset;
+        let nextValue = originalValue;
+        let nextCursorWidth = 0;
+        if (key.leftArrow) {
+            nextCursorOffset--;
+        }
+        else if (key.rightArrow) {
+            nextCursorOffset++;
+        }
+        else if (key.backspace || key.delete) {
+            if (cursorOffset > 0) {
+                nextValue =
+                    originalValue.slice(0, cursorOffset - 1) +
+                        originalValue.slice(cursorOffset);
+                nextCursorOffset--;
+            }
+        }
+        else if (input) {
+            nextValue =
+                originalValue.slice(0, cursorOffset) +
+                    input +
+                    originalValue.slice(cursorOffset);
+            nextCursorOffset += input.length;
+            if (input.length > 1)
+                nextCursorWidth = input.length;
+        }
+        nextCursorOffset = Math.max(0, Math.min(nextCursorOffset, nextValue.length));
+        setState({ cursorOffset: nextCursorOffset, cursorWidth: nextCursorWidth });
+        if (nextValue !== originalValue)
+            onChange(nextValue);
+    }, { isActive: focus });
+    return (_jsx(Text, { children: placeholder
+            ? value.length > 0
+                ? renderedValue
+                : renderedPlaceholder
+            : renderedValue }));
+}

package/dist/ui/tui/components/system-line.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+export declare function SystemLine({ text, marginTop }: {
+    text: string;
+    marginTop: boolean;
+}): React.JSX.Element;

package/dist/ui/tui/components/system-line.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { PALETTE } from "../palette.js";
+export function SystemLine({ text, marginTop }) {
+    return (_jsx(Box, { marginTop: marginTop ? 1 : 0, paddingLeft: 1, children: _jsx(Text, { wrap: "wrap", color: PALETTE.system, dimColor: true, children: text }) }));
+}

package/dist/ui/tui/components/thinking-block.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+export interface ThinkingBlockProps {
+    text: string;
+    live?: boolean;
+    showBody: boolean;
+    durationMs?: number;
+    markdownRendering?: boolean;
+    syntaxHighlighting?: boolean;
+    syntaxTheme?: string;
+}
+export declare function ThinkingBlock({ text, live, showBody, durationMs, }: ThinkingBlockProps): React.JSX.Element | null;

package/dist/ui/tui/components/thinking-block.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { PALETTE } from "../palette.js";
+import { formatThinkingDuration, reasoningSummary, } from "../reasoning-summary.js";
+function thinkingTextProps(extra) {
+    return {
+        color: PALETTE.thinking,
+        dimColor: true,
+        italic: true,
+        ...extra,
+    };
+}
+function ThinkingBody({ bodyText }) {
+    return (_jsx(Text, { wrap: "wrap", ...thinkingTextProps(), children: bodyText }));
+}
+export function ThinkingBlock({ text, live = false, showBody, durationMs, }) {
+    const plain = text.trim();
+    const duration = durationMs !== undefined ? formatThinkingDuration(durationMs) : undefined;
+    if (!showBody) {
+        return (_jsx(Box, { flexDirection: "column", marginTop: 1, marginBottom: 1, paddingLeft: 1, children: _jsx(Text, { ...thinkingTextProps({ wrap: "wrap" }), children: live ? "Thinking…" : duration ? `Thought · ${duration}` : "Thought" }) }));
+    }
+    if (!plain && live) {
+        return (_jsx(Box, { flexDirection: "column", marginTop: 1, marginBottom: 1, paddingLeft: 1, children: _jsx(Text, { ...thinkingTextProps({ wrap: "wrap" }), children: "Thinking\u2026" }) }));
+    }
+    if (!plain)
+        return null;
+    const { title, body } = reasoningSummary(plain);
+    const bodyText = body || plain;
+    const hasBody = Boolean(bodyText.trim());
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, marginBottom: 1, paddingLeft: 1, children: [title ? (_jsxs(Text, { ...thinkingTextProps({ wrap: "wrap" }), children: [live ? "Thinking" : "Thought", ": ", title, !live && duration ? ` · ${duration}` : live ? " …" : ""] })) : !live && duration ? (_jsxs(Text, { ...thinkingTextProps({ wrap: "wrap" }), children: ["Thought \u00B7 ", duration] })) : null, hasBody ? (_jsx(Box, { paddingLeft: title ? 2 : 0, marginTop: title ? 1 : 0, children: _jsx(ThinkingBody, { bodyText: bodyText }) })) : null] }));
+}

package/dist/ui/tui/components/toast-line.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+export declare function ToastLine({ message }: {
+    message: string;
+}): React.JSX.Element | null;

package/dist/ui/tui/components/toast-line.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { PALETTE } from "../palette.js";
+export function ToastLine({ message }) {
+    if (!message)
+        return null;
+    return (_jsx(Box, { paddingLeft: 1, children: _jsx(Text, { color: PALETTE.tool, dimColor: true, children: message }) }));
+}

package/dist/ui/tui/components/tool-result-line.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+export declare function ToolResultLine({ summary, isError, }: {
+    summary: string;
+    isError?: boolean;
+}): React.JSX.Element;

package/dist/ui/tui/components/tool-result-line.js

@@ -0,0 +1,6 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { PALETTE } from "../palette.js";
+export function ToolResultLine({ summary, isError = false, }) {
+    return (_jsx(Box, { paddingLeft: 3, children: _jsxs(Text, { wrap: "wrap", color: isError ? PALETTE.error : PALETTE.muted, dimColor: !isError, children: ["\u21B3 ", summary] }) }));
+}

package/dist/ui/tui/components/turn-footer.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+export declare function TurnFooter({ text, marginTop }: {
+    text: string;
+    marginTop?: boolean;
+}): React.JSX.Element;

package/dist/ui/tui/components/turn-footer.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { PALETTE } from "../palette.js";
+import { GutterRule } from "./gutter-rule.js";
+export function TurnFooter({ text, marginTop }) {
+    return (_jsxs(Box, { flexDirection: "column", marginTop: marginTop ? 1 : 0, paddingTop: 1, children: [_jsx(GutterRule, {}), _jsx(Box, { paddingLeft: 1, marginTop: 0, children: _jsx(Text, { color: PALETTE.muted, dimColor: true, children: text }) })] }));
+}

package/dist/ui/tui/components/user-block.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+export declare function UserBlock({ text, marginTop, showTurnBreak, }: {
+    text: string;
+    marginTop: boolean;
+    showTurnBreak?: boolean;
+}): React.JSX.Element;

package/dist/ui/tui/components/user-block.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { PALETTE } from "../palette.js";
+export function UserBlock({ text, marginTop, showTurnBreak, }) {
+    return (_jsx(Box, { flexDirection: "column", marginTop: showTurnBreak || marginTop ? 1 : 0, borderStyle: "single", borderColor: PALETTE.user, borderLeft: true, borderTop: false, borderRight: false, borderBottom: false, paddingX: 1, paddingY: 1, children: _jsx(Text, { wrap: "wrap", color: PALETTE.user, children: text || " " }) }));
+}

package/dist/ui/tui/logo-banner.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+export interface LogoBannerProps {
+    bootSummary?: string;
+}
+export declare function LogoBanner({ bootSummary }: LogoBannerProps): React.JSX.Element;

package/dist/ui/tui/logo-banner.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { PALETTE } from "./palette.js";
+import { APP_VERSION } from "../../app-banner.js";
+export function LogoBanner({ bootSummary }) {
+    const title = `▲ PRAANA ${APP_VERSION}`;
+    return (_jsx(Box, { marginBottom: 1, children: _jsxs(Box, { flexDirection: "column", paddingX: 2, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: PALETTE.assistant, children: title }) }), bootSummary ? (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: PALETTE.muted, dimColor: true, children: bootSummary }) })) : null, _jsx(Text, { color: PALETTE.text, children: "Terminal coding agent with adaptive context and persistent memory." }), _jsx(Text, { color: PALETTE.text, children: "I remember decisions across sessions and auto-compress stale context." }), _jsx(Box, { marginBottom: 1, marginTop: 2, children: _jsx(Text, { color: PALETTE.assistant, children: "Quick tips:" }) }), _jsxs(Box, { children: [_jsx(Box, { marginLeft: 2, marginRight: 1, children: _jsx(Text, { children: "*" }) }), _jsx(Text, { children: "Say what you want \u2014 I'll read code, run shell commands, make edits" })] }), _jsxs(Box, { children: [_jsx(Box, { marginLeft: 2, marginRight: 1, children: _jsx(Text, { children: "*" }) }), _jsx(Text, { children: "/help   \u2014 all slash commands" })] }), _jsxs(Box, { children: [_jsx(Box, { marginLeft: 2, marginRight: 1, children: _jsx(Text, { children: "*" }) }), _jsx(Text, { children: "/stats  \u2014 what I know and remember" })] }), _jsxs(Box, { children: [_jsx(Box, { marginLeft: 2, marginRight: 1, children: _jsx(Text, { children: "*" }) }), _jsx(Text, { children: "/recall \u2014 search my persistent memory" })] }), _jsxs(Box, { children: [_jsx(Box, { marginLeft: 2, marginRight: 1, children: _jsx(Text, { children: "*" }) }), _jsx(Text, { children: "/thinking on|off \u2014 show or hide reasoning text" })] }), _jsxs(Box, { children: [_jsx(Box, { marginLeft: 2, marginRight: 1, children: _jsx(Text, { children: "*" }) }), _jsx(Text, { children: "Esc \u2014 interrupt a running turn" })] })] }) }));
+}

package/dist/ui/tui/markdown-render.d.ts

@@ -0,0 +1,16 @@
+import React from "react";
+import { type Token } from "marked";
+interface MarkdownRenderProps {
+    text: string;
+    syntaxHighlighting?: boolean;
+    syntaxTheme?: string;
+}
+/** Flatten inline tokens to plain text (used in tests). */
+export declare function plainTextFromInlineTokens(tokens: (Token | string)[]): string;
+export declare function extractCellText(cell: {
+    text: string;
+    tokens: (Token | string)[];
+}): string;
+export declare function computeColWidths(headerTexts: string[], bodyTexts: string[][], terminalWidth?: number): number[];
+export declare const MarkdownRender: React.NamedExoticComponent<MarkdownRenderProps>;
+export {};