@myagentroam/agent 0.11.33 → 0.11.34

package/dist/tools/local/apply-patch-parser.js

@@ -0,0 +1,177 @@
+import { isAbsolute, resolve } from 'node:path';
+import { AgentError } from '../../error.js';
+import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
+import { sourcePreview } from '../input-diagnostics/source-preview.js';
+const beginMarker = '*** Begin Patch';
+const endMarker = '*** End Patch';
+const addHeader = '*** Add File: ';
+const updateHeader = '*** Update File: ';
+const deleteHeader = '*** Delete File: ';
+const moveHeader = '*** Move to: ';
+export function parsePatch(patch) {
+    if (typeof patch !== 'string')
+        throw new AgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Patch must be a string.');
+    if (Buffer.byteLength(patch) > TOOL_EXECUTION_LIMITS.patchMaxBytes)
+        throw new AgentError('MAR_AGENT_TOOL_OUTPUT_LIMIT', 'Patch exceeds the input byte limit.');
+    return new FreeformPatchParser(patch).parse();
+}
+class FreeformPatchParser {
+    #lines;
+    #lineOffsets = [];
+    #claimed = new Set();
+    #index = 1;
+    constructor(patch) {
+        const sourceLines = patch.split('\n');
+        let offset = 0;
+        this.#lines = sourceLines.map((line, index) => {
+            this.#lineOffsets.push(offset);
+            offset += line.length + 1;
+            return index < sourceLines.length - 1 && line.endsWith('\r') ? line.slice(0, -1) : line;
+        });
+        if (patch.endsWith('\n'))
+            this.#lines.pop();
+    }
+    parse() {
+        for (const [index, line] of this.#lines.entries()) {
+            const column = line.indexOf('\r');
+            if (column !== -1)
+                this.#fail('Patch contains unsupported bare carriage returns.', index, column);
+        }
+        this.#marker(0, beginMarker, 'first');
+        this.#marker(this.#lines.length - 1, endMarker, 'last');
+        if (this.#lines.length < 3)
+            this.#fail('Patch must contain at least one operation.', 1);
+        const changes = [];
+        while (this.#index < this.#lines.length - 1) {
+            const headerIndex = this.#index++;
+            const header = this.#lines[headerIndex];
+            if (header.startsWith(addHeader)) {
+                const path = this.#path(headerIndex, addHeader);
+                const lines = [];
+                while (this.#hasBodyLine()) {
+                    const index = this.#index++;
+                    const line = this.#lines[index];
+                    if (!line.startsWith('+'))
+                        this.#fail('Added file lines must start with +.', index);
+                    lines.push(line.slice(1));
+                }
+                changes.push({ kind: 'add', path, lines });
+            }
+            else if (header.startsWith(deleteHeader)) {
+                changes.push({ kind: 'delete', path: this.#path(headerIndex, deleteHeader) });
+            }
+            else if (header.startsWith(updateHeader)) {
+                const path = this.#path(headerIndex, updateHeader);
+                let targetPath;
+                if (this.#lines[this.#index]?.startsWith(moveHeader)) {
+                    targetPath = this.#path(this.#index++, moveHeader);
+                }
+                const hunks = [];
+                while (this.#index < this.#lines.length - 1 && this.#lines[this.#index].startsWith('@@'))
+                    hunks.push(this.#hunk());
+                if (!hunks.length && !targetPath)
+                    this.#fail('Update operations must contain hunks or move a file.', headerIndex);
+                changes.push({ kind: 'update', path, ...(targetPath ? { targetPath } : {}), hunks });
+            }
+            else {
+                this.#fail("Expected an operation header: '*** Add File: <path>', '*** Update File: <path>', or '*** Delete File: <path>'.", headerIndex, Math.max(...[addHeader, updateHeader, deleteHeader].map((prefix) => commonPrefixLength(header, prefix))));
+            }
+            if (changes.length > TOOL_EXECUTION_LIMITS.patchMaxFiles)
+                throw new AgentError('MAR_AGENT_TOOL_OUTPUT_LIMIT', 'Patch exceeds the file limit.');
+        }
+        if (!changes.some((change) => change.kind !== 'update' || change.targetPath || change.hunks.some((hunk) => !hunk.anchor)))
+            this.#fail('Patch must change or move at least one file. No additions, deletions, or moves were supplied; context-only hunks only validate existing lines. Use read to inspect a file, or supply -old/+new lines to edit it.', 1);
+        return changes;
+    }
+    #marker(index, marker, position) {
+        const line = this.#lines[index];
+        const trimmed = line.trim();
+        if (trimmed === marker || trimmed === `${marker} ***`)
+            return;
+        const leading = line.length - line.trimStart().length;
+        const expected = trimmed.startsWith(`${marker} ***`) ? `${marker} ***` : marker;
+        this.#fail(`Expected ${position} line to be '${marker}' (optional trailing ' ***').`, index, leading + commonPrefixLength(trimmed, expected));
+    }
+    #path(index, prefix) {
+        const path = this.#lines[index].slice(prefix.length);
+        if (!path || path.trim() !== path) {
+            const column = path.trimStart() !== path ? prefix.length : prefix.length + path.trimEnd().length;
+            this.#fail('Patch paths must be non-empty and unpadded.', index, column);
+        }
+        const key = isAbsolute(path) ? resolve(path) : resolve('/', path);
+        if (this.#claimed.has(key))
+            this.#fail('Patch contains duplicate or overlapping paths.', index, prefix.length);
+        this.#claimed.add(key);
+        return path;
+    }
+    #hasBodyLine() {
+        return this.#index < this.#lines.length - 1 && !this.#lines[this.#index].startsWith('*** ');
+    }
+    #hunk() {
+        const index = this.#index++;
+        const header = this.#lines[index];
+        let changeContext;
+        if (header !== '@@') {
+            if (!header.startsWith('@@ '))
+                this.#fail('Patch change context headers must use @@ or @@ <context>.', index, 2);
+            changeContext = header.slice(3);
+            if (!changeContext.trim())
+                this.#fail('Patch change context must be non-empty.', index, 3);
+        }
+        const oldLines = [];
+        const patchLines = [];
+        let addedLines = 0;
+        let deletedLines = 0;
+        while (this.#hasBodyLine() && !this.#lines[this.#index].startsWith('@@')) {
+            const lineIndex = this.#index++;
+            const line = this.#lines[lineIndex];
+            const value = line.slice(1);
+            if (line.startsWith(' ')) {
+                oldLines.push(value);
+                patchLines.push({ kind: 'context', value });
+            }
+            else if (line.startsWith('+')) {
+                patchLines.push({ kind: 'addition', value });
+                addedLines++;
+            }
+            else if (line.startsWith('-')) {
+                oldLines.push(value);
+                patchLines.push({ kind: 'deletion', value });
+                deletedLines++;
+            }
+            else
+                this.#fail('Patch hunk lines must start with space, +, or -.', lineIndex);
+        }
+        if (!oldLines.length)
+            this.#fail('Insertion hunks require context.', index);
+        return {
+            ...(changeContext === undefined ? {} : { changeContext }),
+            oldLines,
+            patchLines,
+            addedLines,
+            deletedLines,
+            anchor: !addedLines && !deletedLines
+        };
+    }
+    #fail(message, index, characterOffset = 0) {
+        const source = this.#lines[index];
+        const line = index + 1;
+        const column = characterCount(source.slice(0, characterOffset)) + 1;
+        const offset = this.#lineOffsets[index] + characterOffset;
+        const preview = sourcePreview(source, column);
+        const gutter = String(line);
+        throw new AgentError('MAR_AGENT_TOOL_INPUT_INVALID', `Patch syntax error at line ${line}, column ${column}: ${message}\n${gutter} | ${preview.text}\n${' '.repeat(gutter.length)} | ${' '.repeat(preview.caret)}^`, { details: { line, column, offset } });
+    }
+}
+function commonPrefixLength(actual, expected) {
+    let index = 0;
+    while (index < actual.length && index < expected.length && actual[index] === expected[index])
+        index++;
+    return index;
+}
+function characterCount(value) {
+    let count = 0;
+    for (const _character of value)
+        count++;
+    return count;
+}

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

