@bubblebrain-ai/bubble 0.0.51 → 0.0.53

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/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.js

@@ -2,6 +2,7 @@ import os from "node:os";
 import { getEditDiffDetails } from "./edit-diff.js";
 import { formatSubagentRoute } from "../agent/subagent-route-format.js";
 import { mcpInfoFromString } from "../mcp/name.js";
+import { analyzeToolIntent } from "../agent/tool-intent.js";
 const DEFAULT_MAX_ITEMS = 6;
 const DEFAULT_MAX_PREVIEW_LINES = 8;
 export function buildTraceGroups(toolCalls, options = {}) {
@@ -100,6 +101,18 @@ function classifyTool(toolCall) {
     if (toolCall.metadata?.kind === "subagent") {
         return { kind: "subagent", title: "Subagents", bucketKey: `subagent:${toolCall.id}`, groupable: false };
     }
+    if (toolCall.name === "bash") {
+        const semanticKind = toolCall.metadata?.kind;
+        const family = semanticKind === "read" || semanticKind === "search"
+            ? semanticKind
+            : analyzeToolIntent({ name: toolCall.name, parsedArgs: toolCall.args }).family;
+        if (family === "read") {
+            return { kind: "read", title: "Read", bucketKey: "read", groupable: true };
+        }
+        if (family === "search") {
+            return { kind: "search", title: "Search", bucketKey: "search", groupable: true };
+        }
+    }
     switch (toolCall.name) {
         case "glob": {
             const pattern = String(toolCall.args.pattern ?? "");
@@ -194,7 +207,7 @@ 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") {
+    if (metadataPaths.length > 0) {
         return metadataPaths.map((line) => formatTracePath(line, homeDir));
     }
     return resultLines(tool.result)
@@ -226,7 +239,11 @@ function isListResultLine(line) {
 }
 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))
+        .map((tool) => formatTracePath(tool.args.path
+        ?? tool.args.file
+        ?? tool.metadata?.path
+        ?? analyzeToolIntent({ name: tool.name, parsedArgs: tool.args }).read?.path
+        ?? "", options.homeDir))
         .filter(Boolean));
     const { shown, omitted } = take(items, options.maxItems);
     const count = items.length || raw.length;
@@ -248,12 +265,16 @@ function buildPathGroup(classifier, raw, options, pending, startedAt, hasError,
 }
 function buildSearchGroup(classifier, raw, options, pending, startedAt, hasError, errorCount) {
     const items = raw.map((tool) => {
-        const pattern = String(tool.args.pattern ?? tool.args.query ?? "").trim();
-        const scope = String(tool.args.path ?? tool.args.glob ?? tool.args.include ?? "").trim();
+        const intent = analyzeToolIntent({ name: tool.name, parsedArgs: tool.args }).search;
+        const pattern = String(tool.args.pattern ?? tool.args.query ?? tool.metadata?.pattern ?? intent?.pattern ?? "").trim();
+        const scope = String(tool.args.path ?? tool.args.glob ?? tool.args.include ?? tool.metadata?.path ?? intent?.path ?? "").trim();
         const patternText = pattern ? `"${pattern}"` : "(pattern)";
         return scope ? `${patternText} in ${formatTracePath(scope, options.homeDir)}` : patternText;
     });
+    const resultPreview = raw.flatMap((tool) => resultLines(tool.result))
+        .map((line) => formatTracePath(line, options.homeDir));
     const { shown, omitted } = take(items, options.maxItems);
+    const preview = take(resultPreview, options.maxPreviewLines);
     const count = raw.length;
     return {
         kind: "search",
@@ -262,9 +283,9 @@ function buildSearchGroup(classifier, raw, options, pending, startedAt, hasError
         count,
         noun: plural(count, "search", "searches"),
         items: shown,
-        previewLines: [],
+        previewLines: preview.shown,
         errorLines: collectErrorLines(raw, options),
-        omitted,
+        omitted: omitted + preview.omitted,
         pending,
         hasError,
         errorCount,

package/dist/types.d.ts

@@ -35,6 +35,13 @@ export interface AssistantProviderMetadata {
 export interface UserMessage {
     role: "user";
     content: string | ContentPart[];
+    /** Local presentation metadata; provider adapters intentionally ignore it. */
+    ui?: {
+        /** Exact composer layout, including inline image chips. */
+        displayText: string;
+        /** First [Image #N] label used by this message. */
+        imageDisplayStart?: number;
+    };
 }
 export interface AssistantMessage {
     role: "assistant";

package/node_modules/@bubblebrain-ai/pi-tui/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Mario Zechner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.