@bubblebrain-ai/bubble 0.0.7 → 0.0.9

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

@@ -0,0 +1,389 @@
+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 ?? ""),
+        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 || "(command)";
+}
+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-ink/use-terminal-size.d.ts

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

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

@@ -0,0 +1,21 @@
+import { useEffect, useState } from "react";
+import { useStdout } from "ink";
+export function useTerminalSize() {
+    const { stdout } = useStdout();
+    const [size, setSize] = useState(() => ({
+        columns: stdout?.columns || 80,
+        rows: stdout?.rows || 24,
+    }));
+    useEffect(() => {
+        if (!stdout)
+            return;
+        const onResize = () => {
+            setSize({ columns: stdout.columns || 80, rows: stdout.rows || 24 });
+        };
+        stdout.on("resize", onResize);
+        return () => {
+            stdout.off("resize", onResize);
+        };
+    }, [stdout]);
+    return size;
+}

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

@@ -0,0 +1,18 @@
+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 WelcomeVisibilityInput {
+    messages: Pick<DisplayMessage, "role" | "syntheticKind">[];
+    startedWithVisibleHistory: boolean;
+}
+export declare function shouldShowWelcomeBanner({ startedWithVisibleHistory, }: WelcomeVisibilityInput): boolean;
+export declare function WelcomeBanner({ terminalColumns, modelLabel, cwd, tips, skillsCount, mcpConnectedCount, mcpTotalCount, hasAgentsFile, }: WelcomeBannerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/tui-ink/welcome.js

@@ -0,0 +1,138 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import React from "react";
+import { Box, Text } from "ink";
+import { createRequire } from "node:module";
+import { useTheme } from "./theme.js";
+const require = createRequire(import.meta.url);
+const PACKAGE_VERSION = readPackageVersion();
+const BUBBLE_LOGO_LETTERS = [
+    [
+        "██████ ",
+        "██   ██",
+        "██   ██",
+        "██████ ",
+        "██   ██",
+        "██   ██",
+        "██████ ",
+    ],
+    [
+        "██   ██",
+        "██   ██",
+        "██   ██",
+        "██   ██",
+        "██   ██",
+        "██   ██",
+        " █████ ",
+    ],
+    [
+        "██████ ",
+        "██   ██",
+        "██   ██",
+        "██████ ",
+        "██   ██",
+        "██   ██",
+        "██████ ",
+    ],
+    [
+        "██████ ",
+        "██   ██",
+        "██   ██",
+        "██████ ",
+        "██   ██",
+        "██   ██",
+        "██████ ",
+    ],
+    [
+        "██     ",
+        "██     ",
+        "██     ",
+        "██     ",
+        "██     ",
+        "██     ",
+        "███████",
+    ],
+    [
+        "███████",
+        "██     ",
+        "██     ",
+        "██████ ",
+        "██     ",
+        "██     ",
+        "███████",
+    ],
+];
+/**
+ * Derive a 6-step logo gradient from the active theme tokens so the banner
+ * stays readable on both dark and light backgrounds.
+ */
+function logoColors(theme) {
+    return [
+        theme.userMessageText,
+        theme.userMessageText,
+        theme.inputBorder,
+        theme.inputBorder,
+        theme.traceCommand,
+        theme.traceCommand,
+    ];
+}
+const COMPACT_LOGO = ["B", "U", "B", "B", "L", "E"];
+const WIDE_LOGO_MIN_WIDTH = 52;
+export function shouldShowWelcomeBanner({ startedWithVisibleHistory, }) {
+    // Banner is committed to Static scrollback once at session start. Flipping
+    // this flag back to false (e.g. when a picker opens) shrinks the Static
+    // items list — when the items grow back, ink replays the banner a second
+    // time into scrollback. Keep visibility decided purely by initial history.
+    if (startedWithVisibleHistory)
+        return false;
+    return true;
+}
+export function WelcomeBanner({ terminalColumns, modelLabel, cwd, tips, skillsCount = 0, mcpConnectedCount = 0, mcpTotalCount = 0, hasAgentsFile = false, }) {
+    const theme = useTheme();
+    const effectiveWidth = Math.max(20, Math.min(terminalColumns - 2, 118));
+    const useWideLogo = effectiveWidth >= WIDE_LOGO_MIN_WIDTH;
+    const actionableTips = tips
+        .filter((item) => !item.startsWith("Ready with") && item.trim().length > 0)
+        .slice(0, 2);
+    const tip = actionableTips.length > 0
+        ? actionableTips.join(" · ")
+        : "Type / for commands and @ to reference files";
+    const modelLine = modelLabel ? `${modelLabel}${cwd ? ` · ${cwd}` : ""}` : cwd;
+    return (_jsxs(Box, { width: effectiveWidth, flexDirection: "column", alignItems: "center", marginBottom: 1, children: [_jsx(Box, { flexDirection: "column", alignItems: "center", children: useWideLogo
+                    ? BUBBLE_LOGO_LETTERS[0].map((_, rowIndex) => (_jsx(LogoRow, { rowIndex: rowIndex }, `logo-row-${rowIndex}`)))
+                    : _jsx(CompactLogo, {}) }), _jsx(Box, { marginTop: 2, children: _jsx(Text, { bold: true, color: theme.muted, children: PACKAGE_VERSION }) }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { bold: true, color: theme.userMessageText, children: "TIP: " }), _jsx(Text, { bold: true, color: theme.userMessageText, children: tip })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.muted, children: "shift+tab to cycle modes \u00B7 ctrl+r for reasoning \u00B7 ctrl+o for trace" }) }), modelLine && (_jsx(Box, { children: _jsx(Text, { color: theme.muted, children: truncateToWidth(modelLine, effectiveWidth - 4) }) })), _jsxs(Box, { marginTop: 1, children: [_jsx(StatusItem, { label: "Skills", count: skillsCount, ok: skillsCount > 0 }), _jsx(Text, { color: theme.muted, children: "  " }), _jsx(StatusItem, { label: "MCPs", count: mcpConnectedCount, total: mcpTotalCount, ok: mcpTotalCount === 0 || mcpConnectedCount === mcpTotalCount }), _jsx(Text, { color: theme.muted, children: "  " }), _jsx(StatusItem, { label: "AGENTS.md", ok: hasAgentsFile })] })] }));
+}
+function LogoRow({ rowIndex }) {
+    const theme = useTheme();
+    const colors = logoColors(theme);
+    return (_jsx(Box, { children: BUBBLE_LOGO_LETTERS.map((letter, index) => (_jsxs(React.Fragment, { children: [_jsx(Text, { bold: true, color: colors[index], children: letter[rowIndex] }), index < BUBBLE_LOGO_LETTERS.length - 1 && _jsx(Text, { children: " " })] }, `${index}-${rowIndex}`))) }));
+}
+function CompactLogo() {
+    const theme = useTheme();
+    const colors = logoColors(theme);
+    return (_jsx(Box, { children: COMPACT_LOGO.map((letter, index) => (_jsx(Text, { bold: true, color: colors[index], children: letter }, `${letter}-${index}`))) }));
+}
+function StatusItem({ label, count, total, ok, }) {
+    const theme = useTheme();
+    const countText = count === undefined
+        ? ""
+        : total !== undefined && total > count
+            ? ` (${count}/${total})`
+            : ` (${count})`;
+    return (_jsxs(_Fragment, { children: [_jsxs(Text, { bold: true, color: theme.muted, children: [label, countText, " "] }), _jsx(Text, { bold: true, color: ok ? theme.success : theme.error, children: ok ? "✓" : "×" })] }));
+}
+function readPackageVersion() {
+    try {
+        const pkg = require("../../package.json");
+        return pkg.version ? `v${pkg.version}` : "v0.0.0";
+    }
+    catch {
+        return "v0.0.0";
+    }
+}
+function truncateToWidth(text, maxWidth) {
+    if (maxWidth <= 0)
+        return "";
+    if (text.length <= maxWidth)
+        return text;
+    return text.slice(0, Math.max(1, maxWidth - 1)) + "…";
+}

