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

package/src/core/extensions/loader.ts

@@ -4,22 +4,26 @@
 
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import * as path from "node:path";
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { ImageContent, Model, TextContent } from "@oh-my-pi/pi-ai";
 import type { KeyId } from "@oh-my-pi/pi-tui";
+import type { TSchema } from "@sinclair/typebox";
 import * as TypeBox from "@sinclair/typebox";
 import { type ExtensionModule, extensionModuleCapability } from "../../capability/extension-module";
 import { loadCapability } from "../../discovery";
 import { expandPath, getExtensionNameFromPath } from "../../discovery/helpers";
 import * as piCodingAgent from "../../index";
-import { createEventBus, type EventBus } from "../event-bus";
+import { EventBus } from "../event-bus";
 import type { ExecOptions } from "../exec";
 import { execCommand } from "../exec";
 import { logger } from "../logger";
+import type { CustomMessage } from "../messages";
 import type {
 	Extension,
 	ExtensionAPI,
 	ExtensionContext,
 	ExtensionFactory,
-	ExtensionRuntime,
+	ExtensionRuntime as IExtensionRuntime,
 	LoadExtensionsResult,
 	MessageRenderer,
 	RegisteredCommand,
@@ -36,147 +40,183 @@ function resolvePath(extPath: string, cwd: string): string {
 
 type HandlerFn = (...args: unknown[]) => Promise<unknown>;
 
+export class ExtensionRuntimeNotInitializedError extends Error {
+	constructor() {
+		super("Extension runtime not initialized. Action methods cannot be called during extension loading.");
+	}
+}
+
 /**
- * Create a runtime with throwing stubs for action methods.
- * Runner.initialize() replaces these with real implementations.
+ * Extension runtime with throwing stubs for action methods.
+ * These are replaced with real implementations during initialization.
  */
-export function createExtensionRuntime(): ExtensionRuntime {
-	const notInitialized = () => {
-		throw new Error("Extension runtime not initialized. Action methods cannot be called during extension loading.");
-	};
+export class ExtensionRuntime implements IExtensionRuntime {
+	flagValues = new Map<string, boolean | string>();
 
-	return {
-		sendMessage: notInitialized,
-		sendUserMessage: notInitialized,
-		appendEntry: notInitialized,
-		setLabel: notInitialized,
-		getActiveTools: notInitialized,
-		getAllTools: notInitialized,
-		setActiveTools: notInitialized,
-		setModel: () => Promise.reject(new Error("Extension runtime not initialized")),
-		getThinkingLevel: notInitialized,
-		setThinkingLevel: notInitialized,
-		flagValues: new Map(),
-	};
+	sendMessage(): void {
+		throw new ExtensionRuntimeNotInitializedError();
+	}
+
+	sendUserMessage(): void {
+		throw new ExtensionRuntimeNotInitializedError();
+	}
+
+	appendEntry(): void {
+		throw new ExtensionRuntimeNotInitializedError();
+	}
+
+	setLabel(): void {
+		throw new ExtensionRuntimeNotInitializedError();
+	}
+
+	getActiveTools(): string[] {
+		throw new ExtensionRuntimeNotInitializedError();
+	}
+
+	getAllTools(): string[] {
+		throw new ExtensionRuntimeNotInitializedError();
+	}
+
+	setActiveTools(): Promise<void> {
+		throw new ExtensionRuntimeNotInitializedError();
+	}
+
+	setModel(): Promise<boolean> {
+		throw new ExtensionRuntimeNotInitializedError();
+	}
+
+	getThinkingLevel(): ThinkingLevel {
+		throw new ExtensionRuntimeNotInitializedError();
+	}
+
+	setThinkingLevel(): void {
+		throw new ExtensionRuntimeNotInitializedError();
+	}
 }
 
 /**
- * Create the ExtensionAPI for an extension.
+ * ExtensionAPI implementation for an extension.
  * Registration methods write to the extension object.
  * Action methods delegate to the shared runtime.
  */
-function createExtensionAPI(
-	extension: Extension,
-	runtime: ExtensionRuntime,
-	cwd: string,
-	eventBus: EventBus,
-): ExtensionAPI {
-	const api = {
-		logger,
-		typebox: TypeBox,
-		pi: piCodingAgent,
-
-		on(event: string, handler: HandlerFn): void {
-			const list = extension.handlers.get(event) ?? [];
-			list.push(handler);
-			extension.handlers.set(event, list);
-		},
-
-		registerTool(tool: ToolDefinition): void {
-			extension.tools.set(tool.name, {
-				definition: tool,
-				extensionPath: extension.path,
-			});
-		},
+class ConcreteExtensionAPI implements ExtensionAPI, IExtensionRuntime {
+	readonly logger = logger;
+	readonly typebox = TypeBox;
+	readonly pi = piCodingAgent;
+	readonly events: EventBus;
+	readonly flagValues = new Map<string, boolean | string>();
+
+	constructor(
+		private extension: Extension,
+		private runtime: IExtensionRuntime,
+		private cwd: string,
+		eventBus: EventBus,
+	) {
+		this.events = eventBus;
+	}
 
-		registerCommand(
-			name: string,
-			options: {
-				description?: string;
-				getArgumentCompletions?: RegisteredCommand["getArgumentCompletions"];
-				handler: RegisteredCommand["handler"];
-			},
-		): void {
-			extension.commands.set(name, { name, ...options });
-		},
+	on<F extends HandlerFn>(event: string, handler: F): void {
+		const list = this.extension.handlers.get(event) ?? [];
+		list.push(handler);
+		this.extension.handlers.set(event, list);
+	}
 
-		setLabel(label: string): void {
-			extension.label = label;
-		},
+	registerTool<TParams extends TSchema = TSchema, TDetails = unknown>(tool: ToolDefinition<TParams, TDetails>): void {
+		this.extension.tools.set(tool.name, {
+			definition: tool,
+			extensionPath: this.extension.path,
+		});
+	}
 
-		registerShortcut(
-			shortcut: KeyId,
-			options: {
-				description?: string;
-				handler: (ctx: ExtensionContext) => Promise<void> | void;
-			},
-		): void {
-			extension.shortcuts.set(shortcut, { shortcut, extensionPath: extension.path, ...options });
+	registerCommand(
+		name: string,
+		options: {
+			description?: string;
+			getArgumentCompletions?: RegisteredCommand["getArgumentCompletions"];
+			handler: RegisteredCommand["handler"];
 		},
+	): void {
+		this.extension.commands.set(name, { name, ...options });
+	}
 
-		registerFlag(
-			name: string,
-			options: { description?: string; type: "boolean" | "string"; default?: boolean | string },
-		): void {
-			extension.flags.set(name, { name, extensionPath: extension.path, ...options });
-			if (options.default !== undefined) {
-				runtime.flagValues.set(name, options.default);
-			}
-		},
+	setLabel(label: string): void {
+		this.extension.label = label;
+	}
 
-		registerMessageRenderer<T>(customType: string, renderer: MessageRenderer<T>): void {
-			extension.messageRenderers.set(customType, renderer as MessageRenderer);
+	registerShortcut(
+		shortcut: KeyId,
+		options: {
+			description?: string;
+			handler: (ctx: ExtensionContext) => Promise<void> | void;
 		},
+	): void {
+		this.extension.shortcuts.set(shortcut, { shortcut, extensionPath: this.extension.path, ...options });
+	}
 
-		getFlag(name: string): boolean | string | undefined {
-			if (!extension.flags.has(name)) return undefined;
-			return runtime.flagValues.get(name);
-		},
+	registerFlag(
+		name: string,
+		options: { description?: string; type: "boolean" | "string"; default?: boolean | string },
+	): void {
+		this.extension.flags.set(name, { name, extensionPath: this.extension.path, ...options });
+		if (options.default !== undefined) {
+			this.runtime.flagValues.set(name, options.default);
+		}
+	}
 
-		sendMessage(message, options): void {
-			runtime.sendMessage(message, options);
-		},
+	registerMessageRenderer<T>(customType: string, renderer: MessageRenderer<T>): void {
+		this.extension.messageRenderers.set(customType, renderer as MessageRenderer);
+	}
 
-		sendUserMessage(content, options): void {
-			runtime.sendUserMessage(content, options);
-		},
+	getFlag(name: string): boolean | string | undefined {
+		if (!this.extension.flags.has(name)) return undefined;
+		return this.runtime.flagValues.get(name);
+	}
 
-		appendEntry(customType: string, data?: unknown): void {
-			runtime.appendEntry(customType, data);
-		},
+	sendMessage<T = unknown>(
+		message: Pick<CustomMessage<T>, "customType" | "content" | "display" | "details">,
+		options?: { triggerTurn?: boolean; deliverAs?: "steer" | "followUp" | "nextTurn" },
+	): void {
+		this.runtime.sendMessage(message, options);
+	}
 
-		exec(command: string, args: string[], options?: ExecOptions) {
-			return execCommand(command, args, options?.cwd ?? cwd, options);
-		},
+	sendUserMessage(
+		content: string | (TextContent | ImageContent)[],
+		options?: { deliverAs?: "steer" | "followUp" },
+	): void {
+		this.runtime.sendUserMessage(content, options);
+	}
 
-		getActiveTools(): string[] {
-			return runtime.getActiveTools();
-		},
+	appendEntry(customType: string, data?: unknown): void {
+		this.runtime.appendEntry(customType, data);
+	}
 
-		getAllTools(): string[] {
-			return runtime.getAllTools();
-		},
+	exec(command: string, args: string[], options?: ExecOptions) {
+		return execCommand(command, args, options?.cwd ?? this.cwd, options);
+	}
 
-		setActiveTools(toolNames: string[]): void {
-			runtime.setActiveTools(toolNames);
-		},
+	getActiveTools(): string[] {
+		return this.runtime.getActiveTools();
+	}
 
-		setModel(model) {
-			return runtime.setModel(model);
-		},
+	getAllTools(): string[] {
+		return this.runtime.getAllTools();
+	}
 
-		getThinkingLevel() {
-			return runtime.getThinkingLevel();
-		},
+	setActiveTools(toolNames: string[]): Promise<void> {
+		return this.runtime.setActiveTools(toolNames);
+	}
 
-		setThinkingLevel(level) {
-			runtime.setThinkingLevel(level);
-		},
+	setModel(model: Model<any>): Promise<boolean> {
+		return this.runtime.setModel(model);
+	}
 
-		events: eventBus,
-	} as ExtensionAPI;
+	getThinkingLevel(): ThinkingLevel {
+		return this.runtime.getThinkingLevel();
+	}
 
-	return api;
+	setThinkingLevel(level: ThinkingLevel): void {
+		this.runtime.setThinkingLevel(level);
+	}
 }
 
 /**
@@ -199,7 +239,7 @@ async function loadExtension(
 	extensionPath: string,
 	cwd: string,
 	eventBus: EventBus,
-	runtime: ExtensionRuntime,
+	runtime: IExtensionRuntime,
 ): Promise<{ extension: Extension | null; error: string | null }> {
 	const resolvedPath = resolvePath(extensionPath, cwd);
 
@@ -215,7 +255,7 @@ async function loadExtension(
 		}
 
 		const extension = createExtension(extensionPath, resolvedPath);
-		const api = createExtensionAPI(extension, runtime, cwd, eventBus);
+		const api = new ConcreteExtensionAPI(extension, runtime, cwd, eventBus);
 		await factory(api);
 
 		return { extension, error: null };
@@ -232,11 +272,11 @@ export async function loadExtensionFromFactory(
 	factory: ExtensionFactory,
 	cwd: string,
 	eventBus: EventBus,
-	runtime: ExtensionRuntime,
+	runtime: IExtensionRuntime,
 	name = "<inline>",
 ): Promise<Extension> {
 	const extension = createExtension(name, name);
-	const api = createExtensionAPI(extension, runtime, cwd, eventBus);
+	const api = new ConcreteExtensionAPI(extension, runtime, cwd, eventBus);
 	await factory(api);
 	return extension;
 }
@@ -247,8 +287,8 @@ export async function loadExtensionFromFactory(
 export async function loadExtensions(paths: string[], cwd: string, eventBus?: EventBus): Promise<LoadExtensionsResult> {
 	const extensions: Extension[] = [];
 	const errors: Array<{ path: string; error: string }> = [];
-	const resolvedEventBus = eventBus ?? createEventBus();
-	const runtime = createExtensionRuntime();
+	const resolvedEventBus = eventBus ?? new EventBus();
+	const runtime = new ExtensionRuntime();
 
 	for (const extPath of paths) {
 		const { extension, error } = await loadExtension(extPath, cwd, resolvedEventBus, runtime);

package/src/core/extensions/types.ts

@@ -30,7 +30,7 @@ import type {
 } from "../session-manager";
 import type { BashToolDetails, FindToolDetails, GrepToolDetails, LsToolDetails, ReadToolDetails } from "../tools";
 import type { BashOperations } from "../tools/bash";
-import type { EditToolDetails } from "../tools/edit";
+import type { EditToolDetails } from "../tools/patch";
 
 export type { ExecOptions, ExecResult } from "../exec";
 export type { AgentToolResult, AgentToolUpdateCallback };
@@ -779,8 +779,8 @@ export type ExtensionFactory = (pi: ExtensionAPI) => void | Promise<void>;
 // Loaded Extension Types
 // ============================================================================
 
-export interface RegisteredTool {
-	definition: ToolDefinition;
+export interface RegisteredTool<TParams extends TSchema = TSchema, TDetails = unknown> {
+	definition: ToolDefinition<TParams, TDetails>;
 	extensionPath: string;
 }
 
@@ -877,7 +877,7 @@ export interface Extension {
 	resolvedPath: string;
 	label?: string;
 	handlers: Map<string, HandlerFn[]>;
-	tools: Map<string, RegisteredTool>;
+	tools: Map<string, RegisteredTool<any, any>>;
 	messageRenderers: Map<string, MessageRenderer>;
 	commands: Map<string, RegisteredCommand>;
 	flags: Map<string, ExtensionFlag>;

package/src/core/extensions/wrapper.ts

@@ -9,27 +9,53 @@ import type { ExtensionRunner } from "./runner";
 import type { RegisteredTool, ToolCallEventResult, ToolResultEventResult } from "./types";
 
 /**
- * Wrap a RegisteredTool into an AgentTool.
+ * Adapts a RegisteredTool into an AgentTool.
+ */
+export class RegisteredToolAdapter implements AgentTool<any, any, any> {
+	readonly name: string;
+	readonly label: string;
+	readonly description: string;
+	readonly parameters: any;
+
+	constructor(
+		private registeredTool: RegisteredTool,
+		private runner: ExtensionRunner,
+	) {
+		const { definition } = registeredTool;
+		this.name = definition.name;
+		this.label = definition.label || "";
+		this.description = definition.description;
+		this.parameters = definition.parameters;
+	}
+
+	async execute(
+		toolCallId: string,
+		params: any,
+		signal?: AbortSignal,
+		onUpdate?: AgentToolUpdateCallback<any>,
+		_context?: AgentToolContext,
+	) {
+		return this.registeredTool.definition.execute(toolCallId, params, onUpdate, this.runner.createContext(), signal);
+	}
+
+	renderCall?(args: any, theme: any) {
+		return this.registeredTool.definition.renderCall?.(args, theme as Theme);
+	}
+
+	renderResult?(result: any, options: any, theme: any) {
+		return this.registeredTool.definition.renderResult?.(
+			result,
+			{ expanded: options.expanded, isPartial: options.isPartial, spinnerFrame: options.spinnerFrame },
+			theme as Theme,
+		);
+	}
+}
+
+/**
+ * Backward-compatible factory function wrapper.
  */
 export function wrapRegisteredTool(registeredTool: RegisteredTool, runner: ExtensionRunner): AgentTool {
-	const { definition } = registeredTool;
-	return {
-		name: definition.name,
-		label: definition.label,
-		description: definition.description,
-		parameters: definition.parameters,
-		execute: (toolCallId, params, signal, onUpdate) =>
-			definition.execute(toolCallId, params, onUpdate, runner.createContext(), signal),
-		renderCall: definition.renderCall ? (args, theme) => definition.renderCall?.(args, theme as Theme) : undefined,
-		renderResult: definition.renderResult
-			? (result, options, theme) =>
-					definition.renderResult?.(
-						result,
-						{ expanded: options.expanded, isPartial: options.isPartial, spinnerFrame: options.spinnerFrame },
-						theme as Theme,
-					)
-			: undefined,
-	};
+	return new RegisteredToolAdapter(registeredTool, runner);
 }
 
 /**
@@ -40,98 +66,121 @@ export function wrapRegisteredTools(registeredTools: RegisteredTool[], runner: E
 }
 
 /**
- * Wrap a tool with extension callbacks for interception.
+ * Wraps a tool with extension callbacks for interception.
  * - Emits tool_call event before execution (can block)
  * - Emits tool_result event after execution (can modify result)
  */
-export function wrapToolWithExtensions<T>(tool: AgentTool<any, T>, runner: ExtensionRunner): AgentTool<any, T> {
-	return {
-		...tool,
-		execute: async (
-			toolCallId: string,
-			params: Record<string, unknown>,
-			signal?: AbortSignal,
-			onUpdate?: AgentToolUpdateCallback<T>,
-			context?: AgentToolContext,
-		) => {
-			// Emit tool_call event - extensions can block execution
-			if (runner.hasHandlers("tool_call")) {
-				try {
-					const callResult = (await runner.emitToolCall({
-						type: "tool_call",
-						toolName: tool.name,
-						toolCallId,
-						input: params,
-					})) as ToolCallEventResult | undefined;
-
-					if (callResult?.block) {
-						const reason = callResult.reason || "Tool execution was blocked by an extension";
-						throw new Error(reason);
-					}
-				} catch (err) {
-					if (err instanceof Error) {
-						throw err;
-					}
-					throw new Error(`Extension failed, blocking execution: ${String(err)}`);
-				}
-			}
+export class ExtensionToolWrapper<T> implements AgentTool<any, T> {
+	name: string;
+	label: string;
+	description: string;
+	parameters: unknown;
+	renderCall?: AgentTool["renderCall"];
+	renderResult?: AgentTool["renderResult"];
 
-			// Execute the actual tool
-			let result: { content: any; details: T };
-			let executionError: Error | undefined;
+	constructor(
+		private tool: AgentTool<any, T>,
+		private runner: ExtensionRunner,
+	) {
+		this.name = tool.name;
+		this.label = tool.label ?? "";
+		this.description = tool.description;
+		this.parameters = tool.parameters;
+		this.renderCall = tool.renderCall;
+		this.renderResult = tool.renderResult;
+	}
 
+	async execute(
+		toolCallId: string,
+		params: Record<string, unknown>,
+		signal?: AbortSignal,
+		onUpdate?: AgentToolUpdateCallback<T>,
+		context?: AgentToolContext,
+	) {
+		// Emit tool_call event - extensions can block execution
+		if (this.runner.hasHandlers("tool_call")) {
 			try {
-				result = await tool.execute(toolCallId, params, signal, onUpdate, context);
+				const callResult = (await this.runner.emitToolCall({
+					type: "tool_call",
+					toolName: this.tool.name,
+					toolCallId,
+					input: params,
+				})) as ToolCallEventResult | undefined;
+
+				if (callResult?.block) {
+					const reason = callResult.reason || "Tool execution was blocked by an extension";
+					throw new Error(reason);
+				}
 			} catch (err) {
-				executionError = err instanceof Error ? err : new Error(String(err));
-				result = {
-					content: [{ type: "text", text: executionError.message }],
-					details: undefined as T,
-				};
+				if (err instanceof Error) {
+					throw err;
+				}
+				throw new Error(`Extension failed, blocking execution: ${String(err)}`);
 			}
+		}
 
-			// Emit tool_result event - extensions can modify the result and error status
-			if (runner.hasHandlers("tool_result")) {
-				const resultResult = (await runner.emit({
-					type: "tool_result",
-					toolName: tool.name,
-					toolCallId,
-					input: params,
-					content: result.content,
-					details: result.details,
-					isError: !!executionError,
-				})) as ToolResultEventResult | undefined;
-
-				if (resultResult) {
-					const modifiedContent: (TextContent | ImageContent)[] = resultResult.content ?? result.content;
-					const modifiedDetails = (resultResult.details ?? result.details) as T;
-
-					// Extension can override error status
-					if (resultResult.isError === true && !executionError) {
-						// Extension marks a successful result as error
-						const textBlocks = (modifiedContent ?? []).filter((c): c is TextContent => c.type === "text");
-						const errorText =
-							textBlocks.map((t) => t.text).join("\n") || "Tool result marked as error by extension";
-						throw new Error(errorText);
-					}
-					if (resultResult.isError === false && executionError) {
-						// Extension clears the error - return success
-						return { content: modifiedContent, details: modifiedDetails };
-					}
-
-					// Error status unchanged, but content/details may be modified
-					if (executionError) {
-						throw executionError;
-					}
+		// Execute the actual tool
+		let result: { content: any; details?: T };
+		let executionError: Error | undefined;
+
+		try {
+			result = await this.tool.execute(toolCallId, params, signal, onUpdate, context);
+		} catch (err) {
+			executionError = err instanceof Error ? err : new Error(String(err));
+			result = {
+				content: [{ type: "text", text: executionError.message }],
+				details: undefined as T,
+			};
+		}
+
+		// Emit tool_result event - extensions can modify the result and error status
+		if (this.runner.hasHandlers("tool_result")) {
+			const resultResult = (await this.runner.emit({
+				type: "tool_result",
+				toolName: this.tool.name,
+				toolCallId,
+				input: params,
+				content: result.content,
+				details: result.details,
+				isError: !!executionError,
+			})) as ToolResultEventResult | undefined;
+
+			if (resultResult) {
+				const modifiedContent: (TextContent | ImageContent)[] = resultResult.content ?? result.content;
+				const modifiedDetails = (resultResult.details ?? result.details) as T;
+
+				// Extension can override error status
+				if (resultResult.isError === true && !executionError) {
+					// Extension marks a successful result as error
+					const textBlocks = (modifiedContent ?? []).filter((c): c is TextContent => c.type === "text");
+					const errorText = textBlocks.map((t) => t.text).join("\n") || "Tool result marked as error by extension";
+					throw new Error(errorText);
+				}
+				if (resultResult.isError === false && executionError) {
+					// Extension clears the error - return success
 					return { content: modifiedContent, details: modifiedDetails };
 				}
-			}
 
-			// No extension modification
-			if (executionError) {
-				throw executionError;
+				// Error status unchanged, but content/details may be modified
+				if (executionError) {
+					throw executionError;
+				}
+				return { content: modifiedContent, details: modifiedDetails };
 			}
-			return result;
-		},
-	};
+		}
+
+		// No extension modification
+		if (executionError) {
+			throw executionError;
+		}
+		return result;
+	}
+}
+
+/**
+ * Wrap a tool with extension callbacks for interception.
+ * @deprecated Use `new ExtensionToolWrapper()` directly
+ */
+export function wrapToolWithExtensions<T>(tool: AgentTool<any, T>, runner: ExtensionRunner): AgentTool<any, T> {
+	return new ExtensionToolWrapper(tool, runner);
 }