@oh-my-pi/pi-coding-agent 6.1.0 → 6.2.0

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+## [6.2.0] - 2026-01-19
+### Changed
+
+- Improved LSP batching to coalesce formatting and diagnostics for parallel edits
+- Updated edit and write tools to support batched LSP operations
+
+### Fixed
+
+- Coalesced LSP formatting/diagnostics for parallel edits so only the final write triggers LSP across touched files
+
 ## [6.1.0] - 2026-01-19
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "6.1.0",
+	"version": "6.2.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -40,10 +40,10 @@
 		"prepublishOnly": "bun run generate-template && bun run clean && bun run build"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-agent-core": "6.1.0",
-		"@oh-my-pi/pi-ai": "6.1.0",
-		"@oh-my-pi/pi-git-tool": "6.1.0",
-		"@oh-my-pi/pi-tui": "6.1.0",
+		"@oh-my-pi/pi-agent-core": "6.2.0",
+		"@oh-my-pi/pi-ai": "6.2.0",
+		"@oh-my-pi/pi-git-tool": "6.2.0",
+		"@oh-my-pi/pi-tui": "6.2.0",
 		"@openai/agents": "^0.3.7",
 		"@sinclair/typebox": "^0.34.46",
 		"ajv": "^8.17.1",

package/src/core/tools/context.ts

@@ -1,4 +1,4 @@
-import type { AgentToolContext } from "@oh-my-pi/pi-agent-core";
+import type { AgentToolContext, ToolCallContext } from "@oh-my-pi/pi-agent-core";
 import type { CustomToolContext } from "../custom-tools/types";
 import type { ExtensionUIContext } from "../extensions/types";
 
@@ -7,11 +7,12 @@ declare module "@oh-my-pi/pi-agent-core" {
 		ui?: ExtensionUIContext;
 		hasUI?: boolean;
 		toolNames?: string[];
+		toolCall?: ToolCallContext;
 	}
 }
 
 export interface ToolContextStore {
-	getContext(): AgentToolContext;
+	getContext(toolCall?: ToolCallContext): AgentToolContext;
 	setUIContext(uiContext: ExtensionUIContext, hasUI: boolean): void;
 	setToolNames(names: string[]): void;
 }
