@bubblebrain-ai/bubble 0.0.63 → 0.0.64

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

@@ -0,0 +1,78 @@
+import type { Message, ToolResultMetadata } from "../../types.js";
+import type { DisplayImageAttachment } from "./image-attachment.js";
+export type UserInputStatus = "queued" | "pending_steer";
+export interface DisplayMessage {
+    /** Stable identity, used as the transcript list key. Generated by the UI layer. */
+    key?: string;
+    role: "user" | "assistant" | "error";
+    content: string;
+    /** Rich image state retained for chips, preview and session restore. */
+    images?: DisplayImageAttachment[];
+    /** Correlates queued/steer placeholder rows with their lifecycle events. */
+    clientId?: string;
+    /** Badge for user input waiting to enter the run (QUEUED / STEER). */
+    inputStatus?: UserInputStatus;
+    reasoning?: string;
+    toolCalls?: DisplayToolCall[];
+    parts?: DisplayMessagePart[];
+    syntheticKind?: "ui_summary" | "ui_compact_summary" | "ui_interrupt" | "ui_notice";
+    /** Markdown body shown inside a `ui_compact_summary` card. */
+    compactionSummary?: string;
+    hiddenCount?: number;
+    taskElapsedMs?: number;
+    /** Backend configuration fingerprint reported for this model response. */
+    systemFingerprint?: string;
+}
+export declare function userInputStatusBadgeLabel(status?: UserInputStatus): string | undefined;
+export declare function setUserInputStatus(message: DisplayMessage, inputStatus?: UserInputStatus): DisplayMessage;
+export declare function moveStatusMessageToEnd(messages: DisplayMessage[], key: string, inputStatus?: UserInputStatus): DisplayMessage[];
+/**
+ * Aborted assistant messages carry a model-facing interruption note appended
+ * to their content (whole content, or a "\n\n"-joined suffix after partial
+ * streamed text). That note is for the next model call, not the user — strip
+ * it so only what the assistant actually said renders, and let the caller
+ * show a dedicated interrupt indicator instead.
+ */
+export declare function stripInterruptedAssistantMarker(content: string, marker: string): string;
+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>;
+    /**
+     * Unparsed JSON string for tool arguments, populated during partial-streaming
+     * before `args` resolves. Used as a fallback by trace-groups when extracting
+     * a command preview.
+     */
+    rawArguments?: string;
+    /** Live execution state. Result text may be present during a running
+     *  subagent/tool update, so pending cannot be inferred from `result` alone. */
+    status?: "queued" | "pending" | "running" | "completed" | "failed" | "blocked" | "cancelled";
+    result?: string;
+    isError?: boolean;
+    metadata?: ToolResultMetadata;
+    /** Set when the tool_start event was received. Used to render elapsed time. */
+    startedAt?: number;
+}
+export declare function nextDisplayMessageKey(prefix?: string): string;
+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[];
+/**
+ * Find the most recent compaction summary embedded in the agent's system
+ * messages. Bubble's compaction step rewrites the system transcript so that
+ * the long-form summary lives in either a "Previous conversation summary:"
+ * block or an "Earlier in this turn" block; we walk from newest to oldest and
+ * return the first match so the UI can show the freshest summary.
+ */
+export declare function latestCompactionSummary(agentMessages: Message[]): string | undefined;

package/dist/tui/model/display-history.js

