@aexol/spectral 0.9.126 → 0.9.128

package/dist/sdk/coding-agent/core/tools/apply-patch.js

@@ -1,11 +1,12 @@
 import { constants } from "fs";
-import { access as fsAccess, mkdir as fsMkdir, readFile as fsReadFile, rm as fsRm, writeFile as fsWriteFile } from "fs/promises";
+import { access as fsAccess, mkdir as fsMkdir, readFile as fsReadFile, rm as fsRm, stat as fsStat, writeFile as fsWriteFile, } from "fs/promises";
 import { dirname } from "path";
 import { Type } from "typebox";
 import { detectLineEnding, generateDiffString, generateUnifiedPatch, normalizeForFuzzyMatch, normalizeToLF, restoreLineEndings, stripBom, } from "./edit-diff.js";
 import { withFileMutationQueue } from "./file-mutation-queue.js";
 import { resolveToCwd } from "./path-utils.js";
 import { wrapToolDefinition } from "./tool-definition-wrapper.js";
+import { atomicWriteFile, defaultAtomicWriteOperations } from "./atomic-write.js";
 const applyPatchSchema = Type.Object({
     patchText: Type.String({ description: "The full patch text that describes all changes to be made." }),
 }, { additionalProperties: false });
@@ -15,11 +16,9 @@ const defaultApplyPatchOperations = {
     removeFile: (filePath) => fsRm(filePath, { force: false }),
     mkdir: (filePath) => fsMkdir(filePath, { recursive: true }).then(() => { }),
     access: (filePath) => fsAccess(filePath, constants.R_OK | constants.W_OK),
+    stat: (filePath) => fsStat(filePath).then((s) => ({ isDirectory: s.isDirectory() })),
 };
