@bubblebrain-ai/bubble 0.0.4 → 0.0.6

package/dist/tools/write.js

@@ -1,84 +1,165 @@
 /**
- * Write tool - create or overwrite files.
+ * Write tool - create files or safely replace full file contents.
  */
-import { constants } from "node:fs";
-import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { createTwoFilesPatch } from "diff";
 import { gateToolAction } from "../approval/tool-helper.js";
 import { formatDiagnosticBlocks } from "../lsp/index.js";
-export function createWriteTool(cwd, options = {}, approval, lsp) {
+import { isWithinWorkspace } from "./file-state.js";
+import { withFileMutationQueue } from "./file-mutation-queue.js";
+export function createWriteTool(cwd, options = {}, approval, lsp, fileState) {
     return {
         name: "write",
-        description: `Write a file to disk. Creates parent directories if needed.${options.refuseOverwrite ? " Will not overwrite existing files." : ""}`,
+        effect: "write_direct",
+        requiresApproval: true,
+        description: "Write a file to disk. Creates parent directories if needed. For an existing file, use overwrite=true only for full-file replacement after the file has been read or modified in this session; use edit for small targeted changes.",
         parameters: {
             type: "object",
             properties: {
                 path: { type: "string", description: "Path to the file (relative or absolute)" },
                 content: { type: "string", description: "File contents" },
+                overwrite: {
+                    type: "boolean",
+                    description: "Set true only for full-file replacement of an existing file. Existing files must have been read or modified in this session.",
+                },
             },
             required: ["path", "content"],
         },
         async execute(args) {
             const filePath = resolve(cwd, args.path);
-            if (options.refuseOverwrite) {
+            const overwrite = args.overwrite === true;
+            if (!isWithinWorkspace(cwd, filePath)) {
+                return {
+                    content: `Error: Write path is outside the workspace: ${filePath}`,
+                    isError: true,
+                    status: "blocked",
+                    metadata: {
+                        kind: "security",
+                        path: filePath,
+                        reason: "Write path is outside the workspace.",
+                    },
+                };
+            }
+            return withFileMutationQueue(filePath, async () => {
+                let existed = false;
+                let oldContent = "";
                 try {
-                    await access(filePath, constants.F_OK);
+                    oldContent = await readFile(filePath, "utf-8");
+                    existed = true;
+                }
+                catch {
+                    // New file.
+                }
+                if (existed && options.refuseOverwrite && !overwrite) {
                     return {
-                        content: `Error: File already exists: ${filePath}. Use edit tool to modify existing files.`,
+                        content: `Error: File already exists: ${filePath}.\n\n`
+                            + "For small targeted changes, use edit.\n"
+                            + "For a full-file replacement, call write again with overwrite=true. Existing files must be read or modified in this session before they can be safely overwritten.\n"
+                            + "Do not delete and recreate the file just to overwrite it.",
                         isError: true,
                     };
                 }
-                catch {
-                    // file doesn't exist, proceed
+                if (existed && overwrite && options.refuseOverwrite) {
+                    if (!fileState) {
+                        return {
+                            content: `Error: Cannot safely overwrite ${filePath} because file-state tracking is unavailable. `
+                                + "Read the file first in this agent session, then retry the full-file replacement.",
+                            isError: true,
+                            status: "blocked",
+                        };
+                    }
+                    const freshness = await fileState.checkFresh(filePath);
+                    if (!freshness.ok) {
+                        return staleOverwriteResult(filePath, freshness.reason);
+                    }
                 }
-            }
-            let existed = false;
-            let oldContent = "";
-            try {
-                oldContent = await readFile(filePath, "utf-8");
-                existed = true;
-            }
-            catch {
-                // new file
-            }
-            const diff = createTwoFilesPatch(filePath, filePath, oldContent, args.content, "original", "modified", { context: 3 });
-            const gate = await gateToolAction(approval, {
-                type: "write",
-                path: filePath,
-                content: args.content,
-                diff,
-                fileExists: existed,
-            });
-            if (!gate.approved)
-                return gate.result;
-            try {
-                await mkdir(dirname(filePath), { recursive: true });
-                await writeFile(filePath, args.content, "utf-8");
-                const lineCount = args.content.split("\n").length;
-                const verb = existed ? "Updated" : "Wrote";
-                let content = `${verb} ${lineCount} lines to ${filePath}`;
-                if (lsp) {
-                    try {
-                        await lsp.touchFile(filePath, "document");
-                        content += formatDiagnosticBlocks(cwd, filePath, lsp.diagnostics());
+                const diff = createTwoFilesPatch(filePath, filePath, oldContent, args.content, "original", "modified", { context: 3 });
+                const gate = await gateToolAction(approval, {
+                    type: "write",
+                    path: filePath,
+                    content: args.content,
+                    diff,
+                    fileExists: existed,
+                });
+                if (!gate.approved)
+                    return gate.result;
+                if (existed && overwrite && options.refuseOverwrite && fileState) {
+                    const freshness = await fileState.checkFresh(filePath);
+                    if (!freshness.ok) {
+                        return staleOverwriteResult(filePath, freshness.reason);
                     }
-                    catch {
-                        // LSP diagnostics should not turn a successful write into a failed tool call.
+                }
+                try {
+                    await mkdir(dirname(filePath), { recursive: true });
+                    await writeFile(filePath, args.content, "utf-8");
+                    await fileState?.observe(filePath, "write", args.content).catch(() => undefined);
+                    const lineCount = args.content.split("\n").length;
+                    const verb = existed ? "Updated" : "Wrote";
+                    let content = `${verb} ${lineCount} lines to ${filePath}`;
+                    if (lsp) {
+                        try {
+                            await lsp.touchFile(filePath, "document");
+                            content += formatDiagnosticBlocks(cwd, filePath, lsp.diagnostics());
+                        }
+                        catch {
+                            // LSP diagnostics should not turn a successful write into a failed tool call.
+                        }
                     }
+                    return {
+                        content,
+                        status: "success",
+                        metadata: {
+                            kind: "write",
+                            path: filePath,
+                            overwrite,
+                        },
+                    };
                 }
-                return {
-                    content,
-                    status: "success",
-                    metadata: {
-                        kind: "write",
-                        path: filePath,
-                    },
-                };
-            }
-            catch (err) {
-                return { content: `Error: ${err.message}`, isError: true };
-            }
+                catch (err) {
+                    return { content: `Error: ${err.message}`, isError: true };
+                }
+            });
+        },
+    };
+}
+function staleOverwriteResult(filePath, reason) {
+    if (reason === "unobserved") {
+        return {
+            content: `Error: Cannot safely overwrite existing file: ${filePath}.\n\n`
+                + "This file has not been read or modified in this agent session. Read it first, then retry write with overwrite=true.\n"
+                + "For small targeted changes, use edit. Do not delete and recreate the file just to overwrite it.",
+            isError: true,
+            status: "blocked",
+            metadata: {
+                kind: "security",
+                path: filePath,
+                reason,
+            },
+        };
+    }
+    if (reason === "changed") {
+        return {
+            content: `Error: Cannot safely overwrite ${filePath} because it changed since the last read/write/edit in this agent session.\n\n`
+                + "Re-read the file to pick up the latest content, then retry write with overwrite=true if a full-file replacement is still intended.",
+            isError: true,
+            status: "blocked",
+            metadata: {
+                kind: "security",
+                path: filePath,
+                reason,
+            },
+        };
+    }
+    return {
+        content: `Error: Cannot safely overwrite ${filePath} because it is missing now.\n\n`
+            + "Check the path before retrying.",
+        isError: true,
+        status: "blocked",
+        metadata: {
+            kind: "security",
+            path: filePath,
+            reason,
         },
     };
 }

package/dist/tui/display-history.d.ts

@@ -1,4 +1,4 @@
-import type { ToolResultMetadata } from "../types.js";
+import type { ToolResultMetadata, TokenUsage } from "../types.js";
 export interface CompactionMeta {
     turns: number;
     messages: number;
@@ -20,15 +20,24 @@ export interface DisplayMessage {
     syntheticKind?: "ui_compact_card";
     hiddenCount?: number;
     compactionMeta?: CompactionMeta;
+    turnStartedAt?: number;
+    turnCompletedAt?: number;
+    turnUsage?: TokenUsage;
 }
 export interface DisplayToolCall {
     id: string;
     name: string;
     args: Record<string, any>;
+    rawArguments?: string;
+    streamingArgs?: boolean;
+    /** During streaming, an approximate line count derived from `\n` escapes in rawArguments. */
+    streamingNewlineCount?: number;
     status?: "pending" | "running" | "completed" | "error";
     result?: string;
     isError?: boolean;
     metadata?: ToolResultMetadata;
+    startedAt?: number;
+    completedAt?: number;
 }
 export declare function compactDisplayMessages(messages: DisplayMessage[]): DisplayMessage[];
 export declare function truncateText(value: string, maxChars: number): string;

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);
+}