@bubblebrain-ai/bubble 0.0.63 → 0.0.65

package/dist/tui/run.d.ts

@@ -0,0 +1,72 @@
+import type { Agent } from "../agent.js";
+import type { SessionManager } from "../session.js";
+import type { ProviderRegistry } from "../provider-registry.js";
+import type { SkillRegistry } from "../skills/registry.js";
+import type { PlanDecision } from "../types.js";
+import type { ApprovalDecision, ApprovalRequest } from "../approval/types.js";
+import type { QuestionController } from "../question/controller.js";
+import type { BashAllowlist } from "../approval/session-cache.js";
+import type { SettingsManager } from "../permissions/settings.js";
+import type { LspService } from "../lsp/service.js";
+import type { McpManager } from "../mcp/manager.js";
+import type { GoalStore } from "../goal/store.js";
+import type { ProcessManager } from "../tasks/manager.js";
+import type { PromotionChannel } from "../tasks/promotion.js";
+import type { ThemeMode } from "../config.js";
+import type { ExternalHookController } from "../hooks/controller.js";
+import type { ExternalRuntimeManager } from "../external-runtime/types.js";
+import type { FlushScheduler } from "./controller/ports.js";
+export interface RunTuiOptions {
+    sessionManager?: SessionManager;
+    createProvider?: (providerId: string, apiKey: string, baseURL: string) => unknown;
+    registry?: ProviderRegistry;
+    skillRegistry?: SkillRegistry;
+    planHandlerRef?: {
+        current?: (plan: string) => Promise<PlanDecision>;
+    };
+    approvalHandlerRef?: {
+        current?: (request: ApprovalRequest) => Promise<ApprovalDecision>;
+    };
+    questionController?: QuestionController;
+    bashAllowlist?: BashAllowlist;
+    settingsManager?: SettingsManager;
+    switchSession?: (sessionFile: string) => {
+        manager: SessionManager;
+    } | {
+        error: string;
+    };
+    createFreshSession?: (cwd: string) => {
+        manager: SessionManager;
+    } | {
+        error: string;
+    };
+    lspService?: LspService;
+    mcpManager?: McpManager;
+    goalStore?: GoalStore;
+    processManager?: ProcessManager;
+    tasksAutoResume?: boolean;
+    promotionChannel?: PromotionChannel;
+    themeMode?: ThemeMode;
+    themeOverrides?: Record<string, string>;
+    detectedTheme?: "light" | "dark";
+    onThemeModeChange?: (mode: ThemeMode) => void;
+    flushMemory?: () => Promise<void>;
+    runMemoryCompaction?: () => Promise<string>;
+    runMemorySummary?: (scope?: string) => Promise<string>;
+    runMemoryRefresh?: (scope?: string) => Promise<string>;
+    bypassEnabled?: boolean;
+    updateNotice?: string;
+    updateNoticeRefresh?: Promise<string | null>;
+    hookController?: ExternalHookController;
+    externalRuntime?: ExternalRuntimeManager;
+}
+export interface TuiExitSummary {
+    exitCode: number;
+    reason: string;
+    wallMs: number;
+}
+export declare function runTui(agent: Agent, _args: unknown, options: RunTuiOptions): Promise<TuiExitSummary>;
+/** Resolve after first paint so git discovery never delays TUI startup. */
+export declare function currentGitBranch(cwd: string): Promise<string | undefined>;
+/** Production streaming repaint scheduler: one cancellable timer per burst. */
+export declare function createFlushScheduler(): FlushScheduler;

package/dist/tui/run.js

