@oh-my-pi/pi-coding-agent 13.19.0 → 14.0.2

package/src/utils/image-loading.ts

@@ -0,0 +1,98 @@
+import * as fs from "node:fs/promises";
+import type { ImageContent } from "@oh-my-pi/pi-ai";
+import { formatBytes, readImageMetadata, SUPPORTED_IMAGE_MIME_TYPES } from "@oh-my-pi/pi-utils";
+import { resolveReadPath } from "../tools/path-utils";
+import { convertToPng } from "./image-convert";
+import { formatDimensionNote, resizeImage } from "./image-resize";
+
+export const MAX_IMAGE_INPUT_BYTES = 20 * 1024 * 1024;
+export const SUPPORTED_INPUT_IMAGE_MIME_TYPES = SUPPORTED_IMAGE_MIME_TYPES;
+
+export interface LoadImageInputOptions {
+	path: string;
+	cwd: string;
+	autoResize: boolean;
+	maxBytes?: number;
+	resolvedPath?: string;
+	detectedMimeType?: string;
+}
+
+export interface LoadedImageInput {
+	resolvedPath: string;
+	mimeType: string;
+	data: string;
+	textNote: string;
+	dimensionNote?: string;
+	bytes: number;
+}
+
+export class ImageInputTooLargeError extends Error {
+	readonly bytes: number;
+	readonly maxBytes: number;
+
+	constructor(bytes: number, maxBytes: number) {
+		super(`Image file too large: ${formatBytes(bytes)} exceeds ${formatBytes(maxBytes)} limit.`);
+		this.name = "ImageInputTooLargeError";
+		this.bytes = bytes;
+		this.maxBytes = maxBytes;
+	}
+}
+
+export async function ensureSupportedImageInput(image: ImageContent): Promise<ImageContent | null> {
+	if (SUPPORTED_INPUT_IMAGE_MIME_TYPES.has(image.mimeType)) {
+		return image;
+	}
+	const converted = await convertToPng(image.data, image.mimeType);
+	return converted ? { type: "image", data: converted.data, mimeType: converted.mimeType } : null;
+}
+
+export async function loadImageInput(options: LoadImageInputOptions): Promise<LoadedImageInput | null> {
+	const maxBytes = options.maxBytes ?? MAX_IMAGE_INPUT_BYTES;
+	const resolvedPath = options.resolvedPath ?? resolveReadPath(options.path, options.cwd);
+	const metadata = options.detectedMimeType
+		? { mimeType: options.detectedMimeType }
+		: await readImageMetadata(resolvedPath);
+	const mimeType = metadata?.mimeType;
+	if (!mimeType) return null;
+
+	const stat = await Bun.file(resolvedPath).stat();
+	if (stat.size > maxBytes) {
+		throw new ImageInputTooLargeError(stat.size, maxBytes);
+	}
+
+	const inputBuffer = await fs.readFile(resolvedPath);
+	if (inputBuffer.byteLength > maxBytes) {
+		throw new ImageInputTooLargeError(inputBuffer.byteLength, maxBytes);
+	}
+
+	let outputData = Buffer.from(inputBuffer).toBase64();
+	let outputMimeType = mimeType;
+	let outputBytes = inputBuffer.byteLength;
+	let dimensionNote: string | undefined;
+
+	if (options.autoResize) {
+		try {
+			const resized = await resizeImage({ type: "image", data: outputData, mimeType });
+			outputData = resized.data;
+			outputMimeType = resized.mimeType;
+			outputBytes = resized.buffer.byteLength;
+			dimensionNote = formatDimensionNote(resized);
+		} catch {
+			// keep original image when resize fails
+		}
+	}
+
+	let textNote = `Read image file [${outputMimeType}]`;
+	if (dimensionNote) {
+		textNote += `\n${dimensionNote}`;
+	}
+
+	return {
+		resolvedPath,
+		mimeType: outputMimeType,
+		data: outputData,
+		textNote,
+		dimensionNote,
+		bytes: outputBytes,
+	};
+}

package/src/utils/title-generator.ts

@@ -5,15 +5,14 @@ import * as path from "node:path";
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Api, Model } from "@oh-my-pi/pi-ai";
 import { completeSimple } from "@oh-my-pi/pi-ai";
