@bubblebrain-ai/bubble 0.0.1

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,21 @@
+import type { ColorInput } from "@opentui/core";
+import { RGBA } from "@opentui/core";
+import type { ColorGenerator } from "opentui-spinner";
+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;

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,41 @@
+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 isModeCycleKeyEvent(input: {
+    name?: string;
+    raw?: string;
+    sequence?: string;
+}): boolean;

package/dist/tui/prompt-keybindings.js

@@ -0,0 +1,28 @@
+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 isModeCycleKeyEvent(input) {
+    const name = String(input.name || "").toLowerCase();
+    return name === "tab"
+        || name === "backtab"
+        || name === "shift+tab"
+        || isModeCycleSequence(input.raw || input.sequence);
+}

package/dist/tui/recent-activity.d.ts

@@ -0,0 +1,8 @@
+export interface RecentSession {
+    file: string;
+    modifiedAt: number;
+    preview: string;
+}
+export declare function getRecentSessions(cwd: string, limit?: number): RecentSession[];
+export declare function formatRelativeTime(timestampMs: number, now?: number): string;
+export declare function truncatePreview(preview: string, maxLen: number): string;

package/dist/tui/recent-activity.js

@@ -0,0 +1,71 @@
+import { readFileSync, readdirSync, statSync, existsSync } from "node:fs";
+import path from "node:path";
+import { getSessionsDir } from "../session.js";
+export function getRecentSessions(cwd, limit = 3) {
+    const dir = getSessionsDir(cwd);
+    if (!existsSync(dir))
+        return [];
+    const files = readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+    const withMtime = files.map((f) => {
+        const full = path.join(dir, f);
+        try {
+            return { file: f, full, modifiedAt: statSync(full).mtimeMs };
+        }
+        catch {
+            return { file: f, full, modifiedAt: 0 };
+        }
+    });
+    withMtime.sort((a, b) => b.modifiedAt - a.modifiedAt);
+    return withMtime.slice(0, limit).map(({ file, full, modifiedAt }) => ({
+        file,
+        modifiedAt,
+        preview: extractFirstUserMessage(full) ?? "(no messages)",
+    }));
+}
+export function formatRelativeTime(timestampMs, now = Date.now()) {
+    const diffSec = Math.max(0, Math.floor((now - timestampMs) / 1000));
+    if (diffSec < 60)
+        return "just now";
+    if (diffSec < 3600)
+        return `${Math.floor(diffSec / 60)}m ago`;
+    if (diffSec < 86400)
+        return `${Math.floor(diffSec / 3600)}h ago`;
+    if (diffSec < 604800)
+        return `${Math.floor(diffSec / 86400)}d ago`;
+    const weeks = Math.floor(diffSec / 604800);
+    if (weeks < 5)
+        return `${weeks}w ago`;
+    const months = Math.floor(diffSec / (30 * 86400));
+    return `${months}mo ago`;
+}
+function extractFirstUserMessage(file) {
+    let raw;
+    try {
+        raw = readFileSync(file, "utf-8");
+    }
+    catch {
+        return null;
+    }
+    const lines = raw.split("\n");
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (entry.type === "user_message" && typeof entry.message?.content === "string") {
+            return entry.message.content;
+        }
+    }
+    return null;
+}
+export function truncatePreview(preview, maxLen) {
+    const firstLine = preview.split("\n")[0]?.trim() ?? "";
+    if (firstLine.length <= maxLen)
+        return firstLine;
+    return firstLine.slice(0, Math.max(1, maxLen - 1)) + "…";
+}

package/dist/tui/run.d.ts

@@ -0,0 +1,39 @@
+import type { Agent } from "../agent.js";
+import type { CliArgs } from "../cli.js";
+import type { 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 { ApprovalDecision, ApprovalRequest } from "../approval/types.js";
+import type { QuestionController } from "../question/index.js";
+import type { MemoryScope } from "../memory/index.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;
+    lspService?: LspService;
+    mcpManager?: McpManager;
+    bypassEnabled?: boolean;
+    theme?: Record<string, string>;
+    flushMemory?: () => Promise<void>;
+    runMemoryCompaction?: () => Promise<string>;
+    runMemorySummary?: (scope?: MemoryScope) => Promise<string>;
+    runMemoryRefresh?: (scope?: MemoryScope) => Promise<string>;
+}
+export declare function runTui(agent: Agent, args: CliArgs, options?: RunTuiOptions): Promise<void>;