praana 0.5.0

package/dist/ui/tui/markdown-render.js

@@ -0,0 +1,218 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import React from "react";
+import { Text, Box } from "ink";
+import { marked } from "marked";
+import { highlight as cliHighlight } from "cli-highlight";
+import stripAnsi from "strip-ansi";
+import { PALETTE } from "./palette.js";
+import { getTerminalWidth } from "./terminal-width.js";
+const HEADING_STYLES = {
+    1: { bold: true, color: PALETTE.assistant, underline: true },
+    2: { bold: true, color: PALETTE.assistant },
+    3: { bold: true, color: PALETTE.user },
+    4: { bold: true, color: PALETTE.muted },
+    5: { bold: true, color: PALETTE.muted },
+    6: { bold: true, color: PALETTE.muted },
+};
+function InlineToken({ token }) {
+    if (typeof token === "string") {
+        return _jsx(Text, { children: token });
+    }
+    switch (token.type) {
+        case "text": {
+            const t = token;
+            if (t.tokens && t.tokens.length > 0) {
+                return _jsx(InlineTokens, { tokens: t.tokens });
+            }
+            return _jsx(Text, { children: t.text });
+        }
+        case "strong": {
+            const t = token;
+            return (_jsx(Text, { bold: true, children: t.tokens?.length ? _jsx(InlineTokens, { tokens: t.tokens }) : t.text }));
+        }
+        case "em": {
+            const t = token;
+            return (_jsx(Text, { italic: true, children: t.tokens?.length ? _jsx(InlineTokens, { tokens: t.tokens }) : t.text }));
+        }
+        case "del": {
+            const t = token;
+            return (_jsx(Text, { strikethrough: true, dimColor: true, children: t.tokens?.length ? _jsx(InlineTokens, { tokens: t.tokens }) : t.text }));
+        }
+        case "codespan":
+            return (_jsxs(Text, { color: PALETTE.tool, backgroundColor: "#2d2d2d", children: [" ", token.text, " "] }));
+        case "link": {
+            const t = token;
+            const label = t.text || t.href;
+            const showHref = t.href && t.href !== t.text;
+            return (_jsxs(Text, { color: PALETTE.assistant, underline: true, children: [label, showHref ? (_jsx(Text, { dimColor: true, children: ` (${t.href})` })) : null] }));
+        }
+        case "br":
+            return _jsx(Text, { children: "\n" });
+        case "escape":
+            return _jsx(Text, { children: token.text });
+        default:
+            return _jsx(Text, { children: token.raw ?? "" });
+    }
+}
+function InlineTokens({ tokens }) {
+    return (_jsx(_Fragment, { children: tokens.map((token, i) => (_jsx(InlineToken, { token: token }, i))) }));
+}
+function MarkdownList({ token, depth = 0, }) {
+    return (_jsx(Box, { flexDirection: "column", marginBottom: depth === 0 ? 1 : 0, paddingLeft: depth > 0 ? 2 : 2, children: token.items.map((item, i) => {
+            const bullet = token.ordered ? `${i + 1}. ` : "• ";
+            return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: PALETTE.gutter, children: bullet }), _jsx(Text, { wrap: "wrap", children: _jsx(ListItemTokens, { tokens: item.tokens, depth: depth }) })] }, i));
+        }) }));
+}
+function ListItemTokens({ tokens, depth = 0, }) {
+    return (_jsx(_Fragment, { children: tokens.map((token, i) => {
+            if (token.type === "space") {
+                return _jsx(Text, { children: "\n" }, i);
+            }
+            if (token.type === "paragraph") {
+                const p = token;
+                return (_jsx(Text, { wrap: "wrap", children: _jsx(InlineTokens, { tokens: p.tokens }) }, i));
+            }
+            if (token.type === "list") {
+                return (_jsx(MarkdownList, { token: token, depth: depth + 1 }, i));
+            }
+            return _jsx(InlineToken, { token: token }, i);
+        }) }));
+}
+/** Flatten inline tokens to plain text (used in tests). */
+export function plainTextFromInlineTokens(tokens) {
+    return tokens
+        .map((token) => {
+        if (typeof token === "string")
+            return token;
+        switch (token.type) {
+            case "text": {
+                const t = token;
+                if (t.tokens?.length)
+                    return plainTextFromInlineTokens(t.tokens);
+                return t.text ?? t.raw ?? "";
+            }
+            case "strong":
+                return token.text;
+            case "em":
+                return token.text;
+            case "del": {
+                const t = token;
+                if (t.tokens?.length)
+                    return plainTextFromInlineTokens(t.tokens);
+                return t.text ?? "";
+            }
+            case "codespan":
+                return token.text;
+            case "link":
+                return token.text;
+            case "br":
+                return "\n";
+            case "escape":
+                return token.text;
+            default:
+                return token.raw ?? "";
+        }
+    })
+        .join("");
+}
+export function extractCellText(cell) {
+    if (cell.tokens && cell.tokens.length > 0) {
+        return plainTextFromInlineTokens(cell.tokens);
+    }
+    return cell.text ?? "";
+}
+function truncatePlain(text, width) {
+    if (text.length <= width)
+        return text;
+    return width <= 1 ? "…" : `${text.slice(0, width - 1)}…`;
+}
+function TableCellContent({ cell, width, bold, }) {
+    const plain = extractCellText(cell);
+    const truncated = plain.length > width;
+    if (truncated) {
+        return (_jsx(Text, { bold: bold, wrap: "truncate", children: truncatePlain(plain, width) }));
+    }
+    const pad = " ".repeat(Math.max(0, width - plain.length));
+    return (_jsxs(Text, { bold: bold, children: [_jsx(InlineTokens, { tokens: cell.tokens }), pad] }));
+}
+function TableRow({ cells, colWidths, header, }) {
+    return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: header ? PALETTE.assistant : undefined, bold: header, children: "\u2502" }), cells.map((cell, i) => (_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { children: " " }), _jsx(TableCellContent, { cell: cell, width: colWidths[i], bold: header }), _jsx(Text, { children: " " }), _jsx(Text, { color: PALETTE.gutter, children: "\u2502" })] }, i)))] }));
+}
+export function computeColWidths(headerTexts, bodyTexts, terminalWidth = getTerminalWidth()) {
+    const colCount = headerTexts.length;
+    const gutter = 2 + colCount * 3;
+    const perColMax = Math.max(8, Math.min(48, Math.floor((terminalWidth - gutter) / Math.max(colCount, 1))));
+    return Array.from({ length: colCount }, (_, ci) => {
+        const headerLen = stripAnsi(headerTexts[ci] ?? "").length;
+        const maxBodyLen = bodyTexts.reduce((max, row) => Math.max(max, stripAnsi(row[ci] ?? "").length), 0);
+        return Math.min(Math.max(headerLen, maxBodyLen, 4), perColMax);
+    });
+}
+function renderCodeBlock(token, syntaxHighlighting, syntaxTheme) {
+    const code = token.text.replace(/\n$/, "");
+    let highlighted;
+    if (syntaxHighlighting && token.lang) {
+        try {
+            highlighted = cliHighlight(code, { language: token.lang, theme: syntaxTheme, ignoreIllegals: true });
+        }
+        catch {
+            highlighted = code;
+        }
+    }
+    else {
+        highlighted = code;
+    }
+    const lines = highlighted.split("\n");
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [token.lang && (_jsxs(Text, { color: PALETTE.muted, dimColor: true, children: ["  ", token.lang] })), _jsx(Box, { flexDirection: "column", backgroundColor: "#1e1e1e", paddingX: 1, children: lines.map((line, i) => (_jsx(Text, { children: line || " " }, i))) })] }));
+}
+function MarkdownBlock({ token, syntaxHighlighting, syntaxTheme }) {
+    switch (token.type) {
+        case "heading": {
+            const t = token;
+            const style = HEADING_STYLES[t.depth] ?? HEADING_STYLES[3];
+            return (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: style.bold, color: style.color, underline: style.underline, children: _jsx(InlineTokens, { tokens: t.tokens }) }) }));
+        }
+        case "paragraph": {
+            const t = token;
+            return (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { wrap: "wrap", children: _jsx(InlineTokens, { tokens: t.tokens }) }) }));
+        }
+        case "code": {
+            const t = token;
+            return renderCodeBlock(t, syntaxHighlighting, syntaxTheme);
+        }
+        case "list":
+            return _jsx(MarkdownList, { token: token });
+        case "table": {
+            const t = token;
+            const headerTexts = t.header.map(extractCellText);
+            const bodyTexts = t.rows.map((row) => row.map(extractCellText));
+            const colWidths = computeColWidths(headerTexts, bodyTexts);
+            const separator = colWidths.map((w) => "─".repeat(w));
+            return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(TableRow, { cells: t.header, colWidths: colWidths, header: true }), _jsxs(Text, { color: PALETTE.gutter, children: ["\u251C\u2500", separator.join("─┼─"), "\u2500\u2524"] }), t.rows.map((row, i) => (_jsx(TableRow, { cells: row, colWidths: colWidths }, i)))] }));
+        }
+        case "blockquote": {
+            const t = token;
+            return (_jsx(Box, { flexDirection: "column", marginBottom: 1, paddingLeft: 2, children: t.tokens.map((tk, i) => {
+                    if (tk.type === "paragraph") {
+                        const p = tk;
+                        return (_jsx(Text, { wrap: "wrap", color: PALETTE.muted, italic: true, children: _jsx(InlineTokens, { tokens: p.tokens }) }, i));
+                    }
+                    return (_jsx(Text, { color: PALETTE.muted, children: typeof tk === "string" ? tk : tk.raw ?? "" }, i));
+                }) }));
+        }
+        case "hr":
+            return (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: PALETTE.gutter, children: "─".repeat(Math.max(20, getTerminalWidth() - 4)) }) }));
+        case "html":
+            return _jsx(Text, { children: token.raw });
+        case "space":
+            return null;
+        default:
+            return _jsx(Text, { children: token.raw ?? "" });
+    }
+}
+export const MarkdownRender = React.memo(function MarkdownRender({ text, syntaxHighlighting = true, syntaxTheme = "solarized-dark", }) {
+    if (!text)
+        return _jsx(Text, { children: " " });
+    const tokens = marked.lexer(text);
+    return (_jsx(Box, { flexDirection: "column", children: tokens.map((token, i) => (_jsx(MarkdownBlock, { token: token, syntaxHighlighting: syntaxHighlighting, syntaxTheme: syntaxTheme }, i))) }));
+});

