mitsupi 1.4.0 → 1.5.0

package/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to agent-stuff are documented here.
 
 ## Unreleased
 
+## 1.5.0
+
+* Added a `multi-edit` extension that replaces `edit` with support for batched `multi` edits and Codex-style `patch` payloads.
+* Added preflight validation before mutating files for both `multi` edits and `patch` operations in `multi-edit`.
+* Added `/session-breakdown` views for cwd, day-of-week, and time-of-day breakdowns.
+* Added `pi-share` support for `pi.dev` URLs and `#session_id` inputs.
+* Improved day rendering in `/session-breakdown`.
+* Fixed PDF handling in the `summarize` skill.
+* Hardened `uv` command handling by blocking pip/poetry bypasses.
+* Fixed `web-browser` startup behavior to avoid killing user Chrome instances.
+* Updated README extension docs to include `pi-extensions/multi-edit.ts`.
+
 ## 1.4.0
 
 * Added a prompt editor extension for managing prompt modes (create, rename, delete, and edit), with persistence and detection fixes.

package/README.md

@@ -20,7 +20,7 @@ All skills live in the [`skills`](skills) folder:
 * [`/native-web-search`](skills/native-web-search) - Trigger native web search with concise summaries and source URLs.
 * [`/oebb-scotty`](skills/oebb-scotty) - Plan Austrian rail journeys via ÖBB Scotty API.
 * [`/openscad`](skills/openscad) - Create/render OpenSCAD models and export STL files.
-* [`/pi-share`](skills/pi-share) - Load and parse session transcripts from shittycodingagent.ai/buildwithpi URLs.
+* [`/pi-share`](skills/pi-share) - Load and parse session transcripts from shittycodingagent.ai/buildwithpi/pi.dev URLs.
 * [`/sentry`](skills/sentry) - Fetch and analyze Sentry issues, events, transactions, and logs.
 * [`/summarize`](skills/summarize) - Convert files/URLs to Markdown via `uvx markitdown` and summarize.
 * [`/tmux`](skills/tmux) - Drive tmux sessions via keystrokes and pane output scraping.
@@ -38,6 +38,7 @@ Custom extensions for Pi Coding Agent are in [`pi-extensions`](pi-extensions):
 * [`files.ts`](pi-extensions/files.ts) - Unified file browser with git status + session references and reveal/open/edit/diff actions.
 * [`go-to-bed.ts`](pi-extensions/go-to-bed.ts) - Late-night safety guard with explicit confirmation after midnight.
 * [`loop.ts`](pi-extensions/loop.ts) - Prompt loop for rapid iterative coding with optional auto-continue.
+* [`multi-edit.ts`](pi-extensions/multi-edit.ts) - Replaces the built-in `edit` tool with batch `multi` edits and Codex-style `patch` support, including preflight validation.
 * [`notify.ts`](pi-extensions/notify.ts) - Native desktop notifications when the agent finishes.
 * [`prompt-editor.ts`](pi-extensions/prompt-editor.ts) - In-editor prompt mode selector with persistence, history, config, and shortcuts.
 * [`review.ts`](pi-extensions/review.ts) - Code review command (working tree, PR-style diff, commits, custom instructions, optional fix loop).

package/intercepted-commands/poetry

@@ -1,3 +1,10 @@
 #!/bin/bash
