@hoilab/ada-cli 0.84.22 → 0.85.0

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

@@ -1 +1 @@
-{"version":3,"file":"edit-diff.d.ts","sourceRoot":"","sources":["../../../src/core/tools/edit-diff.ts"],"names":[],"mappings":"AAAA;;GAEG;AAQH,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;AAWD,UAAU,WAAW;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,KAAK,eAAe,GAAG,IAAI,CAAC,WAAW,EAAE,YAAY,GAAG,aAAa,GAAG,SAAS,CAAC,CAAC;AAiDnF;;;;;;;;;GASG;AACH,wBAAgB,yCAAyC,CACxD,eAAe,EAAE,MAAM,EACvB,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,eAAe,EAAE,GAC7B,MAAM,CAqCR;AAED,MAAM,WAAW,gBAAgB;IAChC,gCAAgC;IAChC,KAAK,EAAE,OAAO,CAAC;IACf,4FAA4F;IAC5F,KAAK,EAAE,MAAM,CAAC;IACd,iCAAiC;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,4DAA4D;IAC5D,cAAc,EAAE,OAAO,CAAC;IACxB;;;OAGG;IACH,qBAAqB,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,IAAI;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,kBAAkB;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,gBAAgB,CAsChF;AA8CD;;;;;;;;GAQG;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","sourcesContent":["/**\n * Shared diff computation utilities for the edit and similar tools.\n */\n\nimport * as Diff from \"diff\";\nimport { constants } from \"fs\";\nimport { access, readFile } from \"fs/promises\";\nimport { splitBom } from \"../../utils/text.ts\";\nimport { resolveToCwd } from \"./path-utils.ts\";\n\nexport function detectLineEnding(content: string): \"\\r\\n\" | \"\\n\" {\n\tconst crlfIdx = content.indexOf(\"\\r\\n\");\n\tconst lfIdx = content.indexOf(\"\\n\");\n\tif (lfIdx === -1) return \"\\n\";\n\tif (crlfIdx === -1) return \"\\n\";\n\treturn crlfIdx < lfIdx ? \"\\r\\n\" : \"\\n\";\n}\n\nexport function normalizeToLF(text: string): string {\n\treturn text.replace(/\\r\\n/g, \"\\n\").replace(/\\r/g, \"\\n\");\n}\n\nexport function restoreLineEndings(text: string, ending: \"\\r\\n\" | \"\\n\"): string {\n\treturn ending === \"\\r\\n\" ? text.replace(/\\n/g, \"\\r\\n\") : text;\n}\n\n/**\n * Normalize text for fuzzy matching. Applies progressive transformations:\n * - Strip trailing whitespace from each line\n * - Normalize smart quotes to ASCII equivalents\n * - Normalize Unicode dashes/hyphens to ASCII hyphen\n * - Normalize special Unicode spaces to regular space\n */\nexport function normalizeForFuzzyMatch(text: string): string {\n\treturn (\n\t\ttext\n\t\t\t.normalize(\"NFKC\")\n\t\t\t// Strip trailing whitespace per line\n\t\t\t.split(\"\\n\")\n\t\t\t.map((line) => line.trimEnd())\n\t\t\t.join(\"\\n\")\n\t\t\t// Smart single quotes → '\n\t\t\t.replace(/[\\u2018\\u2019\\u201A\\u201B]/g, \"'\")\n\t\t\t// Smart double quotes → \"\n\t\t\t.replace(/[\\u201C\\u201D\\u201E\\u201F]/g, '\"')\n\t\t\t// Various dashes/hyphens → -\n\t\t\t// U+2010 hyphen, U+2011 non-breaking hyphen, U+2012 figure dash,\n\t\t\t// U+2013 en-dash, U+2014 em-dash, U+2015 horizontal bar, U+2212 minus\n\t\t\t.replace(/[\\u2010\\u2011\\u2012\\u2013\\u2014\\u2015\\u2212]/g, \"-\")\n\t\t\t// Special spaces → regular space\n\t\t\t// U+00A0 NBSP, U+2002-U+200A various spaces, U+202F narrow NBSP,\n\t\t\t// U+205F medium math space, U+3000 ideographic space\n\t\t\t.replace(/[\\u00A0\\u2002-\\u200A\\u202F\\u205F\\u3000]/g, \" \")\n\t);\n}\n\nfunction splitLinesWithEndings(content: string): string[] {\n\treturn content.match(/[^\\n]*\\n|[^\\n]+/g) ?? [];\n}\n\ninterface LineSpan {\n\tstart: number;\n\tend: number;\n}\n\ninterface MatchedEdit {\n\teditIndex: number;\n\tmatchIndex: number;\n\tmatchLength: number;\n\tnewText: string;\n}\n\ntype TextReplacement = Pick<MatchedEdit, \"matchIndex\" | \"matchLength\" | \"newText\">;\n\nfunction getLineSpans(content: string): LineSpan[] {\n\tlet offset = 0;\n\treturn splitLinesWithEndings(content).map((line) => {\n\t\tconst span = { start: offset, end: offset + line.length };\n\t\toffset = span.end;\n\t\treturn span;\n\t});\n}\n\nfunction getReplacementLineRange(lines: LineSpan[], replacement: TextReplacement) {\n\tconst replacementStart = replacement.matchIndex;\n\tconst replacementEnd = replacement.matchIndex + replacement.matchLength;\n\n\tlet startLine = -1;\n\tfor (let i = 0; i < lines.length; i++) {\n\t\tconst line = lines[i];\n\t\tif (replacementStart >= line.start && replacementStart < line.end) {\n\t\t\tstartLine = i;\n\t\t\tbreak;\n\t\t}\n\t}\n\tif (startLine === -1) {\n\t\tthrow new Error(\"Replacement range is outside the base content.\");\n\t}\n\n\tlet endLine = startLine;\n\twhile (endLine < lines.length && lines[endLine].end < replacementEnd) {\n\t\tendLine++;\n\t}\n\tif (endLine >= lines.length) {\n\t\tthrow new Error(\"Replacement range is outside the base content.\");\n\t}\n\n\treturn { startLine, endLine: endLine + 1 };\n}\n\nfunction applyReplacements(content: string, replacements: TextReplacement[], offset = 0): string {\n\tlet result = content;\n\tfor (let i = replacements.length - 1; i >= 0; i--) {\n\t\tconst replacement = replacements[i];\n\t\tconst matchIndex = replacement.matchIndex - offset;\n\t\tresult =\n\t\t\tresult.substring(0, matchIndex) + replacement.newText + result.substring(matchIndex + replacement.matchLength);\n\t}\n\treturn result;\n}\n\n/**\n * Apply replacements matched against `baseContent` to `originalContent` while\n * preserving unchanged line blocks from the original.\n *\n * This is useful when `baseContent` is a normalized view of the original. Each\n * replacement is widened to the lines it actually touches, those touched lines\n * are rewritten from the normalized base, and all other lines are copied back\n * from `originalContent`. The actual replacement ranges drive preservation so\n * duplicate normalized lines cannot be aligned to the wrong occurrence.\n */\nexport function applyReplacementsPreservingUnchangedLines(\n\toriginalContent: string,\n\tbaseContent: string,\n\treplacements: TextReplacement[],\n): string {\n\tconst originalLines = splitLinesWithEndings(originalContent);\n\tconst baseLines = getLineSpans(baseContent);\n\tif (originalLines.length !== baseLines.length) {\n\t\tthrow new Error(\"Cannot preserve unchanged lines because the base content has a different line count.\");\n\t}\n\n\tconst groups: Array<{ startLine: number; endLine: number; replacements: TextReplacement[] }> = [];\n\tconst sortedReplacements = [...replacements].sort((a, b) => a.matchIndex - b.matchIndex);\n\tfor (const replacement of sortedReplacements) {\n\t\tconst range = getReplacementLineRange(baseLines, replacement);\n\t\tconst current = groups[groups.length - 1];\n\t\tif (current && range.startLine < current.endLine) {\n\t\t\tcurrent.endLine = Math.max(current.endLine, range.endLine);\n\t\t\tcurrent.replacements.push(replacement);\n\t\t\tcontinue;\n\t\t}\n\t\tgroups.push({ ...range, replacements: [replacement] });\n\t}\n\n\tlet originalLineIndex = 0;\n\tlet result = \"\";\n\tfor (const group of groups) {\n\t\tresult += originalLines.slice(originalLineIndex, group.startLine).join(\"\");\n\n\t\tconst groupStartOffset = baseLines[group.startLine].start;\n\t\tconst groupEndOffset = baseLines[group.endLine - 1].end;\n\t\tresult += applyReplacements(\n\t\t\tbaseContent.slice(groupStartOffset, groupEndOffset),\n\t\t\tgroup.replacements,\n\t\t\tgroupStartOffset,\n\t\t);\n\t\toriginalLineIndex = group.endLine;\n\t}\n\tresult += originalLines.slice(originalLineIndex).join(\"\");\n\n\treturn result;\n}\n\nexport interface FuzzyMatchResult {\n\t/** Whether a match was found */\n\tfound: boolean;\n\t/** The index where the match starts (in the content that should be used for replacement) */\n\tindex: number;\n\t/** Length of the matched text */\n\tmatchLength: number;\n\t/** Whether fuzzy matching was used (false = exact match) */\n\tusedFuzzyMatch: boolean;\n\t/**\n\t * The content to use for replacement operations.\n\t * When exact match: original content. When fuzzy match: normalized content.\n\t */\n\tcontentForReplacement: string;\n}\n\nexport interface Edit {\n\toldText: string;\n\tnewText: string;\n}\n\nexport interface AppliedEditsResult {\n\tbaseContent: string;\n\tnewContent: string;\n}\n\n/**\n * Find oldText in content, trying exact match first, then fuzzy match.\n * When fuzzy matching is used, the returned contentForReplacement is the\n * fuzzy-normalized version of the content (trailing whitespace stripped,\n * Unicode quotes/dashes normalized to ASCII).\n */\nexport function fuzzyFindText(content: string, oldText: string): FuzzyMatchResult {\n\t// Try exact match first\n\tconst exactIndex = content.indexOf(oldText);\n\tif (exactIndex !== -1) {\n\t\treturn {\n\t\t\tfound: true,\n\t\t\tindex: exactIndex,\n\t\t\tmatchLength: oldText.length,\n\t\t\tusedFuzzyMatch: false,\n\t\t\tcontentForReplacement: content,\n\t\t};\n\t}\n\n\t// Try fuzzy match - work entirely in normalized space\n\tconst fuzzyContent = normalizeForFuzzyMatch(content);\n\tconst fuzzyOldText = normalizeForFuzzyMatch(oldText);\n\tconst fuzzyIndex = fuzzyContent.indexOf(fuzzyOldText);\n\n\tif (fuzzyIndex === -1) {\n\t\treturn {\n\t\t\tfound: false,\n\t\t\tindex: -1,\n\t\t\tmatchLength: 0,\n\t\t\tusedFuzzyMatch: false,\n\t\t\tcontentForReplacement: content,\n\t\t};\n\t}\n\n\t// When fuzzy matching, return offsets in normalized space. Callers can use\n\t// the normalized content to compute replacements, then decide how much of\n\t// that normalized output should be written back.\n\treturn {\n\t\tfound: true,\n\t\tindex: fuzzyIndex,\n\t\tmatchLength: fuzzyOldText.length,\n\t\tusedFuzzyMatch: true,\n\t\tcontentForReplacement: fuzzyContent,\n\t};\n}\n\nfunction countOccurrences(content: string, oldText: string): number {\n\tconst fuzzyContent = normalizeForFuzzyMatch(content);\n\tconst fuzzyOldText = normalizeForFuzzyMatch(oldText);\n\treturn fuzzyContent.split(fuzzyOldText).length - 1;\n}\n\nfunction getNotFoundError(path: string, editIndex: number, totalEdits: number): Error {\n\tif (totalEdits === 1) {\n\t\treturn new Error(\n\t\t\t`Could not find the exact text in ${path}. The old text must match exactly including all whitespace and newlines.`,\n\t\t);\n\t}\n\treturn new Error(\n\t\t`Could not find edits[${editIndex}] in ${path}. The oldText must match exactly including all whitespace and newlines.`,\n\t);\n}\n\nfunction getDuplicateError(path: string, editIndex: number, totalEdits: number, occurrences: number): Error {\n\tif (totalEdits === 1) {\n\t\treturn new Error(\n\t\t\t`Found ${occurrences} occurrences of the text in ${path}. The text must be unique. Please provide more context to make it unique.`,\n\t\t);\n\t}\n\treturn new Error(\n\t\t`Found ${occurrences} occurrences of edits[${editIndex}] in ${path}. Each oldText must be unique. Please provide more context to make it unique.`,\n\t);\n}\n\nfunction getEmptyOldTextError(path: string, editIndex: number, totalEdits: number): Error {\n\tif (totalEdits === 1) {\n\t\treturn new Error(`oldText must not be empty in ${path}.`);\n\t}\n\treturn new Error(`edits[${editIndex}].oldText must not be empty in ${path}.`);\n}\n\nfunction getNoChangeError(path: string, totalEdits: number): Error {\n\tif (totalEdits === 1) {\n\t\treturn new Error(\n\t\t\t`No changes made to ${path}. The replacement produced identical content. This might indicate an issue with special characters or the text not existing as expected.`,\n\t\t);\n\t}\n\treturn new Error(`No changes made to ${path}. The replacements produced identical content.`);\n}\n\n/**\n * Apply one or more exact-text replacements to LF-normalized content.\n *\n * All edits are matched against the same original content. Replacements are\n * then applied in reverse order so offsets remain stable. If any edit needs\n * fuzzy matching, the operation runs in fuzzy-normalized content space and then\n * overlays those line-level changes onto the original content so unchanged line\n * blocks keep their original bytes.\n */\nexport function applyEditsToNormalizedContent(\n\tnormalizedContent: string,\n\tedits: Edit[],\n\tpath: string,\n): AppliedEditsResult {\n\tconst normalizedEdits = edits.map((edit) => ({\n\t\toldText: normalizeToLF(edit.oldText),\n\t\tnewText: normalizeToLF(edit.newText),\n\t}));\n\n\tfor (let i = 0; i < normalizedEdits.length; i++) {\n\t\tif (normalizedEdits[i].oldText.length === 0) {\n\t\t\tthrow getEmptyOldTextError(path, i, normalizedEdits.length);\n\t\t}\n\t}\n\n\tconst initialMatches = normalizedEdits.map((edit) => fuzzyFindText(normalizedContent, edit.oldText));\n\tconst usedFuzzyMatch = initialMatches.some((match) => match.usedFuzzyMatch);\n\tconst replacementBaseContent = usedFuzzyMatch ? normalizeForFuzzyMatch(normalizedContent) : normalizedContent;\n\n\tconst matchedEdits: MatchedEdit[] = [];\n\tfor (let i = 0; i < normalizedEdits.length; i++) {\n\t\tconst edit = normalizedEdits[i];\n\t\tconst matchResult = fuzzyFindText(replacementBaseContent, edit.oldText);\n\t\tif (!matchResult.found) {\n\t\t\tthrow getNotFoundError(path, i, normalizedEdits.length);\n\t\t}\n\n\t\tconst occurrences = countOccurrences(replacementBaseContent, edit.oldText);\n\t\tif (occurrences > 1) {\n\t\t\tthrow getDuplicateError(path, i, normalizedEdits.length, occurrences);\n\t\t}\n\n\t\tmatchedEdits.push({\n\t\t\teditIndex: i,\n\t\t\tmatchIndex: matchResult.index,\n\t\t\tmatchLength: matchResult.matchLength,\n\t\t\tnewText: edit.newText,\n\t\t});\n\t}\n\n\tmatchedEdits.sort((a, b) => a.matchIndex - b.matchIndex);\n\tfor (let i = 1; i < matchedEdits.length; i++) {\n\t\tconst previous = matchedEdits[i - 1];\n\t\tconst current = matchedEdits[i];\n\t\tif (previous.matchIndex + previous.matchLength > current.matchIndex) {\n\t\t\tthrow new Error(\n\t\t\t\t`edits[${previous.editIndex}] and edits[${current.editIndex}] overlap in ${path}. Merge them into one edit or target disjoint regions.`,\n\t\t\t);\n\t\t}\n\t}\n\n\tconst baseContent = normalizedContent;\n\tconst newContent = usedFuzzyMatch\n\t\t? applyReplacementsPreservingUnchangedLines(normalizedContent, replacementBaseContent, matchedEdits)\n\t\t: applyReplacements(replacementBaseContent, matchedEdits);\n\n\tif (baseContent === newContent) {\n\t\tthrow getNoChangeError(path, normalizedEdits.length);\n\t}\n\n\treturn { baseContent, newContent };\n}\n\n/** Generate a standard unified patch. */\nexport function generateUnifiedPatch(path: string, oldContent: string, newContent: string, contextLines = 4): string {\n\treturn Diff.createTwoFilesPatch(path, path, oldContent, newContent, undefined, undefined, {\n\t\tcontext: contextLines,\n\t\theaderOptions: Diff.FILE_HEADERS_ONLY,\n\t});\n}\n\n/**\n * Generate a display-oriented diff string with line numbers and context.\n * Returns both the diff string and the first changed line number (in the new file).\n */\nexport function generateDiffString(\n\toldContent: string,\n\tnewContent: string,\n\tcontextLines = 4,\n): { diff: string; firstChangedLine: number | undefined } {\n\tconst parts = Diff.diffLines(oldContent, newContent);\n\tconst output: string[] = [];\n\n\tconst oldLines = oldContent.split(\"\\n\");\n\tconst newLines = newContent.split(\"\\n\");\n\tconst maxLineNum = Math.max(oldLines.length, newLines.length);\n\tconst lineNumWidth = String(maxLineNum).length;\n\n\tlet oldLineNum = 1;\n\tlet newLineNum = 1;\n\tlet lastWasChange = false;\n\tlet firstChangedLine: number | undefined;\n\n\tfor (let i = 0; i < parts.length; i++) {\n\t\tconst part = parts[i];\n\t\tconst raw = part.value.split(\"\\n\");\n\t\tif (raw[raw.length - 1] === \"\") {\n\t\t\traw.pop();\n\t\t}\n\n\t\tif (part.added || part.removed) {\n\t\t\t// Capture the first changed line (in the new file)\n\t\t\tif (firstChangedLine === undefined) {\n\t\t\t\tfirstChangedLine = newLineNum;\n\t\t\t}\n\n\t\t\t// Show the change\n\t\t\tfor (const line of raw) {\n\t\t\t\tif (part.added) {\n\t\t\t\t\tconst lineNum = String(newLineNum).padStart(lineNumWidth, \" \");\n\t\t\t\t\toutput.push(`+${lineNum} ${line}`);\n\t\t\t\t\tnewLineNum++;\n\t\t\t\t} else {\n\t\t\t\t\t// removed\n\t\t\t\t\tconst lineNum = String(oldLineNum).padStart(lineNumWidth, \" \");\n\t\t\t\t\toutput.push(`-${lineNum} ${line}`);\n\t\t\t\t\toldLineNum++;\n\t\t\t\t}\n\t\t\t}\n\t\t\tlastWasChange = true;\n\t\t} else {\n\t\t\t// Context lines - only show a few before/after changes\n\t\t\tconst nextPartIsChange = i < parts.length - 1 && (parts[i + 1].added || parts[i + 1].removed);\n\t\t\tconst hasLeadingChange = lastWasChange;\n\t\t\tconst hasTrailingChange = nextPartIsChange;\n\n\t\t\tif (hasLeadingChange && hasTrailingChange) {\n\t\t\t\tif (raw.length <= contextLines * 2) {\n\t\t\t\t\tfor (const line of raw) {\n\t\t\t\t\t\tconst lineNum = String(oldLineNum).padStart(lineNumWidth, \" \");\n\t\t\t\t\t\toutput.push(` ${lineNum} ${line}`);\n\t\t\t\t\t\toldLineNum++;\n\t\t\t\t\t\tnewLineNum++;\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tconst leadingLines = raw.slice(0, contextLines);\n\t\t\t\t\tconst trailingLines = raw.slice(raw.length - contextLines);\n\t\t\t\t\tconst skippedLines = raw.length - leadingLines.length - trailingLines.length;\n\n\t\t\t\t\tfor (const line of leadingLines) {\n\t\t\t\t\t\tconst lineNum = String(oldLineNum).padStart(lineNumWidth, \" \");\n\t\t\t\t\t\toutput.push(` ${lineNum} ${line}`);\n\t\t\t\t\t\toldLineNum++;\n\t\t\t\t\t\tnewLineNum++;\n\t\t\t\t\t}\n\n\t\t\t\t\toutput.push(` ${\"\".padStart(lineNumWidth, \" \")} ...`);\n\t\t\t\t\toldLineNum += skippedLines;\n\t\t\t\t\tnewLineNum += skippedLines;\n\n\t\t\t\t\tfor (const line of trailingLines) {\n\t\t\t\t\t\tconst lineNum = String(oldLineNum).padStart(lineNumWidth, \" \");\n\t\t\t\t\t\toutput.push(` ${lineNum} ${line}`);\n\t\t\t\t\t\toldLineNum++;\n\t\t\t\t\t\tnewLineNum++;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else if (hasLeadingChange) {\n\t\t\t\tconst shownLines = raw.slice(0, contextLines);\n\t\t\t\tconst skippedLines = raw.length - shownLines.length;\n\n\t\t\t\tfor (const line of shownLines) {\n\t\t\t\t\tconst lineNum = String(oldLineNum).padStart(lineNumWidth, \" \");\n\t\t\t\t\toutput.push(` ${lineNum} ${line}`);\n\t\t\t\t\toldLineNum++;\n\t\t\t\t\tnewLineNum++;\n\t\t\t\t}\n\n\t\t\t\tif (skippedLines > 0) {\n\t\t\t\t\toutput.push(` ${\"\".padStart(lineNumWidth, \" \")} ...`);\n\t\t\t\t\toldLineNum += skippedLines;\n\t\t\t\t\tnewLineNum += skippedLines;\n\t\t\t\t}\n\t\t\t} else if (hasTrailingChange) {\n\t\t\t\tconst skippedLines = Math.max(0, raw.length - contextLines);\n\t\t\t\tif (skippedLines > 0) {\n\t\t\t\t\toutput.push(` ${\"\".padStart(lineNumWidth, \" \")} ...`);\n\t\t\t\t\toldLineNum += skippedLines;\n\t\t\t\t\tnewLineNum += skippedLines;\n\t\t\t\t}\n\n\t\t\t\tfor (const line of raw.slice(skippedLines)) {\n\t\t\t\t\tconst lineNum = String(oldLineNum).padStart(lineNumWidth, \" \");\n\t\t\t\t\toutput.push(` ${lineNum} ${line}`);\n\t\t\t\t\toldLineNum++;\n\t\t\t\t\tnewLineNum++;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\t// Skip these context lines entirely\n\t\t\t\toldLineNum += raw.length;\n\t\t\t\tnewLineNum += raw.length;\n\t\t\t}\n\n\t\t\tlastWasChange = false;\n\t\t}\n\t}\n\n\treturn { diff: output.join(\"\\n\"), firstChangedLine };\n}\n\nexport interface EditDiffResult {\n\tdiff: string;\n\tfirstChangedLine: number | undefined;\n}\n\nexport interface EditDiffError {\n\terror: string;\n}\n\n/**\n * Compute the diff for one or more edit operations without applying them.\n * Used for preview rendering in the TUI before the tool executes.\n */\nexport async function computeEditsDiff(\n\tpath: string,\n\tedits: Edit[],\n\tcwd: string,\n): Promise<EditDiffResult | EditDiffError> {\n\tconst absolutePath = resolveToCwd(path, cwd);\n\n\ttry {\n\t\t// Check if file exists and is readable\n\t\ttry {\n\t\t\tawait access(absolutePath, constants.R_OK);\n\t\t} catch (error: unknown) {\n\t\t\tconst errorMessage = error instanceof Error && \"code\" in error ? `Error code: ${error.code}` : String(error);\n\t\t\treturn { error: `Could not edit file: ${path}. ${errorMessage}.` };\n\t\t}\n\n\t\t// Read the file\n\t\tconst rawContent = await readFile(absolutePath, \"utf-8\");\n\n\t\t// Strip BOM before matching (LLM won't include invisible BOM in oldText)\n\t\tconst { text: content } = splitBom(rawContent);\n\t\tconst normalizedContent = normalizeToLF(content);\n\t\tconst { baseContent, newContent } = applyEditsToNormalizedContent(normalizedContent, edits, path);\n\n\t\t// Generate the diff\n\t\treturn generateDiffString(baseContent, newContent);\n\t} catch (err) {\n\t\treturn { error: err instanceof Error ? err.message : String(err) };\n\t}\n}\n\n/**\n * Compute the diff for a single edit operation without applying it.\n * Kept as a convenience wrapper for single-edit callers.\n */\nexport async function computeEditDiff(\n\tpath: string,\n\toldText: string,\n\tnewText: string,\n\tcwd: string,\n): Promise<EditDiffResult | EditDiffError> {\n\treturn computeEditsDiff(path, [{ oldText, newText }], cwd);\n}\n"]}
+{"version":3,"file":"edit-diff.d.ts","sourceRoot":"","sources":["../../../src/core/tools/edit-diff.ts"],"names":[],"mappings":"AAAA;;GAEG;AAYH,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;AAkED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAoB3D;AAWD,UAAU,WAAW;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,KAAK,eAAe,GAAG,IAAI,CAAC,WAAW,EAAE,YAAY,GAAG,aAAa,GAAG,SAAS,CAAC,CAAC;AAiDnF;;;;;;;;;GASG;AACH,wBAAgB,yCAAyC,CACxD,eAAe,EAAE,MAAM,EACvB,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,eAAe,EAAE,GAC7B,MAAM,CA+GR;AAED,MAAM,WAAW,gBAAgB;IAChC,gCAAgC;IAChC,KAAK,EAAE,OAAO,CAAC;IACf,4FAA4F;IAC5F,KAAK,EAAE,MAAM,CAAC;IACd,iCAAiC;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,4DAA4D;IAC5D,cAAc,EAAE,OAAO,CAAC;IACxB;;;OAGG;IACH,qBAAqB,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,IAAI;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,kBAAkB;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,gBAAgB,CAsChF;AA8CD;;;;;;;;GAQG;AACH,wBAAgB,6BAA6B,CAC5C,iBAAiB,EAAE,MAAM,EACzB,KAAK,EAAE,IAAI,EAAE,EACb,IAAI,EAAE,MAAM,GACV,kBAAkB,CAyJpB;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","sourcesContent":["/**\n * Shared diff computation utilities for the edit and similar tools.\n */\n\nimport * as Diff from \"diff\";\nimport { constants } from \"fs\";\nimport { access, readFile } from \"fs/promises\";\nimport { splitBom } from \"../../utils/text.ts\";\nimport { casarHuecoElidido } from \"../edicion/hueco.ts\";\nimport { limpiarCarga } from \"../edicion/limpiar-carga.ts\";\nimport { casarPorParecido } from \"../edicion/parecido.ts\";\nimport { casarIgnorandoSangria, coherenteConElBloque } from \"../edicion/sangria.ts\";\nimport { resolveToCwd } from \"./path-utils.ts\";\n\nexport function detectLineEnding(content: string): \"\\r\\n\" | \"\\n\" {\n\tconst crlfIdx = content.indexOf(\"\\r\\n\");\n\tconst lfIdx = content.indexOf(\"\\n\");\n\tif (lfIdx === -1) return \"\\n\";\n\tif (crlfIdx === -1) return \"\\n\";\n\treturn crlfIdx < lfIdx ? \"\\r\\n\" : \"\\n\";\n}\n\nexport function normalizeToLF(text: string): string {\n\treturn text.replace(/\\r\\n/g, \"\\n\").replace(/\\r/g, \"\\n\");\n}\n\nexport function restoreLineEndings(text: string, ending: \"\\r\\n\" | \"\\n\"): string {\n\treturn ending === \"\\r\\n\" ? text.replace(/\\n/g, \"\\r\\n\") : text;\n}\n\n/**\n * Normalize text for fuzzy matching. Applies progressive transformations:\n * - Strip trailing whitespace from each line\n * - Normalize smart quotes to ASCII equivalents\n * - Normalize Unicode dashes/hyphens to ASCII hyphen\n * - Normalize special Unicode spaces to regular space\n */\n/**\n * NFKC, pero SOLO donde no cambia el número de caracteres.\n *\n * El texto normalizado no se usa únicamente para comparar. Cuando alguna\n * edición del lote necesita el camino difuso, `usedFuzzyMatch` es un `some()`\n * sobre TODAS (más abajo, en `applyEditsToNormalizedContent`), y esa forma\n * normalizada pasa a ser la base de escritura: `applyReplacementsPreservingUnchangedLines`\n * reescribe entonces cada línea del grupo tocado desde ella.\n *\n * Un `.normalize(\"NFKC\")` sobre el texto entero corrompía código que nadie\n * había pedido tocar. Medido sobre un fichero real, con dos ediciones en la\n * misma llamada —una difusa por comillas tipográficas, otra exacta en la línea\n * de abajo—:\n *\n *   antes:   const razon = compute(1) + \" ½ \";\n *   después: const razon = compute(2) + \" 1⁄2 \";\n *\n * El disparador es cotidiano: comillas tipográficas o guiones largos en el\n * fichero y el modelo escribiendo los ASCII, que es lo normal en ficheros con\n * textos de interfaz.\n *\n * El corte está medido, no elegido a ojo. Las conversiones que aportan al\n * casado son 1:1 y se conservan:\n *\n *   `，`→`,`  `（`→`(`  `Ａ`→`A`  `１`→`1`     (ancho completo, 1 → 1)\n *\n * Las que corrompen cambian de longitud y se descartan:\n *\n *   `½`→`1⁄2` (1 → 3)   `fi`→`fi` (1 → 2)   `e`+`◌́`→`é` (2 → 1)\n *\n * Lo que se pierde es casar formas descompuestas (`cafe`+acento combinante\n * contra `café`). Se acepta a propósito: es un caso estrecho frente a destruir\n * el fichero del usuario en silencio.\n *\n * SEGUNDA RAZÓN, y ahora es la principal: `applyReplacementsPreservingUnchangedLines`\n * traduce posiciones del texto normalizado a posiciones del original, y esa\n * traducción SOLO es válida si dentro de una línea las dos coordenadas\n * coinciden. Un NFKC completo rompería el mapeo (`½` ocupa 1 y `1⁄2` ocupa 3),\n * y con él el empalme sobre bytes originales. Mantener el 1:1 no es una\n * preferencia: es lo que hace correcta la función de traducción.\n *\n * Nota sobre por qué el 1:1 NO bastaba por sí solo, que es donde me equivoqué\n * primero: preservar la LONGITUD no es preservar el CONTENIDO. `“` y `\"` miden\n * lo mismo y son bytes distintos, así que restringir NFKC dejaba fuera el ½\n * pero seguía mutando comillas, guiones y espacios duros al escribir — y el\n * caso de las comillas produce un fichero que ni siquiera compila. Lo que\n * arregla eso es no escribir nunca desde el texto normalizado.\n */\nfunction nfkcCaracterAcaracter(text: string): string {\n\tlet salida = \"\";\n\tfor (const caracter of text) {\n\t\tconst normalizado = caracter.normalize(\"NFKC\");\n\t\tsalida += normalizado.length === caracter.length ? normalizado : caracter;\n\t}\n\treturn salida;\n}\n\nexport function normalizeForFuzzyMatch(text: string): string {\n\treturn (\n\t\tnfkcCaracterAcaracter(text)\n\t\t\t// Strip trailing whitespace per line\n\t\t\t.split(\"\\n\")\n\t\t\t.map((line) => line.trimEnd())\n\t\t\t.join(\"\\n\")\n\t\t\t// Smart single quotes → '\n\t\t\t.replace(/[\\u2018\\u2019\\u201A\\u201B]/g, \"'\")\n\t\t\t// Smart double quotes → \"\n\t\t\t.replace(/[\\u201C\\u201D\\u201E\\u201F]/g, '\"')\n\t\t\t// Various dashes/hyphens → -\n\t\t\t// U+2010 hyphen, U+2011 non-breaking hyphen, U+2012 figure dash,\n\t\t\t// U+2013 en-dash, U+2014 em-dash, U+2015 horizontal bar, U+2212 minus\n\t\t\t.replace(/[\\u2010\\u2011\\u2012\\u2013\\u2014\\u2015\\u2212]/g, \"-\")\n\t\t\t// Special spaces → regular space\n\t\t\t// U+00A0 NBSP, U+2002-U+200A various spaces, U+202F narrow NBSP,\n\t\t\t// U+205F medium math space, U+3000 ideographic space\n\t\t\t.replace(/[\\u00A0\\u2002-\\u200A\\u202F\\u205F\\u3000]/g, \" \")\n\t);\n}\n\nfunction splitLinesWithEndings(content: string): string[] {\n\treturn content.match(/[^\\n]*\\n|[^\\n]+/g) ?? [];\n}\n\ninterface LineSpan {\n\tstart: number;\n\tend: number;\n}\n\ninterface MatchedEdit {\n\teditIndex: number;\n\tmatchIndex: number;\n\tmatchLength: number;\n\tnewText: string;\n}\n\ntype TextReplacement = Pick<MatchedEdit, \"matchIndex\" | \"matchLength\" | \"newText\">;\n\nfunction getLineSpans(content: string): LineSpan[] {\n\tlet offset = 0;\n\treturn splitLinesWithEndings(content).map((line) => {\n\t\tconst span = { start: offset, end: offset + line.length };\n\t\toffset = span.end;\n\t\treturn span;\n\t});\n}\n\nfunction getReplacementLineRange(lines: LineSpan[], replacement: TextReplacement) {\n\tconst replacementStart = replacement.matchIndex;\n\tconst replacementEnd = replacement.matchIndex + replacement.matchLength;\n\n\tlet startLine = -1;\n\tfor (let i = 0; i < lines.length; i++) {\n\t\tconst line = lines[i];\n\t\tif (replacementStart >= line.start && replacementStart < line.end) {\n\t\t\tstartLine = i;\n\t\t\tbreak;\n\t\t}\n\t}\n\tif (startLine === -1) {\n\t\tthrow new Error(\"Replacement range is outside the base content.\");\n\t}\n\n\tlet endLine = startLine;\n\twhile (endLine < lines.length && lines[endLine].end < replacementEnd) {\n\t\tendLine++;\n\t}\n\tif (endLine >= lines.length) {\n\t\tthrow new Error(\"Replacement range is outside the base content.\");\n\t}\n\n\treturn { startLine, endLine: endLine + 1 };\n}\n\nfunction applyReplacements(content: string, replacements: TextReplacement[], offset = 0): string {\n\tlet result = content;\n\tfor (let i = replacements.length - 1; i >= 0; i--) {\n\t\tconst replacement = replacements[i];\n\t\tconst matchIndex = replacement.matchIndex - offset;\n\t\tresult =\n\t\t\tresult.substring(0, matchIndex) + replacement.newText + result.substring(matchIndex + replacement.matchLength);\n\t}\n\treturn result;\n}\n\n/**\n * Apply replacements matched against `baseContent` to `originalContent` while\n * preserving unchanged line blocks from the original.\n *\n * This is useful when `baseContent` is a normalized view of the original. Each\n * replacement is widened to the lines it actually touches, those touched lines\n * are rewritten from the normalized base, and all other lines are copied back\n * from `originalContent`. The actual replacement ranges drive preservation so\n * duplicate normalized lines cannot be aligned to the wrong occurrence.\n */\nexport function applyReplacementsPreservingUnchangedLines(\n\toriginalContent: string,\n\tbaseContent: string,\n\treplacements: TextReplacement[],\n): string {\n\tconst originalLines = splitLinesWithEndings(originalContent);\n\tconst baseLines = getLineSpans(baseContent);\n\tif (originalLines.length !== baseLines.length) {\n\t\tthrow new Error(\"Cannot preserve unchanged lines because the base content has a different line count.\");\n\t}\n\n\tconst groups: Array<{ startLine: number; endLine: number; replacements: TextReplacement[] }> = [];\n\tconst sortedReplacements = [...replacements].sort((a, b) => a.matchIndex - b.matchIndex);\n\tfor (const replacement of sortedReplacements) {\n\t\tconst range = getReplacementLineRange(baseLines, replacement);\n\t\tconst current = groups[groups.length - 1];\n\t\tif (current && range.startLine < current.endLine) {\n\t\t\tcurrent.endLine = Math.max(current.endLine, range.endLine);\n\t\t\tcurrent.replacements.push(replacement);\n\t\t\tcontinue;\n\t\t}\n\t\tgroups.push({ ...range, replacements: [replacement] });\n\t}\n\n\t// Desplazamientos de inicio de cada línea en el ORIGINAL, para poder\n\t// traducir una posición del texto normalizado a su posición real.\n\tconst originalStarts: number[] = [];\n\t{\n\t\tlet acumulado = 0;\n\t\tfor (const linea of originalLines) {\n\t\t\toriginalStarts.push(acumulado);\n\t\t\tacumulado += linea.length;\n\t\t}\n\t}\n\n\t/**\n\t * De una posición en el texto normalizado a la misma posición en el\n\t * original.\n\t *\n\t * Dentro del TEXTO de una línea las dos coordenadas coinciden: todas las\n\t * sustituciones de `normalizeForFuzzyMatch` son de un carácter por otro\n\t * —incluido el NFKC, que ahora solo se aplica donde es 1:1— y lo único que\n\t * cambia la longitud es el recorte de espacios FINALES. Entre líneas sí\n\t * difieren, y por eso hay que ir línea a línea.\n\t *\n\t * PERO el recorte de espacios finales NO está «detrás de cualquier posición\n\t * que nos interese», que es lo que decía aquí y era falso: el LÍMITE de una\n\t * línea es una posición que interesa —la usan el final de un grupo y el\n\t * final de un reemplazo multilínea— y cae justo detrás del recorte. Sumar\n\t * el desplazamiento desde el principio dejaba esa posición DENTRO de la\n\t * línea original, tantos caracteres antes como espacios se hubieran\n\t * recortado. Medido, con dos ediciones en la misma llamada —una difusa por\n\t * comillas tipográficas y otra en una línea con tres espacios al final—:\n\t *\n\t *   antes:   const a = \"x\";   ⏎ const b = 1;\n\t *   después: const a = \"z\"; const b = 1;      ← dos líneas en una\n\t *\n\t * Se perdían los espacios finales y, con ellos, el SALTO DE LÍNEA que nadie\n\t * había pedido tocar. En JavaScript a veces sigue compilando; con un\n\t * comentario de línea delante se come la línea siguiente, y en Python o en\n\t * YAML destruye el fichero.\n\t *\n\t * Así que el límite se ancla al FINAL de la línea original y el resto sigue\n\t * anclado al principio. La posición del salto de línea (justo delante del\n\t * límite) se ancla también al principio a propósito: es donde acaba un\n\t * reemplazo que llega al final del TEXTO de la línea, y anclarla al final\n\t * se llevaría por delante los espacios que el modelo no ha nombrado.\n\t */\n\tfunction aOriginal(posicionNormalizada: number): number {\n\t\tfor (let i = 0; i < baseLines.length; i++) {\n\t\t\tconst linea = baseLines[i];\n\t\t\tif (posicionNormalizada >= linea.start && posicionNormalizada <= linea.end) {\n\t\t\t\tif (posicionNormalizada === linea.end) return originalStarts[i] + originalLines[i].length;\n\t\t\t\treturn originalStarts[i] + (posicionNormalizada - linea.start);\n\t\t\t}\n\t\t}\n\t\tthrow new Error(\"La posición normalizada cae fuera del contenido base.\");\n\t}\n\n\tlet originalLineIndex = 0;\n\tlet result = \"\";\n\tfor (const group of groups) {\n\t\tresult += originalLines.slice(originalLineIndex, group.startLine).join(\"\");\n\n\t\t// Se empalma sobre los BYTES ORIGINALES, no sobre la forma normalizada.\n\t\t//\n\t\t// Antes esta rama cortaba de `baseContent`, y eso reescribía cada línea\n\t\t// del grupo desde el texto normalizado. Consecuencia medida, con dos\n\t\t// ediciones en la misma llamada —una difusa, otra exacta en la línea de\n\t\t// abajo—:\n\t\t//\n\t\t//   antes:   const msg = \"el “titulo” va aqui\" + compute(1);\n\t\t//   después: const msg = \"el \"titulo\" va aqui\" + compute(2);\n\t\t//\n\t\t// Nadie pidió tocar esas comillas, y el resultado ni siquiera compila:\n\t\t// quedan comillas rectas anidadas dentro de una cadena. Lo mismo pasaba\n\t\t// con `½` → `1⁄2`, con los guiones largos y con los espacios duros.\n\t\t//\n\t\t// La normalización es para CASAR. Restringirla a sustituciones de igual\n\t\t// longitud no basta: `“` y `\"` miden lo mismo y son bytes distintos, así\n\t\t// que \"preserva la longitud\" no es \"preserva el contenido\". Lo único que\n\t\t// lo garantiza es no escribir nunca desde el texto normalizado.\n\t\tconst inicioOriginal = aOriginal(baseLines[group.startLine].start);\n\t\tconst finOriginal = aOriginal(baseLines[group.endLine - 1].end);\n\t\tconst reubicadas = group.replacements.map((r) => ({\n\t\t\t...r,\n\t\t\tmatchIndex: aOriginal(r.matchIndex),\n\t\t\tmatchLength: aOriginal(r.matchIndex + r.matchLength) - aOriginal(r.matchIndex),\n\t\t}));\n\t\tresult += applyReplacements(originalContent.slice(inicioOriginal, finOriginal), reubicadas, inicioOriginal);\n\t\toriginalLineIndex = group.endLine;\n\t}\n\tresult += originalLines.slice(originalLineIndex).join(\"\");\n\n\treturn result;\n}\n\nexport interface FuzzyMatchResult {\n\t/** Whether a match was found */\n\tfound: boolean;\n\t/** The index where the match starts (in the content that should be used for replacement) */\n\tindex: number;\n\t/** Length of the matched text */\n\tmatchLength: number;\n\t/** Whether fuzzy matching was used (false = exact match) */\n\tusedFuzzyMatch: boolean;\n\t/**\n\t * The content to use for replacement operations.\n\t * When exact match: original content. When fuzzy match: normalized content.\n\t */\n\tcontentForReplacement: string;\n}\n\nexport interface Edit {\n\toldText: string;\n\tnewText: string;\n}\n\nexport interface AppliedEditsResult {\n\tbaseContent: string;\n\tnewContent: string;\n}\n\n/**\n * Find oldText in content, trying exact match first, then fuzzy match.\n * When fuzzy matching is used, the returned contentForReplacement is the\n * fuzzy-normalized version of the content (trailing whitespace stripped,\n * Unicode quotes/dashes normalized to ASCII).\n */\nexport function fuzzyFindText(content: string, oldText: string): FuzzyMatchResult {\n\t// Try exact match first\n\tconst exactIndex = content.indexOf(oldText);\n\tif (exactIndex !== -1) {\n\t\treturn {\n\t\t\tfound: true,\n\t\t\tindex: exactIndex,\n\t\t\tmatchLength: oldText.length,\n\t\t\tusedFuzzyMatch: false,\n\t\t\tcontentForReplacement: content,\n\t\t};\n\t}\n\n\t// Try fuzzy match - work entirely in normalized space\n\tconst fuzzyContent = normalizeForFuzzyMatch(content);\n\tconst fuzzyOldText = normalizeForFuzzyMatch(oldText);\n\tconst fuzzyIndex = fuzzyContent.indexOf(fuzzyOldText);\n\n\tif (fuzzyIndex === -1) {\n\t\treturn {\n\t\t\tfound: false,\n\t\t\tindex: -1,\n\t\t\tmatchLength: 0,\n\t\t\tusedFuzzyMatch: false,\n\t\t\tcontentForReplacement: content,\n\t\t};\n\t}\n\n\t// When fuzzy matching, return offsets in normalized space. Callers can use\n\t// the normalized content to compute replacements, then decide how much of\n\t// that normalized output should be written back.\n\treturn {\n\t\tfound: true,\n\t\tindex: fuzzyIndex,\n\t\tmatchLength: fuzzyOldText.length,\n\t\tusedFuzzyMatch: true,\n\t\tcontentForReplacement: fuzzyContent,\n\t};\n}\n\nfunction countOccurrences(content: string, oldText: string): number {\n\tconst fuzzyContent = normalizeForFuzzyMatch(content);\n\tconst fuzzyOldText = normalizeForFuzzyMatch(oldText);\n\treturn fuzzyContent.split(fuzzyOldText).length - 1;\n}\n\nfunction getNotFoundError(path: string, editIndex: number, totalEdits: number): Error {\n\tif (totalEdits === 1) {\n\t\treturn new Error(\n\t\t\t`Could not find the exact text in ${path}. The old text must match exactly including all whitespace and newlines.`,\n\t\t);\n\t}\n\treturn new Error(\n\t\t`Could not find edits[${editIndex}] in ${path}. The oldText must match exactly including all whitespace and newlines.`,\n\t);\n}\n\nfunction getDuplicateError(path: string, editIndex: number, totalEdits: number, occurrences: number): Error {\n\tif (totalEdits === 1) {\n\t\treturn new Error(\n\t\t\t`Found ${occurrences} occurrences of the text in ${path}. The text must be unique. Please provide more context to make it unique.`,\n\t\t);\n\t}\n\treturn new Error(\n\t\t`Found ${occurrences} occurrences of edits[${editIndex}] in ${path}. Each oldText must be unique. Please provide more context to make it unique.`,\n\t);\n}\n\nfunction getEmptyOldTextError(path: string, editIndex: number, totalEdits: number): Error {\n\tif (totalEdits === 1) {\n\t\treturn new Error(`oldText must not be empty in ${path}.`);\n\t}\n\treturn new Error(`edits[${editIndex}].oldText must not be empty in ${path}.`);\n}\n\nfunction getNoChangeError(path: string, totalEdits: number): Error {\n\tif (totalEdits === 1) {\n\t\treturn new Error(\n\t\t\t`No changes made to ${path}. The replacement produced identical content. This might indicate an issue with special characters or the text not existing as expected.`,\n\t\t);\n\t}\n\treturn new Error(`No changes made to ${path}. The replacements produced identical content.`);\n}\n\n/**\n * Apply one or more exact-text replacements to LF-normalized content.\n *\n * All edits are matched against the same original content. Replacements are\n * then applied in reverse order so offsets remain stable. If any edit needs\n * fuzzy matching, the operation runs in fuzzy-normalized content space and then\n * overlays those line-level changes onto the original content so unchanged line\n * blocks keep their original bytes.\n */\nexport function applyEditsToNormalizedContent(\n\tnormalizedContent: string,\n\tedits: Edit[],\n\tpath: string,\n): AppliedEditsResult {\n\tconst normalizedEdits = edits.map((edit) => ({\n\t\toldText: normalizeToLF(edit.oldText),\n\t\tnewText: normalizeToLF(edit.newText),\n\t}));\n\n\tfor (let i = 0; i < normalizedEdits.length; i++) {\n\t\tif (normalizedEdits[i].oldText.length === 0) {\n\t\t\tthrow getEmptyOldTextError(path, i, normalizedEdits.length);\n\t\t}\n\t}\n\n\tconst initialMatches = normalizedEdits.map((edit) => fuzzyFindText(normalizedContent, edit.oldText));\n\tconst usedFuzzyMatch = initialMatches.some((match) => match.usedFuzzyMatch);\n\tconst replacementBaseContent = usedFuzzyMatch ? normalizeForFuzzyMatch(normalizedContent) : normalizedContent;\n\n\tconst matchedEdits: MatchedEdit[] = [];\n\tfor (let i = 0; i < normalizedEdits.length; i++) {\n\t\tconst edit = normalizedEdits[i];\n\t\tconst matchResult = fuzzyFindText(replacementBaseContent, edit.oldText);\n\t\tif (!matchResult.found) {\n\t\t\t// Último intento antes de rechazar: casar ignorando la SANGRÍA.\n\t\t\t//\n\t\t\t// Es el error más frecuente que existe — Ada se indenta con tabuladores\n\t\t\t// y los modelos emiten espacios— y hasta ahora costaba un turno entero:\n\t\t\t// el modelo tenía que releer el fichero y reescribir el bloque a ciegas,\n\t\t\t// muchas veces repitiendo el mismo error.\n\t\t\t//\n\t\t\t// `casarIgnorandoSangria` devuelve `null` si el patrón sin sangría casa\n\t\t\t// en más de un sitio: quitar la sangría hace el patrón MENOS específico,\n\t\t\t// así que puede volver ambiguo algo que no lo era, y elegir por el\n\t\t\t// modelo cuál de los dos editar es peor que rechazar. Y re-sangra el\n\t\t\t// reemplazo con la sangría DEL FICHERO, no con la que mandó el modelo:\n\t\t\t// oh-my-pi casa más cargas que nosotros y de las diez que aplica, tres\n\t\t\t// corrompen, dos de ellas por esto. Aplicar no es aplicar bien.\n\t\t\tlet porSangria = casarIgnorandoSangria(replacementBaseContent, edit.oldText, edit.newText);\n\t\t\tif (!porSangria) {\n\t\t\t\t// Y antes de rendirse: quitarle al patrón el ruido que no es código.\n\t\t\t\t//\n\t\t\t\t// El caso más vergonzoso es el nuestro. `read` añade al final de lo\n\t\t\t\t// que devuelve `[Showing lines 1-5 of 5. Use offset=6 to continue.]`;\n\t\t\t\t// el modelo copia el bloque con la cabecera pegada y nosotros\n\t\t\t\t// rechazábamos la edición por «el texto no coincide exactamente».\n\t\t\t\t// Generábamos la contaminación y la castigábamos.\n\t\t\t\t//\n\t\t\t\t// `limpiarCarga` solo quita lo INEQUÍVOCO (vallas de markdown,\n\t\t\t\t// sentinelas de sobre, nuestra cabecera, y números de línea solo si\n\t\t\t\t// TODAS las líneas los llevan y van en orden). Preferimos dejar ruido\n\t\t\t\t// a borrar código: quitar de más casaría el patrón en el sitio\n\t\t\t\t// equivocado, y eso es corrupción silenciosa.\n\t\t\t\tconst limpia = limpiarCarga(edit.oldText);\n\t\t\t\tif (limpia.quitado.length > 0) {\n\t\t\t\t\tconst reintento = fuzzyFindText(replacementBaseContent, limpia.texto);\n\t\t\t\t\tif (reintento.found) {\n\t\t\t\t\t\tmatchedEdits.push({\n\t\t\t\t\t\t\teditIndex: i,\n\t\t\t\t\t\t\tmatchIndex: reintento.index,\n\t\t\t\t\t\t\tmatchLength: reintento.matchLength,\n\t\t\t\t\t\t\tnewText: coherenteConElBloque(\n\t\t\t\t\t\t\t\treplacementBaseContent.slice(reintento.index, reintento.index + reintento.matchLength),\n\t\t\t\t\t\t\t\tedit.newText,\n\t\t\t\t\t\t\t),\n\t\t\t\t\t\t});\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\tporSangria = casarIgnorandoSangria(replacementBaseContent, limpia.texto, edit.newText);\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (!porSangria) {\n\t\t\t\t// Y lo último: que el modelo haya elidido el medio con `...` entre dos\n\t\t\t\t// anclas, para no retipear lo que no cambia. `casarHuecoElidido`\n\t\t\t\t// compara las anclas con igualdad EXACTA de línea y exige que cada una\n\t\t\t\t// case en un solo sitio, porque este camino se traga líneas que el\n\t\t\t\t// modelo no ha nombrado: un fallo aquí no deja un espacio mal, borra\n\t\t\t\t// código.\n\t\t\t\tporSangria = casarHuecoElidido(replacementBaseContent, edit.oldText, edit.newText);\n\t\t\t}\n\t\t\tif (!porSangria) {\n\t\t\t\t// Último recurso: el modelo retecleó el contexto con una errata.\n\t\t\t\t//\n\t\t\t\t// Cuanto más contexto pedimos, más superficie tiene para equivocarse\n\t\t\t\t// en algo que no pretendía cambiar. `casarPorParecido` localiza por\n\t\t\t\t// similitud y —esto es lo que lo hace seguro— escribe la versión del\n\t\t\t\t// FICHERO en las líneas que el modelo solo estaba CITANDO. oh-my-pi\n\t\t\t\t// localiza igual pero escribe la errata, y su motor produce código que\n\t\t\t\t// no compila. Ver `core/edicion/parecido.ts`.\n\t\t\t\tconst porParecido = casarPorParecido(replacementBaseContent, edit.oldText, edit.newText);\n\t\t\t\tif (porParecido) {\n\t\t\t\t\tmatchedEdits.push({\n\t\t\t\t\t\teditIndex: i,\n\t\t\t\t\t\tmatchIndex: porParecido.indice,\n\t\t\t\t\t\tmatchLength: porParecido.longitud,\n\t\t\t\t\t\tnewText: porParecido.textoNuevo,\n\t\t\t\t\t});\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tthrow getNotFoundError(path, i, normalizedEdits.length);\n\t\t\t}\n\t\t\tmatchedEdits.push({\n\t\t\t\teditIndex: i,\n\t\t\t\tmatchIndex: porSangria.indice,\n\t\t\t\tmatchLength: porSangria.longitud,\n\t\t\t\tnewText: porSangria.textoNuevo,\n\t\t\t});\n\t\t\tcontinue;\n\t\t}\n\n\t\tconst occurrences = countOccurrences(replacementBaseContent, edit.oldText);\n\t\tif (occurrences > 1) {\n\t\t\tthrow getDuplicateError(path, i, normalizedEdits.length, occurrences);\n\t\t}\n\n\t\t// Coherencia de sangría, TAMBIÉN en el camino exacto.\n\t\t//\n\t\t// Cuando el `oldText` casa exacto, el `newText` se escribía tal cual y se\n\t\t// saltaba la lógica de sangría entera. Si el modelo teclea el bloque con\n\t\t// tabuladores en un fichero de espacios —cosa que hace constantemente— la\n\t\t// mezcla entraba sin que nadie la mirara. Medido: en Python es un\n\t\t// `TabError` y el fichero no arranca, y `parseo.ts` no cubre `.py`, así que\n\t\t// la red de reparación ni se despierta. Ver `edicion/sangria.ts`.\n\t\tconst trozoOriginal = replacementBaseContent.slice(\n\t\t\tmatchResult.index,\n\t\t\tmatchResult.index + matchResult.matchLength,\n\t\t);\n\t\tmatchedEdits.push({\n\t\t\teditIndex: i,\n\t\t\tmatchIndex: matchResult.index,\n\t\t\tmatchLength: matchResult.matchLength,\n\t\t\tnewText: coherenteConElBloque(trozoOriginal, edit.newText),\n\t\t});\n\t}\n\n\tmatchedEdits.sort((a, b) => a.matchIndex - b.matchIndex);\n\tfor (let i = 1; i < matchedEdits.length; i++) {\n\t\tconst previous = matchedEdits[i - 1];\n\t\tconst current = matchedEdits[i];\n\t\tif (previous.matchIndex + previous.matchLength > current.matchIndex) {\n\t\t\tthrow new Error(\n\t\t\t\t`edits[${previous.editIndex}] and edits[${current.editIndex}] overlap in ${path}. Merge them into one edit or target disjoint regions.`,\n\t\t\t);\n\t\t}\n\t}\n\n\tconst baseContent = normalizedContent;\n\tconst newContent = usedFuzzyMatch\n\t\t? applyReplacementsPreservingUnchangedLines(normalizedContent, replacementBaseContent, matchedEdits)\n\t\t: applyReplacements(replacementBaseContent, matchedEdits);\n\n\tif (baseContent === newContent) {\n\t\tthrow getNoChangeError(path, normalizedEdits.length);\n\t}\n\n\treturn { baseContent, newContent };\n}\n\n/** Generate a standard unified patch. */\nexport function generateUnifiedPatch(path: string, oldContent: string, newContent: string, contextLines = 4): string {\n\treturn Diff.createTwoFilesPatch(path, path, oldContent, newContent, undefined, undefined, {\n\t\tcontext: contextLines,\n\t\theaderOptions: Diff.FILE_HEADERS_ONLY,\n\t});\n}\n\n/**\n * Generate a display-oriented diff string with line numbers and context.\n * Returns both the diff string and the first changed line number (in the new file).\n */\nexport function generateDiffString(\n\toldContent: string,\n\tnewContent: string,\n\tcontextLines = 4,\n): { diff: string; firstChangedLine: number | undefined } {\n\tconst parts = Diff.diffLines(oldContent, newContent);\n\tconst output: string[] = [];\n\n\tconst oldLines = oldContent.split(\"\\n\");\n\tconst newLines = newContent.split(\"\\n\");\n\tconst maxLineNum = Math.max(oldLines.length, newLines.length);\n\tconst lineNumWidth = String(maxLineNum).length;\n\n\tlet oldLineNum = 1;\n\tlet newLineNum = 1;\n\tlet lastWasChange = false;\n\tlet firstChangedLine: number | undefined;\n\n\tfor (let i = 0; i < parts.length; i++) {\n\t\tconst part = parts[i];\n\t\tconst raw = part.value.split(\"\\n\");\n\t\tif (raw[raw.length - 1] === \"\") {\n\t\t\traw.pop();\n\t\t}\n\n\t\tif (part.added || part.removed) {\n\t\t\t// Capture the first changed line (in the new file)\n\t\t\tif (firstChangedLine === undefined) {\n\t\t\t\tfirstChangedLine = newLineNum;\n\t\t\t}\n\n\t\t\t// Show the change\n\t\t\tfor (const line of raw) {\n\t\t\t\tif (part.added) {\n\t\t\t\t\tconst lineNum = String(newLineNum).padStart(lineNumWidth, \" \");\n\t\t\t\t\toutput.push(`+${lineNum} ${line}`);\n\t\t\t\t\tnewLineNum++;\n\t\t\t\t} else {\n\t\t\t\t\t// removed\n\t\t\t\t\tconst lineNum = String(oldLineNum).padStart(lineNumWidth, \" \");\n\t\t\t\t\toutput.push(`-${lineNum} ${line}`);\n\t\t\t\t\toldLineNum++;\n\t\t\t\t}\n\t\t\t}\n\t\t\tlastWasChange = true;\n\t\t} else {\n\t\t\t// Context lines - only show a few before/after changes\n\t\t\tconst nextPartIsChange = i < parts.length - 1 && (parts[i + 1].added || parts[i + 1].removed);\n\t\t\tconst hasLeadingChange = lastWasChange;\n\t\t\tconst hasTrailingChange = nextPartIsChange;\n\n\t\t\tif (hasLeadingChange && hasTrailingChange) {\n\t\t\t\tif (raw.length <= contextLines * 2) {\n\t\t\t\t\tfor (const line of raw) {\n\t\t\t\t\t\tconst lineNum = String(oldLineNum).padStart(lineNumWidth, \" \");\n\t\t\t\t\t\toutput.push(` ${lineNum} ${line}`);\n\t\t\t\t\t\toldLineNum++;\n\t\t\t\t\t\tnewLineNum++;\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tconst leadingLines = raw.slice(0, contextLines);\n\t\t\t\t\tconst trailingLines = raw.slice(raw.length - contextLines);\n\t\t\t\t\tconst skippedLines = raw.length - leadingLines.length - trailingLines.length;\n\n\t\t\t\t\tfor (const line of leadingLines) {\n\t\t\t\t\t\tconst lineNum = String(oldLineNum).padStart(lineNumWidth, \" \");\n\t\t\t\t\t\toutput.push(` ${lineNum} ${line}`);\n\t\t\t\t\t\toldLineNum++;\n\t\t\t\t\t\tnewLineNum++;\n\t\t\t\t\t}\n\n\t\t\t\t\toutput.push(` ${\"\".padStart(lineNumWidth, \" \")} ...`);\n\t\t\t\t\toldLineNum += skippedLines;\n\t\t\t\t\tnewLineNum += skippedLines;\n\n\t\t\t\t\tfor (const line of trailingLines) {\n\t\t\t\t\t\tconst lineNum = String(oldLineNum).padStart(lineNumWidth, \" \");\n\t\t\t\t\t\toutput.push(` ${lineNum} ${line}`);\n\t\t\t\t\t\toldLineNum++;\n\t\t\t\t\t\tnewLineNum++;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else if (hasLeadingChange) {\n\t\t\t\tconst shownLines = raw.slice(0, contextLines);\n\t\t\t\tconst skippedLines = raw.length - shownLines.length;\n\n\t\t\t\tfor (const line of shownLines) {\n\t\t\t\t\tconst lineNum = String(oldLineNum).padStart(lineNumWidth, \" \");\n\t\t\t\t\toutput.push(` ${lineNum} ${line}`);\n\t\t\t\t\toldLineNum++;\n\t\t\t\t\tnewLineNum++;\n\t\t\t\t}\n\n\t\t\t\tif (skippedLines > 0) {\n\t\t\t\t\toutput.push(` ${\"\".padStart(lineNumWidth, \" \")} ...`);\n\t\t\t\t\toldLineNum += skippedLines;\n\t\t\t\t\tnewLineNum += skippedLines;\n\t\t\t\t}\n\t\t\t} else if (hasTrailingChange) {\n\t\t\t\tconst skippedLines = Math.max(0, raw.length - contextLines);\n\t\t\t\tif (skippedLines > 0) {\n\t\t\t\t\toutput.push(` ${\"\".padStart(lineNumWidth, \" \")} ...`);\n\t\t\t\t\toldLineNum += skippedLines;\n\t\t\t\t\tnewLineNum += skippedLines;\n\t\t\t\t}\n\n\t\t\t\tfor (const line of raw.slice(skippedLines)) {\n\t\t\t\t\tconst lineNum = String(oldLineNum).padStart(lineNumWidth, \" \");\n\t\t\t\t\toutput.push(` ${lineNum} ${line}`);\n\t\t\t\t\toldLineNum++;\n\t\t\t\t\tnewLineNum++;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\t// Skip these context lines entirely\n\t\t\t\toldLineNum += raw.length;\n\t\t\t\tnewLineNum += raw.length;\n\t\t\t}\n\n\t\t\tlastWasChange = false;\n\t\t}\n\t}\n\n\treturn { diff: output.join(\"\\n\"), firstChangedLine };\n}\n\nexport interface EditDiffResult {\n\tdiff: string;\n\tfirstChangedLine: number | undefined;\n}\n\nexport interface EditDiffError {\n\terror: string;\n}\n\n/**\n * Compute the diff for one or more edit operations without applying them.\n * Used for preview rendering in the TUI before the tool executes.\n */\nexport async function computeEditsDiff(\n\tpath: string,\n\tedits: Edit[],\n\tcwd: string,\n): Promise<EditDiffResult | EditDiffError> {\n\tconst absolutePath = resolveToCwd(path, cwd);\n\n\ttry {\n\t\t// Check if file exists and is readable\n\t\ttry {\n\t\t\tawait access(absolutePath, constants.R_OK);\n\t\t} catch (error: unknown) {\n\t\t\tconst errorMessage = error instanceof Error && \"code\" in error ? `Error code: ${error.code}` : String(error);\n\t\t\treturn { error: `Could not edit file: ${path}. ${errorMessage}.` };\n\t\t}\n\n\t\t// Read the file\n\t\tconst rawContent = await readFile(absolutePath, \"utf-8\");\n\n\t\t// Strip BOM before matching (LLM won't include invisible BOM in oldText)\n\t\tconst { text: content } = splitBom(rawContent);\n\t\tconst normalizedContent = normalizeToLF(content);\n\t\tconst { baseContent, newContent } = applyEditsToNormalizedContent(normalizedContent, edits, path);\n\n\t\t// Generate the diff\n\t\treturn generateDiffString(baseContent, newContent);\n\t} catch (err) {\n\t\treturn { error: err instanceof Error ? err.message : String(err) };\n\t}\n}\n\n/**\n * Compute the diff for a single edit operation without applying it.\n * Kept as a convenience wrapper for single-edit callers.\n */\nexport async function computeEditDiff(\n\tpath: string,\n\toldText: string,\n\tnewText: string,\n\tcwd: string,\n): Promise<EditDiffResult | EditDiffError> {\n\treturn computeEditsDiff(path, [{ oldText, newText }], cwd);\n}\n"]}