package/dist/ui/tui/palette.d.ts

@@ -0,0 +1,12 @@
+export declare const PALETTE: {
+    user: string;
+    assistant: string;
+    thinking: string;
+    tool: string;
+    system: string;
+    border: string;
+    gutter: string;
+    muted: string;
+    error: string;
+    text: string;
+};

package/dist/ui/tui/palette.js

@@ -0,0 +1,13 @@
+/* Colour palette for the ARIA TUI */
+export const PALETTE = {
+    user: "#B7E4C7", // green-600
+    assistant: "#fbbf24", // amber-400
+    thinking: "#6b7280", // gray-500
+    tool: "#f59e0b", // amber-500
+    system: "#6b7280", // gray-500
+    border: "#fbbf24", // amber-400 for input bar
+    gutter: "#374151", // gray-700 for turn-group gutter
+    muted: "#475569", // gray-600
+    error: "#ef4444", // red-500
+    text: "#FAF9F6"
+};

package/dist/ui/tui/reasoning-summary.d.ts

@@ -0,0 +1,12 @@
+/** Extract a disclosure title from reasoning text (OpenAI-style **Title** blocks). */
+export declare function reasoningSummary(text: string): {
+    title: string | null;
+    body: string;
+};
+export declare function formatThinkingDuration(ms: number): string;
+export declare const THINKING_PREVIEW_LINES = 3;
+/** Truncate thinking body for collapsed preview. */
+export declare function truncateThinkingBody(body: string, maxLines?: number): {
+    text: string;
+    truncated: boolean;
+};

