@bubblebrain-ai/bubble 0.0.10 → 0.0.12

package/dist/tui/file-mentions.js

@@ -1,174 +0,0 @@
-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

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

package/dist/tui/global-key-router.js

@@ -1,87 +0,0 @@
-import { isEscapeSequence } from "./prompt-keybindings.js";
-export function normalizeKeyName(name) {
-    const rawName = String(name || "").toLowerCase();
-    if (["arrowleft", "left_arrow", "leftarrow", "cursorleft", "left"].includes(rawName))
-        return "left";
-    if (["arrowright", "right_arrow", "rightarrow", "cursorright", "right"].includes(rawName))
-        return "right";
-    if (["arrowup", "up_arrow", "uparrow", "cursorup", "up"].includes(rawName))
-        return "up";
-    if (["arrowdown", "down_arrow", "downarrow", "cursordown", "down"].includes(rawName))
-        return "down";
-    if (rawName === "return" || rawName === "enter")
-        return "enter";
-    if (rawName === "esc" || rawName === "escape")
-        return "escape";
-    if (rawName === "tab")
-        return "tab";
-    return rawName;
-}
-export function keyNameFromSequence(sequence) {
-    if (!sequence)
-        return "";
-    const kittyName = keyNameFromKittySequence(sequence);
-    if (kittyName)
-        return kittyName;
-    if (sequence === "\x1b[D" || /^\x1b\[[0-9;]*D$/.test(sequence))
-        return "left";
-    if (sequence === "\x1b[C" || /^\x1b\[[0-9;]*C$/.test(sequence))
-        return "right";
-    if (sequence === "\x1b[A" || /^\x1b\[[0-9;]*A$/.test(sequence))
-        return "up";
-    if (sequence === "\x1b[B" || /^\x1b\[[0-9;]*B$/.test(sequence))
-        return "down";
-    if (sequence === "\x1bOD")
-        return "left";
-    if (sequence === "\x1bOC")
-        return "right";
-    if (sequence === "\x1bOA")
-        return "up";
-    if (sequence === "\x1bOB")
-        return "down";
-    if (sequence === "\t")
-        return "tab";
-    if (sequence === "\r" || sequence === "\n")
-        return "enter";
-    if (isEscapeSequence(sequence))
-        return "escape";
-    return "";
-}
-function keyNameFromKittySequence(sequence) {
-    const kittyMatch = /^\x1b\[(\d+)(?:;[1-9]\d*(?::[1-3])?)?u$/.exec(sequence);
-    const kittyCode = kittyMatch?.[1] ? Number(kittyMatch[1]) : NaN;
-    if (!Number.isNaN(kittyCode))
-        return keyNameFromKittyCode(kittyCode);
-    const modifyOtherKeysMatch = /^\x1b\[27;[1-9]\d*(?::[1-3])?;(\d+)~$/.exec(sequence);
-    const modifyOtherKeysCode = modifyOtherKeysMatch?.[1] ? Number(modifyOtherKeysMatch[1]) : NaN;
-    if (!Number.isNaN(modifyOtherKeysCode))
-        return keyNameFromKittyCode(modifyOtherKeysCode);
-    return "";
-}
-function keyNameFromKittyCode(code) {
-    switch (code) {
-        case 27:
-        case 57344:
-            return "escape";
-        case 9:
-        case 57346:
-            return "tab";
-        case 13:
-        case 57345:
-            return "enter";
-        case 57350:
-            return "left";
-        case 57351:
-            return "right";
-        case 57352:
-            return "up";
-        case 57353:
-            return "down";
-        default:
-            return "";
-    }
-}
-export function keyNameFromEvent(event) {
-    const rawName = normalizeKeyName(event?.name || event?.key || event?.input);
-    return rawName || keyNameFromSequence(event?.raw || event?.sequence);
-}

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

@@ -1,95 +0,0 @@
-/**
- * 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.
- */
-import type { ContentPart } from "../types.js";
-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 interface ImagePathToken {
-    rawPath: string;
-    start: number;
-    end: number;
-}
-export interface ImageInputResolution {
-    actualInput: string | ContentPart[];
-    displayInput: string;
-    errors: string[];
-    attachments: ImageAttachment[];
-    imagePathCount: number;
-}
-export interface LabeledImageAttachment extends ImageAttachment {
-    label: string;
-}
-export interface ComposerImageResolution {
-    text: string;
-    attachments: LabeledImageAttachment[];
-    errors: string[];
-    imagePathCount: number;
-    nextLabelIndex: number;
-}
-export declare function isImageFilePath(raw: string): boolean;
-export declare function extractImagePathTokens(input: string): ImagePathToken[];
-export declare function removeImagePathTokens(input: string, tokens: ImagePathToken[]): string;
-export declare function imageAttachmentLabel(att: ImageAttachment, index: number): string;
-export declare function imageAttachmentReference(att: ImageAttachment, index: number): string;
-export declare function imageAttachmentLabelPattern(): RegExp;
-export declare function buildImageContentParts(promptText: string, attachments: ImageAttachment[]): ContentPart[];
-export declare function formatImageDisplayInput(promptText: string, attachments: ImageAttachment[], labelStart?: number): string;
-export declare function buildImageContentPartsFromLabels(input: string, attachmentsByLabel: Map<string, ImageAttachment>): {
-    actualInput?: ContentPart[];
-    displayInput: string;
-    usedLabels: string[];
-};
-/**
- * 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;
-}>;
-export declare function resolveImageInput(input: string, options?: {
-    labelStart?: number;
-}): Promise<ImageInputResolution>;
-export declare function resolveComposerImagePaths(input: string, options?: {
-    labelStart?: number;
-}): Promise<ComposerImageResolution>;