@@ -0,0 +1,124 @@
+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 moveStatusMessageToEnd(messages, key, inputStatus) {
+    const index = messages.findIndex((message) => message.key === key);
+    if (index === -1)
+        return messages;
+    const message = messages[index];
+    return [
+        ...messages.slice(0, index),
+        ...messages.slice(index + 1),
+        setUserInputStatus(message, inputStatus),
+    ];
+}
+/**
+ * Aborted assistant messages carry a model-facing interruption note appended
+ * to their content (whole content, or a "\n\n"-joined suffix after partial
+ * streamed text). That note is for the next model call, not the user — strip
+ * it so only what the assistant actually said renders, and let the caller
+ * show a dedicated interrupt indicator instead.
+ */
+export function stripInterruptedAssistantMarker(content, marker) {
+    if (!content || !marker)
+        return content;
+    if (content === marker)
+        return "";
+    const suffix = `\n\n${marker}`;
+    if (content.endsWith(suffix))
+        return content.slice(0, -suffix.length);
+    return content;
+}
+let __displayMessageCounter = 0;
+export function nextDisplayMessageKey(prefix = "msg") {
+    __displayMessageCounter += 1;
+    return `${prefix}-${__displayMessageCounter}`;
+}
+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 : []);
+}
+function cloneToolCall(toolCall) {
+    return {
+        ...toolCall,
+        args: { ...toolCall.args },
+    };
+}
+const PREVIOUS_SUMMARY_PREFIX = /^Previous conversation summary:\s*\n?([\s\S]*)$/;
+const TURN_SUMMARY_PREFIX = /^Earlier in this turn \(compacted to free context\):\s*\n?([\s\S]*)$/;
+/**
+ * Find the most recent compaction summary embedded in the agent's system
+ * messages. Bubble's compaction step rewrites the system transcript so that
+ * the long-form summary lives in either a "Previous conversation summary:"
+ * block or an "Earlier in this turn" block; we walk from newest to oldest and
+ * return the first match so the UI can show the freshest summary.
+ */
+export function latestCompactionSummary(agentMessages) {
+    for (let index = agentMessages.length - 1; index >= 0; index--) {
+        const message = agentMessages[index];
+        if (!message || typeof message.content !== "string")
+            continue;
+        // Summaries are meta messages since 0.0.43; raw system form is legacy.
+        const isSummaryCarrier = message.role === "system"
+            || (message.role === "meta"
+                && (message.kind === "compaction-summary" || message.kind === "subturn-compaction-summary"));
+        if (!isSummaryCarrier)
+            continue;
+        const previousMatch = message.content.match(PREVIOUS_SUMMARY_PREFIX);
+        if (previousMatch?.[1]?.trim())
+            return previousMatch[1].trim();
+        const turnMatch = message.content.match(TURN_SUMMARY_PREFIX);
+        if (turnMatch?.[1]?.trim())
+            return turnMatch[1].trim();
+    }
+    return undefined;
+}

package/dist/tui/model/display-reconstruct.d.ts

@@ -0,0 +1,3 @@
+import { type DisplayMessage } from "./display-history.js";
+import type { Message } from "../../types.js";
+export declare function reconstructDisplayMessages(agentMessages: Message[]): DisplayMessage[];

package/dist/tui/model/display-reconstruct.js

