@bubblebrain-ai/bubble 0.0.17 → 0.0.19

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;

package/dist/tools/patch-apply.js

@@ -1,312 +0,0 @@
-export class PatchApplyError extends Error {
-    status;
-    constructor(message, status = "no_match") {
-        super(message);
-        this.status = status;
-        this.name = "PatchApplyError";
-    }
-}
-const CHANGE_MARKERS = [
-    "*** Add File: ",
-    "*** Delete File: ",
-    "*** Update File: ",
-    "*** End Patch",
-];
-export function parseApplyPatch(patchText) {
-    const lines = normalizeToLF(patchText).split("\n");
-    if (lines[lines.length - 1] === "")
-        lines.pop();
-    if (lines[0] !== "*** Begin Patch") {
-        throw new PatchApplyError("Error: apply_patch must start with *** Begin Patch", "blocked");
-    }
-    const operations = [];
-    let index = 1;
-    while (index < lines.length) {
-        const line = lines[index];
-        if (line === "*** End Patch") {
-            if (index !== lines.length - 1) {
-                throw new PatchApplyError("Error: Unexpected content after *** End Patch", "blocked");
-            }
-            if (operations.length === 0) {
-                throw new PatchApplyError("Error: apply_patch rejected an empty patch", "blocked");
-            }
-            return { operations };
-        }
-        if (line.startsWith("*** Add File: ")) {
-            const path = parseMarkerPath(line, "*** Add File: ");
-            index++;
-            const addLines = [];
-            while (index < lines.length && !isFileMarker(lines[index])) {
-                const current = lines[index];
-                if (!current.startsWith("+")) {
-                    throw new PatchApplyError(`Error: Add File ${path} contains a non-added line: ${current}`, "blocked");
-                }
-                addLines.push(current.slice(1));
-                index++;
-            }
-            operations.push({ type: "add", path, lines: addLines });
-            continue;
-        }
-        if (line.startsWith("*** Delete File: ")) {
-            const path = parseMarkerPath(line, "*** Delete File: ");
-            operations.push({ type: "delete", path });
-            index++;
-            continue;
-        }
-        if (line.startsWith("*** Update File: ")) {
-            const path = parseMarkerPath(line, "*** Update File: ");
-            index++;
-            let movePath;
-            const chunks = [];
-            while (index < lines.length && !isFileMarker(lines[index])) {
-                const current = lines[index];
-                if (current.startsWith("*** Move to: ")) {
-                    if (movePath || chunks.length > 0) {
-                        throw new PatchApplyError(`Error: Move marker for ${path} must appear before update chunks`, "blocked");
-                    }
-                    movePath = parseMarkerPath(current, "*** Move to: ");
-                    index++;
-                    continue;
-                }
-                if (!current.startsWith("@@")) {
-                    throw new PatchApplyError(`Error: Update File ${path} expected @@ hunk header, got: ${current}`, "blocked");
-                }
-                const header = current;
-                index++;
-                const chunkLines = [];
-                while (index < lines.length && !isFileMarker(lines[index]) && !lines[index].startsWith("@@")) {
-                    const patchLine = lines[index];
-                    if (patchLine.startsWith("\")) {
-                        index++;
-                        continue;
-                    }
-                    const prefix = patchLine[0];
-                    const text = patchLine.slice(1);
-                    if (prefix === " ") {
-                        chunkLines.push({ kind: "context", text });
-                    }
-                    else if (prefix === "-") {
-                        chunkLines.push({ kind: "remove", text });
-                    }
-                    else if (prefix === "+") {
-                        chunkLines.push({ kind: "add", text });
-                    }
-                    else {
-                        throw new PatchApplyError(`Error: Hunk for ${path} contains invalid line: ${patchLine}`, "blocked");
-                    }
-                    index++;
-                }
-                if (chunkLines.length === 0) {
-                    throw new PatchApplyError(`Error: Empty hunk in ${path}`, "blocked");
-                }
-                chunks.push({ header, lines: chunkLines });
-            }
-            if (!movePath && chunks.length === 0) {
-                throw new PatchApplyError(`Error: Update File ${path} has no hunks`, "blocked");
-            }
-            operations.push({ type: "update", path, ...(movePath ? { movePath } : {}), chunks });
-            continue;
-        }
-        throw new PatchApplyError(`Error: Unexpected patch marker: ${line}`, "blocked");
-    }
-    throw new PatchApplyError("Error: apply_patch must end with *** End Patch", "blocked");
-}
-export function buildAddedFileContent(lines) {
-    if (lines.length === 0)
-        return "";
-    return `${lines.join("\n")}\n`;
-}
-export function applyPatchChunks(rawContent, chunks, path) {
-    const { bom, text } = stripBom(rawContent);
-    const lineEnding = detectLineEnding(text);
-    let normalized = normalizeToLF(text);
-    let usedFallback = false;
-    for (let index = 0; index < chunks.length; index++) {
-        const result = applyChunk(normalized, chunks[index], path, index);
-        normalized = result.content;
-        usedFallback ||= result.usedFallback;
-    }
-    return {
-        content: bom + restoreLineEndings(normalized, lineEnding),
-        usedFallback,
-    };
-}
-function applyChunk(content, chunk, path, chunkIndex) {
-    const oldLines = chunk.lines
-        .filter((line) => line.kind === "context" || line.kind === "remove")
-        .map((line) => line.text);
-    const newLines = chunk.lines
-        .filter((line) => line.kind === "context" || line.kind === "add")
-        .map((line) => line.text);
-    if (oldLines.length === 0) {
-        throw new PatchApplyError(`Error: Hunk ${chunkIndex + 1} in ${path} has no context to locate an insertion.`, "blocked");
-    }
-    const exactMatches = findExactLineBlockMatches(content, oldLines);
-    if (exactMatches.length === 1) {
-        return {
-            content: replaceSpan(content, exactMatches[0], newLines),
-            usedFallback: false,
-        };
-    }
-    if (exactMatches.length > 1) {
-        throw new PatchApplyError(`Error: Hunk ${chunkIndex + 1} in ${path} matched ${exactMatches.length} exact locations. Add more context.`, "blocked");
-    }
-    const fallbackMatches = findNormalizedLineBlockMatches(content, oldLines, path);
-    if (fallbackMatches.length === 1) {
-        return {
-            content: replaceSpan(content, fallbackMatches[0], newLines),
-            usedFallback: true,
-        };
-    }
-    if (fallbackMatches.length > 1) {
-        throw new PatchApplyError(`Error: Hunk ${chunkIndex + 1} in ${path} matched ${fallbackMatches.length} normalized locations. Add more context.`, "blocked");
-    }
-    throw new PatchApplyError(`Error: Hunk ${chunkIndex + 1} in ${path} did not match the file. Re-read the file and regenerate the patch.`);
-}
-function parseMarkerPath(line, marker) {
-    const path = line.slice(marker.length).trim();
-    if (!path)
-        throw new PatchApplyError(`Error: Patch marker is missing a path: ${line}`, "blocked");
-    return path;
-}
-function isFileMarker(line) {
-    return CHANGE_MARKERS.some((marker) => line === marker || line.startsWith(marker));
-}
-function detectLineEnding(content) {
-    const crlf = content.indexOf("\r\n");
-    const lf = content.indexOf("\n");
-    return crlf !== -1 && crlf === lf - 1 ? "\r\n" : "\n";
-}
-function stripBom(content) {
-    return content.startsWith("\uFEFF") ? { bom: "\uFEFF", text: content.slice(1) } : { bom: "", text: content };
-}
-function normalizeToLF(text) {
-    return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-}
-function restoreLineEndings(text, lineEnding) {
-    return lineEnding === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
-}
-function splitLines(content) {
-    const lines = [];
-    let start = 0;
-    for (let index = 0; index < content.length; index++) {
-        if (content[index] === "\n") {
-            lines.push({ text: content.slice(start, index), start, endNoNewline: index });
-            start = index + 1;
-        }
-    }
-    lines.push({ text: content.slice(start), start, endNoNewline: content.length });
-    return lines;
-}
-function findExactLineBlockMatches(content, oldLines) {
-    const lines = splitLines(content);
-    const matches = [];
-    for (let index = 0; index <= lines.length - oldLines.length; index++) {
-        let matched = true;
-        for (let offset = 0; offset < oldLines.length; offset++) {
-            if (lines[index + offset].text !== oldLines[offset]) {
-                matched = false;
-                break;
-            }
-        }
-        if (matched) {
-            matches.push({
-                start: lines[index].start,
-                end: lines[index + oldLines.length - 1].endNoNewline,
-            });
-        }
-    }
-    return matches;
-}
-function findNormalizedLineBlockMatches(content, oldLines, path) {
-    const expected = oldLines
-        .map((line) => normalizeLineForMatch(line))
-        .filter((line) => line.trim().length > 0);
-    if (expected.length === 0)
-        return [];
-    const contentLines = splitLines(content)
-        .map((line) => ({ line, normalized: normalizeLineForMatch(line.text) }))
-        .filter((item) => item.normalized.trim().length > 0);
-    const matches = [];
-    for (let index = 0; index <= contentLines.length - expected.length; index++) {
-        let matched = true;
-        for (let offset = 0; offset < expected.length; offset++) {
-            if (!lineEquivalent(contentLines[index + offset].line.text, expected[offset], path, expected.length)) {
-                matched = false;
-                break;
-            }
-        }
-        if (matched) {
-            matches.push({
-                start: contentLines[index].line.start,
-                end: contentLines[index + expected.length - 1].line.endNoNewline,
-            });
-        }
-    }
-    return matches;
-}
-function normalizeLineForMatch(line) {
-    return line
-        .normalize("NFKC")
-        .trimEnd()
-        .replace(/[\u2018\u2019\u201A\u201B]/g, "'")
-        .replace(/[\u201C\u201D\u201E\u201F]/g, '"')
-        .replace(/[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]/g, "-")
-        .replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " ");
-}
-function lineEquivalent(actual, expectedNormalized, path, expectedLineCount) {
-    const actualNormalized = normalizeLineForMatch(actual);
-    if (actualNormalized === expectedNormalized)
-        return true;
-    const actualCells = splitMarkdownTableCells(actualNormalized);
-    const expectedCells = splitMarkdownTableCells(expectedNormalized);
-    if (actualCells && expectedCells && sameCells(actualCells, expectedCells))
-        return true;
-    if (expectedLineCount === 1 && isDocumentLikePath(path)) {
-        return collapseInlineWhitespace(actualNormalized) === collapseInlineWhitespace(expectedNormalized);
-    }
-    return false;
-}
-function splitMarkdownTableCells(line) {
-    const normalized = 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 collapseInlineWhitespace(text) {
-    return text.trim().replace(/[ \t]+/g, " ");
-}
-function isDocumentLikePath(path) {
-    return /\.(?:md|mdx|markdown|txt|rst|adoc)$/i.test(path);
-}
-function replaceSpan(content, span, newLines) {
-    return content.slice(0, span.start) + newLines.join("\n") + content.slice(span.end);
-}