@bubblebrain-ai/bubble 0.0.12 → 0.0.13

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

@@ -0,0 +1,16 @@
+export declare function defaultHistoryFilePath(): string;
+export declare function loadHistorySync(filePath?: string): string[];
+export declare function appendHistoryEntry(entry: string, filePath?: string): void;
+export interface HistoryNavState {
+    history: string[];
+    index: number | null;
+    draft: string;
+}
+export interface HistoryNavResult {
+    text: string;
+    index: number | null;
+    draft: string;
+    changed: boolean;
+}
+export declare function stepHistory(state: HistoryNavState, direction: "up" | "down", currentText: string): HistoryNavResult;
+export declare function pushHistoryEntry(history: string[], entry: string): string[];

package/dist/tui/input-history.js

@@ -0,0 +1,79 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getBubbleHome } from "../bubble-home.js";
+const MAX_HISTORY_ENTRIES = 1000;
+export function defaultHistoryFilePath() {
+    return join(getBubbleHome(), "input-history.jsonl");
+}
+// JSONL on disk: each line is a JSON-encoded string. JSON encoding handles
+// embedded newlines and quotes so multi-line composer entries round-trip safely.
+export function loadHistorySync(filePath = defaultHistoryFilePath()) {
+    try {
+        if (!existsSync(filePath))
+            return [];
+        const raw = readFileSync(filePath, "utf8");
+        const out = [];
+        for (const line of raw.split("\n")) {
+            if (!line)
+                continue;
+            try {
+                const parsed = JSON.parse(line);
+                if (typeof parsed === "string" && parsed.length > 0)
+                    out.push(parsed);
+            }
+            catch {
+                // Malformed line - skip rather than fail the whole load.
+            }
+        }
+        return out.length > MAX_HISTORY_ENTRIES ? out.slice(-MAX_HISTORY_ENTRIES) : out;
+    }
+    catch {
+        return [];
+    }
+}
+export function appendHistoryEntry(entry, filePath = defaultHistoryFilePath()) {
+    if (!entry || entry.trim().length === 0)
+        return;
+    try {
+        mkdirSync(dirname(filePath), { recursive: true });
+        appendFileSync(filePath, JSON.stringify(entry) + "\n", "utf8");
+    }
+    catch {
+        // Persistence is best-effort; never crash the composer over disk IO.
+    }
+}
+// Pure transition for up/down navigation. `index === null` means the user is
+// editing a fresh draft; otherwise it points at history[index]. When stepping
+// from the draft into history we snapshot the current text so down past the
+// newest entry can restore it.
+export function stepHistory(state, direction, currentText) {
+    const { history, index, draft } = state;
+    const noChange = { text: currentText, index, draft, changed: false };
+    if (direction === "up") {
+        if (history.length === 0)
+            return noChange;
+        if (index === null) {
+            const newIdx = history.length - 1;
+            return { text: history[newIdx], index: newIdx, draft: currentText, changed: true };
+        }
+        if (index > 0) {
+            return { text: history[index - 1], index: index - 1, draft, changed: true };
+        }
+        return noChange;
+    }
+    if (index === null)
+        return noChange;
+    if (index < history.length - 1) {
+        return { text: history[index + 1], index: index + 1, draft, changed: true };
+    }
+    return { text: draft, index: null, draft: "", changed: true };
+}
+// Push to in-memory history with last-entry dedupe so repeated identical
+// submissions don't spam the stack.
+export function pushHistoryEntry(history, entry) {
+    if (!entry || entry.trim().length === 0)
+        return history;
+    if (history.length > 0 && history[history.length - 1] === entry)
+        return history;
+    return [...history, entry];
+}

package/dist/tui/markdown-inline.d.ts