@@ -0,0 +1,130 @@
+/**
+ * Rebuilds UI DisplayMessages from the agent's raw transcript — used on
+ * initial mount and after transcript rewrites (rewind, resume).
+ */
+import { INTERRUPTED_ASSISTANT_CONTENT } from "../../agent.js";
+import { isHiddenToolMetadata } from "../../agent/tool-visibility.js";
+import { isInternalBlockOnlyContent } from "../../agent/internal-reminder-sanitizer.js";
+import { COMPACTION_SUMMARY_PREFIX } from "../../context/compact.js";
+import { nextDisplayMessageKey, stripInterruptedAssistantMarker } from "./display-history.js";
+import { synchronizeSubagentSnapshots } from "./subagent-view.js";
+import { formatImageUserDisplayText, imageAttachmentFromDataUrl, imageDisplayLabel } from "../image-display.js";
+function reconstructUserContent(message, imageDisplayStart) {
+    const { content } = message;
+    if (typeof content === "string") {
+        return { text: content, images: [], nextImageDisplayStart: imageDisplayStart };
+    }
+    const text = content
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join("\n")
+        .trim();
+    const imageCount = content.filter((part) => part.type === "image_url").length;
+    const labelStart = message.ui?.imageDisplayStart ?? imageDisplayStart;
+    const images = content
+        .filter((part) => part.type === "image_url")
+        .map((part, index) => {
+        const attachment = imageAttachmentFromDataUrl(part.image_url.url);
+        return attachment ? { ...attachment, label: imageDisplayLabel(labelStart + index) } : undefined;
+    })
+        .filter((item) => item !== undefined);
+    return {
+        text: formatImageUserDisplayText(message.ui?.displayText ?? text, imageCount, labelStart),
+        images,
+        nextImageDisplayStart: Math.max(imageDisplayStart, labelStart + imageCount),
+    };
+}
+export function reconstructDisplayMessages(agentMessages) {
+    const result = [];
+    let nextImageDisplayStart = 1;
+    for (const m of agentMessages) {
+        if (m.role === "system") {
+            const content = typeof m.content === "string" ? m.content : "";
+            if (content.startsWith(COMPACTION_SUMMARY_PREFIX)) {
+                const summary = content.slice(COMPACTION_SUMMARY_PREFIX.length).trim();
+                if (summary) {
+                    result.push({
+                        key: nextDisplayMessageKey("compact"),
+                        role: "assistant",
+                        content: "Compaction completed.",
+                        syntheticKind: "ui_compact_summary",
+                        compactionSummary: summary,
+                    });
+                }
+            }
+            continue;
+        }
+        if (m.role === "tool")
+            continue;
+        if (m.role === "user") {
+            if (m.isMeta)
+                continue; // <system-reminder> injections are not user-visible
+            // Harness-initiated kicks (goal continuations, task wakes) persist as
+            // user-role messages wrapped in internal blocks so the model keeps
+            // them across resume — but they were hidden live and must stay hidden
+            // when the transcript is rebuilt.
+            if (isInternalBlockOnlyContent(m.content))
+                continue;
+            const reconstructed = reconstructUserContent(m, nextImageDisplayStart);
+            nextImageDisplayStart = reconstructed.nextImageDisplayStart;
+            result.push({
+                key: nextDisplayMessageKey("user"),
+                role: "user",
+                content: reconstructed.text,
+                images: reconstructed.images.length > 0 ? reconstructed.images : undefined,
+            });
+        }
+        else if (m.role === "assistant") {
+            const toolCalls = [];
+            if (m.toolCalls) {
+                for (const tc of m.toolCalls) {
+                    let args = {};
+                    try {
+                        args = JSON.parse(tc.arguments || "{}");
+                    }
+                    catch {
+                        args = {};
+                    }
+                    const toolResult = agentMessages.find((tm) => tm.role === "tool" && tm.toolCallId === tc.id);
+                    if (isHiddenToolMetadata(toolResult ? toolResult.metadata : undefined))
+                        continue;
+                    toolCalls.push({
+                        id: tc.id,
+                        name: tc.name,
+                        args,
+                        result: toolResult ? toolResult.content : undefined,
+                        isError: toolResult ? toolResult.content?.startsWith?.("Error:") : false,
+                        metadata: toolResult ? toolResult.metadata : undefined,
+                    });
+                }
+            }
+            // An aborted assistant message carries the model-facing interruption
+            // note in its content. Render only what the assistant actually said
+            // (partial streamed text, if any) plus a dedicated interrupt row —
+            // never the note itself, which reads like a leaked system prompt.
+            const interrupted = m.error?.aborted === true;
+            const content = interrupted
+                ? stripInterruptedAssistantMarker(m.content, INTERRUPTED_ASSISTANT_CONTENT)
+                : m.content;
+            if (content || m.reasoning || toolCalls.length > 0 || m.systemFingerprint) {
+                result.push({
+                    key: nextDisplayMessageKey("asst"),
+                    role: "assistant",
+                    content,
+                    reasoning: m.reasoning || undefined,
+                    toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+                    systemFingerprint: m.systemFingerprint,
+                });
+            }
+            if (interrupted) {
+                result.push({
+                    key: nextDisplayMessageKey("asst"),
+                    role: "assistant",
+                    content: "Interrupted by user",
+                    syntheticKind: "ui_interrupt",
+                });
+            }
+        }
+    }
+    return synchronizeSubagentSnapshots(result);
+}

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