-import { logger } from "@oh-my-pi/pi-utils";
+import { logger, prompt } from "@oh-my-pi/pi-utils";
 import type { ModelRegistry } from "../config/model-registry";
 import { resolveRoleSelection } from "../config/model-resolver";
-import { renderPromptTemplate } from "../config/prompt-templates";
 import type { Settings } from "../config/settings";
 import titleSystemPrompt from "../prompts/system/title-system.md" with { type: "text" };
 import { toReasoningEffort } from "../thinking";
 
-const TITLE_SYSTEM_PROMPT = renderPromptTemplate(titleSystemPrompt);
+const TITLE_SYSTEM_PROMPT = prompt.render(titleSystemPrompt);
 
 const DEFAULT_TERMINAL_TITLE = "π";
 const TERMINAL_TITLE_CONTROL_CHARS = /[\u0000-\u001f\u007f-\u009f]/g;

package/src/utils/tools-manager.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { APP_NAME, getToolsDir, logger, ptree, TempDir } from "@oh-my-pi/pi-utils";
+import { $which, APP_NAME, getToolsDir, logger, ptree, TempDir } from "@oh-my-pi/pi-utils";
 
 const TOOLS_DIR = getToolsDir();
 const TOOL_DOWNLOAD_TIMEOUT_MS = 120_000;
@@ -96,7 +96,7 @@ export function getToolPath(tool: ToolName): string | null {
 	// Check Python tools first
 	const pythonConfig = PYTHON_TOOLS[tool];
 	if (pythonConfig) {
-		return Bun.which(pythonConfig.binaryName);
+		return $which(pythonConfig.binaryName);
 	}
 
 	const config = TOOLS[tool];
@@ -109,7 +109,7 @@ export function getToolPath(tool: ToolName): string | null {
 	}
 
 	// Check system PATH
-	return Bun.which(config.binaryName);
+	return $which(config.binaryName);
 }
 
 // Fetch latest release version from GitHub