@@ -22,11 +23,12 @@ export function createToolContextStore(getBaseContext: () => CustomToolContext):
 	let toolNames: string[] = [];
 
 	return {
-		getContext: () => ({
+		getContext: (toolCall) => ({
 			...getBaseContext(),
 			ui: uiContext,
 			hasUI,
 			toolNames,
+			toolCall,
 		}),
 		setUIContext: (context, uiAvailable) => {
 			uiContext = context;

package/src/core/tools/edit.ts

@@ -1,4 +1,4 @@
-import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { AgentTool, AgentToolContext, ToolCallContext } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
@@ -41,6 +41,22 @@ export interface EditToolDetails {
 	diagnostics?: FileDiagnosticsResult;
 }
 
+const LSP_BATCH_TOOLS = new Set(["edit", "write"]);
+
+function getLspBatchRequest(toolCall: ToolCallContext | undefined): { id: string; flush: boolean } | undefined {
+	if (!toolCall) {
+		return undefined;
+	}
+	const hasOtherWrites = toolCall.toolCalls.some(
+		(call, index) => index !== toolCall.index && LSP_BATCH_TOOLS.has(call.name),
+	);
+	if (!hasOtherWrites) {
+		return undefined;
+	}
+	const hasLaterWrites = toolCall.toolCalls.slice(toolCall.index + 1).some((call) => LSP_BATCH_TOOLS.has(call.name));
+	return { id: toolCall.batchId, flush: !hasLaterWrites };
+}
+
 export function createEditTool(session: ToolSession): AgentTool<typeof editSchema> {
 	const allowFuzzy = session.settings?.getEditFuzzyMatch() ?? true;
 	const enableLsp = session.enableLsp ?? true;
@@ -58,6 +74,8 @@ export function createEditTool(session: ToolSession): AgentTool<typeof editSchem
 			_toolCallId: string,
 			{ path, oldText, newText, all }: { path: string; oldText: string; newText: string; all?: boolean },
 			signal?: AbortSignal,
+			_onUpdate?: unknown,
+			context?: AgentToolContext,
 		) => {
 			// Reject .ipynb files - use NotebookEdit tool instead
 			if (path.endsWith(".ipynb")) {
@@ -163,7 +181,8 @@ export function createEditTool(session: ToolSession): AgentTool<typeof editSchem
 			}
 
 			const finalContent = bom + restoreLineEndings(normalizedNewContent, originalEnding);
-			const diagnostics = await writethrough(absolutePath, finalContent, signal, file);
+			const batchRequest = getLspBatchRequest(context?.toolCall);
+			const diagnostics = await writethrough(absolutePath, finalContent, signal, file, batchRequest);
 
 			const diffResult = generateDiffString(normalizedContent, normalizedNewContent);
 

package/src/core/tools/lsp/index.ts

@@ -667,6 +667,7 @@ export type WritethroughCallback = (
 	content: string,
 	signal?: AbortSignal,
 	file?: BunFile,
+	batch?: LspWritethroughBatchRequest,
 ) => Promise<FileDiagnosticsResult | undefined>;
 
 /** No-op writethrough callback */
@@ -684,83 +685,241 @@ export async function writethroughNoop(
 	return undefined;
 }
 
-/** Create a writethrough callback for LSP aware write operations */
-export function createLspWritethrough(cwd: string, options?: WritethroughOptions): WritethroughCallback {
-	const { enableFormat = false, enableDiagnostics = false } = options ?? {};
-	if (!enableFormat && !enableDiagnostics) {
-		return writethroughNoop;
+interface PendingWritethrough {
+	dst: string;
+	content: string;
+	file?: BunFile;
+}
+
+interface LspWritethroughBatchRequest {
+	id: string;
+	flush: boolean;
+}
+
+interface LspWritethroughBatchState {
+	entries: Map<string, PendingWritethrough>;
+	options: Required<WritethroughOptions>;
+}
+
+const writethroughBatches = new Map<string, LspWritethroughBatchState>();
+
+function getOrCreateWritethroughBatch(id: string, options: Required<WritethroughOptions>): LspWritethroughBatchState {
+	const existing = writethroughBatches.get(id);
+	if (existing) {
+		existing.options.enableFormat ||= options.enableFormat;
+		existing.options.enableDiagnostics ||= options.enableDiagnostics;
+		return existing;
 	}
-	return async (dst: string, content: string, signal?: AbortSignal, file?: BunFile) => {
-		const config = await getConfig(cwd);
-		const servers = getServersForFile(config, dst);
-		if (servers.length === 0) {
-			return writethroughNoop(dst, content, signal, file);
+	const batch: LspWritethroughBatchState = {
+		entries: new Map<string, PendingWritethrough>(),
+		options: { ...options },
+	};
+	writethroughBatches.set(id, batch);
+	return batch;
+}
+
+function summarizeDiagnosticMessages(messages: string[]): { summary: string; errored: boolean } {
+	const counts = { error: 0, warning: 0, info: 0, hint: 0 };
+	for (const message of messages) {
+		const match = message.match(/\[(error|warning|info|hint)\]/i);
+		if (!match) continue;
+		const key = match[1].toLowerCase() as keyof typeof counts;
+		counts[key] += 1;
+	}
+
+	const parts: string[] = [];
+	if (counts.error > 0) parts.push(`${counts.error} error(s)`);
+	if (counts.warning > 0) parts.push(`${counts.warning} warning(s)`);
+	if (counts.info > 0) parts.push(`${counts.info} info(s)`);
+	if (counts.hint > 0) parts.push(`${counts.hint} hint(s)`);
+
+	return {
+		summary: parts.length > 0 ? parts.join(", ") : "no issues",
+		errored: counts.error > 0,
+	};
+}
+
+function mergeDiagnostics(
+	results: Array<FileDiagnosticsResult | undefined>,
+	options: Required<WritethroughOptions>,
+): FileDiagnosticsResult | undefined {
+	const messages: string[] = [];
+	const servers = new Set<string>();
+	let hasResults = false;
+	let hasFormatter = false;
+	let formatted = false;
+
+	for (const result of results) {
+		if (!result) continue;
+		hasResults = true;
+		if (result.server) {
+			for (const server of result.server.split(",")) {
+				const trimmed = server.trim();
+				if (trimmed) {
+					servers.add(trimmed);
+				}
+			}
+		}
+		if (result.messages.length > 0) {
+			messages.push(...result.messages);
+		}
+		if (result.formatter !== undefined) {
+			hasFormatter = true;
+			if (result.formatter === FileFormatResult.FORMATTED) {
+				formatted = true;
+			}
 		}
-		const { lspServers, customLinterServers } = splitServers(servers);
+	}
 
-		let finalContent = content;
-		const writeContent = async (value: string) => (file ? file.write(value) : Bun.write(dst, value));
-		const getWritePromise = once(() => writeContent(finalContent));
-		const useCustomFormatter = enableFormat && customLinterServers.length > 0;
+	if (!hasResults && !hasFormatter) {
+		return undefined;
+	}
 
-		// Capture diagnostic versions BEFORE syncing to detect stale diagnostics
-		const minVersions = enableDiagnostics ? await captureDiagnosticVersions(cwd, servers) : undefined;
+	let summary = options.enableDiagnostics ? "no issues" : "OK";
+	let errored = false;
+	if (messages.length > 0) {
+		const summaryInfo = summarizeDiagnosticMessages(messages);
+		summary = summaryInfo.summary;
+		errored = summaryInfo.errored;
+	}
+	const formatter = hasFormatter ? (formatted ? FileFormatResult.FORMATTED : FileFormatResult.UNCHANGED) : undefined;
 
-		let formatter: FileFormatResult | undefined;
-		let diagnostics: FileDiagnosticsResult | undefined;
-		try {
-			const timeoutSignal = AbortSignal.timeout(10_000);
-			const operationSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
-			await untilAborted(operationSignal, async () => {
-				if (useCustomFormatter) {
-					// Custom linters (e.g. Biome CLI) require on-disk input.
-					await writeContent(content);
-					finalContent = await formatContent(dst, content, cwd, customLinterServers, operationSignal);
+	return {
+		server: servers.size > 0 ? Array.from(servers).join(", ") : undefined,
+		messages,
+		summary,
+		errored,
+		formatter,
+	};
+}
+
+async function runLspWritethrough(
+	dst: string,
+	content: string,
+	cwd: string,
+	options: Required<WritethroughOptions>,
+	signal?: AbortSignal,
+	file?: BunFile,
+): Promise<FileDiagnosticsResult | undefined> {
+	const { enableFormat, enableDiagnostics } = options;
+	const config = await getConfig(cwd);
+	const servers = getServersForFile(config, dst);
+	if (servers.length === 0) {
+		return writethroughNoop(dst, content, signal, file);
+	}
+	const { lspServers, customLinterServers } = splitServers(servers);
+
+	let finalContent = content;
+	const writeContent = async (value: string) => (file ? file.write(value) : Bun.write(dst, value));
+	const getWritePromise = once(() => writeContent(finalContent));
+	const useCustomFormatter = enableFormat && customLinterServers.length > 0;
+
+	// Capture diagnostic versions BEFORE syncing to detect stale diagnostics
+	const minVersions = enableDiagnostics ? await captureDiagnosticVersions(cwd, servers) : undefined;
+
+	let formatter: FileFormatResult | undefined;
+	let diagnostics: FileDiagnosticsResult | undefined;
+	try {
+		const timeoutSignal = AbortSignal.timeout(10_000);
+		const operationSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+		await untilAborted(operationSignal, async () => {
+			if (useCustomFormatter) {
+				// Custom linters (e.g. Biome CLI) require on-disk input.
+				await writeContent(content);
+				finalContent = await formatContent(dst, content, cwd, customLinterServers, operationSignal);
+				formatter = finalContent !== content ? FileFormatResult.FORMATTED : FileFormatResult.UNCHANGED;
+				await writeContent(finalContent);
+				await syncFileContent(dst, finalContent, cwd, lspServers, operationSignal);
+			} else {
+				// 1. Sync original content to LSP servers
+				await syncFileContent(dst, content, cwd, lspServers, operationSignal);
+
+				// 2. Format in-memory via LSP
+				if (enableFormat) {
+					finalContent = await formatContent(dst, content, cwd, lspServers, operationSignal);
 					formatter = finalContent !== content ? FileFormatResult.FORMATTED : FileFormatResult.UNCHANGED;
-					await writeContent(finalContent);
+				}
+
+				// 3. If formatted, sync formatted content to LSP servers
+				if (finalContent !== content) {
 					await syncFileContent(dst, finalContent, cwd, lspServers, operationSignal);
-				} else {
-					// 1. Sync original content to LSP servers
-					await syncFileContent(dst, content, cwd, lspServers, operationSignal);
-
-					// 2. Format in-memory via LSP
-					if (enableFormat) {
-						finalContent = await formatContent(dst, content, cwd, lspServers, operationSignal);
-						formatter = finalContent !== content ? FileFormatResult.FORMATTED : FileFormatResult.UNCHANGED;
-					}
+				}
 
-					// 3. If formatted, sync formatted content to LSP servers
-					if (finalContent !== content) {
-						await syncFileContent(dst, finalContent, cwd, lspServers, operationSignal);
-					}
+				// 4. Write to disk
+				await getWritePromise();
+			}
 
-					// 4. Write to disk
-					await getWritePromise();
-				}
+			// 5. Notify saved to LSP servers
+			await notifyFileSaved(dst, cwd, lspServers, operationSignal);
 
-				// 5. Notify saved to LSP servers
-				await notifyFileSaved(dst, cwd, lspServers, operationSignal);
+			// 6. Get diagnostics from all servers (wait for fresh results)
+			if (enableDiagnostics) {
+				diagnostics = await getDiagnosticsForFile(dst, cwd, servers, operationSignal, minVersions);
+			}
+		});
+	} catch {
+		await getWritePromise();
+	}
 
-				// 6. Get diagnostics from all servers (wait for fresh results)
-				if (enableDiagnostics) {
-					diagnostics = await getDiagnosticsForFile(dst, cwd, servers, operationSignal, minVersions);
-				}
-			});
-		} catch {
-			await getWritePromise();
+	if (formatter !== undefined) {
+		diagnostics ??= {
+			server: servers.map(([name]) => name).join(", "),
+			messages: [],
+			summary: "OK",
+			errored: false,
+		};
+		diagnostics.formatter = formatter;
+	}
+
+	return diagnostics;
+}
+
+async function flushWritethroughBatch(
+	batch: PendingWritethrough[],
+	cwd: string,
+	options: Required<WritethroughOptions>,
+	signal?: AbortSignal,
+): Promise<FileDiagnosticsResult | undefined> {
+	if (batch.length === 0) {
+		return undefined;
+	}
+	const results: Array<FileDiagnosticsResult | undefined> = [];
+	for (const entry of batch) {
+		results.push(await runLspWritethrough(entry.dst, entry.content, cwd, options, signal, entry.file));
+	}
+	return mergeDiagnostics(results, options);
+}
+
+/** Create a writethrough callback for LSP aware write operations */
+export function createLspWritethrough(cwd: string, options?: WritethroughOptions): WritethroughCallback {
+	const resolvedOptions: Required<WritethroughOptions> = {
+		enableFormat: options?.enableFormat ?? false,
+		enableDiagnostics: options?.enableDiagnostics ?? false,
+	};
+	if (!resolvedOptions.enableFormat && !resolvedOptions.enableDiagnostics) {
+		return writethroughNoop;
+	}
+	return async (
+		dst: string,
+		content: string,
+		signal?: AbortSignal,
+		file?: BunFile,
+		batch?: LspWritethroughBatchRequest,
+	) => {
+		if (!batch) {
+			return runLspWritethrough(dst, content, cwd, resolvedOptions, signal, file);
 		}
 
-		if (formatter !== undefined) {
-			diagnostics ??= {
-				server: servers.map(([name]) => name).join(", "),
-				messages: [],
-				summary: "OK",
-				errored: false,
-			};
-			diagnostics.formatter = formatter;
+		const state = getOrCreateWritethroughBatch(batch.id, resolvedOptions);
+		state.entries.set(dst, { dst, content, file });
+
+		if (!batch.flush) {
+			await writethroughNoop(dst, content, signal, file);
+			return undefined;
 		}
 
-		return diagnostics;
+		writethroughBatches.delete(batch.id);
+		return flushWritethroughBatch(Array.from(state.entries.values()), cwd, state.options, signal);
 	};
 }
 

package/src/core/tools/write.ts

@@ -1,4 +1,4 @@
-import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { AgentTool, AgentToolContext, ToolCallContext } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
@@ -22,6 +22,22 @@ export interface WriteToolDetails {
 	diagnostics?: FileDiagnosticsResult;
 }
 
+const LSP_BATCH_TOOLS = new Set(["edit", "write"]);
+
+function getLspBatchRequest(toolCall: ToolCallContext | undefined): { id: string; flush: boolean } | undefined {
+	if (!toolCall) {
+		return undefined;
+	}
+	const hasOtherWrites = toolCall.toolCalls.some(
+		(call, index) => index !== toolCall.index && LSP_BATCH_TOOLS.has(call.name),
+	);
+	if (!hasOtherWrites) {
+		return undefined;
+	}
+	const hasLaterWrites = toolCall.toolCalls.slice(toolCall.index + 1).some((call) => LSP_BATCH_TOOLS.has(call.name));
+	return { id: toolCall.batchId, flush: !hasLaterWrites };
+}
+
 export function createWriteTool(session: ToolSession): AgentTool<typeof writeSchema, WriteToolDetails> {
 	const enableLsp = session.enableLsp ?? true;
 	const enableFormat = enableLsp ? (session.settings?.getLspFormatOnWrite() ?? true) : false;
@@ -38,11 +54,14 @@ export function createWriteTool(session: ToolSession): AgentTool<typeof writeSch
 			_toolCallId: string,
 			{ path, content }: { path: string; content: string },
 			signal?: AbortSignal,
+			_onUpdate?: unknown,
+			context?: AgentToolContext,
 		) => {
 			return untilAborted(signal, async () => {
 				const absolutePath = resolveToCwd(path, session.cwd);
+				const batchRequest = getLspBatchRequest(context?.toolCall);
 
-				const diagnostics = await writethrough(absolutePath, content, signal);
+				const diagnostics = await writethrough(absolutePath, content, signal, undefined, batchRequest);
 
 				let resultText = `Successfully wrote ${content.length} bytes to ${path}`;
 				if (!diagnostics) {