@oh-my-pi/pi-coding-agent 6.2.0 → 6.7.0

package/src/core/tools/patch/index.ts

@@ -0,0 +1,430 @@
+/**
+ * Edit tool module.
+ *
+ * Supports two modes:
+ * - Replace mode (default): oldText/newText replacement with fuzzy matching
+ * - Patch mode: structured diff format with explicit operation type
+ *
+ * The mode is determined by the `edit.patchMode` setting.
+ */
+
+import { mkdir } from "node:fs/promises";
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import { StringEnum } from "@oh-my-pi/pi-ai";
+import { Type } from "@sinclair/typebox";
+import patchDescription from "../../../prompts/tools/patch.md" with { type: "text" };
+import replaceDescription from "../../../prompts/tools/replace.md" with { type: "text" };
+import { renderPromptTemplate } from "../../prompt-templates";
+import type { ToolSession } from "../index";
+import {
+	createLspWritethrough,
+	type FileDiagnosticsResult,
+	flushLspWritethroughBatch,
+	type WritethroughCallback,
+	writethroughNoop,
+} from "../lsp/index";
+import { resolveToCwd } from "../path-utils";
+import { applyPatch } from "./applicator";
+import { generateDiffString, generateUnifiedDiffString, replaceText } from "./diff";
+import { DEFAULT_FUZZY_THRESHOLD, findMatch } from "./fuzzy";
+import { detectLineEnding, normalizeToLF, restoreLineEndings, stripBom } from "./normalize";
+import { buildNormativeUpdateInput } from "./normative";
+import { type EditToolDetails, getLspBatchRequest } from "./shared";
+// Internal imports
+import type { FileSystem, Operation, PatchInput } from "./types";
+import { EditMatchError } from "./types";
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Re-exports
+// ═══════════════════════════════════════════════════════════════════════════
+
+// Application
+export { applyPatch, defaultFileSystem, previewPatch } from "./applicator";
+// Diff generation
+export { computeEditDiff, computePatchDiff, generateDiffString, generateUnifiedDiffString, replaceText } from "./diff";
+
+// Fuzzy matching
+export { DEFAULT_FUZZY_THRESHOLD, findContextLine, findMatch as findEditMatch, findMatch, seekSequence } from "./fuzzy";
+
+// Normalization
+export {
+	adjustIndentation as adjustNewTextIndentation,
+	detectLineEnding,
+	normalizeToLF,
+	restoreLineEndings,
+	stripBom,
+} from "./normalize";
+
+// Parsing
+export { normalizeCreateContent, normalizeDiff, parseHunks as parseDiffHunks } from "./parser";
+export type { EditRenderContext, EditToolDetails } from "./shared";
+// Rendering
+export { editToolRenderer, getLspBatchRequest } from "./shared";
+export type {
+	ApplyPatchOptions,
+	ApplyPatchResult,
+	ContextLineResult,
+	DiffError,
+	DiffError as EditDiffError,
+	DiffHunk,
+	DiffHunk as UpdateChunk,
+	DiffHunk as UpdateFileChunk,
+	DiffResult,
+	DiffResult as EditDiffResult,
+	FileChange,
+	FileSystem,
+	FuzzyMatch as EditMatch,
+	FuzzyMatch,
+	MatchOutcome as EditMatchOutcome,
+	MatchOutcome,
+	Operation,
+	PatchInput,
+	SequenceSearchResult,
+} from "./types";
+// Types
+// Legacy aliases for backwards compatibility
+export { ApplyPatchError, EditMatchError, ParseError } from "./types";
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Schemas
+// ═══════════════════════════════════════════════════════════════════════════
+
+const replaceEditSchema = Type.Object({
+	path: Type.String({ description: "Path to the file to edit (relative or absolute)" }),
+	oldText: Type.String({
+		description: "Text to find and replace (high-confidence fuzzy matching for whitespace/indentation is always on)",
+	}),
+	newText: Type.String({ description: "New text to replace the old text with" }),
+	all: Type.Optional(Type.Boolean({ description: "Replace all occurrences instead of requiring unique match" })),
+});
+
+const patchEditSchema = Type.Object({
+	path: Type.String({ description: "Path to the file" }),
+	op: Type.Optional(
+		StringEnum(["create", "delete", "update"], {
+			description: "The operation to perform (Defaults to 'update')",
+		}),
+	),
+	rename: Type.Optional(Type.String({ description: "New path, if moving" })),
+	diff: Type.Optional(
+		Type.String({
+			description: "Diff hunk(s) for update. Full content for create.",
+		}),
+	),
+});
+
+export type ReplaceParams = { path: string; oldText: string; newText: string; all?: boolean };
+export type PatchParams = { path: string; op?: string; rename?: string; diff?: string };
+
+// ═══════════════════════════════════════════════════════════════════════════
+// LSP FileSystem for patch mode
+// ═══════════════════════════════════════════════════════════════════════════
+
+class LspFileSystem implements FileSystem {
+	private lastDiagnostics: FileDiagnosticsResult | undefined;
+	private fileCache: Record<string, Bun.BunFile> = {};
+
+	constructor(
+		private readonly writethrough: (
+			dst: string,
+			content: string,
+			signal?: AbortSignal,
+			file?: import("bun").BunFile,
+			batch?: { id: string; flush: boolean },
+		) => Promise<FileDiagnosticsResult | undefined>,
+		private readonly signal?: AbortSignal,
+		private readonly batchRequest?: { id: string; flush: boolean },
+	) {}
+
+	#getFile(path: string): Bun.BunFile {
+		if (this.fileCache[path]) {
+			return this.fileCache[path];
+		}
+		const file = Bun.file(path);
+		this.fileCache[path] = file;
+		return file;
+	}
+
+	async exists(path: string): Promise<boolean> {
+		return this.#getFile(path).exists();
+	}
+
+	async read(path: string): Promise<string> {
+		return this.#getFile(path).text();
+	}
+
+	async readBinary(path: string): Promise<Uint8Array> {
+		const buffer = await this.#getFile(path).arrayBuffer();
+		return new Uint8Array(buffer);
+	}
+
+	async write(path: string, content: string): Promise<void> {
+		const file = this.#getFile(path);
+		const result = await this.writethrough(path, content, this.signal, file, this.batchRequest);
+		if (result) {
+			this.lastDiagnostics = result;
+		}
+	}
+
+	async delete(path: string): Promise<void> {
+		await this.#getFile(path).unlink();
+	}
+
+	async mkdir(path: string): Promise<void> {
+		await mkdir(path, { recursive: true });
+	}
+
+	getDiagnostics(): FileDiagnosticsResult | undefined {
+		return this.lastDiagnostics;
+	}
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Tool Class
+// ═══════════════════════════════════════════════════════════════════════════
+
+type TInput = typeof replaceEditSchema | typeof patchEditSchema;
+
+/**
+ * Edit tool implementation.
+ *
+ * Creates replace-mode or patch-mode behavior based on session settings.
+ */
+export class EditTool implements AgentTool<TInput> {
+	public readonly name = "edit";
+	public readonly label = "Edit";
+	public readonly description: string;
+	public readonly parameters: TInput;
+
+	private readonly session: ToolSession;
+	private readonly patchMode: boolean;
+	private readonly allowFuzzy: boolean;
+	private readonly fuzzyThreshold: number;
+	private readonly writethrough: WritethroughCallback;
+
+	constructor(session: ToolSession) {
+		this.session = session;
+
+		const {
+			OMP_EDIT_FUZZY: editFuzzy = "auto",
+			OMP_EDIT_FUZZY_THRESHOLD: editFuzzyThreshold = "auto",
+			OMP_EDIT_VARIANT: editVariant = "auto",
+		} = process.env;
+
+		switch (editVariant) {
+			case "replace":
+				this.patchMode = false;
+				break;
+			case "patch":
+				this.patchMode = true;
+				break;
+			case "auto":
+				this.patchMode = session.settings?.getEditPatchMode?.() ?? true;
+				break;
+			default:
+				throw new Error(`Invalid OMP_EDIT_VARIANT: ${process.env.OMP_EDIT_VARIANT}`);
+		}
+		switch (editFuzzy) {
+			case "true":
+			case "1":
+				this.allowFuzzy = true;
+				break;
+			case "false":
+			case "0":
+				this.allowFuzzy = false;
+				break;
+			case "auto":
+				this.allowFuzzy = session.settings?.getEditFuzzyMatch() ?? true;
+				break;
+			default:
+				throw new Error(`Invalid OMP_EDIT_FUZZY: ${editFuzzy}`);
+		}
+		switch (editFuzzyThreshold) {
+			case "auto":
+				this.fuzzyThreshold = session.settings?.getEditFuzzyThreshold?.() ?? DEFAULT_FUZZY_THRESHOLD;
+				break;
+			default:
+				this.fuzzyThreshold = parseFloat(editFuzzyThreshold);
+				if (Number.isNaN(this.fuzzyThreshold) || this.fuzzyThreshold < 0 || this.fuzzyThreshold > 1) {
+					throw new Error(`Invalid OMP_EDIT_FUZZY_THRESHOLD: ${editFuzzyThreshold}`);
+				}
+				break;
+		}
+
+		const enableLsp = session.enableLsp ?? true;
+		const enableDiagnostics = enableLsp ? (session.settings?.getLspDiagnosticsOnEdit() ?? false) : false;
+		const enableFormat = enableLsp ? (session.settings?.getLspFormatOnWrite() ?? true) : false;
+		this.writethrough = enableLsp
+			? createLspWritethrough(session.cwd, { enableFormat, enableDiagnostics })
+			: writethroughNoop;
+		this.description = this.patchMode
+			? renderPromptTemplate(patchDescription)
+			: renderPromptTemplate(replaceDescription);
+		this.parameters = this.patchMode ? patchEditSchema : replaceEditSchema;
+	}
+
+	public async execute(
+		_toolCallId: string,
+		params: ReplaceParams | PatchParams,
+		signal?: AbortSignal,
+		_onUpdate?: AgentToolUpdateCallback<EditToolDetails, TInput>,
+		context?: AgentToolContext,
+	): Promise<AgentToolResult<EditToolDetails, TInput>> {
+		const batchRequest = getLspBatchRequest(context?.toolCall);
+
+		// ─────────────────────────────────────────────────────────────────
+		// Patch mode execution
+		// ─────────────────────────────────────────────────────────────────
+		if (this.patchMode) {
+			const { path, op: rawOp, rename, diff } = params as PatchParams;
+
+			// Normalize unrecognized operations to "update"
+			const op: Operation = rawOp === "create" || rawOp === "delete" ? rawOp : "update";
+
+			if (path.endsWith(".ipynb")) {
+				throw new Error("Cannot edit Jupyter notebooks with the Edit tool. Use the NotebookEdit tool instead.");
+			}
+			if (rename?.endsWith(".ipynb")) {
+				throw new Error("Cannot edit Jupyter notebooks with the Edit tool. Use the NotebookEdit tool instead.");
+			}
+
+			const input: PatchInput = { path, op, rename, diff };
+			const fs = new LspFileSystem(this.writethrough, signal, batchRequest);
+			const result = await applyPatch(input, {
+				cwd: this.session.cwd,
+				fs,
+				fuzzyThreshold: this.fuzzyThreshold,
+				allowFuzzy: this.allowFuzzy,
+			});
+			const effRename = result.change.newPath ? rename : undefined;
+
+			// Generate diff for display
+			let diffResult = { diff: "", firstChangedLine: undefined as number | undefined };
+			let normative: PatchInput | undefined;
+			if (result.change.type === "update" && result.change.oldContent && result.change.newContent) {
+				const normalizedOld = normalizeToLF(stripBom(result.change.oldContent).text);
+				const normalizedNew = normalizeToLF(stripBom(result.change.newContent).text);
+				diffResult = generateUnifiedDiffString(normalizedOld, normalizedNew);
+				normative = buildNormativeUpdateInput({
+					path,
+					rename: effRename,
+					oldContent: result.change.oldContent,
+					newContent: result.change.newContent,
+				});
+			}
+
+			let resultText: string;
+			switch (result.change.type) {
+				case "create":
+					resultText = `Created ${path}`;
+					break;
+				case "delete":
+					resultText = `Deleted ${path}`;
+					break;
+				case "update":
+					resultText = effRename ? `Updated and moved ${path} to ${effRename}` : `Updated ${path}`;
+					break;
+			}
+
+			let diagnostics = fs.getDiagnostics();
+			if (op === "delete" && batchRequest?.flush) {
+				const flushedDiagnostics = await flushLspWritethroughBatch(batchRequest.id, this.session.cwd, signal);
+				diagnostics ??= flushedDiagnostics;
+			}
+			if (diagnostics?.messages?.length) {
+				resultText += `\n\nLSP Diagnostics (${diagnostics.summary}):\n`;
+				resultText += diagnostics.messages.map((d) => `  ${d}`).join("\n");
+			}
+
+			return {
+				content: [{ type: "text", text: resultText }],
+				details: {
+					diff: diffResult.diff,
+					firstChangedLine: diffResult.firstChangedLine,
+					diagnostics,
+					op,
+					rename: effRename,
+				},
+				$normative: normative,
+			};
+		}
+
+		// ─────────────────────────────────────────────────────────────────
+		// Replace mode execution
+		// ─────────────────────────────────────────────────────────────────
+		const { path, oldText, newText, all } = params as ReplaceParams;
+
+		if (path.endsWith(".ipynb")) {
+			throw new Error("Cannot edit Jupyter notebooks with the Edit tool. Use the NotebookEdit tool instead.");
+		}
+
+		if (oldText.length === 0) {
+			throw new Error("oldText must not be empty.");
+		}
+
+		const absolutePath = resolveToCwd(path, this.session.cwd);
+		const file = Bun.file(absolutePath);
+
+		if (!(await file.exists())) {
+			throw new Error(`File not found: ${path}`);
+		}
+
+		const rawContent = await file.text();
+		const { bom, text: content } = stripBom(rawContent);
+		const originalEnding = detectLineEnding(content);
+		const normalizedContent = normalizeToLF(content);
+		const normalizedOldText = normalizeToLF(oldText);
+		const normalizedNewText = normalizeToLF(newText);
+
+		const result = replaceText(normalizedContent, normalizedOldText, normalizedNewText, {
+			fuzzy: this.allowFuzzy,
+			all: all ?? false,
+			threshold: this.fuzzyThreshold,
+		});
+
+		if (result.count === 0) {
+			// Get error details
+			const matchOutcome = findMatch(normalizedContent, normalizedOldText, {
+				allowFuzzy: this.allowFuzzy,
+				threshold: this.fuzzyThreshold,
+			});
+
+			if (matchOutcome.occurrences && matchOutcome.occurrences > 1) {
+				throw new Error(
+					`Found ${matchOutcome.occurrences} occurrences of the text in ${path}. The text must be unique. Please provide more context to make it unique, or use all: true to replace all.`,
+				);
+			}
+
+			throw new EditMatchError(path, normalizedOldText, matchOutcome.closest, {
+				allowFuzzy: this.allowFuzzy,
+				threshold: this.fuzzyThreshold,
+				fuzzyMatches: matchOutcome.fuzzyMatches,
+			});
+		}
+
+		if (normalizedContent === result.content) {
+			throw 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.`,
+			);
+		}
+
+		const finalContent = bom + restoreLineEndings(result.content, originalEnding);
+		const diagnostics = await this.writethrough(absolutePath, finalContent, signal, file, batchRequest);
+		const diffResult = generateDiffString(normalizedContent, result.content);
+
+		let resultText =
+			result.count > 1
+				? `Successfully replaced ${result.count} occurrences in ${path}.`
+				: `Successfully replaced text in ${path}.`;
+
+		if (diagnostics?.messages?.length) {
+			resultText += `\n\nLSP Diagnostics (${diagnostics.summary}):\n`;
+			resultText += diagnostics.messages.map((d) => `  ${d}`).join("\n");
+		}
+
+		return {
+			content: [{ type: "text", text: resultText }],
+			details: { diff: diffResult.diff, firstChangedLine: diffResult.firstChangedLine, diagnostics },
+		};
+	}
+}

package/src/core/tools/patch/normalize.ts

@@ -0,0 +1,220 @@
+/**
+ * Text normalization utilities for the edit tool.
+ *
+ * Handles line endings, BOM, whitespace, and Unicode normalization.
+ */
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Line Ending Utilities
+// ═══════════════════════════════════════════════════════════════════════════
+
+export type LineEnding = "\r\n" | "\n";
+
+/** Detect the predominant line ending in content */
+export function detectLineEnding(content: string): LineEnding {
+	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";
+}
+
+/** Normalize all line endings to LF */
+export function normalizeToLF(text: string): string {
+	return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+
+/** Restore line endings to the specified type */
+export function restoreLineEndings(text: string, ending: LineEnding): string {
+	return ending === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// BOM Handling
+// ═══════════════════════════════════════════════════════════════════════════
+
+export interface BomResult {
+	/** The BOM character if present, empty string otherwise */
+	bom: string;
+	/** The text without the BOM */
+	text: string;
+}
+
+/** Strip UTF-8 BOM if present */
+export function stripBom(content: string): BomResult {
+	return content.startsWith("\uFEFF") ? { bom: "\uFEFF", text: content.slice(1) } : { bom: "", text: content };
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Whitespace Utilities
+// ═══════════════════════════════════════════════════════════════════════════
+
+/** Count leading whitespace characters in a line */
+export function countLeadingWhitespace(line: string): number {
+	let count = 0;
+	for (let i = 0; i < line.length; i++) {
+		const char = line[i];
+		if (char === " " || char === "\t") {
+			count++;
+		} else {
+			break;
+		}
+	}
+	return count;
+}
+
+/** Get the leading whitespace string from a line */
+export function getLeadingWhitespace(line: string): string {
+	return line.slice(0, countLeadingWhitespace(line));
+}
+
+/** Compute minimum indentation of non-empty lines */
+export function minIndent(text: string): number {
+	const lines = text.split("\n");
+	let min = Infinity;
+	for (const line of lines) {
+		if (line.trim().length > 0) {
+			min = Math.min(min, countLeadingWhitespace(line));
+		}
+	}
+	return min === Infinity ? 0 : min;
+}
+
+/** Detect the indentation character used in text (space or tab) */
+export function detectIndentChar(text: string): string {
+	const lines = text.split("\n");
+	for (const line of lines) {
+		const ws = getLeadingWhitespace(line);
+		if (ws.length > 0) {
+			return ws[0];
+		}
+	}
+	return " ";
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Unicode Normalization
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Normalize common Unicode punctuation to ASCII equivalents.
+ * Allows diffs with ASCII characters to match source files with typographic punctuation.
+ */
+export function normalizeUnicode(s: string): string {
+	return s
+		.trim()
+		.split("")
+		.map((c) => {
+			const code = c.charCodeAt(0);
+
+			// Various dash/hyphen code-points → ASCII '-'
+			if (
+				code === 0x2010 || // HYPHEN
+				code === 0x2011 || // NON-BREAKING HYPHEN
+				code === 0x2012 || // FIGURE DASH
+				code === 0x2013 || // EN DASH
+				code === 0x2014 || // EM DASH
+				code === 0x2015 || // HORIZONTAL BAR
+				code === 0x2212 // MINUS SIGN
+			) {
+				return "-";
+			}
+
+			// Fancy single quotes → '
+			if (
+				code === 0x2018 || // LEFT SINGLE QUOTATION MARK
+				code === 0x2019 || // RIGHT SINGLE QUOTATION MARK
+				code === 0x201a || // SINGLE LOW-9 QUOTATION MARK
+				code === 0x201b // SINGLE HIGH-REVERSED-9 QUOTATION MARK
+			) {
+				return "'";
+			}
+
+			// Fancy double quotes → "
+			if (
+				code === 0x201c || // LEFT DOUBLE QUOTATION MARK
+				code === 0x201d || // RIGHT DOUBLE QUOTATION MARK
+				code === 0x201e || // DOUBLE LOW-9 QUOTATION MARK
+				code === 0x201f // DOUBLE HIGH-REVERSED-9 QUOTATION MARK
+			) {
+				return '"';
+			}
+
+			// Non-breaking space and other odd spaces → normal space
+			if (
+				code === 0x00a0 || // NO-BREAK SPACE
+				code === 0x2002 || // EN SPACE
+				code === 0x2003 || // EM SPACE
+				code === 0x2004 || // THREE-PER-EM SPACE
+				code === 0x2005 || // FOUR-PER-EM SPACE
+				code === 0x2006 || // SIX-PER-EM SPACE
+				code === 0x2007 || // FIGURE SPACE
+				code === 0x2008 || // PUNCTUATION SPACE
+				code === 0x2009 || // THIN SPACE
+				code === 0x200a || // HAIR SPACE
+				code === 0x202f || // NARROW NO-BREAK SPACE
+				code === 0x205f || // MEDIUM MATHEMATICAL SPACE
+				code === 0x3000 // IDEOGRAPHIC SPACE
+			) {
+				return " ";
+			}
+
+			return c;
+		})
+		.join("");
+}
+
+/**
+ * Normalize a line for fuzzy comparison.
+ * Trims, collapses whitespace, and normalizes punctuation.
+ */
+export function normalizeForFuzzy(line: string): string {
+	const trimmed = line.trim();
+	if (trimmed.length === 0) return "";
+
+	return trimmed
+		.replace(/[""„‟«»]/g, '"')
+		.replace(/[''‚‛`´]/g, "'")
+		.replace(/[‐‑‒–—−]/g, "-")
+		.replace(/[ \t]+/g, " ");
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Indentation Adjustment
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Adjust newText indentation to match the indentation delta between
+ * what was provided (oldText) and what was actually matched (actualText).
+ *
+ * If oldText has 0 indent but actualText has 12 spaces, we add 12 spaces
+ * to each line in newText.
+ */
+export function adjustIndentation(oldText: string, actualText: string, newText: string): string {
+	const oldMin = minIndent(oldText);
+	const actualMin = minIndent(actualText);
+	const delta = actualMin - oldMin;
+
+	if (delta === 0) {
+		return newText;
+	}
+
+	const indentChar = detectIndentChar(actualText);
+	const lines = newText.split("\n");
+
+	const adjusted = lines.map((line) => {
+		if (line.trim().length === 0) {
+			return line; // Preserve empty/whitespace-only lines as-is
+		}
+
+		if (delta > 0) {
+			return indentChar.repeat(delta) + line;
+		}
+
+		// Remove indentation (delta < 0)
+		const toRemove = Math.min(-delta, countLeadingWhitespace(line));
+		return line.slice(toRemove);
+	});
+
+	return adjusted.join("\n");
+}

package/src/core/tools/patch/normative.ts

@@ -0,0 +1,49 @@
+/**
+ * Normalize applied patch output into a canonical edit tool payload.
+ */
+
+import { generateUnifiedDiffString } from "./diff";
+import { normalizeToLF, stripBom } from "./normalize";
+import type { PatchInput } from "./types";
+
+export interface NormativePatchOptions {
+	path: string;
+	rename?: string;
+	oldContent: string;
+	newContent: string;
+	contextLines?: number;
+	anchor?: string | string[];
+}
+
+/** Normative patch input is the MongoDB-style update variant */
+
+function applyAnchors(diff: string, anchors: string[] | undefined): string {
+	if (!anchors || anchors.length === 0) {
+		return diff;
+	}
+	const lines = diff.split("\n");
+	let anchorIndex = 0;
+	for (let i = 0; i < lines.length; i++) {
+		if (!lines[i].startsWith("@@")) continue;
+		const anchor = anchors[anchorIndex];
+		if (anchor !== undefined) {
+			lines[i] = anchor.trim().length === 0 ? "@@" : `@@ ${anchor}`;
+			anchorIndex++;
+		}
+	}
+	return lines.join("\n");
+}
+
+export function buildNormativeUpdateInput(options: NormativePatchOptions): PatchInput {
+	const normalizedOld = normalizeToLF(stripBom(options.oldContent).text);
+	const normalizedNew = normalizeToLF(stripBom(options.newContent).text);
+	const diffResult = generateUnifiedDiffString(normalizedOld, normalizedNew, options.contextLines ?? 3);
+	const anchors = typeof options.anchor === "string" ? [options.anchor] : options.anchor;
+	const diff = applyAnchors(diffResult.diff, anchors);
+	return {
+		path: options.path,
+		op: "update",
+		rename: options.rename,
+		diff,
+	};
+}