@bubblebrain-ai/bubble 0.0.20 → 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 };
@@ -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-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 {};