@bubblebrain-ai/bubble 0.0.11 → 0.0.13

package/dist/tools/skill-search.js

@@ -0,0 +1,134 @@
+const DEFAULT_MAX_RESULTS = 8;
+const MAX_RESULTS = 25;
+const SOURCE_PRIORITY = {
+    project: 0,
+    configured: 1,
+    user: 2,
+};
+export function createSkillSearchTool(registry) {
+    return {
+        name: "skill_search",
+        readOnly: true,
+        effect: "read",
+        description: "Search available skills by name, description, tags, and source. Use this before loading a skill when a task may match a specialized workflow.",
+        parameters: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Search terms describing the desired skill or workflow.",
+                },
+                max_results: {
+                    type: "number",
+                    description: `Maximum number of matches to return (default ${DEFAULT_MAX_RESULTS}, max ${MAX_RESULTS}).`,
+                },
+            },
+            required: ["query"],
+            additionalProperties: false,
+        },
+        async execute(args) {
+            const query = typeof args.query === "string" ? args.query.trim() : "";
+            const maxResults = typeof args.max_results === "number" && args.max_results > 0
+                ? Math.min(Math.floor(args.max_results), MAX_RESULTS)
+                : DEFAULT_MAX_RESULTS;
+            const skills = registry.summaries();
+            if (skills.length === 0) {
+                return { content: "No skills are currently available." };
+            }
+            const matches = searchSkillSummaries(skills, query).slice(0, maxResults);
+            if (matches.length === 0) {
+                return {
+                    content: `No skills matched "${query}". Try broader terms or use /skills to browse all skills manually.`,
+                };
+            }
+            return {
+                content: formatSkillSearchResults(matches, skills.length, query),
+            };
+        },
+    };
+}
+export function searchSkillSummaries(skills, query) {
+    const terms = normalizeTerms(query);
+    const scored = [];
+    for (const skill of skills) {
+        const score = scoreSkill(skill, terms, query);
+        if (score > 0 || terms.length === 0) {
+            scored.push({ skill, score });
+        }
+    }
+    scored.sort((a, b) => {
+        if (b.score !== a.score)
+            return b.score - a.score;
+        const ap = SOURCE_PRIORITY[a.skill.source ?? "user"] ?? 3;
+        const bp = SOURCE_PRIORITY[b.skill.source ?? "user"] ?? 3;
+        if (ap !== bp)
+            return ap - bp;
+        return a.skill.name.localeCompare(b.skill.name);
+    });
+    return scored;
+}
+function scoreSkill(skill, terms, rawQuery) {
+    const name = skill.name.toLowerCase();
+    const desc = (skill.description ?? "").toLowerCase();
+    const tags = (skill.tags ?? []).map((tag) => tag.toLowerCase());
+    const source = skill.source ?? "user";
+    const sourceBonus = source === "project" ? 4 : source === "configured" ? 2 : 0;
+    const query = rawQuery.trim().toLowerCase();
+    if (terms.length === 0)
+        return 1 + sourceBonus;
+    let score = 0;
+    if (name === query)
+        score += 80;
+    if (name.includes(query) && query.length > 0)
+        score += 30;
+    for (const term of terms) {
+        if (name === term)
+            score += 30;
+        else if (name.includes(term))
+            score += 12;
+        if (tags.some((tag) => tag === term))
+            score += 10;
+        else if (tags.some((tag) => tag.includes(term)))
+            score += 6;
+        if (desc.includes(term))
+            score += 3;
+        if (source.includes(term))
+            score += 2;
+    }
+    return score > 0 ? score + sourceBonus : 0;
+}
+function normalizeTerms(query) {
+    const rawTerms = query
+        .toLowerCase()
+        .split(/[^a-z0-9_\-\u3000-\u9fff]+/i)
+        .map((term) => term.trim())
+        .filter(Boolean);
+    const terms = new Set();
+    for (const term of rawTerms) {
+        terms.add(term);
+        const chars = Array.from(term);
+        if (chars.some(isCjkChar) && chars.length > 2) {
+            for (let i = 0; i < chars.length - 1; i++) {
+                terms.add(`${chars[i]}${chars[i + 1]}`);
+            }
+        }
+    }
+    return [...terms];
+}
+function isCjkChar(ch) {
+    const code = ch.codePointAt(0) ?? 0;
+    return code >= 0x3000 && code <= 0x9fff;
+}
+function formatSkillSearchResults(matches, total, query) {
+    const lines = [
+        query ? `Skill search results for "${query}" (${matches.length} of ${total}):` : `Available skills (${matches.length} of ${total}):`,
+    ];
+    for (const { skill } of matches) {
+        const tags = skill.tags && skill.tags.length > 0 ? ` [tags: ${skill.tags.join(", ")}]` : "";
+        const source = skill.source ? ` (${skill.source})` : "";
+        lines.push(`- ${skill.name}${source}: ${skill.description}${tags}`);
+    }
+    lines.push("");
+    lines.push("Call skill with the exact name to load a selected skill.");
+    return lines.join("\n");
+}

