@bubblebrain-ai/bubble 0.0.16 → 0.0.18

package/dist/tui-opentui/input-box.js

@@ -14,21 +14,10 @@ import { useTheme } from "./theme.js";
 import { filterFileSuggestions, findAtContext, listProjectFiles } from "./file-mentions.js";
 import { ingestImagePath, isImageFilePath, isScreenshotTempPath, splitPastedPaths, } from "./image-paste.js";
 import { appendHistoryEntry, loadHistorySync, stepHistory, } from "./input-history.js";
+export { createPastedContentMarker, shouldCollapsePastedContent, } from "../tui/paste-placeholder.js";
+import { createPastedContentMarker, expandPastedContentMarkers, shouldCollapsePastedContent, } from "../tui/paste-placeholder.js";
 const PROMPT = " > ";
-const LONG_PASTE_CHAR_THRESHOLD = 1000;
-const LONG_PASTE_LINE_THRESHOLD = 20;
 const MAX_VISIBLE_SUGGESTIONS = 8;
-export function shouldCollapsePastedContent(text) {
-    if (text.length >= LONG_PASTE_CHAR_THRESHOLD)
-        return true;
-    const lines = text.split("\n").length;
-    return lines >= LONG_PASTE_LINE_THRESHOLD;
-}
-export function createPastedContentMarker(content) {
-    const lineCount = content.split("\n").length;
-    const wordCount = content.trim().split(/\s+/).length;
-    return `[Pasted ${lineCount} lines · ${wordCount} words]`;
-}
 export function isCtrlCInput(input, key) {
     return input === "\x03" || (key.ctrl === true && input.toLowerCase() === "c");
 }
