@bubblebrain-ai/bubble 0.0.63 → 0.0.64

package/dist/tui/model/trace-groups.js

@@ -0,0 +1,558 @@
+import os from "node:os";
+import { getEditDiffDetails } from "../formatting/edit-diff.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) {
+        // Grok keeps background-agent lifecycle in Tasks Pane. The transcript
+        // records only the launch event; wait/list/input/close echoes would repeat
+        // the same roster on every provider turn without adding chat history.
+        if (toolCall.metadata?.kind === "subagent"
+            && toolCall.name !== "spawn_agent"
+            && toolCall.name !== "run_workflow") {
+            continue;
+        }
+        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") {
+        const workflow = toolCall.name === "run_workflow" || toolCall.metadata.mode === "workflow";
+        return { kind: "subagent", title: workflow ? "Workflow" : "Subagent", 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:
+            return {
+                kind: "other",
+                title: displayToolName(toolCall.name),
+                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;
+    const taskId = typeof tool.metadata?.taskId === "string" ? tool.metadata.taskId : undefined;
+    const lifecycle = typeof tool.metadata?.taskLifecycle === "string"
+        ? tool.metadata.taskLifecycle
+        : undefined;
+    const backgroundLaunch = tool.metadata?.background === true && taskId && !lifecycle;
+    const title = lifecycle === "completed"
+        ? "Task completed"
+        : lifecycle === "failed"
+            ? "Task failed"
+            : lifecycle === "killed"
+                ? "Task killed"
+                : backgroundLaunch
+                    ? "Task started"
+                    : classifier.title;
+    const endedAt = typeof tool.metadata?.endedAt === "number" ? tool.metadata.endedAt : undefined;
+    const elapsed = endedAt ? formatElapsedDuration(tool.startedAt, endedAt) : undefined;
+    const exitCode = typeof tool.metadata?.exitCode === "number" ? tool.metadata.exitCode : undefined;
+    const outputLines = typeof tool.metadata?.outputLines === "number" ? tool.metadata.outputLines : undefined;
+    const statusLabel = taskId
+        ? [taskId, elapsed ? `in ${elapsed}` : undefined, exitCode !== undefined ? `exit ${exitCode}` : undefined,
+            outputLines !== undefined ? `${outputLines} line${outputLines === 1 ? "" : "s"}` : undefined]
+            .filter(Boolean)
+            .join(" · ")
+        : undefined;
+    return {
+        kind: "execute",
+        title,
+        raw: [tool],
+        command: normalizeCommand(rawCommand),
+        description,
+        commandLines: commandLinesOf(rawCommand),
+        items: [],
+        previewLines: shown,
+        errorLines: [],
+        omitted,
+        pending,
+        hasError,
+        errorCount,
+        startedAt,
+        statusLabel,
+    };
+}
+function formatElapsedDuration(startedAt, endedAt) {
+    if (startedAt === undefined)
+        return undefined;
+    const seconds = Math.max(0, Math.round((endedAt - startedAt) / 1000));
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    return `${minutes}m${String(seconds % 60).padStart(2, "0")}s`;
+}
+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" ? 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 errorCount = subagents.filter(isFailedSubagent).length + (tool.isError ? 1 : 0);
+    const statusLabel = subagents.length > 0
+        && subagents.every((subagent) => subagent.status === "completed" || subagent.status === "closed")
+        ? "completed"
+        : undefined;
+    const launchLabel = tool.name === "run_workflow"
+        ? String(tool.args.title ?? tool.args.description ?? "").trim()
+        : subagents[0]?.nickname || subagents[0]?.agentName || String(tool.args.description ?? "").trim();
+    return {
+        kind: "subagent",
+        title: classifier.title,
+        description: launchLabel || undefined,
+        raw: [tool],
+        count: subagents.length || 1,
+        noun: plural(subagents.length || 1, "agent", "agents"),
+        items: [],
+        // The full roster and live activity belong to Tasks Pane. Keeping member
+        // rows here creates two competing sources of truth and makes every
+        // wait/list call visually replay the launch.
+        previewLines: [],
+        errorLines: [],
+        omitted: 0,
+        pending: pending || subagents.some((subagent) => ["queued", "running"].includes(subagent.status ?? "running")),
+        hasError: !!tool.isError || errorCount > 0,
+        errorCount,
+        startedAt,
+        statusLabel,
+    };
+}
+function buildOtherGroup(classifier, raw, options, pending, startedAt, hasError, errorCount) {
+    const tool = raw[0];
+    const header = toolHeader(tool, options.homeDir);
+    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,
+        count: header ? undefined : raw.length,
+        noun: header ? 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 isFailedSubagent(subagent) {
+    return subagent.status === "failed" || subagent.status === "blocked" || subagent.status === "cancelled";
+}
+function isToolPending(tool) {
+    if (tool.status) {
+        return tool.status === "queued" || tool.status === "pending" || tool.status === "running";
+    }
+    return tool.result === undefined;
+}
+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;
+}
+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, " ");
+}
+// 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 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/model/trace-interaction.d.ts

@@ -0,0 +1,63 @@
+import type { TraceGroup } from "./trace-groups.js";
+export type TraceRowTarget = {
+    kind: "group";
+    key: string;
+    groupKey: string;
+    foldable: boolean;
+    action?: TraceAction;
+} | {
+    kind: "item";
+    key: string;
+    groupKey: string;
+    toolId: string;
+    foldable: boolean;
+    action?: TraceAction;
+} | {
+    kind: "image";
+    key: string;
+    groupKey: string;
+    imageLabel: string;
+    foldable: false;
+    action: TraceAction;
+};
+export type TraceAction = {
+    kind: "open-subagent";
+    subAgentId: string;
+} | {
+    kind: "open-task";
+    taskId: string;
+} | {
+    kind: "open-image";
+    messageKey: string;
+    imageLabel: string;
+};
+/**
+ * UI-only fold/selection state. Tool lifecycle data remains immutable in the
+ * controller; live and settled renderers share this object so committing a
+ * turn cannot reset an expanded tool entry.
+ */
+export declare class TraceInteractionState {
+    private revision;
+    private selectedKey?;
+    private selectedGroupKey?;
+    private hoveredGroupKey?;
+    private readonly expandedGroups;
+    private readonly expandedItems;
+    groupKey(group: TraceGroup): string;
+    itemKey(group: TraceGroup, toolId: string): string;
+    isSelected(key: string): boolean;
+    isGroupSelected(groupKey: string): boolean;
+    isGroupHovered(groupKey: string): boolean;
+    isGroupExpanded(groupKey: string): boolean;
+    isItemExpanded(itemKey: string): boolean;
+    /**
+     * Monotonic render revision for transcript projection caches. The tool
+     * lifecycle remains immutable in the controller; only these UI affordances
+     * can change the settled projection without replacing the transcript array.
+     */
+    getRevision(): number;
+    activate(target: TraceRowTarget, clickCount: 1 | 2): TraceAction | undefined;
+    hover(target: TraceRowTarget | undefined): boolean;
+    clearHover(): boolean;
+    private toggle;
+}