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

package/src/core/tools/render-utils.ts

@@ -231,67 +231,104 @@ export interface ToolUITitleOptions {
 	bold?: boolean;
 }
 
-export interface ToolUIKit {
-	theme: Theme;
-	title: (label: string, options?: ToolUITitleOptions) => string;
-	meta: (meta: string[]) => string;
-	count: (label: string, count: number) => string;
-	moreItems: (remaining: number, itemType: string) => string;
-	expandHint: (expanded: boolean, hasMore: boolean) => string;
-	scope: (scopePath?: string) => string;
-	truncationSuffix: (truncated: boolean) => string;
-	errorMessage: (message: string | undefined) => string;
-	emptyMessage: (message: string) => string;
-	badge: (label: string, color: ToolUIColor) => string;
-	statusIcon: (status: ToolUIStatus, spinnerFrame?: number) => string;
-	wrapBrackets: (text: string) => string;
-	truncate: (text: string, maxLen: number) => string;
-	previewLines: (text: string, maxLines: number, maxLineLen: number) => string[];
-	formatBytes: (bytes: number) => string;
-	formatTokens: (tokens: number) => string;
-	formatDuration: (ms: number) => string;
-	formatAge: (ageSeconds: number | null | undefined) => string;
-	formatDiagnostics: (
+// =============================================================================
+// Diagnostic Formatting
+// =============================================================================
+
+export class ToolUIKit {
+	constructor(public theme: Theme) {}
+
+	title(label: string, options?: ToolUITitleOptions): string {
+		const content = options?.bold === false ? label : this.theme.bold(label);
+		return this.theme.fg("toolTitle", content);
+	}
+
+	meta(meta: string[]): string {
+		return formatMeta(meta, this.theme);
+	}
+
+	count(label: string, count: number): string {
+		return formatCount(label, count);
+	}
+
+	moreItems(remaining: number, itemType: string): string {
+		return formatMoreItems(remaining, itemType, this.theme);
+	}
+
+	expandHint(expanded: boolean, hasMore: boolean): string {
+		return formatExpandHint(this.theme, expanded, hasMore);
+	}
+
+	scope(scopePath?: string): string {
+		return formatScope(scopePath, this.theme);
+	}
+
+	truncationSuffix(truncated: boolean): string {
+		return formatTruncationSuffix(truncated, this.theme);
+	}
+
+	errorMessage(message: string | undefined): string {
+		return formatErrorMessage(message, this.theme);
+	}
+
+	emptyMessage(message: string): string {
+		return formatEmptyMessage(message, this.theme);
+	}
+
+	badge(label: string, color: ToolUIColor): string {
+		return formatBadge(label, color, this.theme);
+	}
+
+	statusIcon(status: ToolUIStatus, spinnerFrame?: number): string {
+		return formatStatusIcon(status, this.theme, spinnerFrame);
+	}
+
+	wrapBrackets(text: string): string {
+		return wrapBrackets(text, this.theme);
+	}
+
+	truncate(text: string, maxLen: number): string {
+		return truncate(text, maxLen, this.theme.format.ellipsis);
+	}
+
+	previewLines(text: string, maxLines: number, maxLineLen: number): string[] {
+		return getPreviewLines(text, maxLines, maxLineLen, this.theme.format.ellipsis);
+	}
+
+	formatBytes(bytes: number): string {
+		return formatBytes(bytes);
+	}
+
+	formatTokens(tokens: number): string {
+		return formatTokens(tokens);
+	}
+
+	formatDuration(ms: number): string {
+		return formatDuration(ms);
+	}
+
+	formatAge(ageSeconds: number | null | undefined): string {
+		return formatAge(ageSeconds);
+	}
+
+	formatDiagnostics(
 		diag: { errored: boolean; summary: string; messages: string[] },
 		expanded: boolean,
 		getLangIcon: (filePath: string) => string,
-	) => string;
-	formatDiffStats: (added: number, removed: number, hunks: number) => string;
+	): string {
+		return formatDiagnostics(diag, expanded, this.theme, getLangIcon);
+	}
+
+	formatDiffStats(added: number, removed: number, hunks: number): string {
+		return formatDiffStats(added, removed, hunks, this.theme);
+	}
 }
 
+/** @deprecated Use `new ToolUIKit(theme)` instead */
 export function createToolUIKit(theme: Theme): ToolUIKit {
-	return {
-		theme,
-		title: (label, options) => {
-			const content = options?.bold === false ? label : theme.bold(label);
-			return theme.fg("toolTitle", content);
-		},
-		meta: (meta) => formatMeta(meta, theme),
-		count: (label, count) => formatCount(label, count),
-		moreItems: (remaining, itemType) => formatMoreItems(remaining, itemType, theme),
-		expandHint: (expanded, hasMore) => formatExpandHint(theme, expanded, hasMore),
-		scope: (scopePath) => formatScope(scopePath, theme),
-		truncationSuffix: (truncated) => formatTruncationSuffix(truncated, theme),
-		errorMessage: (message) => formatErrorMessage(message, theme),
-		emptyMessage: (message) => formatEmptyMessage(message, theme),
-		badge: (label, color) => formatBadge(label, color, theme),
-		statusIcon: (status, spinnerFrame) => formatStatusIcon(status, theme, spinnerFrame),
-		wrapBrackets: (text) => wrapBrackets(text, theme),
-		truncate: (text, maxLen) => truncate(text, maxLen, theme.format.ellipsis),
-		previewLines: (text, maxLines, maxLineLen) => getPreviewLines(text, maxLines, maxLineLen, theme.format.ellipsis),
-		formatBytes,
-		formatTokens,
-		formatDuration,
-		formatAge,
-		formatDiagnostics: (diag, expanded, getLangIcon) => formatDiagnostics(diag, expanded, theme, getLangIcon),
-		formatDiffStats: (added, removed, hunks) => formatDiffStats(added, removed, hunks, theme),
-	};
+	return new ToolUIKit(theme);
 }
 
-// =============================================================================
-// Diagnostic Formatting
-// =============================================================================
-
 interface ParsedDiagnostic {
 	filePath: string;
 	line: number;
@@ -477,6 +514,36 @@ export function formatDiffStats(added: number, removed: number, hunks: number, t
 	return parts.join(theme.fg("dim", " / "));
 }
 
+interface DiffSegment {
+	lines: string[];
+	isChange: boolean;
+	isEllipsis: boolean;
+}
+
+function parseDiffSegments(lines: string[]): DiffSegment[] {
+	const segments: DiffSegment[] = [];
+	let current: DiffSegment | null = null;
+
+	for (const line of lines) {
+		const isChange = line.startsWith("+") || line.startsWith("-");
+		const isEllipsis = line.trimStart().startsWith("...");
+
+		if (isEllipsis) {
+			if (current) segments.push(current);
+			segments.push({ lines: [line], isChange: false, isEllipsis: true });
+			current = null;
+		} else if (!current || current.isChange !== isChange) {
+			if (current) segments.push(current);
+			current = { lines: [line], isChange, isEllipsis: false };
+		} else {
+			current.lines.push(line);
+		}
+	}
+
+	if (current) segments.push(current);
+	return segments;
+}
+
 export function truncateDiffByHunk(
 	diffText: string,
 	maxHunks: number,
@@ -484,42 +551,94 @@ export function truncateDiffByHunk(
 ): { text: string; hiddenHunks: number; hiddenLines: number } {
 	const lines = diffText ? diffText.split("\n") : [];
 	const totalStats = getDiffStats(diffText);
-	const kept: string[] = [];
-	let inHunk = false;
-	let currentHunks = 0;
-	let reachedLimit = false;
 
-	for (const line of lines) {
-		const isChange = line.startsWith("+") || line.startsWith("-");
-		if (isChange && !inHunk) {
-			currentHunks++;
-			inHunk = true;
-		}
-		if (!isChange) {
-			inHunk = false;
-		}
+	if (lines.length <= maxLines && totalStats.hunks <= maxHunks) {
+		return { text: diffText, hiddenHunks: 0, hiddenLines: 0 };
+	}
 
-		if (currentHunks > maxHunks) {
-			reachedLimit = true;
-			break;
-		}
+	const segments = parseDiffSegments(lines);
+
+	const changeSegments = segments.filter((s) => s.isChange);
+	const changeLineCount = changeSegments.reduce((sum, s) => sum + s.lines.length, 0);
+
+	if (changeLineCount > maxLines) {
+		const kept: string[] = [];
+		let keptHunks = 0;
 
-		kept.push(line);
-		if (kept.length >= maxLines) {
-			reachedLimit = true;
-			break;
+		for (const seg of segments) {
+			if (seg.isChange) {
+				keptHunks++;
+				if (keptHunks > maxHunks) break;
+			}
+			kept.push(...seg.lines);
+			if (kept.length >= maxLines) break;
 		}
+
+		const keptStats = getDiffStats(kept.join("\n"));
+		return {
+			text: kept.join("\n"),
+			hiddenHunks: Math.max(0, totalStats.hunks - keptStats.hunks),
+			hiddenLines: Math.max(0, lines.length - kept.length),
+		};
 	}
 
-	if (!reachedLimit) {
-		return { text: diffText, hiddenHunks: 0, hiddenLines: 0 };
+	const contextBudget = maxLines - changeLineCount;
+	const contextSegments = segments.filter((s) => !s.isChange && !s.isEllipsis);
+	const totalContextLines = contextSegments.reduce((sum, s) => sum + s.lines.length, 0);
+
+	const kept: string[] = [];
+	let keptHunks = 0;
+
+	if (totalContextLines <= contextBudget) {
+		for (const seg of segments) {
+			if (seg.isChange) {
+				keptHunks++;
+				if (keptHunks > maxHunks) break;
+			}
+			kept.push(...seg.lines);
+		}
+	} else {
+		const contextRatio = contextSegments.length > 0 ? contextBudget / totalContextLines : 0;
+
+		for (let i = 0; i < segments.length; i++) {
+			const seg = segments[i];
+
+			if (seg.isChange) {
+				keptHunks++;
+				if (keptHunks > maxHunks) break;
+				kept.push(...seg.lines);
+			} else if (seg.isEllipsis) {
+				kept.push(...seg.lines);
+			} else {
+				const allowedLines = Math.max(1, Math.floor(seg.lines.length * contextRatio));
+				const isBeforeChange = segments[i + 1]?.isChange;
+				const isAfterChange = segments[i - 1]?.isChange;
+
+				if (isBeforeChange && isAfterChange) {
+					const half = Math.ceil(allowedLines / 2);
+					if (seg.lines.length > allowedLines) {
+						kept.push(...seg.lines.slice(0, half));
+						kept.push(seg.lines[0].replace(/^(\s*\d*\s*).*/, "$1..."));
+						kept.push(...seg.lines.slice(-half));
+					} else {
+						kept.push(...seg.lines);
+					}
+				} else if (isBeforeChange) {
+					kept.push(...seg.lines.slice(-allowedLines));
+				} else if (isAfterChange) {
+					kept.push(...seg.lines.slice(0, allowedLines));
+				} else {
+					kept.push(...seg.lines.slice(0, Math.min(allowedLines, 2)));
+				}
+			}
+		}
 	}
 
 	const keptStats = getDiffStats(kept.join("\n"));
 	return {
 		text: kept.join("\n"),
 		hiddenHunks: Math.max(0, totalStats.hunks - keptStats.hunks),
-		hiddenLines: Math.max(0, totalStats.lines - kept.length),
+		hiddenLines: Math.max(0, lines.length - kept.length),
 	};
 }
 

package/src/core/tools/renderers.ts

@@ -10,13 +10,13 @@ import type { RenderResultOptions } from "../custom-tools/types";
 import { askToolRenderer } from "./ask";
 import { bashToolRenderer } from "./bash";
 import { calculatorToolRenderer } from "./calculator";
-import { editToolRenderer } from "./edit";
 import { findToolRenderer } from "./find";
 import { grepToolRenderer } from "./grep";
 import { lsToolRenderer } from "./ls";
 import { lspToolRenderer } from "./lsp/render";
 import { notebookToolRenderer } from "./notebook";
 import { outputToolRenderer } from "./output";
+import { editToolRenderer } from "./patch";
 import { pythonToolRenderer } from "./python";
 import { readToolRenderer } from "./read";
 import { sshToolRenderer } from "./ssh";

package/src/core/tools/ssh.ts

@@ -1,4 +1,4 @@
-import type { AgentTool, AgentToolContext } from "@oh-my-pi/pi-agent-core";
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } 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";
@@ -112,97 +112,116 @@ async function loadHosts(session: ToolSession): Promise<{
 	return { hostNames, hostsByName };
 }
 
-export async function createSshTool(session: ToolSession): Promise<AgentTool<typeof sshSchema> | null> {
-	const { hostNames, hostsByName } = await loadHosts(session);
-	if (hostNames.length === 0) {
-		return null;
-	}
+interface SshToolParams {
+	host: string;
+	command: string;
+	cwd?: string;
+	timeout?: number;
+}
 
-	const allowedHosts = new Set(hostNames);
-
-	const descriptionHosts = hostNames
-		.map((name) => hostsByName.get(name))
-		.filter((host): host is SSHHost => host !== undefined);
-
-	return {
-		name: "ssh",
-		label: "SSH",
-		description: formatDescription(descriptionHosts),
-		parameters: sshSchema,
-		execute: async (
-			_toolCallId: string,
-			{ host, command, cwd, timeout }: { host: string; command: string; cwd?: string; timeout?: number },
-			signal?: AbortSignal,
-			onUpdate?,
-			_ctx?: AgentToolContext,
-		) => {
-			if (!allowedHosts.has(host)) {
-				throw new Error(`Unknown SSH host: ${host}. Available hosts: ${hostNames.join(", ")}`);
-			}
+export class SshTool implements AgentTool<typeof sshSchema, SSHToolDetails> {
+	public readonly name = "ssh";
+	public readonly label = "SSH";
+	public readonly description: string;
+	public readonly parameters = sshSchema;
 
-			const hostConfig = hostsByName.get(host);
-			if (!hostConfig) {
-				throw new Error(`SSH host not loaded: ${host}`);
-			}
+	private readonly allowedHosts: Set<string>;
+	private readonly hostsByName: Map<string, SSHHost>;
+	private readonly hostNames: string[];
 
-			const hostInfo = await ensureHostInfo(hostConfig);
-			const remoteCommand = buildRemoteCommand(command, cwd, hostInfo);
-			let currentOutput = "";
-
-			const result = await executeSSH(hostConfig, remoteCommand, {
-				timeout: timeout ? timeout * 1000 : undefined,
-				signal,
-				compatEnabled: hostInfo.compatEnabled,
-				onChunk: (chunk) => {
-					currentOutput += chunk;
-					if (onUpdate) {
-						const truncation = truncateTail(currentOutput);
-						onUpdate({
-							content: [{ type: "text", text: truncation.content || "" }],
-							details: {
-								truncation: truncation.truncated ? truncation : undefined,
-							},
-						});
-					}
-				},
-			});
-
-			if (result.cancelled) {
-				throw new Error(result.output || "Command aborted");
-			}
+	constructor(hostNames: string[], hostsByName: Map<string, SSHHost>) {
+		this.hostNames = hostNames;
+		this.hostsByName = hostsByName;
+		this.allowedHosts = new Set(hostNames);
 
-			const truncation = truncateTail(result.output);
-			let outputText = truncation.content || "(no output)";
+		const descriptionHosts = hostNames
+			.map((name) => hostsByName.get(name))
+			.filter((host): host is SSHHost => host !== undefined);
 
-			let details: SSHToolDetails | undefined;
+		this.description = formatDescription(descriptionHosts);
+	}
 
-			if (truncation.truncated) {
-				details = {
-					truncation,
-					fullOutputPath: result.fullOutputPath,
-				};
+	public async execute(
+		_toolCallId: string,
+		{ host, command, cwd, timeout }: SshToolParams,
+		signal?: AbortSignal,
+		onUpdate?: AgentToolUpdateCallback<SSHToolDetails>,
+		_ctx?: AgentToolContext,
+	): Promise<AgentToolResult<SSHToolDetails>> {
+		if (!this.allowedHosts.has(host)) {
+			throw new Error(`Unknown SSH host: ${host}. Available hosts: ${this.hostNames.join(", ")}`);
+		}
 
-				const startLine = truncation.totalLines - truncation.outputLines + 1;
-				const endLine = truncation.totalLines;
+		const hostConfig = this.hostsByName.get(host);
+		if (!hostConfig) {
+			throw new Error(`SSH host not loaded: ${host}`);
+		}
 
-				if (truncation.lastLinePartial) {
-					const lastLineSize = formatSize(Buffer.byteLength(result.output.split("\n").pop() || "", "utf-8"));
-					outputText += `\n\n[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine} (line is ${lastLineSize}). Full output: ${result.fullOutputPath}]`;
-				} else if (truncation.truncatedBy === "lines") {
-					outputText += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}. Full output: ${result.fullOutputPath}]`;
-				} else {
-					outputText += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Full output: ${result.fullOutputPath}]`;
+		const hostInfo = await ensureHostInfo(hostConfig);
+		const remoteCommand = buildRemoteCommand(command, cwd, hostInfo);
+		let currentOutput = "";
+
+		const result = await executeSSH(hostConfig, remoteCommand, {
+			timeout: timeout ? timeout * 1000 : undefined,
+			signal,
+			compatEnabled: hostInfo.compatEnabled,
+			onChunk: (chunk) => {
+				currentOutput += chunk;
+				if (onUpdate) {
+					const truncation = truncateTail(currentOutput);
+					onUpdate({
+						content: [{ type: "text", text: truncation.content || "" }],
+						details: {
+							truncation: truncation.truncated ? truncation : undefined,
+						},
+					});
 				}
-			}
+			},
+		});
+
+		if (result.cancelled) {
+			throw new Error(result.output || "Command aborted");
+		}
 
-			if (result.exitCode !== 0 && result.exitCode !== undefined) {
-				outputText += `\n\nCommand exited with code ${result.exitCode}`;
-				throw new Error(outputText);
+		const truncation = truncateTail(result.output);
+		let outputText = truncation.content || "(no output)";
+
+		let details: SSHToolDetails | undefined;
+
+		if (truncation.truncated) {
+			details = {
+				truncation,
+				fullOutputPath: result.fullOutputPath,
+			};
+
+			const startLine = truncation.totalLines - truncation.outputLines + 1;
+			const endLine = truncation.totalLines;
+
+			if (truncation.lastLinePartial) {
+				const lastLineSize = formatSize(Buffer.byteLength(result.output.split("\n").pop() || "", "utf-8"));
+				outputText += `\n\n[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine} (line is ${lastLineSize}). Full output: ${result.fullOutputPath}]`;
+			} else if (truncation.truncatedBy === "lines") {
+				outputText += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}. Full output: ${result.fullOutputPath}]`;
+			} else {
+				outputText += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Full output: ${result.fullOutputPath}]`;
 			}
+		}
 
-			return { content: [{ type: "text", text: outputText }], details };
-		},
-	};
+		if (result.exitCode !== 0 && result.exitCode !== undefined) {
+			outputText += `\n\nCommand exited with code ${result.exitCode}`;
+			throw new Error(outputText);
+		}
+
+		return { content: [{ type: "text", text: outputText }], details: details ?? {} };
+	}
+}
+
+export async function loadSshTool(session: ToolSession): Promise<SshTool | null> {
+	const { hostNames, hostsByName } = await loadHosts(session);
+	if (hostNames.length === 0) {
+		return null;
+	}
+	return new SshTool(hostNames, hostsByName);
 }
 
 // =============================================================================

package/src/core/tools/task/executor.ts

@@ -12,9 +12,9 @@ import type { MCPManager } from "../../mcp/manager";
 import type { ModelRegistry } from "../../model-registry";
 import { checkPythonKernelAvailability } from "../../python-kernel";
 import type { ToolSession } from "..";
-import { createLspTool } from "../lsp/index";
+import { LspTool } from "../lsp/index";
 import type { LspParams } from "../lsp/types";
-import { createPythonTool } from "../python";
+import { PythonTool } from "../python";
 import { ensureArtifactsDir, getArtifactPaths } from "./artifacts";
 import { resolveModelPattern } from "./model-resolver";
 import { subprocessToolRegistry } from "./subprocess-tool-registry";
@@ -388,7 +388,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		settings: options.settingsManager as ToolSession["settings"],
 		settingsManager: options.settingsManager,
 	};
-	const pythonTool = pythonProxyEnabled ? createPythonTool(pythonToolSession) : null;
+	const pythonTool = pythonProxyEnabled ? new PythonTool(pythonToolSession) : null;
 	const pythonCallControllers = new Map<string, AbortController>();
 
 	const lspToolSession: ToolSession = {
@@ -400,7 +400,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		settings: options.settingsManager as ToolSession["settings"],
 		settingsManager: options.settingsManager,
 	};
-	const lspTool = lspToolRequested ? createLspTool(lspToolSession) : null;
+	const lspTool = lspToolRequested ? new LspTool(lspToolSession) : null;
 
 	// Accumulate usage incrementally from message_end events (no memory for streaming events)
 	const accumulatedUsage = {
@@ -736,9 +736,13 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			try {
 				const parsed = parseMCPToolName(request.toolName);
 				if (!parsed) throw new Error(`Invalid MCP tool name: ${request.toolName}`);
-				const connection = mcpManager.getConnection(parsed.serverName);
-				if (!connection) throw new Error(`MCP server not connected: ${parsed.serverName}`);
-				const result = await withTimeout(callTool(connection, parsed.toolName, request.params), request.timeoutMs);
+				const result = await withTimeout(
+					(async () => {
+						const connection = await mcpManager.waitForConnection(parsed.serverName);
+						return callTool(connection, parsed.toolName, request.params);
+					})(),
+					request.timeoutMs,
+				);
 				worker.postMessage({
 					type: "mcp_tool_result",
 					callId: request.callId,