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

package/CHANGELOG.md

@@ -2,6 +2,62 @@
 
 ## [Unreleased]
 
+## [6.7.0] - 2026-01-19
+
+### Added
+
+- Normative patch generation to canonicalize edit tool output with tool call argument rewriting for session history
+- Patch matching fallback variants: trimmed context, collapsed duplicates, single-line reduction, comment-prefix normalization
+- Extended anchor syntax: ellipsis placeholders, `top of file`/`start of file`, `@@ line N`, nested `@@` anchors, space-separated hierarchical contexts
+- Relaxed fuzzy threshold fallback and unique substring acceptance for context matching
+- Added `--no-title` flag to disable automatic session title generation
+- Environment variables for edit tool configuration (OMP_EDIT_VARIANT, OMP_EDIT_FUZZY, OMP_EDIT_FUZZY_THRESHOLD)
+- Configurable fuzzy matching threshold setting (0.85 lenient to 0.98 strict)
+- Apply-patch mode for edit tool (`edit.patchMode` setting) with create, update, delete, and rename operations
+- Added MCP tool caching for faster startup with cached tool definitions
+
+### Changed
+
+- Patch applicator now supports normalized input, implicit context lines, and improved indentation adjustment
+- Patch operation schema uses 'op' instead of 'operation' and 'rename' instead of 'moveTo'
+- Fuzzy matching tries comment-prefix normalized matches before unicode normalization
+- Updated patch prompts with clearer anchor selection rules and verbatim context requirements
+- Changed default behavior of read tool to omit line numbers by default
+- Changed default edit tool mode to use apply-patch format instead of oldText/newText
+- Converted tool implementations from factory functions to class-based architecture
+- Refactored edit tool with modular patch architecture (moved from `edit/` to `patch/` module)
+- Enhanced patch parsing: unified diff format, Codex-style patches, nested anchors, multi-file markers
+- Improved fuzzy matching with multiple match tracking, ambiguity detection, and out-of-order hunk processing
+- Better diff rendering: smarter truncation, optional line numbers, trailing newline preservation
+- Improved error messages with hierarchical context display using `>` separator
+- Centralized output sanitization in streaming-output module
+- Enhanced MCP startup with deferred tool loading and cached fallback
+
+### Fixed
+
+- Patch application handles repeated context blocks, preserves original indentation on fuzzy match
+- Ambiguous context matching resolves duplicates using adjacent @@ anchor positioning
+- Patch parser handles bare *** terminators, model hallucination markers, line hint ranges
+- Function context matching handles signatures with and without empty parentheses
+- Fixed session title generation to respect OMP_NO_TITLE environment variable
+- Fixed Python module discovery to use import.meta.dir for ES module compatibility
+- Fixed LSP writethrough batching to flush when delete operations complete a batch
+- Fixed line number validation, BOM detection, and trailing newline preservation in patches
+- Fixed hierarchical context matching and space-separated anchor parsing
+- Fixed fuzzy matching to avoid infinite loops when `allowFuzzy` is disabled
+- Fixed tool completion logic to only mark tools as complete when streaming is not aborted or in error state
+- Fixed MCP tool path formatting to correctly display provider information
+
+## [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/docs/sdk.md

@@ -942,7 +942,7 @@ createTools                // Create all tools from ToolSession
 type ToolSession           // Session context for tool creation
 
 // Individual tool factories
-createReadTool, createBashTool, createEditTool, createWriteTool
+createReadTool, createBashTool, EditTool, createWriteTool
 createGrepTool, createFindTool, createLsTool, createGitTool
 
 // Types

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "6.1.0",
+	"version": "6.7.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.7.0",
+		"@oh-my-pi/pi-ai": "6.7.0",
+		"@oh-my-pi/pi-git-tool": "6.7.0",
+		"@oh-my-pi/pi-tui": "6.7.0",
 		"@openai/agents": "^0.3.7",
 		"@sinclair/typebox": "^0.34.46",
 		"ajv": "^8.17.1",

package/scripts/generate-template.ts

@@ -13,15 +13,15 @@ const js = await Bun.file(`${dir}template.js`).text();
 
 // Minify CSS
 const minifiedCss = css
