@bubblebrain-ai/bubble 0.0.63 → 0.0.64

package/dist/tui/file-mentions.js

@@ -0,0 +1,174 @@
+import { execFile } from "node:child_process";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const MAX_INLINE_BYTES = 200 * 1024;
+const IGNORED_DIRS = new Set([".git", "node_modules", "dist", "build", ".next", ".turbo", ".cache"]);
+const fileListCache = new Map();
+export function findAtContext(text, cursor) {
+    const before = text.slice(0, cursor);
+    const at = before.lastIndexOf("@");
+    if (at === -1)
+        return null;
+    const prev = at === 0 ? "" : before[at - 1];
+    if (prev !== "" && !/\s/.test(prev))
+        return null;
+    const query = before.slice(at + 1);
+    if (/\s/.test(query))
+        return null;
+    return { start: at, end: cursor, query };
+}
+export function filterFileSuggestions(files, query, limit = 20) {
+    const q = query.toLowerCase();
+    if (q.length === 0) {
+        return files.slice(0, limit).map((p) => ({ path: p, score: 1 }));
+    }
+    const scored = [];
+    for (const file of files) {
+        const lower = file.toLowerCase();
+        const base = path.basename(lower);
+        let score = 0;
+        if (base.startsWith(q))
+            score = 100;
+        else if (lower.startsWith(q))
+            score = 80;
+        else if (base.includes(q))
+            score = 60;
+        else if (lower.includes(q))
+            score = 40;
+        if (score > 0)
+            scored.push({ path: file, score });
+    }
+    scored.sort((a, b) => (b.score - a.score) || (a.path.length - b.path.length) || a.path.localeCompare(b.path));
+    return scored.slice(0, limit);
+}
+export async function listProjectFiles(cwd) {
+    const cached = fileListCache.get(cwd);
+    if (cached)
+        return cached;
+    const files = await discoverFiles(cwd);
+    fileListCache.set(cwd, files);
+    return files;
+}
+export function invalidateFileListCache(cwd) {
+    if (cwd)
+        fileListCache.delete(cwd);
+    else
+        fileListCache.clear();
+}
+async function discoverFiles(cwd) {
+    try {
+        const { stdout } = await execFileAsync("git", ["ls-files", "-co", "--exclude-standard"], {
+            cwd,
+            maxBuffer: 32 * 1024 * 1024,
+        });
+        const files = stdout.split("\n").map((s) => s.trim()).filter(Boolean);
+        if (files.length > 0)
+            return files;
+    }
+    catch {
+        // Not a git repo or git unavailable — fall through to filesystem walk.
+    }
+    return walkFilesystem(cwd);
+}
+async function walkFilesystem(root) {
+    const results = [];
+    async function visit(dir, rel) {
+        let entries;
+        try {
+            entries = (await fs.readdir(dir, { withFileTypes: true }));
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith(".") && entry.name !== ".env" && entry.name !== ".gitignore")
+                continue;
+            if (IGNORED_DIRS.has(entry.name))
+                continue;
+            const abs = path.join(dir, entry.name);
+            const relPath = rel ? `${rel}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                await visit(abs, relPath);
+            }
+            else if (entry.isFile()) {
+                results.push(relPath);
+            }
+        }
+    }
+    await visit(root, "");
+    return results;
+}
+const MENTION_REGEX = /(^|\s)@([^\s]+)/g;
+export async function expandAtMentions(text, cwd) {
+    const result = { text, expanded: [], missing: [], skipped: [] };
+    const mentions = Array.from(text.matchAll(MENTION_REGEX));
+    if (mentions.length === 0)
+        return result;
+    const blocks = [];
+    const seen = new Set();
+    for (const match of mentions) {
+        const token = match[2];
+        if (seen.has(token))
+            continue;
+        seen.add(token);
+        const abs = path.resolve(cwd, token);
+        if (!abs.startsWith(path.resolve(cwd))) {
+            result.skipped.push({ path: token, reason: "outside project" });
+            continue;
+        }
+        let stat;
+        try {
+            stat = await fs.stat(abs);
+        }
+        catch {
+            result.missing.push(token);
+            continue;
+        }
+        if (!stat.isFile()) {
+            result.skipped.push({ path: token, reason: "not a file" });
+            continue;
+        }
+        if (stat.size > MAX_INLINE_BYTES) {
+            result.skipped.push({ path: token, reason: "too large", bytes: stat.size });
+            blocks.push(`### @${token}\n(${formatBytes(stat.size)}, exceeds inline limit of ${formatBytes(MAX_INLINE_BYTES)} — use the Read tool to access)`);
+            continue;
+        }
+        let contents;
+        try {
+            contents = await fs.readFile(abs, "utf8");
+        }
+        catch (err) {
+            result.skipped.push({ path: token, reason: `read failed: ${err.message || String(err)}` });
+            continue;
+        }
+        result.expanded.push({ path: token, bytes: stat.size, truncated: false });
+        const lang = guessLanguage(token);
+        blocks.push(`### @${token}\n\`\`\`${lang}\n${contents}\n\`\`\``);
+    }
+    if (blocks.length === 0)
+        return result;
+    result.text = `${text}\n\n---\nReferenced files:\n\n${blocks.join("\n\n")}`;
+    return result;
+}
+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 guessLanguage(filePath) {
+    const ext = path.extname(filePath).slice(1).toLowerCase();
+    const map = {
+        ts: "ts", tsx: "tsx", js: "js", jsx: "jsx",
+        py: "python", rb: "ruby", go: "go", rs: "rust",
+        java: "java", kt: "kotlin", swift: "swift",
+        c: "c", h: "c", cpp: "cpp", cc: "cpp", hpp: "cpp",
+        cs: "csharp", php: "php", sh: "bash", zsh: "bash", bash: "bash",
+        json: "json", yaml: "yaml", yml: "yaml", toml: "toml", xml: "xml",
+        html: "html", css: "css", scss: "scss", sql: "sql", md: "markdown",
+    };
+    return map[ext] ?? "";
+}

