@bubblebrain-ai/bubble 0.0.24 → 0.0.26

package/dist/tui/markdown-inline.js

@@ -1,68 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,164 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,216 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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;

package/dist/tui/prompt-keybindings.js

@@ -1,35 +0,0 @@
-export const PROMPT_TEXTAREA_KEYBINDINGS = [
-    { name: "return", action: "submit" },
-    { name: "return", shift: true, action: "newline" },
-    { name: "return", ctrl: true, action: "newline" },
-    { name: "return", meta: true, action: "newline" },
-    { name: "j", ctrl: true, action: "newline" },
-    { name: "linefeed", action: "newline" },
-];
-export function isModifiedEnterSequence(input) {
-    const value = input.sequence || input.raw || "";
-    return /^\x1b\[13;[2-9]\d*[u~]$/.test(value)
-        || /^\x1b\[27;[2-9]\d*;13~$/.test(value);
-}
-export function isModeCycleSequence(value) {
-    if (!value)
-        return false;
-    return value === "\t"
-        || value === "\x1b[Z"
-        || /^\x1b\[(?:9|57346);[12]u$/.test(value)
-        || /^\x1b\[27;2;9~$/.test(value);
-}
-export function isEscapeSequence(value) {
-    if (!value)
-        return false;
-    return value === "\x1b"
-        || /^\x1b\[(?:27|57344)(?:;[1-9]\d*(?::[1-3])?)?u$/.test(value)
-        || /^\x1b\[27;[1-9]\d*(?::[1-3])?;(?:27|57344)~$/.test(value);
-}
-export function isModeCycleKeyEvent(input) {
-    const name = String(input.name || "").toLowerCase();
-    return name === "tab"
-        || name === "backtab"
-        || name === "shift+tab"
-        || isModeCycleSequence(input.raw || input.sequence);
-}

package/dist/tui/render-signature.d.ts

@@ -1 +0,0 @@
-export declare function hashString(value: string): string;

package/dist/tui/render-signature.js

@@ -1,7 +0,0 @@
-export function hashString(value) {
-    let hash = 5381;
-    for (let index = 0; index < value.length; index++) {
-        hash = ((hash << 5) + hash) ^ value.charCodeAt(index);
-    }
-    return (hash >>> 0).toString(36);
-}

package/dist/tui/run.d.ts

@@ -1,67 +0,0 @@
-import { type Agent } from "../agent.js";
-import type { CliArgs } from "../cli.js";
-import type { ThemeMode } from "../config.js";
-import type { ExternalHookController } from "../hooks/controller.js";
-import { SessionManager } from "../session.js";
-import type { PlanDecision, Provider } from "../types.js";
-import type { ProviderRegistry } from "../provider-registry.js";
-import type { SkillRegistry } from "../skills/registry.js";
-import { type LspService } from "../lsp/index.js";
-import { type BashAllowlist } from "../approval/session-cache.js";
-import type { SettingsManager } from "../permissions/settings.js";
-import type { McpManager } from "../mcp/manager.js";
-import type { GoalStore } from "../goal/store.js";
-import type { ApprovalDecision, ApprovalRequest } from "../approval/types.js";
-import type { QuestionController } from "../question/index.js";
-import type { MemoryScope } from "../memory/index.js";
-import type { ResolvedTheme } from "./detect-theme.js";
-export interface PlanHandlerRef {
-    current?: (plan: string) => Promise<PlanDecision>;
-}
-export interface ApprovalHandlerRef {
-    current?: (req: ApprovalRequest) => Promise<ApprovalDecision>;
-}
-export interface RunTuiOptions {
-    sessionManager?: SessionManager;
-    createProvider?: (providerId: string, apiKey: string, baseURL: string) => Provider;
-    registry?: ProviderRegistry;
-    skillRegistry?: SkillRegistry;
-    planHandlerRef?: PlanHandlerRef;
-    approvalHandlerRef?: ApprovalHandlerRef;
-    questionController?: QuestionController;
-    bashAllowlist?: BashAllowlist;
-    settingsManager?: SettingsManager;
-    hookController?: ExternalHookController;
-    lspService?: LspService;
-    mcpManager?: McpManager;
-    goalStore?: GoalStore;
-    themeMode?: ThemeMode;
-    themeOverrides?: Record<string, string>;
-    detectedTheme?: ResolvedTheme;
-    onThemeModeChange?: (mode: ThemeMode) => void;
-    /** Legacy dark-palette overrides. Prefer themeOverrides for new callers. */
-    theme?: Record<string, string>;
-    flushMemory?: () => Promise<void>;
-    runMemoryCompaction?: () => Promise<string>;
-    runMemorySummary?: (scope?: MemoryScope) => Promise<string>;
-    runMemoryRefresh?: (scope?: MemoryScope) => Promise<string>;
-    /** One-line "update available" notice shown on the home screen, if any. */
-    updateNotice?: string;
-    /**
-     * Background registry check started before the TUI. Resolves with a late
-     * "update available" notice (or null); the TUI surfaces it live — on the
-     * home screen when still there, otherwise as a composer notice.
-     */
-    updateNoticeRefresh?: Promise<string | null>;
-    /**
-     * Swap the active session in place (driven by the /session picker).
-     * Rebinds persistence to the picked session file and replaces the agent's
-     * message history; the TUI rebuilds its transcript from the result.
-     */
-    switchSession?: (sessionFile: string) => {
-        manager: SessionManager;
-    } | {
-        error: string;
-    };
-}
-export declare function runTui(agent: Agent, args: CliArgs, options?: RunTuiOptions): Promise<void>;