@bubblebrain-ai/bubble 0.0.12 → 0.0.13

package/dist/tui-opentui/theme.js

@@ -0,0 +1,157 @@
+/**
+ * Theme for the OpenTUI TUI, structured after opencode's grayscale + semantic
+ * accent model. Bubble keeps the quiet terminal surface, blue focus color, and
+ * warm command accent instead of turning light mode into a plain gray port.
+ *
+ * The exported `Theme` shape preserves the keys consumed by the rest of the
+ * TUI so no caller needs to change.
+ */
+import { createContext, useContext } from "react";
+/**
+ * 12-step grayscale + lavender accent.
+ *
+ *  step1  #0a0a0a  root bg
+ *  step2  #141414  panel bg (dialogs, chips)
+ *  step3  #1c1820  element bg (input fill, slightly purple-tinged)
+ *  step4  #232028  surface  (current input bg base)
+ *  step5  #2a2630  raised panel
+ *  step6  #3a3242  borderSubtle
+ *  step7  #4a4254  border
+ *  step8  #5e5570  borderActive
+ *  step9  #bd91db  accent / primary       ← brand
+ *  step10 #d4afe8  accent hover / soft
+ *  step11 #808080  text muted
+ *  step12 #eeeeee  text
+ */
+export const darkTheme = {
+    user: "#8E3A52", // user messages render in accent — opencode pattern
+    agent: "#EEEEEE", // assistant messages render in full white
+    error: "#E06C75",
+    warning: "#F5A742",
+    success: "#7FD88F",
+    accent: "#8E3A52",
+    border: "#4A3A40",
+    borderActive: "#8E3A52",
+    inputBorder: "#8E3A52", // heavy left rail color
+    inputBorderDisabled: "#3A2A2F",
+    inputBg: "#1A1014", // surface — slightly raised from root
+    inputBgDisabled: "#141414",
+    inputText: "#EEEEEE",
+    inputPlaceholder: "#808080",
+    muted: "#808080",
+    dim: "#606070",
+    thinking: "#6B2A3E",
+    thinkingDim: "#808080",
+    toolName: "#808080", // tool header lines are dim (opencode pattern)
+    toolResult: "#EEEEEE",
+    toolError: "#E06C75",
+    toolPending: "#F5A742",
+    code: "#7FD88F",
+    traceAction: "#8E3A52",
+    traceCount: "#808080",
+    traceDetail: "#606070",
+    traceCommand: "#56B6C2",
+    tracePending: "#F5A742",
+    userMessageBorder: "transparent", // unused under opencode style
+    userMessageBg: "transparent",
+    userMessageText: "#8E3A52", // user message body color
+    userRail: "#8E3A52",
+    diffAdd: "#20303B",
+    diffRemove: "#37222C",
+    diffAddFg: "#4FD6BE",
+    diffRemoveFg: "#C53B53",
+    toolFile: "#7FD88F",
+    toolShell: "#F5A742",
+    toolSearch: "#56B6C2",
+    toolThink: "#6B2A3E",
+    toolNet: "#5C9CF5",
+    toolEdit: "#8E3A52",
+    brand: "#8E3A52",
+    brandSoft: "#B85574",
+    brandDeep: "#6B2A3E",
+    background: "#0A0A0A",
+    backgroundPanel: "#141414",
+    backgroundElement: "#1A1014",
+    text: "#EEEEEE",
+    textMuted: "#808080",
+    textDim: "#606070",
+    surface: "#1A1014",
+    shade: "#141414",
+};
+export const lightTheme = {
+    user: "#356FD2",
+    agent: "#171717",
+    error: "#B62633",
+    warning: "#8B4A00",
+    success: "#2F7D4A",
+    accent: "#8B4A00",
+    border: "#B9BDB8",
+    borderActive: "#356FD2",
+    inputBorder: "#356FD2",
+    inputBorderDisabled: "#D7DAD4",
+    inputBg: "#F1F3F0",
+    inputBgDisabled: "#E6E8E3",
+    inputText: "#171717",
+    inputPlaceholder: "#6F7377",
+    muted: "#6F7377",
+    dim: "#8B9094",
+    thinking: "#5F666D",
+    thinkingDim: "#8B9094",
+    toolName: "#495057",
+    toolResult: "#171717",
+    toolError: "#B62633",
+    toolPending: "#8B4A00",
+    code: "#2F7D4A",
+    traceAction: "#8B4A00",
+    traceCount: "#6F7377",
+    traceDetail: "#8B9094",
+    traceCommand: "#257E8A",
+    tracePending: "#8B4A00",
+    userMessageBorder: "transparent",
+    userMessageBg: "transparent",
+    userMessageText: "#234B93",
+    userRail: "#356FD2",
+    diffAdd: "#D7E8D8",
+    diffRemove: "#F7DADC",
+    diffAddFg: "#173D2D",
+    diffRemoveFg: "#5D1922",
+    toolFile: "#2F7D4A",
+    toolShell: "#257E8A",
+    toolSearch: "#356FD2",
+    toolThink: "#5F666D",
+    toolNet: "#356FD2",
+    toolEdit: "#8B4A00",
+    brand: "#8B4A00",
+    brandSoft: "#B86B15",
+    brandDeep: "#5A2F00",
+    background: "#FCFCFA",
+    backgroundPanel: "#F6F6F3",
+    backgroundElement: "#ECEDEA",
+    text: "#171717",
+    textMuted: "#6F7377",
+    textDim: "#8B9094",
+    surface: "#F1F3F0",
+    shade: "#E6E8E3",
+};
+const ThemeContext = createContext(darkTheme);
+export const ThemeProvider = ThemeContext.Provider;
+export function useTheme() {
+    return useContext(ThemeContext);
+}
+export function paletteFor(mode, overrides) {
+    const base = mode === "light" ? lightTheme : darkTheme;
+    if (!overrides)
+        return base;
+    const filtered = {};
+    for (const [key, value] of Object.entries(overrides)) {
+        if (typeof value === "string" && key in base) {
+            filtered[key] = value;
+        }
+    }
+    return { ...base, ...filtered };
+}
+/** opencode style: tool category is encoded by header text, not color. Keep
+ * a single accent for tool names so users get visual consistency. */
+export function toolAccent(theme, _toolName) {
+    return theme.text;
+}