-   .replace(/\/\*[\s\S]*?\*\//g, "")
-   .replace(/\s+/g, " ")
-   .replace(/\s*([{}:;,])\s*/g, "$1")
-   .trim();
+	.replace(/\/\*[\s\S]*?\*\//g, "")
+	.replace(/\s+/g, " ")
+	.replace(/\s*([{}:;,])\s*/g, "$1")
+	.trim();
 
 // Inline everything
 const template = html
-   .replace("<template-css/>", `<style>${minifiedCss}</style>`)
-   .replace("<template-js/>", `<script>${js}</script>`);
+	.replace("<template-css/>", `<style>${minifiedCss}</style>`)
+	.replace("<template-js/>", `<script>${js}</script>`);
 
 // Write generated file
 const output = `// Auto-generated by scripts/generate-template.ts - DO NOT EDIT

package/src/cli/args.ts

@@ -40,6 +40,7 @@ export interface Args {
 	noSkills?: boolean;
 	skills?: string[];
 	listModels?: string | true;
+	noTitle?: boolean;
 	messages: string[];
 	fileArgs: string[];
 	/** Unknown flags (potentially extension flags) - map of flag name to value */
@@ -143,6 +144,8 @@ export function parseArgs(args: string[], extensionFlags?: Map<string, { type: "
 			result.noExtensions = true;
 		} else if (arg === "--no-skills") {
 			result.noSkills = true;
+		} else if (arg === "--no-title") {
+			result.noTitle = true;
 		} else if (arg === "--skills" && i + 1 < args.length) {
 			// Comma-separated glob patterns for skill filtering
 			result.skills = args[++i].split(",").map((s) => s.trim());

package/src/core/agent-session.ts

@@ -432,6 +432,18 @@ export class AgentSession {
 			if (event.message.role === "assistant") {
 				this._lastAssistantMessage = event.message;
 			}
+
+			if (event.message.role === "toolResult") {
+				const { $normative, toolCallId } = event.message as {
+					toolName?: string;
+					toolCallId?: string;
+					details?: unknown;
+					$normative?: Record<string, unknown>;
+				};
+				if ($normative && toolCallId) {
+					await this._rewriteToolCallArgs(toolCallId, $normative);
+				}
+			}
 		}
 
 		// Check auto-retry and auto-compaction after agent completes
@@ -513,6 +525,33 @@ export class AgentSession {
 		return undefined;
 	}
 
+	/** Rewrite tool call arguments in agent state and persisted session history. */
+	private async _rewriteToolCallArgs(toolCallId: string, args: Record<string, unknown>): Promise<void> {
+		let updated = false;
+		const messages = this.agent.state.messages;
+		for (let i = messages.length - 1; i >= 0; i--) {
+			const msg = messages[i];
+			if (msg.role !== "assistant") continue;
+			const assistantMsg = msg as AssistantMessage;
+			if (!Array.isArray(assistantMsg.content)) continue;
+			for (const block of assistantMsg.content) {
+				if (typeof block !== "object" || block === null) continue;
+				if (!("type" in block) || (block as { type?: string }).type !== "toolCall") continue;
+				const toolCall = block as { id?: string; arguments?: Record<string, unknown> };
+				if (toolCall.id === toolCallId) {
+					toolCall.arguments = args;
+					updated = true;
+					break;
+				}
+			}
+			if (updated) break;
+		}
+
+		if (updated) {
+			await this.sessionManager.rewriteAssistantToolCallArgs(toolCallId, args);
+		}
+	}
+
 	/** Emit extension events based on agent events */
 	private async _emitExtensionEvent(event: AgentEvent): Promise<void> {
 		if (!this._extensionRunner) return;

package/src/core/bash-executor.ts

@@ -9,7 +9,7 @@
 import type { Subprocess } from "bun";
 import { getShellConfig, killProcessTree } from "../utils/shell";
 import { getOrCreateSnapshot, getSnapshotSourceCommand } from "../utils/shell-snapshot";
-import { createOutputSink, pumpStream } from "./streaming-output";
+import { OutputSink, pumpStream } from "./streaming-output";
 import type { BashOperations } from "./tools/bash";
 import { DEFAULT_MAX_BYTES } from "./tools/truncate";
 import { ScopeSignal } from "./utils";
@@ -85,7 +85,7 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 		killProcessTree(child.pid);
 	});
 
-	const sink = createOutputSink(DEFAULT_MAX_BYTES, DEFAULT_MAX_BYTES * 2, options?.onChunk);
+	const sink = new OutputSink(DEFAULT_MAX_BYTES, DEFAULT_MAX_BYTES * 2, options?.onChunk);
 
 	const writer = sink.getWriter();
 	try {
@@ -128,7 +128,7 @@ export async function executeBashWithOperations(
 	operations: BashOperations,
 	options?: BashExecutorOptions,
 ): Promise<BashResult> {
-	const sink = createOutputSink(DEFAULT_MAX_BYTES, DEFAULT_MAX_BYTES * 2, options?.onChunk);
+	const sink = new OutputSink(DEFAULT_MAX_BYTES, DEFAULT_MAX_BYTES * 2, options?.onChunk);
 	const writer = sink.getWriter();
 
 	// Create a ReadableStream from the callback-based operations.exec

package/src/core/cursor/exec-bridge.ts

@@ -7,7 +7,7 @@ import type {
 	AgentToolResult,
 	AgentToolUpdateCallback,
 } from "@oh-my-pi/pi-agent-core";
-import type { CursorExecHandlers, CursorMcpCall, ToolResultMessage } from "@oh-my-pi/pi-ai";
+import type { CursorMcpCall, CursorExecHandlers as ICursorExecHandlers, ToolResultMessage } from "@oh-my-pi/pi-ai";
 import { resolveToCwd } from "../tools/path-utils";
 
 interface CursorExecBridgeOptions {
@@ -143,92 +143,99 @@ function formatMcpToolErrorMessage(toolName: string, availableTools: string[]):
 	return `MCP tool "${toolName}" not found. Available tools: ${list}`;
 }
 
-export function createCursorExecHandlers(options: CursorExecBridgeOptions): CursorExecHandlers {
-	return {
-		read: async (args) => {
-			const toolCallId = decodeToolCallId(args.toolCallId);
-			const toolResultMessage = await executeTool(options, "read", toolCallId, { path: args.path });
-			return toolResultMessage;
-		},
-		ls: async (args) => {
-			const toolCallId = decodeToolCallId(args.toolCallId);
-			const toolResultMessage = await executeTool(options, "ls", toolCallId, { path: args.path });
-			return toolResultMessage;
-		},
-		grep: async (args) => {
-			const toolCallId = decodeToolCallId(args.toolCallId);
-			const toolResultMessage = await executeTool(options, "grep", toolCallId, {
-				pattern: args.pattern,
-				path: args.path || undefined,
-				glob: args.glob || undefined,
-				outputMode: args.outputMode || undefined,
-				context: args.context ?? args.contextBefore ?? args.contextAfter ?? undefined,
-				ignoreCase: args.caseInsensitive || undefined,
-				type: args.type || undefined,
-				headLimit: args.headLimit ?? undefined,
-				multiline: args.multiline || undefined,
-			});
-			return toolResultMessage;
-		},
-		write: async (args) => {
-			const toolCallId = decodeToolCallId(args.toolCallId);
-			const content = args.fileText ?? new TextDecoder().decode(args.fileBytes ?? new Uint8Array());
-			const toolResultMessage = await executeTool(options, "write", toolCallId, {
-				path: args.path,
-				content,
-			});
-			return toolResultMessage;
-		},
-		delete: async (args) => {
-			const toolCallId = decodeToolCallId(args.toolCallId);
-			const toolResultMessage = await executeDelete(options, args.path, toolCallId);
-			return toolResultMessage;
-		},
-		shell: async (args) => {
-			const toolCallId = decodeToolCallId(args.toolCallId);
-			const timeoutSeconds =
-				args.timeout && args.timeout > 0
-					? args.timeout > 1000
-						? Math.ceil(args.timeout / 1000)
-						: args.timeout
-					: undefined;
-			const toolResultMessage = await executeTool(options, "bash", toolCallId, {
-				command: args.command,
-				workdir: args.workingDirectory || undefined,
-				timeout: timeoutSeconds,
-			});
-			return toolResultMessage;
-		},
-		diagnostics: async (args) => {
-			const toolCallId = decodeToolCallId(args.toolCallId);
-			const toolResultMessage = await executeTool(options, "lsp", toolCallId, {
-				action: "diagnostics",
-				file: args.path,
-			});
-			return toolResultMessage;
-		},
-		mcp: async (call: CursorMcpCall) => {
-			const toolName = call.toolName || call.name;
-			const toolCallId = decodeToolCallId(call.toolCallId);
-			const tool = options.tools.get(toolName);
-			if (!tool) {
-				const availableTools = Array.from(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;
-			}
+export class CursorExecHandlers implements ICursorExecHandlers {
+	constructor(private options: CursorExecBridgeOptions) {}
 
-			const args = Object.keys(call.args ?? {}).length > 0 ? call.args : decodeMcpArgs(call.rawArgs ?? {});
-			const toolResultMessage = await executeTool(options, toolName, toolCallId, args);
-			return toolResultMessage;
-		},
-	};
+	async read(args: Parameters<NonNullable<ICursorExecHandlers["read"]>>[0]) {
+		const toolCallId = decodeToolCallId(args.toolCallId);
+		const toolResultMessage = await executeTool(this.options, "read", toolCallId, { path: args.path });
+		return toolResultMessage;
+	}
+
+	async ls(args: Parameters<NonNullable<ICursorExecHandlers["ls"]>>[0]) {
+		const toolCallId = decodeToolCallId(args.toolCallId);
+		const toolResultMessage = await executeTool(this.options, "ls", toolCallId, { path: args.path });
+		return toolResultMessage;
+	}
+
+	async grep(args: Parameters<NonNullable<ICursorExecHandlers["grep"]>>[0]) {
+		const toolCallId = decodeToolCallId(args.toolCallId);
+		const toolResultMessage = await executeTool(this.options, "grep", toolCallId, {
+			pattern: args.pattern,
+			path: args.path || undefined,
+			glob: args.glob || undefined,
+			outputMode: args.outputMode || undefined,
+			context: args.context ?? args.contextBefore ?? args.contextAfter ?? undefined,
+			ignoreCase: args.caseInsensitive || undefined,
+			type: args.type || undefined,
+			headLimit: args.headLimit ?? undefined,
+			multiline: args.multiline || undefined,
+		});
+		return toolResultMessage;
+	}
+
+	async write(args: Parameters<NonNullable<ICursorExecHandlers["write"]>>[0]) {
+		const toolCallId = decodeToolCallId(args.toolCallId);
+		const content = args.fileText ?? new TextDecoder().decode(args.fileBytes ?? new Uint8Array());
+		const toolResultMessage = await executeTool(this.options, "write", toolCallId, {
+			path: args.path,
+			content,
+		});
+		return toolResultMessage;
+	}
+
+	async delete(args: Parameters<NonNullable<ICursorExecHandlers["delete"]>>[0]) {
+		const toolCallId = decodeToolCallId(args.toolCallId);
+		const toolResultMessage = await executeDelete(this.options, args.path, toolCallId);
+		return toolResultMessage;
+	}
+
+	async shell(args: Parameters<NonNullable<ICursorExecHandlers["shell"]>>[0]) {
+		const toolCallId = decodeToolCallId(args.toolCallId);
+		const timeoutSeconds =
+			args.timeout && args.timeout > 0
+				? args.timeout > 1000
+					? Math.ceil(args.timeout / 1000)
+					: args.timeout
+				: undefined;
+		const toolResultMessage = await executeTool(this.options, "bash", toolCallId, {
+			command: args.command,
+			workdir: args.workingDirectory || undefined,
+			timeout: timeoutSeconds,
+		});
+		return toolResultMessage;
+	}
+
+	async diagnostics(args: Parameters<NonNullable<ICursorExecHandlers["diagnostics"]>>[0]) {
+		const toolCallId = decodeToolCallId(args.toolCallId);
+		const toolResultMessage = await executeTool(this.options, "lsp", toolCallId, {
+			action: "diagnostics",
+			file: args.path,
+		});
+		return toolResultMessage;
+	}
+
+	async mcp(call: CursorMcpCall) {
+		const toolName = call.toolName || call.name;
+		const toolCallId = decodeToolCallId(call.toolCallId);
+		const tool = this.options.tools.get(toolName);
+		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 args = Object.keys(call.args ?? {}).length > 0 ? call.args : decodeMcpArgs(call.rawArgs ?? {});
+		const toolResultMessage = await executeTool(this.options, toolName, toolCallId, args);
+		return toolResultMessage;
+	}
 }