@bubblebrain-ai/bubble 0.0.20 → 0.0.22

package/dist/tui/session-picker-data.d.ts

@@ -0,0 +1,18 @@
+import type { SessionSummary } from "../session.js";
+export interface SessionPickerEntry {
+    /** Session title (or first-message preview when untitled). */
+    label: string;
+    /** Message count, e.g. "12 messages". */
+    detail: string;
+    /** Absolute path to the session .jsonl file. */
+    value: string;
+    /** "current" for the active session, otherwise a relative timestamp. */
+    footer: string;
+    /** "●" marks the active session. */
+    gutter?: string;
+}
+export declare function buildSessionPickerEntries(summaries: SessionSummary[], activeFile: string | undefined, now?: number): SessionPickerEntry[];
+/** Default selection: the most recent session that is not the active one. */
+export declare function preferredSessionPickerIndex(entries: Array<{
+    gutter?: string;
+}>): number;

package/dist/tui/session-picker-data.js

@@ -0,0 +1,21 @@
+import { normalizeSingleLine, truncateVisual } from "../text-display.js";
+import { formatRelativeTime } from "./recent-activity.js";
+const SESSION_PICKER_LABEL_MAX_WIDTH = 72;
+export function buildSessionPickerEntries(summaries, activeFile, now = Date.now()) {
+    return summaries.map((summary) => {
+        const isCurrent = summary.file === activeFile;
+        const label = truncateVisual(normalizeSingleLine(summary.title || summary.preview || summary.name), SESSION_PICKER_LABEL_MAX_WIDTH) || summary.name;
+        return {
+            label,
+            detail: `${summary.messageCount} message${summary.messageCount === 1 ? "" : "s"}`,
+            value: summary.file,
+            footer: isCurrent ? "current" : formatRelativeTime(summary.mtime, now),
+            gutter: isCurrent ? "●" : undefined,
+        };
+    });
+}
+/** Default selection: the most recent session that is not the active one. */
+export function preferredSessionPickerIndex(entries) {
+    const firstOther = entries.findIndex((entry) => entry.gutter !== "●");
+    return firstOther >= 0 ? firstOther : 0;
+}

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 };
@@ -244,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: [],
@@ -400,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

@@ -8,6 +8,8 @@ export interface BubbleWordmarkLine {
     tone?: BubbleWordmarkTone;
     segments?: BubbleWordmarkSegment[];
 }
+export declare const BUBBLE_CAT: BubbleWordmarkLine[];
+export declare const BUBBLE_CAT_LARGE: BubbleWordmarkLine[];
 export declare const BUBBLE_WORDMARK: BubbleWordmarkLine[];
 export declare const BUBBLE_WORDMARK_LARGE: BubbleWordmarkLine[];
 export declare const BUBBLE_COMPACT_WORDMARK: BubbleWordmarkLine[];

package/dist/tui/wordmark.js

@@ -22,6 +22,27 @@ const LOWER_B = {
         "    ",
     ],
 };
+// Pixel cat mascot, drawn on the same half-block pixel grid as the letters:
+// pointy ears, 2x2-pixel eyes, tiny mouth, round chin (10x14 pixels). It is
+// stacked above the wordmark (icon-over-name lockup) rather than inlined, so
+// its solid fill doesn't compete with the thin letter strokes.
+const CAT_LINES = [
+    " █▄    ▄█ ",
+    " ███▄▄███ ",
+    "██████████",
+    "█  ████  █",
+    "████▀▀████",
+    "██████████",
+    " ▀██████▀ ",
+];
+export const BUBBLE_CAT = CAT_LINES.map((text) => ({
+    text,
+    tone: "brand",
+}));
+export const BUBBLE_CAT_LARGE = CAT_LINES.map((text) => ({
+    text: text.split("").map((ch) => ch + ch).join(""),
+    tone: "brand",
+}));
 const GLYPHS = {
     u: {
         tone: "ink",
@@ -172,10 +193,16 @@ export function bubbleWordmarkLineText(line) {
 export function bubbleWordmarkMaxWidth(lines = BUBBLE_WORDMARK) {
     return Math.max(...lines.map((line) => bubbleWordmarkLineText(line).length));
 }
+const LOGO_GAP = { text: "", tone: "caption" };
+// Icon-over-name lockup: pixel cat centered above the wordmark. Both render
+// sites center every line independently, which is what stacks the cat over
+// the text without any per-line padding here.
 export function bubbleWordmarkForWidth(width) {
-    if (width >= bubbleWordmarkMaxWidth(BUBBLE_WORDMARK_LARGE) + 4)
-        return BUBBLE_WORDMARK_LARGE;
-    if (width >= bubbleWordmarkMaxWidth() + 4)
-        return BUBBLE_WORDMARK;
+    if (width >= bubbleWordmarkMaxWidth(BUBBLE_WORDMARK_LARGE) + 4) {
+        return [...BUBBLE_CAT_LARGE, LOGO_GAP, ...BUBBLE_WORDMARK_LARGE];
+    }
+    if (width >= bubbleWordmarkMaxWidth() + 4) {
+        return [...BUBBLE_CAT, LOGO_GAP, ...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 {};