@bubblebrain-ai/bubble 0.0.12 → 0.0.14

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/model-picker-data.d.ts

@@ -0,0 +1,10 @@
+import { type ModelInfo, type ProviderProfile, type ProviderRegistry } from "../provider-registry.js";
+type ModelPickerRegistry = Pick<ProviderRegistry, "getEnabled" | "getModelConfig" | "listModels">;
+export type ModelProviderGroup = {
+    provider: ProviderProfile;
+    models: ModelInfo[];
+};
+export declare function localModelsForProvider(registry: Pick<ProviderRegistry, "getModelConfig">, provider: ProviderProfile): ModelInfo[];
+export declare function getVisibleModelProviders(registry: Pick<ProviderRegistry, "getEnabled">, providerId?: string): ProviderProfile[];
+export declare function discoverModelProviderGroups(registry: ModelPickerRegistry, providerId?: string): Promise<ModelProviderGroup[]>;
+export {};

package/dist/tui/model-picker-data.js

@@ -0,0 +1,32 @@
+import { listBuiltinModels } from "../model-catalog.js";
+import { isUserVisibleProvider, } from "../provider-registry.js";
+export function localModelsForProvider(registry, provider) {
+    const customModels = registry.getModelConfig().getCustomModels(provider.id);
+    if (customModels.length > 0)
+        return customModels;
+    const builtinProviderId = provider.id === "openai" && provider.authType === "oauth"
+        ? "openai-codex"
+        : provider.id;
+    return listBuiltinModels(builtinProviderId).map((model) => ({
+        id: model.id,
+        name: model.name,
+        providerId: provider.id,
+    }));
+}
+export function getVisibleModelProviders(registry, providerId) {
+    return registry
+        .getEnabled()
+        .filter((provider) => isUserVisibleProvider(provider.id))
+        .filter((provider) => !providerId || provider.id === providerId);
+}
+export async function discoverModelProviderGroups(registry, providerId) {
+    const providers = getVisibleModelProviders(registry, providerId);
+    return Promise.all(providers.map(async (provider) => {
+        try {
+            return { provider, models: await registry.listModels(provider) };
+        }
+        catch {
+            return { provider, models: localModelsForProvider(registry, provider) };
+        }
+    }));
+}

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 {};