@bubblebrain-ai/bubble 0.0.7 → 0.0.9

package/dist/tui-ink/display-history.js

@@ -0,0 +1,130 @@
+let __displayMessageCounter = 0;
+export function nextDisplayMessageKey(prefix = "msg") {
+    __displayMessageCounter += 1;
+    return `${prefix}-${__displayMessageCounter}`;
+}
+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;
+export function compactDisplayMessages(messages) {
+    if (messages.length === 0) {
+        return messages;
+    }
+    let hiddenCount = 0;
+    const withoutSynthetic = messages.filter((message) => {
+        if (message.syntheticKind !== "ui_summary") {
+            return true;
+        }
+        hiddenCount += message.hiddenCount ?? 0;
+        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) => (index < detailStart ? compactDisplayMessage(message) : message));
+    if (hiddenCount === 0) {
+        return compacted;
+    }
+    return [buildUiSummary(hiddenCount), ...compacted];
+}
+function compactDisplayMessage(message) {
+    if (message.syntheticKind === "ui_summary") {
+        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 buildUiSummary(hiddenCount) {
+    return {
+        key: "synthetic-ui-summary",
+        role: "assistant",
+        content: `[Earlier UI history compacted to control memory: ${hiddenCount} message${hiddenCount === 1 ? "" : "s"} hidden]`,
+        syntheticKind: "ui_summary",
+        hiddenCount,
+    };
+}
+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;
+    return `${value.slice(0, head)}\n...[${omitted} chars omitted for UI]...\n${value.slice(-tail)}`;
+}
+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,
+    };
+}

package/dist/tui-ink/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-ink/edit-diff.js

