@howaboua/pi-codex-conversion 1.0.9 → 1.0.11

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

@@ -1,8 +1,9 @@
 import { Type } from "@sinclair/typebox";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { Text } from "@mariozechner/pi-tui";
+import { Container, Text } from "@mariozechner/pi-tui";
 import { executePatch } from "../patch/core.ts";
-import type { ExecutePatchResult } from "../patch/types.ts";
+import { ExecutePatchError, type ExecutePatchResult } from "../patch/types.ts";
+import { formatApplyPatchSummary, formatPatchTarget, renderApplyPatchCall } from "./apply-patch-rendering.ts";
 
 const APPLY_PATCH_PARAMETERS = Type.Object({
 	input: Type.String({
@@ -10,6 +11,38 @@ const APPLY_PATCH_PARAMETERS = Type.Object({
 	}),
 });
 
+interface ApplyPatchRenderState {
+	cwd: string;
+	patchText: string;
+	collapsed: string;
+	expanded: string;
+	status: "pending" | "partial_failure";
+	failedTarget?: string;
+}
+
+interface ApplyPatchSuccessDetails {
+	status: "success";
+	result: ExecutePatchResult;
+}
+
+interface ApplyPatchPartialFailureDetails {
+	status: "partial_failure";
+	result: ExecutePatchResult;
+	error: string;
+	failedTarget?: string;
+}
+
+type ApplyPatchToolDetails = ApplyPatchSuccessDetails | ApplyPatchPartialFailureDetails;
+
+const applyPatchRenderStates = new Map<string, ApplyPatchRenderState>();
+
+interface ApplyPatchRenderContextLike {
+	toolCallId?: string;
+	cwd?: string;
+	expanded?: boolean;
+	argsComplete?: boolean;
+}
+
 function parseApplyPatchParams(params: unknown): { patchText: string } {
 	if (!params || typeof params !== "object" || !("input" in params) || typeof params.input !== "string") {
 		throw new Error("apply_patch requires a string 'input' parameter");
@@ -17,27 +50,179 @@ function parseApplyPatchParams(params: unknown): { patchText: string } {
 	return { patchText: params.input };
 }
 
-function isExecutePatchResult(details: unknown): details is ExecutePatchResult {
-	return typeof details === "object" && details !== null;
+function isApplyPatchToolDetails(details: unknown): details is ApplyPatchToolDetails {
+	return typeof details === "object" && details !== null && "status" in details && "result" in details;
+}
+
+function setApplyPatchRenderState(
+	toolCallId: string,
+	patchText: string,
+	cwd: string,
+	status: "pending" | "partial_failure" = "pending",
+	failedTarget?: string,
+): void {
+	const collapsed = formatApplyPatchSummary(patchText, cwd);
+	const expanded = renderApplyPatchCall(patchText, cwd);
+	applyPatchRenderStates.set(toolCallId, {
+		cwd,
+		patchText,
+		collapsed,
+		expanded,
+		status,
+		failedTarget,
+	});
+}
+
+function markApplyPatchPartialFailure(toolCallId: string, failedTarget?: string): void {
+	const existing = applyPatchRenderStates.get(toolCallId);
+	if (!existing) {
+		return;
+	}
+	applyPatchRenderStates.set(toolCallId, {
+		...existing,
+		status: "partial_failure",
+		failedTarget,
+	});
+}
+
+function renderPartialFailureCall(
+	text: string,
+	theme: { fg(role: string, text: string): string },
+	failedTarget?: string,
+): string {
+	const lines = text.split("\n");
+	if (lines.length === 0) {
+		return theme.fg("warning", "• Edit partially failed");
+	}
+	lines[0] = lines[0].replace(/^• (Added|Edited|Deleted)\b/, "• Edit partially failed");
+	const failedLineIndexes = new Set<number>();
+	if (failedTarget) {
+		for (let i = 0; i < lines.length; i += 1) {
+			const failedLine = markFailedTargetLine(lines[i], failedTarget);
+			if (failedLine) {
+				lines[i] = failedLine;
+				failedLineIndexes.add(i);
+			}
+		}
+	}
+	return lines
+		.map((line, index) => {
+			if (failedLineIndexes.has(index)) {
+				return theme.fg("error", line);
+			}
+			if (index === 0) {
+				return theme.fg("warning", line);
+			}
+			return line;
+		})
+		.join("\n");
+}
+
+function markFailedTargetLine(line: string, failedTarget: string): string | undefined {
+	const suffixMatch = line.match(/ \(\+\d+ -\d+\)$/);
+	if (!suffixMatch) {
+		return undefined;
+	}
+	const suffix = suffixMatch[0];
+	const prefixAndTarget = line.slice(0, -suffix.length);
+	const candidatePrefixes = ["• Edit partially failed ", "• Added ", "• Edited ", "• Deleted ", "  └ ", "    "];
+	for (const prefix of candidatePrefixes) {
+		if (prefixAndTarget === `${prefix}${failedTarget}`) {
+			return `${prefix}${failedTarget} failed${suffix}`;
+		}
+	}
+	return undefined;
+}
+
+function summarizePatchCounts(result: ExecutePatchResult): string {
+	return [
+		`changed ${result.changedFiles.length} file${result.changedFiles.length === 1 ? "" : "s"}`,
+		`created ${result.createdFiles.length}`,
+		`deleted ${result.deletedFiles.length}`,
+		`moved ${result.movedFiles.length}`,
+	].join(", ");
+}
+
+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);
 }
 
 export type { ExecutePatchResult } from "../patch/types.ts";
 
+export function clearApplyPatchRenderState(): void {
+	applyPatchRenderStates.clear();
+}
+
+const renderApplyPatchCallWithOptionalContext: any = (
+	args: { input?: unknown },
+	theme: { fg(role: string, text: string): string; bold(text: string): string },
+	context?: ApplyPatchRenderContextLike,
+) => {
+	if (context?.argsComplete === false) {
+		return new Text(`${theme.fg("dim", "•")} ${theme.bold("Patching")}`, 0, 0);
+	}
+	const patchText = typeof args.input === "string" ? args.input : "";
+	if (patchText.trim().length === 0) {
+		return new Text(`${theme.fg("dim", "•")} ${theme.bold("Patching")}`, 0, 0);
+	}
+	const cached = context?.toolCallId ? applyPatchRenderStates.get(context.toolCallId) : undefined;
+	const cwd = context?.cwd ?? cached?.cwd;
+	const effectivePatchText = cached?.patchText ?? patchText;
+	const baseText = context?.expanded
+		? cached?.expanded ?? renderApplyPatchCall(effectivePatchText, cwd)
+		: cached?.collapsed ?? formatApplyPatchSummary(effectivePatchText, cwd);
+	const text = cached?.status === "partial_failure" ? renderPartialFailureCall(baseText, theme, cached.failedTarget) : baseText;
+	return new Text(text, 0, 0);
+};
+
 export function registerApplyPatchTool(pi: ExtensionAPI): void {
 	pi.registerTool({
 		name: "apply_patch",
 		label: "apply_patch",
 		description: "Use `apply_patch` to edit files. Send the full patch in `input`.",
 		promptSnippet: "Edit files with a patch.",
-		promptGuidelines: ["Prefer apply_patch for focused textual edits instead of rewriting whole files."],
+		promptGuidelines: [
+			"Prefer apply_patch for focused textual edits instead of rewriting whole files.",
+			"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,
-		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+		async execute(toolCallId, params, signal, _onUpdate, ctx) {
 			if (signal?.aborted) {
 				throw new Error("apply_patch aborted");
 			}
 
 			const typedParams = parseApplyPatchParams(params);
-			const result = executePatch({ cwd: ctx.cwd, patchText: typedParams.patchText });
+			setApplyPatchRenderState(toolCallId, typedParams.patchText, ctx.cwd);
+			let result: ExecutePatchResult;
+			try {
+				result = executePatch({ cwd: ctx.cwd, patchText: typedParams.patchText });
+			} catch (error) {
+				if (error instanceof ExecutePatchError) {
+					const partial = error.hasPartialSuccess();
+					const failedTarget = describeFailedAction(error, ctx.cwd);
+					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}`;
+					if (partial) {
+						markApplyPatchPartialFailure(toolCallId, failedTarget);
+						return {
+							content: [{ type: "text", text: message }],
+							details: {
+								status: "partial_failure",
+								result: error.result,
+								error: message,
+								failedTarget,
+							} satisfies ApplyPatchPartialFailureDetails,
+						};
+					}
+					throw new Error(message);
+				}
+				throw error;
+			}
 			const summary = [
 				"Applied patch successfully.",
 				`Changed files: ${result.changedFiles.length}`,
@@ -49,36 +234,27 @@ export function registerApplyPatchTool(pi: ExtensionAPI): void {
 
 			return {
 				content: [{ type: "text", text: summary }],
-				details: result,
+				details: {
+					status: "success",
+					result,
+				} satisfies ApplyPatchSuccessDetails,
 			};
 		},
-		renderCall(_args, theme) {
-			return new Text(`${theme.fg("toolTitle", theme.bold("apply_patch"))} ${theme.fg("muted", "patch")}`, 0, 0);
-		},
+		renderCall: renderApplyPatchCallWithOptionalContext,
 		renderResult(result, { isPartial, expanded }, theme) {
 			if (isPartial) {
-				return new Text(theme.fg("warning", "Applying patch..."), 0, 0);
+				return new Text(`${theme.fg("dim", "•")} ${theme.bold("Patching")}`, 0, 0);
 			}
 
-			const details = isExecutePatchResult(result.details) ? result.details : undefined;
-			if (!details) {
-				return new Text(theme.fg("success", "Patch applied"), 0, 0);
+			if (!isApplyPatchToolDetails(result.details)) {
+				return new Container();
 			}
 
-			let text = theme.fg("success", "Patch applied");
-			text += theme.fg(
-				"dim",
-				` (${details.changedFiles.length} changed, ${details.createdFiles.length} created, ${details.deletedFiles.length} deleted)`,
-			);
-			if (expanded) {
-				for (const file of details.changedFiles) {
-					text += `\n${theme.fg("dim", file)}`;
-				}
-				for (const move of details.movedFiles) {
-					text += `\n${theme.fg("accent", move)}`;
-				}
+			if (result.details.status === "partial_failure") {
+				return new Container();
 			}
-			return new Text(text, 0, 0);
+
+			return new Container();
 		},
 	});
 }

package/src/tools/codex-rendering.ts

@@ -8,7 +8,11 @@ export interface RenderTheme {
 
 export function renderExecCommandCall(command: string, state: ExecCommandStatus, theme: RenderTheme): string {
 	const summary = summarizeShellCommand(command);
-	return summary.maskAsExplored ? renderExplorationText(summary.actions, state, theme) : renderCommandText(command, state, theme);
+	return summary.maskAsExplored ? renderExplorationText([summary.actions], state, theme) : renderCommandText(command, state, theme);
+}
+
+export function renderGroupedExecCommandCall(actionGroups: ShellAction[][], state: ExecCommandStatus, theme: RenderTheme): string {
+	return renderExplorationText(actionGroups, state, theme);
 }
 
 export function renderWriteStdinCall(
@@ -32,11 +36,11 @@ export function renderWriteStdinCall(
 	return text;
 }
 
-function renderExplorationText(actions: ShellAction[], state: ExecCommandStatus, theme: RenderTheme): string {
+function renderExplorationText(actionGroups: ShellAction[][], state: ExecCommandStatus, theme: RenderTheme): string {
 	const header = state === "running" ? "Exploring" : "Explored";
 	let text = `${theme.fg("dim", "•")} ${theme.bold(header)}`;
 
-	for (const [index, line] of coalesceReads(actions).map(formatActionLine).entries()) {
+	for (const [index, line] of coalesceReadGroups(actionGroups).map(formatActionLine).entries()) {
 		const prefix = index === 0 ? "  └ " : "    ";
 		text += `\n${theme.fg("dim", prefix)}${theme.fg("accent", line.title)} ${theme.fg("muted", line.body)}`;
 	}
@@ -83,13 +87,56 @@ function formatActionLine(action: ShellAction): { title: string; body: string }
 	return { title: "Run", body: action.command };
 }
 
-function coalesceReads(actions: ShellAction[]): ShellAction[] {
-	if (!actions.every((action) => action.kind !== "run")) return actions;
-	const reads = actions.filter((action): action is Extract<ShellAction, { kind: "read" }> => action.kind === "read");
-	if (reads.length !== actions.length) {
-		return actions;
+function coalesceReadGroups(actionGroups: ShellAction[][]): ShellAction[] {
+	const flattened: ShellAction[] = [];
+
+	for (let index = 0; index < actionGroups.length; index += 1) {
+		const actions = actionGroups[index];
+		if (actions.every((action) => action.kind === "read")) {
+			const reads: Extract<ShellAction, { kind: "read" }>[] = [];
+			const seenPaths = new Set<string>();
+			let lastRead: Extract<ShellAction, { kind: "read" }> | undefined;
+
+			for (let readIndex = index; readIndex < actionGroups.length; readIndex += 1) {
+				const readActions = actionGroups[readIndex];
+				if (!readActions.every((action) => action.kind === "read")) {
+					break;
+				}
+
+				for (const action of readActions) {
+					if (action.kind !== "read") continue;
+					lastRead = action;
+					if (seenPaths.has(action.path)) continue;
+					seenPaths.add(action.path);
+					reads.push(action);
+				}
+
+				index = readIndex;
+			}
+
+			if (lastRead) {
+				const duplicateNames = new Set<string>();
+				const seenNames = new Set<string>();
+				for (const read of reads) {
+					if (seenNames.has(read.name)) {
+						duplicateNames.add(read.name);
+						continue;
+					}
+					seenNames.add(read.name);
+				}
+				const labels = reads.map((read) => (duplicateNames.has(read.name) ? read.path : read.name));
+				flattened.push({
+					kind: "read",
+					command: labels.join(" && "),
+					name: labels.join(", "),
+					path: lastRead.path,
+				});
+			}
+			continue;
+		}
+
+		flattened.push(...actions);
 	}
 
-	const names = [...new Set(reads.map((action) => action.name))];
-	return [{ kind: "read", command: reads.map((action) => action.command).join(" && "), name: names.join(", "), path: reads[0].path }];
+	return flattened;
 }

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

@@ -1,43 +1,215 @@
+import { summarizeShellCommand, type CommandSummary, type ShellAction } from "../shell/summary.ts";
+
 export type ExecCommandStatus = "running" | "done";
 
+export interface ExecCommandRenderInfo {
+	hidden: boolean;
+	status: ExecCommandStatus;
+	actionGroups?: ShellAction[][];
+}
+
+interface ExecEntry {
+	toolCallId: string;
+	command: string;
+	summary: CommandSummary;
+	status: ExecCommandStatus;
+	hidden: boolean;
+	groupId?: number;
+	invalidate?: () => void;
+}
+
+interface ExecGroup {
+	id: number;
+	entryIds: string[];
+	visibleEntryId: string;
+}
+
 export interface ExecCommandTracker {
 	getState(command: string): ExecCommandStatus;
+	getRenderInfo(toolCallId: string | undefined, command: string): ExecCommandRenderInfo;
+	registerRenderContext(toolCallId: string | undefined, invalidate: () => void): void;
 	recordStart(toolCallId: string, command: string): void;
-	recordPersistentSession(command: string): void;
+	recordPersistentSession(toolCallId: string, sessionId: number): void;
 	recordEnd(toolCallId: string): void;
-	recordCommandFinished(command: string): void;
+	recordSessionFinished(sessionId: number): void;
+	resetExplorationGroup(): void;
+	clear(): void;
 }
 
 export function createExecCommandTracker(): ExecCommandTracker {
 	const commandByToolCallId = new Map<string, string>();
-	const executionStateByCommand = new Map<string, ExecCommandStatus>();
-	const persistentCommands = new Set<string>();
+	const runningCountsByCommand = new Map<string, number>();
+	const sessionBackedToolCallIds = new Set<string>();
+	const toolCallIdBySessionId = new Map<number, string>();
+	const entriesByToolCallId = new Map<string, ExecEntry>();
+	const groupsById = new Map<number, ExecGroup>();
+	let activeExplorationGroupId: number | undefined;
+	let nextGroupId = 1;
+
+	function incrementCommand(command: string): void {
+		runningCountsByCommand.set(command, (runningCountsByCommand.get(command) ?? 0) + 1);
+	}
+
+	function decrementCommand(command: string): void {
+		const next = (runningCountsByCommand.get(command) ?? 0) - 1;
+		if (next > 0) {
+			runningCountsByCommand.set(command, next);
+			return;
+		}
+		runningCountsByCommand.delete(command);
+	}
+
+	function invalidateToolCall(toolCallId: string | undefined): void {
+		if (!toolCallId) return;
+		entriesByToolCallId.get(toolCallId)?.invalidate?.();
+	}
+
+	function findLatestEntryByCommand(command: string): ExecEntry | undefined {
+		let latest: ExecEntry | undefined;
+		for (const entry of entriesByToolCallId.values()) {
+			if (entry.command !== command) continue;
+			latest = entry;
+		}
+		return latest;
+	}
+
+	function getGroupForEntry(entry: ExecEntry | undefined): ExecGroup | undefined {
+		if (!entry?.groupId) return undefined;
+		return groupsById.get(entry.groupId);
+	}
+
+	function getVisibleEntry(group: ExecGroup | undefined): ExecEntry | undefined {
+		if (!group) return undefined;
+		return entriesByToolCallId.get(group.visibleEntryId);
+	}
 
 	return {
 		getState(command) {
-			return executionStateByCommand.get(command) ?? "running";
+			return (runningCountsByCommand.get(command) ?? 0) > 0 ? "running" : "done";
+		},
+		getRenderInfo(toolCallId, command) {
+			if (!toolCallId) {
+				return { hidden: false, status: (runningCountsByCommand.get(command) ?? 0) > 0 ? "running" : "done" };
+			}
+
+			const entry = entriesByToolCallId.get(toolCallId);
+			if (!entry) {
+				return { hidden: false, status: (runningCountsByCommand.get(command) ?? 0) > 0 ? "running" : "done" };
+			}
+
+			if (entry.hidden) {
+				return { hidden: true, status: entry.status };
+			}
+
+			const group = getGroupForEntry(entry);
+			if (!group) {
+				return {
+					hidden: false,
+					status: entry.status,
+					actionGroups: entry.summary.maskAsExplored ? [entry.summary.actions] : undefined,
+				};
+			}
+
+			const entries = group.entryIds
+				.map((groupEntryId) => entriesByToolCallId.get(groupEntryId))
+				.filter((groupEntry): groupEntry is ExecEntry => Boolean(groupEntry));
+			return {
+				hidden: false,
+				status: entries.some((groupEntry) => groupEntry.status === "running") ? "running" : "done",
+				actionGroups: entries.map((groupEntry) => groupEntry.summary.actions),
+			};
+		},
+		registerRenderContext(toolCallId, invalidate) {
+			if (!toolCallId) return;
+			const entry = entriesByToolCallId.get(toolCallId);
+			if (!entry) return;
+			entry.invalidate = invalidate;
 		},
 		recordStart(toolCallId, command) {
 			commandByToolCallId.set(toolCallId, command);
-			executionStateByCommand.set(command, "running");
+			incrementCommand(command);
+
+			const summary = summarizeShellCommand(command);
+			const entry: ExecEntry = {
+				toolCallId,
+				command,
+				summary,
+				status: "running",
+				hidden: false,
+			};
+			entriesByToolCallId.set(toolCallId, entry);
+
+			if (!summary.maskAsExplored) {
+				activeExplorationGroupId = undefined;
+				return;
+			}
+
+			let group = activeExplorationGroupId ? groupsById.get(activeExplorationGroupId) : undefined;
+			if (!group) {
+				group = { id: nextGroupId++, entryIds: [toolCallId], visibleEntryId: toolCallId };
+				groupsById.set(group.id, group);
+				activeExplorationGroupId = group.id;
+				entry.groupId = group.id;
+				return;
+			}
+
+			const previousVisibleEntry = getVisibleEntry(group);
+			if (previousVisibleEntry) {
+				previousVisibleEntry.hidden = true;
+				invalidateToolCall(previousVisibleEntry.toolCallId);
+			}
+
+			group.entryIds.push(toolCallId);
+			group.visibleEntryId = toolCallId;
+			entry.groupId = group.id;
 		},
-		recordPersistentSession(command) {
-			persistentCommands.add(command);
-			executionStateByCommand.set(command, "running");
+		recordPersistentSession(toolCallId, sessionId) {
+			sessionBackedToolCallIds.add(toolCallId);
+			toolCallIdBySessionId.set(sessionId, toolCallId);
+			const entry = entriesByToolCallId.get(toolCallId);
+			if (!entry) return;
+			entry.status = "running";
+			const group = getGroupForEntry(entry);
+			invalidateToolCall(group?.visibleEntryId ?? entry.toolCallId);
 		},
 		recordEnd(toolCallId) {
 			const command = commandByToolCallId.get(toolCallId);
 			if (!command) return;
-			// Pi renderers do not currently receive toolCallId, so we track the
-			// last-known state per command string for compact Exploring/Explored UI.
-			if (!persistentCommands.has(command)) {
-				executionStateByCommand.set(command, "done");
+			const entry = entriesByToolCallId.get(toolCallId);
+			if (!sessionBackedToolCallIds.has(toolCallId)) {
+				decrementCommand(command);
+				if (entry) {
+					entry.status = "done";
+				}
 			}
+			const group = getGroupForEntry(entry);
+			invalidateToolCall(group?.visibleEntryId ?? toolCallId);
 			commandByToolCallId.delete(toolCallId);
 		},
-		recordCommandFinished(command) {
-			persistentCommands.delete(command);
-			executionStateByCommand.set(command, "done");
+		recordSessionFinished(sessionId) {
+			const toolCallId = toolCallIdBySessionId.get(sessionId);
+			if (!toolCallId) return;
+			toolCallIdBySessionId.delete(sessionId);
+			const entry = entriesByToolCallId.get(toolCallId);
+			if (!entry) return;
+			decrementCommand(entry.command);
+			entry.status = "done";
+			sessionBackedToolCallIds.delete(toolCallId);
+			const group = getGroupForEntry(entry);
+			invalidateToolCall(group?.visibleEntryId ?? entry.toolCallId);
+		},
+		resetExplorationGroup() {
+			activeExplorationGroupId = undefined;
+		},
+		clear() {
+			commandByToolCallId.clear();
+			runningCountsByCommand.clear();
+			sessionBackedToolCallIds.clear();
+			toolCallIdBySessionId.clear();
+			entriesByToolCallId.clear();
+			groupsById.clear();
+			activeExplorationGroupId = undefined;
+			nextGroupId = 1;
 		},
 	};
 }