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

package/src/core/python-executor.ts

@@ -1,5 +1,3 @@
-import stripAnsi from "strip-ansi";
-import { sanitizeBinaryOutput } from "../utils/shell";
 import { logger } from "./logger";
 import {
 	checkPythonKernelAvailability,
@@ -9,7 +7,7 @@ import {
 	type PreludeHelper,
 	PythonKernel,
 } from "./python-kernel";
-import { createOutputSink } from "./streaming-output";
+import { OutputSink, sanitizeText } from "./streaming-output";
 import { DEFAULT_MAX_BYTES } from "./tools/truncate";
 
 export type PythonKernelMode = "session" | "per-call";
@@ -72,10 +70,6 @@ export async function disposeAllKernelSessions(): Promise<void> {
 	await Promise.allSettled(sessions.map((session) => disposeKernelSession(session)));
 }
 
-function sanitizeChunk(text: string): string {
-	return sanitizeBinaryOutput(stripAnsi(text)).replace(/\r/g, "");
-}
-
 async function ensureKernelAvailable(cwd: string): Promise<void> {
 	const availability = await checkPythonKernelAvailability(cwd);
 	if (!availability.ok) {
@@ -218,7 +212,7 @@ async function executeWithKernel(
 	code: string,
 	options: PythonExecutorOptions | undefined,
 ): Promise<PythonResult> {
-	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();
 	const displayOutputs: KernelDisplayOutput[] = [];
 
@@ -227,7 +221,7 @@ async function executeWithKernel(
 			signal: options?.signal,
 			timeoutMs: options?.timeout,
 			onChunk: async (text) => {
-				await writer.write(sanitizeChunk(text));
+				await writer.write(sanitizeText(text));
 			},
 			onDisplay: async (output) => {
 				displayOutputs.push(output);

package/src/core/sdk.ts

@@ -40,13 +40,13 @@ import { initializeWithSettings } from "../discovery";
 import { registerAsyncCleanup } from "../modes/cleanup";
 import { AgentSession } from "./agent-session";
 import { AuthStorage } from "./auth-storage";
-import { createCursorExecHandlers } from "./cursor/exec-bridge";
+import { CursorExecHandlers } from "./cursor/exec-bridge";
 import {
 	type CustomCommandsLoadResult,
 	loadCustomCommands as loadCustomCommandsInternal,
 } from "./custom-commands/index";
 import type { CustomTool, CustomToolContext, CustomToolSessionEvent } from "./custom-tools/types";
-import { createEventBus, type EventBus } from "./event-bus";
+import { EventBus } from "./event-bus";
 import {
 	discoverAndLoadExtensions,
 	type ExtensionContext,
@@ -79,29 +79,29 @@ import {
 	loadProjectContextFiles as loadContextFilesInternal,
 } from "./system-prompt";
 import { time } from "./timings";
-import { createToolContextStore } from "./tools/context";
+import { ToolContextStore } from "./tools/context";
 import { getGeminiImageTools } from "./tools/gemini-image";
 import {
+	BashTool,
 	BUILTIN_TOOLS,
-	createBashTool,
-	createEditTool,
-	createFindTool,
-	createGitTool,
-	createGrepTool,
-	createLsTool,
-	createPythonTool,
-	createReadTool,
-	createSshTool,
 	createTools,
-	createWriteTool,
+	EditTool,
+	FindTool,
+	GitTool,
+	GrepTool,
 	getWebSearchTools,
+	LsTool,
+	loadSshTool,
+	PythonTool,
+	ReadTool,
 	setPreferredImageProvider,
 	setPreferredWebSearchProvider,
 	type Tool,
 	type ToolSession,
+	WriteTool,
 	warmupLspServers,
 } from "./tools/index";
-import { createTtsrManager } from "./ttsr";
+import { TtsrManager } from "./ttsr";
 
 // Types
 export interface CreateAgentSessionOptions {
@@ -212,21 +212,21 @@ export type { FileSlashCommand } from "./slash-commands";
 export type { Tool } from "./tools/index";
 
 export {
-	// Tool factories
+	// Tool classes and factories
 	BUILTIN_TOOLS,
 	createTools,
 	type ToolSession,
-	// Individual tool factories (for custom usage)
-	createReadTool,
-	createBashTool,
-	createPythonTool,
-	createSshTool,
-	createEditTool,
-	createWriteTool,
-	createGrepTool,
-	createFindTool,
-	createGitTool,
-	createLsTool,
+	// Individual tool classes (for custom usage)
+	BashTool,
+	EditTool,
+	FindTool,
+	GitTool,
+	GrepTool,
+	loadSshTool,
+	LsTool,
+	PythonTool,
+	ReadTool,
+	WriteTool,
 };
 
 // Helper Functions
@@ -551,7 +551,7 @@ function createCustomToolsExtension(tools: CustomTool[]): ExtensionFactory {
 export async function createAgentSession(options: CreateAgentSessionOptions = {}): Promise<CreateAgentSessionResult> {
 	const cwd = options.cwd ?? process.cwd();
 	const agentDir = options.agentDir ?? getDefaultAgentDir();
-	const eventBus = options.eventBus ?? createEventBus();
+	const eventBus = options.eventBus ?? new EventBus();
 
 	registerSshCleanup();
 	registerPythonCleanup();
@@ -662,7 +662,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	time("discoverSkills");
 
 	// Discover rules
-	const ttsrManager = createTtsrManager(settingsManager.getTtsrSettings());
+	const ttsrManager = new TtsrManager(settingsManager.getTtsrSettings());
 	const rulesResult = await loadCapability<Rule>(ruleCapability.id, { cwd });
 	for (const rule of rulesResult.items) {
 		if (rule.ttsrTrigger) {
@@ -728,6 +728,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			enableProjectConfig: settingsManager.getMCPProjectConfigEnabled(),
 			// Always filter Exa - we have native integration
 			filterExa: true,
+			cacheStorage: settingsManager.getStorage(),
 		});
 		time("discoverAndLoadMCPTools");
 		mcpManager = mcpResult.manager;
@@ -849,7 +850,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			session.abort();
 		},
 	});
-	const toolContextStore = createToolContextStore(getSessionContext);
+	const toolContextStore = new ToolContextStore(getSessionContext);
 
 	const registeredTools = extensionRunner?.getAllRegisteredTools() ?? [];
 	const allCustomTools = [
@@ -880,10 +881,10 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	time("combineTools");
 
 	let cursorEventEmitter: ((event: AgentEvent) => void) | undefined;
-	const cursorExecHandlers = createCursorExecHandlers({
+	const cursorExecHandlers = new CursorExecHandlers({
 		cwd,
 		tools: toolRegistry,
-		getToolContext: toolContextStore.getContext,
+		getToolContext: () => toolContextStore.getContext(),
 		emitEvent: (event) => cursorEventEmitter?.(event),
 	});
 
@@ -985,7 +986,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		followUpMode: settingsManager.getFollowUpMode(),
 		interruptMode: settingsManager.getInterruptMode(),
 		thinkingBudgets: settingsManager.getThinkingBudgets(),
-		getToolContext: toolContextStore.getContext,
+		getToolContext: (tc) => toolContextStore.getContext(tc),
 		getApiKey: async () => {
 			const currentModel = agent.state.model;
 			if (!currentModel) {

package/src/core/session-manager.ts

@@ -1386,6 +1386,36 @@ export class SessionManager {
 		return entry.id;
 	}
 
+	/**
+	 * Rewrite tool call arguments in the most recent assistant message containing the toolCallId.
+	 * Returns true if a tool call was updated.
+	 */
+	async rewriteAssistantToolCallArgs(toolCallId: string, args: Record<string, unknown>): Promise<boolean> {
+		let updated = false;
+		for (let i = this.fileEntries.length - 1; i >= 0; i--) {
+			const entry = this.fileEntries[i];
+			if (entry.type !== "message" || entry.message.role !== "assistant") continue;
+			const message = entry.message as { content?: unknown };
+			if (!Array.isArray(message.content)) continue;
+			for (const block of message.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 && this.persist && this.sessionFile) {
+			await this._rewriteFile();
+		}
+		return updated;
+	}
+
 	/**
 	 * Append a custom message entry (for extensions) that participates in LLM context.
 	 * @param customType Hook identifier for filtering on reload

package/src/core/settings-manager.ts

@@ -123,6 +123,8 @@ export interface PythonSettings {
 
 export interface EditSettings {
 	fuzzyMatch?: boolean; // default: true (accept high-confidence fuzzy matches for whitespace/indentation)
+	fuzzyThreshold?: number; // default: 0.95 (similarity threshold for fuzzy matching)
+	patchMode?: boolean; // default: true (use codex-style apply-patch format instead of oldText/newText)
 }
 
 export type { SymbolPreset };
@@ -318,7 +320,7 @@ const DEFAULT_SETTINGS: Settings = {
 	mcp: { enableProjectConfig: true },
 	lsp: { formatOnWrite: false, diagnosticsOnWrite: true, diagnosticsOnEdit: false },
 	python: { toolMode: "both", kernelMode: "session", sharedGateway: true },
-	edit: { fuzzyMatch: true },
+	edit: { fuzzyMatch: true, fuzzyThreshold: 0.95 },
 	ttsr: { enabled: true, contextMode: "discard", repeatMode: "once", repeatGap: 10 },
 	voice: {
 		enabled: false,
@@ -550,6 +552,13 @@ export class SettingsManager {
 		return { ...this.settings };
 	}
 
+	/**
+	 * Access the underlying agent storage (null for in-memory settings).
+	 */
+	getStorage(): AgentStorage | null {
+		return this.storage;
+	}
+
 	/**
 	 * Load settings from SQLite storage, applying any schema migrations.
 	 * @param storage - AgentStorage instance, or null for in-memory mode
@@ -1266,6 +1275,30 @@ export class SettingsManager {
 		await this.save();
 	}
 
+	getEditFuzzyThreshold(): number {
+		return this.settings.edit?.fuzzyThreshold ?? 0.95;
+	}
+
+	async setEditFuzzyThreshold(value: number): Promise<void> {
+		if (!this.globalSettings.edit) {
+			this.globalSettings.edit = {};
+		}
+		this.globalSettings.edit.fuzzyThreshold = value;
+		await this.save();
+	}
+
+	getEditPatchMode(): boolean {
+		return this.settings.edit?.patchMode ?? true;
+	}
+
+	async setEditPatchMode(enabled: boolean): Promise<void> {
+		if (!this.globalSettings.edit) {
+			this.globalSettings.edit = {};
+		}
+		this.globalSettings.edit.patchMode = enabled;
+		await this.save();
+	}
+
 	getDisabledProviders(): string[] {
 		return [...(this.settings.disabledProviders ?? [])];
 	}

package/src/core/ssh/ssh-executor.ts

@@ -1,12 +1,8 @@
-import { createWriteStream, type WriteStream } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
 import type { Subprocess } from "bun";
-import { nanoid } from "nanoid";
-import stripAnsi from "strip-ansi";
-import { killProcessTree, sanitizeBinaryOutput } from "../../utils/shell";
+import { killProcessTree } from "../../utils/shell";
 import { logger } from "../logger";
-import { DEFAULT_MAX_BYTES, truncateTail } from "../tools/truncate";
+import { OutputSink, pumpStream } from "../streaming-output";
+import { DEFAULT_MAX_BYTES } from "../tools/truncate";
 import { ScopeSignal } from "../utils";
 import { buildRemoteCommand, ensureConnection, ensureHostInfo, type SSHConnectionTarget } from "./connection-manager";
 import { hasSshfs, mountRemote } from "./sshfs-mount";
@@ -37,68 +33,6 @@ export interface SSHResult {
 	fullOutputPath?: string;
 }
 
-function createSanitizer(): TransformStream<Uint8Array, string> {
-	const decoder = new TextDecoder();
-	return new TransformStream({
-		transform(chunk, controller) {
-			const text = sanitizeBinaryOutput(stripAnsi(decoder.decode(chunk, { stream: true }))).replace(/\r/g, "");
-			controller.enqueue(text);
-		},
-	});
-}
-
-function createOutputSink(
-	spillThreshold: number,
-	maxBuffer: number,
-	onChunk?: (text: string) => void,
-): WritableStream<string> & {
-	dump: (annotation?: string) => { output: string; truncated: boolean; fullOutputPath?: string };
-} {
-	const chunks: string[] = [];
-	let chunkBytes = 0;
-	let totalBytes = 0;
-	let fullOutputPath: string | undefined;
-	let fullOutputStream: WriteStream | undefined;
-
-	const sink = new WritableStream<string>({
-		write(text) {
-			totalBytes += text.length;
-
-			if (totalBytes > spillThreshold && !fullOutputPath) {
-				fullOutputPath = join(tmpdir(), `omp-${nanoid()}.buffer`);
-				const ts = createWriteStream(fullOutputPath);
-				chunks.forEach((c) => {
-					ts.write(c);
-				});
-				fullOutputStream = ts;
-			}
-			fullOutputStream?.write(text);
-
-			chunks.push(text);
-			chunkBytes += text.length;
-			while (chunkBytes > maxBuffer && chunks.length > 1) {
-				chunkBytes -= chunks.shift()!.length;
-			}
-
-			onChunk?.(text);
-		},
-		close() {
-			fullOutputStream?.end();
-		},
-	});
-
-	return Object.assign(sink, {
-		dump(annotation?: string) {
-			if (annotation) {
-				chunks.push(`\n\n${annotation}`);
-			}
-			const full = chunks.join("");
-			const { content, truncated } = truncateTail(full);
-			return { output: truncated ? content : full, truncated, fullOutputPath };
-		},
-	});
-}
-
 function quoteForCompatShell(command: string): string {
 	if (command.length === 0) {
 		return "''";
@@ -146,25 +80,13 @@ export async function executeSSH(
 		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 {
-		async function pumpStream(readable: ReadableStream<Uint8Array>) {
-			const reader = readable.pipeThrough(createSanitizer()).getReader();
-			try {
-				while (true) {
-					const { done, value } = await reader.read();
-					if (done) break;
-					await writer.write(value);
-				}
-			} finally {
-				reader.releaseLock();
-			}
-		}
 		await Promise.all([
-			pumpStream(child.stdout as ReadableStream<Uint8Array>),
-			pumpStream(child.stderr as ReadableStream<Uint8Array>),
+			pumpStream(child.stdout as ReadableStream<Uint8Array>, writer),
+			pumpStream(child.stderr as ReadableStream<Uint8Array>, writer),
 		]);
 	} finally {
 		await writer.close();

package/src/core/streaming-output.ts

@@ -2,9 +2,55 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { nanoid } from "nanoid";
 import stripAnsi from "strip-ansi";
-import { sanitizeBinaryOutput } from "../utils/shell";
 import { truncateTail } from "./tools/truncate";
 
+/**
+ * Sanitize binary output for display/storage.
+ * Removes characters that crash string-width or cause display issues:
+ * - Control characters (except tab, newline, carriage return)
+ * - Lone surrogates
+ * - Unicode Format characters (crash string-width due to a bug)
+ * - Characters with undefined code points
+ */
+export function sanitizeBinaryOutput(str: string): string {
+	// Use Array.from to properly iterate over code points (not code units)
+	// This handles surrogate pairs correctly and catches edge cases where
+	// codePointAt() might return undefined
+	return Array.from(str)
+		.filter((char) => {
+			// Filter out characters that cause string-width to crash
+			// This includes:
+			// - Unicode format characters
+			// - Lone surrogates (already filtered by Array.from)
+			// - Control chars except \t \n \r
+			// - Characters with undefined code points
+
+			const code = char.codePointAt(0);
+
+			// Skip if code point is undefined (edge case with invalid strings)
+			if (code === undefined) return false;
+
+			// Allow tab, newline, carriage return
+			if (code === 0x09 || code === 0x0a || code === 0x0d) return true;
+
+			// Filter out control characters (0x00-0x1F, except 0x09, 0x0a, 0x0x0d)
+			if (code <= 0x1f) return false;
+
+			// Filter out Unicode format characters
+			if (code >= 0xfff9 && code <= 0xfffb) return false;
+
+			return true;
+		})
+		.join("");
+}
+
+/**
+ * Sanitize text output: strip ANSI codes, remove binary garbage, normalize line endings.
+ */
+export function sanitizeText(text: string): string {
+	return sanitizeBinaryOutput(stripAnsi(text)).replace(/\r/g, "");
+}
+
 interface OutputFileSink {
 	write(data: string): number | Promise<number>;
 	end(): void;
@@ -12,7 +58,6 @@ interface OutputFileSink {
 
 export function createSanitizer(): TransformStream<Uint8Array, string> {
 	const decoder = new TextDecoder();
-	const sanitizeText = (text: string) => sanitizeBinaryOutput(stripAnsi(text)).replace(/\r/g, "");
 	return new TransformStream({
 		transform(chunk, controller) {
 			const text = sanitizeText(decoder.decode(chunk, { stream: true }));
@@ -42,59 +87,68 @@ export async function pumpStream(readable: ReadableStream<Uint8Array>, writer: W
 	}
 }
 
-export function createOutputSink(
-	spillThreshold: number,
-	maxBuffer: number,
-	onChunk?: (text: string) => void,
-): WritableStream<string> & {
-	dump: (annotation?: string) => { output: string; truncated: boolean; fullOutputPath?: string };
-} {
-	const chunks: Array<{ text: string; bytes: number }> = [];
-	let chunkBytes = 0;
-	let totalBytes = 0;
-	let fullOutputPath: string | undefined;
-	let fullOutputStream: OutputFileSink | undefined;
-
-	const sink = new WritableStream<string>({
-		write(text) {
-			const bytes = Buffer.byteLength(text, "utf-8");
-			totalBytes += bytes;
-
-			if (totalBytes > spillThreshold && !fullOutputPath) {
-				fullOutputPath = join(tmpdir(), `omp-${nanoid()}.buffer`);
-				const stream = Bun.file(fullOutputPath).writer();
-				for (const chunk of chunks) {
-					stream.write(chunk.text);
+export interface OutputSinkDump {
+	output: string;
+	truncated: boolean;
+	fullOutputPath?: string;
+}
+
+export class OutputSink {
+	private readonly stream: WritableStream<string>;
+	private readonly chunks: Array<{ text: string; bytes: number }> = [];
+	private chunkBytes = 0;
+	private totalBytes = 0;
+	private fullOutputPath: string | undefined;
+	private fullOutputStream: OutputFileSink | undefined;
+
+	constructor(
+		private readonly spillThreshold: number,
+		private readonly maxBuffer: number,
+		private readonly onChunk?: (text: string) => void,
+	) {
+		this.stream = new WritableStream<string>({
+			write: (text) => {
+				const bytes = Buffer.byteLength(text, "utf-8");
+				this.totalBytes += bytes;
+
+				if (this.totalBytes > this.spillThreshold && !this.fullOutputPath) {
+					this.fullOutputPath = join(tmpdir(), `omp-${nanoid()}.buffer`);
+					const stream = Bun.file(this.fullOutputPath).writer();
+					for (const chunk of this.chunks) {
+						stream.write(chunk.text);
+					}
+					this.fullOutputStream = stream;
 				}
-				fullOutputStream = stream;
-			}
-			fullOutputStream?.write(text);
-
-			chunks.push({ text, bytes });
-			chunkBytes += bytes;
-			while (chunkBytes > maxBuffer && chunks.length > 1) {
-				const removed = chunks.shift();
-				if (removed) {
-					chunkBytes -= removed.bytes;
+				this.fullOutputStream?.write(text);
+
+				this.chunks.push({ text, bytes });
+				this.chunkBytes += bytes;
+				while (this.chunkBytes > this.maxBuffer && this.chunks.length > 1) {
+					const removed = this.chunks.shift();
+					if (removed) {
+						this.chunkBytes -= removed.bytes;
+					}
 				}
-			}
 
-			onChunk?.(text);
-		},
-		close() {
-			fullOutputStream?.end();
-		},
-	});
+				this.onChunk?.(text);
+			},
+			close: () => {
+				this.fullOutputStream?.end();
+			},
+		});
+	}
 
-	return Object.assign(sink, {
-		dump(annotation?: string) {
-			if (annotation) {
-				const text = `\n\n${annotation}`;
-				chunks.push({ text, bytes: Buffer.byteLength(text, "utf-8") });
-			}
-			const full = chunks.map((chunk) => chunk.text).join("");
-			const { content, truncated } = truncateTail(full);
-			return { output: truncated ? content : full, truncated, fullOutputPath };
-		},
-	});
+	getWriter(): WritableStreamDefaultWriter<string> {
+		return this.stream.getWriter();
+	}
+
+	dump(annotation?: string): OutputSinkDump {
+		if (annotation) {
+			const text = `\n\n${annotation}`;
+			this.chunks.push({ text, bytes: Buffer.byteLength(text, "utf-8") });
+		}
+		const full = this.chunks.map((chunk) => chunk.text).join("");
+		const { content, truncated } = truncateTail(full);
+		return { output: truncated ? content : full, truncated, fullOutputPath: this.fullOutputPath };
+	}
 }