@bubblebrain-ai/bubble 0.0.12 → 0.0.13

package/dist/agent/input-controller.d.ts

@@ -0,0 +1,11 @@
+import type { AgentInputController, AgentRunInput } from "../types.js";
+export declare class AgentRunInputQueue implements AgentInputController {
+    private readonly idPrefix;
+    private pending;
+    private nextInputId;
+    constructor(idPrefix?: string);
+    enqueue(content: string): AgentRunInput;
+    drainPendingInputs(): AgentRunInput[];
+    pendingInputCount(): number;
+    clear(): AgentRunInput[];
+}

package/dist/agent/input-controller.js

@@ -0,0 +1,30 @@
+export class AgentRunInputQueue {
+    idPrefix;
+    pending = [];
+    nextInputId = 0;
+    constructor(idPrefix = "input") {
+        this.idPrefix = idPrefix;
+    }
+    enqueue(content) {
+        const input = {
+            id: `${this.idPrefix}-${++this.nextInputId}`,
+            content,
+            submittedAt: Date.now(),
+        };
+        this.pending.push(input);
+        return input;
+    }
+    drainPendingInputs() {
+        if (this.pending.length === 0)
+            return [];
+        const inputs = this.pending;
+        this.pending = [];
+        return inputs;
+    }
+    pendingInputCount() {
+        return this.pending.length;
+    }
+    clear() {
+        return this.drainPendingInputs();
+    }
+}

package/dist/agent.d.ts

@@ -3,7 +3,7 @@
  * It maintains message state, calls the LLM, executes tools, and auto-continues.
  */
 import { type ContextUsageSnapshot } from "./context/usage.js";
-import type { AgentEvent, ContentPart, PermissionMode, Message, Provider, ThinkingLevel, Todo, ToolResult, ToolRegistryEntry, ToolUpdate } from "./types.js";
+import type { AgentEvent, AgentInputController, ContentPart, PermissionMode, Message, Provider, ThinkingLevel, Todo, ToolResult, ToolRegistryEntry, ToolUpdate } from "./types.js";
 import { type TurnHooks } from "./orchestrator/hooks.js";
 import { type AgentCategoriesConfig, type ResolvedSubagentRoute } from "./agent/categories.js";
 import { BudgetLedger } from "./agent/budget-ledger.js";
@@ -46,6 +46,10 @@ export interface AgentOptions {
     agentCategories?: AgentCategoriesConfig;
     providerFactory?: (route: ResolvedSubagentRoute) => Provider | Promise<Provider>;
 }