-echo "Error: Use uv instead of poetry (uv init, uv add, uv sync, uv run)" >&2
+
+echo "Error: poetry is disabled. Use uv instead:" >&2
+echo "" >&2
+echo "  To initialize a project: uv init" >&2
+echo "  To add a dependency: uv add PACKAGE" >&2
+echo "  To sync dependencies: uv sync" >&2
+echo "  To run commands: uv run COMMAND" >&2
+echo "" >&2
 exit 1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mitsupi",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Armin's pi coding agent commands, skills, extensions, and themes",
   "repository": {
     "type": "git",

package/pi-extensions/multi-edit.ts

@@ -0,0 +1,641 @@
+/**
+ * Multi-Edit Extension — replaces the built-in `edit` tool.
+ *
+ * Supports all original parameters (path, oldText, newText) plus:
+ * - `multi`: array of {path, oldText, newText} edits applied in sequence
+ * - `patch`: Codex-style apply_patch payload
+ *
+ * When both top-level params and `multi` are provided, the top-level edit
+ * is treated as an implicit first item prepended to the multi list.
+ *
+ * A preflight pass is performed before mutating files:
+ * - multi/top-level mode: preflight via virtualized built-in edit tool
+ * - patch mode: preflight by applying patch operations on a virtual filesystem
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { createEditTool, type EditToolDetails } from "@mariozechner/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import { constants } from "fs";
+import { access as fsAccess, readFile as fsReadFile, unlink as fsUnlink, writeFile as fsWriteFile } from "fs/promises";
+import { isAbsolute, resolve as resolvePath } from "path";
+
+const editItemSchema = Type.Object({
+	path: Type.String({ description: "Path to the file to edit (relative or absolute)" }),
+	oldText: Type.String({ description: "Exact text to find and replace (must match exactly)" }),
+	newText: Type.String({ description: "New text to replace the old text with" }),
+});
+
+const multiEditSchema = Type.Object({
+	path: Type.Optional(Type.String({ description: "Path to the file to edit (relative or absolute)" })),
+	oldText: Type.Optional(Type.String({ description: "Exact text to find and replace (must match exactly)" })),
+	newText: Type.Optional(Type.String({ description: "New text to replace the old text with" })),
+	multi: Type.Optional(
+		Type.Array(editItemSchema, {
+			description: "Multiple edits to apply in sequence. Each item has path, oldText, and newText.",
+		}),
+	),
+	patch: Type.Optional(
+		Type.String({
+			description:
+				"Codex-style apply_patch payload (*** Begin Patch ... *** End Patch). Mutually exclusive with path/oldText/newText/multi.",
+		}),
+	),
+});
+
+interface EditItem {
+	path: string;
+	oldText: string;
+	newText: string;
+}
+
+interface EditResult {
+	path: string;
+	success: boolean;
+	message: string;
+	diff?: string;
+	firstChangedLine?: number;
+}
+
+interface UpdateChunk {
+	changeContext?: string;
+	oldLines: string[];
+	newLines: string[];
+	isEndOfFile: boolean;
+}
+
+type PatchOperation =
+	| { kind: "add"; path: string; contents: string }
+	| { kind: "delete"; path: string }
+	| { kind: "update"; path: string; chunks: UpdateChunk[] };
+
+interface PatchOpResult {
+	path: string;
+	message: string;
+}
+
+interface Workspace {
+	readText: (absolutePath: string) => Promise<string>;
+	writeText: (absolutePath: string, content: string) => Promise<void>;
+	deleteFile: (absolutePath: string) => Promise<void>;
+	exists: (absolutePath: string) => Promise<boolean>;
+}
+
+function normalizeToLF(text: string): string {
+	return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+
+function resolvePatchPath(cwd: string, filePath: string): string {
+	const trimmed = filePath.trim();
+	if (!trimmed) {
+		throw new Error("Patch path cannot be empty");
+	}
+	return isAbsolute(trimmed) ? resolvePath(trimmed) : resolvePath(cwd, trimmed);
+}
+
+function ensureTrailingNewline(content: string): string {
+	return content.endsWith("\n") ? content : `${content}\n`;
+}
+
+function normaliseLineForFuzzyMatch(s: string): string {
+	return s
+		.trim()
+		.replace(/[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]/g, "-")
+		.replace(/[\u2018\u2019\u201A\u201B]/g, "'")
+		.replace(/[\u201C\u201D\u201E\u201F]/g, '"')
+		.replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " ");
+}
+
+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 searchStart = eof && lines.length >= pattern.length ? lines.length - pattern.length : start;
+	const searchEnd = lines.length - pattern.length;
+
+	const exactEqual = (a: string, b: string) => a === b;
+	const rstripEqual = (a: string, b: string) => a.trimEnd() === b.trimEnd();
+	const trimEqual = (a: string, b: string) => a.trim() === b.trim();
+	const fuzzyEqual = (a: string, b: string) => normaliseLineForFuzzyMatch(a) === normaliseLineForFuzzyMatch(b);
+
+	const passes = [exactEqual, rstripEqual, trimEqual, fuzzyEqual];
+
+	for (const eq of passes) {
+		for (let i = searchStart; i <= searchEnd; i++) {
+			let ok = true;
+			for (let p = 0; p < pattern.length; p++) {
+				if (!eq(lines[i + p], pattern[p])) {
+					ok = false;
+					break;
+				}
+			}
+			if (ok) return i;
+		}
+	}
+
+	return undefined;
+}
+
+function applyReplacements(lines: string[], replacements: Array<[number, number, string[]]>): string[] {
+	const next = [...lines];
+
+	for (const [start, oldLen, newSegment] of [...replacements].sort((a, b) => b[0] - a[0])) {
+		next.splice(start, oldLen, ...newSegment);
+	}
+
+	return next;
+}
+
+function deriveUpdatedContent(filePath: string, currentContent: string, chunks: UpdateChunk[]): string {
+	const originalLines = currentContent.split("\n");
+	if (originalLines[originalLines.length - 1] === "") {
+		originalLines.pop();
+	}
+
+	const replacements: Array<[number, number, string[]]> = [];
+	let lineIndex = 0;
+
+	for (const chunk of chunks) {
+		if (chunk.changeContext !== undefined) {
+			const ctxIndex = seekSequence(originalLines, [chunk.changeContext], lineIndex, false);
+			if (ctxIndex === undefined) {
+				throw new Error(`Failed to find context '${chunk.changeContext}' in ${filePath}`);
+			}
+			lineIndex = ctxIndex + 1;
+		}
+
+		if (chunk.oldLines.length === 0) {
+			replacements.push([originalLines.length, 0, [...chunk.newLines]]);
+			continue;
+		}
+
+		let pattern = chunk.oldLines;
+		let newSlice = chunk.newLines;
+
+		let found = seekSequence(originalLines, pattern, lineIndex, chunk.isEndOfFile);
+		if (found === undefined && pattern[pattern.length - 1] === "") {
+			pattern = pattern.slice(0, -1);
+			if (newSlice[newSlice.length - 1] === "") {
+				newSlice = newSlice.slice(0, -1);
+			}
+			found = seekSequence(originalLines, pattern, lineIndex, chunk.isEndOfFile);
+		}
+
+		if (found === undefined) {
+			throw new Error(`Failed to find expected lines in ${filePath}:\n${chunk.oldLines.join("\n")}`);
+		}
+
+		replacements.push([found, pattern.length, [...newSlice]]);
+		lineIndex = found + pattern.length;
+	}
+
+	const newLines = applyReplacements(originalLines, replacements);
+	if (newLines[newLines.length - 1] !== "") {
+		newLines.push("");
+	}
+	return newLines.join("\n");
+}
+
+function parseUpdateChunk(
+	lines: string[],
+	startIndex: number,
+	lastContentLine: number,
+	allowMissingContext: boolean,
+): { chunk: UpdateChunk; nextIndex: number } {
+	let i = startIndex;
+	let changeContext: string | undefined;
+	const first = lines[i].trimEnd();
+
+	if (first === "@@") {
+		i++;
+	} else if (first.startsWith("@@ ")) {
+		changeContext = first.slice(3);
+		i++;
+	} else if (!allowMissingContext) {
+		throw new Error(`Expected update hunk to start with @@ context marker, got: '${lines[i]}'`);
+	}
+
+	const oldLines: string[] = [];
+	const newLines: string[] = [];
+	let parsed = 0;
+	let isEndOfFile = false;
+
+	while (i <= lastContentLine) {
+		const raw = lines[i];
+		const trimmed = raw.trimEnd();
+
+		if (trimmed === "*** End of File") {
+			if (parsed === 0) {
+				throw new Error("Update hunk does not contain any lines");
+			}
+			isEndOfFile = true;
+			i++;
+			break;
+		}
+
+		if (parsed > 0 && (trimmed.startsWith("@@") || trimmed.startsWith("*** "))) {
+			break;
+		}
+
+		if (raw.length === 0) {
+			oldLines.push("");
+			newLines.push("");
+			parsed++;
+			i++;
+			continue;
+		}
+
+		const marker = raw[0];
+		const body = raw.slice(1);
+		if (marker === " ") {
+			oldLines.push(body);
+			newLines.push(body);
+		} else if (marker === "-") {
+			oldLines.push(body);
+		} else if (marker === "+") {
+			newLines.push(body);
+		} else if (parsed === 0) {
+			throw new Error(
+				`Unexpected line found in update hunk: '${raw}'. Every line should start with ' ', '+', or '-'.`,
+			);
+		} else {
+			break;
+		}
+
+		parsed++;
+		i++;
+	}
+
+	if (parsed === 0) {
+		throw new Error("Update hunk does not contain any lines");
+	}
+
+	return {
+		chunk: { changeContext, oldLines, newLines, isEndOfFile },
+		nextIndex: i,
+	};
+}
+
+function parsePatch(patchText: string): PatchOperation[] {
+	const lines = normalizeToLF(patchText).trim().split("\n");
+	if (lines.length < 2) {
+		throw new Error("Patch is empty or invalid");
+	}
+	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 operations: PatchOperation[] = [];
+	let i = 1;
+	const lastContentLine = lines.length - 2;
+
+	while (i <= lastContentLine) {
+		if (lines[i].trim() === "") {
+			i++;
+			continue;
+		}
+
+		const line = lines[i].trim();
+		if (line.startsWith("*** Add File: ")) {
+			const path = line.slice("*** Add File: ".length);
+			i++;
+			const contentLines: string[] = [];
+			while (i <= lastContentLine) {
+				const next = lines[i];
+				if (next.trim().startsWith("*** ")) break;
+				if (!next.startsWith("+")) {
+					throw new Error(`Invalid add-file line '${next}'. Add file lines must start with '+'`);
+				}
+				contentLines.push(next.slice(1));
+				i++;
+			}
+			operations.push({ kind: "add", path, contents: contentLines.length > 0 ? `${contentLines.join("\n")}\n` : "" });
+			continue;
+		}
+
+		if (line.startsWith("*** Delete File: ")) {
+			const path = line.slice("*** Delete File: ".length);
+			operations.push({ kind: "delete", path });
+			i++;
+			continue;
+		}
+
+		if (line.startsWith("*** Update File: ")) {
+			const path = line.slice("*** Update File: ".length);
+			i++;
+
+			if (i <= lastContentLine && lines[i].trim().startsWith("*** Move to: ")) {
+				throw new Error("Patch move operations (*** Move to:) are not supported.");
+			}
+
+			const chunks: UpdateChunk[] = [];
+			while (i <= lastContentLine) {
+				if (lines[i].trim() === "") {
+					i++;
+					continue;
+				}
+				if (lines[i].trim().startsWith("*** ")) {
+					break;
+				}
+
+				const parsed = parseUpdateChunk(lines, i, lastContentLine, chunks.length === 0);
+				chunks.push(parsed.chunk);
+				i = parsed.nextIndex;
+			}
+
+			if (chunks.length === 0) {
+				throw new Error(`Update file hunk for path '${path}' is empty`);
+			}
+
+			operations.push({ kind: "update", path, chunks });
+			continue;
+		}
+
+		throw new Error(
+			`'${line}' is not a valid hunk header. Valid headers: '*** Add File:', '*** Delete File:', '*** Update File:'`,
+		);
+	}
+
+	return operations;
+}
+
+function createVirtualEditOperations(): {
+	readFile: (absolutePath: string) => Promise<Buffer>;
+	writeFile: (absolutePath: string, content: string) => Promise<void>;
+	access: (absolutePath: string) => Promise<void>;
+} {
+	const files = new Map<string, string>();
+
+	async function ensureLoaded(absolutePath: string): Promise<void> {
+		if (files.has(absolutePath)) return;
+		const content = await fsReadFile(absolutePath, "utf-8");
+		files.set(absolutePath, content);
+	}
+
+	return {
+		readFile: async (absolutePath) => {
+			await ensureLoaded(absolutePath);
+			return Buffer.from(files.get(absolutePath) ?? "", "utf-8");
+		},
+		writeFile: async (absolutePath, content) => {
+			files.set(absolutePath, content);
+		},
+		access: async (absolutePath) => {
+			if (files.has(absolutePath)) return;
+			await fsAccess(absolutePath, constants.R_OK | constants.W_OK);
+		},
+	};
+}
+
+function createRealWorkspace(): Workspace {
+	return {
+		readText: (absolutePath: string) => fsReadFile(absolutePath, "utf-8"),
+		writeText: (absolutePath: string, content: string) => fsWriteFile(absolutePath, content, "utf-8"),
+		deleteFile: (absolutePath: string) => fsUnlink(absolutePath),
+		exists: async (absolutePath: string) => {
+			try {
+				await fsAccess(absolutePath, constants.F_OK);
+				return true;
+			} catch {
+				return false;
+			}
+		},
+	};
+}
+
+function createVirtualWorkspace(cwd: string): Workspace {
+	const state = new Map<string, string | null>();
+
+	async function ensureLoaded(absolutePath: string): Promise<void> {
+		if (state.has(absolutePath)) return;
+		try {
+			const content = await fsReadFile(absolutePath, "utf-8");
+			state.set(absolutePath, content);
+		} catch {
+			state.set(absolutePath, null);
+		}
+	}
+
+	return {
+		readText: async (absolutePath) => {
+			await ensureLoaded(absolutePath);
+			const content = state.get(absolutePath);
+			if (content === null || content === undefined) {
+				throw new Error(`File not found: ${absolutePath.replace(`${cwd}/`, "")}`);
+			}
+			return content;
+		},
+		writeText: async (absolutePath, content) => {
+			state.set(absolutePath, content);
+		},
+		deleteFile: async (absolutePath) => {
+			await ensureLoaded(absolutePath);
+			if (state.get(absolutePath) === null) {
+				throw new Error(`File not found: ${absolutePath.replace(`${cwd}/`, "")}`);
+			}
+			state.set(absolutePath, null);
+		},
+		exists: async (absolutePath) => {
+			await ensureLoaded(absolutePath);
+			return state.get(absolutePath) !== null;
+		},
+	};
+}
+
+async function applyPatchOperations(
+	ops: PatchOperation[],
+	workspace: Workspace,
+	cwd: string,
+	signal?: AbortSignal,
+): Promise<PatchOpResult[]> {
+	const results: PatchOpResult[] = [];
+
+	for (const op of ops) {
+		if (signal?.aborted) {
+			throw new Error("Operation aborted");
+		}
+
+		if (op.kind === "add") {
+			const abs = resolvePatchPath(cwd, op.path);
+			await workspace.writeText(abs, ensureTrailingNewline(op.contents));
+			results.push({ path: op.path, message: `Added file ${op.path}.` });
+			continue;
+		}
+
+		if (op.kind === "delete") {
+			const abs = resolvePatchPath(cwd, op.path);
+			const exists = await workspace.exists(abs);
+			if (!exists) {
+				throw new Error(`Failed to delete ${op.path}: file does not exist`);
+			}
+			await workspace.deleteFile(abs);
+			results.push({ path: op.path, message: `Deleted file ${op.path}.` });
+			continue;
+		}
+
+		const sourceAbs = resolvePatchPath(cwd, op.path);
+		const sourceText = await workspace.readText(sourceAbs);
+		const updated = deriveUpdatedContent(op.path, sourceText, op.chunks);
+
+		await workspace.writeText(sourceAbs, updated);
+		results.push({ path: op.path, message: `Updated ${op.path}.` });
+	}
+
+	return results;
+}
+
+export default function (pi: ExtensionAPI) {
+	pi.registerTool({
+		name: "edit",
+		label: "edit",
+		description:
+			"Edit a file by replacing exact text. The oldText must match exactly (including whitespace). Use this for precise, surgical edits. Supports a `multi` parameter for batch edits across one or more files, and a `patch` parameter for Codex-style patches.",
+		promptSnippet:
+			"Edit a file by replacing exact text. The oldText must match exactly (including whitespace). Use this for precise, surgical edits.",
+		promptGuidelines: [
+			"Use edit for precise changes (old text must match exactly)",
+			"Use the `multi` parameter to apply multiple edits in a single tool call",
+			"Use the `patch` parameter for Codex-style multi-file / hunk-based edits",
+		],
+		parameters: multiEditSchema,
+
+		async execute(toolCallId, params, signal, onUpdate, ctx) {
+			const { path, oldText, newText, multi, patch } = params;
+
+			const hasAnyClassicParam = path !== undefined || oldText !== undefined || newText !== undefined || multi !== undefined;
+			if (patch !== undefined && hasAnyClassicParam) {
+				throw new Error("The `patch` parameter is mutually exclusive with path/oldText/newText/multi.");
+			}
+
+			if (patch !== undefined) {
+				const ops = parsePatch(patch);
+
+				// Preflight on virtual filesystem before mutating real files.
+				await applyPatchOperations(ops, createVirtualWorkspace(ctx.cwd), ctx.cwd, signal);
+
+				// Apply for real.
+				const applied = await applyPatchOperations(ops, createRealWorkspace(), ctx.cwd, signal);
+				const summary = applied.map((r, i) => `${i + 1}. ${r.message}`).join("\n");
+				return {
+					content: [{ type: "text" as const, text: `Applied patch with ${applied.length} operation(s).\n${summary}` }],
+				};
+			}
+
+			// Build classic edit list.
+			const edits: EditItem[] = [];
+			const hasTopLevel = path !== undefined && oldText !== undefined && newText !== undefined;
+
+			if (hasTopLevel) {
+				edits.push({ path: path!, oldText: oldText!, newText: newText! });
+			} else if (path !== undefined || oldText !== undefined || newText !== undefined) {
+				const missing: string[] = [];
+				if (path === undefined) missing.push("path");
+				if (oldText === undefined) missing.push("oldText");
+				if (newText === undefined) missing.push("newText");
+				throw new Error(
+					`Incomplete top-level edit: missing ${missing.join(", ")}. Provide all three (path, oldText, newText) or use only the multi parameter.`,
+				);
+			}
+
+			if (multi) {
+				edits.push(...multi);
+			}
+
+			if (edits.length === 0) {
+				throw new Error("No edits provided. Supply path/oldText/newText, a multi array, or a patch.");
+			}
+
+			// Preflight pass before mutating files.
+			const preflightTool = createEditTool(ctx.cwd, { operations: createVirtualEditOperations() });
+			const preflightResults: EditResult[] = [];
+			for (let i = 0; i < edits.length; i++) {
+				if (signal?.aborted) {
+					throw new Error("Operation aborted");
+				}
+				const edit = edits[i];
+				try {
+					await preflightTool.execute(`${toolCallId}_preflight_${i}`, edit, signal);
+					preflightResults.push({ path: edit.path, success: true, message: "Preflight passed." });
+				} catch (err: any) {
+					preflightResults.push({ path: edit.path, success: false, message: err.message ?? String(err) });
+					throw new Error(`Preflight failed before mutating files.\n${formatResults(preflightResults, edits.length)}`);
+				}
+			}
+
+			// Apply for real with built-in edit tool.
+			const innerTool = createEditTool(ctx.cwd);
+			const results: EditResult[] = [];
+
+			for (let i = 0; i < edits.length; i++) {
+				if (signal?.aborted) {
+					throw new Error("Operation aborted");
+				}
+
+				const edit = edits[i];
+				try {
+					const result = await innerTool.execute(`${toolCallId}_${i}`, edit, signal);
+					const details = result.details as EditToolDetails | undefined;
+					const text = result.content?.[0]?.type === "text" ? result.content[0].text : `Edit ${i + 1} applied.`;
+
+					results.push({
+						path: edit.path,
+						success: true,
+						message: text,
+						diff: details?.diff,
+						firstChangedLine: details?.firstChangedLine,
+					});
+				} catch (err: any) {
+					results.push({ path: edit.path, success: false, message: err.message ?? String(err) });
+					throw new Error(formatResults(results, edits.length));
+				}
+			}
+
+			if (results.length === 1) {
+				const r = results[0];
+				return {
+					content: [{ type: "text" as const, text: r.message }],
+					details: {
+						diff: r.diff ?? "",
+						firstChangedLine: r.firstChangedLine,
+					},
+				};
+			}
+
+			const combinedDiff = results
+				.filter((r) => r.diff)
+				.map((r) => r.diff)
+				.join("\n");
+
+			const firstChanged = results.find((r) => r.firstChangedLine !== undefined)?.firstChangedLine;
+			const summary = results.map((r, i) => `${i + 1}. ${r.message}`).join("\n");
+
+			return {
+				content: [{ type: "text" as const, text: `Applied ${results.length} edit(s) successfully.\n${summary}` }],
+				details: {
+					diff: combinedDiff,
+					firstChangedLine: firstChanged,
+				},
+			};
+		},
+	});
+}
+
+function formatResults(results: EditResult[], totalEdits: number): string {
+	const lines: string[] = [];
+
+	for (let i = 0; i < results.length; i++) {
+		const r = results[i];
+		const status = r.success ? "✓" : "✗";
+		lines.push(`${status} Edit ${i + 1}/${totalEdits} (${r.path}): ${r.message}`);
+	}
+
+	const remaining = totalEdits - results.length;
+	if (remaining > 0) {
+		lines.push(`⊘ ${remaining} remaining edit(s) skipped due to error.`);
+	}
+
+	return lines.join("\n");
+}