package/dist/tools/skill.js

@@ -38,11 +38,8 @@ export function createSkillTool(registry) {
             }
             const skill = registry.get(name);
             if (!skill) {
-                const available = registry.summaries().map((item) => item.name).join(", ");
                 return {
-                    content: available
-                        ? `Error: Unknown skill "${name}". Available skills: ${available}`
-                        : `Error: Unknown skill "${name}". No skills are currently available.`,
+                    content: `Error: Unknown skill "${name}". Use skill_search to find available skills, then retry with the exact skill name.`,
                     isError: true,
                 };
             }

package/dist/tui/clipboard.d.ts

@@ -0,0 +1 @@
+export declare function copyTextToClipboard(text: string): Promise<void>;

package/dist/tui/clipboard.js

@@ -0,0 +1,53 @@
+import { spawn } from "node:child_process";
+export async function copyTextToClipboard(text) {
+    if (process.platform === "darwin") {
+        await writeToProcess("pbcopy", [], text);
+        return;
+    }
+    if (process.platform === "win32") {
+        await writeToProcess("powershell", [
+            "-NoProfile",
+            "-Command",
+            "Set-Clipboard -Value ([Console]::In.ReadToEnd())",
+        ], text);
+        return;
+    }
+    const candidates = [
+        ["wl-copy", []],
+        ["xclip", ["-selection", "clipboard"]],
+        ["xsel", ["--clipboard", "--input"]],
+    ];
+    let lastError;
+    for (const [command, args] of candidates) {
+        try {
+            await writeToProcess(command, args, text);
+            return;
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error("No clipboard command available");
+}
+function writeToProcess(command, args, input) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            stdio: ["pipe", "ignore", "pipe"],
+            windowsHide: true,
+        });
+        let stderr = "";
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(stderr.trim() || `${command} exited with code ${code}`));
+        });
+        child.stdin.end(input);
+    });
+}

package/dist/tui/detect-theme.d.ts

@@ -0,0 +1,2 @@
+export type ResolvedTheme = "light" | "dark";
+export declare function detectTerminalTheme(timeoutMs?: number): Promise<ResolvedTheme>;

package/dist/tui/detect-theme.js

@@ -0,0 +1,87 @@
+export async function detectTerminalTheme(timeoutMs = 150) {
+    const fromEnv = parseColorFgBg(process.env.COLORFGBG);
+    if (fromEnv)
+        return fromEnv;
+    if (process.stdout.isTTY && process.stdin.isTTY) {
+        const fromOsc = await queryOsc11(timeoutMs);
+        if (fromOsc)
+            return fromOsc;
+    }
+    return "dark";
+}
+function parseColorFgBg(value) {
+    if (!value)
+        return null;
+    const parts = value.split(";");
+    const last = parts[parts.length - 1];
+    if (!last)
+        return null;
+    const bg = parseInt(last, 10);
+    if (Number.isNaN(bg))
+        return null;
+    if (bg >= 0 && bg <= 6)
+        return "dark";
+    if (bg >= 7 && bg <= 15)
+        return "light";
+    return null;
+}
+function queryOsc11(timeoutMs) {
+    return new Promise((resolve) => {
+        const stdin = process.stdin;
+        const stdout = process.stdout;
+        let settled = false;
+        const originalRaw = stdin.isRaw;
+        let buffer = "";
+        const cleanup = () => {
+            stdin.removeListener("data", onData);
+            try {
+                stdin.setRawMode(originalRaw);
+            }
+            catch {
+                // ignore - terminal may have already restored
+            }
+            stdin.pause();
+        };
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            cleanup();
+            resolve(result);
+        };
+        const onData = (chunk) => {
+            buffer += chunk.toString("utf8");
+            const match = buffer.match(/\x1b\]11;rgb:([0-9a-fA-F]+)\/([0-9a-fA-F]+)\/([0-9a-fA-F]+)(?:\x07|\x1b\\)/);
+            if (!match)
+                return;
+            const [, r, g, b] = match;
+            const lum = relativeLuminance(parseHexChannel(r), parseHexChannel(g), parseHexChannel(b));
+            finish(lum > 0.5 ? "light" : "dark");
+        };
+        try {
+            stdin.setRawMode(true);
+        }
+        catch {
+            resolve(null);
+            return;
+        }
+        stdin.resume();
+        stdin.on("data", onData);
+        const timer = setTimeout(() => finish(null), timeoutMs);
+        try {
+            stdout.write("\x1b]11;?\x07");
+        }
+        catch {
+            finish(null);
+        }
+    });
+}
+function parseHexChannel(hex) {
+    const max = (1 << (hex.length * 4)) - 1;
+    return parseInt(hex, 16) / max;
+}
+function relativeLuminance(r, g, b) {
+    const channel = (c) => c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+    return 0.2126 * channel(r) + 0.7152 * channel(g) + 0.0722 * channel(b);
+}

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

