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

package/src/core/tools/ask.ts

@@ -15,7 +15,7 @@
  *     and add "(Recommended)" at the end of the label
  */
 
-import type { AgentTool, AgentToolContext, AgentToolUpdateCallback } 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";
@@ -188,7 +188,7 @@ function formatQuestionResult(result: QuestionResult): string {
 }
 
 // =============================================================================
-// Tool Implementation
+// Tool Class
 // =============================================================================
 
 interface AskParams {
@@ -203,110 +203,109 @@ interface AskParams {
 	}>;
 }
 
-export function createAskTool(session: ToolSession): null | AgentTool<typeof askSchema, AskToolDetails> {
-	if (!session.hasUI) {
-		return null;
+/**
+ * Ask tool for interactive user prompting during execution.
+ *
+ * Allows gathering user preferences, clarifying instructions, and getting decisions
+ * on implementation choices as the agent works.
+ */
+export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
+	public readonly name = "ask";
+	public readonly label = "Ask";
+	public readonly description: string;
+	public readonly parameters = askSchema;
+
+	constructor(_session: ToolSession) {
+		this.description = renderPromptTemplate(askDescription);
 	}
-	return {
-		name: "ask",
-		label: "Ask",
-		description: renderPromptTemplate(askDescription),
-		parameters: askSchema,
-
-		async execute(
-			_toolCallId: string,
-			params: AskParams,
-			_signal?: AbortSignal,
-			_onUpdate?: AgentToolUpdateCallback<AskToolDetails>,
-			context?: AgentToolContext,
-		) {
-			// Headless fallback
-			if (!context?.hasUI || !context.ui) {
-				return {
-					content: [{ type: "text" as const, text: "Error: User prompt requires interactive mode" }],
-					details: {},
-				};
-			}
-
-			const { ui } = context;
-
-			// Multi-part questions mode
-			if (params.questions && params.questions.length > 0) {
-				const results: QuestionResult[] = [];
 
-				for (const q of params.questions) {
-					const optionLabels = q.options.map((o) => o.label);
-					const { selectedOptions, customInput } = await askSingleQuestion(
-						ui,
-						q.question,
-						optionLabels,
-						q.multi ?? false,
-					);
-
-					results.push({
-						id: q.id,
-						question: q.question,
-						options: optionLabels,
-						multi: q.multi ?? false,
-						selectedOptions,
-						customInput,
-					});
-				}
+	static createIf(session: ToolSession): AskTool | null {
+		return session.hasUI ? new AskTool(session) : null;
+	}
 
-				const details: AskToolDetails = { results };
-				const responseLines = results.map(formatQuestionResult);
-				const responseText = `User answers:\n${responseLines.join("\n")}`;
+	public async execute(
+		_toolCallId: string,
+		params: AskParams,
+		_signal?: AbortSignal,
+		_onUpdate?: AgentToolUpdateCallback<AskToolDetails>,
+		context?: AgentToolContext,
+	): Promise<AgentToolResult<AskToolDetails>> {
+		// Headless fallback
+		if (!context?.hasUI || !context.ui) {
+			return {
+				content: [{ type: "text" as const, text: "Error: User prompt requires interactive mode" }],
+				details: {},
+			};
+		}
 
-				return { content: [{ type: "text" as const, text: responseText }], details };
+		const { ui } = context;
+
+		// Multi-part questions mode
+		if (params.questions && params.questions.length > 0) {
+			const results: QuestionResult[] = [];
+
+			for (const q of params.questions) {
+				const optionLabels = q.options.map((o) => o.label);
+				const { selectedOptions, customInput } = await askSingleQuestion(
+					ui,
+					q.question,
+					optionLabels,
+					q.multi ?? false,
+				);
+
+				results.push({
+					id: q.id,
+					question: q.question,
+					options: optionLabels,
+					multi: q.multi ?? false,
+					selectedOptions,
+					customInput,
+				});
 			}
 
-			// Single question mode (backwards compatible)
-			const question = params.question ?? "";
-			const options = params.options ?? [];
-			const multi = params.multi ?? false;
-			const optionLabels = options.map((o) => o.label);
-
-			if (!question || optionLabels.length === 0) {
-				return {
-					content: [{ type: "text" as const, text: "Error: question and options are required" }],
-					details: {},
-				};
-			}
+			const details: AskToolDetails = { results };
+			const responseLines = results.map(formatQuestionResult);
+			const responseText = `User answers:\n${responseLines.join("\n")}`;
+
+			return { content: [{ type: "text" as const, text: responseText }], details };
+		}
 
-			const { selectedOptions, customInput } = await askSingleQuestion(ui, question, optionLabels, multi);
+		// Single question mode (backwards compatible)
+		const question = params.question ?? "";
+		const options = params.options ?? [];
+		const multi = params.multi ?? false;
+		const optionLabels = options.map((o) => o.label);
 
-			const details: AskToolDetails = {
-				question,
-				options: optionLabels,
-				multi,
-				selectedOptions,
-				customInput,
+		if (!question || optionLabels.length === 0) {
+			return {
+				content: [{ type: "text" as const, text: "Error: question and options are required" }],
+				details: {},
 			};
+		}
 
-			let responseText: string;
-			if (customInput) {
-				responseText = `User provided custom input: ${customInput}`;
-			} else if (selectedOptions.length > 0) {
-				responseText = multi
-					? `User selected: ${selectedOptions.join(", ")}`
-					: `User selected: ${selectedOptions[0]}`;
-			} else {
-				responseText = "User cancelled the selection";
-			}
+		const { selectedOptions, customInput } = await askSingleQuestion(ui, question, optionLabels, multi);
+
+		const details: AskToolDetails = {
+			question,
+			options: optionLabels,
+			multi,
+			selectedOptions,
+			customInput,
+		};
+
+		let responseText: string;
+		if (customInput) {
+			responseText = `User provided custom input: ${customInput}`;
+		} else if (selectedOptions.length > 0) {
+			responseText = multi ? `User selected: ${selectedOptions.join(", ")}` : `User selected: ${selectedOptions[0]}`;
+		} else {
+			responseText = "User cancelled the selection";
+		}
 
-			return { content: [{ type: "text" as const, text: responseText }], details };
-		},
-	};
+		return { content: [{ type: "text" as const, text: responseText }], details };
+	}
 }
 
-/** Default ask tool - returns null when no UI */
-export const askTool = createAskTool({
-	cwd: process.cwd(),
-	hasUI: false,
-	getSessionFile: () => null,
-	getSessionSpawns: () => "*",
-});
-
 // =============================================================================
 // TUI Renderer
 // =============================================================================

package/src/core/tools/bash.ts

@@ -1,5 +1,5 @@
 import { relative, resolve, sep } from "node:path";
-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, truncateToWidth } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
@@ -52,113 +52,122 @@ export interface BashToolOptions {
 	operations?: BashOperations;
 }
 
-export function createBashTool(session: ToolSession, options?: BashToolOptions): AgentTool<typeof bashSchema> {
-	return {
-		name: "bash",
-		label: "Bash",
-		description: renderPromptTemplate(bashDescription),
-		parameters: bashSchema,
-		execute: async (
-			_toolCallId: string,
-			{ command, timeout, workdir }: { command: string; timeout?: number; workdir?: string },
-			signal?: AbortSignal,
-			onUpdate?,
-			ctx?: AgentToolContext,
-		) => {
-			// Check interception if enabled and available tools are known
-			if (session.settings?.getBashInterceptorEnabled()) {
-				const rules = session.settings?.getBashInterceptorRules?.();
-				const interception = checkBashInterception(command, ctx?.toolNames ?? [], rules);
-				if (interception.block) {
-					throw new Error(interception.message);
-				}
-				if (session.settings?.getBashInterceptorSimpleLsEnabled?.() !== false) {
-					const lsInterception = checkSimpleLsInterception(command, ctx?.toolNames ?? []);
-					if (lsInterception.block) {
-						throw new Error(lsInterception.message);
-					}
+/**
+ * Bash tool implementation.
+ *
+ * Executes bash commands with optional timeout and working directory.
+ * Supports custom operations for remote execution.
+ */
+export class BashTool implements AgentTool<typeof bashSchema, BashToolDetails> {
+	public readonly name = "bash";
+	public readonly label = "Bash";
+	public readonly description: string;
+	public readonly parameters = bashSchema;
+
+	private readonly session: ToolSession;
+	private readonly options?: BashToolOptions;
+
+	constructor(session: ToolSession, options?: BashToolOptions) {
+		this.session = session;
+		this.options = options;
+		this.description = renderPromptTemplate(bashDescription);
+	}
+
+	public async execute(
+		_toolCallId: string,
+		{ command, timeout, workdir }: { command: string; timeout?: number; workdir?: string },
+		signal?: AbortSignal,
+		onUpdate?: AgentToolUpdateCallback<BashToolDetails>,
+		ctx?: AgentToolContext,
+	): Promise<AgentToolResult<BashToolDetails>> {
+		// Check interception if enabled and available tools are known
+		if (this.session.settings?.getBashInterceptorEnabled()) {
+			const rules = this.session.settings?.getBashInterceptorRules?.();
+			const interception = checkBashInterception(command, ctx?.toolNames ?? [], rules);
+			if (interception.block) {
+				throw new Error(interception.message);
+			}
+			if (this.session.settings?.getBashInterceptorSimpleLsEnabled?.() !== false) {
+				const lsInterception = checkSimpleLsInterception(command, ctx?.toolNames ?? []);
+				if (lsInterception.block) {
+					throw new Error(lsInterception.message);
 				}
 			}
+		}
 
-			const commandCwd = workdir ? resolveToCwd(workdir, session.cwd) : session.cwd;
-			let cwdStat: Awaited<ReturnType<Bun.BunFile["stat"]>>;
-			try {
-				cwdStat = await Bun.file(commandCwd).stat();
-			} catch {
-				throw new Error(`Working directory does not exist: ${commandCwd}`);
-			}
-			if (!cwdStat.isDirectory()) {
-				throw new Error(`Working directory is not a directory: ${commandCwd}`);
-			}
+		const commandCwd = workdir ? resolveToCwd(workdir, this.session.cwd) : this.session.cwd;
+		let cwdStat: Awaited<ReturnType<Bun.BunFile["stat"]>>;
+		try {
+			cwdStat = await Bun.file(commandCwd).stat();
+		} catch {
+			throw new Error(`Working directory does not exist: ${commandCwd}`);
+		}
+		if (!cwdStat.isDirectory()) {
+			throw new Error(`Working directory is not a directory: ${commandCwd}`);
+		}
 
-			// Track output for streaming updates
-			let currentOutput = "";
-
-			const executorOptions: BashExecutorOptions = {
-				cwd: commandCwd,
-				timeout: timeout ? timeout * 1000 : undefined, // Convert to milliseconds
-				signal,
-				onChunk: (chunk) => {
-					currentOutput += chunk;
-					if (onUpdate) {
-						const truncation = truncateTail(currentOutput);
-						onUpdate({
-							content: [{ type: "text", text: truncation.content || "" }],
-							details: truncation.truncated
-								? {
-										truncation,
-										fullOutput: currentOutput,
-									}
-								: undefined,
-						});
-					}
-				},
-			};
+		// Track output for streaming updates
+		let currentOutput = "";
+
+		const executorOptions: BashExecutorOptions = {
+			cwd: commandCwd,
+			timeout: timeout ? timeout * 1000 : undefined, // Convert to milliseconds
+			signal,
+			onChunk: (chunk) => {
+				currentOutput += chunk;
+				if (onUpdate) {
+					const truncation = truncateTail(currentOutput);
+					onUpdate({
+						content: [{ type: "text", text: truncation.content || "" }],
+						details: truncation.truncated ? { truncation, fullOutput: currentOutput } : {},
+					});
+				}
+			},
+		};
 
-			// Use custom operations if provided, otherwise use default local executor
-			const result = options?.operations
-				? await executeBashWithOperations(command, commandCwd, options.operations, executorOptions)
-				: await executeBash(command, executorOptions);
+		// Use custom operations if provided, otherwise use default local executor
+		const result = this.options?.operations
+			? await executeBashWithOperations(command, commandCwd, this.options.operations, executorOptions)
+			: await executeBash(command, executorOptions);
 
-			// Handle errors
-			if (result.cancelled) {
-				throw new Error(result.output || "Command aborted");
-			}
+		// Handle errors
+		if (result.cancelled) {
+			throw new Error(result.output || "Command aborted");
+		}
 
-			// Apply tail truncation for final output
-			const truncation = truncateTail(result.output);
-			let outputText = truncation.content || "(no output)";
+		// Apply tail truncation for final output
+		const truncation = truncateTail(result.output);
+		let outputText = truncation.content || "(no output)";
 
-			let details: BashToolDetails | undefined;
+		let details: BashToolDetails | undefined;
 
-			if (truncation.truncated) {
-				details = {
-					truncation,
-					fullOutputPath: result.fullOutputPath,
-					fullOutput: currentOutput,
-				};
+		if (truncation.truncated) {
+			details = {
+				truncation,
+				fullOutputPath: result.fullOutputPath,
+				fullOutput: currentOutput,
+			};
 
-				const startLine = truncation.totalLines - truncation.outputLines + 1;
-				const endLine = truncation.totalLines;
+			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}]`;
-				}
+			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}]`;
 			}
+		}
 
-			if (result.exitCode !== 0 && result.exitCode !== undefined) {
-				outputText += `\n\nCommand exited with code ${result.exitCode}`;
-				throw new Error(outputText);
-			}
+		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 };
-		},
-	};
+		return { content: [{ type: "text", text: outputText }], details };
+	}
 }
 
 // =============================================================================

package/src/core/tools/calculator.ts

@@ -1,4 +1,4 @@
-import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { AgentTool, AgentToolResult } 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";
@@ -390,32 +390,47 @@ function formatResult(value: number): string {
 	return String(value);
 }
 
-export function createCalculatorTool(_session: ToolSession): AgentTool<typeof calculatorSchema> {
-	return {
-		name: "calc",
-		label: "Calc",
-		description: renderPromptTemplate(calculatorDescription),
-		parameters: calculatorSchema,
-		execute: async (
-			_toolCallId: string,
-			{ calculations }: { calculations: Array<{ expression: string; prefix: string; suffix: string }> },
-			signal?: AbortSignal,
-		) => {
-			return untilAborted(signal, async () => {
-				const results = calculations.map((calc) => {
-					const value = evaluateExpression(calc.expression);
-					const output = `${calc.prefix}${formatResult(value)}${calc.suffix}`;
-					return { expression: calc.expression, value, output };
-				});
-
-				const outputText = results.map((result) => result.output).join("\n");
-				return {
-					content: [{ type: "text", text: outputText }],
-					details: { results },
-				};
+// ═══════════════════════════════════════════════════════════════════════════
+// Tool Class
+// ═══════════════════════════════════════════════════════════════════════════
+
+type CalculatorParams = { calculations: Array<{ expression: string; prefix: string; suffix: string }> };
+
+/**
+ * Calculator tool for evaluating mathematical expressions.
+ *
+ * Supports decimal, hex (0x), binary (0b), octal (0o) literals,
+ * standard arithmetic operators, and parentheses.
+ */
+export class CalculatorTool implements AgentTool<typeof calculatorSchema, CalculatorToolDetails> {
+	public readonly name = "calc";
+	public readonly label = "Calc";
+	public readonly description: string;
+	public readonly parameters = calculatorSchema;
+
+	constructor(_session: ToolSession) {
+		this.description = renderPromptTemplate(calculatorDescription);
+	}
+
+	public async execute(
+		_toolCallId: string,
+		{ calculations }: CalculatorParams,
+		signal?: AbortSignal,
+	): Promise<AgentToolResult<CalculatorToolDetails>> {
+		return untilAborted(signal, async () => {
+			const results = calculations.map((calc) => {
+				const value = evaluateExpression(calc.expression);
+				const output = `${calc.prefix}${formatResult(value)}${calc.suffix}`;
+				return { expression: calc.expression, value, output };
 			});
-		},
-	};
+
+			const outputText = results.map((result) => result.output).join("\n");
+			return {
+				content: [{ type: "text", text: outputText }],
+				details: { results },
+			};
+		});
+	}
 }
 
 // =============================================================================