@shanepadgett/tau-agent 0.1.0

package/extensions/patch/matcher.ts

@@ -0,0 +1,236 @@
+import { type LineRange, mergeLineRanges } from "../../shared/ranges.js";
+
+export interface ChunkLine {
+	prefix: " " | "+" | "-";
+	text: string;
+}
+
+export interface UpdateFileChunk {
+	changeContext?: string;
+	lines: ChunkLine[];
+	isEndOfFile: boolean;
+}
+
+export interface SnapshotRange extends LineRange {}
+
+export interface ApplyChunksResult {
+	content: string;
+	snapshotRanges: SnapshotRange[];
+}
+
+interface TextParts {
+	bom: string;
+	text: string;
+	lineEnding: "\n" | "\r\n";
+}
+
+function stripBom(content: string): { bom: string; text: string } {
+	return content.startsWith("\uFEFF") ? { bom: "\uFEFF", text: content.slice(1) } : { bom: "", text: content };
+}
+
+function detectLineEnding(content: string): "\n" | "\r\n" {
+	const crlfIndex = content.indexOf("\r\n");
+	const lfIndex = content.indexOf("\n");
+	if (lfIndex === -1 || crlfIndex === -1) return "\n";
+	return crlfIndex < lfIndex ? "\r\n" : "\n";
+}
+
+function normalizeToLf(content: string): string {
+	return content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+
+function restoreLineEndings(content: string, lineEnding: "\n" | "\r\n"): string {
+	return lineEnding === "\r\n" ? content.replace(/\n/g, "\r\n") : content;
+}
+
+function splitText(content: string): TextParts {
+	const { bom, text } = stripBom(content);
+	return {
+		bom,
+		text: normalizeToLf(text),
+		lineEnding: detectLineEnding(text),
+	};
+}
+
+function splitLogicalLines(content: string): string[] {
+	const lines = content.split("\n");
+	if (lines[lines.length - 1] === "") lines.pop();
+	return lines;
+}
+
+export function countLogicalLines(content: string): number {
+	return splitLogicalLines(normalizeToLf(stripBom(content).text)).length;
+}
+
+function normalizeUnicodeText(value: string): string {
+	return value
+		.normalize("NFKC")
+		.replace(/[\u2018\u2019\u201A\u201B]/g, "'")
+		.replace(/[\u201C\u201D\u201E\u201F]/g, '"')
+		.replace(/[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]/g, "-")
+		.replace(/[\u00A0\u1680\u2000-\u200A\u202F\u205F\u3000]/g, " ");
+}
+
+function normalizeForFuzzyMatch(value: string): string {
+	return normalizeUnicodeText(value).trimEnd();
+}
+
+function matchesAt(source: string[], pattern: string[], start: number, normalize: (value: string) => string): boolean {
+	if (start < 0 || start + pattern.length > source.length) return false;
+	for (let offset = 0; offset < pattern.length; offset += 1) {
+		const sourceLine = source[start + offset];
+		const patternLine = pattern[offset];
+		if (sourceLine === undefined || patternLine === undefined) return false;
+		if (normalize(sourceLine) !== normalize(patternLine)) return false;
+	}
+	return true;
+}
+
+const NORMALIZERS: ReadonlyArray<(value: string) => string> = [
+	(value) => value,
+	(value) => value.trimEnd(),
+	(value) => value.trim(),
+	normalizeForFuzzyMatch,
+];
+
+function findSequenceMatches(lines: string[], pattern: string[], start: number): number[] {
+	if (pattern.length === 0) return [Math.min(Math.max(start, 0), lines.length)];
+	for (const normalize of NORMALIZERS) {
+		const matches: number[] = [];
+		for (let index = Math.max(start, 0); index <= lines.length - pattern.length; index += 1) {
+			if (matchesAt(lines, pattern, index, normalize)) matches.push(index);
+		}
+		if (matches.length > 0) return matches;
+	}
+	return [];
+}
+
+function seekSequence(lines: string[], pattern: string[], start: number): number {
+	return findSequenceMatches(lines, pattern, start)[0] ?? -1;
+}
+
+function buildReplacement(chunk: UpdateFileChunk, fileLines: string[], matchIndex: number): string[] {
+	const result: string[] = [];
+	let fileOffset = 0;
+	for (const line of chunk.lines) {
+		if (line.prefix === "+") {
+			result.push(line.text);
+		} else if (line.prefix === "-") {
+			fileOffset += 1;
+		} else {
+			result.push(fileLines[matchIndex + fileOffset] ?? line.text);
+			fileOffset += 1;
+		}
+	}
+	return result;
+}
+
+export function applyChunksWithRanges(currentContent: string, chunks: UpdateFileChunk[]): ApplyChunksResult {
+	const parts = splitText(currentContent);
+	const lines = splitLogicalLines(parts.text);
+	const replacements: Array<{ index: number; deleteCount: number; insert: string[]; order: number }> = [];
+	const rawRanges: Array<{ index: number; deleteCount: number; insertCount: number }> = [];
+	let lineIndex = 0;
+	let order = 0;
+
+	for (let ci = 0; ci < chunks.length; ci += 1) {
+		const chunk = chunks[ci];
+		if (chunk === undefined) continue;
+		const oldLines = chunk.lines.filter((l) => l.prefix !== "+").map((l) => l.text);
+
+		if (chunk.changeContext) {
+			const contextIndex = seekSequence(lines, [chunk.changeContext], lineIndex);
+			if (contextIndex < 0) {
+				throw new UpdateChunkApplyError(
+					ci + 1,
+					chunks.length,
+					formatContextHint(chunk),
+					"could not find update context",
+				);
+			}
+			lineIndex = contextIndex + 1;
+		}
+
+		if (oldLines.length === 0) {
+			const insertIndex = lines.length;
+			const insert = chunk.lines.map((l) => l.text);
+			replacements.push({ index: insertIndex, deleteCount: 0, insert, order });
+			order += 1;
+			rawRanges.push({ index: insertIndex, deleteCount: 0, insertCount: insert.length });
+			continue;
+		}
+
+		let matchIndex = -1;
+		if (chunk.isEndOfFile) {
+			const eofIndex = lines.length - oldLines.length;
+			if (eofIndex >= lineIndex && seekSequence(lines, oldLines, eofIndex) === eofIndex) {
+				matchIndex = eofIndex;
+			}
+		}
+		if (matchIndex < 0) matchIndex = seekSequence(lines, oldLines, lineIndex);
+		if (matchIndex < 0) {
+			throw new UpdateChunkApplyError(ci + 1, chunks.length, formatContextHint(chunk), "could not match");
+		}
+
+		const replacement = buildReplacement(chunk, lines, matchIndex);
+		replacements.push({ index: matchIndex, deleteCount: oldLines.length, insert: replacement, order });
+		order += 1;
+		rawRanges.push({ index: matchIndex, deleteCount: oldLines.length, insertCount: replacement.length });
+		lineIndex = matchIndex + oldLines.length;
+	}
+
+	const output = [...lines];
+	replacements
+		.sort((a, b) => b.index - a.index || b.order - a.order)
+		.forEach((r) => {
+			output.splice(r.index, r.deleteCount, ...r.insert);
+		});
+
+	const joined = output.join("\n");
+	const normalized = joined === "" ? "" : `${joined}\n`;
+	const next = parts.bom + restoreLineEndings(normalized, parts.lineEnding);
+	return { content: next, snapshotRanges: mergeLineRanges(toPostApplyRanges(rawRanges, output.length)) };
+}
+
+function toPostApplyRanges(
+	rawRanges: Array<{ index: number; deleteCount: number; insertCount: number }>,
+	lineCount: number,
+): SnapshotRange[] {
+	const ranges: SnapshotRange[] = [];
+	let delta = 0;
+	for (const range of rawRanges) {
+		const postIndex = range.index + delta;
+		if (range.insertCount > 0) {
+			const startLine = Math.max(1, postIndex + 1);
+			const endLine = Math.min(lineCount, postIndex + range.insertCount);
+			if (endLine >= startLine) ranges.push({ startLine, endLine });
+		} else if (lineCount > 0) {
+			const anchor = Math.min(Math.max(1, postIndex + 1), lineCount);
+			ranges.push({ startLine: anchor, endLine: anchor });
+		}
+		delta += range.insertCount - range.deleteCount;
+	}
+	return ranges;
+}
+
+export class UpdateChunkApplyError extends Error {
+	chunkIndex: number;
+	totalChunks: number;
+	contextHint?: string;
+
+	constructor(chunkIndex: number, totalChunks: number, contextHint: string | undefined, message: string) {
+		super(message);
+		this.name = "UpdateChunkApplyError";
+		this.chunkIndex = chunkIndex;
+		this.totalChunks = totalChunks;
+		this.contextHint = contextHint;
+	}
+}
+
+function formatContextHint(chunk: UpdateFileChunk): string | undefined {
+	const raw = chunk.changeContext ?? chunk.lines.find((l) => l.text.trim().length > 0)?.text;
+	if (!raw) return undefined;
+	const compact = raw.replace(/\s+/g, " ").trim();
+	if (!compact) return undefined;
+	return compact.length > 80 ? `${compact.slice(0, 77)}...` : compact;
+}

package/extensions/patch/parser.ts

@@ -0,0 +1,347 @@
+import type { ChunkLine, UpdateFileChunk } from "./matcher.ts";
+
+type ParsedSection =
+	| { type: "add"; path: string; content: string; linesAdded: number }
+	| { type: "replace"; path: string; content: string; linesAdded: number }
+	| {
+			type: "update";
+			path: string;
+			movePath?: string;
+			chunks: UpdateFileChunk[];
+			linesAdded: number;
+			linesRemoved: number;
+	  }
+	| { type: "delete"; path: string };
+
+export type PatchOperation =
+	| { type: "add"; sectionIndex: number; path: string; content: string; linesAdded: number }
+	| { type: "replace"; sectionIndex: number; path: string; content: string; linesAdded: number }
+	| {
+			type: "update";
+			sectionIndex: number;
+			path: string;
+			movePath?: string;
+			chunks: UpdateFileChunk[];
+			linesAdded: number;
+			linesRemoved: number;
+	  }
+	| { type: "delete"; sectionIndex: number; path: string };
+
+export interface PatchFailure {
+	phase: "parse" | "apply";
+	sectionIndex: number;
+	path?: string;
+	kind?: PatchOperation["type"];
+	chunkIndex?: number;
+	totalChunks?: number;
+	contextHint?: string;
+	message: string;
+}
+
+export interface ParsedPatch {
+	operations: PatchOperation[];
+	parseFailures: PatchFailure[];
+	totalSections: number;
+}
+
+const BEGIN_PATCH_MARKER = "*** Begin Patch";
+const END_PATCH_MARKER = "*** End Patch";
+const ADD_FILE_MARKER = "*** Add File: ";
+const REPLACE_FILE_MARKER = "*** Replace File: ";
+const DELETE_FILE_MARKER = "*** Delete File: ";
+const UPDATE_FILE_MARKER = "*** Update File: ";
+const MOVE_TO_MARKER = "*** Move to: ";
+const CHANGE_CONTEXT_MARKER = "@@";
+const EOF_MARKER = "*** End of File";
+
+const TOP_LEVEL_BOUNDARIES = [
+	END_PATCH_MARKER,
+	ADD_FILE_MARKER,
+	REPLACE_FILE_MARKER,
+	DELETE_FILE_MARKER,
+	UPDATE_FILE_MARKER,
+] as const;
+
+function topLevelDirective(line: string): string {
+	return line.trim();
+}
+
+function updateDirective(line: string): string {
+	return line.trimEnd();
+}
+
+function isTopLevelBoundary(line: string): boolean {
+	const value = topLevelDirective(line);
+	return TOP_LEVEL_BOUNDARIES.some((b) => (b === END_PATCH_MARKER ? value === b : value.startsWith(b)));
+}
+
+function isUpdateBoundary(line: string): boolean {
+	const value = updateDirective(line);
+	return TOP_LEVEL_BOUNDARIES.some((b) => (b === END_PATCH_MARKER ? value === b : value.startsWith(b)));
+}
+
+function requirePathFromDirective(value: string, originalLine: string, prefix: string): string {
+	const path = value.slice(prefix.length).trim();
+	if (!path) throw new Error(`Missing path for patch directive: ${originalLine}`);
+	return path;
+}
+
+function requireTopLevelPath(line: string, prefix: string): string {
+	return requirePathFromDirective(topLevelDirective(line), line, prefix);
+}
+
+function requireUpdatePath(line: string, prefix: string): string {
+	return requirePathFromDirective(updateDirective(line), line, prefix);
+}
+
+function isUpdateHeader(line: string): boolean {
+	return topLevelDirective(line).startsWith(UPDATE_FILE_MARKER);
+}
+
+function nextSectionBoundary(lines: string[], start: number, updateBody: boolean): number {
+	let index = start;
+	const limit = lines.length - 1;
+	while (index < limit) {
+		const line = lines[index];
+		if (line === undefined) break;
+		if (updateBody ? isUpdateBoundary(line) : isTopLevelBoundary(line)) break;
+		index += 1;
+	}
+	return index;
+}
+
+function parseAddBody(lines: string[], startIndex: number): { content: string; lineCount: number; nextIndex: number } {
+	const body: string[] = [];
+	let index = startIndex;
+	while (index < lines.length) {
+		const line = lines[index];
+		if (line === undefined || !line.startsWith("+")) break;
+		body.push(line.slice(1));
+		index += 1;
+	}
+	return {
+		content: body.length === 0 ? "" : `${body.join("\n")}\n`,
+		lineCount: body.length,
+		nextIndex: index,
+	};
+}
+
+interface MutableChunk {
+	changeContext?: string;
+	lines: ChunkLine[];
+	isEndOfFile: boolean;
+	hasLines: boolean;
+}
+
+function createChunk(changeContext?: string): MutableChunk {
+	return { changeContext, lines: [], isEndOfFile: false, hasLines: false };
+}
+
+function finalizeChunk(target: MutableChunk | undefined, chunks: UpdateFileChunk[], path: string): void {
+	if (!target) return;
+	if (!target.hasLines) throw new Error(`Update file patch has an empty chunk: ${path}`);
+	chunks.push({
+		changeContext: target.changeContext,
+		lines: target.lines,
+		isEndOfFile: target.isEndOfFile,
+	});
+}
+
+function parseChunkLine(rawLine: string): { prefix: " " | "+" | "-"; text: string } {
+	if (rawLine.length === 0) return { prefix: " ", text: "" };
+	const prefix = rawLine[0];
+	if (prefix !== " " && prefix !== "+" && prefix !== "-") {
+		throw new Error(`Invalid update hunk line: ${rawLine}`);
+	}
+	return { prefix, text: rawLine.slice(1) };
+}
+
+function parseUpdateBody(
+	lines: string[],
+	startIndex: number,
+	operationPath: string,
+): { movePath?: string; chunks: UpdateFileChunk[]; linesAdded: number; linesRemoved: number; nextIndex: number } {
+	const chunks: UpdateFileChunk[] = [];
+	let index = startIndex;
+	let movePath: string | undefined;
+	let current: MutableChunk | undefined;
+	let sawAnyChunk = false;
+	let linesAdded = 0;
+	let linesRemoved = 0;
+
+	while (index < lines.length) {
+		const line = lines[index];
+		if (line === undefined) break;
+		const currentDirective = updateDirective(line);
+		if (isUpdateBoundary(line)) break;
+
+		if (currentDirective.startsWith(MOVE_TO_MARKER)) {
+			if (sawAnyChunk || current) throw new Error(`Move to must appear before update chunks: ${operationPath}`);
+			movePath = requireUpdatePath(line, MOVE_TO_MARKER);
+			index += 1;
+			continue;
+		}
+
+		if (currentDirective === CHANGE_CONTEXT_MARKER || currentDirective.startsWith(`${CHANGE_CONTEXT_MARKER} `)) {
+			finalizeChunk(current, chunks, operationPath);
+			const context =
+				currentDirective === CHANGE_CONTEXT_MARKER
+					? undefined
+					: currentDirective.slice(CHANGE_CONTEXT_MARKER.length + 1).trim();
+			current = createChunk(context && context.length > 0 ? context : undefined);
+			sawAnyChunk = true;
+			index += 1;
+			continue;
+		}
+
+		if (!current) {
+			if (sawAnyChunk || chunks.length > 0) {
+				throw new Error(`Only the first update chunk may omit @@: ${operationPath}`);
+			}
+			current = createChunk();
+			sawAnyChunk = true;
+		}
+
+		if (currentDirective === EOF_MARKER) {
+			current.isEndOfFile = true;
+			index += 1;
+			continue;
+		}
+
+		const parsedLine = parseChunkLine(line);
+		current.hasLines = true;
+
+		if (parsedLine.prefix === "+") linesAdded += 1;
+		if (parsedLine.prefix === "-") linesRemoved += 1;
+
+		current.lines.push({ prefix: parsedLine.prefix, text: parsedLine.text });
+		index += 1;
+	}
+
+	finalizeChunk(current, chunks, operationPath);
+	if (chunks.length === 0 && !movePath)
+		throw new Error(`Update file patch is missing chunk content: ${operationPath}`);
+
+	return { movePath, chunks, linesAdded, linesRemoved, nextIndex: index };
+}
+
+function parseSection(sectionLines: string[]): ParsedSection {
+	const header = sectionLines[0] ?? "";
+
+	const headerDirective = topLevelDirective(header);
+
+	if (headerDirective.startsWith(ADD_FILE_MARKER) || headerDirective.startsWith(REPLACE_FILE_MARKER)) {
+		const isReplace = headerDirective.startsWith(REPLACE_FILE_MARKER);
+		const prefix = isReplace ? REPLACE_FILE_MARKER : ADD_FILE_MARKER;
+		const path = requireTopLevelPath(header, prefix);
+		const body = parseAddBody(sectionLines, 1);
+		if (body.nextIndex !== sectionLines.length) {
+			throw new Error(`Malformed ${isReplace ? "Replace" : "Add"} File section: ${path}`);
+		}
+		return { type: isReplace ? "replace" : "add", path, content: body.content, linesAdded: body.lineCount };
+	}
+
+	if (headerDirective.startsWith(DELETE_FILE_MARKER)) {
+		const path = requireTopLevelPath(header, DELETE_FILE_MARKER);
+		if (sectionLines.length !== 1) throw new Error(`Malformed Delete File section: ${path}`);
+		return { type: "delete", path };
+	}
+
+	if (headerDirective.startsWith(UPDATE_FILE_MARKER)) {
+		const path = requireTopLevelPath(header, UPDATE_FILE_MARKER);
+		const updateBody = parseUpdateBody(sectionLines, 1, path);
+		if (updateBody.nextIndex !== sectionLines.length) throw new Error(`Malformed Update File section: ${path}`);
+		return {
+			type: "update",
+			path,
+			movePath: updateBody.movePath,
+			chunks: updateBody.chunks,
+			linesAdded: updateBody.linesAdded,
+			linesRemoved: updateBody.linesRemoved,
+		};
+	}
+
+	throw new Error(`Unexpected patch line: ${header}`);
+}
+
+function parseHeaderMetadata(header: string): Pick<PatchFailure, "kind" | "path"> {
+	const headerDirective = topLevelDirective(header);
+	if (headerDirective.startsWith(ADD_FILE_MARKER) || headerDirective.startsWith(REPLACE_FILE_MARKER)) {
+		return {
+			kind: headerDirective.startsWith(REPLACE_FILE_MARKER) ? "replace" : "add",
+			path: headerDirective.slice(headerDirective.indexOf(": ") + 2).trim() || undefined,
+		};
+	}
+	if (headerDirective.startsWith(DELETE_FILE_MARKER)) {
+		return { kind: "delete", path: headerDirective.slice(DELETE_FILE_MARKER.length).trim() || undefined };
+	}
+	if (headerDirective.startsWith(UPDATE_FILE_MARKER)) {
+		return { kind: "update", path: headerDirective.slice(UPDATE_FILE_MARKER.length).trim() || undefined };
+	}
+	return {};
+}
+
+function envelopeFailure(message: string): ParsedPatch {
+	return { operations: [], parseFailures: [{ phase: "parse", sectionIndex: 0, message }], totalSections: 1 };
+}
+
+export function parsePatch(input: string): ParsedPatch {
+	const normalized = input.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
+	if (!normalized) return envelopeFailure("Patch must not be empty.");
+
+	const lines = normalized.split("\n");
+	if (topLevelDirective(lines[0] ?? "") !== BEGIN_PATCH_MARKER)
+		return envelopeFailure("Patch must start with *** Begin Patch.");
+	if (topLevelDirective(lines[lines.length - 1] ?? "") !== END_PATCH_MARKER)
+		return envelopeFailure("Patch must end with *** End Patch.");
+
+	const operations: PatchOperation[] = [];
+	const parseFailures: PatchFailure[] = [];
+	let index = 1;
+	let sectionIndex = 0;
+
+	while (index < lines.length - 1) {
+		const line = lines[index];
+		if (line === undefined) break;
+		if (line.trim() === "") {
+			index += 1;
+			continue;
+		}
+
+		const lineDirective = topLevelDirective(line);
+		if (!isTopLevelBoundary(line) || lineDirective === END_PATCH_MARKER) {
+			parseFailures.push({ phase: "parse", sectionIndex, message: `Unexpected patch line: ${line}` });
+			index += 1;
+			continue;
+		}
+
+		sectionIndex += 1;
+		const sectionStart = index;
+		const nextBoundary = nextSectionBoundary(lines, index + 1, isUpdateHeader(line));
+
+		const sectionLines = lines.slice(sectionStart, nextBoundary);
+		try {
+			operations.push({ ...parseSection(sectionLines), sectionIndex });
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			parseFailures.push({
+				phase: "parse",
+				sectionIndex,
+				...parseHeaderMetadata(sectionLines[0] ?? ""),
+				message,
+			});
+		}
+
+		index = nextBoundary;
+	}
+
+	if (operations.length === 0 && parseFailures.length === 0) {
+		parseFailures.push({ phase: "parse", sectionIndex: 0, message: "Patch contains no operations." });
+	}
+
+	return {
+		operations,
+		parseFailures,
+		totalSections: Math.max(sectionIndex, operations.length + parseFailures.length),
+	};
+}