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

package/src/core/custom-tools/loader.ts

@@ -17,7 +17,7 @@ import { execCommand } from "../exec";
 import type { HookUIContext } from "../hooks/types";
 import { logger } from "../logger";
 import { getAllPluginToolPaths } from "../plugins/loader";
-import type { CustomToolAPI, CustomToolFactory, CustomToolsLoadResult, LoadedCustomTool } from "./types";
+import type { CustomToolAPI, CustomToolFactory, LoadedCustomTool, ToolLoadError } from "./types";
 
 /**
  * Resolve tool path.
@@ -56,13 +56,6 @@ function createNoOpUIContext(): HookUIContext {
 	};
 }
 
-/** Error with source metadata */
-interface ToolLoadError {
-	path: string;
-	error: string;
-	source?: { provider: string; providerName: string; level: "user" | "project" };
-}
-
 /**
  * Load a single tool module using native Bun import.
  */
@@ -118,64 +111,80 @@ interface ToolPathWithSource {
 }
 
 /**
- * Load all tools from configuration.
- * @param pathsWithSources - Array of tool paths with optional source metadata
- * @param cwd - Current working directory for resolving relative paths
- * @param builtInToolNames - Names of built-in tools to check for conflicts
+ * Loads custom tools from paths with conflict detection and error handling.
+ *
+ * Manages a shared API instance passed to all tool factories, providing access to
+ * execution context, UI, logger, and injected dependencies. The UI context can be
+ * updated after loading via setUIContext().
  */
