@bubblebrain-ai/bubble 0.0.3 → 0.0.5

package/dist/tui/image-paste.js

@@ -14,6 +14,7 @@ import path from "node:path";
 import { promisify } from "node:util";
 const execFileAsync = promisify(execFile);
 const IMAGE_EXT = /\.(png|jpe?g|gif|webp|bmp)$/i;
+const IMAGE_EXT_SOURCE = String.raw `(?:png|jpe?g|gif|webp|bmp)`;
 // Anthropic/OpenAI image uploads cap at ~5MB base64. We target a bit below so
 // the base64 inflation (4/3) doesn't push us over.
 const MAX_BASE64_BYTES = 5 * 1024 * 1024;
@@ -30,6 +31,112 @@ export function isImageFilePath(raw) {
     // be treated as a path.
     return path.isAbsolute(s) || s.startsWith("~") || /^[A-Za-z]:\\/.test(s);
 }
+export function extractImagePathTokens(input) {
+    const pattern = new RegExp(String.raw `(^|\s)(?:"([^"]+\.${IMAGE_EXT_SOURCE})"|'([^']+\.${IMAGE_EXT_SOURCE})'|((?:~|\/|[A-Za-z]:\\)(?:\\ |[^\s"'<>])+\.${IMAGE_EXT_SOURCE}))(?=$|\s)`, "gi");
+    const tokens = [];
+    for (const match of input.matchAll(pattern)) {
+        const leading = match[1] ?? "";
+        const rawPath = match[2] ?? match[3] ?? match[4];
+        if (!rawPath || !isImageFilePath(rawPath))
+            continue;
+        const start = (match.index ?? 0) + leading.length;
+        const end = (match.index ?? 0) + match[0].length;
+        tokens.push({ rawPath, start, end });
+    }
+    return tokens;
+}
+export function removeImagePathTokens(input, tokens) {
+    if (tokens.length === 0)
+        return input.trim();
+    let out = "";
+    let cursor = 0;
+    for (const token of tokens) {
+        out += input.slice(cursor, token.start);
+        out += " ";
+        cursor = token.end;
+    }
+    out += input.slice(cursor);
+    return out
+        .replace(/[ \t]+/g, " ")
+        .replace(/ *\n */g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+export function imageAttachmentLabel(att, index) {
+    return `image#${index}${imageExtension(att)}`;
+}
+export function imageAttachmentReference(att, index) {
+    return `[${imageAttachmentLabel(att, index)}]`;
+}
+export function imageAttachmentLabelPattern() {
+    return /\[image#(\d+)\.[^\]\s]+\]/g;
+}
+function defaultImagePrompt(count) {
+    return count === 1
+        ? "Please analyze the attached image."
+        : "Please analyze the attached images.";
+}
+function imageExtension(att) {
+    const fromPath = path.extname(att.filename ?? att.sourcePath ?? "").toLowerCase();
+    if (fromPath)
+        return fromPath;
+    if (att.mediaType === "image/jpeg")
+        return ".jpg";
+    if (att.mediaType === "image/webp")
+        return ".webp";
+    if (att.mediaType === "image/gif")
+        return ".gif";
+    if (att.mediaType === "image/bmp")
+        return ".bmp";
+    return ".png";
+}
+export function buildImageContentParts(promptText, attachments) {
+    const text = promptText.trim() || defaultImagePrompt(attachments.length);
+    return [
+        { type: "text", text },
+        ...attachments.map((attachment) => ({
+            type: "image_url",
+            image_url: { url: attachment.dataUrl },
+        })),
+    ];
+}
+export function formatImageDisplayInput(promptText, attachments, labelStart = 1) {
+    const text = promptText.trim() || defaultImagePrompt(attachments.length);
+    const imageLines = attachments.map((attachment, index) => imageAttachmentReference(attachment, labelStart + index));
+    return `${text}\n${imageLines.join("\n")}`;
+}
+export function buildImageContentPartsFromLabels(input, attachmentsByLabel) {
+    const matches = Array.from(input.matchAll(imageAttachmentLabelPattern()));
+    const usedLabels = [];
+    const parts = [];
+    let cursor = 0;
+    for (const match of matches) {
+        const label = match[0].slice(1, -1);
+        const attachment = attachmentsByLabel.get(label);
+        if (!attachment)
+            continue;
+        const start = match.index ?? 0;
+        const before = input.slice(cursor, start).trim();
+        if (before)
+            parts.push({ type: "text", text: before });
+        parts.push({ type: "image_url", image_url: { url: attachment.dataUrl } });
+        usedLabels.push(label);
+        cursor = start + match[0].length;
+    }
+    if (usedLabels.length === 0)
+        return { displayInput: input, usedLabels: [] };
+    const rest = input.slice(cursor).trim();
+    if (rest)
+        parts.push({ type: "text", text: rest });
+    if (!parts.some((part) => part.type === "text")) {
+        parts.unshift({ type: "text", text: defaultImagePrompt(usedLabels.length) });
+    }
+    return {
+        actualInput: parts,
+        displayInput: input.trim() || usedLabels.map((label) => `[${label}]`).join("\n"),
+        usedLabels,
+    };
+}
 /**
  * Split a pasted blob into candidate path tokens.
  *
@@ -286,3 +393,113 @@ export async function ingestClipboardImage() {
         return { error: validation.reason };
     return { attachment: sized };
 }
+export async function resolveImageInput(input, options = {}) {
+    const tokens = extractImagePathTokens(input);
+    if (tokens.length === 0) {
+        return {
+            actualInput: input,
+            displayInput: input,
+            errors: [],
+            attachments: [],
+            imagePathCount: 0,
+        };
+    }
+    const attachments = [];
+    const errors = [];
+    const attachmentsByToken = new Map();
+    let nextLabelIndex = options.labelStart ?? 1;
+    for (const token of tokens) {
+        const result = await ingestImagePath(token.rawPath);
+        if (result.attachment) {
+            attachments.push(result.attachment);
+            attachmentsByToken.set(token, {
+                attachment: result.attachment,
+                label: imageAttachmentLabel(result.attachment, nextLabelIndex++),
+            });
+        }
+        else {
+            errors.push(`${token.rawPath}: ${result.error ?? "could not attach image"}`);
+        }
+    }
+    if (attachments.length === 0) {
+        return {
+            actualInput: input,
+            displayInput: input,
+            errors,
+            attachments: [],
+            imagePathCount: tokens.length,
+        };
+    }
+    const parts = [];
+    let displayInput = "";
+    let cursor = 0;
+    for (const token of tokens) {
+        const entry = attachmentsByToken.get(token);
+        if (!entry)
+            continue;
+        const before = input.slice(cursor, token.start);
+        displayInput += before;
+        const text = before.trim();
+        if (text)
+            parts.push({ type: "text", text });
+        parts.push({ type: "image_url", image_url: { url: entry.attachment.dataUrl } });
+        displayInput += `[${entry.label}]`;
+        cursor = token.end;
+    }
+    const rest = input.slice(cursor);
+    displayInput += rest;
+    const restText = rest.trim();
+    if (restText)
+        parts.push({ type: "text", text: restText });
+    if (!parts.some((part) => part.type === "text")) {
+        parts.unshift({ type: "text", text: defaultImagePrompt(attachments.length) });
+    }
+    return {
+        actualInput: parts,
+        displayInput: displayInput.trim(),
+        errors,
+        attachments,
+        imagePathCount: tokens.length,
+    };
+}
+export async function resolveComposerImagePaths(input, options = {}) {
+    const tokens = extractImagePathTokens(input);
+    let nextLabelIndex = options.labelStart ?? 1;
+    if (tokens.length === 0) {
+        return {
+            text: input,
+            attachments: [],
+            errors: [],
+            imagePathCount: 0,
+            nextLabelIndex,
+        };
+    }
+    const errors = [];
+    const attachments = [];
+    const replacements = new Map();
+    for (const token of tokens) {
+        const result = await ingestImagePath(token.rawPath);
+        if (!result.attachment) {
+            errors.push(`${token.rawPath}: ${result.error ?? "could not attach image"}`);
+            continue;
+        }
+        const label = imageAttachmentLabel(result.attachment, nextLabelIndex++);
+        attachments.push({ ...result.attachment, label });
+        replacements.set(token, `[${label}]`);
+    }
+    let text = "";
+    let cursor = 0;
+    for (const token of tokens) {
+        text += input.slice(cursor, token.start);
+        text += replacements.get(token) ?? input.slice(token.start, token.end);
+        cursor = token.end;
+    }
+    text += input.slice(cursor);
+    return {
+        text,
+        attachments,
+        errors,
+        imagePathCount: tokens.length,
+        nextLabelIndex,
+    };
+}

package/dist/tui/markdown-inline.d.ts

@@ -0,0 +1,22 @@
+export interface MarkdownInlineSegment {
+    text: string;
+    color?: "text" | "textMuted" | "success" | "warning" | "secondary";
+    bold?: boolean;
+    italic?: boolean;
+    dim?: boolean;
+}
+type InlineToken = {
+    type?: string;
+    text?: string;
+    raw?: string;
+    href?: string;
+    tokens?: InlineToken[];
+};
+interface InlineStyle {
+    bold?: boolean;
+    italic?: boolean;
+    dim?: boolean;
+    color?: MarkdownInlineSegment["color"];
+}
+export declare function markdownInlineSegments(tokens: InlineToken[] | undefined, fallback?: string, style?: InlineStyle): MarkdownInlineSegment[];
+export {};

package/dist/tui/markdown-inline.js

@@ -0,0 +1,68 @@
+export function markdownInlineSegments(tokens, fallback = "", style = {}) {
+    const segments = [];
+    for (const token of tokens ?? []) {
+        appendInlineToken(segments, token, style);
+    }
+    if (segments.length === 0 && fallback) {
+        appendStyled(segments, fallback, style);
+    }
+    return segments;
+}
+function appendInlineToken(segments, token, style) {
+    switch (token.type) {
+        case "strong":
+            appendInlineTokens(segments, token.tokens, { ...style, bold: true });
+            return;
+        case "em":
+            appendInlineTokens(segments, token.tokens, { ...style, italic: true, color: style.color ?? "warning" });
+            return;
+        case "del":
+            appendInlineTokens(segments, token.tokens, { ...style, dim: true, color: style.color ?? "textMuted" });
+            return;
+        case "codespan":
+            appendStyled(segments, token.text ?? "", { ...style, color: "success" });
+            return;
+        case "link":
+            appendInlineTokens(segments, token.tokens, { ...style, color: style.color ?? "secondary" });
+            return;
+        case "br":
+            appendStyled(segments, "\n", style);
+            return;
+        case "text":
+        case "paragraph":
+        case "list_item":
+        case "heading":
+            if (token.tokens?.length) {
+                appendInlineTokens(segments, token.tokens, style);
+            }
+            else {
+                appendStyled(segments, token.text ?? token.raw ?? "", style);
+            }
+            return;
+        case "space":
+            return;
+        default:
+            if (token.tokens?.length) {
+                appendInlineTokens(segments, token.tokens, style);
+            }
+            else {
+                appendStyled(segments, token.text ?? token.raw ?? "", style);
+            }
+    }
+}
+function appendInlineTokens(segments, tokens, style) {
+    for (const child of tokens ?? []) {
+        appendInlineToken(segments, child, style);
+    }
+}
+function appendStyled(segments, text, style) {
+    if (!text)
+        return;
+    segments.push({
+        text,
+        color: style.color ?? "text",
+        bold: style.bold,
+        italic: style.italic,
+        dim: style.dim,
+    });
+}

package/dist/tui/render-signature.d.ts

@@ -0,0 +1 @@
+export declare function hashString(value: string): string;

package/dist/tui/render-signature.js

@@ -0,0 +1,7 @@
+export function hashString(value) {
+    let hash = 5381;
+    for (let index = 0; index < value.length; index++) {
+        hash = ((hash << 5) + hash) ^ value.charCodeAt(index);
+    }
+    return (hash >>> 0).toString(36);
+}