package/dist/types.d.ts

@@ -101,6 +101,9 @@ export interface ToolResultMetadata {
     searchFamily?: string;
     reason?: string;
     arbiterNote?: string;
+    diff?: string;
+    addedLines?: number;
+    removedLines?: number;
     [key: string]: unknown;
 }
 export interface ToolResult {
@@ -117,6 +120,8 @@ export interface ToolUpdate {
     subAgentId: string;
     agentName: string;
     nickname?: string;
+    category?: string;
+    route?: import("./agent/categories.js").ResolvedSubagentRoute;
     status: "queued" | "running" | "completed" | "failed" | "blocked" | "cancelled";
     childEvent?: AgentEvent;
     summaryDelta?: string;
@@ -144,6 +149,8 @@ export interface ToolContext {
             runId: string;
             subAgentId: string;
             parentToolCallId: string;
+            category?: string;
+            route?: import("./agent/categories.js").ResolvedSubagentRoute;
             approval?: "fail" | "disabled";
             emitUpdate?: (update: ToolUpdate) => void;
             description?: string;
@@ -154,6 +161,8 @@ export interface ToolContext {
         spawnSubAgent?: (input: string | ContentPart[], cwd: string, options: {
             profile: import("./agent/profiles.js").AgentProfile;
             parentToolCallId: string;
+            category?: string;
+            route?: import("./agent/categories.js").ResolvedSubagentRoute;
             approval?: "fail" | "disabled";
             description?: string;
             abortSignal?: AbortSignal;
@@ -299,6 +308,7 @@ export type AgentEvent = {
 } | {
     type: "turn_end";
     usage?: TokenUsage;
+    willContinue?: boolean;
 } | {
     type: "context_recovered";
     droppedMessages: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bubblebrain-ai/bubble",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "A terminal coding agent",
   "type": "module",
   "engines": {
@@ -27,14 +27,20 @@
     "@opentui/core": "^0.1.99",
     "@opentui/solid": "^0.1.99",
     "@types/better-sqlite3": "^7.6.13",
+    "@types/react": "^19.2.14",
     "@vue/language-server": "^3.2.7",
     "better-sqlite3": "^12.9.0",
     "chalk": "^5.3.0",
     "diff": "^7.0.0",
+    "ink": "^7.0.3",
+    "js-tiktoken": "^1.0.21",
     "openai": "^4.77.0",
     "opentui-spinner": "^0.0.6",
     "picomatch": "^4.0.4",
+    "react": "^19.2.6",
+    "shiki": "^4.0.2",
     "solid-js": "^1.9.11",
+    "string-width": "^8.2.1",
     "typescript-language-server": "^5.1.3",
     "vscode-jsonrpc": "^8.2.1",
     "vscode-langservers-extracted": "^4.10.0"