@howaboua/pi-codex-conversion 1.0.14 → 1.0.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@howaboua/pi-codex-conversion",
-  "version": "1.0.14",
+  "version": "1.0.16",
   "description": "Codex-oriented tool and prompt adapter for pi coding agent",
   "type": "module",
   "repository": {

package/src/patch/core.ts

@@ -1,5 +1,6 @@
 import * as fs from "node:fs";
 import { dirname } from "node:path";
+import { linesMatch } from "./matching.ts";
 import { parsePatchActions, parseUpdateFile } from "./parser.ts";
 import { openFileAtPath, pathExists, removeFileAtPath, resolvePatchPath, writeFileAtPath } from "./paths.ts";
 import { DiffError, ExecutePatchError, type ExecutePatchResult, type ParsedPatchAction, type ParserState, type PatchAction } from "./types.ts";
@@ -64,7 +65,7 @@ function getUpdatedFile({ text, action, path }: { text: string; action: PatchAct
 		destIndex += delta;
 
 		for (const line of chunk.delLines) {
-			if (origLines[origIndex] !== line) {
+			if (!linesMatch(origLines[origIndex] ?? "", line)) {
 				throw new DiffError(`_get_updated_file: ${path}: Expected ${line} but got ${origLines[origIndex]} at line ${origIndex + 1}`);
 			}
 			origIndex += 1;

package/src/patch/matching.ts

@@ -0,0 +1,30 @@
+export type LinesMatchQuality = {
+	fuzz: number;
+	worstLineFuzz: number;
+};
+
+export function lineMatchFuzz(left: string, right: string): number | undefined {
+	if (left === right) return 0;
+	if (left.trimEnd() === right.trimEnd()) return 1;
+	if (left.trim() === right.trim()) return 100;
+	return undefined;
+}
+
+export function linesMatch(left: string, right: string): boolean {
+	return left === right || left.trimEnd() === right.trimEnd();
+}
+
+export function linesEqualFuzz({ left, right }: { left: string[]; right: string[] }): LinesMatchQuality | undefined {
+	if (left.length !== right.length) return undefined;
+
+	let fuzz = 0;
+	let worstLineFuzz = 0;
+	for (let index = 0; index < left.length; index++) {
+		const lineFuzz = lineMatchFuzz(left[index], right[index]);
+		if (lineFuzz === undefined) return undefined;
+		fuzz += lineFuzz;
+		worstLineFuzz = Math.max(worstLineFuzz, lineFuzz);
+	}
+
+	return { fuzz, worstLineFuzz };
+}

package/src/patch/parser.ts

@@ -1,3 +1,4 @@
+import { lineMatchFuzz, linesEqualFuzz } from "./matching.ts";
 import { normalizePatchPath } from "./paths.ts";
 import { DiffError, type Chunk, type ParseMode, type ParsedPatchAction, type ParserState, type PatchAction } from "./types.ts";
 
@@ -48,14 +49,6 @@ function splitFileLines(text: string): string[] {
 	return lines;
 }
 
-function linesEqual({ left, right }: { left: string[]; right: string[] }): boolean {
-	if (left.length !== right.length) return false;
-	for (let index = 0; index < left.length; index++) {
-		if (left[index] !== right[index]) return false;
-	}
-	return true;
-}
-
 function findContextCore({ lines, context, start }: { lines: string[]; context: string[]; start: number }): {
 	newIndex: number;
 	fuzz: number;
@@ -64,25 +57,30 @@ function findContextCore({ lines, context, start }: { lines: string[]; context:
 		return { newIndex: start, fuzz: 0 };
 	}
 
-	for (let index = start; index < lines.length; index++) {
-		if (linesEqual({ left: lines.slice(index, index + context.length), right: context })) {
-			return { newIndex: index, fuzz: 0 };
+	for (const tier of [0, 1, 100]) {
+		for (let index = start; index <= lines.length - context.length; index++) {
+			const quality = linesEqualFuzz({ left: lines.slice(index, index + context.length), right: context });
+			if (quality?.worstLineFuzz === tier) {
+				return { newIndex: index, fuzz: quality.fuzz };
+			}
 		}
 	}
 
-	for (let index = start; index < lines.length; index++) {
-		const left = lines.slice(index, index + context.length).map((line) => line.trimEnd());
-		const right = context.map((line) => line.trimEnd());
-		if (linesEqual({ left, right })) {
-			return { newIndex: index, fuzz: 1 };
+	return { newIndex: -1, fuzz: 0 };
+}
+
+function findSectionAnchor({ lines, target, start }: { lines: string[]; target: string; start: number }): { newIndex: number; fuzz: number } {
+	for (const tier of [0, 1, 100]) {
+		const alreadySeen = lines.slice(0, start).some((line) => lineMatchFuzz(line, target) === tier);
+		if (alreadySeen) {
+			continue;
 		}
-	}
 
-	for (let index = start; index < lines.length; index++) {
-		const left = lines.slice(index, index + context.length).map((line) => line.trim());
-		const right = context.map((line) => line.trim());
-		if (linesEqual({ left, right })) {
-			return { newIndex: index, fuzz: 100 };
+		for (let index = start; index < lines.length; index++) {
+			const fuzz = lineMatchFuzz(lines[index], target);
+			if (fuzz === tier) {
+				return { newIndex: index, fuzz };
+			}
 		}
 	}
 
@@ -263,30 +261,10 @@ export function parseUpdateFile({ state, text, path }: { state: ParserState; tex
 		}
 
 		if (defStr.trim().length > 0) {
-			let found = false;
-
-			const exactAlreadySeen = lines.slice(0, index).some((line) => line === defStr);
-			if (!exactAlreadySeen) {
-				for (let lineIndex = index; lineIndex < lines.length; lineIndex++) {
-					if (lines[lineIndex] === defStr) {
-						index = lineIndex + 1;
-						found = true;
-						break;
-					}
-				}
-			}
-
-			if (!found) {
-				const trimAlreadySeen = lines.slice(0, index).some((line) => line.trim() === defStr.trim());
-				if (!trimAlreadySeen) {
-					for (let lineIndex = index; lineIndex < lines.length; lineIndex++) {
-						if (lines[lineIndex].trim() === defStr.trim()) {
-							index = lineIndex + 1;
-							state.fuzz += 1;
-							break;
-						}
-					}
-				}
+			const sectionAnchor = findSectionAnchor({ lines, target: defStr, start: index });
+			if (sectionAnchor.newIndex !== -1) {
+				index = sectionAnchor.newIndex + 1;
+				state.fuzz += sectionAnchor.fuzz;
 			}
 		}
 

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

@@ -30,6 +30,12 @@ interface ApplyPatchPartialFailureDetails {
 	result: ExecutePatchResult;
 	error: string;
 	failedTarget?: string;
+	appliedFiles: string[];
+	failedFiles: string[];
+	recoveryInstructions: {
+		mustReadFiles: string[];
+		mustNotReadFiles: string[];
+	};
 }
 
 type ApplyPatchToolDetails = ApplyPatchSuccessDetails | ApplyPatchPartialFailureDetails;
@@ -177,6 +183,37 @@ function summarizePatchCounts(result: ExecutePatchResult): string {
 	].join(", ");
 }
 
+function uniqueStrings(values: Array<string | undefined>): string[] {
+	return Array.from(new Set(values.filter((value): value is string => typeof value === "string" && value.length > 0)));
+}
+
+function getFailedPaths(error: ExecutePatchError): string[] {
+	if (!error.failedAction) {
+		return [];
+	}
+	return uniqueStrings([
+		error.failedAction.path,
+		error.failedAction.type === "update" ? error.failedAction.movePath : undefined,
+	]);
+}
+
+function getAppliedPaths(result: ExecutePatchResult, failedFiles: string[]): string[] {
+	return result.changedFiles.filter((path) => !failedFiles.includes(path));
+}
+
+function buildPartialFailureMessage(message: string, failedFiles: string[], appliedFiles: string[]): string {
+	const lines = [message];
+	if (failedFiles.length > 0) {
+		lines.push(`Failed file${failedFiles.length === 1 ? "" : "s"}: ${failedFiles.join(", ")}`);
+		lines.push(`Recovery: MUST read ${failedFiles.join(", ")} before retrying.`);
+	}
+	if (appliedFiles.length > 0) {
+		lines.push("Earlier file actions in this patch were already applied.");
+		lines.push("Recovery: MUST NOT reread other files from this patch unless a specific dependency requires it.");
+	}
+	return lines.join("\n");
+}
+
 function describeFailedAction(error: ExecutePatchError, cwd: string): string | undefined {
 	if (!error.failedAction) {
 		return undefined;
@@ -253,14 +290,23 @@ export function registerApplyPatchTool(pi: ExtensionAPI): void {
 						: "apply_patch failed";
 					const message = failedTarget ? `${prefix} while patching ${failedTarget}: ${error.message}` : `${prefix}: ${error.message}`;
 					if (partial) {
+						const failedFiles = getFailedPaths(error);
+						const appliedFiles = getAppliedPaths(error.result, failedFiles);
+						const recoveryMessage = buildPartialFailureMessage(message, failedFiles, appliedFiles);
 						markApplyPatchPartialFailure(toolCallId, failedTarget);
 						return {
-							content: [{ type: "text", text: message }],
+							content: [{ type: "text", text: recoveryMessage }],
 							details: {
 								status: "partial_failure",
 								result: error.result,
-								error: message,
+								error: recoveryMessage,
 								failedTarget,
+								appliedFiles,
+								failedFiles,
+								recoveryInstructions: {
+									mustReadFiles: failedFiles,
+									mustNotReadFiles: appliedFiles,
+								},
 							} satisfies ApplyPatchPartialFailureDetails,
 						};
 					}