@bubblebrain-ai/bubble 0.0.19 → 0.0.21

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

@@ -7,6 +7,10 @@ export interface TraceGroup {
     count?: number;
     noun?: string;
     command?: string;
+    /** Model-provided one-line summary of what the command does (bash `description` arg). */
+    description?: string;
+    /** Original command split into lines, line breaks preserved (execute groups only). */
+    commandLines?: string[];
     items: string[];
     previewLines: string[];
     errorLines: string[];
@@ -25,3 +29,15 @@ export declare function buildTraceGroups(toolCalls: DisplayToolCall[], options?:
 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;
+/**
+ * An execute command is shown inline in the header only when nothing is lost:
+ * no description competing for the slot, a single logical line, and it fits
+ * the width budget. Otherwise the full command renders as a wrapped block
+ * below the header — commands are never clipped mid-line.
+ */
+export declare function shouldInlineExecuteCommand(group: TraceGroup, widthBudget: number): boolean;
+/** Visible command-block lines for compact rendering, capped at `maxLines`. */
+export declare function executeCommandBlock(group: TraceGroup, maxLines: number): {
+    lines: string[];
+    omitted: number;
+};

package/dist/tui/trace-groups.js

@@ -65,12 +65,36 @@ export function formatElapsed(startedAt, now = Date.now()) {
     return `${minutes}m${remainder.toString().padStart(2, "0")}s`;
 }
 export function traceGroupLabel(group) {
+    if (group.description)
+        return `${group.title} ${group.description}`;
     if (group.command)
         return `${group.title} ${group.command}`;
     if (group.count !== undefined && group.noun)
         return `${group.title} ${group.count} ${group.noun}`;
     return group.title;
 }
+/**
+ * An execute command is shown inline in the header only when nothing is lost:
+ * no description competing for the slot, a single logical line, and it fits
+ * the width budget. Otherwise the full command renders as a wrapped block
+ * below the header — commands are never clipped mid-line.
+ */
+export function shouldInlineExecuteCommand(group, widthBudget) {
+    if (group.kind !== "execute" || !group.command)
+        return false;
+    if (group.description)
+        return false;
+    const lines = group.commandLines ?? [];
+    if (lines.length > 1)
+        return false;
+    return group.command.length <= widthBudget;
+}
+/** Visible command-block lines for compact rendering, capped at `maxLines`. */
+export function executeCommandBlock(group, maxLines) {
+    const lines = group.commandLines ?? [];
+    const shown = lines.slice(0, maxLines);
+    return { lines: shown, omitted: Math.max(0, lines.length - shown.length) };
+}
 function classifyTool(toolCall) {
     if (toolCall.metadata?.kind === "subagent") {
         return { kind: "subagent", title: "Subagents", bucketKey: `subagent:${toolCall.id}`, groupable: false };
@@ -133,15 +157,17 @@ function buildTraceGroup(classifier, raw, options) {
     }
 }
 function buildListGroup(classifier, raw, options, pending, startedAt, hasError, errorCount) {
-    const resultItems = raw.flatMap((tool) => resultLines(tool.result).map((line) => formatTracePath(line, options.homeDir)));
+    const matchCount = listMatchCount(raw);
+    const resultItems = raw.flatMap((tool) => listResultItems(tool, 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 hasResultData = matchCount !== undefined || resultItems.length > 0 || raw.some((tool) => isEmptyListResult(tool.result));
+    const sourceItems = hasResultData ? 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");
+    const count = matchCount ?? (hasResultData ? resultItems.length : sourceItems.length || raw.length);
+    const noun = hasResultData ? plural(count, "file", "files") : plural(count, "search", "searches");
     return {
         kind: "list",
         title: classifier.title,
@@ -158,6 +184,40 @@ function buildListGroup(classifier, raw, options, pending, startedAt, hasError,
         startedAt,
     };
 }
+function listResultItems(tool, homeDir) {
+    const metadataPaths = Array.isArray(tool.metadata?.paths)
+        ? tool.metadata.paths.filter((item) => typeof item === "string" && item.trim().length > 0)
+        : [];
+    if (metadataPaths.length > 0 || typeof tool.metadata?.matches === "number") {
+        return metadataPaths.map((line) => formatTracePath(line, homeDir));
+    }
+    return resultLines(tool.result)
+        .filter(isListResultLine)
+        .map((line) => formatTracePath(line, homeDir));
+}
+function listMatchCount(raw) {
+    let count = 0;
+    let sawMetadata = false;
+    for (const tool of raw) {
+        const matches = tool.metadata?.matches;
+        if (typeof matches === "number" && Number.isFinite(matches)) {
+            count += Math.max(0, matches);
+            sawMetadata = true;
+        }
+    }
+    return sawMetadata ? count : undefined;
+}
+function isEmptyListResult(result) {
+    if (result === undefined)
+        return false;
+    const lines = resultLines(result);
+    return lines.length > 0 && lines.every((line) => !isListResultLine(line));
+}
+function isListResultLine(line) {
+    const normalized = line.trim();
+    return !/^No files found\.?$/i.test(normalized)
+        && !/^\[More than \d+ files, output truncated\]$/i.test(normalized);
+}
 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))
@@ -208,11 +268,15 @@ function buildSearchGroup(classifier, raw, options, pending, startedAt, hasError
 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);
+    const rawCommand = String(tool.args.command ?? tool.args.cmd ?? commandFromRawArguments(tool.rawArguments) ?? "");
+    const description = String(tool.args.description ?? "").trim() || undefined;
     return {
         kind: "execute",
         title: classifier.title,
         raw: [tool],
-        command: normalizeCommand(tool.args.command ?? tool.args.cmd ?? commandFromRawArguments(tool.rawArguments)),
+        command: normalizeCommand(rawCommand),
+        description,
+        commandLines: commandLinesOf(rawCommand),
         items: [],
         previewLines: shown,
         errorLines: [],
@@ -364,6 +428,19 @@ function normalizeCommand(value) {
     const command = String(value ?? "").replace(/\s+/g, " ").trim();
     return command;
 }
+// Preserves the command's own line structure (heredocs, && chains the model
+// formatted across lines); only trims trailing whitespace and outer blank lines.
+function commandLinesOf(rawCommand) {
+    const lines = rawCommand
+        .replace(/\r\n/g, "\n")
+        .split("\n")
+        .map((line) => line.trimEnd());
+    while (lines.length > 0 && lines[0].trim() === "")
+        lines.shift();
+    while (lines.length > 0 && lines[lines.length - 1].trim() === "")
+        lines.pop();
+    return lines;
+}
 function commandFromRawArguments(rawArguments) {
     if (!rawArguments)
         return "";

package/dist/tui/transcript-scroll.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Transcript scroll-follow policy.
+ *
+ * The transcript snaps to the bottom ("follows") while the user is at the
+ * bottom, and stays put while they read older history. Two events override a
+ * scrolled-up position and re-engage following:
+ *   - the user sends a message (explicit intent to watch the newest turn)
+ *   - an approval prompt appears (requires the user's attention)
+ *
+ * Those renders set `forcePending`, which must survive until the deferred
+ * scroll actually runs: streaming redraws in the interim recompute the follow
+ * flag from the (still unscrolled) position and would otherwise cancel the
+ * snap. A user mouse scroll clears the pending force — their latest gesture
+ * always wins.
+ */
+export interface TranscriptScrollState {
+    /** A forceFollow render is waiting for its deferred scroll to execute. */
+    forcePending: boolean;
+    /** The viewport was at the bottom when the update was scheduled. */
+    shouldFollow: boolean;
+    /** Live follow flag, recomputed from the viewport position on each render. */
+    following: boolean;
+}
+export type TranscriptScrollAction = "scroll-bottom" | "sync-position";
+export declare function resolveTranscriptScroll(state: TranscriptScrollState): TranscriptScrollAction;

package/dist/tui/transcript-scroll.js

@@ -0,0 +1,20 @@
+/**
+ * Transcript scroll-follow policy.
+ *
+ * The transcript snaps to the bottom ("follows") while the user is at the
+ * bottom, and stays put while they read older history. Two events override a
+ * scrolled-up position and re-engage following:
+ *   - the user sends a message (explicit intent to watch the newest turn)
+ *   - an approval prompt appears (requires the user's attention)
+ *
+ * Those renders set `forcePending`, which must survive until the deferred
+ * scroll actually runs: streaming redraws in the interim recompute the follow
+ * flag from the (still unscrolled) position and would otherwise cancel the
+ * snap. A user mouse scroll clears the pending force — their latest gesture
+ * always wins.
+ */
+export function resolveTranscriptScroll(state) {
+    if (state.forcePending)
+        return "scroll-bottom";
+    return state.shouldFollow && state.following ? "scroll-bottom" : "sync-position";
+}

package/dist/tui/wordmark.d.ts

@@ -9,6 +9,7 @@ export interface BubbleWordmarkLine {
     segments?: BubbleWordmarkSegment[];
 }
 export declare const BUBBLE_WORDMARK: BubbleWordmarkLine[];
+export declare const BUBBLE_WORDMARK_LARGE: BubbleWordmarkLine[];
 export declare const BUBBLE_COMPACT_WORDMARK: BubbleWordmarkLine[];
 export declare function bubbleWordmarkLineText(line: BubbleWordmarkLine): string;
 export declare function bubbleWordmarkMaxWidth(lines?: BubbleWordmarkLine[]): number;

package/dist/tui/wordmark.js

@@ -1,24 +1,24 @@
+// Pixel-style glyphs: each cell is a half-block "pixel" (█ ▀ ▄), giving the
+// wordmark an 8-bit look while staying one terminal row per line.
 const LEAD_B = {
     tone: "brand",
     lines: [
-        "│   ",
-        "│   ",
-        "├─╮ ",
-        "│ │ ",
-        "│ │ ",
-        "╰─╯ ",
+        "█   ",
+        "█   ",
+        "█▀█ ",
+        "█ █ ",
+        "█▄█ ",
         "    ",
     ],
 };
 const LOWER_B = {
     tone: "ink",
     lines: [
-        "│   ",
-        "│   ",
-        "├─╮ ",
-        "│ │ ",
-        "│ │ ",
-        "╰─╯ ",
+        "█   ",
+        "█   ",
+        "█▀█ ",
+        "█ █ ",
+        "█▄█ ",
         "    ",
     ],
 };
@@ -28,22 +28,20 @@ const GLYPHS = {
         lines: [
             "    ",
             "    ",
-            "╷ ╷ ",
-            "│ │ ",
-            "│ │ ",
-            "╰─╯ ",
+            "█ █ ",
+            "█ █ ",
+            "█▄█ ",
             "    ",
         ],
     },
     l: {
         tone: "ink",
         lines: [
-            "│  ",
-            "│  ",
-            "│  ",
-            "│  ",
-            "│  ",
-            "╰─ ",
+            "█  ",
+            "█  ",
+            "█  ",
+            "█  ",
+            "█▄ ",
             "   ",
         ],
     },
@@ -52,23 +50,21 @@ const GLYPHS = {
         lines: [
             "    ",
             "    ",
-            "╭─╮ ",
-            "├─┤ ",
-            "│   ",
-            "╰─╯ ",
+            "█▀█ ",
+            "█▀▀ ",
+            "█▄▄ ",
             "    ",
         ],
     },
     beta: {
         tone: "brand",
         lines: [
-            "╭─╮ ",
-            "│ │ ",
-            "├─╯ ",
-            "├─╮ ",
-            "│ │ ",
-            "├─╯ ",
-            "│   ",
+            "█▀▀▄ ",
+            "█  █ ",
+            "█▀▀▄ ",
+            "█  █ ",
+            "█▄▄▀ ",
+            "█    ",
         ],
     },
     r: {
@@ -76,10 +72,9 @@ const GLYPHS = {
         lines: [
             "    ",
             "    ",
-            "╭─╮ ",
-            "│   ",
-            "│   ",
-            "│   ",
+            "█▀▀ ",
+            "█   ",
+            "█   ",
             "    ",
         ],
     },
@@ -88,22 +83,20 @@ const GLYPHS = {
         lines: [
             "    ",
             "    ",
-            "╭─╮ ",
-            "│ │ ",
-            "├─┤ ",
-            "│ │ ",
+            "▀▀█ ",
+            "█▀█ ",
+            "█▄█ ",
             "    ",
         ],
     },
     i: {
         tone: "ink",
         lines: [
-            "• ",
             "  ",
-            "│ ",
-            "│ ",
-            "│ ",
-            "╰ ",
+            "▀ ",
+            "█ ",
+            "█ ",
+            "█ ",
             "  ",
         ],
     },
@@ -112,10 +105,9 @@ const GLYPHS = {
         lines: [
             "    ",
             "    ",
-            "╭─╮ ",
-            "│ │ ",
-            "│ │ ",
-            "│ │ ",
+            "█▀█ ",
+            "█ █ ",
+            "█ █ ",
             "    ",
         ],
     },
@@ -128,11 +120,10 @@ const GLYPHS = {
             "  ",
             "  ",
             "  ",
-            "  ",
         ],
     },
 };
-export const BUBBLE_WORDMARK = buildWordmark([
+const WORDMARK_GLYPHS = [
     LEAD_B,
     GLYPHS.u,
     LOWER_B,
@@ -145,7 +136,14 @@ export const BUBBLE_WORDMARK = buildWordmark([
     GLYPHS.a,
     GLYPHS.i,
     GLYPHS.n,
-]);
+];
+export const BUBBLE_WORDMARK = buildWordmark(WORDMARK_GLYPHS);
+// Each pixel doubled horizontally: terminal cells are ~2:1 tall, so 2-char
+// pixels render square and the wordmark reads much larger.
+export const BUBBLE_WORDMARK_LARGE = buildWordmark(WORDMARK_GLYPHS.map((glyph) => ({
+    tone: glyph.tone,
+    lines: glyph.lines.map((line) => line.split("").map((ch) => ch + ch).join("")),
+})));
 export const BUBBLE_COMPACT_WORDMARK = [
     {
         segments: [
@@ -175,5 +173,9 @@ export function bubbleWordmarkMaxWidth(lines = BUBBLE_WORDMARK) {
     return Math.max(...lines.map((line) => bubbleWordmarkLineText(line).length));
 }
 export function bubbleWordmarkForWidth(width) {
-    return width < bubbleWordmarkMaxWidth() + 4 ? BUBBLE_COMPACT_WORDMARK : BUBBLE_WORDMARK;
+    if (width >= bubbleWordmarkMaxWidth(BUBBLE_WORDMARK_LARGE) + 4)
+        return BUBBLE_WORDMARK_LARGE;
+    if (width >= bubbleWordmarkMaxWidth() + 4)
+        return BUBBLE_WORDMARK;
+    return BUBBLE_COMPACT_WORDMARK;
 }

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

@@ -12,6 +12,7 @@ import type { McpManager } from "../mcp/manager.js";
 import type { LspService } from "../lsp/index.js";
 import type { QuestionController } from "../question/index.js";
 import type { MemoryScope } from "../memory/index.js";
+import type { ExternalHookController } from "../hooks/controller.js";
 export interface PlanHandlerRef {
     current?: (plan: string) => Promise<PlanDecision>;
 }
@@ -42,11 +43,13 @@ interface AppProps {
     runMemoryRefresh?: (scope?: MemoryScope) => Promise<string>;
     /** Whether the bypassPermissions mode is reachable via Shift+Tab cycling. */
     bypassEnabled?: boolean;
+    updateNotice?: string;
+    hookController?: ExternalHookController;
     onExit?: (summary: ExitSummary) => void;
 }
 export interface ExitSummary {
     /** Wall-clock duration of the session, in milliseconds. */
     wallMs: number;
 }
-export declare function App({ agent, args, sessionManager, createProvider, registry, skillRegistry, planHandlerRef, approvalHandlerRef, questionController, bashAllowlist, settingsManager, lspService, mcpManager, themeMode: initialThemeMode, themeOverrides, detectedTheme, onThemeModeChange, flushMemory, runMemoryCompaction, runMemorySummary, runMemoryRefresh, bypassEnabled, onExit }: AppProps): import("react/jsx-runtime").JSX.Element;
+export declare function App({ agent, args, sessionManager, createProvider, registry, skillRegistry, planHandlerRef, approvalHandlerRef, questionController, bashAllowlist, settingsManager, lspService, mcpManager, themeMode: initialThemeMode, themeOverrides, detectedTheme, onThemeModeChange, flushMemory, runMemoryCompaction, runMemorySummary, runMemoryRefresh, bypassEnabled, updateNotice, hookController, onExit }: AppProps): import("react/jsx-runtime").JSX.Element;
 export {};