@@ -0,0 +1,139 @@
+/**
+ * Pi TUI production entry. Keeps the RunTuiOptions surface main.ts builds so
+ * renderer startup and shutdown remain isolated from application wiring.
+ */
+import process from "node:process";
+import { execFile } from "node:child_process";
+import { BubbleTuiController } from "./controller/controller.js";
+import { PiTuiApp } from "./app.js";
+export async function runTui(agent, _args, options) {
+    const controller = new BubbleTuiController({
+        agent,
+        sessionManager: options.sessionManager,
+        goalStore: options.goalStore,
+        processManager: options.processManager,
+        tasksAutoResume: options.tasksAutoResume,
+        promotionChannel: options.promotionChannel,
+        workspaceCwd: process.cwd(),
+        ports: buildPorts(options),
+    });
+    const app = new PiTuiApp({
+        agent,
+        sessionManager: options.sessionManager,
+        registry: options.registry,
+        createProvider: options.createProvider,
+        skillRegistry: options.skillRegistry,
+        bashAllowlist: options.bashAllowlist,
+        settingsManager: options.settingsManager,
+        hookController: options.hookController,
+        mcpManager: options.mcpManager,
+        lspService: options.lspService,
+        questionController: options.questionController,
+        planHandlerRef: options.planHandlerRef,
+        approvalHandlerRef: options.approvalHandlerRef,
+        controller,
+        updateNotice: options.updateNotice,
+        updateNoticeRefresh: options.updateNoticeRefresh,
+        flushMemory: options.flushMemory,
+        runMemoryCompaction: options.runMemoryCompaction,
+        runMemorySummary: options.runMemorySummary,
+        runMemoryRefresh: options.runMemoryRefresh,
+        themeMode: options.themeMode,
+        detectedTheme: options.detectedTheme,
+        themeOverrides: options.themeOverrides,
+        resolveGitBranch: currentGitBranch,
+        // Fullscreen is the production root renderer. Selecting it before start()
+        // prevents a regular-screen frame from ever being painted at startup.
+        uiMode: "fullscreen",
+        callbacks: {
+            onExitRequest: () => { },
+            onClearTranscript: () => controller.clearTranscript(),
+            onThemeToggle: () => {
+                // Kept for embedded hosts compiled against the pre-runtime-theme
+                // callback shape. /theme now uses onThemeModeChange directly.
+            },
+            onThemeModeChange: (mode) => {
+                options.onThemeModeChange?.(mode);
+            },
+            onCompact: () => {
+                void options.runMemoryCompaction?.();
+            },
+        },
+    });
+    const startedAt = Date.now();
+    app.start();
+    const sigterm = () => app.dispose();
+    process.once("SIGTERM", sigterm);
+    try {
+        await app.waitUntilExit();
+    }
+    finally {
+        process.removeListener("SIGTERM", sigterm);
+        // The app has stopped painting, but the runtime still retains owner-session
+        // bindings. Reap first, then persist killed terminal markers so a resumed
+        // session never contains a dangling `task_started` lifecycle.
+        await options.processManager?.shutdownTasks();
+        controller.persistFinalTaskMarkers();
+    }
+    return { exitCode: 0, reason: "user-quit", wallMs: Date.now() - startedAt };
+}
+/** Resolve after first paint so git discovery never delays TUI startup. */
+export function currentGitBranch(cwd) {
+    return new Promise((resolve) => {
+        execFile("git", ["-C", cwd, "branch", "--show-current"], { timeout: 3_000 }, (error, stdout) => {
+            if (error) {
+                resolve(undefined);
+                return;
+            }
+            resolve(stdout.trim() || undefined);
+        });
+    });
+}
+/** Production streaming repaint scheduler: one cancellable timer per burst. */
+export function createFlushScheduler() {
+    let pending = null;
+    return {
+        scheduleFlush: (intervalMs, flush) => {
+            if (pending !== null)
+                return;
+            pending = setTimeout(() => {
+                pending = null;
+                flush();
+            }, intervalMs);
+        },
+        cancelFlush: () => {
+            if (pending !== null)
+                clearTimeout(pending);
+            pending = null;
+        },
+    };
+}
+function buildPorts(options) {
+    return {
+        clock: { now: () => Date.now() },
+        scheduler: {
+            setTimeout: (callback, ms) => {
+                const timer = setTimeout(callback, ms);
+                return { [Symbol.dispose]: () => clearTimeout(timer) };
+            },
+            setInterval: (callback, ms) => {
+                const timer = setInterval(callback, ms);
+                return { [Symbol.dispose]: () => clearInterval(timer) };
+            },
+        },
+        flush: createFlushScheduler(),
+        terminal: {
+            isMultiplexed: () => !!process.env.TMUX || (process.env.TERM ?? "").startsWith("screen"),
+        },
+        sessionHost: {
+            switchSession: (file) => options.switchSession
+                ? options.switchSession(file)
+                : { error: "session switching not configured" },
+            createFresh: (cwd) => options.createFreshSession
+                ? options.createFreshSession(cwd)
+                : { error: "fresh session creation not configured" },
+        },
+        git: { currentBranch: () => undefined },
+        exitProcess: (code) => process.exit(code),
+    };
+}

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

