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

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

@@ -443,30 +443,20 @@ const isAgentEvent = (event: AgentSessionEvent): event is AgentEvent => {
 	return agentEventTypes.has(event.type as AgentEvent["type"]);
 };
 
-interface RunState {
-	abortController: AbortController;
-	startTime: number;
-	session: { abort: () => Promise<void>; dispose: () => Promise<void> } | null;
-	unsubscribe: (() => void) | null;
-	sendDoneOnce: (message: Extract<SubagentWorkerResponse, { type: "done" }>) => void;
-}
+class RunState {
+	abortController = new AbortController();
+	startTime = Date.now();
+	session: { abort: () => Promise<void>; dispose: () => Promise<void> } | null = null;
+	unsubscribe: (() => void) | null = null;
 
-const createSendDoneOnce = (): RunState["sendDoneOnce"] => {
-	let sent = false;
-	return (message) => {
-		if (sent) return;
-		sent = true;
-		postMessageSafe(message);
-	};
-};
+	private doneSent = false;
 
-const createRunState = (): RunState => ({
-	abortController: new AbortController(),
-	startTime: Date.now(),
-	session: null,
-	unsubscribe: null,
-	sendDoneOnce: createSendDoneOnce(),
-});
+	sendDoneOnce(message: Extract<SubagentWorkerResponse, { type: "done" }>): void {
+		if (this.doneSent) return;
+		this.doneSent = true;
+		postMessageSafe(message);
+	}
+}
 
 let activeRun: RunState | null = null;
 let pendingAbort = false;
