@bubblebrain-ai/bubble 0.0.48 → 0.0.50

package/dist/tui-ink/waiting-indicator.js

@@ -0,0 +1,129 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * The animated spinner row shown while a run is in flight: tool-targeted or
+ * generic phrases, streaming token counter, and steer/queue hints.
+ */
+import { useEffect, useState } from "react";
+import { Box, Text } from "ink";
+import { useTheme } from "./theme.js";
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const GENERIC_PHRASES = [
+    "mapping the workspace",
+    "reading the room",
+    "following the threads",
+    "connecting the pieces",
+    "sorting the context",
+    "scanning the structure",
+    "shaping the next step",
+    "gathering signal",
+    "checking the edges",
+    "lining up the answer",
+    "tracing the flow",
+    "building the picture",
+    "walking the graph",
+    "collecting the clues",
+    "framing the problem",
+    "locating the source",
+    "resolving the shape",
+    "untangling the state",
+    "comparing the paths",
+    "narrowing the target",
+    "tracking the changes",
+    "reading the patterns",
+    "weighing the options",
+    "assembling the context",
+    "following the signal",
+    "checking the assumptions",
+    "aligning the details",
+    "testing the shape",
+    "pulling the thread",
+    "cleaning the edges",
+    "refining the draft",
+    "verifying the route",
+    "making sense of it",
+    "looking for leverage",
+    "stitching the answer",
+    "holding the thread",
+    "distilling the noise",
+    "finding the seam",
+    "reading between the lines",
+    "preparing the response",
+];
+const TOOL_TARGET_PHRASES = {
+    read: "reading files",
+    write: "writing changes",
+    edit: "patching files",
+    grep: "searching the codebase",
+    glob: "scanning paths",
+    ls: "listing directories",
+    bash: "running command",
+    web_search: "searching the web",
+    web_fetch: "fetching a page",
+    task: "spawning subagent",
+};
+function formatTokensApprox(chars) {
+    const tokens = Math.max(0, Math.round(chars / 4));
+    if (tokens < 1000)
+        return `${tokens}`;
+    if (tokens < 10000)
+        return `${(tokens / 1000).toFixed(1)}k`;
+    return `${Math.round(tokens / 1000)}k`;
+}
+export function WaitingIndicator({ tools, hasStreamingText, hasStreamingReasoning, streamedChars, nowTick, pendingSteerCount = 0, queuedCount = 0, }) {
+    void nowTick;
+    const theme = useTheme();
+    const [frameIndex, setFrameIndex] = useState(0);
+    const [idlePhrase, setIdlePhrase] = useState(() => GENERIC_PHRASES[0]);
+    // Frame timer is independent of the agent state — keeps animation smooth.
+    useEffect(() => {
+        const t = setInterval(() => {
+            setFrameIndex((i) => (i + 1) % SPINNER_FRAMES.length);
+        }, 100);
+        return () => clearInterval(t);
+    }, []);
+    // Determine state: active tool > streaming text > streaming reasoning > idle
+    const activeTool = [...tools].reverse().find((t) => !t.result);
+    const state = activeTool
+        ? "tool"
+        : hasStreamingText
+            ? "text"
+            : hasStreamingReasoning
+                ? "reasoning"
+                : "idle";
+    // Rotate idle phrases on a slower cadence; only matters in the idle state.
+    useEffect(() => {
+        if (state !== "idle")
+            return;
+        const t = setInterval(() => {
+            setIdlePhrase((current) => {
+                const candidates = GENERIC_PHRASES.filter((item) => item !== current);
+                return candidates[Math.floor(Math.random() * candidates.length)] || current;
+            });
+        }, 1500);
+        return () => clearInterval(t);
+    }, [state]);
+    let phrase;
+    if (state === "tool" && activeTool) {
+        phrase =
+            TOOL_TARGET_PHRASES[activeTool.name] || `running ${activeTool.name}`;
+    }
+    else if (state === "text") {
+        phrase = "writing the response";
+    }
+    else if (state === "reasoning") {
+        phrase = "working through the request";
+    }
+    else {
+        phrase = idlePhrase;
+    }
+    const tokenText = streamedChars > 0 ? `↓${formatTokensApprox(streamedChars)} tok` : "";
+    const hintParts = [];
+    if (tokenText)
+        hintParts.push(tokenText);
+    if (pendingSteerCount > 0)
+        hintParts.push(`${pendingSteerCount} pending steer${pendingSteerCount === 1 ? "" : "s"}`);
+    if (queuedCount > 0)
+        hintParts.push(`${queuedCount} queued`);
+    hintParts.push("enter steer", "tab queue", "esc stop");
+    return (_jsxs(Box, { children: [_jsx(Text, { color: theme.accent, children: SPINNER_FRAMES[frameIndex] }), _jsxs(Text, { color: theme.muted, children: [" ", phrase, " "] }), _jsxs(Text, { color: theme.muted, dimColor: true, children: ["(", hintParts.join(" · "), ")"] })] }));
+}

package/dist/tui-ink/wordmark.d.ts