package/dist/ui/tui/reasoning-summary.js

@@ -0,0 +1,27 @@
+/** Extract a disclosure title from reasoning text (OpenAI-style **Title** blocks). */
+export function reasoningSummary(text) {
+    const content = text.trim();
+    const match = content.match(/^\*\*([^*\n]+)\*\*(?:\r?\n\r?\n|$)/);
+    if (!match)
+        return { title: null, body: content };
+    return { title: match[1].trim(), body: content.slice(match[0].length).trimEnd() };
+}
+export function formatThinkingDuration(ms) {
+    if (ms < 1000)
+        return `${Math.max(0, Math.round(ms))}ms`;
+    return `${(ms / 1000).toFixed(1)}s`;
+}
+export const THINKING_PREVIEW_LINES = 3;
+/** Truncate thinking body for collapsed preview. */
+export function truncateThinkingBody(body, maxLines = THINKING_PREVIEW_LINES) {
+    const trimmed = body.trim();
+    if (!trimmed)
+        return { text: "", truncated: false };
+    const lines = trimmed.split("\n");
+    if (lines.length <= maxLines)
+        return { text: trimmed, truncated: false };
+    return {
+        text: lines.slice(0, maxLines).join("\n"),
+        truncated: true,
+    };
+}

package/dist/ui/tui/reducer.d.ts