@@ -861,7 +851,7 @@ globalThis.addEventListener("message", (event: WorkerMessageEvent<SubagentWorker
 	if (message.type === "start") {
 		// Only allow one task per worker
 		if (activeRun) return;
-		const runState = createRunState();
+		const runState = new RunState();
 		if (pendingAbort) {
 			pendingAbort = false;
 			runState.abortController.abort();

package/src/core/tools/todo-write.ts

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { mkdirSync } from "node:fs";
 import path from "node:path";
-import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { StringEnum } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
@@ -49,6 +49,8 @@ export interface TodoWriteToolDetails {
 
 const TODO_FILE_NAME = "todos.json";
 
+type TodoWriteParams = { todos: Array<{ id?: string; content?: string; activeForm?: string; status?: string }> };
+
 function normalizeTodoStatus(status?: string): TodoStatus {
 	switch (status) {
 		case "in_progress":
@@ -137,6 +139,14 @@ async function saveTodoFile(filePath: string, data: TodoFile): Promise<void> {
 	await Bun.write(filePath, JSON.stringify(data, null, 2));
 }
 
+function formatTodoSummary(todos: TodoItem[]): string {
+	if (todos.length === 0) return "Todo list cleared.";
+	const completed = todos.filter((t) => t.status === "completed").length;
+	const inProgress = todos.filter((t) => t.status === "in_progress").length;
+	const pending = todos.filter((t) => t.status === "pending").length;
+	return `Saved ${todos.length} todos (${pending} pending, ${inProgress} in progress, ${completed} completed).`;
+}
+
 function formatTodoLine(item: TodoItem, uiTheme: Theme, prefix: string): string {
 	const checkbox = uiTheme.checkbox;
 	const displayText =
@@ -151,71 +161,76 @@ function formatTodoLine(item: TodoItem, uiTheme: Theme, prefix: string): string
 	}
 }
 
-function formatTodoSummary(todos: TodoItem[]): string {
-	if (todos.length === 0) return "Todo list cleared.";
-	const completed = todos.filter((t) => t.status === "completed").length;
-	const inProgress = todos.filter((t) => t.status === "in_progress").length;
-	const pending = todos.filter((t) => t.status === "pending").length;
-	return `Saved ${todos.length} todos (${pending} pending, ${inProgress} in progress, ${completed} completed).`;
-}
+// =============================================================================
+// Tool Class
+// =============================================================================
 
-export function createTodoWriteTool(session: ToolSession): AgentTool<typeof todoWriteSchema, TodoWriteToolDetails> {
-	return {
-		name: "todo_write",
-		label: "Todo Write",
-		description: renderPromptTemplate(todoWriteDescription),
-		parameters: todoWriteSchema,
-		execute: async (
-			_toolCallId: string,
-			params: { todos: Array<{ id?: string; content?: string; activeForm?: string; status?: string }> },
-		) => {
-			const todos = normalizeTodos(params.todos ?? []);
-			const validation = validateSequentialTodos(todos);
-			if (!validation.valid) {
-				throw new Error(validation.error ?? "Todos must be completed sequentially.");
-			}
-			const updatedAt = Date.now();
+export class TodoWriteTool implements AgentTool<typeof todoWriteSchema, TodoWriteToolDetails> {
+	public readonly name = "todo_write";
+	public readonly label = "Todo Write";
+	public readonly description: string;
+	public readonly parameters = todoWriteSchema;
 
-			const sessionFile = session.getSessionFile();
-			if (!sessionFile) {
-				return {
-					content: [{ type: "text", text: formatTodoSummary(todos) }],
-					details: { todos, updatedAt, storage: "memory" },
-				};
-			}
+	private readonly session: ToolSession;
 
-			const artifactsDir = getArtifactsDir(sessionFile);
-			if (!artifactsDir) {
-				return {
-					content: [{ type: "text", text: formatTodoSummary(todos) }],
-					details: { todos, updatedAt, storage: "memory" },
-				};
-			}
+	constructor(session: ToolSession) {
+		this.session = session;
+		this.description = renderPromptTemplate(todoWriteDescription);
+	}
 
-			ensureArtifactsDir(artifactsDir);
-			const todoPath = path.join(artifactsDir, TODO_FILE_NAME);
-			const existing = await loadTodoFile(todoPath);
-			const storedTodos = existing?.todos ?? [];
-			const merged = todos.length > 0 ? todos : [];
-			const fileData: TodoFile = { updatedAt, todos: merged };
-
-			try {
-				mkdirSync(artifactsDir, { recursive: true });
-				await saveTodoFile(todoPath, fileData);
-			} catch (error) {
-				logger.error("Failed to write todo file", { path: todoPath, error: String(error) });
-				return {
-					content: [{ type: "text", text: "Failed to save todos." }],
-					details: { todos: storedTodos, updatedAt, storage: "session" },
-				};
-			}
+	public async execute(
+		_toolCallId: string,
+		params: TodoWriteParams,
+		_signal?: AbortSignal,
+		_onUpdate?: AgentToolUpdateCallback<TodoWriteToolDetails>,
+		_context?: AgentToolContext,
+	): Promise<AgentToolResult<TodoWriteToolDetails>> {
+		const todos = normalizeTodos(params.todos ?? []);
+		const validation = validateSequentialTodos(todos);
+		if (!validation.valid) {
+			throw new Error(validation.error ?? "Todos must be completed sequentially.");
+		}
+		const updatedAt = Date.now();
+
+		const sessionFile = this.session.getSessionFile();
+		if (!sessionFile) {
+			return {
+				content: [{ type: "text", text: formatTodoSummary(todos) }],
+				details: { todos, updatedAt, storage: "memory" },
+			};
+		}
+
+		const artifactsDir = getArtifactsDir(sessionFile);
+		if (!artifactsDir) {
+			return {
+				content: [{ type: "text", text: formatTodoSummary(todos) }],
+				details: { todos, updatedAt, storage: "memory" },
+			};
+		}
+
+		ensureArtifactsDir(artifactsDir);
+		const todoPath = path.join(artifactsDir, TODO_FILE_NAME);
+		const existing = await loadTodoFile(todoPath);
+		const storedTodos = existing?.todos ?? [];
+		const merged = todos.length > 0 ? todos : [];
+		const fileData: TodoFile = { updatedAt, todos: merged };
 
+		try {
+			mkdirSync(artifactsDir, { recursive: true });
+			await saveTodoFile(todoPath, fileData);
+		} catch (error) {
+			logger.error("Failed to write todo file", { path: todoPath, error: String(error) });
 			return {
-				content: [{ type: "text", text: formatTodoSummary(merged) }],
-				details: { todos: merged, updatedAt, storage: "session" },
+				content: [{ type: "text", text: "Failed to save todos." }],
+				details: { todos: storedTodos, updatedAt, storage: "session" },
 			};
-		},
-	};
+		}
+
+		return {
+			content: [{ type: "text", text: formatTodoSummary(merged) }],
+			details: { todos: merged, updatedAt, storage: "session" },
+		};
+	}
 }
 
 // =============================================================================

package/src/core/tools/web-fetch.ts

@@ -1,9 +1,9 @@
 import { tmpdir } from "node:os";
 import * as path from "node:path";
-import type { AgentTool } 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";
+import { type Static, Type } from "@sinclair/typebox";
 import { nanoid } from "nanoid";
 import { parse as parseHtml } from "node-html-parser";
 import { type Theme, theme } from "../../modes/interactive/theme/theme";
@@ -848,55 +848,62 @@ export interface WebFetchToolDetails {
 	notes: string[];
 }
 
-export function createWebFetchTool(_session: ToolSession): AgentTool<typeof webFetchSchema> {
-	return {
-		name: "web_fetch",
-		label: "Web Fetch",
-		description: renderPromptTemplate(webFetchDescription),
-		parameters: webFetchSchema,
-		execute: async (
-			_toolCallId: string,
-			{ url, timeout = DEFAULT_TIMEOUT, raw = false }: { url: string; timeout?: number; raw?: boolean },
-			signal?: AbortSignal,
-		) => {
-			if (signal?.aborted) {
-				throw new Error("Operation aborted");
-			}
+export class WebFetchTool implements AgentTool<typeof webFetchSchema, WebFetchToolDetails> {
+	public readonly name = "web_fetch";
+	public readonly label = "Web Fetch";
+	public readonly description: string;
+	public readonly parameters = webFetchSchema;
 
-			// Clamp timeout
-			const effectiveTimeout = Math.min(Math.max(timeout, 1), 120);
+	constructor(_session: ToolSession) {
+		this.description = renderPromptTemplate(webFetchDescription);
+	}
 
-			const result = await renderUrl(url, effectiveTimeout, raw, signal);
+	public async execute(
+		_toolCallId: string,
+		params: Static<typeof webFetchSchema>,
+		signal?: AbortSignal,
+		_onUpdate?: AgentToolUpdateCallback<WebFetchToolDetails>,
+		_context?: AgentToolContext,
+	): Promise<AgentToolResult<WebFetchToolDetails>> {
+		const { url, timeout = DEFAULT_TIMEOUT, raw = false } = params;
 
-			// Format output
-			let output = "";
-			output += `URL: ${result.finalUrl}\n`;
-			output += `Content-Type: ${result.contentType}\n`;
-			output += `Method: ${result.method}\n`;
-			if (result.truncated) {
-				output += `Warning: Output was truncated\n`;
-			}
-			if (result.notes.length > 0) {
-				output += `Notes: ${result.notes.join("; ")}\n`;
-			}
-			output += `\n---\n\n`;
-			output += result.content;
-
-			const details: WebFetchToolDetails = {
-				url: result.url,
-				finalUrl: result.finalUrl,
-				contentType: result.contentType,
-				method: result.method,
-				truncated: result.truncated,
-				notes: result.notes,
-			};
+		if (signal?.aborted) {
+			throw new Error("Operation aborted");
+		}
 
-			return {
-				content: [{ type: "text", text: output }],
-				details,
-			};
-		},
-	};
+		// Clamp timeout
+		const effectiveTimeout = Math.min(Math.max(timeout, 1), 120);
+
+		const result = await renderUrl(url, effectiveTimeout, raw, signal);
+
+		// Format output
+		let output = "";
+		output += `URL: ${result.finalUrl}\n`;
+		output += `Content-Type: ${result.contentType}\n`;
+		output += `Method: ${result.method}\n`;
+		if (result.truncated) {
+			output += `Warning: Output was truncated\n`;
+		}
+		if (result.notes.length > 0) {
+			output += `Notes: ${result.notes.join("; ")}\n`;
+		}
+		output += `\n---\n\n`;
+		output += result.content;
+
+		const details: WebFetchToolDetails = {
+			url: result.url,
+			finalUrl: result.finalUrl,
+			contentType: result.contentType,
+			method: result.method,
+			truncated: result.truncated,
+			notes: result.notes,
+		};
+
+		return {
+			content: [{ type: "text", text: output }],
+			details,
+		};
+	}
 }
 
 // =============================================================================

package/src/core/tools/web-search/index.ts

@@ -12,7 +12,7 @@
  * - web_search_company: Comprehensive company research
  */
 
-import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { StringEnum } from "@oh-my-pi/pi-ai";
 import { Type } from "@sinclair/typebox";
 import type { Theme } from "../../../modes/interactive/theme/theme";
@@ -330,16 +330,32 @@ async function executeWebSearch(
 	};
 }
 
-/** Web search tool as AgentTool (for allTools export) */
-export const webSearchTool: AgentTool<typeof webSearchSchema> = {
-	name: "web_search",
-	label: "Web Search",
-	description: renderPromptTemplate(webSearchDescription),
-	parameters: webSearchSchema,
-	execute: async (toolCallId, params) => {
-		return executeWebSearch(toolCallId, params as WebSearchParams);
-	},
-};
+/**
+ * Web search tool implementation.
+ *
+ * Supports Anthropic, Perplexity, and Exa providers with automatic fallback.
+ * Session is accepted for interface consistency but not used.
+ */
+export class WebSearchTool implements AgentTool<typeof webSearchSchema, WebSearchRenderDetails> {
+	public readonly name = "web_search";
+	public readonly label = "Web Search";
+	public readonly description: string;
+	public readonly parameters = webSearchSchema;
+
+	constructor(_session: ToolSession) {
+		this.description = renderPromptTemplate(webSearchDescription);
+	}
+
+	public async execute(
+		_toolCallId: string,
+		params: WebSearchParams,
+		_signal?: AbortSignal,
+		_onUpdate?: AgentToolUpdateCallback<WebSearchRenderDetails>,
+		_context?: AgentToolContext,
+	): Promise<AgentToolResult<WebSearchRenderDetails>> {
+		return executeWebSearch(_toolCallId, params);
+	}
+}
 
 /** Web search tool as CustomTool (for TUI rendering support) */
 export const webSearchCustomTool: CustomTool<typeof webSearchSchema, WebSearchRenderDetails> = {
@@ -367,11 +383,6 @@ export const webSearchCustomTool: CustomTool<typeof webSearchSchema, WebSearchRe
 	},
 };
 
-/** Factory function for backward compatibility */
-export function createWebSearchTool(_session: ToolSession): AgentTool<typeof webSearchSchema> {
-	return webSearchTool;
-}
-
 // ============================================================================
 // Exa-specific tools (available when EXA_API_KEY is present)
 // ============================================================================

package/src/core/tools/write.ts

@@ -1,4 +1,10 @@
-import type { AgentTool, AgentToolContext, ToolCallContext } from "@oh-my-pi/pi-agent-core";
+import type {
+	AgentTool,
+	AgentToolContext,
+	AgentToolResult,
+	AgentToolUpdateCallback,
+	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";
@@ -8,9 +14,15 @@ import type { RenderResultOptions } from "../custom-tools/types";
 import { renderPromptTemplate } from "../prompt-templates";
 import type { ToolSession } from "../sdk";
 import { untilAborted } from "../utils";
-import { createLspWritethrough, type FileDiagnosticsResult, writethroughNoop } from "./lsp/index";
+import {
+	createLspWritethrough,
+	type FileDiagnosticsResult,
+	type WritethroughCallback,
+	writethroughNoop,
+} from "./lsp/index";
 import { resolveToCwd } from "./path-utils";
-import { formatDiagnostics, formatExpandHint, replaceTabs, shortenPath } from "./render-utils";
+import { formatDiagnostics, formatExpandHint, formatStatusIcon, replaceTabs, shortenPath } from "./render-utils";
+import type { RenderCallOptions } from "./renderers";
 
 const writeSchema = Type.Object({
 	path: Type.String({ description: "Path to the file to write (relative or absolute)" }),
@@ -38,51 +50,69 @@ function getLspBatchRequest(toolCall: ToolCallContext | undefined): { id: string
 	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;
-	const enableDiagnostics = enableLsp ? (session.settings?.getLspDiagnosticsOnWrite() ?? true) : false;
-	const writethrough = enableLsp
-		? createLspWritethrough(session.cwd, { enableFormat, enableDiagnostics })
-		: writethroughNoop;
-	return {
-		name: "write",
-		label: "Write",
-		description: renderPromptTemplate(writeDescription),
-		parameters: writeSchema,
-		execute: async (
-			_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, undefined, batchRequest);
-
-				let resultText = `Successfully wrote ${content.length} bytes to ${path}`;
-				if (!diagnostics) {
-					return {
-						content: [{ type: "text", text: resultText }],
-						details: {},
-					};
-				}
-
-				const messages = diagnostics?.messages;
-				if (messages && messages.length > 0) {
-					resultText += `\n\nLSP Diagnostics (${diagnostics.summary}):\n`;
-					resultText += messages.map((d) => `  ${d}`).join("\n");
-				}
+// ═══════════════════════════════════════════════════════════════════════════
+// Tool Class
+// ═══════════════════════════════════════════════════════════════════════════
+
+type WriteParams = { path: string; content: string };
+
+/**
+ * Write tool implementation.
+ *
+ * Creates or overwrites files with optional LSP formatting and diagnostics.
+ */
+export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails> {
+	public readonly name = "write";
+	public readonly label = "Write";
+	public readonly description: string;
+	public readonly parameters = writeSchema;
+
+	private readonly session: ToolSession;
+	private readonly writethrough: WritethroughCallback;
+
+	constructor(session: ToolSession) {
+		this.session = session;
+		const enableLsp = session.enableLsp ?? true;
+		const enableFormat = enableLsp ? (session.settings?.getLspFormatOnWrite() ?? true) : false;
+		const enableDiagnostics = enableLsp ? (session.settings?.getLspDiagnosticsOnWrite() ?? true) : false;
+		this.writethrough = enableLsp
+			? createLspWritethrough(session.cwd, { enableFormat, enableDiagnostics })
+			: writethroughNoop;
+		this.description = renderPromptTemplate(writeDescription);
+	}
+
+	public async execute(
+		_toolCallId: string,
+		{ path, content }: WriteParams,
+		signal?: AbortSignal,
+		_onUpdate?: AgentToolUpdateCallback<WriteToolDetails>,
+		context?: AgentToolContext,
+	): Promise<AgentToolResult<WriteToolDetails>> {
+		return untilAborted(signal, async () => {
+			const absolutePath = resolveToCwd(path, this.session.cwd);
+			const batchRequest = getLspBatchRequest(context?.toolCall);
+
+			const diagnostics = await this.writethrough(absolutePath, content, signal, undefined, batchRequest);
+
+			let resultText = `Successfully wrote ${content.length} bytes to ${path}`;
+			if (!diagnostics) {
 				return {
 					content: [{ type: "text", text: resultText }],
-					details: { diagnostics },
+					details: {},
 				};
-			});
-		},
-	};
+			}
+
+			const messages = diagnostics?.messages;
+			if (messages && messages.length > 0) {
+				resultText += `\n\nLSP Diagnostics (${diagnostics.summary}):\n`;
+				resultText += messages.map((d) => `  ${d}`).join("\n");
+			}
+			return {
+				content: [{ type: "text", text: resultText }],
+				details: { diagnostics },
+			};
+		});
+	}
 }
 
 // =============================================================================
@@ -95,11 +125,34 @@ interface WriteRenderArgs {
 	content?: string;
 }
 
+const WRITE_STREAMING_PREVIEW_LINES = 12;
+
 function countLines(text: string): number {
 	if (!text) return 0;
 	return text.split("\n").length;
 }
 
+function formatStreamingContent(content: string, rawPath: string, uiTheme: Theme): string {
+	if (!content) return "";
+	const lang = getLanguageFromPath(rawPath);
+	const lines = content.split("\n");
+	const total = lines.length;
+	const displayLines = lines.slice(-WRITE_STREAMING_PREVIEW_LINES);
+	const hidden = total - displayLines.length;
+
+	const formattedLines = lang
+		? highlightCode(replaceTabs(displayLines.join("\n")), lang)
+		: displayLines.map((line: string) => uiTheme.fg("toolOutput", replaceTabs(line)));
+
+	let text = "\n\n";
+	if (hidden > 0) {
+		text += uiTheme.fg("dim", `${uiTheme.format.ellipsis} (${hidden} earlier lines)\n`);
+	}
+	text += formattedLines.join("\n");
+	text += uiTheme.fg("dim", `\n${uiTheme.format.ellipsis} (streaming)`);
+	return text;
+}
+
 function formatMetadataLine(lineCount: number | null, language: string | undefined, uiTheme: Theme): string {
 	const icon = uiTheme.getLangIcon(language);
 	if (lineCount !== null) {
@@ -109,11 +162,19 @@ function formatMetadataLine(lineCount: number | null, language: string | undefin
 }
 
 export const writeToolRenderer = {
-	renderCall(args: WriteRenderArgs, uiTheme: Theme): Component {
+	renderCall(args: WriteRenderArgs, uiTheme: Theme, options?: RenderCallOptions): Component {
 		const rawPath = args.file_path || args.path || "";
 		const filePath = shortenPath(rawPath);
 		const pathDisplay = filePath ? uiTheme.fg("accent", filePath) : uiTheme.fg("toolOutput", uiTheme.format.ellipsis);
-		const text = `${uiTheme.fg("toolTitle", uiTheme.bold("Write"))} ${pathDisplay}`;
+		const spinner =
+			options?.spinnerFrame !== undefined ? formatStatusIcon("running", uiTheme, options.spinnerFrame) : "";
+		let text = `${uiTheme.fg("toolTitle", uiTheme.bold("Write"))} ${spinner ? `${spinner} ` : ""}${pathDisplay}`;
+
+		// Show streaming preview of content
+		if (args.content) {
+			text += formatStreamingContent(args.content, rawPath, uiTheme);
+		}
+
 		return new Text(text, 0, 0);
 	},