package/dist/core/tools/edit-diff.js

@@ -5,6 +5,10 @@ import * as Diff from "diff";
 import { constants } from "fs";
 import { access, readFile } from "fs/promises";
 import { splitBom } from "../../utils/text.js";
+import { casarHuecoElidido } from "../edicion/hueco.js";
+import { limpiarCarga } from "../edicion/limpiar-carga.js";
+import { casarPorParecido } from "../edicion/parecido.js";
+import { casarIgnorandoSangria, coherenteConElBloque } from "../edicion/sangria.js";
 import { resolveToCwd } from "./path-utils.js";
 export function detectLineEnding(content) {
     const crlfIdx = content.indexOf("\r\n");
@@ -28,9 +32,64 @@ export function restoreLineEndings(text, ending) {
  * - Normalize Unicode dashes/hyphens to ASCII hyphen
  * - Normalize special Unicode spaces to regular space
  */
+/**
+ * NFKC, pero SOLO donde no cambia el número de caracteres.
+ *
+ * El texto normalizado no se usa únicamente para comparar. Cuando alguna
+ * edición del lote necesita el camino difuso, `usedFuzzyMatch` es un `some()`
+ * sobre TODAS (más abajo, en `applyEditsToNormalizedContent`), y esa forma
+ * normalizada pasa a ser la base de escritura: `applyReplacementsPreservingUnchangedLines`
+ * reescribe entonces cada línea del grupo tocado desde ella.
+ *
+ * Un `.normalize("NFKC")` sobre el texto entero corrompía código que nadie
+ * había pedido tocar. Medido sobre un fichero real, con dos ediciones en la
+ * misma llamada —una difusa por comillas tipográficas, otra exacta en la línea
+ * de abajo—:
+ *
+ *   antes:   const razon = compute(1) + " ½ ";
+ *   después: const razon = compute(2) + " 1⁄2 ";
+ *
+ * El disparador es cotidiano: comillas tipográficas o guiones largos en el
+ * fichero y el modelo escribiendo los ASCII, que es lo normal en ficheros con
+ * textos de interfaz.
+ *
+ * El corte está medido, no elegido a ojo. Las conversiones que aportan al
+ * casado son 1:1 y se conservan:
+ *
+ *   `，`→`,`  `（`→`(`  `Ａ`→`A`  `１`→`1`     (ancho completo, 1 → 1)
+ *
+ * Las que corrompen cambian de longitud y se descartan:
+ *
+ *   `½`→`1⁄2` (1 → 3)   `fi`→`fi` (1 → 2)   `e`+`◌́`→`é` (2 → 1)
+ *
+ * Lo que se pierde es casar formas descompuestas (`cafe`+acento combinante
+ * contra `café`). Se acepta a propósito: es un caso estrecho frente a destruir
+ * el fichero del usuario en silencio.
+ *
+ * SEGUNDA RAZÓN, y ahora es la principal: `applyReplacementsPreservingUnchangedLines`
+ * traduce posiciones del texto normalizado a posiciones del original, y esa
+ * traducción SOLO es válida si dentro de una línea las dos coordenadas
+ * coinciden. Un NFKC completo rompería el mapeo (`½` ocupa 1 y `1⁄2` ocupa 3),
+ * y con él el empalme sobre bytes originales. Mantener el 1:1 no es una
+ * preferencia: es lo que hace correcta la función de traducción.
+ *
+ * Nota sobre por qué el 1:1 NO bastaba por sí solo, que es donde me equivoqué
+ * primero: preservar la LONGITUD no es preservar el CONTENIDO. `“` y `"` miden
+ * lo mismo y son bytes distintos, así que restringir NFKC dejaba fuera el ½
+ * pero seguía mutando comillas, guiones y espacios duros al escribir — y el
+ * caso de las comillas produce un fichero que ni siquiera compila. Lo que
+ * arregla eso es no escribir nunca desde el texto normalizado.
+ */
+function nfkcCaracterAcaracter(text) {
+    let salida = "";
+    for (const caracter of text) {
+        const normalizado = caracter.normalize("NFKC");
+        salida += normalizado.length === caracter.length ? normalizado : caracter;
+    }
+    return salida;
+}
 export function normalizeForFuzzyMatch(text) {
-    return (text
-        .normalize("NFKC")
+    return (nfkcCaracterAcaracter(text)
         // Strip trailing whitespace per line
         .split("\n")
         .map((line) => line.trimEnd())
@@ -120,13 +179,90 @@ export function applyReplacementsPreservingUnchangedLines(originalContent, baseC
         }
         groups.push({ ...range, replacements: [replacement] });
     }
+    // Desplazamientos de inicio de cada línea en el ORIGINAL, para poder
+    // traducir una posición del texto normalizado a su posición real.
+    const originalStarts = [];
+    {
+        let acumulado = 0;
+        for (const linea of originalLines) {
+            originalStarts.push(acumulado);
+            acumulado += linea.length;
+        }
+    }
+    /**
+     * De una posición en el texto normalizado a la misma posición en el
+     * original.
+     *
+     * Dentro del TEXTO de una línea las dos coordenadas coinciden: todas las
+     * sustituciones de `normalizeForFuzzyMatch` son de un carácter por otro
+     * —incluido el NFKC, que ahora solo se aplica donde es 1:1— y lo único que
+     * cambia la longitud es el recorte de espacios FINALES. Entre líneas sí
+     * difieren, y por eso hay que ir línea a línea.
+     *
+     * PERO el recorte de espacios finales NO está «detrás de cualquier posición
+     * que nos interese», que es lo que decía aquí y era falso: el LÍMITE de una
+     * línea es una posición que interesa —la usan el final de un grupo y el
+     * final de un reemplazo multilínea— y cae justo detrás del recorte. Sumar
+     * el desplazamiento desde el principio dejaba esa posición DENTRO de la
+     * línea original, tantos caracteres antes como espacios se hubieran
+     * recortado. Medido, con dos ediciones en la misma llamada —una difusa por
+     * comillas tipográficas y otra en una línea con tres espacios al final—:
+     *
+     *   antes:   const a = "x";   ⏎ const b = 1;
+     *   después: const a = "z"; const b = 1;      ← dos líneas en una
+     *
+     * Se perdían los espacios finales y, con ellos, el SALTO DE LÍNEA que nadie
+     * había pedido tocar. En JavaScript a veces sigue compilando; con un
+     * comentario de línea delante se come la línea siguiente, y en Python o en
+     * YAML destruye el fichero.
+     *
+     * Así que el límite se ancla al FINAL de la línea original y el resto sigue
+     * anclado al principio. La posición del salto de línea (justo delante del
+     * límite) se ancla también al principio a propósito: es donde acaba un
+     * reemplazo que llega al final del TEXTO de la línea, y anclarla al final
+     * se llevaría por delante los espacios que el modelo no ha nombrado.
+     */
+    function aOriginal(posicionNormalizada) {
+        for (let i = 0; i < baseLines.length; i++) {
+            const linea = baseLines[i];
+            if (posicionNormalizada >= linea.start && posicionNormalizada <= linea.end) {
+                if (posicionNormalizada === linea.end)
+                    return originalStarts[i] + originalLines[i].length;
+                return originalStarts[i] + (posicionNormalizada - linea.start);
+            }
+        }
+        throw new Error("La posición normalizada cae fuera del contenido base.");
+    }
     let originalLineIndex = 0;
     let result = "";
     for (const group of groups) {
         result += originalLines.slice(originalLineIndex, group.startLine).join("");
-        const groupStartOffset = baseLines[group.startLine].start;
-        const groupEndOffset = baseLines[group.endLine - 1].end;
-        result += applyReplacements(baseContent.slice(groupStartOffset, groupEndOffset), group.replacements, groupStartOffset);
+        // Se empalma sobre los BYTES ORIGINALES, no sobre la forma normalizada.
+        //
+        // Antes esta rama cortaba de `baseContent`, y eso reescribía cada línea
+        // del grupo desde el texto normalizado. Consecuencia medida, con dos
+        // ediciones en la misma llamada —una difusa, otra exacta en la línea de
+        // abajo—:
+        //
+        //   antes:   const msg = "el “titulo” va aqui" + compute(1);
+        //   después: const msg = "el "titulo" va aqui" + compute(2);
+        //
+        // Nadie pidió tocar esas comillas, y el resultado ni siquiera compila:
+        // quedan comillas rectas anidadas dentro de una cadena. Lo mismo pasaba
+        // con `½` → `1⁄2`, con los guiones largos y con los espacios duros.
+        //
+        // La normalización es para CASAR. Restringirla a sustituciones de igual
+        // longitud no basta: `“` y `"` miden lo mismo y son bytes distintos, así
+        // que "preserva la longitud" no es "preserva el contenido". Lo único que
+        // lo garantiza es no escribir nunca desde el texto normalizado.
+        const inicioOriginal = aOriginal(baseLines[group.startLine].start);
+        const finOriginal = aOriginal(baseLines[group.endLine - 1].end);
+        const reubicadas = group.replacements.map((r) => ({
+            ...r,
+            matchIndex: aOriginal(r.matchIndex),
+            matchLength: aOriginal(r.matchIndex + r.matchLength) - aOriginal(r.matchIndex),
+        }));
+        result += applyReplacements(originalContent.slice(inicioOriginal, finOriginal), reubicadas, inicioOriginal);
         originalLineIndex = group.endLine;
     }
     result += originalLines.slice(originalLineIndex).join("");
@@ -230,17 +366,106 @@ export function applyEditsToNormalizedContent(normalizedContent, edits, path) {
         const edit = normalizedEdits[i];
         const matchResult = fuzzyFindText(replacementBaseContent, edit.oldText);
         if (!matchResult.found) {
-            throw getNotFoundError(path, i, normalizedEdits.length);
+            // Último intento antes de rechazar: casar ignorando la SANGRÍA.
+            //
+            // Es el error más frecuente que existe — Ada se indenta con tabuladores
+            // y los modelos emiten espacios— y hasta ahora costaba un turno entero:
+            // el modelo tenía que releer el fichero y reescribir el bloque a ciegas,
+            // muchas veces repitiendo el mismo error.
+            //
+            // `casarIgnorandoSangria` devuelve `null` si el patrón sin sangría casa
+            // en más de un sitio: quitar la sangría hace el patrón MENOS específico,
+            // así que puede volver ambiguo algo que no lo era, y elegir por el
+            // modelo cuál de los dos editar es peor que rechazar. Y re-sangra el
+            // reemplazo con la sangría DEL FICHERO, no con la que mandó el modelo:
+            // oh-my-pi casa más cargas que nosotros y de las diez que aplica, tres
+            // corrompen, dos de ellas por esto. Aplicar no es aplicar bien.
+            let porSangria = casarIgnorandoSangria(replacementBaseContent, edit.oldText, edit.newText);
+            if (!porSangria) {
+                // Y antes de rendirse: quitarle al patrón el ruido que no es código.
+                //
+                // El caso más vergonzoso es el nuestro. `read` añade al final de lo
+                // que devuelve `[Showing lines 1-5 of 5. Use offset=6 to continue.]`;
+                // el modelo copia el bloque con la cabecera pegada y nosotros
+                // rechazábamos la edición por «el texto no coincide exactamente».
+                // Generábamos la contaminación y la castigábamos.
+                //
+                // `limpiarCarga` solo quita lo INEQUÍVOCO (vallas de markdown,
+                // sentinelas de sobre, nuestra cabecera, y números de línea solo si
+                // TODAS las líneas los llevan y van en orden). Preferimos dejar ruido
+                // a borrar código: quitar de más casaría el patrón en el sitio
+                // equivocado, y eso es corrupción silenciosa.
+                const limpia = limpiarCarga(edit.oldText);
+                if (limpia.quitado.length > 0) {
+                    const reintento = fuzzyFindText(replacementBaseContent, limpia.texto);
+                    if (reintento.found) {
+                        matchedEdits.push({
+                            editIndex: i,
+                            matchIndex: reintento.index,
+                            matchLength: reintento.matchLength,
+                            newText: coherenteConElBloque(replacementBaseContent.slice(reintento.index, reintento.index + reintento.matchLength), edit.newText),
+                        });
+                        continue;
+                    }
+                    porSangria = casarIgnorandoSangria(replacementBaseContent, limpia.texto, edit.newText);
+                }
+            }
+            if (!porSangria) {
+                // Y lo último: que el modelo haya elidido el medio con `...` entre dos
+                // anclas, para no retipear lo que no cambia. `casarHuecoElidido`
+                // compara las anclas con igualdad EXACTA de línea y exige que cada una
+                // case en un solo sitio, porque este camino se traga líneas que el
+                // modelo no ha nombrado: un fallo aquí no deja un espacio mal, borra
+                // código.
+                porSangria = casarHuecoElidido(replacementBaseContent, edit.oldText, edit.newText);
+            }
+            if (!porSangria) {
+                // Último recurso: el modelo retecleó el contexto con una errata.
+                //
+                // Cuanto más contexto pedimos, más superficie tiene para equivocarse
+                // en algo que no pretendía cambiar. `casarPorParecido` localiza por
+                // similitud y —esto es lo que lo hace seguro— escribe la versión del
+                // FICHERO en las líneas que el modelo solo estaba CITANDO. oh-my-pi
+                // localiza igual pero escribe la errata, y su motor produce código que
+                // no compila. Ver `core/edicion/parecido.ts`.
+                const porParecido = casarPorParecido(replacementBaseContent, edit.oldText, edit.newText);
+                if (porParecido) {
+                    matchedEdits.push({
+                        editIndex: i,
+                        matchIndex: porParecido.indice,
+                        matchLength: porParecido.longitud,
+                        newText: porParecido.textoNuevo,
+                    });
+                    continue;
+                }
+                throw getNotFoundError(path, i, normalizedEdits.length);
+            }
+            matchedEdits.push({
+                editIndex: i,
+                matchIndex: porSangria.indice,
+                matchLength: porSangria.longitud,
+                newText: porSangria.textoNuevo,
+            });
+            continue;
         }
         const occurrences = countOccurrences(replacementBaseContent, edit.oldText);
         if (occurrences > 1) {
             throw getDuplicateError(path, i, normalizedEdits.length, occurrences);
         }
+        // Coherencia de sangría, TAMBIÉN en el camino exacto.
+        //
+        // Cuando el `oldText` casa exacto, el `newText` se escribía tal cual y se
+        // saltaba la lógica de sangría entera. Si el modelo teclea el bloque con
+        // tabuladores en un fichero de espacios —cosa que hace constantemente— la
+        // mezcla entraba sin que nadie la mirara. Medido: en Python es un
+        // `TabError` y el fichero no arranca, y `parseo.ts` no cubre `.py`, así que
+        // la red de reparación ni se despierta. Ver `edicion/sangria.ts`.
+        const trozoOriginal = replacementBaseContent.slice(matchResult.index, matchResult.index + matchResult.matchLength);
         matchedEdits.push({
             editIndex: i,
             matchIndex: matchResult.index,
             matchLength: matchResult.matchLength,
-            newText: edit.newText,
+            newText: coherenteConElBloque(trozoOriginal, edit.newText),
         });
     }
     matchedEdits.sort((a, b) => a.matchIndex - b.matchIndex);