@bubblebrain-ai/bubble 0.0.63 → 0.0.65

package/dist/tui/trace-groups.js

@@ -0,0 +1,554 @@
+import os from "node:os";
+import { getEditDiffDetails } from "./edit-diff.js";
+import { formatSubagentRoute } from "../agent/subagent-route-format.js";
+import { mcpInfoFromString } from "../mcp/name.js";
+import { analyzeToolIntent } from "../agent/tool-intent.js";
+const DEFAULT_MAX_ITEMS = 6;
+const DEFAULT_MAX_PREVIEW_LINES = 8;
+export function buildTraceGroups(toolCalls, options = {}) {
+    const maxItems = options.maxItems ?? DEFAULT_MAX_ITEMS;
+    const maxPreviewLines = options.maxPreviewLines ?? DEFAULT_MAX_PREVIEW_LINES;
+    const homeDir = options.homeDir ?? os.homedir();
+    const groups = [];
+    let bucket = [];
+    let bucketClassifier = null;
+    const flush = () => {
+        if (bucket.length === 0 || !bucketClassifier)
+            return;
+        groups.push(buildTraceGroup(bucketClassifier, bucket, {
+            maxItems,
+            maxPreviewLines,
+            homeDir,
+        }));
+        bucket = [];
+        bucketClassifier = null;
+    };
+    for (const toolCall of toolCalls) {
+        const classifier = classifyTool(toolCall);
+        if (!classifier.groupable) {
+            flush();
+            groups.push(buildTraceGroup(classifier, [toolCall], {
+                maxItems,
+                maxPreviewLines,
+                homeDir,
+            }));
+            continue;
+        }
+        if (bucketClassifier?.bucketKey === classifier.bucketKey) {
+            bucket.push(toolCall);
+        }
+        else {
+            flush();
+            bucket = [toolCall];
+            bucketClassifier = classifier;
+        }
+    }
+    flush();
+    return groups;
+}
+export function formatTracePath(value, homeDir = os.homedir()) {
+    const text = String(value ?? "").trim();
+    if (!text)
+        return "";
+    if (text === homeDir)
+        return "~";
+    if (text.startsWith(homeDir + "/"))
+        return "~" + text.slice(homeDir.length);
+    return text;
+}
+export function formatElapsed(startedAt, now = Date.now()) {
+    if (!startedAt)
+        return null;
+    const seconds = Math.max(0, Math.floor((now - startedAt) / 1000));
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remainder = seconds % 60;
+    return `${minutes}m${remainder.toString().padStart(2, "0")}s`;
+}
+export function traceGroupLabel(group) {
+    if (group.description)
+        return `${group.title} ${group.description}`;
+    if (group.command)
+        return `${group.title} ${group.command}`;
+    if (group.count !== undefined && group.noun)
+        return `${group.title} ${group.count} ${group.noun}`;
+    return group.title;
+}
+/**
+ * An execute command is shown inline in the header only when nothing is lost:
+ * no description competing for the slot, a single logical line, and it fits
+ * the width budget. Otherwise the full command renders as a wrapped block
+ * below the header — commands are never clipped mid-line.
+ */
+export function shouldInlineExecuteCommand(group, widthBudget) {
+    if (group.kind !== "execute" || !group.command)
+        return false;
+    if (group.description)
+        return false;
+    const lines = group.commandLines ?? [];
+    if (lines.length > 1)
+        return false;
+    return group.command.length <= widthBudget;
+}
+/** Visible command-block lines for compact rendering, capped at `maxLines`. */
+export function executeCommandBlock(group, maxLines) {
+    const lines = group.commandLines ?? [];
+    const shown = lines.slice(0, maxLines);
+    return { lines: shown, omitted: Math.max(0, lines.length - shown.length) };
+}
+function classifyTool(toolCall) {
+    if (toolCall.metadata?.kind === "subagent") {
+        return { kind: "subagent", title: "Subagents", bucketKey: `subagent:${toolCall.id}`, groupable: false };
+    }
+    if (toolCall.name === "bash") {
+        const semanticKind = toolCall.metadata?.kind;
+        const family = semanticKind === "read" || semanticKind === "search"
+            ? semanticKind
+            : analyzeToolIntent({ name: toolCall.name, parsedArgs: toolCall.args }).family;
+        if (family === "read") {
+            return { kind: "read", title: "Read", bucketKey: "read", groupable: true };
+        }
+        if (family === "search") {
+            return { kind: "search", title: "Search", bucketKey: "search", groupable: true };
+        }
+    }
+    switch (toolCall.name) {
+        case "ls":
+            return { kind: "list", title: "List Directory", bucketKey: "list:directory", groupable: true };
+        case "glob": {
+            const title = "Find Files";
+            return {
+                kind: "list",
+                title,
+                bucketKey: `list:${title}`,
+                groupable: true,
+            };
+        }
+        case "read":
+            return { kind: "read", title: "Read", bucketKey: "read", groupable: true };
+        case "grep":
+            return { kind: "search", title: "Search", bucketKey: "search", groupable: true };
+        case "bash":
+            return { kind: "execute", title: "Execute", bucketKey: `execute:${toolCall.id}`, groupable: false };
+        case "edit":
+            return { kind: "edit", title: "Edit", bucketKey: `edit:${toolCall.id}`, groupable: false };
+        case "write":
+            return { kind: "write", title: "Write", bucketKey: "write", groupable: true };
+        default: {
+            const mcp = mcpInfoFromString(toolCall.name);
+            const title = mcp
+                ? `${mcp.serverName.toUpperCase()}: ${mcp.toolName}`
+                : displayToolName(toolCall.name);
+            return {
+                kind: "other",
+                title,
+                bucketKey: `${toolCall.name}:${toolCall.id}`,
+                groupable: false,
+            };
+        }
+    }
+}
+function buildTraceGroup(classifier, raw, options) {
+    const pending = raw.some((tool) => isToolPending(tool));
+    const startedAt = raw
+        .filter((tool) => isToolPending(tool))
+        .map((tool) => tool.startedAt)
+        .filter((value) => typeof value === "number")
+        .sort((a, b) => a - b)[0];
+    const hasError = raw.some((tool) => !!tool.isError);
+    const errorCount = raw.filter((tool) => !!tool.isError).length;
+    switch (classifier.kind) {
+        case "list":
+            return buildListGroup(classifier, raw, options, pending, startedAt, hasError, errorCount);
+        case "read":
+            return buildPathGroup(classifier, raw, options, pending, startedAt, hasError, errorCount, "files");
+        case "search":
+            return buildSearchGroup(classifier, raw, options, pending, startedAt, hasError, errorCount);
+        case "execute":
+            return buildExecuteGroup(classifier, raw[0], options, pending, startedAt, hasError, errorCount);
+        case "edit":
+        case "write":
+            return buildMutationGroup(classifier, raw, options, pending, startedAt, hasError, errorCount);
+        case "subagent":
+            return buildSubagentGroup(classifier, raw[0], options, pending, startedAt);
+        default:
+            return buildOtherGroup(classifier, raw, options, pending, startedAt, hasError, errorCount);
+    }
+}
+function buildListGroup(classifier, raw, options, pending, startedAt, hasError, errorCount) {
+    const matchCount = listMatchCount(raw);
+    const resultItems = raw.flatMap((tool) => listResultItems(tool, options.homeDir));
+    const fallbackItems = raw
+        .map((tool) => String(tool.args.pattern ?? tool.args.path ?? "").trim())
+        .filter(Boolean)
+        .map((item) => formatTracePath(item, options.homeDir));
+    const hasResultData = matchCount !== undefined || resultItems.length > 0 || raw.some((tool) => isEmptyListResult(tool.result));
+    const sourceItems = hasResultData ? resultItems : fallbackItems;
+    const { shown, omitted } = take(sourceItems, options.maxItems);
+    const count = matchCount ?? (hasResultData ? resultItems.length : sourceItems.length || raw.length);
+    const noun = hasResultData
+        ? classifier.title === "List Directory" ? plural(count, "entry", "entries") : plural(count, "file", "files")
+        : plural(count, "search", "searches");
+    return {
+        kind: "list",
+        title: classifier.title,
+        raw,
+        count,
+        noun,
+        items: shown,
+        previewLines: [],
+        errorLines: collectErrorLines(raw, options),
+        omitted,
+        pending,
+        hasError,
+        errorCount,
+        startedAt,
+    };
+}
+function listResultItems(tool, homeDir) {
+    const metadataPaths = Array.isArray(tool.metadata?.paths)
+        ? tool.metadata.paths.filter((item) => typeof item === "string" && item.trim().length > 0)
+        : [];
+    if (Array.isArray(tool.metadata?.paths)) {
+        return metadataPaths.map((line) => formatTracePath(line, homeDir));
+    }
+    return resultLines(tool.result)
+        .filter(isListResultLine)
+        .map((line) => formatTracePath(line, homeDir));
+}
+function listMatchCount(raw) {
+    let count = 0;
+    let sawMetadata = false;
+    for (const tool of raw) {
+        const matches = tool.metadata?.matches;
+        if (typeof matches === "number" && Number.isFinite(matches)) {
+            count += Math.max(0, matches);
+            sawMetadata = true;
+        }
+    }
+    return sawMetadata ? count : undefined;
+}
+function isEmptyListResult(result) {
+    if (result === undefined)
+        return false;
+    const lines = resultLines(result);
+    return lines.length > 0 && lines.every((line) => !isListResultLine(line));
+}
+function isListResultLine(line) {
+    const normalized = line.trim();
+    return !/^\(empty directory\)$/i.test(normalized)
+        && !/^\[Output truncated.*\]$/i.test(normalized)
+        && !/^No files found\.?$/i.test(normalized)
+        && !/^\[More than \d+ files, output truncated\]$/i.test(normalized);
+}
+function buildPathGroup(classifier, raw, options, pending, startedAt, hasError, errorCount, nounBase) {
+    const items = unique(raw
+        .map((tool) => formatTracePath(tool.args.path
+        ?? tool.args.file
+        ?? tool.metadata?.path
+        ?? analyzeToolIntent({ name: tool.name, parsedArgs: tool.args }).read?.path
+        ?? "", options.homeDir))
+        .filter(Boolean));
+    const { shown, omitted } = take(items, options.maxItems);
+    const count = items.length || raw.length;
+    return {
+        kind: classifier.kind,
+        title: classifier.title,
+        raw,
+        count,
+        noun: plural(count, nounBase.slice(0, -1), nounBase),
+        items: shown,
+        previewLines: [],
+        errorLines: collectErrorLines(raw, options),
+        omitted,
+        pending,
+        hasError,
+        errorCount,
+        startedAt,
+    };
+}
+function buildSearchGroup(classifier, raw, options, pending, startedAt, hasError, errorCount) {
+    const items = raw.map((tool) => {
+        const intent = analyzeToolIntent({ name: tool.name, parsedArgs: tool.args }).search;
+        const pattern = String(tool.args.pattern ?? tool.args.query ?? tool.metadata?.pattern ?? intent?.pattern ?? "").trim();
+        const scope = String(tool.args.path ?? tool.args.glob ?? tool.args.include ?? tool.metadata?.path ?? intent?.path ?? "").trim();
+        const patternText = pattern ? `"${pattern}"` : "(pattern)";
+        return scope ? `${patternText} in ${formatTracePath(scope, options.homeDir)}` : patternText;
+    });
+    const resultPreview = raw.flatMap((tool) => resultLines(tool.result))
+        .map((line) => formatTracePath(line, options.homeDir));
+    const { shown, omitted } = take(items, options.maxItems);
+    const preview = take(resultPreview, options.maxPreviewLines);
+    const count = raw.length;
+    return {
+        kind: "search",
+        title: classifier.title,
+        raw,
+        count,
+        noun: plural(count, "search", "searches"),
+        items: shown,
+        previewLines: preview.shown,
+        errorLines: collectErrorLines(raw, options),
+        omitted: omitted + preview.omitted,
+        pending,
+        hasError,
+        errorCount,
+        startedAt,
+    };
+}
+function buildExecuteGroup(classifier, tool, options, pending, startedAt, hasError, errorCount) {
+    const lines = resultLines(tool.result).map((line) => formatTracePath(line, options.homeDir));
+    const { shown, omitted } = take(lines, options.maxPreviewLines);
+    const rawCommand = String(tool.args.command ?? tool.args.cmd ?? commandFromRawArguments(tool.rawArguments) ?? "");
+    const description = String(tool.args.description ?? "").trim() || undefined;
+    return {
+        kind: "execute",
+        title: classifier.title,
+        raw: [tool],
+        command: normalizeCommand(rawCommand),
+        description,
+        commandLines: commandLinesOf(rawCommand),
+        items: [],
+        previewLines: shown,
+        errorLines: [],
+        omitted,
+        pending,
+        hasError,
+        errorCount,
+        startedAt,
+    };
+}
+function buildMutationGroup(classifier, raw, options, pending, startedAt, hasError, errorCount) {
+    const items = raw
+        .map((tool) => {
+        const path = formatTracePath(tool.args.path ?? firstMetadataPath(tool) ?? "", options.homeDir);
+        const details = tool.name === "edit" || tool.name === "apply_patch" ? getEditDiffDetails(tool) : null;
+        const suffix = details ? ` ${formatCompactEditStats(details.added, details.removed)}` : "";
+        return path ? `${path}${suffix}` : "";
+    })
+        .filter(Boolean);
+    const { shown, omitted } = take(items, options.maxItems);
+    const count = items.length || raw.length;
+    const errorPreview = hasError
+        ? raw
+            .filter((tool) => tool.isError)
+            .flatMap((tool) => resultLines(tool.result).map((line) => formatTracePath(line, options.homeDir)))
+            .slice(0, options.maxPreviewLines)
+        : [];
+    return {
+        kind: classifier.kind,
+        title: classifier.title,
+        raw,
+        count,
+        noun: plural(count, "file", "files"),
+        items: shown,
+        previewLines: errorPreview,
+        errorLines: [],
+        omitted,
+        pending,
+        hasError,
+        errorCount,
+        startedAt,
+    };
+}
+function buildSubagentGroup(classifier, tool, options, pending, startedAt) {
+    const subagents = subagentsFromMetadata(tool);
+    const rows = subagents.length > 0
+        ? subagents.map(formatSubagentRow)
+        : resultLines(tool.result).map((line) => formatTracePath(line, options.homeDir));
+    const { shown, omitted } = take(rows, options.maxPreviewLines);
+    const errorCount = subagents.filter(isFailedSubagent).length + (tool.isError ? 1 : 0);
+    return {
+        kind: "subagent",
+        title: classifier.title,
+        raw: [tool],
+        count: subagents.length || 1,
+        noun: plural(subagents.length || 1, "agent", "agents"),
+        items: [],
+        previewLines: shown,
+        errorLines: [],
+        omitted,
+        pending: pending || subagents.some((subagent) => ["queued", "running"].includes(subagent.status ?? "running")),
+        hasError: !!tool.isError || errorCount > 0,
+        errorCount,
+        startedAt,
+    };
+}
+function buildOtherGroup(classifier, raw, options, pending, startedAt, hasError, errorCount) {
+    const tool = raw[0];
+    const mcp = mcpInfoFromString(tool.name);
+    // MCP tools carry arbitrary args, so render them as `key: value` pairs inline
+    // (via the `command` slot) instead of the path-based header used for builtins.
+    const header = mcp ? undefined : toolHeader(tool, options.homeDir);
+    const argsLabel = mcp ? mcpArgsLabel(tool.args) : "";
+    // Suppress the "N calls" fallback for MCP tools — the title already names the
+    // tool, and args (when present) ride alongside it.
+    const hasInline = mcp || !!header;
+    const preview = resultLines(tool.result).map((line) => formatTracePath(line, options.homeDir));
+    const { shown, omitted } = take(preview, options.maxPreviewLines);
+    return {
+        kind: "other",
+        title: classifier.title,
+        raw,
+        command: argsLabel || undefined,
+        count: hasInline ? undefined : raw.length,
+        noun: hasInline ? undefined : plural(raw.length, "call", "calls"),
+        items: header ? [header] : [],
+        previewLines: shown,
+        errorLines: [],
+        omitted,
+        pending,
+        hasError,
+        errorCount,
+        startedAt,
+    };
+}
+function subagentsFromMetadata(tool) {
+    const raw = tool.metadata?.subagents;
+    if (!Array.isArray(raw))
+        return [];
+    return raw.filter((item) => typeof item === "object" && item !== null);
+}
+function formatSubagentRow(subagent) {
+    const label = subagent.nickname || subagent.agentName || subagent.subAgentId || "subagent";
+    const role = [subagent.agentName, subagent.category ? `/${subagent.category}` : ""].join("") || "default";
+    const route = formatSubagentRoute(subagent.route);
+    const descriptor = route ? `${role} @ ${route}` : role;
+    const status = subagent.status || "running";
+    const note = subagent.error
+        || subagent.toolNotes?.filter(Boolean).at(-1)
+        || subagent.summary
+        || subagent.task
+        || "";
+    return [label, `(${descriptor})`, status, note].filter(Boolean).join(" ");
+}
+function isFailedSubagent(subagent) {
+    return subagent.status === "failed" || subagent.status === "blocked" || subagent.status === "cancelled";
+}
+function isToolPending(tool) {
+    return tool.result === undefined && tool.resultCollapsed !== true;
+}
+function resultLines(result) {
+    if (result === undefined)
+        return [];
+    return result
+        .replace(/\r\n/g, "\n")
+        .split("\n")
+        .map((line) => line.trimEnd())
+        .filter((line) => line.trim() !== "");
+}
+function take(items, max) {
+    const shown = items.slice(0, max);
+    return { shown, omitted: Math.max(0, items.length - shown.length) };
+}
+function unique(items) {
+    return [...new Set(items)];
+}
+function collectErrorLines(raw, options) {
+    return raw
+        .filter((tool) => tool.isError)
+        .flatMap((tool) => resultLines(tool.result).map((line) => formatTraceLine(line, options.homeDir)))
+        .slice(0, options.maxPreviewLines);
+}
+function formatTraceLine(value, homeDir) {
+    const text = String(value ?? "").trimEnd();
+    if (!homeDir)
+        return text;
+    return text.split(homeDir + "/").join("~/").split(homeDir).join("~");
+}
+function plural(count, singular, pluralValue) {
+    return count === 1 ? singular : pluralValue;
+}
+function normalizeCommand(value) {
+    const command = String(value ?? "").replace(/\s+/g, " ").trim();
+    return command;
+}
+// Preserves the command's own line structure (heredocs, && chains the model
+// formatted across lines); only trims trailing whitespace and outer blank lines.
+function commandLinesOf(rawCommand) {
+    const lines = rawCommand
+        .replace(/\r\n/g, "\n")
+        .split("\n")
+        .map((line) => line.trimEnd());
+    while (lines.length > 0 && lines[0].trim() === "")
+        lines.shift();
+    while (lines.length > 0 && lines[lines.length - 1].trim() === "")
+        lines.pop();
+    return lines;
+}
+function commandFromRawArguments(rawArguments) {
+    if (!rawArguments)
+        return "";
+    try {
+        const parsed = JSON.parse(rawArguments);
+        if (parsed && typeof parsed === "object") {
+            const command = parsed.command ?? parsed.cmd;
+            return typeof command === "string" ? command : "";
+        }
+    }
+    catch {
+        const match = rawArguments.match(/"(?:command|cmd)"\s*:\s*"((?:\\.|[^"\\])*)/);
+        if (match?.[1]) {
+            try {
+                return JSON.parse(`"${match[1]}"`);
+            }
+            catch {
+                return match[1];
+            }
+        }
+    }
+    return "";
+}
+function displayToolName(name) {
+    if (!name)
+        return "Tool";
+    return name.charAt(0).toUpperCase() + name.slice(1).replace(/_/g, " ");
+}
+/** Compact `key: value, key: value` rendering of an MCP tool's arguments. */
+function mcpArgsLabel(args) {
+    if (!args || typeof args !== "object")
+        return "";
+    return Object.entries(args)
+        .filter(([, value]) => value !== undefined)
+        .map(([key, value]) => `${key}: ${formatMcpArgValue(value)}`)
+        .join(", ");
+}
+function formatMcpArgValue(value) {
+    if (typeof value === "string")
+        return JSON.stringify(value);
+    if (value === null || typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function toolHeader(tool, homeDir) {
+    const args = tool.args || {};
+    for (const key of ["path", "command", "pattern", "query", "url"]) {
+        const value = args[key];
+        if (value !== undefined && value !== null && String(value).trim() !== "") {
+            return formatTracePath(value, homeDir);
+        }
+    }
+    const path = firstMetadataPath(tool);
+    if (path)
+        return formatTracePath(path, homeDir);
+    return undefined;
+}
+function firstMetadataPath(tool) {
+    const paths = tool.metadata?.paths;
+    return Array.isArray(paths) && typeof paths[0] === "string" ? paths[0] : undefined;
+}
+function formatCompactEditStats(added, removed) {
+    const parts = [];
+    if (added > 0)
+        parts.push(`+${added}`);
+    if (removed > 0)
+        parts.push(`-${removed}`);
+    return parts.length > 0 ? `(${parts.join(" ")})` : "";
+}

package/dist/tui/wordmark.d.ts

@@ -0,0 +1,18 @@
+export type BubbleWordmarkTone = "brand" | "ink" | "stone" | "soft" | "caption";
+export interface BubbleWordmarkSegment {
+    text: string;
+    tone: BubbleWordmarkTone;
+}
+export interface BubbleWordmarkLine {
+    text?: string;
+    tone?: BubbleWordmarkTone;
+    segments?: BubbleWordmarkSegment[];
+}
+export declare const BUBBLE_CAT: BubbleWordmarkLine[];
+export declare const BUBBLE_CAT_LARGE: BubbleWordmarkLine[];
+export declare const BUBBLE_WORDMARK: BubbleWordmarkLine[];
+export declare const BUBBLE_WORDMARK_LARGE: BubbleWordmarkLine[];
+export declare const BUBBLE_COMPACT_WORDMARK: BubbleWordmarkLine[];
+export declare function bubbleWordmarkLineText(line: BubbleWordmarkLine): string;
+export declare function bubbleWordmarkMaxWidth(lines?: BubbleWordmarkLine[]): number;
+export declare function bubbleWordmarkForWidth(width: number): BubbleWordmarkLine[];