package/dist/tui/footer.d.ts

@@ -0,0 +1,37 @@
+import { type Component } from "@bubblebrain-ai/pi-tui";
+import type { PermissionMode } from "../types.js";
+import { type Theme } from "./model/theme.js";
+export interface FooterAgentInfo {
+    model: string;
+    getContextUsageSnapshot(): {
+        usedTokens: number;
+        contextWindow?: number;
+    };
+}
+export interface FooterRenderOptions {
+    cwd?: string;
+    branch?: string;
+    sessionTitle?: string;
+    /** External runtimes own model/context state and replace native details. */
+    runtimeLabel?: string;
+    extra?: readonly string[];
+    mode?: PermissionMode;
+    /** Persistent autonomous Goal status, rendered on its own muted row. */
+    goalLine?: string;
+    theme?: Theme;
+}
+export interface ResponsiveFooterSnapshot extends FooterRenderOptions {
+    agent: FooterAgentInfo;
+    hidden?: boolean;
+}
+/** Width-responsive single-row footer shared by main and fullscreen TUIs. */
+export declare class ResponsiveFooterComponent implements Component {
+    private readonly getSnapshot;
+    constructor(getSnapshot: () => ResponsiveFooterSnapshot);
+    render(width: number): string[];
+    invalidate(): void;
+}
+export declare function renderFooterLine(agent: FooterAgentInfo, columns: number, options?: FooterRenderOptions): string;
+/** Match the legacy footer contract for persisted external-runtime sessions. */
+export declare function formatExternalRuntimeFooterLabel(binding: unknown): string | undefined;
+export declare function renderPermissionModeBadge(mode?: PermissionMode): string;

package/dist/tui/footer.js

