@bubblebrain-ai/bubble 0.0.24 → 0.0.26

package/dist/tui-opentui/theme.js

@@ -1,157 +0,0 @@
-/**
- * Theme for the OpenTUI TUI, structured after opencode's grayscale + semantic
- * accent model. Bubble keeps the quiet terminal surface, blue focus color, and
- * warm command accent instead of turning light mode into a plain gray port.
- *
- * The exported `Theme` shape preserves the keys consumed by the rest of the
- * TUI so no caller needs to change.
- */
-import { createContext, useContext } from "react";
-/**
- * 12-step grayscale + lavender accent.
- *
- *  step1  #0a0a0a  root bg
- *  step2  #141414  panel bg (dialogs, chips)
- *  step3  #1c1820  element bg (input fill, slightly purple-tinged)
- *  step4  #232028  surface  (current input bg base)
- *  step5  #2a2630  raised panel
- *  step6  #3a3242  borderSubtle
- *  step7  #4a4254  border
- *  step8  #5e5570  borderActive
- *  step9  #bd91db  accent / primary       ← brand
- *  step10 #d4afe8  accent hover / soft
- *  step11 #808080  text muted
- *  step12 #eeeeee  text
- */
-export const darkTheme = {
-    user: "#8E3A52", // user messages render in accent — opencode pattern
-    agent: "#EEEEEE", // assistant messages render in full white
-    error: "#E06C75",
-    warning: "#F5A742",
-    success: "#7FD88F",
-    accent: "#8E3A52",
-    border: "#4A3A40",
-    borderActive: "#8E3A52",
-    inputBorder: "#8E3A52", // heavy left rail color
-    inputBorderDisabled: "#3A2A2F",
-    inputBg: "#1A1014", // surface — slightly raised from root
-    inputBgDisabled: "#141414",
-    inputText: "#EEEEEE",
-    inputPlaceholder: "#808080",
-    muted: "#808080",
-    dim: "#606070",
-    thinking: "#6B2A3E",
-    thinkingDim: "#808080",
-    toolName: "#808080", // tool header lines are dim (opencode pattern)
-    toolResult: "#EEEEEE",
-    toolError: "#E06C75",
-    toolPending: "#F5A742",
-    code: "#7FD88F",
-    traceAction: "#8E3A52",
-    traceCount: "#808080",
-    traceDetail: "#606070",
-    traceCommand: "#56B6C2",
-    tracePending: "#F5A742",
-    userMessageBorder: "transparent", // unused under opencode style
-    userMessageBg: "transparent",
-    userMessageText: "#8E3A52", // user message body color
-    userRail: "#8E3A52",
-    diffAdd: "#20303B",
-    diffRemove: "#37222C",
-    diffAddFg: "#4FD6BE",
-    diffRemoveFg: "#C53B53",
-    toolFile: "#7FD88F",
-    toolShell: "#F5A742",
-    toolSearch: "#56B6C2",
-    toolThink: "#6B2A3E",
-    toolNet: "#5C9CF5",
-    toolEdit: "#8E3A52",
-    brand: "#8E3A52",
-    brandSoft: "#B85574",
-    brandDeep: "#6B2A3E",
-    background: "#0A0A0A",
-    backgroundPanel: "#141414",
-    backgroundElement: "#1A1014",
-    text: "#EEEEEE",
-    textMuted: "#808080",
-    textDim: "#606070",
-    surface: "#1A1014",
-    shade: "#141414",
-};
-export const lightTheme = {
-    user: "#356FD2",
-    agent: "#171717",
-    error: "#B62633",
-    warning: "#8B4A00",
-    success: "#2F7D4A",
-    accent: "#8B4A00",
-    border: "#B9BDB8",
-    borderActive: "#356FD2",
-    inputBorder: "#356FD2",
-    inputBorderDisabled: "#D7DAD4",
-    inputBg: "#F1F3F0",
-    inputBgDisabled: "#E6E8E3",
-    inputText: "#171717",
-    inputPlaceholder: "#6F7377",
-    muted: "#6F7377",
-    dim: "#8B9094",
-    thinking: "#5F666D",
-    thinkingDim: "#8B9094",
-    toolName: "#495057",
-    toolResult: "#171717",
-    toolError: "#B62633",
-    toolPending: "#8B4A00",
-    code: "#2F7D4A",
-    traceAction: "#8B4A00",
-    traceCount: "#6F7377",
-    traceDetail: "#8B9094",
-    traceCommand: "#257E8A",
-    tracePending: "#8B4A00",
-    userMessageBorder: "transparent",
-    userMessageBg: "transparent",
-    userMessageText: "#234B93",
-    userRail: "#356FD2",
-    diffAdd: "#D7E8D8",
-    diffRemove: "#F7DADC",
-    diffAddFg: "#173D2D",
-    diffRemoveFg: "#5D1922",
-    toolFile: "#2F7D4A",
-    toolShell: "#257E8A",
-    toolSearch: "#356FD2",
-    toolThink: "#5F666D",
-    toolNet: "#356FD2",
-    toolEdit: "#8B4A00",
-    brand: "#8B4A00",
-    brandSoft: "#B86B15",
-    brandDeep: "#5A2F00",
-    background: "#FCFCFA",
-    backgroundPanel: "#F6F6F3",
-    backgroundElement: "#ECEDEA",
-    text: "#171717",
-    textMuted: "#6F7377",
-    textDim: "#8B9094",
-    surface: "#F1F3F0",
-    shade: "#E6E8E3",
-};
-const ThemeContext = createContext(darkTheme);
-export const ThemeProvider = ThemeContext.Provider;
-export function useTheme() {
-    return useContext(ThemeContext);
-}
-export function paletteFor(mode, overrides) {
-    const base = mode === "light" ? lightTheme : darkTheme;
-    if (!overrides)
-        return base;
-    const filtered = {};
-    for (const [key, value] of Object.entries(overrides)) {
-        if (typeof value === "string" && key in base) {
-            filtered[key] = value;
-        }
-    }
-    return { ...base, ...filtered };
-}
-/** opencode style: tool category is encoded by header text, not color. Keep
- * a single accent for tool names so users get visual consistency. */
-export function toolAccent(theme, _toolName) {
-    return theme.text;
-}