@@ -0,0 +1,62 @@
+import type { ToolResultMetadata, TokenUsage } from "../types.js";
+export interface CompactionMeta {
+    turns: number;
+    messages: number;
+    tokensSaved: number;
+    summarySections: Array<{
+        label: string;
+        content: string;
+    }>;
+    contextWindow?: number;
+    compactedAt: number;
+}
+export interface DisplayMessage {
+    role: "user" | "assistant" | "error";
+    content: string;
+    clientId?: string;
+    queued?: boolean;
+    reasoning?: string;
+    toolCalls?: DisplayToolCall[];
+    parts?: DisplayMessagePart[];
+    status?: "thinking" | "responding";
+    streaming?: boolean;
+    syntheticKind?: "ui_compact_card";
+    hiddenCount?: number;
+    compactionMeta?: CompactionMeta;
+    turnStartedAt?: number;
+    turnCompletedAt?: number;
+    turnUsage?: TokenUsage;
+    taskElapsedMs?: number;
+}
+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>;
+    rawArguments?: string;
+    streamingArgs?: boolean;
+    /** During streaming, an approximate line count derived from `\n` escapes in rawArguments. */
+    streamingNewlineCount?: number;
+    status?: "pending" | "running" | "completed" | "error";
+    result?: string;
+    isError?: boolean;
+    metadata?: ToolResultMetadata;
+    startedAt?: number;
+    completedAt?: number;
+}
+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[];
+export declare function compactDisplayMessages(messages: DisplayMessage[]): DisplayMessage[];
+export declare function truncateText(value: string, maxChars: number): string;
+export declare function formatCompactNumber(n: number): string;

package/dist/tui/display-history.js