@@ -0,0 +1,6 @@
+import type { SessionMetadata } from "../session.js";
+export interface SessionDisplaySource {
+    getMetadata(): SessionMetadata;
+    getSessionFile(): string;
+}
+export declare function sessionDisplayName(sessionManager?: SessionDisplaySource): string;

package/dist/tui/session-display.js

@@ -0,0 +1,12 @@
+import { normalizeSingleLine, truncateVisual } from "../text-display.js";
+const SESSION_DISPLAY_TITLE_MAX_WIDTH = 80;
+export function sessionDisplayName(sessionManager) {
+    if (!sessionManager)
+        return "Session";
+    const title = truncateVisual(normalizeSingleLine(sessionManager.getMetadata().title ?? ""), SESSION_DISPLAY_TITLE_MAX_WIDTH);
+    if (title)
+        return title;
+    const file = sessionManager.getSessionFile();
+    const name = file.split(/[\\/]/).pop() || "Session";
+    return name.replace(/\.jsonl$/, "");
+}

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/terminal/multiplexer.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Terminal multiplexer detection for the controller's terminal probe.
+ * Reuses the legacy detection semantics (tmux/screen force full reprints).
+ */
+export declare function isMultiplexedTerminalLike(env?: NodeJS.ProcessEnv): boolean;

package/dist/tui/terminal/multiplexer.js

@@ -0,0 +1,14 @@
+/**
+ * Terminal multiplexer detection for the controller's terminal probe.
+ * Reuses the legacy detection semantics (tmux/screen force full reprints).
+ */
+export function isMultiplexedTerminalLike(env = process.env) {
+    if (env.TMUX)
+        return true;
+    const term = env.TERM ?? "";
+    if (term.startsWith("screen") || term.startsWith("tmux"))
+        return true;
+    if (env.STY)
+        return true;
+    return false;
+}

package/dist/tui/testing/fake-agent.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Scripted fake agent: replays a fixed AgentEvent[] per run so controller
+ * tests drive full sessions deterministically (no provider, no network).
+ */
+import type { AgentRunOptions } from "../../agent.js";
+import type { Message } from "../../types.js";
+import type { AgentEvent } from "../../types.js";
+export interface FakeAgentRunScript {
+    events: AgentEvent[];
+    /** Throw this error at the end of the script instead of completing. */
+    failWith?: Error;
+}
+export declare class FakeAgent {
+    messages: Message[];
+    scripts: FakeAgentRunScript[];
+    runCalls: Array<{
+        input: unknown;
+        options?: AgentRunOptions;
+    }>;
+    sessionIds: string[];
+    setSessionID(file: string): void;
+    enqueueScript(script: FakeAgentRunScript): void;
+    run(userInput: unknown, _cwd: string, options?: AgentRunOptions): AsyncIterable<AgentEvent>;
+}

package/dist/tui/testing/fake-agent.js