@@ -0,0 +1,22 @@
+export interface MarkdownInlineSegment {
+    text: string;
+    color?: "text" | "textMuted" | "success" | "warning" | "secondary";
+    bold?: boolean;
+    italic?: boolean;
+    dim?: boolean;
+}
+type InlineToken = {
+    type?: string;
+    text?: string;
+    raw?: string;
+    href?: string;
+    tokens?: InlineToken[];
+};
+interface InlineStyle {
+    bold?: boolean;
+    italic?: boolean;
+    dim?: boolean;
+    color?: MarkdownInlineSegment["color"];
+}
+export declare function markdownInlineSegments(tokens: InlineToken[] | undefined, fallback?: string, style?: InlineStyle): MarkdownInlineSegment[];
+export {};

package/dist/tui/markdown-inline.js

@@ -0,0 +1,68 @@
+export function markdownInlineSegments(tokens, fallback = "", style = {}) {
+    const segments = [];
+    for (const token of tokens ?? []) {
+        appendInlineToken(segments, token, style);
+    }
+    if (segments.length === 0 && fallback) {
+        appendStyled(segments, fallback, style);
+    }
+    return segments;
+}
+function appendInlineToken(segments, token, style) {
+    switch (token.type) {
+        case "strong":
+            appendInlineTokens(segments, token.tokens, { ...style, bold: true });
+            return;
+        case "em":
+            appendInlineTokens(segments, token.tokens, { ...style, italic: true, color: style.color ?? "warning" });
+            return;
+        case "del":
+            appendInlineTokens(segments, token.tokens, { ...style, dim: true, color: style.color ?? "textMuted" });
+            return;
+        case "codespan":
+            appendStyled(segments, token.text ?? "", { ...style, color: "success" });
+            return;
+        case "link":
+            appendInlineTokens(segments, token.tokens, { ...style, color: style.color ?? "secondary" });
+            return;
+        case "br":
+            appendStyled(segments, "\n", style);
+            return;
+        case "text":
+        case "paragraph":
+        case "list_item":
+        case "heading":
+            if (token.tokens?.length) {
+                appendInlineTokens(segments, token.tokens, style);
+            }
+            else {
+                appendStyled(segments, token.text ?? token.raw ?? "", style);
+            }
+            return;
+        case "space":
+            return;
+        default:
+            if (token.tokens?.length) {
+                appendInlineTokens(segments, token.tokens, style);
+            }
+            else {
+                appendStyled(segments, token.text ?? token.raw ?? "", style);
+            }
+    }
+}
+function appendInlineTokens(segments, tokens, style) {
+    for (const child of tokens ?? []) {
+        appendInlineToken(segments, child, style);
+    }
+}
+function appendStyled(segments, text, style) {
+    if (!text)
+        return;
+    segments.push({
+        text,
+        color: style.color ?? "text",
+        bold: style.bold,
+        italic: style.italic,
+        dim: style.dim,
+    });
+}

package/dist/tui/markdown-theme-rules.d.ts

@@ -0,0 +1,23 @@
+export interface MarkdownThemePalette {
+    text: string;
+    textMuted: string;
+    background: string;
+    secondary: string;
+    info: string;
+    success: string;
+    warning: string;
+    accent: string;
+    error: string;
+}
+export interface SyntaxThemeRule {
+    scope: string[];
+    style: {
+        foreground?: string;
+        background?: string;
+        bold?: boolean;
+        italic?: boolean;
+        underline?: boolean;
+        dim?: boolean;
+    };
+}
+export declare function buildMarkdownThemeRules(theme: MarkdownThemePalette): SyntaxThemeRule[];

package/dist/tui/markdown-theme-rules.js