@@ -0,0 +1,92 @@
+import type { MemoryBannerStats } from "../../ui-events.js";
+export type TranscriptRole = "user" | "assistant" | "system" | "tool" | "thinking" | "tool_result" | "turn_footer";
+export interface TranscriptEntry {
+    id: string;
+    role: TranscriptRole;
+    text: string;
+    toolName?: string;
+    /** Compact result summary attached to a tool entry */
+    resultSummary?: string;
+    isError?: boolean;
+    /** Raw result text for error detail */
+    resultText?: string;
+    /** Display icon for tool rows */
+    toolIcon?: string;
+    /** Human-readable tool label */
+    toolLabel?: string;
+    /** Pending verb while tool is running */
+    toolPending?: string;
+    /** Group ID for visual turn grouping — increments on each user message */
+    group: number;
+    /** Epoch ms when live thinking started */
+    thinkingStartedAt?: number;
+    /** Elapsed thinking time once completed */
+    durationMs?: number;
+}
+export interface TranscriptState {
+    completed: TranscriptEntry[];
+    live: TranscriptEntry | null;
+    nextId: number;
+    liveKind: "assistant" | "thinking" | null;
+    busy: boolean;
+    groupCounter: number;
+}
+export type TranscriptAction = {
+    type: "set_busy";
+    busy: boolean;
+} | {
+    type: "user_message";
+    text: string;
+} | {
+    type: "assistant_delta";
+    delta: string;
+} | {
+    type: "assistant_complete";
+} | {
+    type: "thinking_delta";
+    delta: string;
+} | {
+    type: "thinking_close";
+} | {
+    type: "tool_call";
+    toolName: string;
+    args: Record<string, unknown>;
+} | {
+    type: "tool_result";
+    toolName: string;
+    resultText: string;
+    isError?: boolean;
+} | {
+    type: "turn_footer";
+    model: string;
+    durationMs: number;
+    stats?: MemoryBannerStats;
+} | {
+    type: "system_lines";
+    lines: string[];
+} | {
+    type: "memory_banner";
+    text: string;
+} | {
+    type: "interrupted";
+} | {
+    type: "error";
+    message: string;
+} | {
+    type: "bootstrap";
+    entries: TranscriptEntry[];
+};
+export declare function createInitialTranscriptState(): TranscriptState;
+/** Drop brief pre-tool narration ("Let me check…") that clutters tool loops. */
+export declare const SHORT_PRE_TOOL_NARRATION_MAX = 100;
+export declare function transcriptReducer(state: TranscriptState, action: TranscriptAction): TranscriptState;
+export declare function formatMemoryBannerLine(stats: {
+    activeState: number;
+    totalState: number;
+    digestLen: number;
+    recallCalls: number;
+    recallHits: number;
+    autoHydrated: number;
+    promptTokens: number;
+    outputTokens: number;
+}): string;

