@bubblebrain-ai/bubble 0.0.63 → 0.0.64

package/dist/tui/detect-theme.js

@@ -0,0 +1,116 @@
+import { execFileSync } from "node:child_process";
+export async function detectTerminalTheme(timeoutMs = 300) {
+    // OSC 11 asks the terminal for its actual background color right now — the
+    // only signal that tracks a theme switched after the shell started. The
+    // launch-time signals below are tie-breakers for terminals that don't
+    // answer: COLORFGBG is frozen at shell startup (and propagated stale by
+    // tmux/ssh), and the OS appearance describes the system, not the terminal
+    // profile. Ordering OSC 11 first is what keeps "auto" matching reality.
+    if (process.stdout.isTTY && process.stdin.isTTY) {
+        const fromOsc = await queryOsc11(timeoutMs);
+        if (fromOsc)
+            return fromOsc;
+    }
+    const fromEnv = parseColorFgBg(process.env.COLORFGBG);
+    if (fromEnv)
+        return fromEnv;
+    const fromOs = detectOsAppearanceTheme();
+    if (fromOs)
+        return fromOs;
+    return "dark";
+}
+export function parseColorFgBg(value) {
+    if (!value)
+        return null;
+    const parts = value.split(";");
+    const last = parts[parts.length - 1];
+    if (!last)
+        return null;
+    const bg = parseInt(last, 10);
+    if (Number.isNaN(bg))
+        return null;
+    if (bg >= 0 && bg <= 6)
+        return "dark";
+    if (bg >= 7 && bg <= 15)
+        return "light";
+    return null;
+}
+function queryOsc11(timeoutMs) {
+    return new Promise((resolve) => {
+        const stdin = process.stdin;
+        const stdout = process.stdout;
+        let settled = false;
+        const originalRaw = stdin.isRaw;
+        let buffer = "";
+        const cleanup = () => {
+            stdin.removeListener("data", onData);
+            try {
+                stdin.setRawMode(originalRaw);
+            }
+            catch {
+                // ignore - terminal may have already restored
+            }
+            stdin.pause();
+        };
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            cleanup();
+            resolve(result);
+        };
+        const onData = (chunk) => {
+            buffer += chunk.toString("utf8");
+            const match = buffer.match(/\x1b\]11;rgb:([0-9a-fA-F]+)\/([0-9a-fA-F]+)\/([0-9a-fA-F]+)(?:\x07|\x1b\\)/);
+            if (!match)
+                return;
+            const [, r, g, b] = match;
+            const lum = relativeLuminance(parseHexChannel(r), parseHexChannel(g), parseHexChannel(b));
+            finish(lum > 0.5 ? "light" : "dark");
+        };
+        try {
+            stdin.setRawMode(true);
+        }
+        catch {
+            resolve(null);
+            return;
+        }
+        stdin.resume();
+        stdin.on("data", onData);
+        const timer = setTimeout(() => finish(null), timeoutMs);
+        try {
+            stdout.write("\x1b]11;?\x07");
+        }
+        catch {
+            finish(null);
+        }
+    });
+}
+function parseHexChannel(hex) {
+    const max = (1 << (hex.length * 4)) - 1;
+    return parseInt(hex, 16) / max;
+}
+function relativeLuminance(r, g, b) {
+    const channel = (c) => c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+    return 0.2126 * channel(r) + 0.7152 * channel(g) + 0.0722 * channel(b);
+}
+function detectOsAppearanceTheme() {
+    if (process.platform !== "darwin")
+        return null;
+    try {
+        const output = execFileSync("/usr/bin/defaults", ["read", "-g", "AppleInterfaceStyle"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 100,
+        });
+        return themeFromMacOsAppearance(output);
+    }
+    catch {
+        // On macOS the key is absent in Light mode, and `defaults read` exits 1.
+        return "light";
+    }
+}
+export function themeFromMacOsAppearance(output) {
+    return output?.trim().toLowerCase() === "dark" ? "dark" : "light";
+}

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