+export interface AgentRunOptions {
+    abortSignal?: AbortSignal;
+    inputController?: AgentInputController;
+}
 export declare class Agent {
     messages: Message[];
     private provider;
@@ -116,9 +120,7 @@ export declare class Agent {
     /** Internal: snapshot counter that bumps on every setTodos. Used by run loop to detect mutations. */
     get todosVersion(): number;
     setSystemPrompt(prompt: string): void;
-    run(userInput: string | ContentPart[], cwd: string, options?: {
-        abortSignal?: AbortSignal;
-    }): AsyncIterable<AgentEvent>;
+    run(userInput: string | ContentPart[], cwd: string, options?: AgentRunOptions): AsyncIterable<AgentEvent>;
     private recoverFromOverflow;
     compactResidentHistory(): void;
     private maybeCompactWithLLM;

package/dist/agent.js

@@ -236,6 +236,7 @@ export class Agent {
     }
     async *run(userInput, cwd, options = {}) {
         const abortSignal = composeAbortSignals([options.abortSignal, this.budgetLedger?.signal]);
+        const inputController = options.inputController;
         throwIfAborted(abortSignal);
         const hookBus = new HookBus();
         for (const hooks of createDefaultHooks()) {
@@ -249,6 +250,39 @@ export class Agent {
         const queueReminder = (reminder) => {
             reminderQueue.push(reminder);
         };
+        const pendingInputCount = () => inputController?.pendingInputCount() ?? 0;
+        const applyPendingInputs = () => {
+            const pendingInputs = inputController?.drainPendingInputs() ?? [];
+            if (pendingInputs.length === 0)
+                return [];
+            for (const input of pendingInputs) {
+                this.appendMessage({ role: "user", content: input.content });
+            }
+            return [
+                ...pendingInputs.map((input) => ({
+                    type: "input_applied",
+                    id: input.id,
+                    content: input.content,
+                    target: "current_turn",
+                })),
+                { type: "input_pending_changed", pending: pendingInputCount() },
+            ];
+        };
+        const rejectPendingInputs = (reason) => {
+            const pendingInputs = inputController?.drainPendingInputs() ?? [];
+            if (pendingInputs.length === 0)
+                return [];
+            return [
+                ...pendingInputs.map((input) => ({
+                    type: "input_rejected",
+                    id: input.id,
+                    content: input.content,
+                    reason,
+                    target: "next_turn",
+                })),
+                { type: "input_pending_changed", pending: pendingInputCount() },
+            ];
+        };
         const flushGovernorReminders = () => {
             for (const reminder of reminderQueue.splice(0, reminderQueue.length)) {
                 this.injectSystemReminder(reminder);
@@ -275,6 +309,8 @@ export class Agent {
             flushGovernorReminders();
             for (const update of this.drainSubagentToolUpdates())
                 yield update;
+            for (const event of applyPendingInputs())
+                yield event;
             yield { type: "turn_start" };
             step += 1;
             hookState.turnCount = step;
@@ -604,6 +640,8 @@ export class Agent {
                 delete hookState.forceContinuationReason;
                 continue;
             }
+            for (const event of rejectPendingInputs("no_continuation"))
+                yield event;
             break;
         }
         for (const update of this.drainSubagentToolUpdates())

package/dist/main.js

@@ -25,6 +25,8 @@ import { McpManager } from "./mcp/manager.js";
 import { QuestionController } from "./question/index.js";
 import { buildMemoryPrompt, formatMemoryStartupResult, recordMemoryCitations, runMemoryPhase2, runMemoryStartupPipeline, startMemoryStartupTask, } from "./memory/index.js";
 import { basename } from "node:path";
+import { normalizeSingleLine, truncateVisual } from "./text-display.js";
+import { BUBBLE_WORDMARK } from "./tui/wordmark.js";
 async function main() {
     const args = parseArgs(process.argv.slice(2));
     if (process.argv.includes("-h") || process.argv.includes("--help")) {
@@ -183,7 +185,7 @@ async function main() {
     // - --resume (no name): show interactive picker
     let sessionManager;
     let resumedExistingSession = false;
-    // Resolved before any Ink render so picker and main TUI share the same value
+    // Resolved before any TUI render so picker and main TUI share the same value
     // and we only run OSC 11 once.
     let preResolvedTheme;
     if (args.resume && !args.sessionName) {
@@ -195,13 +197,13 @@ async function main() {
         else {
             const themeConfig = userConfig.getTheme();
             if (themeConfig.mode === "auto") {
-                const { detectTerminalTheme } = await import("./tui-ink/detect-theme.js");
+                const { detectTerminalTheme } = await import("./tui/detect-theme.js");
                 preResolvedTheme = await detectTerminalTheme();
             }
             else {
                 preResolvedTheme = themeConfig.mode;
             }
-            const { runSessionPicker } = await import("./tui-ink/run-session-picker.js");
+            const { runSessionPicker } = await import("./tui-opentui/run-session-picker.js");
             const picked = await runSessionPicker({
                 currentCwd: args.cwd,
                 currentSessions,
@@ -422,9 +424,9 @@ async function main() {
             detectedTheme = preResolvedTheme;
         }
         else if (themeConfig.mode === "auto") {
-            // Probe before either TUI runtime owns stdin. OSC 11 needs raw mode, and
-            // runtime renderers can consume the reply before startup code sees it.
-            const { detectTerminalTheme } = await import("./tui-ink/detect-theme.js");
+            // Probe before OpenTUI owns stdin. OSC 11 needs raw mode, and the
+            // runtime renderer can consume the reply before startup code sees it.
+            const { detectTerminalTheme } = await import("./tui/detect-theme.js");
             detectedTheme = await detectTerminalTheme();
         }
         else {
@@ -447,7 +449,7 @@ async function main() {
             runMemorySummary,
             runMemoryRefresh,
         };
-        const { runTui } = await import("./tui-ink/run.js");
+        const { runTui } = await import("./tui/run.js");
         await runTui(agent, args, {
             ...commonOptions,
             themeMode: themeConfig.mode,
@@ -456,14 +458,61 @@ async function main() {
             onThemeModeChange: (mode) => userConfig.setThemeMode(mode),
         });
         if (sessionManager) {
-            const sessionName = basename(sessionManager.getSessionFile());
-            console.log(chalk.dim(`To resume: bubble --resume   (or --resume --session ${sessionName})`));
+            printOpenTuiExitSummary(sessionManager, {
+                resumed: resumedExistingSession,
+                theme: detectedTheme,
+            });
         }
     }
     finally {
         await shutdownRuntime();
     }
 }
+function printOpenTuiExitSummary(sessionManager, options) {
+    if (!process.stdout.isTTY)
+        return;
+    const sessionName = basename(sessionManager.getSessionFile());
+    const sessionId = sessionName.replace(/\.jsonl$/, "");
+    const title = truncateVisual(normalizeSingleLine(sessionManager.getMetadata().title ?? ""), 64);
+    const sessionLabel = title || `${options.resumed ? "Session" : "New session"} - ${sessionId}`;
+    const continueCommand = `bubble --resume --session ${sessionName}`;
+    const colors = options.theme === "light"
+        ? {
+            markMuted: chalk.hex("#8C8C8C"),
+            markStrong: chalk.hex("#1C1C1C"),
+            markBrand: chalk.hex("#8B4A00"),
+            label: chalk.hex("#6F7377"),
+            value: chalk.hex("#171717").bold,
+        }
+        : {
+            markMuted: chalk.hex("#9CA3AF"),
+            markStrong: chalk.hex("#F4F4F5"),
+            markBrand: chalk.hex("#F5A742"),
+            label: chalk.hex("#808080"),
+            value: chalk.hex("#EEEEEE").bold,
+        };
+    const label = (value) => colors.label(value.padEnd(10));
+    const logoColor = (tone) => {
+        switch (tone) {
+            case "brand": return colors.markBrand;
+            case "ink": return colors.markStrong;
+            case "stone": return colors.markMuted;
+            case "soft": return colors.label;
+            case "caption": return colors.label;
+        }
+    };
+    for (const line of BUBBLE_WORDMARK) {
+        if (line.segments) {
+            console.log(line.segments.map((segment) => logoColor(segment.tone)(segment.text)).join(""));
+        }
+        else {
+            console.log(logoColor(line.tone ?? "caption")(line.text ?? ""));
+        }
+    }
+    console.log();
+    console.log(`${label("Session")}${colors.value(sessionLabel)}`);
+    console.log(`${label("Continue")}${colors.value(continueCommand)}`);
+}
 async function readPipedStdin() {
     if (process.stdin.isTTY)
         return undefined;

package/dist/slash-commands/commands.js

@@ -312,6 +312,33 @@ const builtinSlashCommandEntries = [
             return `Theme set to ${arg}${arg === "auto" ? ` (resolved to ${resolved})` : ""}.`;
         },
     },
+    {
+        name: "sidebar",
+        description: "Toggle the right sidebar. Usage: /sidebar [open|close|auto]",
+        async handler(args, ctx) {
+            if (!ctx.toggleSidebar || !ctx.setSidebarMode) {
+                return "Sidebar control is only available inside the TUI.";
+            }
+            const arg = args.trim().toLowerCase();
+            if (!arg) {
+                ctx.toggleSidebar();
+                return;
+            }
+            if (["open", "show", "expand", "expanded", "on"].includes(arg)) {
+                ctx.setSidebarMode("expanded");
+                return;
+            }
+            if (["close", "hide", "collapse", "collapsed", "off"].includes(arg)) {
+                ctx.setSidebarMode("collapsed");
+                return;
+            }
+            if (arg === "auto") {
+                ctx.setSidebarMode("auto");
+                return;
+            }
+            return "Usage: /sidebar [open|close|auto]";
+        },
+    },
     {
         name: "clear",
         description: "Clear the current conversation history",

package/dist/slash-commands/types.d.ts

@@ -9,6 +9,12 @@ import type { McpManager } from "../mcp/manager.js";
 import type { LspService } from "../lsp/index.js";
 import type { MemoryScope } from "../memory/index.js";
 import type { ThemeMode } from "../config.js";
+export type SidebarMode = "auto" | "expanded" | "collapsed";
+export interface SidebarCommandState {
+    mode: SidebarMode;
+    visible: boolean;
+    active: boolean;
+}
 export interface SlashCommandContext {
     agent: Agent;
     addMessage: (role: "user" | "assistant" | "error", content: string) => void;
@@ -34,6 +40,10 @@ export interface SlashCommandContext {
     getResolvedTheme?: () => "light" | "dark";
     /** Persist a new theme mode AND apply it to the running TUI. */
     setThemeMode?: (mode: ThemeMode) => void;
+    /** Toggle the right session sidebar in the running TUI. */
+    toggleSidebar?: () => SidebarCommandState;
+    /** Set the right session sidebar mode in the running TUI. */
+    setSidebarMode?: (mode: SidebarMode) => SidebarCommandState;
     /** Open the feedback dialog. `initialDescription` prefills the description field. */
     openFeedback?: (initialDescription: string) => void;
 }

package/dist/tui/clipboard.d.ts

@@ -0,0 +1 @@
+export declare function copyTextToClipboard(text: string): Promise<void>;

package/dist/tui/clipboard.js

@@ -0,0 +1,53 @@
+import { spawn } from "node:child_process";
+export async function copyTextToClipboard(text) {
+    if (process.platform === "darwin") {
+        await writeToProcess("pbcopy", [], text);
+        return;
+    }
+    if (process.platform === "win32") {
+        await writeToProcess("powershell", [
+            "-NoProfile",
+            "-Command",
+            "Set-Clipboard -Value ([Console]::In.ReadToEnd())",
+        ], text);
+        return;
+    }
+    const candidates = [
+        ["wl-copy", []],
+        ["xclip", ["-selection", "clipboard"]],
+        ["xsel", ["--clipboard", "--input"]],
+    ];
+    let lastError;
+    for (const [command, args] of candidates) {
+        try {
+            await writeToProcess(command, args, text);
+            return;
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error("No clipboard command available");
+}
+function writeToProcess(command, args, input) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            stdio: ["pipe", "ignore", "pipe"],
+            windowsHide: true,
+        });
+        let stderr = "";
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(stderr.trim() || `${command} exited with code ${code}`));
+        });
+        child.stdin.end(input);
+    });
+}

package/dist/tui/detect-theme.d.ts

@@ -0,0 +1,2 @@
+export type ResolvedTheme = "light" | "dark";
+export declare function detectTerminalTheme(timeoutMs?: number): Promise<ResolvedTheme>;

package/dist/tui/detect-theme.js

@@ -0,0 +1,87 @@
+export async function detectTerminalTheme(timeoutMs = 150) {
+    const fromEnv = parseColorFgBg(process.env.COLORFGBG);
+    if (fromEnv)
+        return fromEnv;
+    if (process.stdout.isTTY && process.stdin.isTTY) {
+        const fromOsc = await queryOsc11(timeoutMs);
+        if (fromOsc)
+            return fromOsc;
+    }
+    return "dark";
+}
+function parseColorFgBg(value) {
+    if (!value)
+        return null;
+    const parts = value.split(";");
+    const last = parts[parts.length - 1];
+    if (!last)
+        return null;
+    const bg = parseInt(last, 10);
+    if (Number.isNaN(bg))
+        return null;
+    if (bg >= 0 && bg <= 6)
+        return "dark";
+    if (bg >= 7 && bg <= 15)
+        return "light";
+    return null;
+}
+function queryOsc11(timeoutMs) {
+    return new Promise((resolve) => {
+        const stdin = process.stdin;
+        const stdout = process.stdout;
+        let settled = false;
+        const originalRaw = stdin.isRaw;
+        let buffer = "";
+        const cleanup = () => {
+            stdin.removeListener("data", onData);
+            try {
+                stdin.setRawMode(originalRaw);
+            }
+            catch {
+                // ignore - terminal may have already restored
+            }
+            stdin.pause();
+        };
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            cleanup();
+            resolve(result);
+        };
+        const onData = (chunk) => {
+            buffer += chunk.toString("utf8");
+            const match = buffer.match(/\x1b\]11;rgb:([0-9a-fA-F]+)\/([0-9a-fA-F]+)\/([0-9a-fA-F]+)(?:\x07|\x1b\\)/);
+            if (!match)
+                return;
+            const [, r, g, b] = match;
+            const lum = relativeLuminance(parseHexChannel(r), parseHexChannel(g), parseHexChannel(b));
+            finish(lum > 0.5 ? "light" : "dark");
+        };
+        try {
+            stdin.setRawMode(true);
+        }
+        catch {
+            resolve(null);
+            return;
+        }
+        stdin.resume();
+        stdin.on("data", onData);
+        const timer = setTimeout(() => finish(null), timeoutMs);
+        try {
+            stdout.write("\x1b]11;?\x07");
+        }
+        catch {
+            finish(null);
+        }
+    });
+}
+function parseHexChannel(hex) {
+    const max = (1 << (hex.length * 4)) - 1;
+    return parseInt(hex, 16) / max;
+}
+function relativeLuminance(r, g, b) {
+    const channel = (c) => c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+    return 0.2126 * channel(r) + 0.7152 * channel(g) + 0.0722 * channel(b);
+}

package/dist/tui/display-history.d.ts

@@ -0,0 +1,62 @@
+import type { ToolResultMetadata, TokenUsage } from "../types.js";
+export interface CompactionMeta {
+    turns: number;
+    messages: number;
+    tokensSaved: number;
+    summarySections: Array<{
+        label: string;
+        content: string;
+    }>;
+    contextWindow?: number;
+    compactedAt: number;
+}
+export interface DisplayMessage {
+    role: "user" | "assistant" | "error";
+    content: string;
+    clientId?: string;
+    queued?: boolean;
+    reasoning?: string;
+    toolCalls?: DisplayToolCall[];
+    parts?: DisplayMessagePart[];
+    status?: "thinking" | "responding";
+    streaming?: boolean;
+    syntheticKind?: "ui_compact_card";
+    hiddenCount?: number;
+    compactionMeta?: CompactionMeta;
+    turnStartedAt?: number;
+    turnCompletedAt?: number;
+    turnUsage?: TokenUsage;
+    taskElapsedMs?: number;
+}
+export type DisplayMessagePart = DisplayTextPart | DisplayToolsPart;
+export interface DisplayTextPart {
+    type: "text";
+    content: string;
+}
+export interface DisplayToolsPart {
+    type: "tools";
+    toolCalls: DisplayToolCall[];
+}
+export interface DisplayToolCall {
+    id: string;
+    name: string;
+    args: Record<string, any>;
+    rawArguments?: string;
+    streamingArgs?: boolean;
+    /** During streaming, an approximate line count derived from `\n` escapes in rawArguments. */
+    streamingNewlineCount?: number;
+    status?: "pending" | "running" | "completed" | "error";
+    result?: string;
+    isError?: boolean;
+    metadata?: ToolResultMetadata;
+    startedAt?: number;
+    completedAt?: number;
+}
+export declare function appendTextPart(parts: DisplayMessagePart[], content: string): void;
+export declare function appendToolPart(parts: DisplayMessagePart[], toolCall: DisplayToolCall): void;
+export declare function snapshotDisplayParts(parts: DisplayMessagePart[]): DisplayMessagePart[];
+export declare function contentFromParts(parts: DisplayMessagePart[]): string;
+export declare function toolCallsFromParts(parts: DisplayMessagePart[]): DisplayToolCall[];
+export declare function compactDisplayMessages(messages: DisplayMessage[]): DisplayMessage[];
+export declare function truncateText(value: string, maxChars: number): string;
+export declare function formatCompactNumber(n: number): string;