@@ -37,7 +26,7 @@ export function InputBox({ onSubmit, onPasteNotice, disabled = false, cursorRese
     const [buffer, setBuffer] = useState("");
     const [cursor, setCursor] = useState(0);
     const [images, setImages] = useState([]);
-    const [pastedRefs, setPastedRefs] = useState(new Map());
+    const [pastedRefs, setPastedRefs] = useState([]);
     const [history] = useState(() => loadHistorySync());
     const [historyIndex, setHistoryIndex] = useState(null);
     const [suggestions, setSuggestions] = useState([]);
@@ -55,6 +44,7 @@ export function InputBox({ onSubmit, onPasteNotice, disabled = false, cursorRese
     const suggestionIndexRef = useRef(suggestionIndex);
     const suggestionKindRef = useRef(suggestionKind);
     const historyIndexRef = useRef(historyIndex);
+    const nextPastedContentIndexRef = useRef(1);
     bufferRef.current = buffer;
     cursorRef.current = cursor;
     imagesRef.current = images;
@@ -70,7 +60,8 @@ export function InputBox({ onSubmit, onPasteNotice, disabled = false, cursorRese
         setBuffer("");
         setCursor(0);
         setImages([]);
-        setPastedRefs(new Map());
+        setPastedRefs([]);
+        nextPastedContentIndexRef.current = 1;
         setSuggestions([]);
         setSuggestionKind(null);
         setHistoryIndex(null);
@@ -81,6 +72,8 @@ export function InputBox({ onSubmit, onPasteNotice, disabled = false, cursorRese
             return;
         setBuffer(draftText);
         setCursor(draftText.length);
+        setPastedRefs([]);
+        nextPastedContentIndexRef.current = 1;
         onDraftApplied?.();
     }, [draftText, draftEpoch, onDraftApplied]);
     const updateSuggestions = useCallback(async (text, cursorPos) => {
@@ -168,10 +161,7 @@ export function InputBox({ onSubmit, onPasteNotice, disabled = false, cursorRese
         const refs = pastedRefsRef.current;
         if (!b.trim() && imgs.length === 0)
             return;
-        let expanded = b;
-        for (const [marker, content] of refs) {
-            expanded = expanded.split(marker).join(content);
-        }
+        const expanded = expandPastedContentMarkers(b, refs);
         const payload = {
             text: expanded,
             displayText: expanded !== b ? b : undefined,
@@ -183,7 +173,8 @@ export function InputBox({ onSubmit, onPasteNotice, disabled = false, cursorRese
         setBuffer("");
         setCursor(0);
         setImages([]);
-        setPastedRefs(new Map());
+        setPastedRefs([]);
+        nextPastedContentIndexRef.current = 1;
         setSuggestions([]);
         setSuggestionKind(null);
         setHistoryIndex(null);
@@ -211,12 +202,8 @@ export function InputBox({ onSubmit, onPasteNotice, disabled = false, cursorRese
         }
         // Plain text: collapse if long, otherwise insert at cursor.
         if (shouldCollapsePastedContent(text)) {
-            const marker = createPastedContentMarker(text);
-            setPastedRefs((prev) => {
-                const next = new Map(prev);
-                next.set(marker, text);
-                return next;
-            });
+            const marker = createPastedContentMarker(text, nextPastedContentIndexRef.current++);
+            setPastedRefs((prev) => [...prev, { marker, content: text }]);
             insertAtCursor(marker);
         }
         else {
@@ -306,6 +293,8 @@ export function InputBox({ onSubmit, onPasteNotice, disabled = false, cursorRese
                     setBuffer(next.text);
                     setCursor(next.text.length);
                     setHistoryIndex(next.index);
+                    setPastedRefs([]);
+                    nextPastedContentIndexRef.current = 1;
                 }
                 return;
             }
@@ -324,6 +313,8 @@ export function InputBox({ onSubmit, onPasteNotice, disabled = false, cursorRese
                 setBuffer(next.text);
                 setCursor(next.text.length);
                 setHistoryIndex(next.index);
+                setPastedRefs([]);
+                nextPastedContentIndexRef.current = 1;
                 return;
             }
             const lineEnd = b.indexOf("\n", c);

package/dist/types.d.ts

@@ -14,6 +14,14 @@ export interface ImageContent {
 export type ContentPart = TextContent | ImageContent;
 export type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
 export type ReasoningEffort = ThinkingLevel;
+export type ProviderRawContentBlock = Record<string, unknown> & {
+    type: string;
+};
+export interface AssistantProviderMetadata {
+    anthropic?: {
+        contentBlocks?: ProviderRawContentBlock[];
+    };
+}
 export interface UserMessage {
     role: "user";
     content: string | ContentPart[];
@@ -23,6 +31,7 @@ export interface AssistantMessage {
     content: string;
     reasoning?: string;
     toolCalls?: ToolCall[];
+    providerMetadata?: AssistantProviderMetadata;
     /** Model metadata captured for local usage statistics. */
     model?: string;
     providerId?: string;
@@ -78,6 +87,7 @@ export interface ToolDefinition {
     description: string;
     parameters: ToolSchema;
 }
+export type ToolChoiceMode = "auto" | "none";
 export interface ToolCall {
     id: string;
     name: string;
@@ -194,6 +204,12 @@ export interface ToolContext {
 }
 export interface ToolRegistryEntry extends ToolDefinition {
     execute: ToolExecutor;
+    /** Optional one-line summary for the Available tools section. */
+    promptSnippet?: string;
+    /** Optional tool-specific rules appended to the system prompt when this tool is active. */
+    promptGuidelines?: string[];
+    /** Optional compatibility shim for provider-specific argument shapes. */
+    prepareArguments?: (args: Record<string, any>) => Record<string, any>;
     /** Whether this tool is allowed in plan mode. Defaults to false (treated as write-capable). */
     readOnly?: boolean;
     /** Capability classification used by subagent profiles. Defaults to "unknown". */
@@ -239,6 +255,10 @@ export type StreamChunk = {
 } | {
     type: "reasoning_delta";
     content: string;
+} | {
+    type: "provider_content_block";
+    provider: "anthropic";
+    block: ProviderRawContentBlock;
 } | {
     type: "tool_call";
     id: string;
@@ -259,6 +279,7 @@ export interface TokenUsage {
     completionTokens: number;
     promptCacheHitTokens?: number;
     promptCacheMissTokens?: number;
+    cacheCreationTokens?: number;
     reasoningTokens?: number;
     totalTokens?: number;
 }
@@ -266,6 +287,7 @@ export interface Provider {
     streamChat(messages: ProviderMessage[], options: {
         model: string;
         tools?: ToolDefinition[];
+        toolChoice?: ToolChoiceMode;
         temperature?: number;
         thinkingLevel?: ThinkingLevel;
         abortSignal?: AbortSignal;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bubblebrain-ai/bubble",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "description": "A terminal coding agent",
   "type": "module",
   "engines": {
@@ -33,7 +33,7 @@
     "@vue/language-server": "^3.2.7",
     "better-sqlite3": "^12.9.0",
     "chalk": "^5.3.0",
-    "diff": "^7.0.0",
+    "diff": "^9.0.0",
     "ink": "^7.0.3",
     "js-tiktoken": "^1.0.21",
     "openai": "^4.77.0",
@@ -49,12 +49,16 @@
     "vscode-langservers-extracted": "^4.10.0"
   },
   "devDependencies": {
-    "@types/diff": "^7.0.0",
     "@types/node": "^22.0.0",
     "@types/picomatch": "^4.0.3",
     "@types/qrcode-terminal": "^0.12.2",
     "@vitest/coverage-v8": "^4.1.4",
     "typescript": "^5.7.0",
     "vitest": "^4.1.4"
+  },
+  "overrides": {
+    "axios": "^1.17.0",
+    "postcss": "^8.5.15",
+    "ws": "^8.21.0"
   }
 }

package/dist/tools/apply-patch.d.ts

@@ -1,9 +0,0 @@
-import type { ApprovalController } from "../approval/types.js";
-import { type LspService } from "../lsp/index.js";
-import type { ToolRegistryEntry } from "../types.js";
-import { type FileStateTracker } from "./file-state.js";
-export interface ApplyPatchArgs {
-    patch?: string;
-    patchText?: string;
-}
-export declare function createApplyPatchTool(cwd: string, approval?: ApprovalController, lsp?: LspService, fileState?: FileStateTracker): ToolRegistryEntry;

package/dist/tools/apply-patch.js

@@ -1,330 +0,0 @@
-import { constants } from "node:fs";
-import { access, mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
-import { createTwoFilesPatch } from "diff";
-import { gateToolAction } from "../approval/tool-helper.js";
-import { countUnifiedDiffChanges } from "../diff-stats.js";
-import { formatDiagnosticBlocks } from "../lsp/index.js";
-import { isWithinWorkspace } from "./file-state.js";
-import { withFileMutationQueues } from "./file-mutation-queue.js";
-import { resolveToolPath } from "./path-utils.js";
-import { applyPatchChunks, buildAddedFileContent, parseApplyPatch, PatchApplyError, } from "./patch-apply.js";
-export function createApplyPatchTool(cwd, approval, lsp, fileState) {
-    return {
-        name: "apply_patch",
-        effect: "write_patch",
-        requiresApproval: true,
-        description: "Apply a structured patch for multi-file or larger changes. Use edit for small targeted replacements, write for full-file generation, and apply_patch for related adds/updates/deletes/moves.",
-        parameters: {
-            type: "object",
-            properties: {
-                patch: {
-                    type: "string",
-                    description: "Patch text using *** Begin Patch / *** Add File / *** Update File / *** Delete File / *** End Patch markers.",
-                },
-                patchText: {
-                    type: "string",
-                    description: "Alias for patch; accepted for compatibility with other coding agents.",
-                },
-            },
-        },
-        async execute(args) {
-            const patchText = typeof args.patch === "string"
-                ? args.patch
-                : typeof args.patchText === "string"
-                    ? args.patchText
-                    : "";
-            if (!patchText.trim()) {
-                return {
-                    content: "Error: apply_patch requires a non-empty patch string.",
-                    isError: true,
-                    status: "blocked",
-                };
-            }
-            let operations;
-            try {
-                operations = parseApplyPatch(patchText).operations;
-            }
-            catch (err) {
-                if (err instanceof PatchApplyError) {
-                    return { content: err.message, isError: true, status: err.status };
-                }
-                throw err;
-            }
-            const lockPaths = collectOperationPaths(cwd, operations);
-            return withFileMutationQueues(lockPaths, async () => {
-                let plan;
-                try {
-                    plan = await buildPatchPlan(cwd, operations);
-                }
-                catch (err) {
-                    if (err instanceof PatchApplyError) {
-                        return { content: err.message, isError: true, status: err.status };
-                    }
-                    throw err;
-                }
-                const gate = await gateToolAction(approval, {
-                    type: "patch",
-                    path: summarizePaths(plan.paths),
-                    paths: plan.paths,
-                    files: plan.changes.map((change) => ({ path: change.path, kind: change.kind })),
-                    diff: plan.diff,
-                });
-                if (!gate.approved)
-                    return gate.result;
-                const stale = await checkPlanFresh(plan);
-                if (stale)
-                    return stale;
-                try {
-                    await writePatchPlan(plan);
-                }
-                catch (err) {
-                    await rollbackPatchPlan(plan).catch(() => undefined);
-                    return {
-                        content: `Error: apply_patch failed while writing files: ${err instanceof Error ? err.message : String(err)}`,
-                        isError: true,
-                        status: "partial",
-                        metadata: {
-                            kind: "patch",
-                            paths: plan.paths,
-                            diff: plan.diff,
-                        },
-                    };
-                }
-                await observePatchPlan(fileState, plan);
-                let output = `Applied patch to ${plan.changes.length} file${plan.changes.length === 1 ? "" : "s"}.`;
-                if (plan.fallbackCount > 0) {
-                    output += ` ${plan.fallbackCount} hunk${plan.fallbackCount === 1 ? "" : "s"} used normalized matching.`;
-                }
-                if (lsp) {
-                    for (const change of plan.changes) {
-                        if (change.newContent === undefined)
-                            continue;
-                        try {
-                            await lsp.touchFile(change.path, "document");
-                            output += formatDiagnosticBlocks(cwd, change.path, lsp.diagnostics());
-                        }
-                        catch {
-                            // LSP diagnostics should not turn a successful patch into a failed tool call.
-                        }
-                    }
-                }
-                const totals = plan.changes.reduce((acc, change) => ({
-                    added: acc.added + change.addedLines,
-                    removed: acc.removed + change.removedLines,
-                }), { added: 0, removed: 0 });
-                return {
-                    content: output,
-                    status: "success",
-                    metadata: {
-                        kind: "patch",
-                        paths: plan.paths,
-                        diff: plan.diff,
-                        addedLines: totals.added,
-                        removedLines: totals.removed,
-                    },
-                };
-            });
-        },
-    };
-}
-async function buildPatchPlan(cwd, operations) {
-    const states = new Map();
-    let fallbackCount = 0;
-    const stateFor = async (path) => {
-        const absolutePath = resolveToolPath(cwd, path);
-        assertWorkspacePath(cwd, absolutePath);
-        const existing = states.get(absolutePath);
-        if (existing)
-            return existing;
-        const originalContent = await readExistingFile(absolutePath);
-        const state = {
-            path: absolutePath,
-            originalContent,
-            currentContent: originalContent,
-        };
-        states.set(absolutePath, state);
-        return state;
-    };
-    for (const operation of operations) {
-        if (operation.type === "add") {
-            const state = await stateFor(operation.path);
-            if (state.currentContent !== undefined) {
-                throw new PatchApplyError(`Error: Cannot add ${operation.path}; file already exists.`, "blocked");
-            }
-            state.currentContent = buildAddedFileContent(operation.lines);
-            continue;
-        }
-        if (operation.type === "delete") {
-            const state = await stateFor(operation.path);
-            if (state.currentContent === undefined) {
-                throw new PatchApplyError(`Error: Cannot delete ${operation.path}; file does not exist.`, "blocked");
-            }
-            state.currentContent = undefined;
-            continue;
-        }
-        const source = await stateFor(operation.path);
-        if (source.currentContent === undefined) {
-            throw new PatchApplyError(`Error: Cannot update ${operation.path}; file does not exist.`, "blocked");
-        }
-        let nextContent = source.currentContent;
-        if (operation.chunks.length > 0) {
-            const patched = applyPatchChunks(source.currentContent, operation.chunks, operation.path);
-            nextContent = patched.content;
-            if (patched.usedFallback)
-                fallbackCount++;
-        }
-        if (operation.movePath) {
-            const target = await stateFor(operation.movePath);
-            if (target.path === source.path) {
-                throw new PatchApplyError(`Error: Cannot move ${operation.path} to itself.`, "blocked");
-            }
-            if (target.currentContent !== undefined) {
-                throw new PatchApplyError(`Error: Cannot move ${operation.path} to ${operation.movePath}; target already exists.`, "blocked");
-            }
-            source.currentContent = undefined;
-            target.currentContent = nextContent;
-        }
-        else {
-            source.currentContent = nextContent;
-        }
-    }
-    const changes = [...states.values()]
-        .filter((state) => state.originalContent !== state.currentContent)
-        .map((state) => fileStateToChange(state));
-    if (changes.length === 0) {
-        throw new PatchApplyError("Error: Patch produced no file changes.", "blocked");
-    }
-    const diff = changes.map((change) => change.diff).join("\n");
-    return {
-        changes,
-        diff,
-        paths: changes.map((change) => change.path),
-        fallbackCount,
-    };
-}
-function fileStateToChange(state) {
-    const oldContent = state.originalContent;
-    const newContent = state.currentContent;
-    const kind = oldContent === undefined
-        ? "add"
-        : newContent === undefined
-            ? "delete"
-            : "update";
-    const diff = createTwoFilesPatch(state.path, state.path, oldContent ?? "", newContent ?? "", "original", "modified", { context: 3 });
-    const stats = countUnifiedDiffChanges(diff);
-    return {
-        path: state.path,
-        kind,
-        oldContent,
-        newContent,
-        diff,
-        addedLines: stats.added,
-        removedLines: stats.removed,
-    };
-}
-async function readExistingFile(path) {
-    try {
-        const info = await stat(path);
-        if (info.isDirectory()) {
-            throw new PatchApplyError(`Error: Cannot patch directory: ${path}`, "blocked");
-        }
-        await access(path, constants.R_OK | constants.W_OK);
-        return await readFile(path, "utf-8");
-    }
-    catch (err) {
-        if (err instanceof PatchApplyError)
-            throw err;
-        if (isMissingPathError(err))
-            return undefined;
-        throw new PatchApplyError(`Error: Cannot read/write file for patch: ${path}`, "blocked");
-    }
-}
-async function checkPlanFresh(plan) {
-    for (const change of plan.changes) {
-        let current;
-        try {
-            current = await readExistingFile(change.path);
-        }
-        catch (err) {
-            if (err instanceof PatchApplyError) {
-                return { content: err.message, isError: true, status: err.status };
-            }
-            throw err;
-        }
-        if (current !== change.oldContent) {
-            return {
-                content: `Error: Cannot safely apply patch because ${change.path} changed after the patch was prepared.\n\n`
-                    + "Re-read the affected file and regenerate the patch against the latest content.",
-                isError: true,
-                status: "blocked",
-                metadata: {
-                    kind: "patch",
-                    path: change.path,
-                    paths: plan.paths,
-                    reason: "changed",
-                },
-            };
-        }
-    }
-    return undefined;
-}
-async function writePatchPlan(plan) {
-    for (const change of plan.changes) {
-        if (change.newContent === undefined)
-            continue;
-        await mkdir(dirname(change.path), { recursive: true });
-        await writeFile(change.path, change.newContent, "utf-8");
-    }
-    for (const change of plan.changes) {
-        if (change.newContent !== undefined)
-            continue;
-        await rm(change.path, { force: true });
-    }
-}
-async function rollbackPatchPlan(plan) {
-    for (const change of [...plan.changes].reverse()) {
-        if (change.oldContent === undefined) {
-            await rm(change.path, { force: true });
-        }
-        else {
-            await mkdir(dirname(change.path), { recursive: true });
-            await writeFile(change.path, change.oldContent, "utf-8");
-        }
-    }
-}
-async function observePatchPlan(fileState, plan) {
-    if (!fileState)
-        return;
-    await Promise.all(plan.changes.map(async (change) => {
-        if (change.newContent === undefined)
-            return;
-        await fileState.observe(change.path, "edit", change.newContent).catch(() => undefined);
-    }));
-}
-function collectOperationPaths(cwd, operations) {
-    const paths = [];
-    for (const operation of operations) {
-        paths.push(resolveToolPath(cwd, operation.path));
-        if (operation.type === "update" && operation.movePath) {
-            paths.push(resolveToolPath(cwd, operation.movePath));
-        }
-    }
-    return paths;
-}
-function assertWorkspacePath(cwd, filePath) {
-    if (!isWithinWorkspace(cwd, filePath)) {
-        throw new PatchApplyError(`Error: Patch path is outside the workspace: ${filePath}`, "blocked");
-    }
-}
-function summarizePaths(paths) {
-    if (paths.length === 1)
-        return paths[0];
-    return `${paths[0]} (+${paths.length - 1} more)`;
-}
-function isMissingPathError(error) {
-    return (typeof error === "object"
-        && error !== null
-        && "code" in error
-        && (error.code === "ENOENT" || error.code === "ENOTDIR"));
-}

package/dist/tools/patch-apply.d.ts

@@ -1,41 +0,0 @@
-export type PatchFileOperation = {
-    type: "add";
-    path: string;
-    lines: string[];
-} | {
-    type: "delete";
-    path: string;
-} | {
-    type: "update";
-    path: string;
-    movePath?: string;
-    chunks: PatchChunk[];
-};
-export interface PatchChunk {
-    header: string;
-    lines: PatchLine[];
-}
-export type PatchLine = {
-    kind: "context";
-    text: string;
-} | {
-    kind: "remove";
-    text: string;
-} | {
-    kind: "add";
-    text: string;
-};
-export interface ParsedApplyPatch {
-    operations: PatchFileOperation[];
-}
-export interface PatchedContentResult {
-    content: string;
-    usedFallback: boolean;
-}
-export declare class PatchApplyError extends Error {
-    readonly status: "no_match" | "blocked";
-    constructor(message: string, status?: "no_match" | "blocked");
-}
-export declare function parseApplyPatch(patchText: string): ParsedApplyPatch;
-export declare function buildAddedFileContent(lines: string[]): string;
-export declare function applyPatchChunks(rawContent: string, chunks: PatchChunk[], path: string): PatchedContentResult;