@@ -0,0 +1,64 @@
+import type { ToolResultMetadata, TokenUsage } from "../types.js";
+export interface CompactionMeta {
+    turns: number;
+    messages: number;
+    summarySections: Array<{
+        label: string;
+        content: string;
+    }>;
+    contextWindow?: number;
+    compactedAt: number;
+}
+export type UserInputStatus = "queued" | "pending_steer";
+export interface DisplayMessage {
+    role: "user" | "assistant" | "error";
+    content: string;
+    clientId?: string;
+    inputStatus?: UserInputStatus;
+    reasoning?: string;
+    toolCalls?: DisplayToolCall[];
+    parts?: DisplayMessagePart[];
+    status?: "thinking" | "responding";
+    streaming?: boolean;
+    syntheticKind?: "ui_compact_card";
+    hiddenCount?: number;
+    compactionMeta?: CompactionMeta;
+    turnStartedAt?: number;
+    turnCompletedAt?: number;
+    turnUsage?: TokenUsage;
+    taskElapsedMs?: number;
+}
+export type DisplayMessagePart = DisplayTextPart | DisplayToolsPart;
+export interface DisplayTextPart {
+    type: "text";
+    content: string;
+}
+export interface DisplayToolsPart {
+    type: "tools";
+    toolCalls: DisplayToolCall[];
+}
+export interface DisplayToolCall {
+    id: string;
+    name: string;
+    args: Record<string, any>;
+    rawArguments?: string;
+    streamingArgs?: boolean;
+    /** During streaming, an approximate line count derived from `\n` escapes in rawArguments. */
+    streamingNewlineCount?: number;
+    status?: "pending" | "running" | "completed" | "error";
+    result?: string;
+    resultCollapsed?: boolean;
+    isError?: boolean;
+    metadata?: ToolResultMetadata;
+    startedAt?: number;
+    completedAt?: number;
+}
+export declare function userInputStatusBadgeLabel(status?: UserInputStatus): string | undefined;
+export declare function setUserInputStatus(message: DisplayMessage, inputStatus?: UserInputStatus): DisplayMessage;
+export declare function appendTextPart(parts: DisplayMessagePart[], content: string): void;
+export declare function appendToolPart(parts: DisplayMessagePart[], toolCall: DisplayToolCall): void;
+export declare function snapshotDisplayParts(parts: DisplayMessagePart[]): DisplayMessagePart[];
+export declare function contentFromParts(parts: DisplayMessagePart[]): string;
+export declare function toolCallsFromParts(parts: DisplayMessagePart[]): DisplayToolCall[];
+export declare function compactDisplayMessages(messages: DisplayMessage[]): DisplayMessage[];
+export declare function formatCompactNumber(n: number): string;

package/dist/tui/display-history.js