@@ -0,0 +1,80 @@
+/** Shared footer line renderer (main + fullscreen modes). */
+import chalk from "chalk";
+import { truncateToWidth } from "@bubblebrain-ai/pi-tui";
+import { formatContextUsageLabel, friendlyCwd } from "./formatting/summary.js";
+import { PERMISSION_MODE_INFO } from "../permission/mode.js";
+import { classifyExternalRuntimeBinding } from "../external-runtime/session-policy.js";
+import { darkTheme } from "./model/theme.js";
+import { themeDim, themeForeground } from "./model/theme-style.js";
+/** Width-responsive single-row footer shared by main and fullscreen TUIs. */
+export class ResponsiveFooterComponent {
+    getSnapshot;
+    constructor(getSnapshot) {
+        this.getSnapshot = getSnapshot;
+    }
+    render(width) {
+        const snapshot = this.getSnapshot();
+        if (snapshot.hidden)
+            return [];
+        const rows = [];
+        const theme = snapshot.theme ?? darkTheme;
+        const muted = snapshot.theme ? (text) => themeDim(theme.dim, text) : chalk.dim;
+        if (snapshot.goalLine?.trim()) {
+            rows.push(truncateToWidth(muted(snapshot.goalLine.trim()), Math.max(1, Math.floor(width))));
+        }
+        if (snapshot.runtimeLabel?.trim()) {
+            rows.push(truncateToWidth(snapshot.theme ? themeForeground(theme.accent, snapshot.runtimeLabel.trim()) : chalk.cyan(snapshot.runtimeLabel.trim()), Math.max(1, Math.floor(width))));
+        }
+        rows.push(renderFooterLine(snapshot.agent, width, snapshot));
+        return rows;
+    }
+    invalidate() {
+        // No cache: terminal width, model, cwd, usage, and queue badges are live.
+    }
+}
+export function renderFooterLine(agent, columns, options = {}) {
+    const theme = options.theme ?? darkTheme;
+    const muted = options.theme ? (text) => themeDim(theme.dim, text) : chalk.dim;
+    const usage = formatContextUsageLabel(agent.getContextUsageSnapshot());
+    const cwd = options.cwd ?? friendlyCwd(process.cwd());
+    const mode = renderPermissionModeBadge(options.mode);
+    const nativeDetails = !options.runtimeLabel?.trim();
+    const parts = [
+        ...(mode ? [mode] : []),
+        ...(nativeDetails && agent.model ? [muted(agent.model)] : []),
+        muted(cwd),
+        ...(options.branch?.trim() ? [muted(options.branch.trim())] : []),
+        ...(nativeDetails && options.sessionTitle?.trim() ? [muted(options.sessionTitle.trim())] : []),
+        ...(nativeDetails && usage ? [muted(usage)] : []),
+        ...(options.extra ?? []),
+    ];
+    const line = parts.join(muted(" │ "));
+    return truncateToWidth(line, Math.max(1, Math.floor(columns)));
+}
+/** Match the legacy footer contract for persisted external-runtime sessions. */
+export function formatExternalRuntimeFooterLabel(binding) {
+    const kind = classifyExternalRuntimeBinding(binding);
+    if (kind === "none")
+        return undefined;
+    if (kind === "unsupported")
+        return "Unsupported external runtime · recovery-only";
+    const record = binding && typeof binding === "object"
+        ? binding
+        : undefined;
+    const model = typeof record?.modelId === "string" && record.modelId.trim()
+        ? record.modelId.trim()
+        : undefined;
+    const effort = typeof record?.reasoningEffort === "string"
+        && record.reasoningEffort.trim()
+        && record.reasoningEffort !== "off"
+        ? record.reasoningEffort.trim()
+        : undefined;
+    return ["Grok Subscription", model, effort, "workspace"].filter(Boolean).join(" · ");
+}
+export function renderPermissionModeBadge(mode) {
+    if (!mode || mode === "default")
+        return "";
+    const info = PERMISSION_MODE_INFO[mode];
+    const label = `${info.symbol ? `${info.symbol} ` : ""}${info.shortTitle} on`;
+    return mode === "bypassPermissions" ? chalk.bold.red(label) : chalk.bold.cyan(label);
+}

package/dist/tui/formatting/edit-diff.d.ts

@@ -0,0 +1,11 @@
+import type { DisplayToolCall } from "../model/display-history.js";
+export declare const EDIT_COLLAPSED_DIFF_LINES = 20;
+export interface EditDiffDetails {
+    diff: string;
+    added: number;
+    removed: number;
+    path?: string;
+}
+export declare function getEditDiffDetails(tool: DisplayToolCall): EditDiffDetails | null;
+export declare function formatEditSuccessSummary(details: EditDiffDetails | null): string;
+export declare function formatEditStats(added: number, removed: number): string;

package/dist/tui/formatting/edit-diff.js