@@ -0,0 +1,52 @@
+import { countUnifiedDiffChanges } from "../diff-stats.js";
+export const EDIT_COLLAPSED_DIFF_LINES = 20;
+export function getEditDiffDetails(tool) {
+    if (tool.name !== "edit" || 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")
+        ?? (typeof tool.args.path === "string" ? tool.args.path : undefined);
+    return { diff, added, removed, path };
+}
+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-ink/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-ink/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-ink/footer.d.ts

@@ -0,0 +1,19 @@
+import type { PermissionMode } from "../types.js";
+export interface FooterUsageTotals {
+    prompt: number;
+    completion: number;
+}
+export interface FooterData {
+    cwd: string;
+    providerId: string;
+    model: string;
+    thinkingLevel: string;
+    showThinking: boolean;
+    mode?: PermissionMode;
+    usageTotals: FooterUsageTotals;
+    verboseTrace?: boolean;
+}
+export declare function FooterBar({ data }: {
+    data: FooterData;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function buildFooterData(input: FooterData): FooterData;

package/dist/tui-ink/footer.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { homedir } from "node:os";
+import { useTheme } from "./theme.js";
+import { PERMISSION_MODE_INFO } from "../permission/mode.js";
+export function FooterBar({ data }) {
+    const theme = useTheme();
+    const usageText = data.usageTotals.prompt || data.usageTotals.completion
+        ? `↑${formatTokens(data.usageTotals.prompt)} ↓${formatTokens(data.usageTotals.completion)}`
+        : "";
+    const thinkingText = data.showThinking
+        ? data.thinkingLevel && data.thinkingLevel !== "off"
+            ? ` • ⌃R ${data.thinkingLevel}`
+            : " • ⌃R off"
+        : "";
+    return (_jsxs(Box, { paddingX: 1, flexShrink: 0, children: [_jsx(Text, { color: theme.muted, children: formatCwd(data.cwd) }), usageText && (_jsxs(_Fragment, { children: [_jsx(Text, { color: theme.muted, children: "  " }), _jsx(Text, { color: theme.muted, dimColor: true, children: usageText })] })), _jsx(ModeBadge, { mode: data.mode }), _jsx(Box, { flexGrow: 1 }), _jsx(Text, { color: theme.muted, children: data.providerId }), _jsx(Text, { color: theme.muted, children: " \u2022 " }), _jsx(Text, { color: theme.toolName, children: data.model }), _jsx(Text, { color: theme.muted, dimColor: true, children: thinkingText })] }));
+}
+function ModeBadge({ mode }) {
+    const theme = useTheme();
+    if (!mode || mode === "default")
+        return null;
+    const info = PERMISSION_MODE_INFO[mode];
+    const color = theme[info.color] ?? theme.muted;
+    const symbol = info.symbol ? `${info.symbol} ` : "";
+    return (_jsxs(_Fragment, { children: [_jsx(Text, { color: theme.muted, children: "  " }), _jsxs(Text, { color: color, bold: true, children: [symbol, info.shortTitle, " on"] }), _jsx(Text, { color: theme.muted, children: " \u21E7\u21E5" })] }));
+}
+export function buildFooterData(input) {
+    return input;
+}
+function formatTokens(count) {
+    if (count < 1000)
+        return String(count);
+    if (count < 10000)
+        return `${(count / 1000).toFixed(1)}k`;
+    if (count < 1000000)
+        return `${Math.round(count / 1000)}k`;
+    return `${(count / 1000000).toFixed(1)}M`;
+}
+function formatCwd(cwd) {
+    const home = homedir();
+    if (cwd.startsWith(home)) {
+        return `~${cwd.slice(home.length)}`;
+    }
+    return cwd;
+}

package/dist/tui-ink/image-paste.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Image paste utilities: path detection, file reading, clipboard access, and size-capping.
+ *
+ * Terminals don't forward image bytes to stdin. Paths arrive as text when users
+ * drag files in; Cmd+V of an image produces an empty paste (we probe the
+ * clipboard). macOS screenshot shortcut (Cmd+Shift+Ctrl+4) writes to both a
+ * TemporaryItems path and the clipboard — the path often gets cleaned up before
+ * we can read it, so we fall back to the clipboard.
+ */
+export interface ImageAttachment {
+    base64: string;
+    mediaType: string;
+    /** Raw byte size of the decoded image (not base64). */
+    bytes: number;
+    /** data:<mediaType>;base64,<...> — ready to send as image_url.url. */
+    dataUrl: string;
+    filename?: string;
+    sourcePath?: string;
+}
+export declare function isImageFilePath(raw: string): boolean;
+/**
+ * Split a pasted blob into candidate path tokens.
+ *
+ * Multi-drag from Finder delivers a mix of newline- and space-separated
+ * absolute paths. Spaces inside a single path are escaped (`\ `) — we split
+ * only on a space that is followed by the start of a new absolute path.
+ */
+export declare function splitPastedPaths(pasted: string): string[];
+export declare function readImageFromPath(rawPath: string): Promise<ImageAttachment | null>;
+/** macOS screenshot shortcut writes to these paths and they may be auto-cleaned. */
+export declare function isScreenshotTempPath(s: string): boolean;
+export declare function getImageFromClipboard(): Promise<ImageAttachment | null>;
+/**
+ * If the image is close to the API size cap, try to downscale it in place.
+ * Uses the OS-native tools that are typically available:
+ *   - macOS: `sips` (always present)
+ *   - linux: ImageMagick `convert` (if installed)
+ * Returns the original attachment if resize isn't needed or can't run.
+ */
+export declare function maybeResizeImage(att: ImageAttachment): Promise<ImageAttachment>;
+export interface ValidationResult {
+    ok: boolean;
+    reason?: string;
+}
+export declare function validateImageSize(att: ImageAttachment): ValidationResult;
+/** End-to-end: given a file path, read -> resize-if-needed -> validate. */
+export declare function ingestImagePath(p: string): Promise<{
+    attachment?: ImageAttachment;
+    error?: string;
+}>;
+export declare function ingestClipboardImage(): Promise<{
+    attachment?: ImageAttachment;
+    error?: string;
+}>;