@@ -0,0 +1,283 @@
+export function userInputStatusBadgeLabel(status) {
+    switch (status) {
+        case "queued":
+            return "QUEUED";
+        case "pending_steer":
+            return "STEER";
+        default:
+            return undefined;
+    }
+}
+export function setUserInputStatus(message, inputStatus) {
+    if (inputStatus)
+        return { ...message, inputStatus };
+    const { inputStatus: _inputStatus, ...rest } = message;
+    return rest;
+}
+export function appendTextPart(parts, content) {
+    if (!content)
+        return;
+    const last = parts[parts.length - 1];
+    if (last?.type === "text") {
+        last.content += content;
+    }
+    else {
+        parts.push({ type: "text", content });
+    }
+}
+export function appendToolPart(parts, toolCall) {
+    const last = parts[parts.length - 1];
+    if (last?.type === "tools") {
+        last.toolCalls.push(toolCall);
+    }
+    else {
+        parts.push({ type: "tools", toolCalls: [toolCall] });
+    }
+}
+export function snapshotDisplayParts(parts) {
+    return parts.map((part) => {
+        if (part.type === "text") {
+            return { ...part };
+        }
+        return {
+            type: "tools",
+            toolCalls: part.toolCalls.map(cloneToolCall),
+        };
+    });
+}
+export function contentFromParts(parts) {
+    return parts
+        .filter((part) => part.type === "text")
+        .map((part) => part.content)
+        .join("");
+}
+export function toolCallsFromParts(parts) {
+    return parts.flatMap((part) => part.type === "tools" ? part.toolCalls : []);
+}
+const MAX_VISIBLE_MESSAGES = 80;
+const FULL_DETAIL_WINDOW = 24;
+const COMPACTION_SUMMARY_ITEMS = 6;
+const COMPACTION_FILE_LIMIT = 8;
+const TOOL_PATH_KEYS = ["file", "path", "paths", "filePath"];
+// Display-history folding policy: message text is NEVER rewritten or truncated.
+// Visible messages keep their content verbatim (older ones only collapse bulky
+// tool-result bodies, which the UI can re-expand). When history exceeds
+// MAX_VISIBLE_MESSAGES, the entire older span is folded behind a single summary
+// card — mirroring how mainstream coding agents present compacted history —
+// instead of clipping individual messages mid-sentence.
+export function compactDisplayMessages(messages) {
+    if (messages.length === 0) {
+        return messages;
+    }
+    let hiddenCount = 0;
+    let accumulatedTurns = 0;
+    const summarySections = [];
+    const withoutSynthetic = messages.filter((message) => {
+        if (message.syntheticKind !== "ui_compact_card") {
+            return true;
+        }
+        hiddenCount += message.hiddenCount ?? 0;
+        if (message.compactionMeta) {
+            accumulatedTurns += message.compactionMeta.turns;
+            for (const section of message.compactionMeta.summarySections) {
+                summarySections.push(section);
+            }
+        }
+        return false;
+    });
+    const overflow = Math.max(0, withoutSynthetic.length - MAX_VISIBLE_MESSAGES);
+    hiddenCount += overflow;
+    const hiddenMessages = overflow > 0 ? withoutSynthetic.slice(0, overflow) : [];
+    const visible = overflow > 0 ? withoutSynthetic.slice(overflow) : withoutSynthetic;
+    const detailStart = Math.max(0, visible.length - FULL_DETAIL_WINDOW);
+    const compacted = visible.map((message, index) => {
+        if (message.syntheticKind === "ui_compact_card") {
+            return message;
+        }
+        return index < detailStart ? collapseToolResults(message) : message;
+    });
+    if (hiddenCount === 0) {
+        return compacted;
+    }
+    const extractedMeta = extractCompactionMeta(hiddenMessages, hiddenCount, accumulatedTurns, summarySections);
+    return [buildCompactCard(extractedMeta), ...compacted];
+}
+function extractCompactionMeta(hiddenMessages, hiddenCount, previousTurns, previousSections) {
+    const turnsInBatch = countUserTurns(hiddenMessages);
+    const totalTurns = previousTurns + turnsInBatch;
+    const sections = [
+        ...previousSections,
+        ...extractSummarySections(hiddenMessages),
+    ];
+    return {
+        turns: totalTurns,
+        messages: hiddenCount,
+        summarySections: mergeSummarySections(sections, COMPACTION_SUMMARY_ITEMS),
+        compactedAt: Date.now(),
+    };
+}
+function countUserTurns(messages) {
+    return messages.filter((message) => message.role === "user").length;
+}
+function extractSummarySections(messages) {
+    const sections = [];
+    const userMessages = messages
+        .filter((m) => m.role === "user")
+        .map((m) => m.content);
+    if (userMessages.length > 0) {
+        sections.push({
+            label: "Progress",
+            content: userMessages.slice(0, 5).map((c) => `- ${shorten(c, 100)}`).join("\n"),
+        });
+    }
+    const assistantInsights = messages
+        .filter((m) => m.role === "assistant" && m.content.trim())
+        .map((m) => m.content.trim());
+    if (assistantInsights.length > 0) {
+        sections.push({
+            label: "Decisions",
+            content: assistantInsights.slice(0, 3).map((c) => `- ${shorten(c, 120)}`).join("\n"),
+        });
+    }
+    const files = collectFiles(messages);
+    if (files.length > 0) {
+        sections.push({
+            label: "Files",
+            content: files.slice(0, COMPACTION_FILE_LIMIT).join(", "),
+        });
+    }
+    const toolFindings = collectToolFindings(messages);
+    if (toolFindings.length > 0) {
+        sections.push({
+            label: "Tools",
+            content: toolFindings.slice(0, 5).map((f) => `- ${f}`).join("\n"),
+        });
+    }
+    return sections;
+}
+function collectFiles(messages) {
+    const files = new Set();
+    for (const message of messages) {
+        for (const tool of message.toolCalls ?? []) {
+            for (const key of TOOL_PATH_KEYS) {
+                const value = tool.args[key];
+                if (typeof value === "string" && value) {
+                    files.add(value);
+                }
+                if (Array.isArray(value)) {
+                    for (const item of value) {
+                        if (typeof item === "string" && item) {
+                            files.add(item);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return [...files].slice(0, COMPACTION_FILE_LIMIT);
+}
+function collectToolFindings(messages) {
+    const findings = [];
+    for (const message of messages) {
+        for (const tool of message.toolCalls ?? []) {
+            if (tool.result && tool.result.length > 0) {
+                findings.push(`${tool.name}: ${shorten(tool.result, 80)}`);
+                if (findings.length >= 10)
+                    break;
+            }
+        }
+        if (findings.length >= 10)
+            break;
+    }
+    return findings;
+}
+function mergeSummarySections(sections, maxItems) {
+    const merged = new Map();
+    for (const section of sections) {
+        const existing = merged.get(section.label);
+        if (existing) {
+            merged.set(section.label, `${existing}\n${section.content}`);
+        }
+        else {
+            merged.set(section.label, section.content);
+        }
+    }
+    return [...merged.entries()]
+        .map(([label, content]) => ({ label, content }))
+        .slice(0, maxItems);
+}
+function buildCompactCard(meta) {
+    const parts = [];
+    if (meta.turns > 0) {
+        parts.push(`${meta.turns} turn${meta.turns === 1 ? "" : "s"}`);
+    }
+    if (meta.messages > 0) {
+        parts.push(`${meta.messages} message${meta.messages === 1 ? "" : "s"}`);
+    }
+    const statsLine = parts.length > 0 ? `┃ ${parts.join(" · ")}` : "";
+    const sectionLines = [];
+    for (const section of meta.summarySections) {
+        sectionLines.push(`┃ ${section.label}: ${section.content.split("\n")[0]}`);
+    }
+    const content = [statsLine, ...sectionLines].filter(Boolean).join("\n");
+    return {
+        role: "assistant",
+        content,
+        syntheticKind: "ui_compact_card",
+        hiddenCount: meta.messages,
+        compactionMeta: meta,
+        status: "responding",
+    };
+}
+// Collapses bulky tool-result bodies on older messages while leaving the
+// message text (content, reasoning) verbatim — never truncate what the user
+// or the assistant actually said.
+function collapseToolResults(message) {
+    if (message.syntheticKind === "ui_compact_card") {
+        return message;
+    }
+    return {
+        ...message,
+        toolCalls: message.toolCalls?.map(compactToolCall),
+        parts: message.parts?.map(compactDisplayPart),
+    };
+}
+function cloneToolCall(toolCall) {
+    return {
+        ...toolCall,
+        args: { ...toolCall.args },
+    };
+}
+function compactDisplayPart(part) {
+    if (part.type === "text") {
+        return part;
+    }
+    return {
+        type: "tools",
+        toolCalls: part.toolCalls.map(compactToolCall),
+    };
+}
+function compactToolCall(toolCall) {
+    if (toolCall.result === undefined) {
+        return toolCall;
+    }
+    return {
+        ...toolCall,
+        result: undefined,
+        resultCollapsed: true,
+    };
+}
+function shorten(text, maxChars) {
+    const normalized = text.replace(/\s+/g, " ").trim();
+    if (normalized.length <= maxChars) {
+        return normalized;
+    }
+    return `${normalized.slice(0, maxChars - 1)}…`;
+}
+export function formatCompactNumber(n) {
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 1_000)
+        return `${(n / 1_000).toFixed(1)}K`;
+    return String(n);
+}

package/dist/tui/display-sanitizer.d.ts

@@ -0,0 +1,3 @@
+import type { DisplayMessage } from "./display-history.js";
+export declare function sanitizeDisplayMessages(messages: DisplayMessage[]): DisplayMessage[];
+export declare function sanitizeDisplayMessage(message: DisplayMessage): DisplayMessage;

package/dist/tui/display-sanitizer.js

@@ -0,0 +1,38 @@
+import { sanitizeInternalReasoningText, sanitizeInternalReminderBlocks, } from "../agent/internal-reminder-sanitizer.js";
+export function sanitizeDisplayMessages(messages) {
+    return messages.map(sanitizeDisplayMessage);
+}
+export function sanitizeDisplayMessage(message) {
+    if (message.role !== "assistant")
+        return message;
+    const content = sanitizeInternalReminderBlocks(message.content);
+    const reasoning = message.reasoning !== undefined
+        ? sanitizeInternalReasoningText(message.reasoning)
+        : undefined;
+    const sanitizedParts = message.parts
+        ?.map(sanitizeDisplayPart)
+        .filter(isRenderableDisplayPart);
+    const parts = sanitizedParts && sanitizedParts.length > 0 ? sanitizedParts : undefined;
+    if (content === message.content
+        && reasoning === message.reasoning
+        && parts === message.parts) {
+        return message;
+    }
+    return {
+        ...message,
+        content,
+        reasoning,
+        parts,
+    };
+}
+function sanitizeDisplayPart(part) {
+    if (part.type !== "text")
+        return part;
+    const content = sanitizeInternalReminderBlocks(part.content);
+    return content === part.content ? part : { ...part, content };
+}
+function isRenderableDisplayPart(part) {
+    if (part.type === "text")
+        return !!part.content.trim();
+    return part.toolCalls.length > 0;
+}

package/dist/tui/edit-diff.d.ts

@@ -0,0 +1,11 @@
+import type { DisplayToolCall } from "./display-history.js";
+export declare const EDIT_COLLAPSED_DIFF_LINES = 20;
+export interface EditDiffDetails {
+    diff: string;
+    added: number;
+    removed: number;
+    path?: string;
+}
+export declare function getEditDiffDetails(tool: DisplayToolCall): EditDiffDetails | null;
+export declare function formatEditSuccessSummary(details: EditDiffDetails | null): string;
+export declare function formatEditStats(added: number, removed: number): string;

package/dist/tui/edit-diff.js

@@ -0,0 +1,57 @@
+import { countUnifiedDiffChanges } from "../diff-stats.js";
+export const EDIT_COLLAPSED_DIFF_LINES = 20;
+export function getEditDiffDetails(tool) {
+    if ((tool.name !== "edit" && tool.name !== "apply_patch") || tool.isError)
+        return null;
+    const metadata = tool.metadata;
+    const metadataDiff = readMetadataString(metadata, "diff");
+    const diff = metadataDiff ?? extractDiffFromResult(tool.result);
+    if (!diff)
+        return null;
+    const counted = countUnifiedDiffChanges(diff);
+    const added = readMetadataNumber(metadata, "addedLines") ?? counted.added;
+    const removed = readMetadataNumber(metadata, "removedLines") ?? counted.removed;
+    const path = readMetadataString(metadata, "path")
+        ?? readFirstMetadataPath(metadata)
+        ?? (typeof tool.args.path === "string" ? tool.args.path : undefined);
+    return { diff, added, removed, path };
+}
+function readFirstMetadataPath(metadata) {
+    const value = metadata?.paths;
+    return Array.isArray(value) && typeof value[0] === "string" ? value[0] : undefined;
+}
+export function formatEditSuccessSummary(details) {
+    const stats = details ? formatEditStats(details.added, details.removed) : "";
+    return `Succeeded. File edited.${stats ? ` ${stats}` : ""}`;
+}
+export function formatEditStats(added, removed) {
+    const parts = [];
+    if (added > 0)
+        parts.push(`+${added} added`);
+    if (removed > 0)
+        parts.push(`-${removed} removed`);
+    if (parts.length === 0)
+        return "";
+    return `(${parts.join(", ")})`;
+}
+function extractDiffFromResult(result) {
+    if (!result)
+        return null;
+    const normalized = result.replace(/\r\n/g, "\n");
+    const marker = "\nDiff:\n";
+    const index = normalized.indexOf(marker);
+    if (index === -1)
+        return null;
+    const rawDiff = normalized.slice(index + marker.length);
+    const diagnosticsIndex = rawDiff.search(/\n\nLSP diagnostics in /);
+    const diff = diagnosticsIndex === -1 ? rawDiff : rawDiff.slice(0, diagnosticsIndex);
+    return diff.trim().length > 0 ? diff : null;
+}
+function readMetadataString(metadata, key) {
+    const value = metadata?.[key];
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function readMetadataNumber(metadata, key) {
+    const value = metadata?.[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}

package/dist/tui/file-mentions.d.ts

@@ -0,0 +1,29 @@
+export interface AtContext {
+    start: number;
+    end: number;
+    query: string;
+}
+export interface FileSuggestion {
+    path: string;
+    score: number;
+}
+export interface ExpandedMention {
+    path: string;
+    bytes: number;
+    truncated: boolean;
+}
+export interface ExpandResult {
+    text: string;
+    expanded: ExpandedMention[];
+    missing: string[];
+    skipped: Array<{
+        path: string;
+        reason: string;
+        bytes?: number;
+    }>;
+}
+export declare function findAtContext(text: string, cursor: number): AtContext | null;
+export declare function filterFileSuggestions(files: string[], query: string, limit?: number): FileSuggestion[];
+export declare function listProjectFiles(cwd: string): Promise<string[]>;
+export declare function invalidateFileListCache(cwd?: string): void;
+export declare function expandAtMentions(text: string, cwd: string): Promise<ExpandResult>;