@@ -0,0 +1,22 @@
+export class FakeAgent {
+    messages = [];
+    scripts = [];
+    runCalls = [];
+    sessionIds = [];
+    setSessionID(file) {
+        this.sessionIds.push(file);
+    }
+    enqueueScript(script) {
+        this.scripts.push(script);
+    }
+    async *run(userInput, _cwd, options) {
+        this.runCalls.push({ input: userInput, options });
+        const script = this.scripts.shift() ?? { events: [{ type: "turn_end" }] };
+        for (const event of script.events) {
+            yield event;
+        }
+        if (script.failWith) {
+            throw script.failWith;
+        }
+    }
+}

package/dist/tui/testing/spy-host.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Headless spy host: deterministic ports for controller tests.
+ * Records every effect and snapshot version so integration tests can assert
+ * exact sequences without a terminal.
+ */
+import type { BubbleTuiPorts } from "../controller/ports.js";
+import type { ControllerEffect } from "../controller/effects.js";
+export declare class SpyHost {
+    readonly effects: ControllerEffect[];
+    readonly snapshotVersions: number[];
+    private flushPending;
+    private nowMs;
+    readonly ports: BubbleTuiPorts;
+    readonly exitCodes: number[];
+    /** Fire any pending debounced flush (simulates the 40ms timer). */
+    fireFlush(): void;
+    advanceNow(deltaMs: number): void;
+    recordEffect(effect: ControllerEffect): void;
+    recordSnapshot(version: number): void;
+    effectsOf(kind: ControllerEffect["kind"]): ControllerEffect[];
+}

package/dist/tui/testing/spy-host.js

@@ -0,0 +1,55 @@
+export class SpyHost {
+    effects = [];
+    snapshotVersions = [];
+    flushPending = null;
+    nowMs = 10_000;
+    ports = {
+        clock: { now: () => this.nowMs },
+        scheduler: {
+            setTimeout: (callback, ms) => {
+                const timer = setTimeout(callback, ms);
+                return { [Symbol.dispose ?? Symbol.for("nodejs.dispose")]: () => clearTimeout(timer) };
+            },
+            setInterval: (callback, ms) => {
+                const timer = setInterval(callback, ms);
+                return { [Symbol.dispose ?? Symbol.for("nodejs.dispose")]: () => clearInterval(timer) };
+            },
+        },
+        flush: {
+            scheduleFlush: (_intervalMs, flush) => {
+                this.flushPending ??= { flush };
+            },
+            cancelFlush: () => {
+                this.flushPending = null;
+            },
+        },
+        terminal: { isMultiplexed: () => false },
+        sessionHost: {
+            switchSession: () => ({ error: "spy host: switchSession not configured" }),
+            createFresh: () => ({ error: "spy host: createFresh not configured" }),
+        },
+        git: { currentBranch: () => undefined },
+        exitProcess: (code) => {
+            this.exitCodes.push(code);
+        },
+    };
+    exitCodes = [];
+    /** Fire any pending debounced flush (simulates the 40ms timer). */
+    fireFlush() {
+        const pending = this.flushPending;
+        this.flushPending = null;
+        pending?.flush();
+    }
+    advanceNow(deltaMs) {
+        this.nowMs += deltaMs;
+    }
+    recordEffect(effect) {
+        this.effects.push(effect);
+    }
+    recordSnapshot(version) {
+        this.snapshotVersions.push(version);
+    }
+    effectsOf(kind) {
+        return this.effects.filter((effect) => effect.kind === kind);
+    }
+}

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

@@ -0,0 +1,43 @@
+import type { DisplayToolCall } from "./display-history.js";
+export type TraceGroupKind = "list" | "read" | "search" | "execute" | "edit" | "write" | "subagent" | "other";
+export interface TraceGroup {
+    kind: TraceGroupKind;
+    title: string;
+    raw: DisplayToolCall[];
+    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[];
+    omitted: number;
+    pending: boolean;
+    hasError: boolean;
+    errorCount: number;
+    startedAt?: number;
+}
+export interface TraceGroupOptions {
+    maxItems?: number;
+    maxPreviewLines?: number;
+    homeDir?: string;
+}
+export declare function buildTraceGroups(toolCalls: DisplayToolCall[], options?: TraceGroupOptions): TraceGroup[];
+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;
+};