@@ -0,0 +1,19 @@
+import type { ClientToolDefinition } from '../contracts.js';
+import type { ApplyPatchResult } from '../contracts.js';
+import { WorkspacePathResolver } from '../shared/path-resolver.js';
+export type { ApplyPatchFileResult, ApplyPatchResult } from '../contracts.js';
+export declare const applyPatchToolDefinition: ClientToolDefinition;
+export declare function applyPatchToolInput(input: unknown): string;
+interface PatchFileOperations {
+    rename(source: string, target: string): Promise<void>;
+    rm(path: string, options?: {
+        force?: boolean;
+        recursive?: boolean;
+    }): Promise<void>;
+}
+export declare class ApplyPatchTool {
+    #private;
+    private readonly paths;
+    constructor(paths: WorkspacePathResolver, operations?: Partial<PatchFileOperations>);
+    execute(patch: string): Promise<ApplyPatchResult>;
+}

package/dist/tools/local/apply-patch.js

@@ -0,0 +1,489 @@
+import { randomUUID } from 'node:crypto';
+import { chmod, lstat, mkdir, readFile, rename, rm, rmdir, writeFile } from 'node:fs/promises';
+import { dirname, parse, resolve } from 'node:path';
+import { TextDecoder } from 'node:util';
+import { AgentError } from '../../error.js';
+import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
+import { captureFileChange, reserveFileChangePaths } from '../result-extensions.js';
+import { parsePatch } from './apply-patch-parser.js';
+export const applyPatchToolDefinition = {
+    name: 'apply_patch',
+    allowedCallers: ['direct', 'programmatic'],
+    codeModeExposure: 'both',
+    parallelSafety: 'serial',
+    description: `Preferred for precise, reviewable local edits. Do not batch all task files merely to reduce tool calls. Group only a few tightly coupled edits whose combined patch is quick to generate and review; split broad or independent work into successive bounded patches before composing them. Submit a raw *** Begin Patch / *** End Patch patch, each marker on its own line. Surrounding marker whitespace and an optional trailing *** are accepted; incomplete markers or extra text are rejected. Add File content lines, including blank lines, must start with +. Syntax errors include line/column and a bounded excerpt of the submitted patch with a caret at the error. Supports Add File, Update File, Delete File, and Move to. Add File may replace an existing regular file, and Move to may replace an existing regular destination; duplicate operations on the same resolved path remain invalid. Update hunks accept @@ or @@ <change context>. Context-only hunks, including trailing hunks, and unchanged file sections are validated in order but are not written or reported as edits. The patch must include a change or move. Context is searched forward with Codex-style exact, whitespace-tolerant, then common Unicode punctuation-tolerant matching. Syntax and resolved paths are validated before writing, then file units are committed in order. Each file unit is atomic, and a Move keeps its source and destination atomic. On MAR_AGENT_PATCH_PARTIAL, earlier files remain applied; the error lists applied, failed, and pending paths, so retry only failed and pending paths. Existing file permissions, line endings, and final-newline state are preserved. Returns changed file paths and operations with per-file and total line counts when all units succeed. In Code Mode, the Promise resolves on success and rejects with code/message on failure; the returned envelope has data.files and data.totals, not an ok or success flag. Oversized patches are rejected without advertising defensive limits as recommended patch sizes. A first-unit MAR_AGENT_PATCH_CONFLICT applies nothing; hunk match conflicts identify the affected path and hunk so you can reread only that file before retrying.`,
+    inputMode: 'freeform',
+    outputSchema: {
+        type: 'object',
+        required: ['content', 'data'],
+        properties: {
+            content: { type: 'string' },
+            data: {
+                type: 'object',
+                required: ['files', 'totals'],
+                properties: {
+                    files: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            required: ['path', 'operation', 'addedLines', 'deletedLines'],
+                            properties: {
+                                path: { type: 'string' },
+                                targetPath: { type: 'string' },
+                                operation: { enum: ['added', 'modified', 'deleted', 'moved'] },
+                                addedLines: { type: 'number' },
+                                deletedLines: { type: 'number' }
+                            }
+                        }
+                    },
+                    totals: {
+                        type: 'object',
+                        required: ['files', 'addedLines', 'deletedLines'],
+                        properties: {
+                            files: { type: 'number' },
+                            addedLines: { type: 'number' },
+                            deletedLines: { type: 'number' }
+                        }
+                    }
+                }
+            }
+        }
+    },
+    inputSchema: {
+        type: 'object',
+        properties: { patch: { type: 'string' } },
+        required: ['patch'],
+        additionalProperties: false
+    }
+};
+export function applyPatchToolInput(input) {
+    const patch = typeof input === 'string' ? input : input?.patch;
+    if (typeof patch !== 'string')
+        throw new AgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Patch is required.');
+    return patch;
+}
+const defaultFileOperations = { rename, rm };
+const utf8Decoder = new TextDecoder('utf-8', { fatal: true });
+export class ApplyPatchTool {
+    paths;
+    #fileOperations;
+    constructor(paths, operations = {}) {
+        this.paths = paths;
+        this.#fileOperations = { ...defaultFileOperations, ...operations };
+    }
+    async execute(patch) {
+        const changes = parsePatch(patch);
+        reserveFileChangePaths(changes.flatMap((change) => change.kind === 'update' && change.targetPath
+            ? [change.path, change.targetPath]
+            : [change.path]));
+        const resolvedChanges = await this.#resolveChanges(changes);
+        const results = [];
+        let totalBytes = 0;
+        const pendingChanges = [];
+        for (const resolvedChange of resolvedChanges) {
+            if (resolvedChange.kind === 'update' &&
+                resolvedChange.change.hunks.every((hunk) => hunk.anchor))
+                totalBytes = (await this.#preflight(resolvedChange, totalBytes)).totalBytes;
+            else
+                pendingChanges.push(resolvedChange);
+        }
+        for (const [index, resolvedChange] of pendingChanges.entries()) {
+            try {
+                const preflight = await this.#preflight(resolvedChange, totalBytes);
+                if (preflight.mutations.length)
+                    await this.#commit(preflight.mutations);
+                if (preflight.result)
+                    results.push(preflight.result);
+                totalBytes = preflight.totalBytes;
+            }
+            catch (error) {
+                if (!results.length ||
+                    (error instanceof AgentError && error.code === 'MAR_AGENT_PATCH_ROLLBACK_FAILED'))
+                    throw error;
+                throw partialPatchError(error, results, pendingChanges.slice(index));
+            }
+        }
+        return {
+            files: results,
+            totals: {
+                files: results.length,
+                addedLines: results.reduce((total, file) => total + file.addedLines, 0),
+                deletedLines: results.reduce((total, file) => total + file.deletedLines, 0)
+            }
+        };
+    }
+    async #resolveChanges(changes) {
+        const resolvedChanges = [];
+        const claimedTargets = new Set();
+        const claimTarget = (target) => {
+            const key = resolve(target);
+            if (claimedTargets.has(key))
+                invalid('Patch contains duplicate or overlapping paths.');
+            claimedTargets.add(key);
+        };
+        for (const change of changes) {
+            if (change.kind === 'add') {
+                const target = await this.paths.resolve(change.path, true, 'write');
+                claimTarget(target);
+                resolvedChanges.push({ kind: 'add', change, target });
+                continue;
+            }
+            const source = await this.paths.resolve(change.path, true, 'write');
+            claimTarget(source);
+            if (change.kind === 'delete') {
+                resolvedChanges.push({ kind: 'delete', change, source });
+                continue;
+            }
+            if (change.targetPath) {
+                const target = await this.paths.resolve(change.targetPath, true, 'write');
+                claimTarget(target);
+                resolvedChanges.push({
+                    kind: 'move',
+                    change: { ...change, targetPath: change.targetPath },
+                    source,
+                    target
+                });
+            }
+            else
+                resolvedChanges.push({ kind: 'update', change, source });
+        }
+        return resolvedChanges;
+    }
+    async #preflight(resolvedChange, currentTotalBytes) {
+        if (resolvedChange.kind === 'add') {
+            const { change } = resolvedChange;
+            const targetStat = await optionalLstat(resolvedChange.target);
+            if (targetStat && !targetStat.isFile())
+                invalid('Patch targets must be regular files.');
+            const content = Buffer.from(change.lines.length ? `${change.lines.join('\n')}\n` : '');
+            const totalBytes = enforceContentLimits(content, currentTotalBytes);
+            return {
+                mutations: [
+                    {
+                        path: change.path,
+                        target: resolvedChange.target,
+                        content,
+                        ...(targetStat ? { mode: targetStat.mode & 0o7777 } : {}),
+                        expectedExisting: targetStat !== undefined,
+                        ...(targetStat ? { original: await readBoundedFile(resolvedChange.target) } : {})
+                    }
+                ],
+                result: {
+                    path: change.path,
+                    operation: 'added',
+                    addedLines: change.lines.length,
+                    deletedLines: 0
+                },
+                totalBytes
+            };
+        }
+        const sourceStat = await lstat(resolvedChange.source);
+        if (!sourceStat.isFile())
+            invalid('Patch sources must be regular files.');
+        const original = await readBoundedFile(resolvedChange.source);
+        let totalBytes = enforceContentLimits(original, currentTotalBytes);
+        if (resolvedChange.kind === 'delete') {
+            const { change } = resolvedChange;
+            return {
+                mutations: [
+                    { path: change.path, target: resolvedChange.source, expectedExisting: true, original }
+                ],
+                result: {
+                    path: change.path,
+                    operation: 'deleted',
+                    addedLines: 0,
+                    deletedLines: logicalLineCount(original)
+                },
+                totalBytes
+            };
+        }
+        const { change } = resolvedChange;
+        const content = change.hunks.length
+            ? applyHunks(original, change.hunks, change.path)
+            : original;
+        totalBytes = enforceContentLimits(content, totalBytes);
+        const addedLines = change.hunks.reduce((sum, hunk) => sum + hunk.addedLines, 0);
+        const deletedLines = change.hunks.reduce((sum, hunk) => sum + hunk.deletedLines, 0);
+        if (resolvedChange.kind === 'update' && !addedLines && !deletedLines)
+            return { mutations: [], totalBytes };
+        if (resolvedChange.kind === 'move') {
+            const moveChange = resolvedChange.change;
+            const targetStat = await optionalLstat(resolvedChange.target);
+            if (targetStat && !targetStat.isFile())
+                invalid('Patch targets must be regular files.');
+            return {
+                mutations: [
+                    { path: change.path, target: resolvedChange.source, expectedExisting: true, original },
+                    {
+                        path: moveChange.targetPath,
+                        target: resolvedChange.target,
+                        content,
+                        mode: (targetStat ?? sourceStat).mode & 0o7777,
+                        expectedExisting: targetStat !== undefined,
+                        ...(targetStat ? { original: await readBoundedFile(resolvedChange.target) } : {})
+                    }
+                ],
+                result: {
+                    path: change.path,
+                    targetPath: moveChange.targetPath,
+                    operation: 'moved',
+                    addedLines,
+                    deletedLines
+                },
+                totalBytes
+            };
+        }
+        return {
+            mutations: [
+                {
+                    path: change.path,
+                    target: resolvedChange.source,
+                    content,
+                    mode: sourceStat.mode & 0o7777,
+                    expectedExisting: true,
+                    original
+                }
+            ],
+            result: {
+                path: change.path,
+                operation: 'modified',
+                addedLines,
+                deletedLines
+            },
+            totalBytes
+        };
+    }
+    async #commit(mutations) {
+        const staged = [];
+        const backups = [];
+        const installed = [];
+        const createdDirectories = [];
+        try {
+            for (const mutation of mutations) {
+                if (!mutation.content)
+                    continue;
+                await ensureDirectory(dirname(mutation.target), createdDirectories);
+                const temporary = `${mutation.target}.mar-patch-${randomUUID()}.tmp`;
+                await writeFile(temporary, mutation.content, { flag: 'wx' });
+                if (mutation.mode !== undefined)
+                    await chmod(temporary, mutation.mode);
+                staged.push({ ...mutation, temporary });
+            }
+            for (const mutation of mutations)
+                if ((await exists(mutation.target)) !== mutation.expectedExisting)
+                    throw new AgentError('MAR_AGENT_PATCH_CONFLICT', 'A patch target changed after preflight.');
+            for (const mutation of mutations) {
+                if (!(await exists(mutation.target)))
+                    continue;
+                const backup = `${mutation.target}.mar-patch-${randomUUID()}.bak`;
+                await this.#fileOperations.rename(mutation.target, backup);
+                backups.push({ target: mutation.target, backup });
+                if (mutation.original && !(await readBoundedFile(backup)).equals(mutation.original))
+                    throw new AgentError('MAR_AGENT_PATCH_CONFLICT', 'A patch target changed after preflight.');
+            }
+            for (const item of staged) {
+                await this.#fileOperations.rename(item.temporary, item.target);
+                installed.push(item.target);
+            }
+        }
+        catch (error) {
+            let rollbackError;
+            for (const target of installed.reverse())
+                await this.#fileOperations
+                    .rm(target, { force: true })
+                    .catch((cause) => (rollbackError ??= cause));
+            for (const item of backups.reverse())
+                await this.#fileOperations
+                    .rename(item.backup, item.target)
+                    .catch((cause) => (rollbackError ??= cause));
+            await Promise.allSettled(staged.map((item) => this.#fileOperations.rm(item.temporary, { force: true })));
+            for (const directory of createdDirectories.reverse())
+                await rmdir(directory).catch(() => undefined);
+            if (rollbackError)
+                throw new AgentError('MAR_AGENT_PATCH_ROLLBACK_FAILED', 'Patch commit failed and rollback could not restore every file.', { cause: rollbackError });
+            throw error;
+        }
+        await Promise.all(backups.map((item) => this.#fileOperations.rm(item.backup, { force: true })));
+        for (const mutation of mutations)
+            await captureFileChange(mutation.path, mutation.original, mutation.content);
+    }
+}
+function applyHunks(original, hunks, path) {
+    let text;
+    try {
+        text = utf8Decoder.decode(original);
+    }
+    catch (cause) {
+        throw new AgentError('MAR_AGENT_PATCH_CONFLICT', 'Patched files must be valid UTF-8.', {
+            cause
+        });
+    }
+    const newline = text.includes('\r\n') ? '\r\n' : '\n';
+    if (text.replaceAll('\r\n', '').includes('\r'))
+        invalid('Patched files contain mixed carriage returns.');
+    const normalized = text.replaceAll('\r\n', '\n');
+    const finalNewline = normalized.endsWith('\n');
+    let lines = (finalNewline ? normalized.slice(0, -1) : normalized).split('\n');
+    if (lines.length === 1 && lines[0] === '')
+        lines = [];
+    let searchStart = 0;
+    for (const [hunkIndex, hunk] of hunks.entries()) {
+        if (hunk.changeContext !== undefined) {
+            const contextPosition = seekSequence(lines, [hunk.changeContext], searchStart);
+            if (contextPosition === undefined)
+                throw new AgentError('MAR_AGENT_PATCH_CONFLICT', `Patch hunk ${hunkIndex + 1} could not find change context in ${path}:\n${summarizePatchLines([hunk.changeContext])}`);
+            searchStart = contextPosition + 1;
+        }
+        const position = seekSequence(lines, hunk.oldLines, searchStart);
+        if (position === undefined)
+            throw new AgentError('MAR_AGENT_PATCH_CONFLICT', `Patch hunk ${hunkIndex + 1} could not find expected lines in ${path}:\n${summarizePatchLines(hunk.oldLines)}`);
+        if (hunk.anchor) {
+            searchStart = position + hunk.oldLines.length;
+            continue;
+        }
+        const replacement = materializeHunk(lines, position, hunk.patchLines);
+        lines.splice(position, hunk.oldLines.length, ...replacement);
+        searchStart = position + replacement.length;
+    }
+    return Buffer.from(`${lines.join(newline)}${finalNewline ? newline : ''}`);
+}
+function materializeHunk(source, position, patchLines) {
+    const replacement = [];
+    let sourceOffset = 0;
+    for (const line of patchLines) {
+        if (line.kind === 'addition') {
+            replacement.push(line.value);
+            continue;
+        }
+        if (line.kind === 'context')
+            replacement.push(source[position + sourceOffset]);
+        sourceOffset++;
+    }
+    return replacement;
+}
+function seekSequence(lines, pattern, start) {
+    if (!pattern.length)
+        return start;
+    if (pattern.length > lines.length)
+        return undefined;
+    const comparators = [
+        (actual, expected) => actual === expected,
+        (actual, expected) => actual.trimEnd() === expected.trimEnd(),
+        (actual, expected) => actual.trim() === expected.trim(),
+        (actual, expected) => normalizePatchContext(actual) === normalizePatchContext(expected)
+    ];
+    for (const matches of comparators)
+        for (let position = start; position <= lines.length - pattern.length; position++)
+            if (pattern.every((line, offset) => matches(lines[position + offset], line)))
+                return position;
+    return undefined;
+}
+function normalizePatchContext(value) {
+    return [...value.trim()]
+        .map((character) => {
+        if ('‐‑‒–—―−'.includes(character))
+            return '-';
+        if ('‘’‚‛'.includes(character))
+            return "'";
+        if ('“”„‟'.includes(character))
+            return '"';
+        if ('            　'.includes(character))
+            return ' ';
+        return character;
+    })
+        .join('');
+}
+function summarizePatchLines(lines) {
+    const value = lines.join('\n');
+    return value.length <= 1_000 ? value : `${[...value].slice(0, 1_000).join('')}…`;
+}
+function logicalLineCount(content) {
+    if (!content.length)
+        return 0;
+    const text = content.toString('utf8').replaceAll('\r\n', '\n');
+    return text.endsWith('\n') ? text.slice(0, -1).split('\n').length : text.split('\n').length;
+}
+async function readBoundedFile(path) {
+    const info = await lstat(path);
+    if (info.size > TOOL_EXECUTION_LIMITS.patchMaxFileBytes)
+        throw new AgentError('MAR_AGENT_TOOL_OUTPUT_LIMIT', 'Patched file exceeds the byte limit.');
+    return readFile(path);
+}
+function enforceContentLimits(content, current) {
+    if (content.byteLength > TOOL_EXECUTION_LIMITS.patchMaxFileBytes)
+        throw new AgentError('MAR_AGENT_TOOL_OUTPUT_LIMIT', 'Patched file exceeds the byte limit.');
+    const total = current + content.byteLength;
+    if (total > TOOL_EXECUTION_LIMITS.patchMaxTotalBytes)
+        throw new AgentError('MAR_AGENT_TOOL_OUTPUT_LIMIT', 'Patch working set exceeds the byte limit.');
+    return total;
+}
+function partialPatchError(cause, appliedResults, pendingChanges) {
+    const appliedFiles = appliedResults.map(resultPath);
+    const failedFile = changePath(pendingChanges[0].change);
+    const pendingFiles = pendingChanges.slice(1).map(({ change }) => changePath(change));
+    return new AgentError('MAR_AGENT_PATCH_PARTIAL', `Patch partially applied. Applied: ${summarizePaths(appliedFiles)}. Failed: ${failedFile}. Pending: ${summarizePaths(pendingFiles)}. Retry only failed and pending paths.`, {
+        cause,
+        retryable: true,
+        details: {
+            appliedFiles,
+            failedFile,
+            pendingFiles,
+            files: appliedResults,
+            totals: {
+                files: appliedResults.length,
+                addedLines: appliedResults.reduce((total, file) => total + file.addedLines, 0),
+                deletedLines: appliedResults.reduce((total, file) => total + file.deletedLines, 0)
+            }
+        }
+    });
+}
+function resultPath(result) {
+    return result.targetPath === undefined ? result.path : `${result.path} -> ${result.targetPath}`;
+}
+function changePath(change) {
+    return change.kind === 'update' && change.targetPath !== undefined
+        ? `${change.path} -> ${change.targetPath}`
+        : change.path;
+}
+function summarizePaths(paths) {
+    if (!paths.length)
+        return '(none)';
+    const visible = paths.slice(0, 12);
+    const suffix = paths.length > visible.length ? `, … (${paths.length} total)` : '';
+    return `${visible.join(', ')}${suffix}`;
+}
+async function optionalLstat(path) {
+    try {
+        return await lstat(path);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+}
+async function ensureDirectory(path, created) {
+    const missing = [];
+    let current = path;
+    const root = parse(path).root;
+    while (current !== root && !(await exists(current))) {
+        missing.push(current);
+        current = dirname(current);
+    }
+    await mkdir(path, { recursive: true });
+    created.push(...missing.reverse());
+}
+async function exists(path) {
+    try {
+        await lstat(path);
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+function invalid(message) {
+    throw new AgentError('MAR_AGENT_TOOL_INPUT_INVALID', message);
+}