@howaboua/pi-codex-conversion 1.0.16 → 1.0.18

package/README.md

@@ -8,6 +8,7 @@ This package replaces Pi's default Codex/GPT experience with a narrower Codex-li
 - 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
+- targets modern Pi tool/rendering APIs and is aligned with Pi `0.67.x`
 
 ![Available tools](./available-tools.png)
 
@@ -139,6 +140,7 @@ That keeps the prompt much closer to `pi-mono` while still steering the model to
 - `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.
+- `apply_patch` uses Pi's self-rendered tool shell mode for more stable large patch previews on current Pi versions.
 - `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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@howaboua/pi-codex-conversion",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "description": "Codex-oriented tool and prompt adapter for pi coding agent",
   "type": "module",
   "repository": {
@@ -51,11 +51,13 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@mariozechner/pi-coding-agent": "^0.62.0",
-    "@mariozechner/pi-tui": "^0.62.0",
+    "@mariozechner/pi-coding-agent": "^0.67.0",
+    "@mariozechner/pi-tui": "^0.67.0",
     "@sinclair/typebox": "*"
   },
   "devDependencies": {
+    "@mariozechner/pi-coding-agent": "^0.67.3",
+    "@mariozechner/pi-tui": "^0.67.3",
     "tsx": "^4.20.5",
     "typescript": "^5.9.3"
   },

package/src/patch/core.ts