package/dist/ui/tui/reducer.js

@@ -0,0 +1,260 @@
+import { summarizeArgs } from "../../tool-summary.js";
+import { formatToolDisplay, formatTurnFooter, summarizeResultForDisplay, } from "./tool-display.js";
+export function createInitialTranscriptState() {
+    return {
+        completed: [],
+        live: null,
+        nextId: 1,
+        liveKind: null,
+        busy: false,
+        groupCounter: 0,
+    };
+}
+function nextId(state) {
+    const id = `m-${state.nextId}`;
+    return [id, { ...state, nextId: state.nextId + 1 }];
+}
+function pushCompleted(state, entry) {
+    const [id, s] = nextId(state);
+    return {
+        ...s,
+        completed: [...s.completed, { ...entry, id, group: state.groupCounter }],
+    };
+}
+function freezeLive(state) {
+    if (!state.live)
+        return state;
+    return {
+        ...state,
+        completed: [...state.completed, state.live],
+        live: null,
+        liveKind: null,
+    };
+}
+/** Drop a live assistant entry without pushing empty rows into completed. */
+function clearEmptyAssistantLive(state) {
+    if (state.liveKind !== "assistant" || !state.live || state.live.text.trim()) {
+        return state;
+    }
+    return { ...state, live: null, liveKind: null };
+}
+/** Drop brief pre-tool narration ("Let me check…") that clutters tool loops. */
+export const SHORT_PRE_TOOL_NARRATION_MAX = 100;
+function clearShortAssistantLive(state) {
+    if (state.liveKind !== "assistant" || !state.live)
+        return state;
+    const text = state.live.text.trim();
+    if (!text || text.length >= SHORT_PRE_TOOL_NARRATION_MAX)
+        return state;
+    return { ...state, live: null, liveKind: null };
+}
+function ensureAssistantPlaceholder(state) {
+    if (state.live)
+        return state;
+    const [id, s] = nextId(state);
+    return {
+        ...s,
+        liveKind: "assistant",
+        live: { id, role: "assistant", text: "", group: state.groupCounter },
+    };
+}
+export function transcriptReducer(state, action) {
+    switch (action.type) {
+        case "set_busy":
+            return { ...state, busy: action.busy };
+        case "bootstrap":
+            return {
+                ...state,
+                completed: action.entries,
+                nextId: action.entries.length + 1,
+            };
+        case "user_message":
+            return pushCompleted({ ...state, groupCounter: state.groupCounter + 1 }, { role: "user", text: action.text });
+        case "assistant_delta": {
+            if (state.liveKind === "assistant" && state.live) {
+                return {
+                    ...state,
+                    live: { ...state.live, text: state.live.text + action.delta },
+                };
+            }
+            const base = freezeLive(state);
+            const [id, s] = nextId(base);
+            return {
+                ...s,
+                liveKind: "assistant",
+                live: { id, role: "assistant", text: action.delta, group: state.groupCounter },
+            };
+        }
+        case "assistant_complete": {
+            // If there's no live entry or a thinking entry, no-op
+            if (!state.live || state.liveKind !== "assistant")
+                return state;
+            // If the live assistant entry has no text, silently drop it
+            if (!state.live.text.trim()) {
+                return { ...state, live: null, liveKind: null };
+            }
+            return {
+                ...state,
+                completed: [...state.completed, state.live],
+                live: null,
+                liveKind: null,
+            };
+        }
+        case "thinking_delta": {
+            if (state.liveKind === "thinking" && state.live) {
+                return {
+                    ...state,
+                    live: { ...state.live, text: state.live.text + action.delta },
+                };
+            }
+            let base = state;
+            if (state.liveKind === "assistant" && state.live) {
+                base = state.live.text.trim() ? freezeLive(state) : clearEmptyAssistantLive(state);
+            }
+            const [id, s] = nextId(base);
+            return {
+                ...s,
+                liveKind: "thinking",
+                live: {
+                    id,
+                    role: "thinking",
+                    text: action.delta,
+                    group: state.groupCounter,
+                    thinkingStartedAt: Date.now(),
+                },
+            };
+        }
+        case "thinking_close": {
+            if (state.liveKind !== "thinking" || !state.live)
+                return state;
+            const text = state.live.text.trim();
+            if (!text) {
+                return { ...state, live: null, liveKind: null };
+            }
+            const durationMs = state.live.thinkingStartedAt !== undefined
+                ? Date.now() - state.live.thinkingStartedAt
+                : undefined;
+            const completedThinking = {
+                ...state.live,
+                text: state.live.text,
+                durationMs,
+            };
+            // Freeze thinking to completed and immediately create an empty assistant
+            // placeholder so the live area is never null (prevents flash when tools start).
+            const frozen = {
+                ...state,
+                completed: [...state.completed, completedThinking],
+                live: null,
+                liveKind: null,
+            };
+            const [id, s] = nextId(frozen);
+            return {
+                ...s,
+                liveKind: "assistant",
+                live: { id, role: "assistant", text: "", group: state.groupCounter },
+            };
+        }
+        case "tool_call": {
+            const display = formatToolDisplay(action.toolName, action.args);
+            let base = clearShortAssistantLive(state);
+            base = ensureAssistantPlaceholder(base);
+            const summary = summarizeArgs(action.toolName, action.args);
+            return pushCompleted(base, {
+                role: "tool",
+                toolName: action.toolName,
+                text: summary ? `${action.toolName} :: ${summary}` : action.toolName,
+                toolIcon: display.icon,
+                toolLabel: display.label,
+                toolPending: display.pending,
+            });
+        }
+        case "tool_result": {
+            const summary = summarizeResultForDisplay(action.resultText);
+            const completed = [...state.completed];
+            for (let i = completed.length - 1; i >= 0; i--) {
+                const entry = completed[i];
+                if (entry?.role === "tool" &&
+                    entry.toolName === action.toolName &&
+                    entry.resultSummary === undefined) {
+                    completed[i] = {
+                        ...entry,
+                        resultSummary: summary,
+                        resultText: action.resultText,
+                        isError: action.isError ?? false,
+                    };
+                    return { ...state, completed };
+                }
+            }
+            return pushCompleted(state, {
+                role: "tool_result",
+                toolName: action.toolName,
+                text: action.resultText,
+                resultSummary: summary,
+                resultText: action.resultText,
+                isError: action.isError ?? false,
+            });
+        }
+        case "turn_footer":
+            return pushCompleted(state, {
+                role: "turn_footer",
+                text: formatTurnFooter(action.model, action.durationMs, action.stats),
+            });
+        case "system_lines": {
+            const text = action.lines.filter(Boolean).join("\n");
+            if (!text)
+                return state;
+            return pushCompleted(freezeLive(state), { role: "system", text });
+        }
+        case "memory_banner": {
+            if (!action.text)
+                return state;
+            return pushCompleted(state, { role: "system", text: action.text });
+        }
+        case "interrupted":
+            return pushCompleted(freezeLive(state), {
+                role: "system",
+                text: "[interrupted]",
+            });
+        case "error":
+            return pushCompleted(freezeLive(state), {
+                role: "system",
+                text: `[error] ${action.message}`,
+            });
+        default:
+            return state;
+    }
+}
+function fmtToken(n) {
+    if (n < 1000)
+        return String(n);
+    if (n < 1_000_000)
+        return `${(n / 1000).toFixed(1)}k`;
+    return `${(n / 1_000_000).toFixed(1)}M`;
+}
+export function formatMemoryBannerLine(stats) {
+    if (stats.activeState === 0 &&
+        stats.recallCalls === 0 &&
+        stats.autoHydrated === 0 &&
+        stats.digestLen === 0 &&
+        !stats.promptTokens &&
+        !stats.outputTokens) {
+        return "";
+    }
+    const parts = [];
+    if (stats.activeState > 0 || stats.totalState > 0) {
+        parts.push(`state ${stats.activeState}/${stats.totalState}`);
+    }
+    if (stats.digestLen > 0)
+        parts.push(`digest ${stats.digestLen}c`);
+    if (stats.recallCalls > 0)
+        parts.push(`recall ${stats.recallHits}/${stats.recallCalls}`);
+    if (stats.autoHydrated > 0)
+        parts.push(`auto+${stats.autoHydrated}`);
+    if (stats.promptTokens > 0)
+        parts.push(`prompt ~${fmtToken(stats.promptTokens)}`);
+    if (stats.outputTokens > 0)
+        parts.push(`out ~${fmtToken(stats.outputTokens)}`);
+    if (parts.length === 0)
+        return "";
+    return parts.join(" · ");
+}

