@oai404iao/pi-codex-core 0.1.0-alpha.1

package/src/patch/apply.ts

@@ -0,0 +1,338 @@
+/*
+ * Substantially modified TypeScript adaptation of OpenAI Codex apply-patch
+ * behavior at 03bb3b12367397e14a8facc2e018d645ff4d8e83.
+ * See ../../THIRD_PARTY_NOTICES.md and ../../LICENSES/Apache-2.0.txt.
+ */
+
+import { chmod, lstat, mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { actionSummary, parseApplyPatch, parseApplyPatchProgress, type ParsedPatch, type PatchAction, type PatchUpdateChunk } from "./parser.js";
+
+export interface ApplyPatchOptions {
+	cwd: string;
+}
+
+export interface AppliedPatchFile {
+	kind: PatchAction["kind"];
+	path: string;
+	absolutePath: string;
+	moveTo?: string;
+	absoluteMoveTo?: string;
+}
+
+export interface ApplyPatchResult {
+	files: AppliedPatchFile[];
+	summary: string;
+}
+
+export function resolvePatchPath(pathValue: string, options: ApplyPatchOptions): string {
+	const cleaned = pathValue.trim();
+	return isAbsolute(cleaned) ? resolve(cleaned) : resolve(options.cwd, cleaned);
+}
+
+function errorCode(error: unknown): string | undefined {
+	return (error as NodeJS.ErrnoException | undefined)?.code;
+}
+
+function verificationError(error: unknown): Error {
+	const message = error instanceof Error ? error.message : String(error);
+	return message.startsWith("apply_patch verification failed:") ? new Error(message) : new Error(`apply_patch verification failed: ${message}`);
+}
+
+async function validatePatchTarget(absolutePath: string, originalPath: string): Promise<void> {
+	try {
+		const info = await lstat(absolutePath);
+		if (info.isSymbolicLink()) throw new Error(`Patch target may not be a symbolic link: ${originalPath}`);
+	} catch (error) {
+		if (error instanceof Error && error.message.startsWith("Patch ")) throw error;
+		if (errorCode(error) !== "ENOENT") throw error;
+	}
+}
+
+function normalizeForMatch(value: string): string {
+	return value.trim().replace(/[‐‑‒–—―−]/gu, "-")
+		.replace(/[‘’‚‛]/gu, "'")
+		.replace(/[“”„‟]/gu, "\"")
+		.replace(/[            　]/gu, " ");
+}
+
+function sequenceMatches(lines: string[], pattern: string[], index: number, normalize: (value: string) => string): boolean {
+	for (let offset = 0; offset < pattern.length; offset++) {
+		if (normalize(lines[index + offset]!) !== normalize(pattern[offset]!)) return false;
+	}
+	return true;
+}
+
+export function seekSequence(lines: string[], pattern: string[], start: number, eof: boolean): number | undefined {
+	if (pattern.length === 0) return start;
+	if (pattern.length > lines.length) return undefined;
+	const lastStart = lines.length - pattern.length;
+	const searchStart = eof ? lastStart : start;
+	if (searchStart > lastStart) return undefined;
+	for (const normalize of [(value: string) => value, (value: string) => value.trimEnd(), (value: string) => value.trim(), normalizeForMatch]) {
+		for (let index = searchStart; index <= lastStart; index++) {
+			if (sequenceMatches(lines, pattern, index, normalize)) return index;
+		}
+	}
+	return undefined;
+}
+
+interface Replacement {
+	start: number;
+	oldLength: number;
+	newLines: string[];
+}
+
+function computeReplacements(originalLines: string[], path: string, chunks: PatchUpdateChunk[]): Replacement[] {
+	const replacements: Replacement[] = [];
+	let lineIndex = 0;
+	for (const chunk of chunks) {
+		if (chunk.changeContext !== undefined) {
+			const contextIndex = seekSequence(originalLines, [chunk.changeContext], lineIndex, false);
+			if (contextIndex === undefined) throw new Error(`Failed to find context '${chunk.changeContext}' in ${path}`);
+			lineIndex = contextIndex + 1;
+		}
+
+		if (chunk.oldLines.length === 0) {
+			replacements.push({ start: originalLines.length, oldLength: 0, newLines: chunk.newLines });
+			continue;
+		}
+
+		let pattern = chunk.oldLines;
+		let newLines = chunk.newLines;
+		let found = seekSequence(originalLines, pattern, lineIndex, chunk.isEndOfFile);
+		if (found === undefined && pattern[pattern.length - 1] === "") {
+			pattern = pattern.slice(0, -1);
+			if (newLines[newLines.length - 1] === "") newLines = newLines.slice(0, -1);
+			found = seekSequence(originalLines, pattern, lineIndex, chunk.isEndOfFile);
+		}
+		if (found === undefined) throw new Error(`Failed to find expected lines in ${path}:\n${chunk.oldLines.join("\n")}`);
+		replacements.push({ start: found, oldLength: pattern.length, newLines });
+		lineIndex = found + pattern.length;
+	}
+	return replacements.sort((a, b) => a.start - b.start);
+}
+
+function dominantLineEnding(content: string): "\n" | "\r\n" {
+	const crlfCount = content.match(/\r\n/g)?.length ?? 0;
+	const lfCount = content.match(/\n/g)?.length ?? 0;
+	return crlfCount > lfCount / 2 ? "\r\n" : "\n";
+}
+
+export function deriveUpdatedContent(content: string, path: string, chunks: PatchUpdateChunk[]): string {
+	const lineEnding = dominantLineEnding(content);
+	const originalLines = content.replace(/\r\n/g, "\n").split("\n");
+	if (originalLines[originalLines.length - 1] === "") originalLines.pop();
+	const replacements = computeReplacements(originalLines, path, chunks);
+	const updated = [...originalLines];
+	for (const replacement of [...replacements].reverse()) {
+		updated.splice(replacement.start, replacement.oldLength, ...replacement.newLines);
+	}
+	if (updated[updated.length - 1] !== "") updated.push("");
+	return updated.join(lineEnding);
+}
+
+interface VirtualFile {
+	exists: boolean;
+	content?: string;
+}
+
+interface PlannedAction {
+	action: PatchAction;
+	absolutePath: string;
+	absoluteMoveTo?: string;
+	previousContent: string;
+	content?: string;
+}
+
+export interface ApplyPatchPreviewFile {
+	kind: PatchAction["kind"];
+	path: string;
+	moveTo?: string;
+	previousContent: string;
+	content: string;
+}
+
+export interface ApplyPatchPreview {
+	complete: boolean;
+	files: ApplyPatchPreviewFile[];
+}
+
+async function loadVirtualFile(path: string, files: Map<string, VirtualFile>): Promise<VirtualFile> {
+	const cached = files.get(path);
+	if (cached) return cached;
+	try {
+		const info = await lstat(path);
+		const file = info.isDirectory() ? { exists: true } : { exists: true, content: await readFile(path, "utf8") };
+		files.set(path, file);
+		return file;
+	} catch (error) {
+		if (errorCode(error) !== "ENOENT") throw error;
+		const file = { exists: false };
+		files.set(path, file);
+		return file;
+	}
+}
+
+async function planPatch(parsed: ParsedPatch, options: ApplyPatchOptions): Promise<PlannedAction[]> {
+	const virtualFiles = new Map<string, VirtualFile>();
+	const plans: PlannedAction[] = [];
+	for (const action of parsed.actions) {
+		const absolutePath = resolvePatchPath(action.path, options);
+		await validatePatchTarget(absolutePath, action.path);
+		const source = await loadVirtualFile(absolutePath, virtualFiles);
+
+		if (action.kind === "add") {
+			if (source.exists) throw new Error(`Add File target already exists: ${action.path}`);
+			virtualFiles.set(absolutePath, { exists: true, content: action.content });
+			plans.push({ action, absolutePath, previousContent: "", content: action.content });
+			continue;
+		}
+
+		if (!source.exists) throw new Error(`Failed to read ${action.path}: file does not exist`);
+		if (source.content === undefined) throw new Error(`Patch target is not a file: ${action.path}`);
+		if (action.kind === "delete") {
+			virtualFiles.set(absolutePath, { exists: false });
+			plans.push({ action, absolutePath, previousContent: source.content });
+			continue;
+		}
+
+		const content = deriveUpdatedContent(source.content, action.path, action.chunks);
+		let absoluteMoveTo: string | undefined;
+		if (action.moveTo) {
+			absoluteMoveTo = resolvePatchPath(action.moveTo, options);
+			await validatePatchTarget(absoluteMoveTo, action.moveTo);
+			if (absoluteMoveTo !== absolutePath) {
+				const destination = await loadVirtualFile(absoluteMoveTo, virtualFiles);
+				if (destination.exists) throw new Error(`Move target already exists: ${action.moveTo}`);
+				virtualFiles.set(absolutePath, { exists: false });
+			}
+		}
+		virtualFiles.set(absoluteMoveTo ?? absolutePath, { exists: true, content });
+		plans.push({ action, absolutePath, ...(absoluteMoveTo ? { absoluteMoveTo } : {}), previousContent: source.content, content });
+	}
+	return plans;
+}
+
+export async function previewApplyPatch(input: string, options: ApplyPatchOptions, complete = false): Promise<ApplyPatchPreview> {
+	let parsed: ParsedPatch;
+	try {
+		parsed = complete ? parseApplyPatch(input) : parseApplyPatchProgress(input);
+	} catch (error) {
+		throw verificationError(error);
+	}
+	if (parsed.actions.length === 0) return { complete, files: [] };
+	let plans: PlannedAction[];
+	try {
+		plans = await planPatch(parsed, options);
+	} catch (error) {
+		throw verificationError(error);
+	}
+	return {
+		complete,
+		files: plans.map((plan) => ({
+			kind: plan.action.kind,
+			path: plan.action.path,
+			...(plan.action.kind === "update" && plan.action.moveTo ? { moveTo: plan.action.moveTo } : {}),
+			previousContent: plan.previousContent,
+			content: plan.content ?? "",
+		})),
+	};
+}
+
+interface FileSnapshot {
+	absolutePath: string;
+	existed: boolean;
+	data?: Buffer;
+	mode?: number;
+}
+
+async function snapshotPath(absolutePath: string): Promise<FileSnapshot> {
+	try {
+		const [data, metadata] = await Promise.all([readFile(absolutePath), stat(absolutePath)]);
+		return { absolutePath, existed: true, data, mode: metadata.mode };
+	} catch (error) {
+		if (errorCode(error) === "ENOENT") return { absolutePath, existed: false };
+		throw error;
+	}
+}
+
+async function restoreSnapshots(snapshots: FileSnapshot[]): Promise<void> {
+	for (const snapshot of [...snapshots].reverse()) {
+		if (snapshot.existed) {
+			await mkdir(dirname(snapshot.absolutePath), { recursive: true });
+			await writeFile(snapshot.absolutePath, snapshot.data ?? Buffer.alloc(0));
+			if (snapshot.mode !== undefined) await chmod(snapshot.absolutePath, snapshot.mode);
+		} else {
+			await rm(snapshot.absolutePath, { force: true });
+		}
+	}
+}
+
+async function commitPlan(plan: PlannedAction): Promise<void> {
+	if (plan.action.kind === "add") {
+		await mkdir(dirname(plan.absolutePath), { recursive: true });
+		await writeFile(plan.absolutePath, plan.content ?? "", { encoding: "utf8", flag: "wx" });
+	} else if (plan.action.kind === "delete") {
+		await rm(plan.absolutePath, { force: false });
+	} else if (plan.absoluteMoveTo && plan.absoluteMoveTo !== plan.absolutePath) {
+		await writeFile(plan.absolutePath, plan.content ?? "", "utf8");
+		await mkdir(dirname(plan.absoluteMoveTo), { recursive: true });
+		await rename(plan.absolutePath, plan.absoluteMoveTo);
+	} else {
+		await writeFile(plan.absolutePath, plan.content ?? "", "utf8");
+	}
+}
+
+function appliedFile(plan: PlannedAction): AppliedPatchFile {
+	const { action } = plan;
+	return {
+		kind: action.kind,
+		path: action.path,
+		absolutePath: plan.absolutePath,
+		...(action.kind === "update" && action.moveTo ? { moveTo: action.moveTo, absoluteMoveTo: plan.absoluteMoveTo } : {}),
+	};
+}
+
+export async function applyParsedPatch(parsed: ParsedPatch, options: ApplyPatchOptions): Promise<ApplyPatchResult> {
+	let plans: PlannedAction[];
+	try {
+		plans = await planPatch(parsed, options);
+	} catch (error) {
+		throw verificationError(error);
+	}
+	const snapshots = new Map<string, FileSnapshot>();
+	for (const plan of plans) {
+		for (const path of [plan.absolutePath, plan.absoluteMoveTo].filter((value): value is string => Boolean(value))) {
+			if (!snapshots.has(path)) snapshots.set(path, await snapshotPath(path));
+		}
+	}
+
+	const files: AppliedPatchFile[] = [];
+	try {
+		for (const plan of plans) {
+			await commitPlan(plan);
+			files.push(appliedFile(plan));
+		}
+	} catch (error) {
+		const applied = files.map((file) => `${file.kind} ${file.path}`).join(", ") || "none";
+		const message = error instanceof Error ? error.message : String(error);
+		await restoreSnapshots([...snapshots.values()]);
+		throw new Error(`${message}\nPartial apply status: completed actions before failure: ${applied}. Rolled back touched files; review the working tree before retrying.`);
+	}
+
+	return {
+		files,
+		summary: `Success. Updated the following files:\n${parsed.actions.map(actionSummary).join("\n")}`,
+	};
+}
+
+export async function applyPatch(input: string, options: ApplyPatchOptions): Promise<ApplyPatchResult> {
+	let parsed: ParsedPatch;
+	try {
+		parsed = parseApplyPatch(input);
+	} catch (error) {
+		throw verificationError(error);
+	}
+	return applyParsedPatch(parsed, options);
+}

package/src/patch/parser.ts

@@ -0,0 +1,224 @@
+/*
+ * Substantially modified TypeScript adaptation of OpenAI Codex apply-patch
+ * behavior at 03bb3b12367397e14a8facc2e018d645ff4d8e83.
+ * See ../../THIRD_PARTY_NOTICES.md and ../../LICENSES/Apache-2.0.txt.
+ */
+
+export type PatchActionKind = "add" | "update" | "delete";
+
+export interface PatchUpdateChunk {
+	changeContext?: string;
+	oldLines: string[];
+	newLines: string[];
+	isEndOfFile: boolean;
+}
+
+export interface PatchAddAction {
+	kind: "add";
+	path: string;
+	content: string;
+}
+
+export interface PatchUpdateAction {
+	kind: "update";
+	path: string;
+	moveTo?: string;
+	chunks: PatchUpdateChunk[];
+}
+
+export interface PatchDeleteAction {
+	kind: "delete";
+	path: string;
+}
+
+export type PatchAction = PatchAddAction | PatchUpdateAction | PatchDeleteAction;
+
+export interface ParsedPatch {
+	actions: PatchAction[];
+}
+
+const BEGIN_PATCH = "*** Begin Patch";
+const END_PATCH = "*** End Patch";
+const ADD_FILE = "*** Add File: ";
+const UPDATE_FILE = "*** Update File: ";
+const DELETE_FILE = "*** Delete File: ";
+const MOVE_TO = "*** Move to: ";
+const END_OF_FILE = "*** End of File";
+
+function patchLines(input: string): string[] {
+	return input.trim().split("\n").map((line) => line.endsWith("\r") ? line.slice(0, -1) : line);
+}
+
+function parseHeader(line: string): { kind: PatchActionKind; path: string } | undefined {
+	for (const [marker, kind] of [[ADD_FILE, "add"], [UPDATE_FILE, "update"], [DELETE_FILE, "delete"]] as const) {
+		if (!line.startsWith(marker)) continue;
+		const path = line.slice(marker.length).trim();
+		if (!path) throw new Error("Patch file header is missing a path.");
+		return { kind, path };
+	}
+	return undefined;
+}
+
+function isBoundary(line: string): boolean {
+	const trimmed = line.trim();
+	return trimmed === END_PATCH || parseHeader(trimmed) !== undefined;
+}
+
+function invalidHunk(lineNumber: number, message: string): Error {
+	return new Error(`Invalid patch hunk on line ${lineNumber}: ${message}`);
+}
+
+function parseAdd(lines: string[], start: number, path: string): { action: PatchAddAction; next: number } {
+	let index = start;
+	let content = "";
+	while (index < lines.length && !isBoundary(lines[index]!)) {
+		const line = lines[index]!;
+		if (!line.startsWith("+")) {
+			throw invalidHunk(index + 1, `Add File lines must start with '+': ${path}`);
+		}
+		content += `${line.slice(1)}\n`;
+		index++;
+	}
+	if (!content) throw invalidHunk(start, `Add file hunk for path '${path}' is empty`);
+	return { action: { kind: "add", path, content }, next: index };
+}
+
+function newChunk(changeContext?: string): PatchUpdateChunk {
+	return { changeContext, oldLines: [], newLines: [], isEndOfFile: false };
+}
+
+function chunkIsEmpty(chunk: PatchUpdateChunk): boolean {
+	return chunk.oldLines.length === 0 && chunk.newLines.length === 0;
+}
+
+function parseUpdate(lines: string[], start: number, path: string): { action: PatchUpdateAction; next: number } {
+	let index = start;
+	let moveTo: string | undefined;
+	const moveLine = lines[index]?.trimEnd();
+	if (moveLine?.startsWith(MOVE_TO)) {
+		moveTo = moveLine.slice(MOVE_TO.length).trim();
+		if (!moveTo) throw invalidHunk(index + 1, `Move target is empty for ${path}`);
+		index++;
+	}
+
+	const chunks: PatchUpdateChunk[] = [];
+	let current: PatchUpdateChunk | undefined;
+	while (index < lines.length) {
+		const line = lines[index]!;
+		const updateLine = line.trimEnd();
+		if (updateLine === END_PATCH || parseHeader(updateLine)) break;
+
+		if (current?.isEndOfFile) {
+			if (updateLine === "") {
+				index++;
+				continue;
+			}
+			if (updateLine !== "@@" && !updateLine.startsWith("@@ ")) {
+				throw invalidHunk(index + 1, `Expected update hunk to start with a @@ context marker, got: '${line}'`);
+			}
+		}
+
+		if (updateLine === "@@" || updateLine.startsWith("@@ ")) {
+			if (current && chunkIsEmpty(current)) {
+				throw invalidHunk(index + 1, `Unexpected line found in update hunk: '${line}'. Every line should start with ' ', '+', or '-'`);
+			}
+			current = newChunk(updateLine === "@@" ? undefined : updateLine.slice(3));
+			chunks.push(current);
+			index++;
+			continue;
+		}
+
+		if (updateLine === END_OF_FILE) {
+			if (!current || chunkIsEmpty(current)) throw invalidHunk(index + 1, "Update hunk does not contain any lines");
+			current.isEndOfFile = true;
+			index++;
+			continue;
+		}
+
+		if (line === "" || line.startsWith(" ") || line.startsWith("+") || line.startsWith("-")) {
+			if (!current) {
+				current = newChunk();
+				chunks.push(current);
+			}
+			const text = line === "" ? "" : line.slice(1);
+			if (line === "" || line.startsWith(" ") || line.startsWith("-")) current.oldLines.push(text);
+			if (line === "" || line.startsWith(" ") || line.startsWith("+")) current.newLines.push(text);
+			index++;
+			continue;
+		}
+
+		throw invalidHunk(index + 1, `Expected update hunk to start with a @@ context marker, got: '${line}'`);
+	}
+
+	if (chunks.length === 0) throw invalidHunk(start, `Update file hunk for path '${path}' is empty`);
+	if (chunkIsEmpty(chunks[chunks.length - 1]!)) throw invalidHunk(index + 1, "Update hunk does not contain any lines");
+	return { action: { kind: "update", path, ...(moveTo ? { moveTo } : {}), chunks }, next: index };
+}
+
+export function parseApplyPatch(input: string): ParsedPatch {
+	if (typeof input !== "string" || input.trim().length === 0) throw new Error("apply_patch input must be a non-empty string.");
+	const lines = patchLines(input);
+	if (lines[0]?.trim() !== BEGIN_PATCH) throw new Error("The first line of the patch must be '*** Begin Patch'.");
+	if (lines[lines.length - 1]?.trim() !== END_PATCH) throw new Error("The last line of the patch must be '*** End Patch'.");
+
+	const actions: PatchAction[] = [];
+	let index = 1;
+	while (index < lines.length - 1) {
+		const line = lines[index]!.trim();
+		if (line === END_PATCH) {
+			for (let trailing = index + 1; trailing < lines.length; trailing++) {
+				if (lines[trailing]!.trim() !== "") throw new Error(`Unexpected content after '*** End Patch' at line ${trailing + 1}.`);
+			}
+			break;
+		}
+		const header = parseHeader(line);
+		if (!header) throw invalidHunk(index + 1, `'${line}' is not a valid file header`);
+		index++;
+		if (header.kind === "add") {
+			const parsed = parseAdd(lines, index, header.path);
+			actions.push(parsed.action);
+			index = parsed.next;
+		} else if (header.kind === "update") {
+			const parsed = parseUpdate(lines, index, header.path);
+			actions.push(parsed.action);
+			index = parsed.next;
+		} else {
+			actions.push({ kind: "delete", path: header.path });
+		}
+	}
+	if (index !== lines.length - 1) throw new Error("The last line of the patch must be '*** End Patch'.");
+	if (actions.length === 0) throw new Error("No files were modified.");
+	return { actions };
+}
+
+/**
+ * Best-effort parser for model arguments that are still streaming. Only
+ * newline-terminated input is considered, and incomplete trailing actions are
+ * removed until the remaining prefix forms a valid patch. Final execution
+ * always uses parseApplyPatch() instead.
+ */
+export function parseApplyPatchProgress(input: string): ParsedPatch {
+	if (typeof input !== "string" || !input.includes("\n")) return { actions: [] };
+	const normalized = input.replace(/\r\n/g, "\n");
+	const completePrefix = normalized.slice(0, normalized.lastIndexOf("\n") + 1);
+	const lines = completePrefix.split("\n");
+	while (lines[lines.length - 1] === "") lines.pop();
+	if (lines[0]?.trim() !== BEGIN_PATCH) return { actions: [] };
+
+	const minimum = Math.max(1, lines.length - 64);
+	for (let end = lines.length; end >= minimum; end--) {
+		const candidate = `${lines.slice(0, end).join("\n")}\n${END_PATCH}`;
+		try {
+			return parseApplyPatch(candidate);
+		} catch {
+			// The current line/action may be incomplete; try the previous line.
+		}
+	}
+	return { actions: [] };
+}
+
+export function actionSummary(action: PatchAction): string {
+	const path = action.kind === "update" && action.moveTo ? action.moveTo : action.path;
+	const marker = action.kind === "add" ? "A" : action.kind === "delete" ? "D" : "M";
+	return `${marker} ${path}`;
+}