@bubblebrain-ai/bubble 0.0.13 → 0.0.15

package/dist/tools/edit-apply.js

@@ -17,6 +17,36 @@ function stripBom(content) {
 function normalizeToLF(text) {
     return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
 }
+function unescapeOverEscaped(text) {
+    return text
+        .replace(/\\u([0-9a-fA-F]{4})/g, (_match, hex) => String.fromCodePoint(Number.parseInt(hex, 16)))
+        .replace(/\\n/g, "\n")
+        .replace(/\\t/g, "\t")
+        .replace(/\\r/g, "\r")
+        .replace(/\\f/g, "\f")
+        .replace(/\\b/g, "\b")
+        .replace(/\\v/g, "\v")
+        .replace(/\\"/g, '"')
+        .replace(/\\\\/g, "\\");
+}
+function addTextCandidate(candidates, seen, text, mode) {
+    if (text.length === 0 || seen.has(text))
+        return;
+    seen.add(text);
+    candidates.push({ text, mode });
+}
+function generateTextCandidates(oldText) {
+    const candidates = [];
+    const seen = new Set();
+    const trimmed = oldText.trim();
+    const unescaped = normalizeToLF(unescapeOverEscaped(oldText));
+    const unescapedTrimmed = normalizeToLF(unescapeOverEscaped(trimmed));
+    addTextCandidate(candidates, seen, oldText, "exact");
+    addTextCandidate(candidates, seen, trimmed, "trimmed");
+    addTextCandidate(candidates, seen, unescaped, "unescaped");
+    addTextCandidate(candidates, seen, unescapedTrimmed, "unescaped");
+    return candidates;
+}
 function restoreLineEndings(text, lineEnding) {
     return lineEnding === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
 }
@@ -29,6 +59,9 @@ function normalizeLineForMatch(line) {
         .replace(/[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]/g, "-")
         .replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " ");
 }
+function normalizeLeadingWhitespaceForMatch(line) {
+    return normalizeLineForMatch(line).replace(/^\s+/, " ");
+}
 function findAllOccurrences(content, needle) {
     const indexes = [];
     if (needle.length === 0)
@@ -67,6 +100,10 @@ function normalizedOldNonBlankLines(oldText) {
         .map((line) => normalizeLineForMatch(line.text))
         .filter((line) => line.trim().length > 0);
 }
+function singleNonBlankOldLine(oldText) {
+    const lines = normalizedOldNonBlankLines(oldText);
+    return lines.length === 1 ? lines[0] : undefined;
+}
 function findNormalizedLineMatches(content, oldText) {
     const contentLines = splitLines(content);
     const searchable = nonBlankLines(contentLines);
@@ -90,6 +127,103 @@ function findNormalizedLineMatches(content, oldText) {
     }
     return matches;
 }
+function findSmartLineMatches(content, oldText) {
+    const contentLines = splitLines(content);
+    const oldLines = splitLines(oldText).map((line) => normalizeLeadingWhitespaceForMatch(line.text));
+    if (oldLines.length === 0 || oldLines.every((line) => line.length === 0))
+        return [];
+    const matches = [];
+    for (let i = 0; i <= contentLines.length - oldLines.length; i++) {
+        let matched = true;
+        for (let j = 0; j < oldLines.length; j++) {
+            const actual = normalizeLeadingWhitespaceForMatch(contentLines[i + j].text);
+            if (actual !== oldLines[j]) {
+                matched = false;
+                break;
+            }
+        }
+        if (matched) {
+            const first = contentLines[i];
+            const last = contentLines[i + oldLines.length - 1];
+            matches.push({ start: first.start, end: last.endNoNewline });
+        }
+    }
+    return matches;
+}
+function splitMarkdownTableCells(line) {
+    const normalized = normalizeLineForMatch(line).trim();
+    if (!normalized.startsWith("|") || !normalized.endsWith("|"))
+        return undefined;
+    const parts = [];
+    let current = "";
+    let escaped = false;
+    for (const char of normalized) {
+        if (escaped) {
+            current += char;
+            escaped = false;
+            continue;
+        }
+        if (char === "\\") {
+            current += char;
+            escaped = true;
+            continue;
+        }
+        if (char === "|") {
+            parts.push(current);
+            current = "";
+            continue;
+        }
+        current += char;
+    }
+    parts.push(current);
+    if (parts.length < 4 || parts[0] !== "" || parts[parts.length - 1] !== "")
+        return undefined;
+    const cells = parts.slice(1, -1).map((cell) => cell.trim());
+    return cells.length >= 2 ? cells : undefined;
+}
+function sameCells(a, b) {
+    return a.length === b.length && a.every((cell, index) => cell === b[index]);
+}
+function findMarkdownTableMatches(content, oldText) {
+    const oldLine = singleNonBlankOldLine(oldText);
+    if (!oldLine)
+        return [];
+    const oldCells = splitMarkdownTableCells(oldLine);
+    if (!oldCells)
+        return [];
+    const matches = [];
+    for (const line of splitLines(content)) {
+        const cells = splitMarkdownTableCells(line.text);
+        if (cells && sameCells(cells, oldCells)) {
+            matches.push({ start: line.start, end: line.endNoNewline });
+        }
+    }
+    return matches;
+}
+function collapseInlineWhitespace(text) {
+    return normalizeLineForMatch(text).trim().replace(/[ \t]+/g, " ");
+}
+function isDocumentLikePath(path) {
+    return !!path && /\.(?:md|mdx|markdown|txt|rst|adoc)$/i.test(path);
+}
+function findSingleLineWhitespaceMatches(content, oldText, options) {
+    if (!isDocumentLikePath(options?.path))
+        return [];
+    const oldLine = singleNonBlankOldLine(oldText);
+    if (!oldLine)
+        return [];
+    const normalizedOld = collapseInlineWhitespace(oldLine);
+    if (normalizedOld.length === 0)
+        return [];
+    const matches = [];
+    for (const line of splitLines(content)) {
+        const collapsed = collapseInlineWhitespace(line.text);
+        if (collapsed === normalizedOld && line.text !== oldLine) {
+            matches.push({ start: line.start, end: line.endNoNewline });
+        }
+    }
+    return matches;
+}
 function summarizeOldText(oldText) {
     const firstLine = normalizeToLF(oldText).split("\n").find((line) => line.trim().length > 0) ?? oldText;
     return firstLine.length > 80 ? `${firstLine.slice(0, 80)}...` : firstLine;
@@ -114,7 +248,7 @@ function findBestLineHint(content, oldText) {
     const startLine = contentLines[best.index].lineIndex + 1;
     return `Closest line-based candidate starts near line ${startLine} and matched ${best.score}/${oldLines.length} non-blank lines.`;
 }
-function matchEdit(content, edit, index, total) {
+function matchEdit(content, edit, index, total, options) {
     if (edit.oldText.length === 0) {
         throw new EditApplyError(total === 1 ? "Error: oldText must not be empty." : `Error: edits[${index}].oldText must not be empty.`);
     }
@@ -127,37 +261,93 @@ function matchEdit(content, edit, index, total) {
             "",
             "Common causes and how to escape:",
             "- Your tokenizer may be folding repeated characters into a single token (hex colors like '#ec489' vs '#ec4899', repeated digits, etc.). The two strings feel different in your head but serialize to identical bytes.",
-            "- Use the write tool with overwrite=true and the full new content for full-file replacements that hinge on a single repeated character or trailing digit.",
+            "- Use the write tool with the full new content for full-file replacements that hinge on a single repeated character or trailing digit.",
             "- Or re-read the file with the read tool, then copy the exact bytes you want to replace before retrying.",
         ].join("\n"));
     }
     const oldText = normalizeToLF(edit.oldText);
-    const exact = findAllOccurrences(content, oldText);
-    if (exact.length === 1) {
-        return { editIndex: index, mode: "exact", start: exact[0], end: exact[0] + oldText.length };
+    const candidates = generateTextCandidates(oldText);
+    for (const candidate of candidates) {
+        const exact = findAllOccurrences(content, candidate.text);
+        if (exact.length === 1) {
+            return { editIndex: index, mode: candidate.mode, start: exact[0], end: exact[0] + candidate.text.length };
+        }
+        if (exact.length > 1) {
+            const recovery = [
+                "",
+                "Extend oldText with more surrounding context (the lines immediately before/after) until it uniquely identifies the intended span.",
+            ].join("\n");
+            const duplicateReason = candidate.mode === "exact"
+                ? `appears ${exact.length} times in file`
+                : `matched ${exact.length} times after ${candidate.mode} matching`;
+            throw new EditApplyError(total === 1
+                ? `Error: oldText ${duplicateReason}. Must be unique: "${summarizeOldText(oldText)}"${recovery}`
+                : `Error: edits[${index}].oldText ${duplicateReason}. Must be unique: "${summarizeOldText(oldText)}"${recovery}`);
+        }
     }
-    if (exact.length > 1) {
-        const recovery = [
-            "",
-            "Extend oldText with more surrounding context (the lines immediately before/after) until it uniquely identifies the intended span.",
-        ].join("\n");
-        throw new EditApplyError(total === 1
-            ? `Error: oldText appears ${exact.length} times in file. Must be unique: "${summarizeOldText(oldText)}"${recovery}`
-            : `Error: edits[${index}].oldText appears ${exact.length} times in file. Must be unique: "${summarizeOldText(oldText)}"${recovery}`);
-    }
-    const normalizedLineMatches = findNormalizedLineMatches(content, oldText);
-    if (normalizedLineMatches.length === 1) {
-        return {
-            editIndex: index,
-            mode: "normalized-line",
-            start: normalizedLineMatches[0].start,
-            end: normalizedLineMatches[0].end,
-        };
-    }
-    if (normalizedLineMatches.length > 1) {
-        throw new EditApplyError(total === 1
-            ? `Error: oldText matched ${normalizedLineMatches.length} normalized line blocks in file. Provide more surrounding context.`
-            : `Error: edits[${index}].oldText matched ${normalizedLineMatches.length} normalized line blocks in file. Provide more surrounding context.`);
+    for (const candidate of candidates) {
+        const normalizedLineMatches = findNormalizedLineMatches(content, candidate.text);
+        if (normalizedLineMatches.length === 1) {
+            return {
+                editIndex: index,
+                mode: candidate.mode === "exact" ? "normalized-line" : candidate.mode,
+                start: normalizedLineMatches[0].start,
+                end: normalizedLineMatches[0].end,
+            };
+        }
+        if (normalizedLineMatches.length > 1) {
+            throw new EditApplyError(total === 1
+                ? `Error: oldText matched ${normalizedLineMatches.length} normalized line blocks in file. Provide more surrounding context.`
+                : `Error: edits[${index}].oldText matched ${normalizedLineMatches.length} normalized line blocks in file. Provide more surrounding context.`);
+        }
+    }
+    for (const candidate of candidates) {
+        const markdownTableMatches = findMarkdownTableMatches(content, candidate.text);
+        if (markdownTableMatches.length === 1) {
+            return {
+                editIndex: index,
+                mode: "markdown-table",
+                start: markdownTableMatches[0].start,
+                end: markdownTableMatches[0].end,
+            };
+        }
+        if (markdownTableMatches.length > 1) {
+            throw new EditApplyError(total === 1
+                ? `Error: oldText matched ${markdownTableMatches.length} markdown table rows in file. Provide more surrounding context.`
+                : `Error: edits[${index}].oldText matched ${markdownTableMatches.length} markdown table rows in file. Provide more surrounding context.`);
+        }
+    }
+    for (const candidate of candidates) {
+        const whitespaceMatches = findSingleLineWhitespaceMatches(content, candidate.text, options);
+        if (whitespaceMatches.length === 1) {
+            return {
+                editIndex: index,
+                mode: "single-line-whitespace",
+                start: whitespaceMatches[0].start,
+                end: whitespaceMatches[0].end,
+            };
+        }
+        if (whitespaceMatches.length > 1) {
+            throw new EditApplyError(total === 1
+                ? `Error: oldText matched ${whitespaceMatches.length} whitespace-normalized lines in file. Provide more surrounding context.`
+                : `Error: edits[${index}].oldText matched ${whitespaceMatches.length} whitespace-normalized lines in file. Provide more surrounding context.`);
+        }
+    }
+    for (const candidate of candidates) {
+        const smartLineMatches = findSmartLineMatches(content, candidate.text);
+        if (smartLineMatches.length === 1) {
+            return {
+                editIndex: index,
+                mode: "smart-line",
+                start: smartLineMatches[0].start,
+                end: smartLineMatches[0].end,
+            };
+        }
+        if (smartLineMatches.length > 1) {
+            throw new EditApplyError(total === 1
+                ? `Error: oldText matched ${smartLineMatches.length} indentation-normalized line blocks in file. Provide more surrounding context.`
+                : `Error: edits[${index}].oldText matched ${smartLineMatches.length} indentation-normalized line blocks in file. Provide more surrounding context.`);
+        }
     }
     const hint = findBestLineHint(content, oldText);
     const hintSuffix = hint ? `\n${hint}` : "";
@@ -166,7 +356,7 @@ function matchEdit(content, edit, index, total) {
         "How to recover:",
         "- Re-read the file with the read tool to see its current bytes; the file may have been changed by a prior edit this turn.",
         "- Shorten oldText to a smaller unique anchor and try again. Long multi-line anchors are fragile to whitespace and indentation.",
-        "- If many lines need to change, use the write tool with overwrite=true and the full new content instead of stacking edits.",
+        "- If many lines need to change, use the write tool with the full new content instead of stacking edits.",
     ].join("\n");
     throw new EditApplyError(total === 1
         ? `Error: oldText not found in file: "${summarizeOldText(oldText)}"${hintSuffix}${recovery}`
@@ -182,7 +372,7 @@ function assertNoOverlaps(matches) {
         }
     }
 }
-export function applyEditsToContent(rawContent, edits) {
+export function applyEditsToContent(rawContent, edits, options) {
     if (!Array.isArray(edits) || edits.length === 0) {
         throw new EditApplyError("Error: No edits provided");
     }
@@ -193,7 +383,7 @@ export function applyEditsToContent(rawContent, edits) {
         oldText: normalizeToLF(edit.oldText),
         newText: normalizeToLF(edit.newText),
     }));
-    const matches = normalizedEdits.map((edit, index) => matchEdit(normalizedOriginal, edit, index, normalizedEdits.length));
+    const matches = normalizedEdits.map((edit, index) => matchEdit(normalizedOriginal, edit, index, normalizedEdits.length, options));
     assertNoOverlaps(matches);
     const byDescendingStart = [...matches].sort((a, b) => b.start - a.start);
     let normalizedNext = normalizedOriginal;
@@ -208,7 +398,7 @@ export function applyEditsToContent(rawContent, edits) {
             "Common causes and how to escape:",
             "- oldText and newText are byte-identical. Verify newText actually contains the intended change (a missing trailing char like turning '#ec489' into '#ec4899' is a frequent culprit).",
             "- The file already contains newText. Re-read the file to confirm the current state before editing again.",
-            "- For wholesale rewrites, use the write tool with overwrite=true and the full new content instead.",
+            "- For wholesale rewrites, use the write tool with the full new content instead.",
         ].join("\n"));
     }
     return {

package/dist/tools/edit.js

@@ -18,7 +18,7 @@ export function createEditTool(cwd, approval, lsp, fileState) {
         name: "edit",
         effect: "write_direct",
         requiresApproval: true,
-        description: "Apply targeted string replacements to a file. Prefer exact oldText. The tool can tolerate line ending, trailing whitespace, Unicode punctuation/space, and blank-line differences only when the target is unique.",
+        description: "Apply targeted string replacements to a file. Prefer exact oldText copied from a recent read. The tool can tolerate common AI formatting mistakes such as extra leading/trailing whitespace, over-escaped sequences, line ending differences, indentation differences, trailing whitespace, Unicode punctuation/space, and blank-line differences when the target is unique.",
         parameters: {
             type: "object",
             properties: {
@@ -62,11 +62,20 @@ export function createEditTool(cwd, approval, lsp, fileState) {
                 const original = await readFile(filePath, "utf-8");
                 let applied;
                 try {
-                    applied = applyEditsToContent(original, args.edits);
+                    applied = applyEditsToContent(original, args.edits, { path: filePath });
                 }
                 catch (err) {
                     if (err instanceof EditApplyError) {
-                        return { content: err.message, isError: true, status: err.status };
+                        return {
+                            content: err.message,
+                            isError: true,
+                            status: err.status,
+                            metadata: {
+                                kind: "edit",
+                                path: filePath,
+                                reason: err.status,
+                            },
+                        };
                     }
                     throw err;
                 }

package/dist/tools/file-mutation-queue.d.ts

@@ -1 +1,2 @@
 export declare function withFileMutationQueue<T>(filePath: string, fn: () => Promise<T>): Promise<T>;
+export declare function withFileMutationQueues<T>(filePaths: string[], fn: () => Promise<T>): Promise<T>;

package/dist/tools/file-mutation-queue.js

@@ -11,7 +11,18 @@ function queueKey(filePath) {
     }
 }
 export async function withFileMutationQueue(filePath, fn) {
-    const key = queueKey(filePath);
+    return withQueueKey(queueKey(filePath), fn);
+}
+export async function withFileMutationQueues(filePaths, fn) {
+    const keys = [...new Set(filePaths.map(queueKey))].sort();
+    const run = (index) => {
+        if (index >= keys.length)
+            return fn();
+        return withQueueKey(keys[index], () => run(index + 1));
+    };
+    return run(0);
+}
+async function withQueueKey(key, fn) {
     const current = queues.get(key) ?? Promise.resolve();
     let release;
     const next = new Promise((resolveNext) => {

package/dist/tools/index.d.ts

@@ -3,8 +3,10 @@
  */
 export { createReadTool } from "./read.js";
 export { createBashTool } from "./bash.js";
+export { createManagedServerTools } from "./server.js";
 export { createWriteTool } from "./write.js";
 export { createEditTool } from "./edit.js";
+export { createApplyPatchTool } from "./apply-patch.js";
 export { createGlobTool } from "./glob.js";
 export { createGrepTool } from "./grep.js";
 export { createLspTool } from "./lsp.js";

package/dist/tools/index.js

@@ -3,8 +3,10 @@
  */
 export { createReadTool } from "./read.js";
 export { createBashTool } from "./bash.js";
+export { createManagedServerTools } from "./server.js";
 export { createWriteTool } from "./write.js";
 export { createEditTool } from "./edit.js";
+export { createApplyPatchTool } from "./apply-patch.js";
 export { createGlobTool } from "./glob.js";
 export { createGrepTool } from "./grep.js";
 export { createLspTool } from "./lsp.js";
@@ -19,7 +21,9 @@ export { createToolSearchTool } from "./tool-search.js";
 export { createQuestionTool } from "./question.js";
 export { createMemoryReadSummaryTool, createMemorySearchTool } from "./memory.js";
 import { createBashTool } from "./bash.js";
+import { createManagedServerTools } from "./server.js";
 import { createEditTool } from "./edit.js";
+import { createApplyPatchTool } from "./apply-patch.js";
 import { createExitPlanModeTool } from "./exit-plan-mode.js";
 import { createGlobTool } from "./glob.js";
 import { createGrepTool } from "./grep.js";
@@ -44,8 +48,10 @@ export function createAllTools(cwd, skillRegistry, options = {}) {
     return [
         createReadTool(cwd, approval, lsp, fileState),
         createBashTool(cwd, approval, fileState),
-        createWriteTool(cwd, { refuseOverwrite: true }, approval, lsp, fileState),
+        ...createManagedServerTools(cwd, approval),
+        createWriteTool(cwd, {}, approval, lsp, fileState),
         createEditTool(cwd, approval, lsp, fileState),
+        createApplyPatchTool(cwd, approval, lsp, fileState),
         createGlobTool(cwd),
         createGrepTool(cwd),
         createLspTool(cwd, lsp, approval),

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

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