Something went wrong. Try again.
more up to date at codeberg https://codeberg.org/cowie/tau.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455/** * Shared diff computation utilities for the edit tool. * Used by both edit.ts (for execution) and tool-execution.ts (for preview rendering). */
import * as Diff from "diff";import { constants } from "fs";import { access, readFile } from "fs/promises";import { resolveToCwd } from "./path-utils.ts";
export function detectLineEnding(content: string): "\r\n" | "\n" { const crlfIdx = content.indexOf("\r\n"); const lfIdx = content.indexOf("\n"); if (lfIdx === -1) return "\n"; if (crlfIdx === -1) return "\n"; return crlfIdx < lfIdx ? "\r\n" : "\n";}
export function normalizeToLF(text: string): string { return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");}
export function restoreLineEndings(text: string, ending: "\r\n" | "\n"): string { return ending === "\r\n" ? text.replace(/\n/g, "\r\n") : text;}
/** * Normalize text for fuzzy matching. Applies progressive 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 */export function normalizeForFuzzyMatch(text: string): string { return ( text .normalize("NFKC") // Strip trailing whitespace per line .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 // 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, " ") );}
export interface FuzzyMatchResult { /** Whether a match was found */ found: boolean; /** The index where the match starts (in the content that should be used for replacement) */ index: number; /** Length of the matched text */ matchLength: number; /** Whether fuzzy matching was used (false = exact match) */ usedFuzzyMatch: boolean; /** * The content to use for replacement operations. * When exact match: original content. When fuzzy match: normalized content. */ contentForReplacement: string;}
export interface Edit { oldText: string; newText: string;}
interface MatchedEdit { editIndex: number; matchIndex: number; matchLength: number; newText: string;}
export interface AppliedEditsResult { baseContent: string; newContent: string;}
/** * Find oldText in content, trying exact match first, then fuzzy match. * When fuzzy matching is used, the returned contentForReplacement is the * fuzzy-normalized version of the content (trailing whitespace stripped, * Unicode quotes/dashes normalized to ASCII). */export function fuzzyFindText(content: string, oldText: string): FuzzyMatchResult { // Try exact match first const exactIndex = content.indexOf(oldText); if (exactIndex !== -1) { return { found: true, index: exactIndex, matchLength: oldText.length, usedFuzzyMatch: false, contentForReplacement: content, }; }
// Try fuzzy match - work entirely in normalized space const fuzzyContent = normalizeForFuzzyMatch(content); const fuzzyOldText = normalizeForFuzzyMatch(oldText); const fuzzyIndex = fuzzyContent.indexOf(fuzzyOldText);
if (fuzzyIndex === -1) { return { found: false, index: -1, matchLength: 0, usedFuzzyMatch: false, contentForReplacement: content, }; }
// When fuzzy matching, we work in the normalized space for replacement. // This means the output will have normalized whitespace/quotes/dashes, // which is acceptable since we're fixing minor formatting differences anyway. return { found: true, index: fuzzyIndex, matchLength: fuzzyOldText.length, usedFuzzyMatch: true, contentForReplacement: fuzzyContent, };}
/** Strip UTF-8 BOM if present, return both the BOM (if any) and the text without it */export function stripBom(content: string): { bom: string; text: string } { return content.startsWith("\uFEFF") ? { bom: "\uFEFF", text: content.slice(1) } : { bom: "", text: content };}
function countOccurrences(content: string, oldText: string): number { const fuzzyContent = normalizeForFuzzyMatch(content); const fuzzyOldText = normalizeForFuzzyMatch(oldText); return fuzzyContent.split(fuzzyOldText).length - 1;}
function getNotFoundError(path: string, editIndex: number, totalEdits: number): Error { if (totalEdits === 1) { return new Error( `Could not find the exact text in ${path}. The old text must match exactly including all whitespace and newlines.`, ); } return new Error( `Could not find edits[${editIndex}] in ${path}. The oldText must match exactly including all whitespace and newlines.`, );}
function getDuplicateError(path: string, editIndex: number, totalEdits: number, occurrences: number): Error { if (totalEdits === 1) { return new Error( `Found ${occurrences} occurrences of the text in ${path}. The text must be unique. Please provide more context to make it unique.`, ); } return new Error( `Found ${occurrences} occurrences of edits[${editIndex}] in ${path}. Each oldText must be unique. Please provide more context to make it unique.`, );}
function getEmptyOldTextError(path: string, editIndex: number, totalEdits: number): Error { if (totalEdits === 1) { return new Error(`oldText must not be empty in ${path}.`); } return new Error(`edits[${editIndex}].oldText must not be empty in ${path}.`);}
function getNoChangeError(path: string, totalEdits: number): Error { if (totalEdits === 1) { return new Error( `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.`, ); } return new Error(`No changes made to ${path}. The replacements produced identical content.`);}
/** * Apply one or more exact-text replacements to LF-normalized content. * * All edits are matched against the same original content. Replacements are * then applied in reverse order so offsets remain stable. If any edit needs * fuzzy matching, the operation runs in fuzzy-normalized content space to * preserve current single-edit behavior. */export function applyEditsToNormalizedContent( normalizedContent: string, edits: Edit[], path: string,): AppliedEditsResult { const normalizedEdits = edits.map((edit) => ({ oldText: normalizeToLF(edit.oldText), newText: normalizeToLF(edit.newText), }));
for (let i = 0; i < normalizedEdits.length; i++) { if (normalizedEdits[i].oldText.length === 0) { throw getEmptyOldTextError(path, i, normalizedEdits.length); } }
const initialMatches = normalizedEdits.map((edit) => fuzzyFindText(normalizedContent, edit.oldText)); const baseContent = initialMatches.some((match) => match.usedFuzzyMatch) ? normalizeForFuzzyMatch(normalizedContent) : normalizedContent;
const matchedEdits: MatchedEdit[] = []; for (let i = 0; i < normalizedEdits.length; i++) { const edit = normalizedEdits[i]; const matchResult = fuzzyFindText(baseContent, edit.oldText); if (!matchResult.found) { throw getNotFoundError(path, i, normalizedEdits.length); }
const occurrences = countOccurrences(baseContent, edit.oldText); if (occurrences > 1) { throw getDuplicateError(path, i, normalizedEdits.length, occurrences); }
matchedEdits.push({ editIndex: i, matchIndex: matchResult.index, matchLength: matchResult.matchLength, newText: edit.newText, }); }
matchedEdits.sort((a, b) => a.matchIndex - b.matchIndex); for (let i = 1; i < matchedEdits.length; i++) { const previous = matchedEdits[i - 1]; const current = matchedEdits[i]; if (previous.matchIndex + previous.matchLength > current.matchIndex) { throw new Error( `edits[${previous.editIndex}] and edits[${current.editIndex}] overlap in ${path}. Merge them into one edit or target disjoint regions.`, ); } }
let newContent = baseContent; for (let i = matchedEdits.length - 1; i >= 0; i--) { const edit = matchedEdits[i]; newContent = newContent.substring(0, edit.matchIndex) + edit.newText + newContent.substring(edit.matchIndex + edit.matchLength); }
if (baseContent === newContent) { throw getNoChangeError(path, normalizedEdits.length); }
return { baseContent, newContent };}
/** Generate a standard unified patch. */export function generateUnifiedPatch(path: string, oldContent: string, newContent: string, contextLines = 4): string { return Diff.createTwoFilesPatch(path, path, oldContent, newContent, undefined, undefined, { context: contextLines, headerOptions: Diff.FILE_HEADERS_ONLY, });}
/** * Generate a display-oriented diff string with line numbers and context. * Returns both the diff string and the first changed line number (in the new file). */export function generateDiffString( oldContent: string, newContent: string, contextLines = 4,): { diff: string; firstChangedLine: number | undefined } { const parts = Diff.diffLines(oldContent, newContent); const output: string[] = [];
const oldLines = oldContent.split("\n"); const newLines = newContent.split("\n"); const maxLineNum = Math.max(oldLines.length, newLines.length); const lineNumWidth = String(maxLineNum).length;
let oldLineNum = 1; let newLineNum = 1; let lastWasChange = false; let firstChangedLine: number | undefined;
for (let i = 0; i < parts.length; i++) { const part = parts[i]; const raw = part.value.split("\n"); if (raw[raw.length - 1] === "") { raw.pop(); }
if (part.added || part.removed) { // Capture the first changed line (in the new file) if (firstChangedLine === undefined) { firstChangedLine = newLineNum; }
// Show the change for (const line of raw) { if (part.added) { const lineNum = String(newLineNum).padStart(lineNumWidth, " "); output.push(`+${lineNum} ${line}`); newLineNum++; } else { // removed const lineNum = String(oldLineNum).padStart(lineNumWidth, " "); output.push(`-${lineNum} ${line}`); oldLineNum++; } } lastWasChange = true; } else { // Context lines - only show a few before/after changes const nextPartIsChange = i < parts.length - 1 && (parts[i + 1].added || parts[i + 1].removed); const hasLeadingChange = lastWasChange; const hasTrailingChange = nextPartIsChange;
if (hasLeadingChange && hasTrailingChange) { if (raw.length <= contextLines * 2) { for (const line of raw) { const lineNum = String(oldLineNum).padStart(lineNumWidth, " "); output.push(` ${lineNum} ${line}`); oldLineNum++; newLineNum++; } } else { const leadingLines = raw.slice(0, contextLines); const trailingLines = raw.slice(raw.length - contextLines); const skippedLines = raw.length - leadingLines.length - trailingLines.length;
for (const line of leadingLines) { const lineNum = String(oldLineNum).padStart(lineNumWidth, " "); output.push(` ${lineNum} ${line}`); oldLineNum++; newLineNum++; }
output.push(` ${"".padStart(lineNumWidth, " ")} ...`); oldLineNum += skippedLines; newLineNum += skippedLines;
for (const line of trailingLines) { const lineNum = String(oldLineNum).padStart(lineNumWidth, " "); output.push(` ${lineNum} ${line}`); oldLineNum++; newLineNum++; } } } else if (hasLeadingChange) { const shownLines = raw.slice(0, contextLines); const skippedLines = raw.length - shownLines.length;
for (const line of shownLines) { const lineNum = String(oldLineNum).padStart(lineNumWidth, " "); output.push(` ${lineNum} ${line}`); oldLineNum++; newLineNum++; }
if (skippedLines > 0) { output.push(` ${"".padStart(lineNumWidth, " ")} ...`); oldLineNum += skippedLines; newLineNum += skippedLines; } } else if (hasTrailingChange) { const skippedLines = Math.max(0, raw.length - contextLines); if (skippedLines > 0) { output.push(` ${"".padStart(lineNumWidth, " ")} ...`); oldLineNum += skippedLines; newLineNum += skippedLines; }
for (const line of raw.slice(skippedLines)) { const lineNum = String(oldLineNum).padStart(lineNumWidth, " "); output.push(` ${lineNum} ${line}`); oldLineNum++; newLineNum++; } } else { // Skip these context lines entirely oldLineNum += raw.length; newLineNum += raw.length; }
lastWasChange = false; } }
return { diff: output.join("\n"), firstChangedLine };}
export interface EditDiffResult { diff: string; firstChangedLine: number | undefined;}
export interface EditDiffError { error: string;}
/** * Compute the diff for one or more edit operations without applying them. * Used for preview rendering in the TUI before the tool executes. */export async function computeEditsDiff( path: string, edits: Edit[], cwd: string,): Promise<EditDiffResult | EditDiffError> { const absolutePath = resolveToCwd(path, cwd);
try { // Check if file exists and is readable try { await access(absolutePath, constants.R_OK); } catch (error: unknown) { const errorMessage = error instanceof Error && "code" in error ? `Error code: ${error.code}` : String(error); return { error: `Could not edit file: ${path}. ${errorMessage}.` }; }
// Read the file const rawContent = await readFile(absolutePath, "utf-8");
// Strip BOM before matching (LLM won't include invisible BOM in oldText) const { text: content } = stripBom(rawContent); const normalizedContent = normalizeToLF(content); const { baseContent, newContent } = applyEditsToNormalizedContent(normalizedContent, edits, path);
// Generate the diff return generateDiffString(baseContent, newContent); } catch (err) { return { error: err instanceof Error ? err.message : String(err) }; }}
/** * Compute the diff for a single edit operation without applying it. * Kept as a convenience wrapper for single-edit callers. */export async function computeEditDiff( path: string, oldText: string, newText: string, cwd: string,): Promise<EditDiffResult | EditDiffError> { return computeEditsDiff(path, [{ oldText, newText }], cwd);}