package/dist/tui-opentui/todos.d.ts

@@ -0,0 +1,9 @@
+/** @jsxImportSource @opentui/react */
+import React from "react";
+import type { Todo } from "../types.js";
+interface TodosPanelProps {
+    todos: Todo[];
+    terminalColumns: number;
+}
+export declare function TodosPanel({ todos, terminalColumns }: TodosPanelProps): React.ReactNode;
+export {};

package/dist/tui-opentui/todos.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@opentui/react/jsx-runtime";
+import { useTheme } from "./theme.js";
+const MAX_ROWS = 8;
+export function TodosPanel({ todos, terminalColumns }) {
+    const theme = useTheme();
+    if (todos.length === 0) {
+        return null;
+    }
+    const rows = selectVisibleRows(todos);
+    const hiddenCount = todos.length - rows.length;
+    const contentWidth = Math.max(20, terminalColumns - 4);
+    return (_jsxs("box", { style: { flexDirection: "column", marginBottom: 1 }, children: [_jsx("text", { fg: theme.accent, attributes: 1, children: "\u25CF Todos" }), rows.map((todo, index) => (_jsx(TodoRow, { todo: todo, maxWidth: contentWidth }, index))), hiddenCount > 0 && (_jsxs("text", { fg: theme.muted, children: ["... ", hiddenCount, " more item", hiddenCount === 1 ? "" : "s", " hidden"] }))] }));
+}
+function selectVisibleRows(todos) {
+    if (todos.length <= MAX_ROWS) {
+        return todos;
+    }
+    // Prefer to show: all in_progress, the last N completed just before current, and upcoming pending.
+    const inProgressIdx = todos.findIndex((t) => t.status === "in_progress");
+    const anchor = inProgressIdx >= 0 ? inProgressIdx : todos.findIndex((t) => t.status === "pending");
+    const pivot = anchor >= 0 ? anchor : 0;
+    const half = Math.floor(MAX_ROWS / 2);
+    let start = Math.max(0, pivot - half);
+    let end = Math.min(todos.length, start + MAX_ROWS);
+    if (end - start < MAX_ROWS) {
+        start = Math.max(0, end - MAX_ROWS);
+    }
+    return todos.slice(start, end);
+}
+function TodoRow({ todo, maxWidth }) {
+    const theme = useTheme();
+    const { glyph, color, label } = statusStyle(todo, theme);
+    const text = label || todo.content;
+    const trimmed = text.length > maxWidth - 4 ? text.slice(0, maxWidth - 5) + "…" : text;
+    return (_jsx("box", { style: { height: 1 }, children: _jsxs("text", { fg: color, children: [glyph, " ", trimmed] }) }));
+}
+function statusStyle(todo, theme) {
+    if (todo.status === "completed") {
+        return { glyph: "✔", color: theme.dim, dim: true, label: todo.content };
+    }
+    if (todo.status === "in_progress") {
+        return { glyph: "▶", color: theme.accent, dim: false, label: todo.activeForm || todo.content };
+    }
+    return { glyph: "○", color: theme.muted, dim: false, label: todo.content };
+}