package/dist/ui/tui/run.d.ts

@@ -0,0 +1,3 @@
+import type { UiScreenMode } from "../../types.js";
+import type { AppController, StartupInfo } from "../../app-controller.js";
+export declare function runTui(controller: AppController, info: StartupInfo, screen: UiScreenMode): Promise<void>;

package/dist/ui/tui/run.js

@@ -0,0 +1,40 @@
+import React from "react";
+import { render } from "ink";
+import { formatSessionEndSummary, formatSessionEpilogue, } from "../../app-banner.js";
+import { formatTuiBootSummary } from "./tool-display.js";
+import { TuiApp } from "./app.js";
+export async function runTui(controller, info, screen) {
+    const config = controller.config;
+    const session = controller.session;
+    const bootSummary = formatTuiBootSummary({
+        sessionId: session.id,
+        contextTokens: session.agentsContext
+            ? Math.ceil(session.agentsContext.length / 4)
+            : undefined,
+        engineEnabled: session.isContextEngineEnabled(),
+        skillCount: session.skills.length,
+        memoryEnabled: session.memoryEnabled,
+        incognito: session.isIncognito(),
+    });
+    const { waitUntilExit, unmount } = render(React.createElement(TuiApp, {
+        controller,
+        initialStatus: controller.getStatusBarInput(),
+        recentLines: info.isResume ? [] : info.recentConversationLines,
+        transcriptBootstrap: info.transcriptBootstrap,
+        bootSummary,
+        markdownRendering: config.ui.markdown_rendering,
+        syntaxHighlighting: config.ui.syntax_highlighting,
+        syntaxTheme: config.ui.syntax_theme,
+    }), {
+        alternateScreen: screen === "alternate",
+        exitOnCtrlC: false,
+        patchConsole: false,
+    });
+    await waitUntilExit();
+    unmount();
+    await controller.shutdown();
+    for (const line of formatSessionEpilogue(controller.session.id)) {
+        console.log(line);
+    }
+    console.log(formatSessionEndSummary(controller.session));
+}