@@ -0,0 +1,164 @@
+export function buildMarkdownThemeRules(theme) {
+    return [
+        {
+            scope: ["default"],
+            style: {
+                foreground: theme.text,
+            },
+        },
+        {
+            scope: ["comment", "comment.documentation"],
+            style: {
+                foreground: theme.textMuted,
+                italic: true,
+            },
+        },
+        {
+            scope: ["string", "symbol", "character", "character.special", "string.escape"],
+            style: {
+                foreground: theme.success,
+            },
+        },
+        {
+            scope: ["number", "boolean", "constant", "float"],
+            style: {
+                foreground: theme.warning,
+            },
+        },
+        {
+            scope: [
+                "keyword",
+                "keyword.import",
+                "keyword.return",
+                "keyword.conditional",
+                "keyword.repeat",
+                "keyword.coroutine",
+                "keyword.directive",
+                "keyword.modifier",
+                "keyword.exception",
+                "string.regexp",
+            ],
+            style: {
+                foreground: theme.accent,
+                italic: true,
+            },
+        },
+        {
+            scope: ["keyword.type", "type", "class", "module"],
+            style: {
+                foreground: theme.info,
+                bold: true,
+            },
+        },
+        {
+            scope: ["function", "function.call", "function.method", "function.method.call", "constructor"],
+            style: {
+                foreground: theme.secondary,
+            },
+        },
+        {
+            scope: ["variable", "variable.parameter", "variable.member", "property", "parameter"],
+            style: {
+                foreground: theme.text,
+            },
+        },
+        {
+            scope: ["operator", "keyword.operator", "punctuation.delimiter", "punctuation.special"],
+            style: {
+                foreground: theme.info,
+            },
+        },
+        {
+            scope: ["punctuation", "punctuation.bracket"],
+            style: {
+                foreground: theme.text,
+            },
+        },
+        {
+            scope: ["variable.builtin", "type.builtin", "function.builtin", "module.builtin", "constant.builtin", "variable.super"],
+            style: {
+                foreground: theme.error,
+            },
+        },
+        {
+            scope: ["markup.heading", "markup.heading.1", "markup.heading.2", "markup.heading.3", "markup.heading.4", "markup.heading.5", "markup.heading.6"],
+            style: {
+                foreground: theme.text,
+                bold: true,
+            },
+        },
+        {
+            scope: ["markup.bold", "markup.strong"],
+            style: {
+                foreground: theme.text,
+                bold: true,
+            },
+        },
+        {
+            scope: ["markup.italic"],
+            style: {
+                foreground: theme.warning,
+                italic: true,
+            },
+        },
+        {
+            scope: ["markup.strikethrough"],
+            style: {
+                foreground: theme.textMuted,
+                dim: true,
+            },
+        },
+        {
+            scope: ["markup.list"],
+            style: {
+                foreground: theme.secondary,
+            },
+        },
+        {
+            scope: ["markup.quote"],
+            style: {
+                foreground: theme.warning,
+                italic: true,
+            },
+        },
+        {
+            scope: ["markup.raw", "markup.raw.block"],
+            style: {
+                foreground: theme.success,
+            },
+        },
+        {
+            scope: ["markup.raw.inline"],
+            style: {
+                foreground: theme.success,
+                background: theme.background,
+            },
+        },
+        {
+            scope: ["markup.link", "markup.link.url", "string.special.url"],
+            style: {
+                foreground: theme.secondary,
+                underline: true,
+            },
+        },
+        {
+            scope: ["markup.link.label", "label"],
+            style: {
+                foreground: theme.info,
+                underline: true,
+            },
+        },
+        {
+            scope: ["spell", "nospell"],
+            style: {
+                foreground: theme.text,
+            },
+        },
+        {
+            scope: ["conceal"],
+            style: {
+                foreground: theme.textMuted,
+            },
+        },
+    ];
+}

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

@@ -0,0 +1,5 @@
+import { SyntaxStyle } from "@opentui/core";
+import { type MarkdownThemePalette } from "./markdown-theme-rules.js";
+export type { MarkdownThemePalette } from "./markdown-theme-rules.js";
+export declare function createMarkdownSyntaxStyle(theme: MarkdownThemePalette): SyntaxStyle;
+export declare function createSubtleMarkdownSyntaxStyle(theme: MarkdownThemePalette, opacity?: number): SyntaxStyle;

package/dist/tui/markdown-theme.js