package/dist/tui-opentui/trace-groups.d.ts

@@ -0,0 +1,27 @@
+import type { DisplayToolCall } from "./display-history.js";
+export type TraceGroupKind = "list" | "read" | "search" | "execute" | "edit" | "write" | "subagent" | "other";
+export interface TraceGroup {
+    kind: TraceGroupKind;
+    title: string;
+    raw: DisplayToolCall[];
+    count?: number;
+    noun?: string;
+    command?: string;
+    items: string[];
+    previewLines: string[];
+    errorLines: string[];
+    omitted: number;
+    pending: boolean;
+    hasError: boolean;
+    errorCount: number;
+    startedAt?: number;
+}
+export interface TraceGroupOptions {
+    maxItems?: number;
+    maxPreviewLines?: number;
+    homeDir?: string;
+}
+export declare function buildTraceGroups(toolCalls: DisplayToolCall[], options?: TraceGroupOptions): TraceGroup[];
+export declare function formatTracePath(value: unknown, homeDir?: string): string;
+export declare function formatElapsed(startedAt: number | undefined, now?: number): string | null;
+export declare function traceGroupLabel(group: TraceGroup): string;

package/dist/tui-opentui/trace-groups.js

@@ -0,0 +1,412 @@
+import os from "node:os";
+import { getEditDiffDetails } from "./edit-diff.js";
+import { formatSubagentRoute } from "../agent/subagent-route-format.js";
+const DEFAULT_MAX_ITEMS = 6;
+const DEFAULT_MAX_PREVIEW_LINES = 8;
+export function buildTraceGroups(toolCalls, options = {}) {
+    const maxItems = options.maxItems ?? DEFAULT_MAX_ITEMS;
+    const maxPreviewLines = options.maxPreviewLines ?? DEFAULT_MAX_PREVIEW_LINES;
+    const homeDir = options.homeDir ?? os.homedir();
+    const groups = [];
+    let bucket = [];
+    let bucketClassifier = null;
+    const flush = () => {
+        if (bucket.length === 0 || !bucketClassifier)
+            return;
+        groups.push(buildTraceGroup(bucketClassifier, bucket, {
+            maxItems,
+            maxPreviewLines,
+            homeDir,
+        }));
+        bucket = [];
+        bucketClassifier = null;
+    };
+    for (const toolCall of toolCalls) {
+        const classifier = classifyTool(toolCall);
+        if (!classifier.groupable) {
+            flush();
+            groups.push(buildTraceGroup(classifier, [toolCall], {
+                maxItems,
+                maxPreviewLines,
+                homeDir,
+            }));
+            continue;
+        }
+        if (bucketClassifier?.bucketKey === classifier.bucketKey) {
+            bucket.push(toolCall);
+        }
+        else {
+            flush();
+            bucket = [toolCall];
+            bucketClassifier = classifier;
+        }
+    }
+    flush();
+    return groups;
+}
+export function formatTracePath(value, homeDir = os.homedir()) {
+    const text = String(value ?? "").trim();
+    if (!text)
+        return "";
+    if (text === homeDir)
+        return "~";
+    if (text.startsWith(homeDir + "/"))
+        return "~" + text.slice(homeDir.length);
+    return text;
+}
+export function formatElapsed(startedAt, now = Date.now()) {
+    if (!startedAt)
+        return null;
+    const seconds = Math.max(0, Math.floor((now - startedAt) / 1000));
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remainder = seconds % 60;
+    return `${minutes}m${remainder.toString().padStart(2, "0")}s`;
+}
+export function traceGroupLabel(group) {
+    if (group.command)
+        return `${group.title} ${group.command}`;
+    if (group.count !== undefined && group.noun)
+        return `${group.title} ${group.count} ${group.noun}`;
+    return group.title;
+}
+function classifyTool(toolCall) {
+    if (toolCall.metadata?.kind === "subagent") {
+        return { kind: "subagent", title: "Subagents", bucketKey: `subagent:${toolCall.id}`, groupable: false };
+    }
+    switch (toolCall.name) {
+        case "glob": {
+            const pattern = String(toolCall.args.pattern ?? "");
+            const title = isDirectoryLikeGlob(pattern) ? "List Directory" : "Find Files";
+            return {
+                kind: "list",
+                title,
+                bucketKey: `list:${title}`,
+                groupable: true,
+            };
+        }
+        case "read":
+            return { kind: "read", title: "Read", bucketKey: "read", groupable: true };
+        case "grep":
+            return { kind: "search", title: "Search", bucketKey: "search", groupable: true };
+        case "bash":
+            return { kind: "execute", title: "Execute", bucketKey: `execute:${toolCall.id}`, groupable: false };
+        case "edit":
+            return { kind: "edit", title: "Edit", bucketKey: `edit:${toolCall.id}`, groupable: false };
+        case "write":
+            return { kind: "write", title: "Write", bucketKey: "write", groupable: true };
+        default:
+            return {
+                kind: "other",
+                title: displayToolName(toolCall.name),
+                bucketKey: `${toolCall.name}:${toolCall.id}`,
+                groupable: false,
+            };
+    }
+}
+function buildTraceGroup(classifier, raw, options) {
+    const pending = raw.some((tool) => isToolPending(tool));
+    const startedAt = raw
+        .filter((tool) => isToolPending(tool))
+        .map((tool) => tool.startedAt)
+        .filter((value) => typeof value === "number")
+        .sort((a, b) => a - b)[0];
+    const hasError = raw.some((tool) => !!tool.isError);
+    const errorCount = raw.filter((tool) => !!tool.isError).length;
+    switch (classifier.kind) {
+        case "list":
+            return buildListGroup(classifier, raw, options, pending, startedAt, hasError, errorCount);
+        case "read":
+            return buildPathGroup(classifier, raw, options, pending, startedAt, hasError, errorCount, "files");
+        case "search":
+            return buildSearchGroup(classifier, raw, options, pending, startedAt, hasError, errorCount);
+        case "execute":
+            return buildExecuteGroup(classifier, raw[0], options, pending, startedAt, hasError, errorCount);
+        case "edit":
+        case "write":
+            return buildMutationGroup(classifier, raw, options, pending, startedAt, hasError, errorCount);
+        case "subagent":
+            return buildSubagentGroup(classifier, raw[0], options, pending, startedAt);
+        default:
+            return buildOtherGroup(classifier, raw, options, pending, startedAt, hasError, errorCount);
+    }
+}
+function buildListGroup(classifier, raw, options, pending, startedAt, hasError, errorCount) {
+    const resultItems = raw.flatMap((tool) => resultLines(tool.result).map((line) => formatTracePath(line, options.homeDir)));
+    const fallbackItems = raw
+        .map((tool) => String(tool.args.pattern ?? tool.args.path ?? "").trim())
+        .filter(Boolean)
+        .map((item) => formatTracePath(item, options.homeDir));
+    const sourceItems = resultItems.length > 0 ? resultItems : fallbackItems;
+    const { shown, omitted } = take(sourceItems, options.maxItems);
+    const count = resultItems.length > 0 ? resultItems.length : sourceItems.length || raw.length;
+    const noun = resultItems.length > 0 ? plural(count, "file", "files") : plural(count, "search", "searches");
+    return {
+        kind: "list",
+        title: classifier.title,
+        raw,
+        count,
+        noun,
+        items: shown,
+        previewLines: [],
+        errorLines: collectErrorLines(raw, options),
+        omitted,
+        pending,
+        hasError,
+        errorCount,
+        startedAt,
+    };
+}
+function buildPathGroup(classifier, raw, options, pending, startedAt, hasError, errorCount, nounBase) {
+    const items = unique(raw
+        .map((tool) => formatTracePath(tool.args.path ?? tool.args.file ?? "", options.homeDir))
+        .filter(Boolean));
+    const { shown, omitted } = take(items, options.maxItems);
+    const count = items.length || raw.length;
+    return {
+        kind: classifier.kind,
+        title: classifier.title,
+        raw,
+        count,
+        noun: plural(count, nounBase.slice(0, -1), nounBase),
+        items: shown,
+        previewLines: [],
+        errorLines: collectErrorLines(raw, options),
+        omitted,
+        pending,
+        hasError,
+        errorCount,
+        startedAt,
+    };
+}
+function buildSearchGroup(classifier, raw, options, pending, startedAt, hasError, errorCount) {
+    const items = raw.map((tool) => {
+        const pattern = String(tool.args.pattern ?? tool.args.query ?? "").trim();
+        const scope = String(tool.args.path ?? tool.args.glob ?? tool.args.include ?? "").trim();
+        const patternText = pattern ? `"${pattern}"` : "(pattern)";
+        return scope ? `${patternText} in ${formatTracePath(scope, options.homeDir)}` : patternText;
+    });
+    const { shown, omitted } = take(items, options.maxItems);
+    const count = raw.length;
+    return {
+        kind: "search",
+        title: classifier.title,
+        raw,
+        count,
+        noun: plural(count, "search", "searches"),
+        items: shown,
+        previewLines: [],
+        errorLines: collectErrorLines(raw, options),
+        omitted,
+        pending,
+        hasError,
+        errorCount,
+        startedAt,
+    };
+}
+function buildExecuteGroup(classifier, tool, options, pending, startedAt, hasError, errorCount) {
+    const lines = resultLines(tool.result).map((line) => formatTracePath(line, options.homeDir));
+    const { shown, omitted } = take(lines, options.maxPreviewLines);
+    return {
+        kind: "execute",
+        title: classifier.title,
+        raw: [tool],
+        command: normalizeCommand(tool.args.command ?? tool.args.cmd ?? commandFromRawArguments(tool.rawArguments)),
+        items: [],
+        previewLines: shown,
+        errorLines: [],
+        omitted,
+        pending,
+        hasError,
+        errorCount,
+        startedAt,
+    };
+}
+function buildMutationGroup(classifier, raw, options, pending, startedAt, hasError, errorCount) {
+    const items = raw
+        .map((tool) => {
+        const path = formatTracePath(tool.args.path ?? "", options.homeDir);
+        const details = tool.name === "edit" ? getEditDiffDetails(tool) : null;
+        const suffix = details ? ` ${formatCompactEditStats(details.added, details.removed)}` : "";
+        return path ? `${path}${suffix}` : "";
+    })
+        .filter(Boolean);
+    const { shown, omitted } = take(items, options.maxItems);
+    const count = items.length || raw.length;
+    const errorPreview = hasError
+        ? raw
+            .filter((tool) => tool.isError)
+            .flatMap((tool) => resultLines(tool.result).map((line) => formatTracePath(line, options.homeDir)))
+            .slice(0, options.maxPreviewLines)
+        : [];
+    return {
+        kind: classifier.kind,
+        title: classifier.title,
+        raw,
+        count,
+        noun: plural(count, "file", "files"),
+        items: shown,
+        previewLines: errorPreview,
+        errorLines: [],
+        omitted,
+        pending,
+        hasError,
+        errorCount,
+        startedAt,
+    };
+}
+function buildSubagentGroup(classifier, tool, options, pending, startedAt) {
+    const subagents = subagentsFromMetadata(tool);
+    const rows = subagents.length > 0
+        ? subagents.map(formatSubagentRow)
+        : resultLines(tool.result).map((line) => formatTracePath(line, options.homeDir));
+    const { shown, omitted } = take(rows, options.maxPreviewLines);
+    const errorCount = subagents.filter(isFailedSubagent).length + (tool.isError ? 1 : 0);
+    return {
+        kind: "subagent",
+        title: classifier.title,
+        raw: [tool],
+        count: subagents.length || 1,
+        noun: plural(subagents.length || 1, "agent", "agents"),
+        items: [],
+        previewLines: shown,
+        errorLines: [],
+        omitted,
+        pending: pending || subagents.some((subagent) => ["queued", "running"].includes(subagent.status ?? "running")),
+        hasError: !!tool.isError || errorCount > 0,
+        errorCount,
+        startedAt,
+    };
+}
+function buildOtherGroup(classifier, raw, options, pending, startedAt, hasError, errorCount) {
+    const tool = raw[0];
+    const header = toolHeader(tool, options.homeDir);
+    const preview = resultLines(tool.result).map((line) => formatTracePath(line, options.homeDir));
+    const { shown, omitted } = take(preview, options.maxPreviewLines);
+    return {
+        kind: "other",
+        title: classifier.title,
+        raw,
+        count: header ? undefined : raw.length,
+        noun: header ? undefined : plural(raw.length, "call", "calls"),
+        items: header ? [header] : [],
+        previewLines: shown,
+        errorLines: [],
+        omitted,
+        pending,
+        hasError,
+        errorCount,
+        startedAt,
+    };
+}
+function subagentsFromMetadata(tool) {
+    const raw = tool.metadata?.subagents;
+    if (!Array.isArray(raw))
+        return [];
+    return raw.filter((item) => typeof item === "object" && item !== null);
+}
+function formatSubagentRow(subagent) {
+    const label = subagent.nickname || subagent.agentName || subagent.subAgentId || "subagent";
+    const role = [subagent.agentName, subagent.category ? `/${subagent.category}` : ""].join("") || "default";
+    const route = formatSubagentRoute(subagent.route);
+    const descriptor = route ? `${role} @ ${route}` : role;
+    const status = subagent.status || "running";
+    const note = subagent.error
+        || subagent.toolNotes?.filter(Boolean).at(-1)
+        || subagent.summary
+        || subagent.task
+        || "";
+    return [label, `(${descriptor})`, status, note].filter(Boolean).join(" ");
+}
+function isFailedSubagent(subagent) {
+    return subagent.status === "failed" || subagent.status === "blocked" || subagent.status === "cancelled";
+}
+function isToolPending(tool) {
+    return tool.result === undefined;
+}
+function isDirectoryLikeGlob(pattern) {
+    const normalized = pattern.trim();
+    return normalized === "" || normalized === "*" || normalized === "**" || normalized === "**/*";
+}
+function resultLines(result) {
+    if (result === undefined)
+        return [];
+    return result
+        .replace(/\r\n/g, "\n")
+        .split("\n")
+        .map((line) => line.trimEnd())
+        .filter((line) => line.trim() !== "");
+}
+function take(items, max) {
+    const shown = items.slice(0, max);
+    return { shown, omitted: Math.max(0, items.length - shown.length) };
+}
+function unique(items) {
+    return [...new Set(items)];
+}
+function collectErrorLines(raw, options) {
+    return raw
+        .filter((tool) => tool.isError)
+        .flatMap((tool) => resultLines(tool.result).map((line) => formatTraceLine(line, options.homeDir)))
+        .slice(0, options.maxPreviewLines);
+}
+function formatTraceLine(value, homeDir) {
+    const text = String(value ?? "").trimEnd();
+    if (!homeDir)
+        return text;
+    return text.split(homeDir + "/").join("~/").split(homeDir).join("~");
+}
+function plural(count, singular, pluralValue) {
+    return count === 1 ? singular : pluralValue;
+}
+function normalizeCommand(value) {
+    const command = String(value ?? "").replace(/\s+/g, " ").trim();
+    return command;
+}
+function commandFromRawArguments(rawArguments) {
+    if (!rawArguments)
+        return "";
+    try {
+        const parsed = JSON.parse(rawArguments);
+        if (parsed && typeof parsed === "object") {
+            const command = parsed.command ?? parsed.cmd;
+            return typeof command === "string" ? command : "";
+        }
+    }
+    catch {
+        const match = rawArguments.match(/"(?:command|cmd)"\s*:\s*"((?:\\.|[^"\\])*)/);
+        if (match?.[1]) {
+            try {
+                return JSON.parse(`"${match[1]}"`);
+            }
+            catch {
+                return match[1];
+            }
+        }
+    }
+    return "";
+}
+function displayToolName(name) {
+    if (!name)
+        return "Tool";
+    return name.charAt(0).toUpperCase() + name.slice(1).replace(/_/g, " ");
+}
+function toolHeader(tool, homeDir) {
+    const args = tool.args || {};
+    for (const key of ["path", "command", "pattern", "query", "url"]) {
+        const value = args[key];
+        if (value !== undefined && value !== null && String(value).trim() !== "") {
+            return formatTracePath(value, homeDir);
+        }
+    }
+    return undefined;
+}
+function formatCompactEditStats(added, removed) {
+    const parts = [];
+    if (added > 0)
+        parts.push(`+${added}`);
+    if (removed > 0)
+        parts.push(`-${removed}`);
+    return parts.length > 0 ? `(${parts.join(" ")})` : "";
+}