@@ -3,7 +3,7 @@ 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";
+import { DiffError, ExecutePatchError, type ExecutePatchFailure, type ExecutePatchResult, type ParsedPatchAction, type ParserState, type PatchAction } from "./types.ts";
 
 export const patchFsOps = {
 	mkdirSync: fs.mkdirSync,
@@ -218,6 +218,14 @@ function applyAction({
 	return fuzz;
 }
 
+function getActionPaths(action: ParsedPatchAction): string[] {
+	return [action.path, action.type === "update" ? action.movePath : undefined].filter((path): path is string => typeof path === "string");
+}
+
+function getCanonicalActionPaths({ cwd, action }: { cwd: string; action: ParsedPatchAction }): string[] {
+	return getActionPaths(action).map((path) => resolvePatchPath({ cwd, patchPath: path }));
+}
+
 export function executePatch({ cwd, patchText }: { cwd: string; patchText: string }): ExecutePatchResult {
 	if (!patchText.startsWith("*** Begin Patch")) {
 		throw new DiffError("Patch must start with '*** Begin Patch'");
@@ -228,9 +236,22 @@ export function executePatch({ cwd, patchText }: { cwd: string; patchText: strin
 	const createdFiles = new Set<string>();
 	const deletedFiles = new Set<string>();
 	const movedFiles = new Set<string>();
+	const blockedPaths = new Set<string>();
+	const failures: ExecutePatchFailure[] = [];
 	let fuzz = 0;
 
 	for (const action of actions) {
+		const actionPaths = getActionPaths(action);
+		const canonicalActionPaths = getCanonicalActionPaths({ cwd, action });
+		const overlappingPaths = canonicalActionPaths.filter((path) => blockedPaths.has(path));
+		if (overlappingPaths.length > 0) {
+			failures.push({
+				action,
+				message: `Skipped because an earlier failed action affected ${actionPaths.filter((_, index) => overlappingPaths.includes(canonicalActionPaths[index])).join(", ")}`,
+			});
+			continue;
+		}
+
 		try {
 			fuzz += applyAction({
 				cwd,
@@ -242,20 +263,31 @@ export function executePatch({ cwd, patchText }: { cwd: string; patchText: strin
 			});
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
-			throw new ExecutePatchError(
-				message,
-				buildExecutePatchResult({
-					changedFiles,
-					createdFiles,
-					deletedFiles,
-					movedFiles,
-					fuzz,
-				}),
-				action,
-			);
+			for (const path of canonicalActionPaths) {
+				blockedPaths.add(path);
+			}
+			failures.push({ action, message });
 		}
 	}
 
+	if (failures.length > 0) {
+		const message =
+			failures.length === 1
+				? failures[0].message
+				: failures.map(({ action, message: failureMessage }) => `${action.path}: ${failureMessage}`).join("\n");
+		throw new ExecutePatchError(
+			message,
+			buildExecutePatchResult({
+				changedFiles,
+				createdFiles,
+				deletedFiles,
+				movedFiles,
+				fuzz,
+			}),
+			failures,
+		);
+	}
+
 	return buildExecutePatchResult({
 		changedFiles,
 		createdFiles,

package/src/patch/types.ts

@@ -36,6 +36,11 @@ export interface ExecutePatchResult {
 	fuzz: number;
 }
 
+export interface ExecutePatchFailure {
+	action: ParsedPatchAction;
+	message: string;
+}
+
 export class DiffError extends Error {
 	constructor(message: string) {
 		super(message);
@@ -46,12 +51,14 @@ export class DiffError extends Error {
 export class ExecutePatchError extends DiffError {
 	result: ExecutePatchResult;
 	failedAction?: ParsedPatchAction;
+	failures: ExecutePatchFailure[];
 
-	constructor(message: string, result: ExecutePatchResult, failedAction?: ParsedPatchAction) {
+	constructor(message: string, result: ExecutePatchResult, failures: ExecutePatchFailure[] = []) {
 		super(message);
 		this.name = "ExecutePatchError";
 		this.result = result;
-		this.failedAction = failedAction;
+		this.failures = failures;
+		this.failedAction = failures[0]?.action;
 	}
 
 	hasPartialSuccess(): boolean {

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

@@ -17,7 +17,7 @@ interface ApplyPatchRenderState {
 	collapsed: string;
 	expanded: string;
 	status: "pending" | "partial_failure" | "failed";
-	failedTarget?: string;
+	failedTargets?: string[];
 }
 
 interface ApplyPatchSuccessDetails {
@@ -29,7 +29,7 @@ interface ApplyPatchPartialFailureDetails {
 	status: "partial_failure";
 	result: ExecutePatchResult;
 	error: string;
-	failedTarget?: string;
+	failedTargets?: string[];
 	appliedFiles: string[];
 	failedFiles: string[];
 	recoveryInstructions: {
@@ -56,6 +56,21 @@ function parseApplyPatchParams(params: unknown): { patchText: string } {
 	return { patchText: params.input };
 }
 
+function prepareApplyPatchArguments(args: unknown): { input: string } {
+	if (args && typeof args === "object") {
+		if ("input" in args && typeof args.input === "string") {
+			return { input: args.input };
+		}
+		if ("patchText" in args && typeof args.patchText === "string") {
+			return { input: args.patchText };
+		}
+		if ("patch" in args && typeof args.patch === "string") {
+			return { input: args.patch };
+		}
+	}
+	return args as { input: string };
+}
+
 function isApplyPatchToolDetails(details: unknown): details is ApplyPatchToolDetails {
 	return typeof details === "object" && details !== null && "status" in details && "result" in details;
 }
@@ -65,7 +80,7 @@ function setApplyPatchRenderState(
 	patchText: string,
 	cwd: string,
 	status: "pending" | "partial_failure" | "failed" = "pending",
-	failedTarget?: string,
+	failedTargets?: string[],
 ): void {
 	const collapsed = formatApplyPatchSummary(patchText, cwd);
 	const expanded = renderApplyPatchCall(patchText, cwd);
@@ -75,15 +90,15 @@ function setApplyPatchRenderState(
 		collapsed,
 		expanded,
 		status,
-		failedTarget,
+		failedTargets,
 	});
 }
 
-function markApplyPatchPartialFailure(toolCallId: string, failedTarget?: string): void {
-	markApplyPatchFailure(toolCallId, "partial_failure", failedTarget);
+function markApplyPatchPartialFailure(toolCallId: string, failedTargets?: string[]): void {
+	markApplyPatchFailure(toolCallId, "partial_failure", failedTargets);
 }
 
-function markApplyPatchFailure(toolCallId: string, status: "partial_failure" | "failed", failedTarget?: string): void {
+function markApplyPatchFailure(toolCallId: string, status: "partial_failure" | "failed", failedTargets?: string[]): void {
 	const existing = applyPatchRenderStates.get(toolCallId);
 	if (!existing) {
 		return;
@@ -91,14 +106,14 @@ function markApplyPatchFailure(toolCallId: string, status: "partial_failure" | "
 	applyPatchRenderStates.set(toolCallId, {
 		...existing,
 		status,
-		failedTarget,
+		failedTargets,
 	});
 }
 
 function renderPartialFailureCall(
 	text: string,
 	theme: { fg(role: string, text: string): string },
-	failedTarget?: string,
+	failedTargets?: string[],
 ): string {
 	const lines = text.split("\n");
 	if (lines.length === 0) {
@@ -106,12 +121,15 @@ function renderPartialFailureCall(
 	}
 	lines[0] = lines[0].replace(/^• (Added|Edited|Deleted)\b/, "• Edit partially failed");
 	const failedLineIndexes = new Set<number>();
-	if (failedTarget) {
+	if (failedTargets) {
 		for (let i = 0; i < lines.length; i += 1) {
-			const failedLine = markFailedTargetLine(lines[i], failedTarget);
-			if (failedLine) {
-				lines[i] = failedLine;
-				failedLineIndexes.add(i);
+			for (const failedTarget of failedTargets) {
+				const failedLine = markFailedTargetLine(lines[i], failedTarget);
+				if (failedLine) {
+					lines[i] = failedLine;
+					failedLineIndexes.add(i);
+					break;
+				}
 			}
 		}
 	}
@@ -131,7 +149,7 @@ function renderPartialFailureCall(
 function renderFailedCall(
 	text: string,
 	theme: { fg(role: string, text: string): string },
-	failedTarget?: string,
+	failedTargets?: string[],
 ): string {
 	const lines = text.split("\n");
 	if (lines.length === 0) {
@@ -139,12 +157,15 @@ function renderFailedCall(
 	}
 	lines[0] = lines[0].replace(/^• (Added|Edited|Deleted)\b/, "• Edit failed");
 	const failedLineIndexes = new Set<number>();
-	if (failedTarget) {
+	if (failedTargets) {
 		for (let i = 0; i < lines.length; i += 1) {
-			const failedLine = markFailedTargetLine(lines[i], failedTarget);
-			if (failedLine) {
-				lines[i] = failedLine;
-				failedLineIndexes.add(i);
+			for (const failedTarget of failedTargets) {
+				const failedLine = markFailedTargetLine(lines[i], failedTarget);
+				if (failedLine) {
+					lines[i] = failedLine;
+					failedLineIndexes.add(i);
+					break;
+				}
 			}
 		}
 	}
@@ -188,13 +209,9 @@ function uniqueStrings(values: Array<string | undefined>): string[] {
 }
 
 function getFailedPaths(error: ExecutePatchError): string[] {
-	if (!error.failedAction) {
-		return [];
-	}
-	return uniqueStrings([
-		error.failedAction.path,
-		error.failedAction.type === "update" ? error.failedAction.movePath : undefined,
-	]);
+	return uniqueStrings(
+		error.failures.flatMap(({ action }) => [action.path, action.type === "update" ? action.movePath : undefined]),
+	);
 }
 
 function getAppliedPaths(result: ExecutePatchResult, failedFiles: string[]): string[] {
@@ -214,11 +231,10 @@ function buildPartialFailureMessage(message: string, failedFiles: string[], appl
 	return lines.join("\n");
 }
 
-function describeFailedAction(error: ExecutePatchError, cwd: string): string | undefined {
-	if (!error.failedAction) {
-		return undefined;
-	}
-	return formatPatchTarget(error.failedAction.path, error.failedAction.type === "update" ? error.failedAction.movePath : undefined, cwd);
+function describeFailedActions(error: ExecutePatchError, cwd: string): string[] {
+	return uniqueStrings(
+		error.failures.map(({ action }) => formatPatchTarget(action.path, action.type === "update" ? action.movePath : undefined, cwd)),
+	);
 }
 
 export type { ExecutePatchResult } from "../patch/types.ts";
@@ -253,9 +269,9 @@ const renderApplyPatchCallWithOptionalContext: any = (
 	}
 	const text =
 		cached?.status === "partial_failure"
-			? renderPartialFailureCall(baseText, theme, cached.failedTarget)
+			? renderPartialFailureCall(baseText, theme, cached.failedTargets)
 			: cached?.status === "failed"
-				? renderFailedCall(baseText, theme, cached.failedTarget)
+				? renderFailedCall(baseText, theme, cached.failedTargets)
 				: baseText;
 	return new Text(text, 0, 0);
 };
@@ -271,6 +287,8 @@ export function registerApplyPatchTool(pi: ExtensionAPI): void {
 			"When one task needs coordinated edits across multiple files, send them in a single apply_patch call when one coherent patch will do.",
 		],
 		parameters: APPLY_PATCH_PARAMETERS,
+		renderShell: "self",
+		prepareArguments: prepareApplyPatchArguments,
 		async execute(toolCallId, params, signal, _onUpdate, ctx) {
 			if (signal?.aborted) {
 				throw new Error("apply_patch aborted");
@@ -284,23 +302,24 @@ export function registerApplyPatchTool(pi: ExtensionAPI): void {
 			} catch (error) {
 				if (error instanceof ExecutePatchError) {
 					const partial = error.hasPartialSuccess();
-					const failedTarget = describeFailedAction(error, ctx.cwd);
+					const failedTargets = describeFailedActions(error, ctx.cwd);
+					const failedTargetSummary = failedTargets.join(", ");
 					const prefix = partial
 						? `apply_patch partially failed after ${summarizePatchCounts(error.result)}`
 						: "apply_patch failed";
-					const message = failedTarget ? `${prefix} while patching ${failedTarget}: ${error.message}` : `${prefix}: ${error.message}`;
+					const message = failedTargetSummary ? `${prefix} while patching ${failedTargetSummary}: ${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);
+						markApplyPatchPartialFailure(toolCallId, failedTargets);
 						return {
 							content: [{ type: "text", text: recoveryMessage }],
 							details: {
 								status: "partial_failure",
 								result: error.result,
 								error: recoveryMessage,
-								failedTarget,
+								failedTargets,
 								appliedFiles,
 								failedFiles,
 								recoveryInstructions: {
@@ -310,7 +329,7 @@ export function registerApplyPatchTool(pi: ExtensionAPI): void {
 							} satisfies ApplyPatchPartialFailureDetails,
 						};
 					}
-					markApplyPatchFailure(toolCallId, "failed", failedTarget);
+					markApplyPatchFailure(toolCallId, "failed", failedTargets);
 					throw new Error(message);
 				}
 				markApplyPatchFailure(toolCallId, "failed");

package/src/tools/exec-command-tool.ts

@@ -30,6 +30,26 @@ interface ExecCommandParams {
 	login?: boolean;
 }
 
+function prepareExecCommandArguments(args: unknown): ExecCommandParams {
+	if (!args || typeof args !== "object") {
+		return args as ExecCommandParams;
+	}
+
+	const record = args as Record<string, unknown>;
+	const prepared: Record<string, unknown> = { ...record };
+	if (!("cmd" in prepared) && "command" in prepared) {
+		prepared.cmd = prepared.command;
+	}
+	if (!("workdir" in prepared)) {
+		if ("cwd" in prepared) {
+			prepared.workdir = prepared.cwd;
+		} else if ("working_directory" in prepared) {
+			prepared.workdir = prepared.working_directory;
+		}
+	}
+	return prepared as unknown as ExecCommandParams;
+}
+
 function parseExecCommandParams(params: unknown): ExecCommandParams {
 	if (!params || typeof params !== "object") {
 		throw new Error("exec_command requires an object parameter");
@@ -125,6 +145,7 @@ export function registerExecCommandTool(pi: ExtensionAPI, tracker: ExecCommandTr
 			"Keep tty disabled unless the command truly needs interactive terminal behavior.",
 		],
 		parameters: EXEC_COMMAND_PARAMETERS,
+		prepareArguments: prepareExecCommandArguments,
 		async execute(toolCallId, params, signal, _onUpdate, ctx) {
 			if (signal?.aborted) {
 				throw new Error("exec_command aborted");

package/src/tools/view-image-tool.ts

@@ -68,6 +68,23 @@ export function parseViewImageParams(params: unknown): ViewImageParams {
 	return { path: params.path, detail };
 }
 
+function prepareViewImageArguments(args: unknown): Record<string, unknown> {
+	if (!args || typeof args !== "object") {
+		return args as Record<string, unknown>;
+	}
+
+	const record = args as Record<string, unknown>;
+	const prepared: Record<string, unknown> = { ...record };
+	if (!("path" in prepared)) {
+		if ("file_path" in prepared) {
+			prepared.path = prepared.file_path;
+		} else if ("image_path" in prepared) {
+			prepared.path = prepared.image_path;
+		}
+	}
+	return prepared;
+}
+
 function resolveViewImagePath(path: string, cwd: string): string {
 	return isAbsolute(path) ? path : resolve(cwd, path);
 }
@@ -131,6 +148,7 @@ export function createViewImageTool(options: CreateViewImageToolOptions = {}): T
 		promptSnippet: "View a local image from the filesystem.",
 		promptGuidelines: ["Use view_image only for image files. Use exec_command for text-file inspection."],
 		parameters,
+		prepareArguments: prepareViewImageArguments,
 		async execute(toolCallId, params, signal, _onUpdate, ctx) {
 			if (!supportsImageInputs(ctx.model)) {
 				throw new Error(VIEW_IMAGE_UNSUPPORTED_MESSAGE);

package/src/tools/web-search-tool.ts

@@ -106,6 +106,7 @@ export function createWebSearchTool(): ToolDefinition<typeof WEB_SEARCH_PARAMETE
 		promptSnippet:
 			"Search the web for sources relevant to the current task. Use it when you need up-to-date information, external references, or broader context beyond the workspace.",
 		parameters: WEB_SEARCH_PARAMETERS,
+		prepareArguments: () => ({}),
 		async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
 			if (!supportsNativeWebSearch(ctx.model)) {
 				throw new Error(WEB_SEARCH_UNSUPPORTED_MESSAGE);