package/dist/tui-opentui/todos.d.ts

@@ -1,9 +0,0 @@
-/** @jsxImportSource @opentui/react */
-import React from "react";
-import type { Todo } from "../types.js";
-interface TodosPanelProps {
-    todos: Todo[];
-    terminalColumns: number;
-}
-export declare function TodosPanel({ todos, terminalColumns }: TodosPanelProps): React.ReactNode;
-export {};

package/dist/tui-opentui/todos.js

@@ -1,45 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "@opentui/react/jsx-runtime";
-import { useTheme } from "./theme.js";
-const MAX_ROWS = 8;
-export function TodosPanel({ todos, terminalColumns }) {
-    const theme = useTheme();
-    if (todos.length === 0) {
-        return null;
-    }
-    const rows = selectVisibleRows(todos);
-    const hiddenCount = todos.length - rows.length;
-    const contentWidth = Math.max(20, terminalColumns - 4);
-    return (_jsxs("box", { style: { flexDirection: "column", marginBottom: 1 }, children: [_jsx("text", { fg: theme.accent, attributes: 1, children: "\u25CF Todos" }), rows.map((todo, index) => (_jsx(TodoRow, { todo: todo, maxWidth: contentWidth }, index))), hiddenCount > 0 && (_jsxs("text", { fg: theme.muted, children: ["... ", hiddenCount, " more item", hiddenCount === 1 ? "" : "s", " hidden"] }))] }));
-}
-function selectVisibleRows(todos) {
-    if (todos.length <= MAX_ROWS) {
-        return todos;
-    }
-    // Prefer to show: all in_progress, the last N completed just before current, and upcoming pending.
-    const inProgressIdx = todos.findIndex((t) => t.status === "in_progress");
-    const anchor = inProgressIdx >= 0 ? inProgressIdx : todos.findIndex((t) => t.status === "pending");
-    const pivot = anchor >= 0 ? anchor : 0;
-    const half = Math.floor(MAX_ROWS / 2);
-    let start = Math.max(0, pivot - half);
-    let end = Math.min(todos.length, start + MAX_ROWS);
-    if (end - start < MAX_ROWS) {
-        start = Math.max(0, end - MAX_ROWS);
-    }
-    return todos.slice(start, end);
-}
-function TodoRow({ todo, maxWidth }) {
-    const theme = useTheme();
-    const { glyph, color, label } = statusStyle(todo, theme);
-    const text = label || todo.content;
-    const trimmed = text.length > maxWidth - 4 ? text.slice(0, maxWidth - 5) + "…" : text;
-    return (_jsx("box", { style: { height: 1 }, children: _jsxs("text", { fg: color, children: [glyph, " ", trimmed] }) }));
-}
-function statusStyle(todo, theme) {
-    if (todo.status === "completed") {
-        return { glyph: "✔", color: theme.dim, dim: true, label: todo.content };
-    }
-    if (todo.status === "in_progress") {
-        return { glyph: "▶", color: theme.accent, dim: false, label: todo.activeForm || todo.content };
-    }
-    return { glyph: "○", color: theme.muted, dim: false, label: todo.content };
-}