@@ -0,0 +1,27 @@
+import { SyntaxStyle } from "@opentui/core";
+import { buildMarkdownThemeRules } from "./markdown-theme-rules.js";
+export function createMarkdownSyntaxStyle(theme) {
+    return SyntaxStyle.fromTheme(buildMarkdownThemeRules(theme));
+}
+export function createSubtleMarkdownSyntaxStyle(theme, opacity = 0.6) {
+    const alpha = Math.max(0, Math.min(1, opacity));
+    return SyntaxStyle.fromTheme(buildMarkdownThemeRules(theme).map((rule) => ({
+        ...rule,
+        style: {
+            ...rule.style,
+            foreground: rule.style.foreground
+                ? applyAlpha(rule.style.foreground, alpha)
+                : rule.style.foreground,
+        },
+    })));
+}
+function applyAlpha(color, opacity) {
+    if (!color.startsWith("#"))
+        return color;
+    const hex = color.slice(1);
+    if (hex.length !== 6 && hex.length !== 8)
+        return color;
+    const rgb = hex.slice(0, 6);
+    const alpha = Math.round(opacity * 255).toString(16).padStart(2, "0");
+    return `#${rgb}${alpha}`;
+}

package/dist/tui/opencode-spinner.d.ts

@@ -0,0 +1,22 @@
+import type { ColorInput } from "@opentui/core";
+import { RGBA } from "@opentui/core";
+type ColorGenerator = (frameIndex: number, charIndex: number, totalFrames: number, totalChars: number) => ColorInput;
+export declare function deriveTrailColors(brightColor: ColorInput, steps?: number): RGBA[];
+export declare function deriveInactiveColor(brightColor: ColorInput, factor?: number): RGBA;
+export type KnightRiderStyle = "blocks" | "diamonds";
+export interface KnightRiderOptions {
+    width?: number;
+    style?: KnightRiderStyle;
+    holdStart?: number;
+    holdEnd?: number;
+    colors?: ColorInput[];
+    color?: ColorInput;
+    trailSteps?: number;
+    defaultColor?: ColorInput;
+    inactiveFactor?: number;
+    enableFading?: boolean;
+    minAlpha?: number;
+}
+export declare function createFrames(options?: KnightRiderOptions): string[];
+export declare function createColors(options?: KnightRiderOptions): ColorGenerator;
+export {};

package/dist/tui/opencode-spinner.js