package/dist/tui-opentui/use-terminal-size.d.ts

@@ -0,0 +1,4 @@
+export declare function useTerminalSize(): {
+    columns: number;
+    rows: number;
+};

package/dist/tui-opentui/use-terminal-size.js

@@ -0,0 +1,5 @@
+import { useTerminalDimensions } from "@opentui/react";
+export function useTerminalSize() {
+    const { width, height } = useTerminalDimensions();
+    return { columns: width || 80, rows: height || 24 };
+}

package/dist/tui-opentui/welcome.d.ts

@@ -0,0 +1,25 @@
+/** @jsxImportSource @opentui/react */
+import React from "react";
+import type { DisplayMessage } from "./display-history.js";
+interface WelcomeBannerProps {
+    terminalColumns: number;
+    modelLabel?: string;
+    cwd?: string;
+    tips: string[];
+    skillsCount?: number;
+    mcpConnectedCount?: number;
+    mcpTotalCount?: number;
+    hasAgentsFile?: boolean;
+}
+interface HomeSurfaceProps extends WelcomeBannerProps {
+    terminalRows: number;
+    composer: React.ReactNode;
+}
+interface WelcomeVisibilityInput {
+    messages: Pick<DisplayMessage, "role" | "syntheticKind">[];
+    startedWithVisibleHistory: boolean;
+}
+export declare function shouldShowWelcomeBanner({ messages, startedWithVisibleHistory, }: WelcomeVisibilityInput): boolean;
+export declare function WelcomeBanner({ terminalColumns, modelLabel, cwd, tips, skillsCount, mcpConnectedCount, mcpTotalCount, hasAgentsFile, }: WelcomeBannerProps): React.ReactNode;
+export declare function HomeSurface({ terminalColumns, terminalRows, modelLabel, cwd, tips, skillsCount, mcpConnectedCount, mcpTotalCount, hasAgentsFile, composer, }: HomeSurfaceProps): React.ReactNode;
+export {};