@howaboua/pi-codex-conversion 1.0.9 → 1.0.11

package/README.md

@@ -7,6 +7,7 @@ This package replaces Pi's default Codex/GPT experience with a narrower Codex-li
 - swaps active tools to `exec_command`, `write_stdin`, `apply_patch`, `view_image`, and native OpenAI Codex Responses `web_search` on `openai-codex`
 - preserves Pi's composed system prompt and applies a narrow Codex-oriented delta on top
 - renders exec activity with Codex-style command and background-terminal labels
+- renders `apply_patch` calls with Codex-style `Added` / `Edited` / `Deleted` diff blocks and Pi-style colored diff lines
 
 ![Available tools](./available-tools.png)
 
@@ -54,11 +55,13 @@ npm run check
 - `rg --files src | head -n 50` -> `Explored / List src`
 - `cat README.md` -> `Explored / Read README.md`
 - `exec_command({ cmd: "npm test", yield_time_ms: 1000 })` may return `session_id`, then continue with `write_stdin`
-- `write_stdin({ session_id, chars: "" })` renders like `Waited for background terminal`
+- for short or non-interactive commands, omitting `yield_time_ms` is preferred; tiny non-interactive waits are clamped upward to avoid unnecessary follow-up calls
+- `write_stdin({ session_id, chars: "" })` renders like `Waited for background terminal` and is meant for occasional polling, not tight repoll loops
 - `write_stdin({ session_id, chars: "y\\n" })` renders like `Interacted with background terminal`
 - `view_image({ path: "/absolute/path/to/screenshot.png" })` is available on image-capable models
 - `web_search` is surfaced only on `openai-codex`, and the adapter rewrites it into the native OpenAI Responses `type: "web_search"` payload instead of executing a local function tool
 - when native web search is available, the adapter shows a one-time session notice; individual searches are not surfaced because Pi does not expose native web-search execution events to extensions
+- `apply_patch` partial failures stay inline in the patch row so successful and failed file entries can be seen together
 
 Raw command output is still available by expanding the tool result.
 
@@ -135,7 +138,10 @@ That keeps the prompt much closer to `pi-mono` while still steering the model to
 - `view_image` resolves paths against the active session cwd and only exposes `detail: "original"` for Codex-family image-capable models.
 - `web_search` is exposed only for the `openai-codex` provider and is forwarded as the native OpenAI Codex Responses web search tool.
 - `apply_patch` paths stay restricted to the current working directory.
+- partial `apply_patch` failures stay in the original patch block and highlight the failed entry instead of adding a second warning row.
 - `exec_command` / `write_stdin` use a custom PTY-backed session manager via `node-pty` for interactive sessions.