package/dist/tui-opentui/trace-groups.d.ts

@@ -1,27 +0,0 @@
-import type { DisplayToolCall } from "./display-history.js";
-export type TraceGroupKind = "list" | "read" | "search" | "execute" | "edit" | "write" | "subagent" | "other";
-export interface TraceGroup {
-    kind: TraceGroupKind;
-    title: string;
-    raw: DisplayToolCall[];
-    count?: number;
-    noun?: string;
-    command?: string;
-    items: string[];
-    previewLines: string[];
-    errorLines: string[];
-    omitted: number;
-    pending: boolean;
-    hasError: boolean;
-    errorCount: number;
-    startedAt?: number;
-}
-export interface TraceGroupOptions {
-    maxItems?: number;
-    maxPreviewLines?: number;
-    homeDir?: string;
-}
-export declare function buildTraceGroups(toolCalls: DisplayToolCall[], options?: TraceGroupOptions): TraceGroup[];
-export declare function formatTracePath(value: unknown, homeDir?: string): string;
-export declare function formatElapsed(startedAt: number | undefined, now?: number): string | null;
-export declare function traceGroupLabel(group: TraceGroup): string;

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

@@ -1,455 +0,0 @@
-import os from "node:os";
-import { getEditDiffDetails } from "./edit-diff.js";
-import { formatSubagentRoute } from "../agent/subagent-route-format.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.command)
-        return `${group.title} ${group.command}`;
-    if (group.count !== undefined && group.noun)
-        return `${group.title} ${group.count} ${group.noun}`;
-    return group.title;
-}
-function classifyTool(toolCall) {
-    if (toolCall.metadata?.kind === "subagent") {
-        return { kind: "subagent", title: "Subagents", bucketKey: `subagent:${toolCall.id}`, groupable: false };
-    }
-    switch (toolCall.name) {
-        case "glob": {
-            const pattern = String(toolCall.args.pattern ?? "");
-            const title = isDirectoryLikeGlob(pattern) ? "List Directory" : "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 ? 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 (metadataPaths.length > 0 || typeof tool.metadata?.matches === "number") {
-        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 !/^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 ?? "", 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 pattern = String(tool.args.pattern ?? tool.args.query ?? "").trim();
-        const scope = String(tool.args.path ?? tool.args.glob ?? tool.args.include ?? "").trim();
-        const patternText = pattern ? `"${pattern}"` : "(pattern)";
-        return scope ? `${patternText} in ${formatTracePath(scope, options.homeDir)}` : patternText;
-    });
-    const { shown, omitted } = take(items, options.maxItems);
-    const count = raw.length;
-    return {
-        kind: "search",
-        title: classifier.title,
-        raw,
-        count,
-        noun: plural(count, "search", "searches"),
-        items: shown,
-        previewLines: [],
-        errorLines: collectErrorLines(raw, options),
-        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);
-    return {
-        kind: "execute",
-        title: classifier.title,
-        raw: [tool],
-        command: normalizeCommand(tool.args.command ?? tool.args.cmd ?? commandFromRawArguments(tool.rawArguments)),
-        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 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 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 isDirectoryLikeGlob(pattern) {
-    const normalized = pattern.trim();
-    return normalized === "" || normalized === "*" || normalized === "**" || normalized === "**/*";
-}
-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, " ");
-}
-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(" ")})` : "";
-}