@bubblebrain-ai/bubble 0.0.8 → 0.0.10

package/dist/tui-ink/todos.js

@@ -1,8 +1,9 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
-import { theme } from "./theme.js";
+import { useTheme } from "./theme.js";
 const MAX_ROWS = 8;
 export function TodosPanel({ todos, terminalColumns }) {
+    const theme = useTheme();
     if (todos.length === 0) {
         return null;
     }
@@ -28,12 +29,13 @@ function selectVisibleRows(todos) {
     return todos.slice(start, end);
 }
 function TodoRow({ todo, maxWidth }) {
-    const { glyph, color, dim, label } = statusStyle(todo);
+    const theme = useTheme();
+    const { glyph, color, dim, label } = statusStyle(todo, theme);
     const text = label || todo.content;
     const trimmed = text.length > maxWidth - 4 ? text.slice(0, maxWidth - 5) + "…" : text;
     return (_jsx(Box, { height: 1, children: _jsxs(Text, { color: color, dimColor: dim, children: [glyph, " ", trimmed] }) }));
 }
-function statusStyle(todo) {
+function statusStyle(todo, theme) {
     if (todo.status === "completed") {
         return { glyph: "✔", color: theme.muted, dim: true, label: todo.content };
     }

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

@@ -1,5 +1,5 @@
 import type { DisplayToolCall } from "./display-history.js";
-export type TraceGroupKind = "list" | "read" | "search" | "execute" | "edit" | "write" | "other";
+export type TraceGroupKind = "list" | "read" | "search" | "execute" | "edit" | "write" | "subagent" | "other";
 export interface TraceGroup {
     kind: TraceGroupKind;
     title: string;
@@ -9,9 +9,11 @@ export interface TraceGroup {
     command?: string;
     items: string[];
     previewLines: string[];
+    errorLines: string[];
     omitted: number;
     pending: boolean;
     hasError: boolean;
+    errorCount: number;
     startedAt?: number;
 }
 export interface TraceGroupOptions {

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

@@ -1,5 +1,6 @@
 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 = {}) {
@@ -71,6 +72,9 @@ export function traceGroupLabel(group) {
     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 ?? "");
@@ -109,23 +113,26 @@ function buildTraceGroup(classifier, raw, options) {
         .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);
+            return buildListGroup(classifier, raw, options, pending, startedAt, hasError, errorCount);
         case "read":
-            return buildPathGroup(classifier, raw, options, pending, startedAt, hasError, "files");
+            return buildPathGroup(classifier, raw, options, pending, startedAt, hasError, errorCount, "files");
         case "search":
-            return buildSearchGroup(classifier, raw, options, pending, startedAt, hasError);
+            return buildSearchGroup(classifier, raw, options, pending, startedAt, hasError, errorCount);
         case "execute":
-            return buildExecuteGroup(classifier, raw[0], options, pending, startedAt, hasError);
+            return buildExecuteGroup(classifier, raw[0], options, pending, startedAt, hasError, errorCount);
         case "edit":
         case "write":
-            return buildMutationGroup(classifier, raw, options, pending, startedAt, hasError);
+            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);
+            return buildOtherGroup(classifier, raw, options, pending, startedAt, hasError, errorCount);
     }
 }
-function buildListGroup(classifier, raw, options, pending, startedAt, hasError) {
+function buildListGroup(classifier, raw, options, pending, startedAt, hasError, errorCount) {
     const resultItems = raw.flatMap((tool) => resultLines(tool.result).map((line) => formatTracePath(line, options.homeDir)));
     const fallbackItems = raw
         .map((tool) => String(tool.args.pattern ?? tool.args.path ?? "").trim())
@@ -143,16 +150,18 @@ function buildListGroup(classifier, raw, options, pending, startedAt, hasError)
         noun,
         items: shown,
         previewLines: [],
+        errorLines: collectErrorLines(raw, options),
         omitted,
         pending,
         hasError,
+        errorCount,
         startedAt,
     };
 }
-function buildPathGroup(classifier, raw, options, pending, startedAt, hasError, nounBase) {
-    const items = raw
+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);
+        .filter(Boolean));
     const { shown, omitted } = take(items, options.maxItems);
     const count = items.length || raw.length;
     return {
@@ -163,13 +172,15 @@ function buildPathGroup(classifier, raw, options, pending, startedAt, hasError,
         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) {
+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();
@@ -186,13 +197,15 @@ function buildSearchGroup(classifier, raw, options, pending, startedAt, hasError
         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) {
+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 {
@@ -202,13 +215,15 @@ function buildExecuteGroup(classifier, tool, options, pending, startedAt, hasErr
         command: normalizeCommand(tool.args.command ?? ""),
         items: [],
         previewLines: shown,
+        errorLines: [],
         omitted,
         pending,
         hasError,
+        errorCount,
         startedAt,
     };
 }
-function buildMutationGroup(classifier, raw, options, pending, startedAt, hasError) {
+function buildMutationGroup(classifier, raw, options, pending, startedAt, hasError, errorCount) {
     const items = raw
         .map((tool) => {
         const path = formatTracePath(tool.args.path ?? "", options.homeDir);
@@ -233,13 +248,38 @@ function buildMutationGroup(classifier, raw, options, pending, startedAt, hasErr
         noun: plural(count, "file", "files"),
         items: shown,
         previewLines: errorPreview,
+        errorLines: [],
         omitted,
         pending,
         hasError,
+        errorCount,
         startedAt,
     };
 }
-function buildOtherGroup(classifier, raw, options, pending, startedAt, hasError) {
+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));
@@ -252,12 +292,36 @@ function buildOtherGroup(classifier, raw, options, pending, startedAt, hasError)
         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;
 }
@@ -278,6 +342,21 @@ 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;
 }

package/dist/tui-ink/welcome.js

@@ -2,7 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import React from "react";
 import { Box, Text } from "ink";
 import { createRequire } from "node:module";
-import { theme } from "./theme.js";
+import { useTheme } from "./theme.js";
 const require = createRequire(import.meta.url);
 const PACKAGE_VERSION = readPackageVersion();
 const BUBBLE_LOGO_LETTERS = [
@@ -61,7 +61,20 @@ const BUBBLE_LOGO_LETTERS = [
         "███████",
     ],
 ];
-const LOGO_COLORS = ["#f3f3f7", "#f3f3f7", "#d8c7ff", "#d8c7ff", "#a9c7ff", "#a9c7ff"];
+/**
+ * Derive a 6-step logo gradient from the active theme tokens so the banner
+ * stays readable on both dark and light backgrounds.
+ */
+function logoColors(theme) {
+    return [
+        theme.userMessageText,
+        theme.userMessageText,
+        theme.inputBorder,
+        theme.inputBorder,
+        theme.traceCommand,
+        theme.traceCommand,
+    ];
+}
 const COMPACT_LOGO = ["B", "U", "B", "B", "L", "E"];
 const WIDE_LOGO_MIN_WIDTH = 52;
 export function shouldShowWelcomeBanner({ startedWithVisibleHistory, }) {
@@ -74,6 +87,7 @@ export function shouldShowWelcomeBanner({ startedWithVisibleHistory, }) {
     return true;
 }
 export function WelcomeBanner({ terminalColumns, modelLabel, cwd, tips, skillsCount = 0, mcpConnectedCount = 0, mcpTotalCount = 0, hasAgentsFile = false, }) {
+    const theme = useTheme();
     const effectiveWidth = Math.max(20, Math.min(terminalColumns - 2, 118));
     const useWideLogo = effectiveWidth >= WIDE_LOGO_MIN_WIDTH;
     const actionableTips = tips
@@ -88,12 +102,17 @@ export function WelcomeBanner({ terminalColumns, modelLabel, cwd, tips, skillsCo
                     : _jsx(CompactLogo, {}) }), _jsx(Box, { marginTop: 2, children: _jsx(Text, { bold: true, color: theme.muted, children: PACKAGE_VERSION }) }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { bold: true, color: theme.userMessageText, children: "TIP: " }), _jsx(Text, { bold: true, color: theme.userMessageText, children: tip })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.muted, children: "shift+tab to cycle modes \u00B7 ctrl+r for reasoning \u00B7 ctrl+o for trace" }) }), modelLine && (_jsx(Box, { children: _jsx(Text, { color: theme.muted, children: truncateToWidth(modelLine, effectiveWidth - 4) }) })), _jsxs(Box, { marginTop: 1, children: [_jsx(StatusItem, { label: "Skills", count: skillsCount, ok: skillsCount > 0 }), _jsx(Text, { color: theme.muted, children: "  " }), _jsx(StatusItem, { label: "MCPs", count: mcpConnectedCount, total: mcpTotalCount, ok: mcpTotalCount === 0 || mcpConnectedCount === mcpTotalCount }), _jsx(Text, { color: theme.muted, children: "  " }), _jsx(StatusItem, { label: "AGENTS.md", ok: hasAgentsFile })] })] }));
 }
 function LogoRow({ rowIndex }) {
-    return (_jsx(Box, { children: BUBBLE_LOGO_LETTERS.map((letter, index) => (_jsxs(React.Fragment, { children: [_jsx(Text, { bold: true, color: LOGO_COLORS[index], children: letter[rowIndex] }), index < BUBBLE_LOGO_LETTERS.length - 1 && _jsx(Text, { children: " " })] }, `${index}-${rowIndex}`))) }));
+    const theme = useTheme();
+    const colors = logoColors(theme);
+    return (_jsx(Box, { children: BUBBLE_LOGO_LETTERS.map((letter, index) => (_jsxs(React.Fragment, { children: [_jsx(Text, { bold: true, color: colors[index], children: letter[rowIndex] }), index < BUBBLE_LOGO_LETTERS.length - 1 && _jsx(Text, { children: " " })] }, `${index}-${rowIndex}`))) }));
 }
 function CompactLogo() {
-    return (_jsx(Box, { children: COMPACT_LOGO.map((letter, index) => (_jsx(Text, { bold: true, color: LOGO_COLORS[index], children: letter }, `${letter}-${index}`))) }));
+    const theme = useTheme();
+    const colors = logoColors(theme);
+    return (_jsx(Box, { children: COMPACT_LOGO.map((letter, index) => (_jsx(Text, { bold: true, color: colors[index], children: letter }, `${letter}-${index}`))) }));
 }
 function StatusItem({ label, count, total, ok, }) {
+    const theme = useTheme();
     const countText = count === undefined
         ? ""
         : total !== undefined && total > count

package/dist/types.d.ts

@@ -120,6 +120,8 @@ export interface ToolUpdate {
     subAgentId: string;
     agentName: string;
     nickname?: string;
+    category?: string;
+    route?: import("./agent/categories.js").ResolvedSubagentRoute;
     status: "queued" | "running" | "completed" | "failed" | "blocked" | "cancelled";
     childEvent?: AgentEvent;
     summaryDelta?: string;
@@ -147,6 +149,8 @@ export interface ToolContext {
             runId: string;
             subAgentId: string;
             parentToolCallId: string;
+            category?: string;
+            route?: import("./agent/categories.js").ResolvedSubagentRoute;
             approval?: "fail" | "disabled";
             emitUpdate?: (update: ToolUpdate) => void;
             description?: string;
@@ -157,6 +161,8 @@ export interface ToolContext {
         spawnSubAgent?: (input: string | ContentPart[], cwd: string, options: {
             profile: import("./agent/profiles.js").AgentProfile;
             parentToolCallId: string;
+            category?: string;
+            route?: import("./agent/categories.js").ResolvedSubagentRoute;
             approval?: "fail" | "disabled";
             description?: string;
             abortSignal?: AbortSignal;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bubblebrain-ai/bubble",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "description": "A terminal coding agent",
   "type": "module",
   "engines": {
@@ -33,6 +33,7 @@
     "chalk": "^5.3.0",
     "diff": "^7.0.0",
     "ink": "^7.0.3",
+    "js-tiktoken": "^1.0.21",
     "openai": "^4.77.0",
     "opentui-spinner": "^0.0.6",
     "picomatch": "^4.0.4",