@@ -0,0 +1,31 @@
+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>;
+/** Composer @-mention context resolution (moved from input-box at cutover). */
+export declare function resolveComposerAtContext(text: string, cursor: number, isSlashContext: boolean, allowWorkspaceMentions?: boolean): AtContext | null;

package/dist/tui/model/file-mentions.js

@@ -0,0 +1,178 @@
+import { execFile } from "node:child_process";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const MAX_INLINE_BYTES = 200 * 1024;
+const IGNORED_DIRS = new Set([".git", "node_modules", "dist", "build", ".next", ".turbo", ".cache"]);
+const fileListCache = new Map();
+export function findAtContext(text, cursor) {
+    const before = text.slice(0, cursor);
+    const at = before.lastIndexOf("@");
+    if (at === -1)
+        return null;
+    const prev = at === 0 ? "" : before[at - 1];
+    if (prev !== "" && !/\s/.test(prev))
+        return null;
+    const query = before.slice(at + 1);
+    if (/\s/.test(query))
+        return null;
+    return { start: at, end: cursor, query };
+}
+export function filterFileSuggestions(files, query, limit = 20) {
+    const q = query.toLowerCase();
+    if (q.length === 0) {
+        return files.slice(0, limit).map((p) => ({ path: p, score: 1 }));
+    }
+    const scored = [];
+    for (const file of files) {
+        const lower = file.toLowerCase();
+        const base = path.basename(lower);
+        let score = 0;
+        if (base.startsWith(q))
+            score = 100;
+        else if (lower.startsWith(q))
+            score = 80;
+        else if (base.includes(q))
+            score = 60;
+        else if (lower.includes(q))
+            score = 40;
+        if (score > 0)
+            scored.push({ path: file, score });
+    }
+    scored.sort((a, b) => (b.score - a.score) || (a.path.length - b.path.length) || a.path.localeCompare(b.path));
+    return scored.slice(0, limit);
+}
+export async function listProjectFiles(cwd) {
+    const cached = fileListCache.get(cwd);
+    if (cached)
+        return cached;
+    const files = await discoverFiles(cwd);
+    fileListCache.set(cwd, files);
+    return files;
+}
+export function invalidateFileListCache(cwd) {
+    if (cwd)
+        fileListCache.delete(cwd);
+    else
+        fileListCache.clear();
+}
+async function discoverFiles(cwd) {
+    try {
+        const { stdout } = await execFileAsync("git", ["ls-files", "-co", "--exclude-standard"], {
+            cwd,
+            maxBuffer: 32 * 1024 * 1024,
+        });
+        const files = stdout.split("\n").map((s) => s.trim()).filter(Boolean);
+        if (files.length > 0)
+            return files;
+    }
+    catch {
+        // Not a git repo or git unavailable — fall through to filesystem walk.
+    }
+    return walkFilesystem(cwd);
+}
+async function walkFilesystem(root) {
+    const results = [];
+    async function visit(dir, rel) {
+        let entries;
+        try {
+            entries = (await fs.readdir(dir, { withFileTypes: true }));
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith(".") && entry.name !== ".env" && entry.name !== ".gitignore")
+                continue;
+            if (IGNORED_DIRS.has(entry.name))
+                continue;
+            const abs = path.join(dir, entry.name);
+            const relPath = rel ? `${rel}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                await visit(abs, relPath);
+            }
+            else if (entry.isFile()) {
+                results.push(relPath);
+            }
+        }
+    }
+    await visit(root, "");
+    return results;
+}
+const MENTION_REGEX = /(^|\s)@([^\s]+)/g;
+export async function expandAtMentions(text, cwd) {
+    const result = { text, expanded: [], missing: [], skipped: [] };
+    const mentions = Array.from(text.matchAll(MENTION_REGEX));
+    if (mentions.length === 0)
+        return result;
+    const blocks = [];
+    const seen = new Set();
+    for (const match of mentions) {
+        const token = match[2];
+        if (seen.has(token))
+            continue;
+        seen.add(token);
+        const abs = path.resolve(cwd, token);
+        if (!abs.startsWith(path.resolve(cwd))) {
+            result.skipped.push({ path: token, reason: "outside project" });
+            continue;
+        }
+        let stat;
+        try {
+            stat = await fs.stat(abs);
+        }
+        catch {
+            result.missing.push(token);
+            continue;
+        }
+        if (!stat.isFile()) {
+            result.skipped.push({ path: token, reason: "not a file" });
+            continue;
+        }
+        if (stat.size > MAX_INLINE_BYTES) {
+            result.skipped.push({ path: token, reason: "too large", bytes: stat.size });
+            blocks.push(`### @${token}\n(${formatBytes(stat.size)}, exceeds inline limit of ${formatBytes(MAX_INLINE_BYTES)} — use the Read tool to access)`);
+            continue;
+        }
+        let contents;
+        try {
+            contents = await fs.readFile(abs, "utf8");
+        }
+        catch (err) {
+            result.skipped.push({ path: token, reason: `read failed: ${err.message || String(err)}` });
+            continue;
+        }
+        result.expanded.push({ path: token, bytes: stat.size, truncated: false });
+        const lang = guessLanguage(token);
+        blocks.push(`### @${token}\n\`\`\`${lang}\n${contents}\n\`\`\``);
+    }
+    if (blocks.length === 0)
+        return result;
+    result.text = `${text}\n\n---\nReferenced files:\n\n${blocks.join("\n\n")}`;
+    return result;
+}
+function formatBytes(n) {
+    if (n < 1024)
+        return `${n}B`;
+    if (n < 1024 * 1024)
+        return `${(n / 1024).toFixed(1)}KB`;
+    return `${(n / 1024 / 1024).toFixed(1)}MB`;
+}
+function guessLanguage(filePath) {
+    const ext = path.extname(filePath).slice(1).toLowerCase();
+    const map = {
+        ts: "ts", tsx: "tsx", js: "js", jsx: "jsx",
+        py: "python", rb: "ruby", go: "go", rs: "rust",
+        java: "java", kt: "kotlin", swift: "swift",
+        c: "c", h: "c", cpp: "cpp", cc: "cpp", hpp: "cpp",
+        cs: "csharp", php: "php", sh: "bash", zsh: "bash", bash: "bash",
+        json: "json", yaml: "yaml", yml: "yaml", toml: "toml", xml: "xml",
+        html: "html", css: "css", scss: "scss", sql: "sql", md: "markdown",
+    };
+    return map[ext] ?? "";
+}
+/** Composer @-mention context resolution (moved from input-box at cutover). */
+export function resolveComposerAtContext(text, cursor, isSlashContext, allowWorkspaceMentions = true) {
+    return !allowWorkspaceMentions || isSlashContext ? null : findAtContext(text, cursor);
+}

package/dist/tui/model/image-attachment.d.ts

@@ -0,0 +1,15 @@
+/** Image attachment shape shared by composer, provider payload, and history. */
+export interface ImageAttachment {
+    base64: string;
+    mediaType: string;
+    /** Raw byte size of the decoded image (not base64). */
+    bytes: number;
+    /** data:<mediaType>;base64,<...> — ready to send as image_url.url. */
+    dataUrl: string;
+    filename?: string;
+    sourcePath?: string;
+}
+/** Image state retained by a rendered user message after composer submit. */
+export interface DisplayImageAttachment extends ImageAttachment {
+    label: string;
+}

package/dist/tui/model/image-attachment.js

@@ -0,0 +1 @@
+export {};