@oh-my-pi/pi-coding-agent 14.0.5 → 14.1.1

package/src/cursor.ts

@@ -13,6 +13,7 @@ import type {
 	CursorExecHandlers as ICursorExecHandlers,
 	ToolResultMessage,
 } from "@oh-my-pi/pi-ai";
+import { sanitizeText } from "@oh-my-pi/pi-natives";
 import { resolveToCwd } from "./tools/path-utils";
 
 interface CursorExecBridgeOptions {
@@ -65,12 +66,16 @@ async function executeTool(
 
 	const onUpdate: AgentToolUpdateCallback<unknown> | undefined = options.emitEvent
 		? partialResult => {
+				const sanitizedResult: AgentToolResult<unknown> = {
+					content: partialResult.content.map(c => (c.type === "text" ? { ...c, text: sanitizeText(c.text) } : c)),
+					details: partialResult.details,
+				};
 				options.emitEvent?.({
 					type: "tool_execution_update",
 					toolCallId,
 					toolName,
 					args,
-					partialResult,
+					partialResult: sanitizedResult,
 				});
 			}
 		: undefined;
@@ -89,7 +94,11 @@ async function executeTool(
 		isError = true;
 	}
 
-	options.emitEvent?.({ type: "tool_execution_end", toolCallId, toolName, result, isError });
+	const sanitizedFinalResult: AgentToolResult<unknown> = {
+		content: result.content.map(c => (c.type === "text" ? { ...c, text: sanitizeText(c.text) } : c)),
+		details: result.details,
+	};
+	options.emitEvent?.({ type: "tool_execution_end", toolCallId, toolName, result: sanitizedFinalResult, isError });
 
 	return createToolResultMessage(toolCallId, toolName, result, isError);
 }
@@ -233,21 +242,43 @@ export class CursorExecHandlers implements ICursorExecHandlers {
 		let result: AgentToolResult<unknown>;
 		let isError = false;
 
-		// Track previously streamed text so we only forward deltas.
-		let streamedLen = 0;
+		let rawText = "";
+		let sanitizedRawText = "";
+		let streamedSanitizedText = "";
+		let canStreamSanitizedDelta = true;
 		const onUpdate: AgentToolUpdateCallback<unknown> = partialResult => {
+			const newRawText = partialResult.content.map(c => (c.type === "text" ? c.text : "")).join("");
+			if (newRawText === rawText) {
+				return;
+			}
+			rawText = newRawText;
+			sanitizedRawText = sanitizeText(newRawText);
+			const sanitizedPartialResult: AgentToolResult<unknown> = {
+				content: [{ type: "text" as const, text: sanitizedRawText }],
+				details: partialResult.details,
+			};
 			this.options.emitEvent?.({
 				type: "tool_execution_update",
 				toolCallId,
 				toolName,
 				args: toolArgs,
-				partialResult,
+				partialResult: sanitizedPartialResult,
 			});
-			const text = partialResult.content.map(c => (c.type === "text" ? c.text : "")).join("");
-			if (text.length > streamedLen) {
-				callbacks.onStdout(text.slice(streamedLen));
-				streamedLen = text.length;
+			if (!canStreamSanitizedDelta) {
+				return;
+			}
+			if (sanitizedRawText.startsWith(streamedSanitizedText)) {
+				const sanitizedDelta = sanitizedRawText.slice(streamedSanitizedText.length);
+				streamedSanitizedText = sanitizedRawText;
+				if (sanitizedDelta) {
+					callbacks.onStdout(sanitizedDelta);
+				}
+				return;
 			}
+			// Cursor's shell-stream callback is append-only. Once the sanitized snapshot
+			// stops being a prefix extension, we can no longer repair the stream safely.
+			// Keep emitting full snapshots via tool_execution_update, but stop stdout deltas.
+			canStreamSanitizedDelta = false;
 		};
 
 		try {
@@ -260,12 +291,30 @@ export class CursorExecHandlers implements ICursorExecHandlers {
 
 		// onUpdate may not fire for every chunk — flush any remaining output
 		// from the final result that wasn't already streamed.
-		const finalText = result.content.map(c => (c.type === "text" ? c.text : "")).join("");
-		if (finalText.length > streamedLen) {
-			callbacks.onStdout(finalText.slice(streamedLen));
+		const finalRawText = result.content.map(c => (c.type === "text" ? c.text : "")).join("");
+		if (finalRawText !== rawText) {
+			rawText = finalRawText;
+			sanitizedRawText = sanitizeText(finalRawText);
+		}
+		if (canStreamSanitizedDelta && sanitizedRawText.startsWith(streamedSanitizedText)) {
+			const finalDelta = sanitizedRawText.slice(streamedSanitizedText.length);
+			streamedSanitizedText = sanitizedRawText;
+			if (finalDelta) {
+				callbacks.onStdout(finalDelta);
+			}
 		}
 
-		this.options.emitEvent?.({ type: "tool_execution_end", toolCallId, toolName, result, isError });
+		const sanitizedFinalResult: AgentToolResult<unknown> = {
+			content: result.content.map(c => (c.type === "text" ? { ...c, text: sanitizeText(c.text) } : c)),
+			details: result.details,
+		};
+		this.options.emitEvent?.({
+			type: "tool_execution_end",
+			toolCallId,
+			toolName,
+			result: sanitizedFinalResult,
+			isError,
+		});
 		return createToolResultMessage(toolCallId, toolName, result, isError);
 	}
 
@@ -285,16 +334,8 @@ export class CursorExecHandlers implements ICursorExecHandlers {
 		if (!tool) {
 			const availableTools = Array.from(this.options.tools.keys()).filter(name => name.startsWith("mcp_"));
 			const message = formatMcpToolErrorMessage(toolName, availableTools);
-			const toolResult: ToolResultMessage = {
-				role: "toolResult",
-				toolCallId,
-				toolName,
-				content: [{ type: "text", text: message }],
-				details: {},
-				isError: true,
-				timestamp: Date.now(),
-			};
-			return toolResult;
+			const result = buildToolErrorResult(message);
+			return createToolResultMessage(toolCallId, toolName, result, true);
 		}
 
 		const args = Object.keys(call.args ?? {}).length > 0 ? call.args : decodeMcpArgs(call.rawArgs ?? {});

package/src/edit/index.ts

@@ -1,5 +1,6 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { prompt } from "@oh-my-pi/pi-utils";
+import type { Static } from "@sinclair/typebox";
 import {
 	createLspWritethrough,
 	type FileDiagnosticsResult,
@@ -12,19 +13,41 @@ import hashlineDescription from "../prompts/tools/hashline.md" with { type: "tex
 import patchDescription from "../prompts/tools/patch.md" with { type: "text" };
 import replaceDescription from "../prompts/tools/replace.md" with { type: "text" };
 import type { ToolSession } from "../tools";
+import { VimTool, vimSchema } from "../tools/vim";
 import { type EditMode, normalizeEditMode, resolveEditMode } from "../utils/edit-mode";
+import type { VimToolDetails } from "../vim/types";
 import {
 	type ChunkParams,
+	type ChunkToolEdit,
 	chunkEditParamsSchema,
-	executeChunkMode,
+	executeChunkSingle,
 	isChunkParams,
+	parseChunkEditPath,
 	resolveAnchorStyle,
 	resolveChunkAutoIndent,
 } from "./modes/chunk";
-import { executeHashlineMode, type HashlineParams, hashlineEditParamsSchema, isHashlineParams } from "./modes/hashline";
-import { executePatchMode, isPatchParams, type PatchParams, patchEditSchema } from "./modes/patch";
-import { executeReplaceMode, isReplaceParams, type ReplaceParams, replaceEditSchema } from "./modes/replace";
-import { type EditToolDetails, getLspBatchRequest, type LspBatchRequest } from "./renderer";
+import {
+	executeHashlineSingle,
+	type HashlineParams,
+	type HashlineToolEdit,
+	hashlineEditParamsSchema,
+	isHashlineParams,
+} from "./modes/hashline";
+import {
+	executePatchSingle,
+	isPatchParams,
+	type PatchEditEntry,
+	type PatchParams,
+	patchEditSchema,
+} from "./modes/patch";
+import {
+	executeReplaceSingle,
+	isReplaceParams,
+	type ReplaceEditEntry,
+	type ReplaceParams,
+	replaceEditSchema,
+} from "./modes/replace";
+import { type EditToolDetails, type EditToolPerFileResult, getLspBatchRequest, type LspBatchRequest } from "./renderer";
 
 export { DEFAULT_EDIT_MODE, type EditMode, normalizeEditMode } from "../utils/edit-mode";
 export * from "./diff";
@@ -40,22 +63,25 @@ type TInput =
 	| typeof replaceEditSchema
 	| typeof patchEditSchema
 	| typeof hashlineEditParamsSchema
-	| typeof chunkEditParamsSchema;
+	| typeof chunkEditParamsSchema
+	| typeof vimSchema;
 
-type EditParams = ReplaceParams | PatchParams | HashlineParams | ChunkParams;
-
-type ModeExecutionArgs = {
-	params: EditParams;
-	signal: AbortSignal | undefined;
-	batchRequest: LspBatchRequest | undefined;
-};
+type VimParams = Static<typeof vimSchema>;
+type EditParams = ReplaceParams | PatchParams | HashlineParams | ChunkParams | VimParams;
+type EditToolResultDetails = EditToolDetails | VimToolDetails;
 
 type EditModeDefinition = {
 	description: (session: ToolSession) => string;
 	parameters: TInput;
 	invalidParamsMessage: string;
 	validate: (params: EditParams) => boolean;
-	execute: (tool: EditTool, args: ModeExecutionArgs) => Promise<AgentToolResult<EditToolDetails, TInput>>;
+	execute: (
+		tool: EditTool,
+		params: EditParams,
+		signal: AbortSignal | undefined,
+		batchRequest: LspBatchRequest | undefined,
+		onUpdate?: (partialResult: AgentToolResult<EditToolResultDetails, TInput>) => void,
+	) => Promise<AgentToolResult<EditToolResultDetails, TInput>>;
 };
 
 function resolveConfiguredEditMode(rawEditMode: string): EditMode | undefined {
@@ -71,6 +97,10 @@ function resolveConfiguredEditMode(rawEditMode: string): EditMode | undefined {
 	return editMode;
 }
 
+function isVimParams(params: EditParams): params is VimParams {
+	return typeof params === "object" && params !== null && "file" in params && typeof params.file === "string";
+}
+
 function resolveAllowFuzzy(session: ToolSession, rawValue: string): boolean {
 	switch (rawValue) {
 		case "true":
@@ -106,6 +136,94 @@ function createEditWritethrough(session: ToolSession): WritethroughCallback {
 	return enableLsp ? createLspWritethrough(session.cwd, { enableFormat, enableDiagnostics }) : writethroughNoop;
 }
 
+/** Group items by a key, preserving insertion order. */
+function groupBy<T, K>(items: T[], key: (item: T) => K): Map<K, T[]> {
+	const map = new Map<K, T[]>();
+	for (const item of items) {
+		const k = key(item);
+		let arr = map.get(k);
+		if (!arr) {
+			arr = [];
+			map.set(k, arr);
+		}
+		arr.push(item);
+	}
+	return map;
+}
+
+/** Run single-file executors for each file group and aggregate results. */
+async function executePerFile(
+	fileEntries: {
+		path: string;
+		run: (batchRequest: LspBatchRequest | undefined) => Promise<AgentToolResult<EditToolDetails, any>>;
+	}[],
+	outerBatchRequest: LspBatchRequest | undefined,
+	onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
+): Promise<AgentToolResult<EditToolDetails, TInput>> {
+	if (fileEntries.length === 1) {
+		// Single file — just run directly, no wrapping
+		return fileEntries[0].run(outerBatchRequest);
+	}
+
+	const perFileResults: EditToolPerFileResult[] = [];
+	const contentTexts: string[] = [];
+
+	for (let i = 0; i < fileEntries.length; i++) {
+		const { path, run } = fileEntries[i];
+		const isLast = i === fileEntries.length - 1;
+		const batchRequest: LspBatchRequest | undefined = outerBatchRequest
+			? { id: outerBatchRequest.id, flush: isLast && outerBatchRequest.flush }
+			: undefined;
+
+		try {
+			const result = await run(batchRequest);
+			const details = result.details;
+			perFileResults.push({
+				path,
+				diff: details?.diff ?? "",
+				firstChangedLine: details?.firstChangedLine,
+				diagnostics: details?.diagnostics,
+				op: details?.op,
+				move: details?.move,
+				meta: details?.meta,
+			});
+			const text = result.content?.find(c => c.type === "text")?.text ?? "";
+			if (text) contentTexts.push(text);
+		} catch (err) {
+			const errorText = err instanceof Error ? err.message : String(err);
+			perFileResults.push({ path, diff: "", isError: true, errorText });
+			contentTexts.push(`Error editing ${path}: ${errorText}`);
+		}
+
+		// Emit partial result after each file so UI shows progressive completion
+		if (!isLast && onUpdate) {
+			onUpdate({
+				content: [{ type: "text", text: contentTexts.join("\n") }],
+				details: {
+					diff: perFileResults
+						.map(r => r.diff)
+						.filter(Boolean)
+						.join("\n"),
+					firstChangedLine: perFileResults.find(r => r.firstChangedLine)?.firstChangedLine,
+					perFileResults: [...perFileResults],
+				},
+			});
+		}
+	}
+
+	return {
+		content: [{ type: "text", text: contentTexts.join("\n") }],
+		details: {
+			diff: perFileResults
+				.map(r => r.diff)
+				.filter(Boolean)
+				.join("\n"),
+			firstChangedLine: perFileResults.find(r => r.firstChangedLine)?.firstChangedLine,
+			perFileResults,
+		},
+	};
+}
+
 export class EditTool implements AgentTool<TInput> {
 	readonly name = "edit";
 	readonly label = "Edit";
@@ -117,6 +235,7 @@ export class EditTool implements AgentTool<TInput> {
 	readonly #fuzzyThreshold: number;
 	readonly #writethrough: WritethroughCallback;
 	readonly #editMode?: EditMode;
+	readonly #vimTool: VimTool;
 	readonly #pendingDeferredFetches = new Map<string, AbortController>();
 
 	constructor(private readonly session: ToolSession) {
@@ -130,6 +249,7 @@ export class EditTool implements AgentTool<TInput> {
 		this.#allowFuzzy = resolveAllowFuzzy(session, editFuzzy);
 		this.#fuzzyThreshold = resolveFuzzyThreshold(session, editFuzzyThreshold);
 		this.#writethrough = createEditWritethrough(session);
+		this.#vimTool = new VimTool(session);
 	}
 
 	get mode(): EditMode {
@@ -145,51 +265,19 @@ export class EditTool implements AgentTool<TInput> {
 		return this.#getModeDefinition().parameters;
 	}
 
-	async execute(
-		_toolCallId: string,
-		params: ReplaceParams,
-		signal?: AbortSignal,
-		_onUpdate?: AgentToolUpdateCallback<EditToolDetails, TInput>,
-		context?: AgentToolContext,
-	): Promise<AgentToolResult<EditToolDetails, TInput>>;
-	async execute(
-		_toolCallId: string,
-		params: PatchParams,
-		signal?: AbortSignal,
-		_onUpdate?: AgentToolUpdateCallback<EditToolDetails, TInput>,
-		context?: AgentToolContext,
-	): Promise<AgentToolResult<EditToolDetails, TInput>>;
-	async execute(
-		_toolCallId: string,
-		params: HashlineParams,
-		signal?: AbortSignal,
-		_onUpdate?: AgentToolUpdateCallback<EditToolDetails, TInput>,
-		context?: AgentToolContext,
-	): Promise<AgentToolResult<EditToolDetails, TInput>>;
-	async execute(
-		_toolCallId: string,
-		params: ChunkParams,
-		signal?: AbortSignal,
-		_onUpdate?: AgentToolUpdateCallback<EditToolDetails, TInput>,
-		context?: AgentToolContext,
-	): Promise<AgentToolResult<EditToolDetails, TInput>>;
 	async execute(
 		_toolCallId: string,
 		params: EditParams,
 		signal?: AbortSignal,
-		_onUpdate?: AgentToolUpdateCallback<EditToolDetails, TInput>,
+		onUpdate?: AgentToolUpdateCallback<EditToolResultDetails, TInput>,
 		context?: AgentToolContext,
-	): Promise<AgentToolResult<EditToolDetails, TInput>> {
+	): Promise<AgentToolResult<EditToolResultDetails, TInput>> {
 		const modeDefinition = this.#getModeDefinition();
 		if (!modeDefinition.validate(params)) {
 			throw new Error(modeDefinition.invalidParamsMessage);
 		}
 
-		return modeDefinition.execute(this, {
-			params,
-			signal,
-			batchRequest: getLspBatchRequest(context?.toolCall),
-		});
+		return modeDefinition.execute(this, params, signal, getLspBatchRequest(context?.toolCall), onUpdate);
 	}
 
 	#getModeDefinition(): EditModeDefinition {
@@ -203,15 +291,29 @@ export class EditTool implements AgentTool<TInput> {
 				parameters: chunkEditParamsSchema,
 				invalidParamsMessage: "Invalid edit parameters for chunk mode.",
 				validate: isChunkParams,
-				async execute(tool: EditTool, args: ModeExecutionArgs) {
-					return executeChunkMode({
-						session: tool.session,
-						params: args.params as ChunkParams,
-						signal: args.signal,
-						batchRequest: args.batchRequest,
-						writethrough: tool.#writethrough,
-						beginDeferredDiagnosticsForPath: path => tool.#beginDeferredDiagnosticsForPath(path),
-					});
+				execute: (
+					tool: EditTool,
+					params: EditParams,
+					signal: AbortSignal | undefined,
+					batchRequest: LspBatchRequest | undefined,
+					onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
+				) => {
+					const { edits } = params as ChunkParams;
+					const byFile = groupBy(edits, (e: ChunkToolEdit) => parseChunkEditPath(e.path).filePath);
+					const entries = [...byFile.entries()].map(([filePath, fileEdits]) => ({
+						path: filePath,
+						run: (br: LspBatchRequest | undefined) =>
+							executeChunkSingle({
+								session: tool.session,
+								path: filePath,
+								edits: fileEdits,
+								signal,
+								batchRequest: br,
+								writethrough: tool.#writethrough,
+								beginDeferredDiagnosticsForPath: p => tool.#beginDeferredDiagnosticsForPath(p),
+							}),
+					}));
+					return executePerFile(entries, batchRequest, onUpdate);
 				},
 			},
 			patch: {
@@ -219,17 +321,29 @@ export class EditTool implements AgentTool<TInput> {
 				parameters: patchEditSchema,
 				invalidParamsMessage: "Invalid edit parameters for patch mode.",
 				validate: isPatchParams,
-				async execute(tool: EditTool, args: ModeExecutionArgs) {
-					return executePatchMode({
-						session: tool.session,
-						params: args.params as PatchParams,
-						signal: args.signal,
-						batchRequest: args.batchRequest,
-						allowFuzzy: tool.#allowFuzzy,
-						fuzzyThreshold: tool.#fuzzyThreshold,
-						writethrough: tool.#writethrough,
-						beginDeferredDiagnosticsForPath: path => tool.#beginDeferredDiagnosticsForPath(path),
-					});
+				execute: (
+					tool: EditTool,
+					params: EditParams,
+					signal: AbortSignal | undefined,
+					batchRequest: LspBatchRequest | undefined,
+					onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
+				) => {
+					const { edits } = params as PatchParams;
+					const entries = edits.map((entry: PatchEditEntry) => ({
+						path: entry.path,
+						run: (br: LspBatchRequest | undefined) =>
+							executePatchSingle({
+								session: tool.session,
+								params: entry,
+								signal,
+								batchRequest: br,
+								allowFuzzy: tool.#allowFuzzy,
+								fuzzyThreshold: tool.#fuzzyThreshold,
+								writethrough: tool.#writethrough,
+								beginDeferredDiagnosticsForPath: p => tool.#beginDeferredDiagnosticsForPath(p),
+							}),
+					}));
+					return executePerFile(entries, batchRequest, onUpdate);
 				},
 			},
 			hashline: {
@@ -237,15 +351,29 @@ export class EditTool implements AgentTool<TInput> {
 				parameters: hashlineEditParamsSchema,
 				invalidParamsMessage: "Invalid edit parameters for hashline mode.",
 				validate: isHashlineParams,
-				async execute(tool: EditTool, args: ModeExecutionArgs) {
-					return executeHashlineMode({
-						session: tool.session,
-						params: args.params as HashlineParams,
-						signal: args.signal,
-						batchRequest: args.batchRequest,
-						writethrough: tool.#writethrough,
-						beginDeferredDiagnosticsForPath: path => tool.#beginDeferredDiagnosticsForPath(path),
-					});
+				execute: (
+					tool: EditTool,
+					params: EditParams,
+					signal: AbortSignal | undefined,
+					batchRequest: LspBatchRequest | undefined,
+					onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
+				) => {
+					const { edits } = params as HashlineParams;
+					const byFile = groupBy(edits, (e: HashlineToolEdit) => e.path);
+					const entries = [...byFile.entries()].map(([path, fileEdits]) => ({
+						path,
+						run: (br: LspBatchRequest | undefined) =>
+							executeHashlineSingle({
+								session: tool.session,
+								path,
+								edits: fileEdits,
+								signal,
+								batchRequest: br,
+								writethrough: tool.#writethrough,
+								beginDeferredDiagnosticsForPath: p => tool.#beginDeferredDiagnosticsForPath(p),
+							}),
+					}));
+					return executePerFile(entries, batchRequest, onUpdate);
 				},
 			},
 			replace: {
@@ -253,17 +381,54 @@ export class EditTool implements AgentTool<TInput> {
 				parameters: replaceEditSchema,
 				invalidParamsMessage: "Invalid edit parameters for replace mode.",
 				validate: isReplaceParams,
-				async execute(tool: EditTool, args: ModeExecutionArgs) {
-					return executeReplaceMode({
-						session: tool.session,
-						params: args.params as ReplaceParams,
-						signal: args.signal,
-						batchRequest: args.batchRequest,
-						allowFuzzy: tool.#allowFuzzy,
-						fuzzyThreshold: tool.#fuzzyThreshold,
-						writethrough: tool.#writethrough,
-						beginDeferredDiagnosticsForPath: path => tool.#beginDeferredDiagnosticsForPath(path),
-					});
+				execute: (
+					tool: EditTool,
+					params: EditParams,
+					signal: AbortSignal | undefined,
+					batchRequest: LspBatchRequest | undefined,
+					onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
+				) => {
+					const { edits } = params as ReplaceParams;
+					const entries = edits.map((entry: ReplaceEditEntry) => ({
+						path: entry.path,
+						run: (br: LspBatchRequest | undefined) =>
+							executeReplaceSingle({
+								session: tool.session,
+								params: entry,
+								signal,
+								batchRequest: br,
+								allowFuzzy: tool.#allowFuzzy,
+								fuzzyThreshold: tool.#fuzzyThreshold,
+								writethrough: tool.#writethrough,
+								beginDeferredDiagnosticsForPath: p => tool.#beginDeferredDiagnosticsForPath(p),
+							}),
+					}));
+					return executePerFile(entries, batchRequest, onUpdate);
+				},
+			},
+			vim: {
+				description: () => this.#vimTool.description,
+				parameters: vimSchema,
+				invalidParamsMessage: "Invalid edit parameters for vim mode.",
+				validate: isVimParams,
+				execute: async (
+					tool: EditTool,
+					params: EditParams,
+					signal: AbortSignal | undefined,
+					_batchRequest: LspBatchRequest | undefined,
+					onUpdate?: (partialResult: AgentToolResult<EditToolResultDetails, TInput>) => void,
+				) => {
+					const handleUpdate = onUpdate
+						? (partialResult: AgentToolResult<VimToolDetails>) => {
+								onUpdate(partialResult as AgentToolResult<EditToolResultDetails, TInput>);
+							}
+						: undefined;
+					return (await tool.#vimTool.execute(
+						"edit",
+						params as VimParams,
+						signal,
+						handleUpdate,
+					)) as AgentToolResult<EditToolResultDetails, TInput>;
 				},
 			},
 		}[this.mode];