@@ -0,0 +1,8 @@
+export interface WordmarkCell {
+    char: string;
+    color: string | null;
+}
+export declare function buildBubbleCodeGrid(): WordmarkCell[][];
+export declare function BubbleCodeWordmark({ width }: {
+    width?: number;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/tui-ink/wordmark.js

@@ -0,0 +1,103 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+/**
+ * Retro terminal pixel-art wordmark: "BUBBLE CODE" rendered in a 5×7 block
+ * font with a light-blue front face and a dark-blue offset shadow (extrusion),
+ * plus a pale highlight along the top edge. Purely decorative; keeps the
+ * terminal background.
+ */
+const LETTER_W = 5;
+const LETTER_H = 7;
+const LETTER_GAP = 2;
+const WORD_GAP = 4;
+const SHADOW_DX = 1;
+const SHADOW_DY = 1;
+const FRONT = "#E0E6ED";
+const SHADOW = "#3A4A5A";
+const HIGHLIGHT = "#FFFFFF";
+// 5×7 bold block pixel font ("1" = filled, "0" = empty).
+const FONT = {
+    B: ["11110", "10001", "10001", "11110", "10001", "10001", "11110"],
+    U: ["10001", "10001", "10001", "10001", "10001", "10001", "01110"],
+    L: ["10000", "10000", "10000", "10000", "10000", "10000", "11111"],
+    E: ["11111", "10000", "10000", "11110", "10000", "10000", "11111"],
+    C: ["01111", "10000", "10000", "10000", "10000", "10000", "01111"],
+    O: ["01110", "10001", "10001", "10001", "10001", "10001", "01110"],
+    D: ["11110", "10001", "10001", "10001", "10001", "10001", "11110"],
+    " ": ["00000", "00000", "00000", "00000", "00000", "00000", "00000"],
+};
+const WORD = "BUBBLE CODE";
+function letterOffsets() {
+    const offsets = [];
+    let x = 0;
+    for (const ch of WORD) {
+        offsets.push({ ch, x });
+        x += ch === " " ? WORD_GAP : LETTER_W + LETTER_GAP;
+    }
+    return offsets;
+}
+export function buildBubbleCodeGrid() {
+    const offsets = letterOffsets();
+    const last = offsets[offsets.length - 1];
+    const width = last.x + LETTER_W + SHADOW_DX;
+    const height = LETTER_H + SHADOW_DY;
+    const grid = Array.from({ length: height }, () => Array.from({ length: width }, () => ({ char: " ", color: null })));
+    const set = (x, y, color) => {
+        if (x >= 0 && x < width && y >= 0 && y < height) {
+            grid[y][x] = { char: "█", color };
+        }
+    };
+    const forEachPixel = (cb) => {
+        for (const { ch, x } of offsets) {
+            const glyph = FONT[ch] ?? FONT[" "];
+            for (let r = 0; r < LETTER_H; r++) {
+                for (let c = 0; c < LETTER_W; c++) {
+                    if (glyph[r][c] === "1")
+                        cb(x + c, r);
+                }
+            }
+        }
+    };
+    // Extrusion (dark blue), offset one cell right + one down.
+    forEachPixel((x, y) => set(x + SHADOW_DX, y + SHADOW_DY, SHADOW));
+    // Front face (light blue).
+    forEachPixel((x, y) => set(x, y, FRONT));
+    // Top-edge highlight (pale blue) for a bit of shine.
+    for (const { ch, x } of offsets) {
+        const glyph = FONT[ch] ?? FONT[" "];
+        for (let c = 0; c < LETTER_W; c++) {
+            if (glyph[0][c] === "1")
+                set(x + c, 0, HIGHLIGHT);
+        }
+    }
+    return grid;
+}
+function mergeRow(row) {
+    const segments = [];
+    let current = null;
+    for (const cell of row) {
+        if (current && current.color === cell.color) {
+            current.text += cell.char;
+        }
+        else {
+            current = { text: cell.char, color: cell.color };
+            segments.push(current);
+        }
+    }
+    // Drop trailing empty cells so the wordmark has no trailing whitespace.
+    while (segments.length > 0 && segments[segments.length - 1].color === null) {
+        segments.pop();
+    }
+    return segments;
+}
+export function BubbleCodeWordmark({ width }) {
+    const grid = buildBubbleCodeGrid();
+    const contentWidth = grid[0]?.length ?? 0;
+    const leftPad = width && width > contentWidth
+        ? Math.floor((width - contentWidth) / 2)
+        : 0;
+    return (_jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: leftPad, children: grid.map((row, rowIndex) => {
+            const segments = mergeRow(row);
+            return (_jsx(Box, { flexDirection: "row", flexShrink: 0, children: segments.map((segment, segmentIndex) => (_jsx(Text, { color: segment.color ?? undefined, children: segment.text }, segmentIndex))) }, rowIndex));
+        }) }));
+}

package/dist/types.d.ts

@@ -47,6 +47,8 @@ export interface AssistantMessage {
     providerId?: string;
     modelId?: string;
     usage?: TokenUsage;
+    /** Backend configuration fingerprint reported by the model provider. */
+    systemFingerprint?: string;
     error?: {
         name: string;
         message: string;
@@ -310,6 +312,9 @@ export type StreamChunk = {
 } | {
     type: "usage";
     usage: TokenUsage;
+} | {
+    type: "response_metadata";
+    systemFingerprint: string;
 } | {
     type: "done";
 };
@@ -430,6 +435,7 @@ export type AgentEvent = {
     type: "turn_end";
     usage?: TokenUsage;
     cost?: UsageCost;
+    systemFingerprint?: string;
     willContinue?: boolean;
 } | {
     type: "context_recovered";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bubblebrain-ai/bubble",
-  "version": "0.0.48",
+  "version": "0.0.50",
   "description": "A terminal coding agent",
   "type": "module",
   "engines": {