@@ -249,7 +249,7 @@ async function downloadTool(tool: ToolName, signal?: AbortSignal): Promise<strin
 // Install a Python package via uv (preferred) or pip
 async function installPythonPackage(pkg: string, signal?: AbortSignal): Promise<boolean> {
 	// Try uv first (faster, better isolation)
-	const uv = Bun.which("uv");
+	const uv = $which("uv");
 	if (uv) {
 		const result = await ptree.exec(["uv", "tool", "install", pkg], {
 			signal,
@@ -261,7 +261,7 @@ async function installPythonPackage(pkg: string, signal?: AbortSignal): Promise<
 	}
 
 	// Fall back to pip
-	const pip = Bun.which("pip3") || Bun.which("pip");
+	const pip = $which("pip3") || $which("pip");
 	if (pip) {
 		const result = await ptree.exec(["pip", "install", "--user", pkg], {
 			signal,
@@ -316,7 +316,7 @@ export async function ensureTool(tool: ToolName, silentOrOptions?: EnsureToolOpt
 		const success = await installPythonPackage(pythonConfig.package, signal);
 		if (success) {
 			// Re-check for the command after installation
-			const path = Bun.which(pythonConfig.binaryName);
+			const path = $which(pythonConfig.binaryName);
 			if (path) {
 				if (!silent) {
 					logger.debug(`${pythonConfig.name} installed successfully`);

package/src/web/scrapers/choosealicense.ts

@@ -1,4 +1,4 @@
-import { parseFrontmatter } from "../../utils/frontmatter";
+import { parseFrontmatter } from "@oh-my-pi/pi-utils";
 import type { RenderResult, SpecialHandler } from "./types";
 import { buildResult, loadPage } from "./types";
 import { asString } from "./utils";

package/src/web/search/index.ts

@@ -7,8 +7,8 @@
  */
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { StringEnum } from "@oh-my-pi/pi-ai";
+import { prompt } from "@oh-my-pi/pi-utils";
 import { Type } from "@sinclair/typebox";
-import { renderPromptTemplate } from "../../config/prompt-templates";
 import type { CustomTool, CustomToolContext, RenderResultOptions } from "../../extensibility/custom-tools/types";
 import type { Theme } from "../../modes/theme/theme";
 import webSearchSystemPrompt from "../../prompts/system/web-search.md" with { type: "text" };
@@ -213,7 +213,7 @@ export class SearchTool implements AgentTool<typeof webSearchSchema, SearchRende
 	readonly strict = true;
 
 	constructor(_session: ToolSession) {
-		this.description = renderPromptTemplate(webSearchDescription);
+		this.description = prompt.render(webSearchDescription);
 	}
 
 	async execute(
@@ -231,7 +231,7 @@ export class SearchTool implements AgentTool<typeof webSearchSchema, SearchRende
 export const webSearchCustomTool: CustomTool<typeof webSearchSchema, SearchRenderDetails> = {
 	name: "web_search",
 	label: "Web Search",
-	description: renderPromptTemplate(webSearchDescription),
+	description: prompt.render(webSearchDescription),
 	parameters: webSearchSchema,
 
 	async execute(

package/src/autoresearch/command-initialize.md

@@ -1,34 +0,0 @@
-Set up autoresearch for this intent:
-
-{{intent}}
-
-{{branch_status_line}}
-
-Collected setup:
-
-- benchmark command: `{{benchmark_command}}`
-- primary metric: `{{metric_name}}`
-- metric unit: `{{metric_unit}}`
-- direction: `{{direction}}`
-- tradeoff metrics:
-{{{secondary_metrics_block}}}
-- files in scope:
-{{{scope_paths_block}}}
-- off limits:
-{{{off_limits_block}}}
-- constraints:
-{{{constraints_block}}}
-
-Explain briefly what autoresearch will do in this repository, then initialize the workspace.
-
-Your first actions:
-- write `autoresearch.md`
-- record the collected benchmark command, primary metric, metric unit, direction, tradeoff metrics, scope, off-limits list, and constraints in `autoresearch.md`
-- add a short preflight section in `autoresearch.md` covering prerequisites, one-time setup, and the comparability invariant that must stay fixed across runs
-- explicitly mark the ground-truth evaluator, fixed datasets, and other measurement-critical files as off-limits or hard constraints when they define the benchmark contract
-- write or update `autoresearch.program.md` when you learn durable heuristics, failure patterns, or repo-specific strategy that future resume turns should inherit
-- define the benchmark entrypoint in `autoresearch.sh`
-- optionally add `autoresearch.checks.sh` if correctness or quality needs a hard gate
-- run `init_experiment` with the exact collected benchmark command, metric definition, scope paths, off-limits list, and constraints
-- run and log the baseline
-- keep iterating until interrupted or until the configured iteration cap is reached

package/src/patch/diff.ts

@@ -1,433 +0,0 @@
-/**
- * Diff generation and replace-mode utilities for the edit tool.
- *
- * Provides diff string generation and the replace-mode edit logic
- * used when not in patch mode.
- */
-import * as Diff from "diff";
-import { resolveToCwd } from "../tools/path-utils";
-import { previewPatch } from "./applicator";
-import { DEFAULT_FUZZY_THRESHOLD, findMatch } from "./fuzzy";
-import type { HashlineEdit } from "./hashline";
-import { applyHashlineEdits } from "./hashline";
-import { adjustIndentation, normalizeToLF, stripBom } from "./normalize";
-import type { DiffError, DiffResult, PatchInput } from "./types";
-import { EditMatchError } from "./types";
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Diff String Generation
-// ═══════════════════════════════════════════════════════════════════════════
-
-function countContentLines(content: string): number {
-	const lines = content.split("\n");
-	if (lines.length > 1 && lines[lines.length - 1] === "") {
-		lines.pop();
-	}
-	return Math.max(1, lines.length);
-}
-
-function formatNumberedDiffLine(prefix: "+" | "-" | " ", lineNum: number, width: number, content: string): string {
-	const padded = String(lineNum).padStart(width, " ");
-	return `${prefix}${padded}|${content}`;
-}
-
-/**
- * Generate a unified 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): DiffResult {
-	const parts = Diff.diffLines(oldContent, newContent);
-	const output: string[] = [];
-
-	const maxLineNum = Math.max(countContentLines(oldContent), countContentLines(newContent));
-	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) {
-					output.push(formatNumberedDiffLine("+", newLineNum, lineNumWidth, line));
-					newLineNum++;
-				} else {
-					output.push(formatNumberedDiffLine("-", oldLineNum, lineNumWidth, 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);
-
-			if (lastWasChange || nextPartIsChange) {
-				let linesToShow = raw;
-				let skipStart = 0;
-				let skipEnd = 0;
-
-				if (!lastWasChange) {
-					// Show only last N lines as leading context
-					skipStart = Math.max(0, raw.length - contextLines);
-					linesToShow = raw.slice(skipStart);
-				}
-
-				if (!nextPartIsChange && linesToShow.length > contextLines) {
-					// Show only first N lines as trailing context
-					skipEnd = linesToShow.length - contextLines;
-					linesToShow = linesToShow.slice(0, contextLines);
-				}
-
-				// Add ellipsis if we skipped lines at start
-				if (skipStart > 0) {
-					output.push(formatNumberedDiffLine(" ", oldLineNum, lineNumWidth, "..."));
-					oldLineNum += skipStart;
-					newLineNum += skipStart;
-				}
-
-				for (const line of linesToShow) {
-					output.push(formatNumberedDiffLine(" ", oldLineNum, lineNumWidth, line));
-					oldLineNum++;
-					newLineNum++;
-				}
-
-				// Add ellipsis if we skipped lines at end
-				if (skipEnd > 0) {
-					output.push(formatNumberedDiffLine(" ", oldLineNum, lineNumWidth, "..."));
-					oldLineNum += skipEnd;
-					newLineNum += skipEnd;
-				}
-			} else {
-				// Skip these context lines entirely
-				oldLineNum += raw.length;
-				newLineNum += raw.length;
-			}
-
-			lastWasChange = false;
-		}
-	}
-
-	return { diff: output.join("\n"), firstChangedLine };
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Replace Mode Logic
-// ═══════════════════════════════════════════════════════════════════════════
-
-export interface ReplaceOptions {
-	/** Allow fuzzy matching */
-	fuzzy: boolean;
-	/** Replace all occurrences */
-	all: boolean;
-	/** Similarity threshold for fuzzy matching */
-	threshold?: number;
-}
-
-export interface ReplaceResult {
-	/** The new content after replacements */
-	content: string;
-	/** Number of replacements made */
-	count: number;
-}
-
-/**
- * Generate a unified diff string without file headers.
- * Returns both the diff string and the first changed line number (in the new file).
- */
-export function generateUnifiedDiffString(oldContent: string, newContent: string, contextLines = 3): DiffResult {
-	const patch = Diff.structuredPatch("", "", oldContent, newContent, "", "", { context: contextLines });
-	const output: string[] = [];
-	let firstChangedLine: number | undefined;
-	const maxLineNum = Math.max(countContentLines(oldContent), countContentLines(newContent));
-	const lineNumWidth = String(maxLineNum).length;
-	for (const hunk of patch.hunks) {
-		output.push(`@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`);
-		let oldLine = hunk.oldStart;
-		let newLine = hunk.newStart;
-		for (const line of hunk.lines) {
-			if (line.startsWith("-")) {
-				if (firstChangedLine === undefined) firstChangedLine = newLine;
-				output.push(formatNumberedDiffLine("-", oldLine, lineNumWidth, line.slice(1)));
-				oldLine++;
-				continue;
-			}
-			if (line.startsWith("+")) {
-				if (firstChangedLine === undefined) firstChangedLine = newLine;
-				output.push(formatNumberedDiffLine("+", newLine, lineNumWidth, line.slice(1)));
-				newLine++;
-				continue;
-			}
-			if (line.startsWith(" ")) {
-				output.push(formatNumberedDiffLine(" ", oldLine, lineNumWidth, line.slice(1)));
-				oldLine++;
-				newLine++;
-				continue;
-			}
-			output.push(line);
-		}
-	}
-
-	return { diff: output.join("\n"), firstChangedLine };
-}
-
-/**
- * Find and replace text in content using fuzzy matching.
- */
-export function replaceText(content: string, oldText: string, newText: string, options: ReplaceOptions): ReplaceResult {
-	if (oldText.length === 0) {
-		throw new Error("oldText must not be empty.");
-	}
-	const threshold = options.threshold ?? DEFAULT_FUZZY_THRESHOLD;
-	let normalizedContent = normalizeToLF(content);
-	const normalizedOldText = normalizeToLF(oldText);
-	const normalizedNewText = normalizeToLF(newText);
-	let count = 0;
-
-	if (options.all) {
-		// Check for exact matches first
-		const exactCount = normalizedContent.split(normalizedOldText).length - 1;
-		if (exactCount > 0) {
-			return {
-				content: normalizedContent.split(normalizedOldText).join(normalizedNewText),
-				count: exactCount,
-			};
-		}
-
-		// No exact matches - try fuzzy matching iteratively
-		while (true) {
-			const matchOutcome = findMatch(normalizedContent, normalizedOldText, {
-				allowFuzzy: options.fuzzy,
-				threshold,
-			});
-
-			const shouldUseClosest =
-				options.fuzzy &&
-				matchOutcome.closest &&
-				matchOutcome.closest.confidence >= threshold &&
-				(matchOutcome.fuzzyMatches === undefined || matchOutcome.fuzzyMatches <= 1);
-			const match = matchOutcome.match || (shouldUseClosest ? matchOutcome.closest : undefined);
-			if (!match) {
-				break;
-			}
-
-			const adjustedNewText = adjustIndentation(normalizedOldText, match.actualText, normalizedNewText);
-			if (adjustedNewText === match.actualText) {
-				break;
-			}
-			normalizedContent =
-				normalizedContent.substring(0, match.startIndex) +
-				adjustedNewText +
-				normalizedContent.substring(match.startIndex + match.actualText.length);
-			count++;
-		}
-
-		return { content: normalizedContent, count };
-	}
-
-	// Single replacement mode
-	const matchOutcome = findMatch(normalizedContent, normalizedOldText, {
-		allowFuzzy: options.fuzzy,
-		threshold,
-	});
-
-	if (matchOutcome.occurrences && matchOutcome.occurrences > 1) {
-		const previews = matchOutcome.occurrencePreviews?.join("\n\n") ?? "";
-		const moreMsg = matchOutcome.occurrences > 5 ? ` (showing first 5 of ${matchOutcome.occurrences})` : "";
-		throw new Error(
-			`Found ${matchOutcome.occurrences} occurrences${moreMsg}:\n\n${previews}\n\n` +
-				`Add more context lines to disambiguate.`,
-		);
-	}
-
-	if (!matchOutcome.match) {
-		return { content: normalizedContent, count: 0 };
-	}
-
-	const match = matchOutcome.match;
-	const adjustedNewText = adjustIndentation(normalizedOldText, match.actualText, normalizedNewText);
-	normalizedContent =
-		normalizedContent.substring(0, match.startIndex) +
-		adjustedNewText +
-		normalizedContent.substring(match.startIndex + match.actualText.length);
-
-	return { content: normalizedContent, count: 1 };
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Preview/Diff Computation
-// ═══════════════════════════════════════════════════════════════════════════
-
-/**
- * Compute the diff for an edit operation without applying it.
- * Used for preview rendering in the TUI before the tool executes.
- */
-export async function computeEditDiff(
-	path: string,
-	oldText: string,
-	newText: string,
-	cwd: string,
-	fuzzy = true,
-	all = false,
-	threshold?: number,
-): Promise<DiffResult | DiffError> {
-	if (oldText.length === 0) {
-		return { error: "oldText must not be empty." };
-	}
-	const absolutePath = resolveToCwd(path, cwd);
-
-	try {
-		const file = Bun.file(absolutePath);
-		try {
-			if (!(await file.exists())) {
-				return { error: `File not found: ${path}` };
-			}
-		} catch {
-			return { error: `File not found: ${path}` };
-		}
-
-		let rawContent: string;
-		try {
-			rawContent = await file.text();
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			return { error: message || `Unable to read ${path}` };
-		}
-
-		const { text: content } = stripBom(rawContent);
-		const normalizedContent = normalizeToLF(content);
-		const normalizedOldText = normalizeToLF(oldText);
-		const normalizedNewText = normalizeToLF(newText);
-
-		const result = replaceText(normalizedContent, normalizedOldText, normalizedNewText, {
-			fuzzy,
-			all,
-			threshold,
-		});
-
-		if (result.count === 0) {
-			// Get closest match for error message
-			const matchOutcome = findMatch(normalizedContent, normalizedOldText, {
-				allowFuzzy: fuzzy,
-				threshold: threshold ?? DEFAULT_FUZZY_THRESHOLD,
-			});
-
-			if (matchOutcome.occurrences && matchOutcome.occurrences > 1) {
-				const previews = matchOutcome.occurrencePreviews?.join("\n\n") ?? "";
-				const moreMsg = matchOutcome.occurrences > 5 ? ` (showing first 5 of ${matchOutcome.occurrences})` : "";
-				return {
-					error: `Found ${matchOutcome.occurrences} occurrences in ${path}${moreMsg}:\n\n${previews}\n\nAdd more context lines to disambiguate.`,
-				};
-			}
-
-			return {
-				error: EditMatchError.formatMessage(path, normalizedOldText, matchOutcome.closest, {
-					allowFuzzy: fuzzy,
-					threshold: threshold ?? DEFAULT_FUZZY_THRESHOLD,
-					fuzzyMatches: matchOutcome.fuzzyMatches,
-				}),
-			};
-		}
-
-		if (normalizedContent === result.content) {
-			return {
-				error: `No changes would be made to ${path}. The replacement produces identical content.`,
-			};
-		}
-
-		return generateDiffString(normalizedContent, result.content);
-	} catch (err) {
-		return { error: err instanceof Error ? err.message : String(err) };
-	}
-}
-
-/**
- * Compute the diff for a patch operation without applying it.
- * Used for preview rendering in the TUI before patch-mode edits execute.
- */
-export async function computePatchDiff(
-	input: PatchInput,
-	cwd: string,
-	options?: { fuzzyThreshold?: number; allowFuzzy?: boolean },
-): Promise<DiffResult | DiffError> {
-	try {
-		const result = await previewPatch(input, {
-			cwd,
-			fuzzyThreshold: options?.fuzzyThreshold,
-			allowFuzzy: options?.allowFuzzy,
-		});
-		const oldContent = result.change.oldContent ?? "";
-		const newContent = result.change.newContent ?? "";
-		const normalizedOld = normalizeToLF(stripBom(oldContent).text);
-		const normalizedNew = normalizeToLF(stripBom(newContent).text);
-		if (!normalizedOld && !normalizedNew) {
-			return { diff: "", firstChangedLine: undefined };
-		}
-		return generateUnifiedDiffString(normalizedOld, normalizedNew);
-	} catch (err) {
-		return { error: err instanceof Error ? err.message : String(err) };
-	}
-}
-/**
- * Compute the diff for a hashline operation without applying it.
- * Used for preview rendering in the TUI before hashline-mode edits execute.
- */
-export async function computeHashlineDiff(
-	input: { path: string; edits: HashlineEdit[]; move?: string },
-	cwd: string,
-): Promise<DiffResult | DiffError> {
-	const { path, edits, move } = input;
-	const absolutePath = resolveToCwd(path, cwd);
-	const movePath = move ? resolveToCwd(move, cwd) : undefined;
-	const isMoveOnly = Boolean(movePath) && movePath !== absolutePath && edits.length === 0;
-
-	try {
-		const file = Bun.file(absolutePath);
-		try {
-			if (!(await file.exists())) {
-				return { error: `File not found: ${path}` };
-			}
-		} catch {
-			return { error: `File not found: ${path}` };
-		}
-
-		if (movePath === absolutePath) {
-			return { error: "move path is the same as source path" };
-		}
-		if (isMoveOnly) {
-			return { diff: "", firstChangedLine: undefined };
-		}
-
-		let rawContent: string;
-		try {
-			rawContent = await file.text();
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			return { error: message || `Unable to read ${path}` };
-		}
-
-		const { text: content } = stripBom(rawContent);
-		const normalizedContent = normalizeToLF(content);
-		const result = applyHashlineEdits(normalizedContent, edits);
-		if (normalizedContent === result.lines && !move) {
-			return { error: `No changes would be made to ${path}. The edits produce identical content.` };
-		}
-
-		return generateDiffString(normalizedContent, result.lines);
-	} catch (err) {
-		return { error: err instanceof Error ? err.message : String(err) };
-	}
-}