-function stripHeredoc(input) {
-    const heredocMatch = input.match(/^(?:cat\s+)?<<['"]?(\w+)['"]?\s*\n([\s\S]*?)\n\1\s*$/);
-    return heredocMatch ? heredocMatch[2] : input;
-}
+export { defaultApplyPatchOperations };
 function parsePatchHeader(lines, startIndex) {
     const line = lines[startIndex];
     if (line.startsWith("*** Add File:")) {
@@ -46,8 +45,11 @@ function parseAddFileContent(lines, startIndex) {
     let content = "";
     let index = startIndex;
     while (index < lines.length && !lines[index].startsWith("***")) {
-        if (lines[index].startsWith("+"))
-            content += `${lines[index].slice(1)}\n`;
+        const line = lines[index];
+        if (!line.startsWith("+")) {
+            throw new Error(`Add File content line missing '+' prefix: ${line}`);
+        }
+        content += `${line.slice(1)}\n`;
         index++;
     }
     return { content: content.endsWith("\n") ? content.slice(0, -1) : content, nextIndex: index };
@@ -107,7 +109,7 @@ function parseUpdateHeader(line) {
 }
 function parsePatch(patchText) {
     const normalizedPatchText = patchText.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-    const lines = stripHeredoc(normalizedPatchText.trim()).split("\n");
+    const lines = normalizedPatchText.trim().split("\n");
     const beginIndex = lines.findIndex((line) => line.trim() === "*** Begin Patch");
     const endIndex = lines.findIndex((line) => line.trim() === "*** End Patch");
     if (beginIndex === -1 || endIndex === -1 || beginIndex >= endIndex) {
@@ -161,7 +163,38 @@ function seekSequence(lines, pattern, startIndex, eof = false) {
         (a, b) => a.trimEnd() === b.trimEnd(),
         (a, b) => a.trim() === b.trim(),
         compareNormalized,
-    ].reduce((found, compare) => found !== -1 ? found : tryMatch(lines, pattern, startIndex, compare, eof), -1);
+    ].reduce((found, compare) => (found !== -1 ? found : tryMatch(lines, pattern, startIndex, compare, eof)), -1);
+}
+/**
+ * Searches for a pattern starting from `startIndex` (forward), and if not found,
+ * falls back to a whole-file search preferring the match nearest to `startIndex`.
+ * This allows context that appears before the cursor to still resolve (A7).
+ */
+function seekSequenceBidirectional(lines, pattern, startIndex, eof = false) {
+    const forward = seekSequence(lines, pattern, startIndex, eof);
+    if (forward !== -1)
+        return forward;
+    if (pattern.length === 0)
+        return -1;
+    const comparators = [
+        (a, b) => a === b,
+        (a, b) => a.trimEnd() === b.trimEnd(),
+        (a, b) => a.trim() === b.trim(),
+        compareNormalized,
+    ];
+    for (const compare of comparators) {
+        let bestIndex = -1;
+        for (let index = 0; index <= lines.length - pattern.length; index++) {
+            if (pattern.every((line, offset) => compare(lines[index + offset], line))) {
+                if (bestIndex === -1 || Math.abs(index - startIndex) < Math.abs(bestIndex - startIndex)) {
+                    bestIndex = index;
+                }
+            }
+        }
+        if (bestIndex !== -1)
+            return bestIndex;
+    }
+    return -1;
 }
 function seekSequenceNearHint(lines, pattern, startIndex, hintLine, eof = false) {
     if (!hintLine || hintLine < 1 || pattern.length === 0)
@@ -216,7 +249,7 @@ function computeReplacements(originalLines, filePath, chunks) {
     let lineIndex = 0;
     for (const chunk of chunks) {
         if (chunk.changeContext) {
-            const contextIndex = seekSequence(originalLines, [chunk.changeContext], lineIndex);
+            const contextIndex = seekSequenceBidirectional(originalLines, [chunk.changeContext], lineIndex);
             if (contextIndex === -1)
                 throw new Error(`Failed to find context '${chunk.changeContext}' in ${filePath}.`);
             lineIndex = contextIndex + 1;
@@ -263,8 +296,112 @@ function deriveUpdatedContent(filePath, rawContent, chunks) {
         newLines.push("");
     return { bom, oldContent: normalized, newContent: newLines.join("\n"), lineEnding };
 }
+/**
+ * Groups update hunks by target path (A2). When multiple hunks target the
+ * same file, their chunks are applied sequentially to a single evolving buffer
+ * so earlier hunks' changes are not lost.
+ */
+function groupUpdateHunksByPath(hunks) {
+    const groups = new Map();
+    for (const hunk of hunks) {
+        if (hunk.type !== "update")
+            continue;
+        let group = groups.get(hunk.path);
+        if (!group) {
+            group = { path: hunk.path, hunks: [] };
+            groups.set(hunk.path, group);
+        }
+        if (hunk.movePath && !group.movePath) {
+            group.movePath = hunk.movePath;
+        }
+        group.hunks.push(hunk.chunks);
+    }
+    return groups;
+}
+/**
+ * Builds backup entries for all changes BEFORE any mutation. On rollback,
+ * entries are restored in reverse order.
+ */
+function buildBackups(changes) {
+    const backups = [];
+    for (const change of changes) {
+        switch (change.type) {
+            case "add":
+                backups.push({ absolutePath: change.absolutePath, existed: false });
+                break;
+            case "update":
+                if (change.movePath && change.absoluteMovePath) {
+                    backups.push({ absolutePath: change.absolutePath, existed: true, content: change.rawOriginalContent ?? undefined });
+                    backups.push({ absolutePath: change.absoluteMovePath, existed: false });
+                }
+                else {
+                    backups.push({ absolutePath: change.absolutePath, existed: true, content: change.rawOriginalContent ?? undefined });
+                }
+                break;
+            case "delete":
+                backups.push({ absolutePath: change.absolutePath, existed: true, content: change.rawOriginalContent ?? undefined });
+                break;
+        }
+    }
+    return backups;
+}
+async function rollbackChanges(backups, ops) {
+    for (let i = backups.length - 1; i >= 0; i--) {
+        const backup = backups[i];
+        try {
+            if (backup.existed && backup.content !== undefined) {
+                await ops.writeFile(backup.absolutePath, backup.content);
+            }
+            else if (!backup.existed) {
+                await ops.removeFile(backup.absolutePath);
+            }
+        }
+        catch {
+            // Best-effort rollback; individual failures are tolerated
+        }
+    }
+}
+/**
+ * Applies all changes transactionally (A1, A4). If any change fails, all
+ * prior mutations are rolled back so the repository returns to its original
+ * state.
+ */
+async function applyChangesTransactionally(changes, ops, atomicOps, signal) {
+    const backups = buildBackups(changes);
+    try {
+        for (const change of changes) {
+            if (signal?.aborted)
+                throw new Error("Operation aborted");
+            if (change.type === "delete") {
+                try {
+                    await ops.removeFile(change.absolutePath);
+                }
+                catch (error) {
+                    // A8: handle ENOENT gracefully (file already gone — no-op)
+                    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+                        continue;
+                    }
+                    throw error;
+                }
+            }
+            else {
+                const targetPath = change.absoluteMovePath ?? change.absolutePath;
+                await ops.mkdir(dirname(targetPath));
+                const writeFn = ops.atomicWrite ?? ((p, c) => atomicWriteFile(p, c, "utf-8", atomicOps));
+                await writeFn(targetPath, change.bom + restoreLineEndings(change.newContent, change.lineEnding));
+                if (change.movePath)
+                    await ops.removeFile(change.absolutePath);
+            }
+        }
+    }
+    catch (error) {
+        await rollbackChanges(backups, ops);
+        throw error;
+    }
+}
 export function createApplyPatchToolDefinition(cwd, options) {
     const ops = options?.operations ?? defaultApplyPatchOperations;
+    const atomicOps = defaultAtomicWriteOperations;
     return {
         name: "apply_patch",
         label: "Apply Patch",
@@ -284,6 +421,10 @@ export function createApplyPatchToolDefinition(cwd, options) {
             const hunks = parsePatch(input.patchText);
             if (hunks.length === 0)
                 throw new Error("apply_patch verification failed: no hunks found.");
+            // A2: group update hunks by path to avoid data loss from duplicate-file patches
+            const updateGroups = groupUpdateHunksByPath(hunks);
+            const processedUpdatePaths = new Set();
+            // Parse / derive phase — no mutations; failures here never partially mutate the repo
             const changes = [];
             for (const hunk of hunks) {
                 if (signal?.aborted)
@@ -302,62 +443,99 @@ export function createApplyPatchToolDefinition(cwd, options) {
                         type: "add",
                         bom,
                         lineEnding: "\n",
+                        rawOriginalContent: null,
                     });
                     continue;
                 }
-                await ops.access(absolutePath).catch((error) => {
-                    const errorMessage = error instanceof Error && "code" in error ? `Error code: ${error.code}` : String(error);
-                    throw new Error(`Could not patch file: ${hunk.path}. ${errorMessage}.`);
-                });
-                const rawContent = (await ops.readFile(absolutePath)).toString("utf-8");
                 if (hunk.type === "delete") {
-                    const { bom, text } = stripBom(rawContent);
+                    // A8: directory check
+                    if (ops.stat) {
+                        const statResult = await ops.stat(absolutePath).catch(() => null);
+                        if (statResult?.isDirectory) {
+                            throw new Error(`Cannot delete directory: ${hunk.path}`);
+                        }
+                    }
+                    // A8: no pre-access TOCTOU check; read for backup, handle missing gracefully
+                    let rawContent = null;
+                    try {
+                        rawContent = (await ops.readFile(absolutePath)).toString("utf-8");
+                    }
+                    catch {
+                        // File doesn't exist — delete is a no-op
+                    }
+                    const { bom, text } = rawContent !== null ? stripBom(rawContent) : { bom: "", text: "" };
                     changes.push({
                         path: hunk.path,
                         absolutePath,
-                        oldContent: normalizeToLF(text),
+                        oldContent: rawContent !== null ? normalizeToLF(text) : "",
                         newContent: "",
                         type: "delete",
                         bom,
-                        lineEnding: detectLineEnding(text),
+                        lineEnding: rawContent !== null ? detectLineEnding(text) : "\n",
+                        rawOriginalContent: rawContent,
                     });
                     continue;
                 }
-                const updated = deriveUpdatedContent(hunk.path, rawContent, hunk.chunks);
-                const absoluteMovePath = hunk.movePath ? resolveToCwd(hunk.movePath, cwd) : undefined;
+                // hunk.type === "update"
+                // A2: process grouped updates only once per path
+                if (processedUpdatePaths.has(hunk.path))
+                    continue;
+                processedUpdatePaths.add(hunk.path);
+                const group = updateGroups.get(hunk.path);
+                if (!group)
+                    continue;
+                let rawContent;
+                try {
+                    rawContent = (await ops.readFile(absolutePath)).toString("utf-8");
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error && "code" in error ? `Error code: ${error.code}` : String(error);
+                    throw new Error(`Could not patch file: ${hunk.path}. ${errorMessage}.`);
+                }
+                // A2: apply each hunk's chunks sequentially to the evolving buffer
+                let currentContent = rawContent;
+                let firstBom = "";
+                let firstLineEnding = "\n";
+                let firstOldContent = "";
+                for (let i = 0; i < group.hunks.length; i++) {
+                    const result = deriveUpdatedContent(hunk.path, currentContent, group.hunks[i]);
+                    if (i === 0) {
+                        firstBom = result.bom;
+                        firstLineEnding = result.lineEnding;
+                        firstOldContent = result.oldContent;
+                    }
+                    currentContent = result.newContent;
+                }
+                const absoluteMovePath = group.movePath ? resolveToCwd(group.movePath, cwd) : undefined;
                 changes.push({
                     path: hunk.path,
                     absolutePath,
-                    oldContent: updated.oldContent,
-                    newContent: updated.newContent,
+                    oldContent: firstOldContent,
+                    newContent: currentContent,
                     type: "update",
-                    movePath: hunk.movePath,
+                    movePath: group.movePath,
                     absoluteMovePath,
-                    bom: updated.bom,
-                    lineEnding: updated.lineEnding,
+                    bom: firstBom,
+                    lineEnding: firstLineEnding,
+                    rawOriginalContent: rawContent,
                 });
             }
+            // Validate before any mutations
+            for (const change of changes) {
+                if (change.oldContent === change.newContent && !change.movePath && change.type !== "delete") {
+                    throw new Error(`No changes made to ${change.path}. The patch produced identical content.`);
+                }
+            }
+            // A3: pass mutated files as array for per-file serialization
             const mutatedFiles = changes.map((change) => change.absoluteMovePath ?? change.absolutePath);
-            return withFileMutationQueue(mutatedFiles.join("\0"), async () => {
+            return withFileMutationQueue(mutatedFiles, async () => {
+                // A1: transactional apply with rollback
+                await applyChangesTransactionally(changes, ops, atomicOps, signal);
+                // Build diff output (only after successful apply)
                 let combinedDiff = "";
                 let combinedPatch = "";
                 let firstChangedLine;
                 for (const change of changes) {
-                    if (signal?.aborted)
-                        throw new Error("Operation aborted");
-                    if (change.oldContent === change.newContent && !change.movePath) {
-                        throw new Error(`No changes made to ${change.path}. The patch produced identical content.`);
-                    }
-                    if (change.type === "delete") {
-                        await ops.removeFile(change.absolutePath);
-                    }
-                    else {
-                        const targetPath = change.absoluteMovePath ?? change.absolutePath;
-                        await ops.mkdir(dirname(targetPath));
-                        await ops.writeFile(targetPath, change.bom + restoreLineEndings(change.newContent, change.lineEnding));
-                        if (change.movePath)
-                            await ops.removeFile(change.absolutePath);
-                    }
                     const displayPath = change.movePath ? `${change.path} => ${change.movePath}` : change.path;
                     const diffResult = generateDiffString(change.oldContent, change.newContent);
                     combinedDiff += `${displayPath}\n${diffResult.diff}\n`;

package/dist/sdk/coding-agent/core/tools/atomic-write.d.ts

@@ -0,0 +1,30 @@
+export type BufferEncoding = "utf-8" | "utf8" | "ascii" | "latin1" | "binary" | "ucs2" | "ucs-2" | "utf16le" | "utf-16le";
+/**
+ * Operations surface for atomic writes. Mirrors the subset of
+ * {@link WriteOperations} needed so that tests can stub the filesystem.
+ */
+export interface AtomicWriteOperations {
+    writeFile: (absolutePath: string, data: string) => Promise<void>;
+    rename: (oldPath: string, newPath: string) => Promise<void>;
+    unlink: (absolutePath: string) => Promise<void>;
+}
+declare const defaultAtomicWriteOperations: AtomicWriteOperations;
+/**
+ * Write `content` to `absolutePath` atomically by first writing to a sibling
+ * temp file in the same directory and then renaming it into place. `rename`
+ * is atomic when source and destination live on the same filesystem, which is
+ * guaranteed because the temp file is a sibling of the destination.
+ *
+ * If the temp write or rename fails, the temp file is best-effort removed so
+ * no stale partial temp file is left behind. The original file (if any) is
+ * never touched until the rename succeeds, so a failed write leaves the
+ * existing file intact.
+ *
+ * @param absolutePath Final destination file path.
+ * @param content      Text content to write.
+ * @param encoding     Encoding for the temp write (defaults to "utf-8").
+ * @param operations   Optional stub for tests; defaults to real `fs/promises`.
+ */
+export declare function atomicWriteFile(absolutePath: string, content: string, encoding?: BufferEncoding, operations?: AtomicWriteOperations): Promise<void>;
+export { defaultAtomicWriteOperations };
+//# sourceMappingURL=atomic-write.d.ts.map

package/dist/sdk/coding-agent/core/tools/atomic-write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomic-write.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/coding-agent/core/tools/atomic-write.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,cAAc,GACvB,OAAO,GACP,MAAM,GACN,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,MAAM,GACN,OAAO,GACP,SAAS,GACT,UAAU,CAAC;AAEd;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACrC,SAAS,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACjE,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5D,MAAM,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAChD;AAED,QAAA,MAAM,4BAA4B,EAAE,qBAInC,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,eAAe,CACpC,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,MAAM,EACf,QAAQ,GAAE,cAAwB,EAClC,UAAU,GAAE,qBAAoD,GAC9D,OAAO,CAAC,IAAI,CAAC,CAef;AAED,OAAO,EAAE,4BAA4B,EAAE,CAAC"}

package/dist/sdk/coding-agent/core/tools/atomic-write.js

@@ -0,0 +1,42 @@
+import { randomBytes } from "node:crypto";
+import { rename as fsRename, unlink as fsUnlink, writeFile as fsWriteFile, } from "node:fs/promises";
+import { dirname, join } from "node:path";
+const defaultAtomicWriteOperations = {
+    writeFile: (path, data) => fsWriteFile(path, data, "utf-8"),
+    rename: (oldPath, newPath) => fsRename(oldPath, newPath),
+    unlink: (path) => fsUnlink(path),
+};
+/**
+ * Write `content` to `absolutePath` atomically by first writing to a sibling
+ * temp file in the same directory and then renaming it into place. `rename`
+ * is atomic when source and destination live on the same filesystem, which is
+ * guaranteed because the temp file is a sibling of the destination.
+ *
+ * If the temp write or rename fails, the temp file is best-effort removed so
+ * no stale partial temp file is left behind. The original file (if any) is
+ * never touched until the rename succeeds, so a failed write leaves the
+ * existing file intact.
+ *
+ * @param absolutePath Final destination file path.
+ * @param content      Text content to write.
+ * @param encoding     Encoding for the temp write (defaults to "utf-8").
+ * @param operations   Optional stub for tests; defaults to real `fs/promises`.
+ */
+export async function atomicWriteFile(absolutePath, content, encoding = "utf-8", operations = defaultAtomicWriteOperations) {
+    const dir = dirname(absolutePath);
+    const base = absolutePath.split(/[\\/]/).pop() ?? absolutePath;
+    // Sibling temp file: same dir so rename is atomic on the same filesystem.
+    // The leading dot + random suffix keeps it out of the way and unique.
+    const tempPath = join(dir, `.${base}.tmp-${randomBytes(6).toString("hex")}`);
+    try {
+        await operations.writeFile(tempPath, content);
+        await operations.rename(tempPath, absolutePath);
+    }
+    catch (error) {
+        // Best-effort cleanup of the temp file on failure; never let cleanup
+        // errors mask the original write/rename failure.
+        await operations.unlink(tempPath).catch(() => { });
+        throw error;
+    }
+}
+export { defaultAtomicWriteOperations };

package/dist/sdk/coding-agent/core/tools/edit-diff.d.ts

@@ -6,11 +6,15 @@ export declare function detectLineEnding(content: string): "\r\n" | "\n";
 export declare function normalizeToLF(text: string): string;
 export declare function restoreLineEndings(text: string, ending: "\r\n" | "\n"): string;
 /**
- * Normalize text for fuzzy matching. Applies progressive transformations:
+ * Normalize text for fuzzy matching. Applies only semantically-safe
+ * whitespace/visibility transformations:
  * - Strip trailing whitespace from each line
- * - Normalize smart quotes to ASCII equivalents
- * - Normalize Unicode dashes/hyphens to ASCII hyphen
- * - Normalize special Unicode spaces to regular space
+ * - Normalize special Unicode spaces to a regular space
+ *
+ * Intentionally does NOT perform NFKC compatibility decomposition, smart-quote
+ * → straight-quote, or dash/hyphen substitutions: those transformations make
+ * semantically different code match silently. Matching across those characters
+ * requires the oldText to use the exact same characters as the file.
  */
 export declare function normalizeForFuzzyMatch(text: string): string;
 export interface FuzzyMatchResult {
@@ -32,6 +36,8 @@ export interface Edit {
 export interface AppliedEditsResult {
     baseContent: string;
     newContent: string;
+    /** True if any edit was matched via a non-exact (line-trimmed or normalized) strategy. */
+    usedFuzzyMatch: boolean;
 }
 export declare function fuzzyFindText(content: string, oldText: string): FuzzyMatchResult;
 /** Strip UTF-8 BOM if present, return both the BOM (if any) and the text without it */

package/dist/sdk/coding-agent/core/tools/edit-diff.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"edit-diff.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/coding-agent/core/tools/edit-diff.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAM/D;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAE9E;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAqB3D;AAED,MAAM,WAAW,gBAAgB;IAChC,gCAAgC;IAChC,KAAK,EAAE,OAAO,CAAC;IACf,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAC;IACd,yDAAyD;IACzD,WAAW,EAAE,MAAM,CAAC;IACpB,4DAA4D;IAC5D,cAAc,EAAE,OAAO,CAAC;IACxB,8DAA8D;IAC9D,qBAAqB,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,IAAI;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CAChB;AAwBD,MAAM,WAAW,kBAAkB;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;CACnB;AA8KD,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,gBAAgB,CAkBhF;AA6CD,uFAAuF;AACvF,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAEvE;AA0CD;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,CAC5C,iBAAiB,EAAE,MAAM,EACzB,KAAK,EAAE,IAAI,EAAE,EACb,IAAI,EAAE,MAAM,GACV,kBAAkB,CA0DpB;AAED,yCAAyC;AACzC,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,YAAY,SAAI,GAAG,MAAM,CAKnH;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CACjC,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,YAAY,SAAI,GACd;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAuHxD;AAED,MAAM,WAAW,cAAc;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;CACrC;AAED,MAAM,WAAW,aAAa;IAC7B,KAAK,EAAE,MAAM,CAAC;CACd;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CACrC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,IAAI,EAAE,EACb,GAAG,EAAE,MAAM,GACT,OAAO,CAAC,cAAc,GAAG,aAAa,CAAC,CAyBzC;AAED;;;GAGG;AACH,wBAAsB,eAAe,CACpC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,GACT,OAAO,CAAC,cAAc,GAAG,aAAa,CAAC,CAEzC"}
+{"version":3,"file":"edit-diff.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/coding-agent/core/tools/edit-diff.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAa/D;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAE9E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAU3D;AAED,MAAM,WAAW,gBAAgB;IAChC,gCAAgC;IAChC,KAAK,EAAE,OAAO,CAAC;IACf,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAC;IACd,yDAAyD;IACzD,WAAW,EAAE,MAAM,CAAC;IACpB,4DAA4D;IAC5D,cAAc,EAAE,OAAO,CAAC;IACxB,8DAA8D;IAC9D,qBAAqB,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,IAAI;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CAChB;AAwBD,MAAM,WAAW,kBAAkB;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,0FAA0F;IAC1F,cAAc,EAAE,OAAO,CAAC;CACxB;AAsLD,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,gBAAgB,CAkBhF;AAkDD,uFAAuF;AACvF,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAEvE;AA0CD;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,CAC5C,iBAAiB,EAAE,MAAM,EACzB,KAAK,EAAE,IAAI,EAAE,EACb,IAAI,EAAE,MAAM,GACV,kBAAkB,CA4DpB;AAED,yCAAyC;AACzC,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,YAAY,SAAI,GAAG,MAAM,CAKnH;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CACjC,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,YAAY,SAAI,GACd;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAuHxD;AAED,MAAM,WAAW,cAAc;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;CACrC;AAED,MAAM,WAAW,aAAa;IAC7B,KAAK,EAAE,MAAM,CAAC;CACd;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CACrC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,IAAI,EAAE,EACb,GAAG,EAAE,MAAM,GACT,OAAO,CAAC,cAAc,GAAG,aAAa,CAAC,CAyBzC;AAED;;;GAGG;AACH,wBAAsB,eAAe,CACpC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,GACT,OAAO,CAAC,cAAc,GAAG,aAAa,CAAC,CAEzC"}

package/dist/sdk/coding-agent/core/tools/edit-diff.js

@@ -7,13 +7,21 @@ import { constants } from "fs";
 import { access, readFile } from "fs/promises";
 import { resolveToCwd } from "./path-utils.js";
 export function detectLineEnding(content) {
-    const crlfIdx = content.indexOf("\r\n");
-    const lfIdx = content.indexOf("\n");
-    if (lfIdx === -1)
-        return "\n";
-    if (crlfIdx === -1)
+    let crlfCount = 0;
+    let lfCount = 0;
+    for (let i = 0; i < content.length; i++) {
+        if (content[i] !== "\n")
+            continue;
+        if (i > 0 && content[i - 1] === "\r") {
+            crlfCount++;
+        }
+        else {
+            lfCount++;
+        }
+    }
+    if (crlfCount === 0 && lfCount === 0)
         return "\n";
-    return crlfIdx < lfIdx ? "\r\n" : "\n";
+    return crlfCount > lfCount ? "\r\n" : "\n";
 }
 export function normalizeToLF(text) {
     return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
@@ -22,31 +30,26 @@ export function restoreLineEndings(text, ending) {
     return ending === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
 }
 /**
- * Normalize text for fuzzy matching. Applies progressive transformations:
+ * Normalize text for fuzzy matching. Applies only semantically-safe
+ * whitespace/visibility transformations:
  * - Strip trailing whitespace from each line
- * - Normalize smart quotes to ASCII equivalents
- * - Normalize Unicode dashes/hyphens to ASCII hyphen
- * - Normalize special Unicode spaces to regular space
+ * - Normalize special Unicode spaces to a regular space
+ *
+ * Intentionally does NOT perform NFKC compatibility decomposition, smart-quote
+ * → straight-quote, or dash/hyphen substitutions: those transformations make
+ * semantically different code match silently. Matching across those characters
+ * requires the oldText to use the exact same characters as the file.
  */
 export function normalizeForFuzzyMatch(text) {
-    return (text
-        .normalize("NFKC")
-        // Strip trailing whitespace per line
+    return text
+        // Strip trailing whitespace per line (tab/space visibility tolerance)
         .split("\n")
         .map((line) => line.trimEnd())
         .join("\n")
-        // Smart single quotes → '
-        .replace(/[\u2018\u2019\u201A\u201B]/g, "'")
-        // Smart double quotes → "
-        .replace(/[\u201C\u201D\u201E\u201F]/g, '"')
-        // Various dashes/hyphens → -
-        // U+2010 hyphen, U+2011 non-breaking hyphen, U+2012 figure dash,
-        // U+2013 en-dash, U+2014 em-dash, U+2015 horizontal bar, U+2212 minus
-        .replace(/[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]/g, "-")
-        // Special spaces → regular space
+        // Special spaces → regular space (whitespace-equivalence only)
         // U+00A0 NBSP, U+2002-U+200A various spaces, U+202F narrow NBSP,
         // U+205F medium math space, U+3000 ideographic space
-        .replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " "));
+        .replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " ");
 }
 function findExactMatches(content, oldText) {
     const matches = [];
@@ -194,6 +197,12 @@ function findLineTrimmedMatches(content, oldText) {
     }
     return dedupeMatches(matches);
 }
+/**
+ * Files at or above this size skip the O(n) normalized index map. Line-trimmed
+ * matching (which already covers tab/space/CRLF tolerance) is still attempted;
+ * only the costly normalized pass is skipped for large files.
+ */
+const NORMALIZED_MATCH_MAX_BYTES = 256 * 1024; // 256KB
 function findTextMatches(content, oldText) {
     const exactMatches = findExactMatches(content, oldText);
     if (exactMatches.length > 0)
@@ -201,6 +210,8 @@ function findTextMatches(content, oldText) {
     const lineTrimmedMatches = findLineTrimmedMatches(content, oldText);
     if (lineTrimmedMatches.length > 0)
         return lineTrimmedMatches;
+    if (content.length >= NORMALIZED_MATCH_MAX_BYTES)
+        return [];
     return findNormalizedTextMatches(content, oldText);
 }
 export function fuzzyFindText(content, oldText) {
@@ -240,8 +251,14 @@ function adaptIndentationFlexibleReplacement(oldText, newText, matchedText) {
     const matchedBaseIndent = leadingWhitespace(matchedBaseLine);
     if (oldBaseIndent === matchedBaseIndent)
         return newText;
+    // When oldText/matchedText/newText have differing line counts, only adapt the
+    // common-length prefix; leave the remaining newText lines untouched so a
+    // divergent tail is not corrupted by fabricated base-indent prefixes.
+    const commonLength = Math.min(oldLines.length, matchedLines.length, newLines.length);
     return newLines
         .map((line, index) => {
+        if (index >= commonLength)
+            return line;
         if (line.trim().length === 0)
             return line;
         const oldLine = oldLines[index];
@@ -312,6 +329,7 @@ export function applyEditsToNormalizedContent(normalizedContent, edits, path) {
     }
     const baseContent = normalizedContent;
     const matchedEdits = [];
+    let usedFuzzyMatch = false;
     for (let i = 0; i < normalizedEdits.length; i++) {
         const edit = normalizedEdits[i];
         const matches = findTextMatches(baseContent, edit.oldText);
@@ -322,6 +340,8 @@ export function applyEditsToNormalizedContent(normalizedContent, edits, path) {
             throw getDuplicateError(path, i, normalizedEdits.length, matches.length);
         }
         const match = matches[0];
+        if (match.strategy !== "exact")
+            usedFuzzyMatch = true;
         matchedEdits.push({
             editIndex: i,
             matchIndex: match.index,
@@ -348,7 +368,7 @@ export function applyEditsToNormalizedContent(normalizedContent, edits, path) {
     if (baseContent === newContent) {
         throw getNoChangeError(path, normalizedEdits.length);
     }
-    return { baseContent, newContent };
+    return { baseContent, newContent, usedFuzzyMatch };
 }
 /** Generate a standard unified patch. */
 export function generateUnifiedPatch(path, oldContent, newContent, contextLines = 4) {

package/dist/sdk/coding-agent/core/tools/edit.d.ts

@@ -1,4 +1,5 @@
 import type { AgentTool } from "../../../agent-core/index.js";
+import type { Stats } from "fs";
 import { type Static, Type } from "typebox";
 import type { ToolDefinition } from "../extensions/types.js";
 declare const editSchema: Type.TObject<{
@@ -28,6 +29,11 @@ export interface EditOperations {
     writeFile: (absolutePath: string, content: string) => Promise<void>;
     /** Check if file is readable and writable (throw if not) */
     access: (absolutePath: string) => Promise<void>;
+    /**
+     * Stat a file to obtain a freshness token (mtime). Used to detect stale reads
+     * between read and write. Optional — defaults to local fs.stat.
+     */
+    stat?: (absolutePath: string) => Promise<Stats>;
 }
 export interface EditToolOptions {
     /** Custom operations for file editing. Default: local filesystem */

package/dist/sdk/coding-agent/core/tools/edit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"edit.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/coding-agent/core/tools/edit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAG9D,OAAO,EAAE,KAAK,MAAM,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAE5C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AA6B7D,QAAA,MAAM,UAAU;;;;;;EASf,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,OAAO,UAAU,CAAC,CAAC;AAMtD,MAAM,WAAW,eAAe;IAC/B,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAC;IACd,8EAA8E;IAC9E,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC9B,qCAAqC;IACrC,QAAQ,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACpD,8BAA8B;IAC9B,SAAS,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpE,4DAA4D;IAC5D,MAAM,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAChD;AAQD,MAAM,WAAW,eAAe;IAC/B,oEAAoE;IACpE,UAAU,CAAC,EAAE,cAAc,CAAC;CAC5B;AAoFD,wBAAgB,wBAAwB,CACvC,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,eAAe,GACvB,cAAc,CAAC,OAAO,UAAU,EAAE,eAAe,GAAG,SAAS,CAAC,CAsIhE;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC,OAAO,UAAU,CAAC,CAEnG"}
+{"version":3,"file":"edit.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/coding-agent/core/tools/edit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAG9D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,IAAI,CAAC;AAChC,OAAO,EAAE,KAAK,MAAM,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAE5C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AA8B7D,QAAA,MAAM,UAAU;;;;;;EASf,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,OAAO,UAAU,CAAC,CAAC;AAMtD,MAAM,WAAW,eAAe;IAC/B,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAC;IACd,8EAA8E;IAC9E,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC9B,qCAAqC;IACrC,QAAQ,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACpD,8BAA8B;IAC9B,SAAS,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpE,4DAA4D;IAC5D,MAAM,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAChD;;;OAGG;IACH,IAAI,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,KAAK,CAAC,CAAC;CAChD;AASD,MAAM,WAAW,eAAe;IAC/B,oEAAoE;IACpE,UAAU,CAAC,EAAE,cAAc,CAAC;CAC5B;AAqGD,wBAAgB,wBAAwB,CACvC,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,eAAe,GACvB,cAAc,CAAC,OAAO,UAAU,EAAE,eAAe,GAAG,SAAS,CAAC,CAyJhE;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC,OAAO,UAAU,CAAC,CAEnG"}