+- tiny `exec_command` waits are clamped for non-interactive commands so short runs do not burn an avoidable follow-up tool call.
+- empty `write_stdin` polls are clamped to a meaningful minimum wait so long-running processes are not repolled too aggressively.
 - PTY output handling applies basic terminal rewrite semantics (`\r`, `\b`, erase-in-line, and common escape cleanup) so interactive redraws replay sensibly.
 - Skills inventory is reintroduced in a Codex-style section when Pi's composed prompt already exposed the underlying Pi skills inventory.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@howaboua/pi-codex-conversion",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "Codex-oriented tool and prompt adapter for pi coding agent",
   "type": "module",
   "repository": {
@@ -51,8 +51,8 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@mariozechner/pi-coding-agent": "*",
-    "@mariozechner/pi-tui": "*",
+    "@mariozechner/pi-coding-agent": "^0.62.0",
+    "@mariozechner/pi-tui": "^0.62.0",
     "@sinclair/typebox": "*"
   },
   "devDependencies": {

package/src/index.ts

@@ -1,7 +1,7 @@
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { getCodexRuntimeShell } from "./adapter/runtime-shell.ts";
 import { CORE_ADAPTER_TOOL_NAMES, DEFAULT_TOOL_NAMES, STATUS_KEY, STATUS_TEXT, VIEW_IMAGE_TOOL_NAME, WEB_SEARCH_TOOL_NAME } from "./adapter/tool-set.ts";
-import { registerApplyPatchTool } from "./tools/apply-patch-tool.ts";
+import { clearApplyPatchRenderState, registerApplyPatchTool } from "./tools/apply-patch-tool.ts";
 import { isCodexLikeContext, isOpenAICodexContext } from "./adapter/codex-model.ts";
 import { createExecCommandTracker } from "./tools/exec-command-state.ts";
 import { registerExecCommandTool } from "./tools/exec-command-tool.ts";
@@ -35,6 +35,16 @@ function getCommandArg(args: unknown): string | undefined {
 	return args.cmd;
 }
 
+function isToolCallOnlyAssistantMessage(message: unknown): boolean {
+	if (!message || typeof message !== "object" || !("role" in message) || message.role !== "assistant") {
+		return false;
+	}
+	if (!("content" in message) || !Array.isArray(message.content) || message.content.length === 0) {
+		return false;
+	}
+	return message.content.every((item) => typeof item === "object" && item !== null && "type" in item && item.type === "toolCall");
+}
+
 export default function codexConversion(pi: ExtensionAPI) {
 	const tracker = createExecCommandTracker();
 	const state: AdapterState = { enabled: false, promptSkills: [], webSearchNoticeShown: false };
@@ -46,12 +56,14 @@ export default function codexConversion(pi: ExtensionAPI) {
 	registerWebSearchTool(pi);
 	registerWebSearchSessionNoteRenderer(pi);
 
-	sessions.onSessionExit((_sessionId, command) => {
-		tracker.recordCommandFinished(command);
+	sessions.onSessionExit((sessionId) => {
+		tracker.recordSessionFinished(sessionId);
 	});
 
 	pi.on("session_start", async (_event, ctx) => {
 		state.webSearchNoticeShown = false;
+		clearApplyPatchRenderState();
+		tracker.clear();
 		syncAdapter(pi, ctx, state);
 	});
 
@@ -59,8 +71,17 @@ export default function codexConversion(pi: ExtensionAPI) {
 		syncAdapter(pi, ctx, state);
 	});
 
+	pi.on("message_start", async (event) => {
+		if (event.message.role === "toolResult") return;
+		if (isToolCallOnlyAssistantMessage(event.message)) return;
+		tracker.resetExplorationGroup();
+	});
+
 	pi.on("tool_execution_start", async (event) => {
-		if (event.toolName !== "exec_command") return;
+		if (event.toolName !== "exec_command") {
+			tracker.resetExplorationGroup();
+			return;
+		}
 		const command = getCommandArg(event.args);
 		if (!command) return;
 		tracker.recordStart(event.toolCallId, command);
@@ -72,6 +93,7 @@ export default function codexConversion(pi: ExtensionAPI) {
 	});
 
 	pi.on("session_shutdown", async () => {
+		clearApplyPatchRenderState();
 		sessions.shutdown();
 	});
 

package/src/patch/core.ts

@@ -1,8 +1,36 @@
-import { mkdirSync, unlinkSync, writeFileSync } from "node:fs";
+import * as fs from "node:fs";
 import { dirname } from "node:path";
 import { parsePatchActions, parseUpdateFile } from "./parser.ts";
 import { openFileAtPath, pathExists, removeFileAtPath, resolvePatchPath, writeFileAtPath } from "./paths.ts";
-import { DiffError, type ExecutePatchResult, type ParsedPatchAction, type ParserState, type PatchAction } from "./types.ts";
+import { DiffError, ExecutePatchError, type ExecutePatchResult, type ParsedPatchAction, type ParserState, type PatchAction } from "./types.ts";
+
+export const patchFsOps = {
+	mkdirSync: fs.mkdirSync,
+	writeFileSync: fs.writeFileSync,
+	unlinkSync: fs.unlinkSync,
+};
+
+function buildExecutePatchResult({
+	changedFiles,
+	createdFiles,
+	deletedFiles,
+	movedFiles,
+	fuzz,
+}: {
+	changedFiles: Set<string>;
+	createdFiles: Set<string>;
+	deletedFiles: Set<string>;
+	movedFiles: Set<string>;
+	fuzz: number;
+}): ExecutePatchResult {
+	return {
+		changedFiles: [...changedFiles],
+		createdFiles: [...createdFiles],
+		deletedFiles: [...deletedFiles],
+		movedFiles: [...movedFiles],
+		fuzz,
+	};
+}
 
 function splitFileLines(text: string): string[] {
 	const lines = text.split("\n");
@@ -103,21 +131,23 @@ function applyMove({
 	const toAbsolutePath = resolvePatchPath({ cwd, patchPath: movePath });
 	const destinationExisted = pathExists({ cwd, path: movePath });
 
-	mkdirSync(dirname(toAbsolutePath), { recursive: true });
-	writeFileSync(toAbsolutePath, content, "utf8");
-	if (fromAbsolutePath !== toAbsolutePath) {
-		unlinkSync(fromAbsolutePath);
-	}
-
-	changedFiles.add(path);
+	patchFsOps.mkdirSync(dirname(toAbsolutePath), { recursive: true });
+	patchFsOps.writeFileSync(toAbsolutePath, content, "utf8");
 	changedFiles.add(movePath);
-	movedFiles.add(`${path} -> ${movePath}`);
 	if (!destinationExisted) {
 		createdFiles.add(movePath);
 	}
+
 	if (fromAbsolutePath !== toAbsolutePath) {
+		patchFsOps.unlinkSync(fromAbsolutePath);
+		changedFiles.add(path);
+		movedFiles.add(`${path} -> ${movePath}`);
 		deletedFiles.add(path);
+		return;
 	}
+
+	changedFiles.add(path);
+	movedFiles.add(`${path} -> ${movePath}`);
 }
 
 function applyAction({
@@ -200,21 +230,36 @@ export function executePatch({ cwd, patchText }: { cwd: string; patchText: strin
 	let fuzz = 0;
 
 	for (const action of actions) {
-		fuzz += applyAction({
-			cwd,
-			action,
-			changedFiles,
-			createdFiles,
-			deletedFiles,
-			movedFiles,
-		});
+		try {
+			fuzz += applyAction({
+				cwd,
+				action,
+				changedFiles,
+				createdFiles,
+				deletedFiles,
+				movedFiles,
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			throw new ExecutePatchError(
+				message,
+				buildExecutePatchResult({
+					changedFiles,
+					createdFiles,
+					deletedFiles,
+					movedFiles,
+					fuzz,
+				}),
+				action,
+			);
+		}
 	}
 
-	return {
-		changedFiles: [...changedFiles],
-		createdFiles: [...createdFiles],
-		deletedFiles: [...deletedFiles],
-		movedFiles: [...movedFiles],
+	return buildExecutePatchResult({
+		changedFiles,
+		createdFiles,
+		deletedFiles,
+		movedFiles,
 		fuzz,
-	};
+	});
 }

package/src/patch/types.ts

@@ -42,3 +42,25 @@ export class DiffError extends Error {
 		this.name = "DiffError";
 	}
 }
+
+export class ExecutePatchError extends DiffError {
+	result: ExecutePatchResult;
+	failedAction?: ParsedPatchAction;
+
+	constructor(message: string, result: ExecutePatchResult, failedAction?: ParsedPatchAction) {
+		super(message);
+		this.name = "ExecutePatchError";
+		this.result = result;
+		this.failedAction = failedAction;
+	}
+
+	hasPartialSuccess(): boolean {
+		return (
+			this.result.changedFiles.length > 0 ||
+			this.result.createdFiles.length > 0 ||
+			this.result.deletedFiles.length > 0 ||
+			this.result.movedFiles.length > 0 ||
+			this.result.fuzz > 0
+		);
+	}
+}

package/src/prompt/build-system-prompt.ts

@@ -6,9 +6,12 @@ export interface PromptSkill {
 
 const CODEX_GUIDELINES = [
 	"Prefer a single `apply_patch` call that updates all related files together when one coherent patch will do.",
+	"When making coordinated edits across multiple files, include them in one `apply_patch` call instead of splitting them into separate patches.",
 	"When multiple tool calls are independent, emit them together so they can execute in parallel instead of serializing them.",
 	"Use `parallel` only when tool calls are independent and can safely run at the same time.",
 	"Use `write_stdin` when an exec session returns `session_id`, and continue until `exit_code` is present.",
+	"For short or non-interactive commands, prefer the default `exec_command` wait instead of a tiny `yield_time_ms` that forces an extra follow-up call.",
+	"When polling a running exec session with empty `chars`, wait meaningfully between polls and do not repeatedly poll by reflex.",
 	"Do not request `tty` unless interactive terminal behavior is required.",
 ];
 

package/src/shell/parse-command.ts

@@ -61,8 +61,6 @@ function parseCommandImpl(command: string[]): ParsedShellCommand[] {
 		const parsed = summarizeMainTokens(tokens);
 		if (parsed.kind === "read" && cwd) {
 			commands.push({ ...parsed, path: joinPaths(cwd, parsed.path) });
-		} else if (parsed.kind === "list" && cwd && !parsed.path) {
-			commands.push({ ...parsed, path: shortDisplayPath(cwd) });
 		} else {
 			commands.push(parsed);
 		}

package/src/shell/parse.ts

@@ -18,12 +18,6 @@ export function parseShellPart(tokens: string[], cwd?: string): ShellAction | nu
 			path: joinPaths(cwd, parsed.path),
 		};
 	}
-	if (parsed.kind === "list" && cwd && !parsed.path) {
-		return {
-			...parsed,
-			path: shortDisplayPath(cwd),
-		};
-	}
 
 	return parsed;
 }

package/src/shell/tokenize.ts

@@ -84,10 +84,21 @@ export function shellSplit(input: string): string[] {
 
 export function shellQuote(token: string): string {
 	if (token.length === 0) return "''";
-	if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(token)) return token;
+	if (canEmitUnquoted(token)) return token;
 	return `'${token.replace(/'/g, `'"'"'`)}'`;
 }
 
+function canEmitUnquoted(token: string): boolean {
+	for (const char of token) {
+		if (!isUnquotedOk(char)) return false;
+	}
+	return true;
+}
+
+function isUnquotedOk(char: string): boolean {
+	return /^[+\-./:@\]_0-9A-Za-z]$/.test(char);
+}
+
 export function joinCommandTokens(tokens: string[]): string {
 	return tokens
 		.map((token) => (token === "&&" || token === "||" || token === "|" || token === ";" ? token : shellQuote(token)))

package/src/tools/apply-patch-rendering.ts

@@ -0,0 +1,352 @@
+import { isAbsolute, relative } from "node:path";
+import { renderDiff } from "@mariozechner/pi-coding-agent";
+import { openFileAtPath } from "../patch/paths.ts";
+import { parsePatchActions } from "../patch/parser.ts";
+import type { ParsedPatchAction } from "../patch/types.ts";
+
+interface PreviewLine {
+	lineNumber: number;
+	marker: " " | "+" | "-";
+	text: string;
+}
+
+interface FilePreview {
+	verb: "Added" | "Deleted" | "Edited";
+	path: string;
+	movePath?: string;
+	added: number;
+	removed: number;
+	lines: PreviewLine[];
+}
+
+export function formatApplyPatchSummary(patchText: string, cwd = process.cwd()): string {
+	let actions: ParsedPatchAction[];
+	try {
+		actions = parsePatchActions({ text: patchText });
+	} catch {
+		return "apply_patch patch";
+	}
+
+	const files = actions.map((action) => buildFilePreview(action, cwd));
+	if (files.length === 0) {
+		return "apply_patch patch";
+	}
+
+	const totalAdded = files.reduce((sum, file) => sum + file.added, 0);
+	const totalRemoved = files.reduce((sum, file) => sum + file.removed, 0);
+	const lines: string[] = [];
+
+	if (files.length === 1) {
+		const [file] = files;
+		lines.push(`${bulletHeader(file.verb, formatPatchTarget(file.path, file.movePath, cwd))} ${renderCounts(file.added, file.removed)}`);
+		return lines.join("\n");
+	}
+
+	lines.push(`${bulletHeader("Edited", `${files.length} files`)} ${renderCounts(totalAdded, totalRemoved)}`);
+	for (const [index, file] of files.entries()) {
+		const prefix = index === 0 ? "  └ " : "    ";
+		lines.push(`${prefix}${formatPatchTarget(file.path, file.movePath, cwd)} ${renderCounts(file.added, file.removed)}`);
+	}
+
+	return lines.join("\n");
+}
+
+export function formatApplyPatchCall(patchText: string, cwd = process.cwd()): string {
+	let actions: ParsedPatchAction[];
+	try {
+		actions = parsePatchActions({ text: patchText });
+	} catch {
+		return "apply_patch patch";
+	}
+
+	const files = actions.map((action) => buildFilePreview(action, cwd));
+	if (files.length === 0) {
+		return "apply_patch patch";
+	}
+
+	const totalAdded = files.reduce((sum, file) => sum + file.added, 0);
+	const totalRemoved = files.reduce((sum, file) => sum + file.removed, 0);
+	const lines: string[] = [];
+
+	if (files.length === 1) {
+		const [file] = files;
+		lines.push(`${bulletHeader(file.verb, formatPatchTarget(file.path, file.movePath, cwd))} ${renderCounts(file.added, file.removed)}`);
+		lines.push(...file.lines.map((line) => formatPreviewLine(line, file.lines)));
+		return lines.join("\n");
+	}
+
+	lines.push(`${bulletHeader("Edited", `${files.length} files`)} ${renderCounts(totalAdded, totalRemoved)}`);
+	for (const [index, file] of files.entries()) {
+		if (index > 0) {
+			lines.push("");
+		}
+		lines.push(`  └ ${formatPatchTarget(file.path, file.movePath, cwd)} ${renderCounts(file.added, file.removed)}`);
+		lines.push(...file.lines.map((line) => formatPreviewLine(line, file.lines)));
+	}
+
+	return lines.join("\n");
+}
+
+export function renderApplyPatchCall(patchText: string, cwd = process.cwd()): string {
+	let actions: ParsedPatchAction[];
+	try {
+		actions = parsePatchActions({ text: patchText });
+	} catch {
+		return "apply_patch patch";
+	}
+
+	const files = actions.map((action) => buildFilePreview(action, cwd));
+	if (files.length === 0) {
+		return "apply_patch patch";
+	}
+
+	const totalAdded = files.reduce((sum, file) => sum + file.added, 0);
+	const totalRemoved = files.reduce((sum, file) => sum + file.removed, 0);
+	const lines: string[] = [];
+
+	if (files.length === 1) {
+		const [file] = files;
+		lines.push(`${bulletHeader(file.verb, formatPatchTarget(file.path, file.movePath, cwd))} ${renderCounts(file.added, file.removed)}`);
+		lines.push(...renderPreviewLines(file.lines));
+		return lines.join("\n");
+	}
+
+	lines.push(`${bulletHeader("Edited", `${files.length} files`)} ${renderCounts(totalAdded, totalRemoved)}`);
+	for (const [index, file] of files.entries()) {
+		if (index > 0) {
+			lines.push("");
+		}
+		lines.push(`  └ ${formatPatchTarget(file.path, file.movePath, cwd)} ${renderCounts(file.added, file.removed)}`);
+		lines.push(...renderPreviewLines(file.lines));
+	}
+
+	return lines.join("\n");
+}
+
+function buildFilePreview(action: ParsedPatchAction, cwd: string): FilePreview {
+	if (action.type === "add") {
+		const lines = splitFileLines(action.newFile ?? "");
+		return {
+			verb: "Added",
+			path: action.path,
+			added: lines.length,
+			removed: 0,
+			lines: lines.map((text, index) => ({ lineNumber: index + 1, marker: "+", text })),
+		};
+	}
+
+	if (action.type === "delete") {
+		const deletedLines = readFileLines(action.path, cwd);
+		return {
+			verb: "Deleted",
+			path: action.path,
+			added: 0,
+			removed: deletedLines.length,
+			lines: deletedLines.map((text, index) => ({ lineNumber: index + 1, marker: "-", text })),
+		};
+	}
+
+	const preview = buildUpdatePreview(action, cwd);
+	return {
+		verb: "Edited",
+		path: action.path,
+		movePath: action.movePath,
+		added: preview.added,
+		removed: preview.removed,
+		lines: preview.lines,
+	};
+}
+
+function buildUpdatePreview(action: ParsedPatchAction, cwd: string): { added: number; removed: number; lines: PreviewLine[] } {
+	if (!action.lines) {
+		return { added: 0, removed: 0, lines: [] };
+	}
+
+	const originalLines = readFileLines(action.path, cwd);
+	const renderedLines: PreviewLine[] = [];
+	let added = 0;
+	let removed = 0;
+	let searchStart = 0;
+	let delta = 0;
+	let index = 0;
+
+	while (index < action.lines.length) {
+		const line = action.lines[index];
+		if (line === "*** End of File") {
+			break;
+		}
+		if (!line.startsWith("@@")) {
+			index += 1;
+			continue;
+		}
+
+		index += 1;
+		const sectionLines: string[] = [];
+		while (index < action.lines.length && !action.lines[index].startsWith("@@") && action.lines[index] !== "*** End of File") {
+			sectionLines.push(action.lines[index]);
+			index += 1;
+		}
+
+		if (sectionLines.length === 0) {
+			continue;
+		}
+
+		const oldSequence = sectionLines
+			.map(normalizePatchLine)
+			.filter((entry) => entry.marker === " " || entry.marker === "-")
+			.map((entry) => entry.text);
+		const sectionStart = findMatchingSequence(originalLines, oldSequence, searchStart);
+		let oldLineNumber = sectionStart + 1;
+		let newLineNumber = sectionStart + 1 + delta;
+
+		for (const rawLine of sectionLines) {
+			const entry = normalizePatchLine(rawLine);
+			if (entry.marker === "+") {
+				added += 1;
+				renderedLines.push({ lineNumber: newLineNumber, marker: "+", text: entry.text });
+				newLineNumber += 1;
+				continue;
+			}
+
+			if (entry.marker === "-") {
+				removed += 1;
+				renderedLines.push({ lineNumber: oldLineNumber, marker: "-", text: entry.text });
+				oldLineNumber += 1;
+				continue;
+			}
+
+			renderedLines.push({ lineNumber: newLineNumber, marker: " ", text: entry.text });
+			oldLineNumber += 1;
+			newLineNumber += 1;
+		}
+
+		searchStart = sectionStart + oldSequence.length;
+		delta += sectionLines.reduce((sum, rawLine) => {
+			const marker = normalizePatchLine(rawLine).marker;
+			if (marker === "+") return sum + 1;
+			if (marker === "-") return sum - 1;
+			return sum;
+		}, 0);
+	}
+
+	return { added, removed, lines: renderedLines };
+}
+
+function formatPreviewLine(line: PreviewLine, lines: PreviewLine[]): string {
+	const numberWidth = Math.max(1, ...lines.map((entry) => String(entry.lineNumber).length));
+	return `    ${String(line.lineNumber).padStart(numberWidth, " ")} ${line.marker}${line.text}`;
+}
+
+function renderPreviewLines(lines: PreviewLine[]): string[] {
+	if (lines.length === 0) {
+		return [];
+	}
+
+	const numberWidth = Math.max(1, ...lines.map((entry) => String(entry.lineNumber).length));
+	const diffText = lines
+		.map((line) => `${line.marker}${String(line.lineNumber).padStart(numberWidth, " ")} ${line.text}`)
+		.join("\n");
+	try {
+		return renderDiff(diffText)
+			.split("\n")
+			.map((line) => `    ${line}`);
+	} catch {
+		return lines.map((line) => formatPreviewLine(line, lines));
+	}
+}
+
+function normalizePatchLine(rawLine: string): PreviewLine {
+	const normalized = rawLine === "" ? " " : rawLine;
+	const marker = normalized[0];
+	if (marker !== " " && marker !== "+" && marker !== "-") {
+		return { lineNumber: 0, marker: " ", text: rawLine };
+	}
+	return { lineNumber: 0, marker, text: normalized.slice(1) };
+}
+
+function findMatchingSequence(lines: string[], context: string[], start: number): number {
+	if (context.length === 0) {
+		return start;
+	}
+
+	const exact = findSequence(lines, context, start, (value) => value);
+	if (exact !== -1) {
+		return exact;
+	}
+
+	const trimEnd = findSequence(lines, context, start, (value) => value.trimEnd());
+	if (trimEnd !== -1) {
+		return trimEnd;
+	}
+
+	const trim = findSequence(lines, context, start, (value) => value.trim());
+	if (trim !== -1) {
+		return trim;
+	}
+
+	return start;
+}
+
+function findSequence(lines: string[], context: string[], start: number, normalize: (value: string) => string): number {
+	for (let lineIndex = start; lineIndex <= lines.length - context.length; lineIndex += 1) {
+		let matches = true;
+		for (let contextIndex = 0; contextIndex < context.length; contextIndex += 1) {
+			if (normalize(lines[lineIndex + contextIndex]) !== normalize(context[contextIndex])) {
+				matches = false;
+				break;
+			}
+		}
+		if (matches) {
+			return lineIndex;
+		}
+	}
+	return -1;
+}
+
+export function formatPatchTarget(path: string, movePath: string | undefined, cwd: string): string {
+	const from = displayPath(path, cwd);
+	if (!movePath) {
+		return from;
+	}
+	return `${from} → ${displayPath(movePath, cwd)}`;
+}
+
+function displayPath(path: string, cwd: string): string {
+	if (!isAbsolute(path)) {
+		return path;
+	}
+
+	const relativePath = relative(cwd, path);
+	if (relativePath !== "" && !relativePath.startsWith("..") && !isAbsolute(relativePath)) {
+		return relativePath;
+	}
+
+	return path;
+}
+
+function readFileLines(path: string, cwd: string): string[] {
+	try {
+		return splitFileLines(openFileAtPath({ cwd, path }));
+	} catch {
+		return [];
+	}
+}
+
+function splitFileLines(text: string): string[] {
+	if (text.length === 0) {
+		return [];
+	}
+	const lines = text.split("\n");
+	if (lines.at(-1) === "") {
+		lines.pop();
+	}
+	return lines;
+}
+
+function bulletHeader(verb: string, label: string): string {
+	return `• ${verb} ${label}`;
+}
+
+function renderCounts(added: number, removed: number): string {
+	return `(+${added} -${removed})`;
+}