-export async function loadCustomTools(
-	pathsWithSources: ToolPathWithSource[],
-	cwd: string,
-	builtInToolNames: string[],
-): Promise<CustomToolsLoadResult> {
-	const tools: LoadedCustomTool[] = [];
-	const errors: ToolLoadError[] = [];
-	const seenNames = new Set<string>(builtInToolNames);
-
-	// Shared API object - all tools get the same instance
-	const sharedApi: CustomToolAPI = {
-		cwd,
-		exec: (command: string, args: string[], options?: ExecOptions) =>
-			execCommand(command, args, options?.cwd ?? cwd, options),
-		ui: createNoOpUIContext(),
-		hasUI: false,
-		logger,
-		typebox,
-		pi: piCodingAgent,
-	};
+export class CustomToolLoader {
+	tools: LoadedCustomTool[] = [];
+	errors: ToolLoadError[] = [];
+	private sharedApi: CustomToolAPI;
+	private seenNames: Set<string>;
+
+	constructor(cwd: string, builtInToolNames: string[]) {
+		this.sharedApi = {
+			cwd,
+			exec: (command: string, args: string[], options?: ExecOptions) =>
+				execCommand(command, args, options?.cwd ?? cwd, options),
+			ui: createNoOpUIContext(),
+			hasUI: false,
+			logger,
+			typebox,
+			pi: piCodingAgent,
+		};
+		this.seenNames = new Set<string>(builtInToolNames);
+	}
 
-	for (const { path: toolPath, source } of pathsWithSources) {
-		const { tools: loadedTools, error } = await loadTool(toolPath, cwd, sharedApi, source);
+	async load(pathsWithSources: ToolPathWithSource[]): Promise<void> {
+		for (const { path: toolPath, source } of pathsWithSources) {
+			const { tools: loadedTools, error } = await loadTool(toolPath, this.sharedApi.cwd, this.sharedApi, source);
 
-		if (error) {
-			errors.push(error);
-			continue;
-		}
+			if (error) {
+				this.errors.push(error);
+				continue;
+			}
 
-		if (loadedTools) {
-			for (const loadedTool of loadedTools) {
-				// Check for name conflicts
-				if (seenNames.has(loadedTool.tool.name)) {
-					errors.push({
-						path: toolPath,
-						error: `Tool name "${loadedTool.tool.name}" conflicts with existing tool`,
-						source,
-					});
-					continue;
+			if (loadedTools) {
+				for (const loadedTool of loadedTools) {
+					// Check for name conflicts
+					if (this.seenNames.has(loadedTool.tool.name)) {
+						this.errors.push({
+							path: toolPath,
+							error: `Tool name "${loadedTool.tool.name}" conflicts with existing tool`,
+							source,
+						});
+						continue;
+					}
+
+					this.seenNames.add(loadedTool.tool.name);
+					this.tools.push(loadedTool);
 				}
-
-				seenNames.add(loadedTool.tool.name);
-				tools.push(loadedTool);
 			}
 		}
 	}
 
+	setUIContext(uiContext: HookUIContext, hasUI: boolean): void {
+		this.sharedApi.ui = uiContext;
+		this.sharedApi.hasUI = hasUI;
+	}
+}
+
+/**
+ * Load all tools from configuration.
+ * @param pathsWithSources - Array of tool paths with optional source metadata
+ * @param cwd - Current working directory for resolving relative paths
+ * @param builtInToolNames - Names of built-in tools to check for conflicts
+ */
+export async function loadCustomTools(pathsWithSources: ToolPathWithSource[], cwd: string, builtInToolNames: string[]) {
+	const loader = new CustomToolLoader(cwd, builtInToolNames);
+	await loader.load(pathsWithSources);
 	return {
-		tools,
-		errors,
-		setUIContext(uiContext, hasUI) {
-			sharedApi.ui = uiContext;
-			sharedApi.hasUI = hasUI;
+		tools: loader.tools,
+		errors: loader.errors,
+		setUIContext: (uiContext: HookUIContext, hasUI: boolean) => {
+			loader.setUIContext(uiContext, hasUI);
 		},
 	};
 }
@@ -190,11 +199,7 @@ export async function loadCustomTools(
  * @param cwd - Current working directory
  * @param builtInToolNames - Names of built-in tools to check for conflicts
  */
-export async function discoverAndLoadCustomTools(
-	configuredPaths: string[],
-	cwd: string,
-	builtInToolNames: string[],
-): Promise<CustomToolsLoadResult> {
+export async function discoverAndLoadCustomTools(configuredPaths: string[], cwd: string, builtInToolNames: string[]) {
 	const allPathsWithSources: ToolPathWithSource[] = [];
 	const seen = new Set<string>();
 

package/src/core/custom-tools/types.ts

@@ -138,10 +138,10 @@ export interface CustomTool<TParams extends TSchema = TSchema, TDetails = any> {
 	execute(
 		toolCallId: string,
 		params: Static<TParams>,
-		onUpdate: AgentToolUpdateCallback<TDetails> | undefined,
+		onUpdate: AgentToolUpdateCallback<TDetails, TParams> | undefined,
 		ctx: CustomToolContext,
 		signal?: AbortSignal,
-	): Promise<AgentToolResult<TDetails>>;
+	): Promise<AgentToolResult<TDetails, TParams>>;
 
 	/** Called on session lifecycle events - use to reconstruct state or cleanup resources */
 	onSession?: (event: CustomToolSessionEvent, ctx: CustomToolContext) => void | Promise<void>;
@@ -158,13 +158,13 @@ export type CustomToolFactory = (
 ) => CustomTool<any, any> | CustomTool<any, any>[] | Promise<CustomTool<any, any> | CustomTool<any, any>[]>;
 
 /** Loaded custom tool with metadata and wrapped AgentTool */
-export interface LoadedCustomTool {
+export interface LoadedCustomTool<TParams extends TSchema = TSchema, TDetails = any> {
 	/** Original path (as specified) */
 	path: string;
 	/** Resolved absolute path */
 	resolvedPath: string;
 	/** The original custom tool instance */
-	tool: CustomTool;
+	tool: CustomTool<TParams, TDetails>;
 	/** Source metadata (provider and level) */
 	source?: { provider: string; providerName: string; level: "user" | "project" };
 }

package/src/core/custom-tools/wrapper.ts

@@ -1,33 +1,69 @@
 /**
- * Wraps CustomTool instances into AgentTool for use with the agent.
+ * CustomToolAdapter wraps CustomTool instances into AgentTool for use with the agent.
  */
 
-import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { AgentTool, AgentToolResult, AgentToolUpdateCallback, RenderResultOptions } from "@oh-my-pi/pi-agent-core";
+import type { Component } from "@oh-my-pi/pi-tui";
+import type { Static, TSchema } from "@sinclair/typebox";
 import type { Theme } from "../../modes/interactive/theme/theme";
 import type { CustomTool, CustomToolContext, LoadedCustomTool } from "./types";
 
-/**
- * Wrap a CustomTool into an AgentTool.
- * The wrapper injects the ToolContext into execute calls.
- */
-export function wrapCustomTool(tool: CustomTool, getContext: () => CustomToolContext): AgentTool {
-	return {
-		name: tool.name,
-		label: tool.label,
-		description: tool.description,
-		parameters: tool.parameters,
-		execute: (toolCallId, params, signal, onUpdate, context) =>
-			tool.execute(toolCallId, params, onUpdate, context ?? getContext(), signal),
-		renderCall: tool.renderCall ? (args, theme) => tool.renderCall?.(args, theme as Theme) : undefined,
-		renderResult: tool.renderResult
-			? (result, options, theme) => tool.renderResult?.(result, options, theme as Theme)
-			: undefined,
-	};
-}
+export class CustomToolAdapter<TParams extends TSchema = TSchema, TDetails = any, TTheme extends Theme = Theme>
+	implements AgentTool<TParams, TDetails, TTheme>
+{
+	name: string;
+	label: string;
+	description: string;
+	parameters: TParams;
 
-/**
- * Wrap all loaded custom tools into AgentTools.
- */
-export function wrapCustomTools(loadedTools: LoadedCustomTool[], getContext: () => CustomToolContext): AgentTool[] {
-	return loadedTools.map((lt) => wrapCustomTool(lt.tool, getContext));
+	constructor(
+		private tool: CustomTool<TParams, TDetails>,
+		private getContext: () => CustomToolContext,
+	) {
+		this.name = tool.name;
+		this.label = tool.label ?? "";
+		this.description = tool.description;
+		this.parameters = tool.parameters;
+	}
+
+	execute(
+		toolCallId: string,
+		params: Static<TParams>,
+		signal?: AbortSignal,
+		onUpdate?: AgentToolUpdateCallback<TDetails, TParams>,
+		context?: CustomToolContext,
+	) {
+		return this.tool.execute(toolCallId, params, onUpdate, context ?? this.getContext(), signal);
+	}
+
+	/** Optional custom rendering for tool call display (returns UI component) */
+	renderCall(args: Static<TParams>, theme: TTheme): Component | undefined {
+		return this.tool.renderCall?.(args, theme);
+	}
+
+	/** Optional custom rendering for tool result display (returns UI component) */
+	renderResult(result: AgentToolResult<TDetails>, options: RenderResultOptions, theme: TTheme): Component | undefined {
+		return this.tool.renderResult?.(result, options, theme);
+	}
+
+	/**
+	 * Backward-compatible export of factory function for existing callers.
+	 * Prefer CustomToolAdapter constructor directly.
+	 */
+	static wrap<TParams extends TSchema = TSchema, TDetails = any, TTheme extends Theme = Theme>(
+		tool: CustomTool<TParams, TDetails>,
+		getContext: () => CustomToolContext,
+	): AgentTool<TParams, TDetails, TTheme> {
+		return new CustomToolAdapter(tool, getContext);
+	}
+
+	/**
+	 * Wrap all loaded custom tools into AgentTools.
+	 */
+	static wrapTools<TParams extends TSchema = TSchema, TDetails = any, TTheme extends Theme = Theme>(
+		loadedTools: LoadedCustomTool<TParams, TDetails>[],
+		getContext: () => CustomToolContext,
+	): AgentTool<TParams, TDetails, TTheme>[] {
+		return loadedTools.map((lt) => CustomToolAdapter.wrap(lt.tool, getContext));
+	}
 }

package/src/core/event-bus.ts

@@ -1,27 +1,7 @@
-export interface EventBus {
-	emit(channel: string, data: unknown): void;
-	on(channel: string, handler: (data: unknown) => void): () => void;
-}
-
-export interface EventBusController extends EventBus {
-	clear(): void;
-}
-
-class SimpleEventEmitter {
-	private listeners = new Map<string, Set<(data: unknown) => void>>();
-
-	on(channel: string, handler: (data: unknown) => void): void {
-		if (!this.listeners.has(channel)) {
-			this.listeners.set(channel, new Set());
-		}
-		this.listeners.get(channel)!.add(handler);
-	}
+export class EventBus {
+	private readonly listeners = new Map<string, Set<(data: unknown) => void>>();
 
-	off(channel: string, handler: (data: unknown) => void): void {
-		this.listeners.get(channel)?.delete(handler);
-	}
-
-	emit(channel: string, data: unknown): void {
+	public emit(channel: string, data: unknown): void {
 		const handlers = this.listeners.get(channel);
 		if (handlers) {
 			for (const handler of handlers) {
@@ -30,30 +10,22 @@ class SimpleEventEmitter {
 		}
 	}
 
-	removeAllListeners(): void {
-		this.listeners.clear();
+	public on(channel: string, handler: (data: unknown) => void): () => void {
+		if (!this.listeners.has(channel)) {
+			this.listeners.set(channel, new Set());
+		}
+		const safeHandler = async (data: unknown) => {
+			try {
+				await handler(data);
+			} catch (err) {
+				console.error(`Event handler error (${channel}):`, err);
+			}
+		};
+		this.listeners.get(channel)!.add(safeHandler);
+		return () => this.listeners.get(channel)?.delete(safeHandler);
 	}
-}
 
-export function createEventBus(): EventBusController {
-	const emitter = new SimpleEventEmitter();
-	return {
-		emit: (channel, data) => {
-			emitter.emit(channel, data);
-		},
-		on: (channel, handler) => {
-			const safeHandler = async (data: unknown) => {
-				try {
-					await handler(data);
-				} catch (err) {
-					console.error(`Event handler error (${channel}):`, err);
-				}
-			};
-			emitter.on(channel, safeHandler);
-			return () => emitter.off(channel, safeHandler);
-		},
-		clear: () => {
-			emitter.removeAllListeners();
-		},
-	};
+	public clear(): void {
+		this.listeners.clear();
+	}
 }

package/src/core/extensions/index.ts

@@ -2,7 +2,7 @@
  * Extension system for lifecycle events and custom tools.
  */
 
-export { createExtensionRuntime, discoverAndLoadExtensions, loadExtensionFromFactory, loadExtensions } from "./loader";
+export { discoverAndLoadExtensions, ExtensionRuntime, loadExtensionFromFactory, loadExtensions } from "./loader";
 export type {
 	BranchHandler,
 	ExtensionErrorListener,
@@ -32,7 +32,6 @@ export type {
 	ExecResult,
 	Extension,
 	ExtensionActions,
-	// API
 	ExtensionAPI,
 	ExtensionCommandContext,
 	ExtensionCommandContextActions,
@@ -45,7 +44,6 @@ export type {
 	ExtensionFactory,
 	ExtensionFlag,
 	ExtensionHandler,
-	ExtensionRuntime,
 	ExtensionShortcut,
 	ExtensionUIContext,
 	ExtensionUIDialogOptions,
@@ -112,4 +110,10 @@ export {
 	isReadToolResult,
 	isWriteToolResult,
 } from "./types";
-export { wrapRegisteredTool, wrapRegisteredTools, wrapToolWithExtensions } from "./wrapper";
+export {
+	ExtensionToolWrapper,
+	RegisteredToolAdapter,
+	wrapRegisteredTool,
+	wrapRegisteredTools,
+	wrapToolWithExtensions,
+} from "./wrapper";