@@ -0,0 +1,52 @@
+import { countUnifiedDiffChanges } from "../../diff-stats.js";
+export const EDIT_COLLAPSED_DIFF_LINES = 20;
+export function getEditDiffDetails(tool) {
+    if (tool.name !== "edit" || tool.isError)
+        return null;
+    const metadata = tool.metadata;
+    const metadataDiff = readMetadataString(metadata, "diff");
+    const diff = metadataDiff ?? extractDiffFromResult(tool.result);
+    if (!diff)
+        return null;
+    const counted = countUnifiedDiffChanges(diff);
+    const added = readMetadataNumber(metadata, "addedLines") ?? counted.added;
+    const removed = readMetadataNumber(metadata, "removedLines") ?? counted.removed;
+    const path = readMetadataString(metadata, "path")
+        ?? (typeof tool.args.path === "string" ? tool.args.path : undefined);
+    return { diff, added, removed, path };
+}
+export function formatEditSuccessSummary(details) {
+    const stats = details ? formatEditStats(details.added, details.removed) : "";
+    return `Succeeded. File edited.${stats ? ` ${stats}` : ""}`;
+}
+export function formatEditStats(added, removed) {
+    const parts = [];
+    if (added > 0)
+        parts.push(`+${added} added`);
+    if (removed > 0)
+        parts.push(`-${removed} removed`);
+    if (parts.length === 0)
+        return "";
+    return `(${parts.join(", ")})`;
+}
+function extractDiffFromResult(result) {
+    if (!result)
+        return null;
+    const normalized = result.replace(/\r\n/g, "\n");
+    const marker = "\nDiff:\n";
+    const index = normalized.indexOf(marker);
+    if (index === -1)
+        return null;
+    const rawDiff = normalized.slice(index + marker.length);
+    const diagnosticsIndex = rawDiff.search(/\n\nLSP diagnostics in /);
+    const diff = diagnosticsIndex === -1 ? rawDiff : rawDiff.slice(0, diagnosticsIndex);
+    return diff.trim().length > 0 ? diff : null;
+}
+function readMetadataString(metadata, key) {
+    const value = metadata?.[key];
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function readMetadataNumber(metadata, key) {
+    const value = metadata?.[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}

package/dist/tui/formatting/summary.d.ts

@@ -0,0 +1,43 @@
+import type { Agent } from "../../agent.js";
+import { type ProviderRegistry } from "../../provider-registry.js";
+import type { BackgroundTaskInfo } from "../../tasks/manager.js";
+import { type DisplayMessage } from "../model/display-history.js";
+export declare const TASK_WAKE_DEBOUNCE_MS = 2000;
+export declare function buildTips(agent: Agent, registry: ProviderRegistry, grokActive?: boolean): string[];
+/**
+ * Slash-command results arrive as plain strings; recognize the /model
+ * confirmations by shape so they render as accent-colored UI notices — the
+ * same treatment the picker path applies — instead of assistant prose.
+ */
+export declare function slashResultNoticeKind(result: string): DisplayMessage["syntheticKind"] | undefined;
+/** Status-row summary for running background tasks (design §2.5). */
+export declare function taskRowSummary(tasks: BackgroundTaskInfo[], nowTick: number): string;
+export declare function friendlyCwd(cwd: string): string;
+export declare function sessionBasename(sessionFile: string | undefined): string | undefined;
+export declare function truncate(value: string, max: number): string;
+export declare function formatCompactTokens(n: number): string;
+export declare function formatContextUsageLabel(snapshot: {
+    usedTokens: number;
+    contextWindow?: number;
+}): string;
+/**
+ * Streaming tool arguments arrive as an incomplete JSON buffer. We can't
+ * JSON.parse() until the closing brace lands, but the user wants to see the
+ * short identifying fields (path, command, …) as soon as the model emits
+ * them so the tool row header reflects what's happening.
+ *
+ * Intentionally limited to short, single-line fields. Long fields like
+ * `content` are *not* surfaced live: rendering thousands of partial lines
+ * per delta floods the terminal and the partial value can break around
+ * unescaped sequences. The final value lands when the tool actually
+ * executes and tool_start delivers canonical args.
+ */
+export declare function parsePartialArgs(buffer: string, previous: Record<string, any>): Record<string, any>;
+/**
+ * Coerce a freshly-constructed DisplayMessage into one that carries a stable
+ * `key`. Centralizes the safety net so callers don't have to remember to call
+ * nextDisplayMessageKey on every push.
+ */
+export declare function withMessageKey(message: DisplayMessage): DisplayMessage;
+export declare const STREAMING_FLUSH_INTERVAL_MS = 40;
+export declare function clampWindowStartForIndex(total: number, selectedIndex: number, maxVisible: number): number;

package/dist/tui/formatting/summary.js

@@ -0,0 +1,150 @@
+/**
+ * Pure helpers for the Ink app: welcome tips, status-row summaries,
+ * cwd/session labels, truncation, context-usage formatting, partial
+ * streaming-arg extraction, display-message keying, and the scrolling-window
+ * clamp shared by the picker overlays.
+ */
+import os from "node:os";
+import { displayModel } from "../../provider-registry.js";
+import { nextDisplayMessageKey } from "../model/display-history.js";
+export const TASK_WAKE_DEBOUNCE_MS = 2000;
+export function buildTips(agent, registry, grokActive = false) {
+    const tips = [];
+    if (grokActive) {
+        return [
+            "Grok Subscription is active with workspace tools and Bubble approvals",
+            "Use /model to choose the Grok model and reasoning effort",
+            "Use /logout grok to return to a fresh native session",
+        ];
+    }
+    const hasProvider = registry.getEnabled().length > 0;
+    if (!hasProvider) {
+        tips.push("Run /login or /provider --add to configure a model");
+    }
+    else if (agent.model) {
+        tips.push(`Ready with ${displayModel(agent.model)}`);
+    }
+    else {
+        tips.push("Run /model to pick a model");
+    }
+    tips.push("Type @ to reference a file");
+    tips.push("Type / for commands and skills");
+    return tips;
+}
+/**
+ * Slash-command results arrive as plain strings; recognize the /model
+ * confirmations by shape so they render as accent-colored UI notices — the
+ * same treatment the picker path applies — instead of assistant prose.
+ */
+export function slashResultNoticeKind(result) {
+    return /^(Grok m|M)odel switched to /.test(result) ? "ui_notice" : undefined;
+}
+/** Status-row summary for running background tasks (design §2.5). */
+export function taskRowSummary(tasks, nowTick) {
+    const first = tasks[0];
+    const label = first.description?.trim() || first.command.replace(/\s+/g, " ").slice(0, 32);
+    const elapsed = Math.max(0, Math.round((nowTick - first.startedAt) / 1000));
+    return `${label} ${elapsed}s`;
+}
+export function friendlyCwd(cwd) {
+    const home = os.homedir();
+    if (cwd === home)
+        return "~";
+    if (cwd.startsWith(home + "/"))
+        return "~" + cwd.slice(home.length);
+    return cwd;
+}
+export function sessionBasename(sessionFile) {
+    if (!sessionFile)
+        return undefined;
+    const base = sessionFile.split("/").pop() ?? sessionFile;
+    return base.replace(/\.jsonl$/, "");
+}
+export function truncate(value, max) {
+    if (value.length <= max)
+        return value;
+    return `${value.slice(0, Math.max(0, max - 1))}…`;
+}
+export function formatCompactTokens(n) {
+    if (n < 1000)
+        return `${Math.round(n)}`;
+    if (n < 1_000_000)
+        return `${(n / 1000).toFixed(n >= 10000 ? 0 : 1)}K`;
+    return `${(n / 1_000_000).toFixed(n >= 10_000_000 ? 0 : 1)}M`;
+}
+export function formatContextUsageLabel(snapshot) {
+    if (!snapshot.contextWindow || snapshot.contextWindow <= 0) {
+        return `${formatCompactTokens(snapshot.usedTokens)} context`;
+    }
+    const percent = (snapshot.usedTokens / snapshot.contextWindow) * 100;
+    const label = percent >= 10
+        ? `${Math.round(percent)}%`
+        : percent >= 0.05
+            ? `${percent.toFixed(1)}%`
+            : "<0.1%";
+    return `${label} context`;
+}
+/**
+ * Streaming tool arguments arrive as an incomplete JSON buffer. We can't
+ * JSON.parse() until the closing brace lands, but the user wants to see the
+ * short identifying fields (path, command, …) as soon as the model emits
+ * them so the tool row header reflects what's happening.
+ *
+ * Intentionally limited to short, single-line fields. Long fields like
+ * `content` are *not* surfaced live: rendering thousands of partial lines
+ * per delta floods the terminal and the partial value can break around
+ * unescaped sequences. The final value lands when the tool actually
+ * executes and tool_start delivers canonical args.
+ */
+export function parsePartialArgs(buffer, previous) {
+    // If the buffer is now valid JSON, prefer the real parse.
+    try {
+        const parsed = JSON.parse(buffer);
+        if (parsed && typeof parsed === "object")
+            return parsed;
+    }
+    catch {
+        // fall through to partial extraction below
+    }
+    const result = { ...previous };
+    const FIELDS = ["path", "command", "pattern", "url", "query"];
+    for (const field of FIELDS) {
+        // Match a complete-looking quoted string. Requires a closing quote so we
+        // don't surface half-typed paths that may still change as bytes arrive.
+        const match = buffer.match(new RegExp(`"${field}"\\s*:\\s*"((?:\\\\.|[^"\\\\])*)"`));
+        if (match) {
+            const raw = match[1] ?? "";
+            result[field] = raw
+                .replace(/\\n/g, "\n")
+                .replace(/\\t/g, "\t")
+                .replace(/\\"/g, '"')
+                .replace(/\\\\/g, "\\");
+        }
+    }
+    return result;
+}
+/**
+ * Coerce a freshly-constructed DisplayMessage into one that carries a stable
+ * `key`. Centralizes the safety net so callers don't have to remember to call
+ * nextDisplayMessageKey on every push.
+ */
+export function withMessageKey(message) {
+    if (message.key)
+        return message;
+    const prefix = message.role === "user" ? "user" : message.role === "error" ? "err" : "asst";
+    return { ...message, key: nextDisplayMessageKey(prefix) };
+}
+// Batch streaming text deltas before committing them to React state. Without
+// <Static>, every commit re-renders the full-screen frame; per-token commits
+// would make Yoga re-lay-out the transcript for every few bytes of output.
+// 40ms keeps perceived latency invisible while capping layout work at 25fps.
+export const STREAMING_FLUSH_INTERVAL_MS = 40;
+export function clampWindowStartForIndex(total, selectedIndex, maxVisible) {
+    if (total <= maxVisible)
+        return 0;
+    const half = Math.floor(maxVisible / 2);
+    let start = Math.max(0, selectedIndex - half);
+    if (start + maxVisible > total)
+        start = total - maxVisible;
+    return Math.max(0, start);
+}

package/dist/tui/fullscreen.d.ts

@@ -0,0 +1,48 @@
+import { type Terminal } from "@bubblebrain-ai/pi-tui";
+import type { BubbleTuiController } from "./controller/controller.js";
+import type { Agent } from "../agent.js";
+import { TraceInteractionState } from "./model/trace-interaction.js";
+import type { ComposerController } from "./controller/composer-controller.js";
+import { type Theme } from "./model/theme.js";
+export interface FullscreenAppOptions {
+    controller: BubbleTuiController;
+    agent: Pick<Agent, "model" | "mode" | "setMode" | "getContextUsageSnapshot">;
+    onExit(): void;
+    /** Route non-mode slash commands through the main app's shared registry. */
+    onCommand(command: string): void;
+    /** Test/embedded host injection; production uses ProcessTerminal. */
+    terminal?: Terminal;
+    /** Preserve tool-group folds when switching from the regular renderer. */
+    traceInteraction?: TraceInteractionState;
+    /** Shared semantic composer state when transitioning from the main renderer. */
+    composer?: ComposerController;
+    /** Shared live palette when this view is entered from the regular renderer. */
+    getTheme?: () => Theme;
+}
+export declare class FullscreenApp {
+    private readonly options;
+    private readonly tui;
+    private readonly transcript;
+    private readonly streamingMessage;
+    private readonly animationClock;
+    private readonly editor;
+    private readonly composerPreview?;
+    private readonly footer;
+    private readonly traceInteraction;
+    private readonly markdown;
+    private readonly transcriptTheme;
+    private readonly markdownRenderer;
+    private readonly unsubscribe;
+    private showReasoning;
+    private verboseTrace;
+    private disposed;
+    private streamingMounted;
+    constructor(options: FullscreenAppOptions);
+    private buildLayout;
+    private openImageViewer;
+    render(): void;
+    private transcriptRenderOptions;
+    start(): void;
+    dispose(): void;
+    waitUntilExit(): Promise<void>;
+}