@bubblebrain-ai/bubble 0.0.12 → 0.0.14

package/dist/tui/display-history.js

@@ -0,0 +1,306 @@
+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 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) {
+    if (toolCall.result === undefined) {
+        return toolCall;
+    }
+    return {
+        ...toolCall,
+        result: undefined,
+        resultCollapsed: true,
+    };
+}
+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;

package/dist/tui/edit-diff.js

@@ -0,0 +1,57 @@
+import { countUnifiedDiffChanges } from "../diff-stats.js";
+export const EDIT_COLLAPSED_DIFF_LINES = 20;
+export function getEditDiffDetails(tool) {
+    if ((tool.name !== "edit" && tool.name !== "apply_patch") || tool.isError)
+        return null;
+    const metadata = tool.metadata;
+    const metadataDiff = readMetadataString(metadata, "diff");
+    const diff = metadataDiff ?? extractDiffFromResult(tool.result);
+    if (!diff)
+        return null;
+    const counted = countUnifiedDiffChanges(diff);
+    const added = readMetadataNumber(metadata, "addedLines") ?? counted.added;
+    const removed = readMetadataNumber(metadata, "removedLines") ?? counted.removed;
+    const path = readMetadataString(metadata, "path")
+        ?? readFirstMetadataPath(metadata)
+        ?? (typeof tool.args.path === "string" ? tool.args.path : undefined);
+    return { diff, added, removed, path };
+}
+function readFirstMetadataPath(metadata) {
+    const value = metadata?.paths;
+    return Array.isArray(value) && typeof value[0] === "string" ? value[0] : undefined;
+}
+export function formatEditSuccessSummary(details) {
+    const stats = details ? formatEditStats(details.added, details.removed) : "";
+    return `Succeeded. File edited.${stats ? ` ${stats}` : ""}`;
+}
+export function formatEditStats(added, removed) {
+    const parts = [];
+    if (added > 0)
+        parts.push(`+${added} added`);
+    if (removed > 0)
+        parts.push(`-${removed} removed`);
+    if (parts.length === 0)
+        return "";
+    return `(${parts.join(", ")})`;
+}
+function extractDiffFromResult(result) {
+    if (!result)
+        return null;
+    const normalized = result.replace(/\r\n/g, "\n");
+    const marker = "\nDiff:\n";
+    const index = normalized.indexOf(marker);
+    if (index === -1)
+        return null;
+    const rawDiff = normalized.slice(index + marker.length);
+    const diagnosticsIndex = rawDiff.search(/\n\nLSP diagnostics in /);
+    const diff = diagnosticsIndex === -1 ? rawDiff : rawDiff.slice(0, diagnosticsIndex);
+    return diff.trim().length > 0 ? diff : null;
+}
+function readMetadataString(metadata, key) {
+    const value = metadata?.[key];
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function readMetadataNumber(metadata, key) {
+    const value = metadata?.[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}

package/dist/tui/escape-confirmation.d.ts

@@ -0,0 +1,15 @@
+export type EscapeConfirmationDecision = {
+    action: "arm";
+    expiresAt: number;
+} | {
+    action: "confirm";
+};
+export declare class EscapeConfirmationGate {
+    private readonly windowMs;
+    private armedRunId;
+    private deadline;
+    constructor(windowMs: number);
+    press(runId: number, now?: number): EscapeConfirmationDecision;
+    isArmed(runId: number, now?: number): boolean;
+    clear(): void;
+}

package/dist/tui/escape-confirmation.js

@@ -0,0 +1,30 @@
+export class EscapeConfirmationGate {
+    windowMs;
+    armedRunId;
+    deadline = 0;
+    constructor(windowMs) {
+        this.windowMs = windowMs;
+    }
+    press(runId, now = Date.now()) {
+        if (this.armedRunId === runId && now <= this.deadline) {
+            this.clear();
+            return { action: "confirm" };
+        }
+        this.armedRunId = runId;
+        this.deadline = now + this.windowMs;
+        return { action: "arm", expiresAt: this.deadline };
+    }
+    isArmed(runId, now = Date.now()) {
+        if (this.armedRunId !== runId)
+            return false;
+        if (now > this.deadline) {
+            this.clear();
+            return false;
+        }
+        return true;
+    }
+    clear() {
+        this.armedRunId = undefined;
+        this.deadline = 0;
+    }
+}

package/dist/tui/file-mentions.d.ts

@@ -0,0 +1,29 @@
+export interface AtContext {
+    start: number;
+    end: number;
+    query: string;
+}
+export interface FileSuggestion {
+    path: string;
+    score: number;
+}
+export interface ExpandedMention {
+    path: string;
+    bytes: number;
+    truncated: boolean;
+}
+export interface ExpandResult {
+    text: string;
+    expanded: ExpandedMention[];
+    missing: string[];
+    skipped: Array<{
+        path: string;
+        reason: string;
+        bytes?: number;
+    }>;
+}
+export declare function findAtContext(text: string, cursor: number): AtContext | null;
+export declare function filterFileSuggestions(files: string[], query: string, limit?: number): FileSuggestion[];
+export declare function listProjectFiles(cwd: string): Promise<string[]>;
+export declare function invalidateFileListCache(cwd?: string): void;
+export declare function expandAtMentions(text: string, cwd: string): Promise<ExpandResult>;

package/dist/tui/file-mentions.js

@@ -0,0 +1,174 @@
+import { execFile } from "node:child_process";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const MAX_INLINE_BYTES = 200 * 1024;
+const IGNORED_DIRS = new Set([".git", "node_modules", "dist", "build", ".next", ".turbo", ".cache"]);
+const fileListCache = new Map();
+export function findAtContext(text, cursor) {
+    const before = text.slice(0, cursor);
+    const at = before.lastIndexOf("@");
+    if (at === -1)
+        return null;
+    const prev = at === 0 ? "" : before[at - 1];
+    if (prev !== "" && !/\s/.test(prev))
+        return null;
+    const query = before.slice(at + 1);
+    if (/\s/.test(query))
+        return null;
+    return { start: at, end: cursor, query };
+}
+export function filterFileSuggestions(files, query, limit = 20) {
+    const q = query.toLowerCase();
+    if (q.length === 0) {
+        return files.slice(0, limit).map((p) => ({ path: p, score: 1 }));
+    }
+    const scored = [];
+    for (const file of files) {
+        const lower = file.toLowerCase();
+        const base = path.basename(lower);
+        let score = 0;
+        if (base.startsWith(q))
+            score = 100;
+        else if (lower.startsWith(q))
+            score = 80;
+        else if (base.includes(q))
+            score = 60;
+        else if (lower.includes(q))
+            score = 40;
+        if (score > 0)
+            scored.push({ path: file, score });
+    }
+    scored.sort((a, b) => (b.score - a.score) || (a.path.length - b.path.length) || a.path.localeCompare(b.path));
+    return scored.slice(0, limit);
+}
+export async function listProjectFiles(cwd) {
+    const cached = fileListCache.get(cwd);
+    if (cached)
+        return cached;
+    const files = await discoverFiles(cwd);
+    fileListCache.set(cwd, files);
+    return files;
+}
+export function invalidateFileListCache(cwd) {
+    if (cwd)
+        fileListCache.delete(cwd);
+    else
+        fileListCache.clear();
+}
+async function discoverFiles(cwd) {
+    try {
+        const { stdout } = await execFileAsync("git", ["ls-files", "-co", "--exclude-standard"], {
+            cwd,
+            maxBuffer: 32 * 1024 * 1024,
+        });
+        const files = stdout.split("\n").map((s) => s.trim()).filter(Boolean);
+        if (files.length > 0)
+            return files;
+    }
+    catch {
+        // Not a git repo or git unavailable — fall through to filesystem walk.
+    }
+    return walkFilesystem(cwd);
+}
+async function walkFilesystem(root) {
+    const results = [];
+    async function visit(dir, rel) {
+        let entries;
+        try {
+            entries = (await fs.readdir(dir, { withFileTypes: true }));
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith(".") && entry.name !== ".env" && entry.name !== ".gitignore")
+                continue;
+            if (IGNORED_DIRS.has(entry.name))
+                continue;
+            const abs = path.join(dir, entry.name);
+            const relPath = rel ? `${rel}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                await visit(abs, relPath);
+            }
+            else if (entry.isFile()) {
+                results.push(relPath);
+            }
+        }
+    }
+    await visit(root, "");
+    return results;
+}
+const MENTION_REGEX = /(^|\s)@([^\s]+)/g;
+export async function expandAtMentions(text, cwd) {
+    const result = { text, expanded: [], missing: [], skipped: [] };
+    const mentions = Array.from(text.matchAll(MENTION_REGEX));
+    if (mentions.length === 0)
+        return result;
+    const blocks = [];
+    const seen = new Set();
+    for (const match of mentions) {
+        const token = match[2];
+        if (seen.has(token))
+            continue;
+        seen.add(token);
+        const abs = path.resolve(cwd, token);
+        if (!abs.startsWith(path.resolve(cwd))) {
+            result.skipped.push({ path: token, reason: "outside project" });
+            continue;
+        }
+        let stat;
+        try {
+            stat = await fs.stat(abs);
+        }
+        catch {
+            result.missing.push(token);
+            continue;
+        }
+        if (!stat.isFile()) {
+            result.skipped.push({ path: token, reason: "not a file" });
+            continue;
+        }
+        if (stat.size > MAX_INLINE_BYTES) {
+            result.skipped.push({ path: token, reason: "too large", bytes: stat.size });
+            blocks.push(`### @${token}\n(${formatBytes(stat.size)}, exceeds inline limit of ${formatBytes(MAX_INLINE_BYTES)} — use the Read tool to access)`);
+            continue;
+        }
+        let contents;
+        try {
+            contents = await fs.readFile(abs, "utf8");
+        }
+        catch (err) {
+            result.skipped.push({ path: token, reason: `read failed: ${err.message || String(err)}` });
+            continue;
+        }
+        result.expanded.push({ path: token, bytes: stat.size, truncated: false });
+        const lang = guessLanguage(token);
+        blocks.push(`### @${token}\n\`\`\`${lang}\n${contents}\n\`\`\``);
+    }
+    if (blocks.length === 0)
+        return result;
+    result.text = `${text}\n\n---\nReferenced files:\n\n${blocks.join("\n\n")}`;
+    return result;
+}
+function formatBytes(n) {
+    if (n < 1024)
+        return `${n}B`;
+    if (n < 1024 * 1024)
+        return `${(n / 1024).toFixed(1)}KB`;
+    return `${(n / 1024 / 1024).toFixed(1)}MB`;
+}
+function guessLanguage(filePath) {
+    const ext = path.extname(filePath).slice(1).toLowerCase();
+    const map = {
+        ts: "ts", tsx: "tsx", js: "js", jsx: "jsx",
+        py: "python", rb: "ruby", go: "go", rs: "rust",
+        java: "java", kt: "kotlin", swift: "swift",
+        c: "c", h: "c", cpp: "cpp", cc: "cpp", hpp: "cpp",
+        cs: "csharp", php: "php", sh: "bash", zsh: "bash", bash: "bash",
+        json: "json", yaml: "yaml", yml: "yaml", toml: "toml", xml: "xml",
+        html: "html", css: "css", scss: "scss", sql: "sql", md: "markdown",
+    };
+    return map[ext] ?? "";
+}

package/dist/tui/global-key-router.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizeKeyName(name?: string): string;
+export declare function keyNameFromSequence(sequence?: string): string;
+export declare function keyNameFromEvent(event: any): string;