@@ -0,0 +1,305 @@
+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 : []);
+}
+const MAX_VISIBLE_MESSAGES = 80;
+const FULL_DETAIL_WINDOW = 24;
+const MAX_OLD_CONTENT_CHARS = 1200;
+const MAX_OLD_REASONING_CHARS = 600;
+const MAX_OLD_TOOL_RESULT_CHARS = 800;
+const COMPACTION_SUMMARY_ITEMS = 6;
+const COMPACTION_FILE_LIMIT = 8;
+const TOOL_PATH_KEYS = ["file", "path", "paths", "filePath"];
+export function compactDisplayMessages(messages) {
+    if (messages.length === 0) {
+        return messages;
+    }
+    let hiddenCount = 0;
+    let accumulatedTurns = 0;
+    let accumulatedTokens = 0;
+    const summarySections = [];
+    const withoutSynthetic = messages.filter((message) => {
+        if (message.syntheticKind !== "ui_compact_card") {
+            return true;
+        }
+        hiddenCount += message.hiddenCount ?? 0;
+        if (message.compactionMeta) {
+            accumulatedTurns += message.compactionMeta.turns;
+            accumulatedTokens += message.compactionMeta.tokensSaved;
+            for (const section of message.compactionMeta.summarySections) {
+                summarySections.push(section);
+            }
+        }
+        return false;
+    });
+    const overflow = Math.max(0, withoutSynthetic.length - MAX_VISIBLE_MESSAGES);
+    hiddenCount += overflow;
+    const visible = overflow > 0 ? withoutSynthetic.slice(overflow) : withoutSynthetic;
+    const detailStart = Math.max(0, visible.length - FULL_DETAIL_WINDOW);
+    const compacted = visible.map((message, index) => {
+        if (message.syntheticKind === "ui_compact_card") {
+            return message;
+        }
+        return index < detailStart ? compactDisplayMessage(message) : message;
+    });
+    if (hiddenCount === 0) {
+        return compacted;
+    }
+    const truncatedMessages = visible.slice(0, Math.max(1, detailStart));
+    const extractedMeta = extractCompactionMeta(truncatedMessages, hiddenCount, accumulatedTurns, accumulatedTokens, summarySections);
+    return [buildCompactCard(extractedMeta), ...compacted];
+}
+function extractCompactionMeta(truncatedMessages, hiddenCount, previousTurns, previousTokens, previousSections) {
+    const turnsInBatch = countUserTurns(truncatedMessages);
+    const totalTurns = previousTurns + turnsInBatch;
+    const messagesInBatch = truncatedMessages.length;
+    const totalMessages = hiddenCount;
+    const estimatedTokens = estimateTokenSavings(truncatedMessages);
+    const totalTokens = previousTokens + estimatedTokens;
+    const sections = [
+        ...previousSections,
+        ...extractSummarySections(truncatedMessages),
+    ];
+    return {
+        turns: totalTurns,
+        messages: totalMessages,
+        tokensSaved: totalTokens > 0 ? totalTokens : estimatedTokens,
+        summarySections: mergeSummarySections(sections, COMPACTION_SUMMARY_ITEMS),
+        compactedAt: Date.now(),
+    };
+}
+function countUserTurns(messages) {
+    return messages.filter((message) => message.role === "user").length;
+}
+function estimateTokenSavings(messages) {
+    let chars = 0;
+    for (const message of messages) {
+        chars += message.content.length;
+        chars += (message.reasoning?.length ?? 0);
+        for (const tool of message.toolCalls ?? []) {
+            chars += (tool.result?.length ?? 0);
+            chars += JSON.stringify(tool.args).length;
+        }
+    }
+    return Math.ceil(chars / 4);
+}
+function extractSummarySections(messages) {
+    const sections = [];
+    const userMessages = messages
+        .filter((m) => m.role === "user")
+        .map((m) => m.content);
+    if (userMessages.length > 0) {
+        sections.push({
+            label: "Progress",
+            content: userMessages.slice(0, 5).map((c) => `- ${shorten(c, 100)}`).join("\n"),
+        });
+    }
+    const assistantInsights = messages
+        .filter((m) => m.role === "assistant" && m.content.trim())
+        .map((m) => m.content.trim());
+    if (assistantInsights.length > 0) {
+        sections.push({
+            label: "Decisions",
+            content: assistantInsights.slice(0, 3).map((c) => `- ${shorten(c, 120)}`).join("\n"),
+        });
+    }
+    const files = collectFiles(messages);
+    if (files.length > 0) {
+        sections.push({
+            label: "Files",
+            content: files.slice(0, COMPACTION_FILE_LIMIT).join(", "),
+        });
+    }
+    const toolFindings = collectToolFindings(messages);
+    if (toolFindings.length > 0) {
+        sections.push({
+            label: "Tools",
+            content: toolFindings.slice(0, 5).map((f) => `- ${f}`).join("\n"),
+        });
+    }
+    return sections;
+}
+function collectFiles(messages) {
+    const files = new Set();
+    for (const message of messages) {
+        for (const tool of message.toolCalls ?? []) {
+            for (const key of TOOL_PATH_KEYS) {
+                const value = tool.args[key];
+                if (typeof value === "string" && value) {
+                    files.add(value);
+                }
+                if (Array.isArray(value)) {
+                    for (const item of value) {
+                        if (typeof item === "string" && item) {
+                            files.add(item);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return [...files].slice(0, COMPACTION_FILE_LIMIT);
+}
+function collectToolFindings(messages) {
+    const findings = [];
+    for (const message of messages) {
+        for (const tool of message.toolCalls ?? []) {
+            if (tool.result && tool.result.length > 0) {
+                findings.push(`${tool.name}: ${shorten(tool.result, 80)}`);
+                if (findings.length >= 10)
+                    break;
+            }
+        }
+        if (findings.length >= 10)
+            break;
+    }
+    return findings;
+}
+function mergeSummarySections(sections, maxItems) {
+    const merged = new Map();
+    for (const section of sections) {
+        const existing = merged.get(section.label);
+        if (existing) {
+            merged.set(section.label, `${existing}\n${section.content}`);
+        }
+        else {
+            merged.set(section.label, section.content);
+        }
+    }
+    return [...merged.entries()]
+        .map(([label, content]) => ({ label, content }))
+        .slice(0, maxItems);
+}
+function buildCompactCard(meta) {
+    const formatNum = (n) => {
+        if (n >= 1_000_000)
+            return `${(n / 1_000_000).toFixed(1)}M`;
+        if (n >= 1_000)
+            return `${(n / 1_000).toFixed(1)}K`;
+        return String(n);
+    };
+    const parts = [];
+    if (meta.turns > 0) {
+        parts.push(`${meta.turns} turn${meta.turns === 1 ? "" : "s"}`);
+    }
+    if (meta.messages > 0) {
+        parts.push(`${meta.messages} message${meta.messages === 1 ? "" : "s"}`);
+    }
+    if (meta.tokensSaved > 0) {
+        parts.push(`~${formatNum(meta.tokensSaved)} tokens`);
+    }
+    const statsLine = parts.length > 0 ? `┃ ${parts.join(" · ")}` : "";
+    const sectionLines = [];
+    for (const section of meta.summarySections) {
+        sectionLines.push(`┃ ${section.label}: ${section.content.split("\n")[0]}`);
+    }
+    const content = [statsLine, ...sectionLines].filter(Boolean).join("\n");
+    return {
+        role: "assistant",
+        content,
+        syntheticKind: "ui_compact_card",
+        hiddenCount: meta.messages,
+        compactionMeta: meta,
+        status: "responding",
+    };
+}
+function compactDisplayMessage(message) {
+    if (message.syntheticKind === "ui_compact_card") {
+        return message;
+    }
+    return {
+        ...message,
+        content: truncateText(message.content, MAX_OLD_CONTENT_CHARS),
+        reasoning: message.reasoning
+            ? truncateText(message.reasoning, MAX_OLD_REASONING_CHARS)
+            : message.reasoning,
+        toolCalls: message.toolCalls?.map(compactToolCall),
+        parts: message.parts?.map(compactDisplayPart),
+    };
+}
+function cloneToolCall(toolCall) {
+    return {
+        ...toolCall,
+        args: { ...toolCall.args },
+    };
+}
+function compactDisplayPart(part) {
+    if (part.type === "text") {
+        return {
+            ...part,
+            content: truncateText(part.content, MAX_OLD_CONTENT_CHARS),
+        };
+    }
+    return {
+        type: "tools",
+        toolCalls: part.toolCalls.map(compactToolCall),
+    };
+}
+function compactToolCall(toolCall) {
+    return {
+        ...toolCall,
+        result: toolCall.result
+            ? truncateText(toolCall.result, MAX_OLD_TOOL_RESULT_CHARS)
+            : toolCall.result,
+    };
+}
+export function truncateText(value, maxChars) {
+    if (value.length <= maxChars) {
+        return value;
+    }
+    const head = Math.max(1, Math.floor(maxChars * 0.7));
+    const tail = Math.max(1, maxChars - head - 32);
+    const omitted = value.length - head - tail;
+    const separator = "─".repeat(12);
+    return `${value.slice(0, head)}\n${separator} ✂ ${omitted} chars truncated ${separator}\n${value.slice(-tail)}`;
+}
+function shorten(text, maxChars) {
+    const normalized = text.replace(/\s+/g, " ").trim();
+    if (normalized.length <= maxChars) {
+        return normalized;
+    }
+    return `${normalized.slice(0, maxChars - 1)}…`;
+}
+export function formatCompactNumber(n) {
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 1_000)
+        return `${(n / 1_000).toFixed(1)}K`;
+    return String(n);
+}

package/dist/tui/edit-diff.d.ts

@@ -0,0 +1,11 @@
+import type { DisplayToolCall } from "./display-history.js";
+export declare const EDIT_COLLAPSED_DIFF_LINES = 20;
+export interface EditDiffDetails {
+    diff: string;
+    added: number;
+    removed: number;
+    path?: string;
+}
+export declare function getEditDiffDetails(tool: DisplayToolCall): EditDiffDetails | null;
+export declare function formatEditSuccessSummary(details: EditDiffDetails | null): string;
+export declare function formatEditStats(added: number, removed: number): string;