@@ -0,0 +1,216 @@
+import { RGBA } from "@opentui/core";
+function getScannerState(frameIndex, totalChars, options) {
+    const { direction = "forward", holdFrames = {} } = options;
+    if (direction === "bidirectional") {
+        const forwardFrames = totalChars;
+        const holdEndFrames = holdFrames.end ?? 0;
+        const backwardFrames = totalChars - 1;
+        if (frameIndex < forwardFrames) {
+            return {
+                activePosition: frameIndex,
+                isHolding: false,
+                holdProgress: 0,
+                holdTotal: 0,
+                movementProgress: frameIndex,
+                movementTotal: forwardFrames,
+                isMovingForward: true,
+            };
+        }
+        if (frameIndex < forwardFrames + holdEndFrames) {
+            return {
+                activePosition: totalChars - 1,
+                isHolding: true,
+                holdProgress: frameIndex - forwardFrames,
+                holdTotal: holdEndFrames,
+                movementProgress: 0,
+                movementTotal: 0,
+                isMovingForward: true,
+            };
+        }
+        if (frameIndex < forwardFrames + holdEndFrames + backwardFrames) {
+            const backwardIndex = frameIndex - forwardFrames - holdEndFrames;
+            return {
+                activePosition: totalChars - 2 - backwardIndex,
+                isHolding: false,
+                holdProgress: 0,
+                holdTotal: 0,
+                movementProgress: backwardIndex,
+                movementTotal: backwardFrames,
+                isMovingForward: false,
+            };
+        }
+        return {
+            activePosition: 0,
+            isHolding: true,
+            holdProgress: frameIndex - forwardFrames - holdEndFrames - backwardFrames,
+            holdTotal: holdFrames.start ?? 0,
+            movementProgress: 0,
+            movementTotal: 0,
+            isMovingForward: false,
+        };
+    }
+    if (direction === "backward") {
+        return {
+            activePosition: totalChars - 1 - (frameIndex % totalChars),
+            isHolding: false,
+            holdProgress: 0,
+            holdTotal: 0,
+            movementProgress: frameIndex % totalChars,
+            movementTotal: totalChars,
+            isMovingForward: false,
+        };
+    }
+    return {
+        activePosition: frameIndex % totalChars,
+        isHolding: false,
+        holdProgress: 0,
+        holdTotal: 0,
+        movementProgress: frameIndex % totalChars,
+        movementTotal: totalChars,
+        isMovingForward: true,
+    };
+}
+function calculateColorIndex(frameIndex, charIndex, totalChars, options, state) {
+    const { trailLength } = options;
+    const { activePosition, isHolding, holdProgress, isMovingForward } = state ?? getScannerState(frameIndex, totalChars, options);
+    const directionalDistance = isMovingForward
+        ? activePosition - charIndex
+        : charIndex - activePosition;
+    if (isHolding)
+        return directionalDistance + holdProgress;
+    if (directionalDistance > 0 && directionalDistance < trailLength)
+        return directionalDistance;
+    if (directionalDistance === 0)
+        return 0;
+    return -1;
+}
+function createKnightRiderTrail(options) {
+    const { colors, defaultColor, enableFading = true, minAlpha = 0 } = options;
+    const defaultRgba = defaultColor instanceof RGBA ? defaultColor : RGBA.fromHex(defaultColor || "#000000");
+    const baseInactiveAlpha = defaultRgba.a;
+    let cachedFrameIndex = -1;
+    let cachedState = null;
+    return (frameIndex, charIndex, _totalFrames, totalChars) => {
+        if (frameIndex !== cachedFrameIndex) {
+            cachedFrameIndex = frameIndex;
+            cachedState = getScannerState(frameIndex, totalChars, options);
+        }
+        const state = cachedState;
+        const index = calculateColorIndex(frameIndex, charIndex, totalChars, options, state);
+        const { isHolding, holdProgress, holdTotal, movementProgress, movementTotal } = state;
+        let fadeFactor = 1.0;
+        if (enableFading) {
+            if (isHolding && holdTotal > 0) {
+                const progress = Math.min(holdProgress / holdTotal, 1);
+                fadeFactor = Math.max(minAlpha, 1 - progress * (1 - minAlpha));
+            }
+            else if (!isHolding && movementTotal > 0) {
+                const progress = Math.min(movementProgress / Math.max(1, movementTotal - 1), 1);
+                fadeFactor = minAlpha + progress * (1 - minAlpha);
+            }
+        }
+        defaultRgba.a = baseInactiveAlpha * fadeFactor;
+        if (index === -1)
+            return defaultRgba;
+        return colors[index] ?? defaultRgba;
+    };
+}
+export function deriveTrailColors(brightColor, steps = 6) {
+    const baseRgba = brightColor instanceof RGBA ? brightColor : RGBA.fromHex(brightColor);
+    const colors = [];
+    for (let i = 0; i < steps; i++) {
+        let alpha;
+        let brightnessFactor;
+        if (i === 0) {
+            alpha = 1.0;
+            brightnessFactor = 1.0;
+        }
+        else if (i === 1) {
+            alpha = 0.9;
+            brightnessFactor = 1.15;
+        }
+        else {
+            alpha = Math.pow(0.65, i - 1);
+            brightnessFactor = 1.0;
+        }
+        const r = Math.min(1.0, baseRgba.r * brightnessFactor);
+        const g = Math.min(1.0, baseRgba.g * brightnessFactor);
+        const b = Math.min(1.0, baseRgba.b * brightnessFactor);
+        colors.push(RGBA.fromValues(r, g, b, alpha));
+    }
+    return colors;
+}
+export function deriveInactiveColor(brightColor, factor = 0.2) {
+    const baseRgba = brightColor instanceof RGBA ? brightColor : RGBA.fromHex(brightColor);
+    return RGBA.fromValues(baseRgba.r, baseRgba.g, baseRgba.b, factor);
+}
+export function createFrames(options = {}) {
+    const width = options.width ?? 8;
+    const style = options.style ?? "diamonds";
+    const holdStart = options.holdStart ?? 30;
+    const holdEnd = options.holdEnd ?? 9;
+    const colors = options.colors ??
+        (options.color
+            ? deriveTrailColors(options.color, options.trailSteps)
+            : [
+                RGBA.fromHex("#ff0000"),
+                RGBA.fromHex("#ff5555"),
+                RGBA.fromHex("#dd0000"),
+                RGBA.fromHex("#aa0000"),
+                RGBA.fromHex("#770000"),
+                RGBA.fromHex("#440000"),
+            ]);
+    const defaultColor = options.defaultColor ??
+        (options.color ? deriveInactiveColor(options.color, options.inactiveFactor) : RGBA.fromHex("#330000"));
+    const trailOptions = {
+        colors,
+        trailLength: colors.length,
+        defaultColor,
+        direction: "bidirectional",
+        holdFrames: { start: holdStart, end: holdEnd },
+        enableFading: options.enableFading,
+        minAlpha: options.minAlpha,
+    };
+    const totalFrames = width + holdEnd + (width - 1) + holdStart;
+    return Array.from({ length: totalFrames }, (_, frameIndex) => {
+        return Array.from({ length: width }, (_, charIndex) => {
+            const index = calculateColorIndex(frameIndex, charIndex, width, trailOptions);
+            if (style === "diamonds") {
+                const shapes = ["⬥", "◆", "⬩", "⬪"];
+                if (index >= 0 && index < trailOptions.colors.length) {
+                    return shapes[Math.min(index, shapes.length - 1)];
+                }
+                return "·";
+            }
+            const isActive = index >= 0 && index < trailOptions.colors.length;
+            return isActive ? "■" : "⬝";
+        }).join("");
+    });
+}
+export function createColors(options = {}) {
+    const holdStart = options.holdStart ?? 30;
+    const holdEnd = options.holdEnd ?? 9;
+    const colors = options.colors ??
+        (options.color
+            ? deriveTrailColors(options.color, options.trailSteps)
+            : [
+                RGBA.fromHex("#ff0000"),
+                RGBA.fromHex("#ff5555"),
+                RGBA.fromHex("#dd0000"),
+                RGBA.fromHex("#aa0000"),
+                RGBA.fromHex("#770000"),
+                RGBA.fromHex("#440000"),
+            ]);
+    const defaultColor = options.defaultColor ??
+        (options.color ? deriveInactiveColor(options.color, options.inactiveFactor) : RGBA.fromHex("#330000"));
+    const trailOptions = {
+        colors,
+        trailLength: colors.length,
+        defaultColor,
+        direction: "bidirectional",
+        holdFrames: { start: holdStart, end: holdEnd },
+        enableFading: options.enableFading,
+        minAlpha: options.minAlpha,
+    };
+    return createKnightRiderTrail(trailOptions);
+}

package/dist/tui/prompt-keybindings.d.ts

@@ -0,0 +1,42 @@
+export declare const PROMPT_TEXTAREA_KEYBINDINGS: ({
+    name: string;
+    action: "submit";
+    shift?: undefined;
+    ctrl?: undefined;
+    meta?: undefined;
+} | {
+    name: string;
+    shift: true;
+    action: "newline";
+    ctrl?: undefined;
+    meta?: undefined;
+} | {
+    name: string;
+    ctrl: true;
+    action: "newline";
+    shift?: undefined;
+    meta?: undefined;
+} | {
+    name: string;
+    meta: true;
+    action: "newline";
+    shift?: undefined;
+    ctrl?: undefined;
+} | {
+    name: string;
+    action: "newline";
+    shift?: undefined;
+    ctrl?: undefined;
+    meta?: undefined;
+})[];
+export declare function isModifiedEnterSequence(input: {
+    raw?: string;
+    sequence?: string;
+}): boolean;
+export declare function isModeCycleSequence(value?: string): boolean;
+export declare function isEscapeSequence(value?: string): boolean;
+export declare function isModeCycleKeyEvent(input: {
+    name?: string;
+    raw?: string;
+    sequence?: string;
+}): boolean;