@oh-my-pi/pi-coding-agent 3.15.0 → 3.20.0

package/src/core/extensions/wrapper.ts

@@ -0,0 +1,147 @@
+/**
+ * Tool wrappers for extensions.
+ */
+
+import type { AgentTool, AgentToolContext, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
+import type { Theme } from "../../modes/interactive/theme/theme";
+import type { ExtensionRunner } from "./runner";
+import type { ExtensionContext, RegisteredTool, ToolCallEventResult, ToolResultEventResult } from "./types";
+
+/**
+ * Wrap a RegisteredTool into an AgentTool.
+ */
+export function wrapRegisteredTool(registeredTool: RegisteredTool, getContext: () => ExtensionContext): 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, getContext(), 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,
+	};
+}
+
+/**
+ * Wrap all registered tools into AgentTools.
+ */
+export function wrapRegisteredTools(
+	registeredTools: RegisteredTool[],
+	getContext: () => ExtensionContext,
+): AgentTool[] {
+	return registeredTools.map((rt) => wrapRegisteredTool(rt, getContext));
+}
+
+/**
+ * Wrap 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)}`);
+				}
+			}
+
+			// Execute the actual tool
+			let result: { content: any; details: T };
+			let executionError: Error | undefined;
+
+			try {
+				result = await 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 (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;
+					}
+					return { content: modifiedContent, details: modifiedDetails };
+				}
+			}
+
+			// No extension modification
+			if (executionError) {
+				throw executionError;
+			}
+			return result;
+		},
+	};
+}
+
+/**
+ * Wrap all tools with extension callbacks.
+ */
+export function wrapToolsWithExtensions<T>(tools: AgentTool<any, T>[], runner: ExtensionRunner): AgentTool<any, T>[] {
+	return tools.map((tool) => wrapToolWithExtensions(tool, runner));
+}

package/src/core/hooks/types.ts

@@ -268,7 +268,7 @@ export interface SessionCompactEvent {
 	type: "session_compact";
 	compactionEntry: CompactionEntry;
 	/** Whether the compaction entry was provided by a hook */
-	fromHook: boolean;
+	fromExtension: boolean;
 }
 
 /** Fired on process exit (SIGINT/SIGTERM) */
@@ -309,7 +309,7 @@ export interface SessionTreeEvent {
 	/** Branch summary entry if one was created */
 	summaryEntry?: BranchSummaryEntry;
 	/** Whether summary came from hook */
-	fromHook?: boolean;
+	fromExtension?: boolean;
 }
 
 /** Union of all session event types */

package/src/core/index.ts

@@ -14,27 +14,16 @@ export {
 export { type BashExecutorOptions, type BashResult, executeBash } from "./bash-executor";
 export type { CompactionResult } from "./compaction/index";
 export {
-	type CustomTool,
-	type CustomToolAPI,
-	type CustomToolFactory,
-	type CustomToolsLoadResult,
-	type CustomToolUIContext,
-	discoverAndLoadCustomTools,
-	type ExecResult,
-	type LoadedCustomTool,
-	loadCustomTools,
-	type RenderResultOptions,
-} from "./custom-tools/index";
-export {
-	type HookAPI,
-	type HookContext,
-	type HookError,
-	type HookEvent,
-	type HookFactory,
-	HookRunner,
-	type HookUIContext,
-	loadHooks,
-} from "./hooks/index";
+	discoverAndLoadExtensions,
+	type ExtensionAPI,
+	type ExtensionCommandContext,
+	type ExtensionContext,
+	type ExtensionFactory,
+	ExtensionRunner,
+	type ExtensionUIContext,
+	loadExtensionFromFactory,
+	type ToolDefinition,
+} from "./extensions/index";
 export {
 	createMCPManager,
 	discoverAndLoadMCPTools,

package/src/core/keybindings.ts

@@ -0,0 +1,199 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import {
+	DEFAULT_EDITOR_KEYBINDINGS,
+	type EditorAction,
+	type EditorKeybindingsConfig,
+	EditorKeybindingsManager,
+	type KeyId,
+	matchesKey,
+	setEditorKeybindings,
+} from "@oh-my-pi/pi-tui";
+import { getAgentDir } from "../config";
+
+/**
+ * Application-level actions (coding agent specific).
+ */
+export type AppAction =
+	| "interrupt"
+	| "clear"
+	| "exit"
+	| "suspend"
+	| "cycleThinkingLevel"
+	| "cycleModelForward"
+	| "cycleModelBackward"
+	| "selectModel"
+	| "expandTools"
+	| "toggleThinking"
+	| "externalEditor"
+	| "followUp";
+
+/**
+ * All configurable actions.
+ */
+export type KeyAction = AppAction | EditorAction;
+
+/**
+ * Full keybindings configuration (app + editor actions).
+ */
+export type KeybindingsConfig = {
+	[K in KeyAction]?: KeyId | KeyId[];
+};
+
+/**
+ * Default application keybindings.
+ */
+export const DEFAULT_APP_KEYBINDINGS: Record<AppAction, KeyId | KeyId[]> = {
+	interrupt: "escape",
+	clear: "ctrl+c",
+	exit: "ctrl+d",
+	suspend: "ctrl+z",
+	cycleThinkingLevel: "shift+tab",
+	cycleModelForward: "ctrl+p",
+	cycleModelBackward: "shift+ctrl+p",
+	selectModel: "ctrl+l",
+	expandTools: "ctrl+o",
+	toggleThinking: "ctrl+t",
+	externalEditor: "ctrl+g",
+	followUp: "alt+enter",
+};
+
+/**
+ * All default keybindings (app + editor).
+ */
+export const DEFAULT_KEYBINDINGS: Required<KeybindingsConfig> = {
+	...DEFAULT_EDITOR_KEYBINDINGS,
+	...DEFAULT_APP_KEYBINDINGS,
+};
+
+// App actions list for type checking
+const APP_ACTIONS: AppAction[] = [
+	"interrupt",
+	"clear",
+	"exit",
+	"suspend",
+	"cycleThinkingLevel",
+	"cycleModelForward",
+	"cycleModelBackward",
+	"selectModel",
+	"expandTools",
+	"toggleThinking",
+	"externalEditor",
+	"followUp",
+];
+
+function isAppAction(action: string): action is AppAction {
+	return APP_ACTIONS.includes(action as AppAction);
+}
+
+/**
+ * Manages all keybindings (app + editor).
+ */
+export class KeybindingsManager {
+	private config: KeybindingsConfig;
+	private appActionToKeys: Map<AppAction, KeyId[]>;
+
+	private constructor(config: KeybindingsConfig) {
+		this.config = config;
+		this.appActionToKeys = new Map();
+		this.buildMaps();
+	}
+
+	/**
+	 * Create from config file and set up editor keybindings.
+	 */
+	static async create(agentDir: string = getAgentDir()): Promise<KeybindingsManager> {
+		const configPath = join(agentDir, "keybindings.json");
+		const config = await KeybindingsManager.loadFromFile(configPath);
+		const manager = new KeybindingsManager(config);
+
+		// Set up editor keybindings globally
+		const editorConfig: EditorKeybindingsConfig = {};
+		for (const [action, keys] of Object.entries(config)) {
+			if (!isAppAction(action)) {
+				editorConfig[action as EditorAction] = keys;
+			}
+		}
+		setEditorKeybindings(new EditorKeybindingsManager(editorConfig));
+
+		return manager;
+	}
+
+	/**
+	 * Create in-memory.
+	 */
+	static inMemory(config: KeybindingsConfig = {}): KeybindingsManager {
+		return new KeybindingsManager(config);
+	}
+
+	private static async loadFromFile(path: string): Promise<KeybindingsConfig> {
+		if (!existsSync(path)) return {};
+		try {
+			return JSON.parse(readFileSync(path, "utf-8"));
+		} catch {
+			return {};
+		}
+	}
+
+	private buildMaps(): void {
+		this.appActionToKeys.clear();
+
+		// Set defaults for app actions
+		for (const [action, keys] of Object.entries(DEFAULT_APP_KEYBINDINGS)) {
+			const keyArray = Array.isArray(keys) ? keys : [keys];
+			this.appActionToKeys.set(action as AppAction, [...keyArray]);
+		}
+
+		// Override with user config (app actions only)
+		for (const [action, keys] of Object.entries(this.config)) {
+			if (keys === undefined || !isAppAction(action)) continue;
+			const keyArray = Array.isArray(keys) ? keys : [keys];
+			this.appActionToKeys.set(action, keyArray);
+		}
+	}
+
+	/**
+	 * Check if input matches an app action.
+	 */
+	matches(data: string, action: AppAction): boolean {
+		const keys = this.appActionToKeys.get(action);
+		if (!keys) return false;
+		for (const key of keys) {
+			if (matchesKey(data, key)) return true;
+		}
+		return false;
+	}
+
+	/**
+	 * Get keys bound to an app action.
+	 */
+	getKeys(action: AppAction): KeyId[] {
+		return this.appActionToKeys.get(action) ?? [];
+	}
+
+	/**
+	 * Get display string for an action.
+	 */
+	getDisplayString(action: AppAction): string {
+		const keys = this.getKeys(action);
+		if (keys.length === 0) return "";
+		if (keys.length === 1) return keys[0]!;
+		return keys.join("/");
+	}
+
+	/**
+	 * Get the full effective config.
+	 */
+	getEffectiveConfig(): Required<KeybindingsConfig> {
+		const result = { ...DEFAULT_KEYBINDINGS };
+		for (const [action, keys] of Object.entries(this.config)) {
+			if (keys !== undefined) {
+				(result as KeybindingsConfig)[action as KeyAction] = keys;
+			}
+		}
+		return result;
+	}
+}
+
+// Re-export for convenience
+export type { EditorAction, KeyId };

package/src/core/messages.ts

@@ -35,11 +35,24 @@ export interface BashExecutionMessage {
 	truncated: boolean;
 	fullOutputPath?: string;
 	timestamp: number;
+	/** If true, this message is excluded from LLM context (!! prefix) */
+	excludeFromContext?: boolean;
 }
 
 /**
- * Message type for hook-injected messages via sendMessage().
- * These are custom messages that hooks can inject into the conversation.
+ * Message type for extension-injected messages via sendMessage().
+ */
+export interface CustomMessage<T = unknown> {
+	role: "custom";
+	customType: string;
+	content: string | (TextContent | ImageContent)[];
+	display: boolean;
+	details?: T;
+	timestamp: number;
+}
+
+/**
+ * Legacy hook message type (pre-extensions). Kept for session migration.
  */
 export interface HookMessage<T = unknown> {
 	role: "hookMessage";
@@ -78,9 +91,11 @@ export interface FileMentionMessage {
 }
 
 // Extend CustomAgentMessages via declaration merging
+// Legacy hookMessage is kept for migration; new code should use custom.
 declare module "@oh-my-pi/pi-agent-core" {
 	interface CustomAgentMessages {
 		bashExecution: BashExecutionMessage;
+		custom: CustomMessage;
 		hookMessage: HookMessage;
 		branchSummary: BranchSummaryMessage;
 		compactionSummary: CompactionSummaryMessage;
@@ -125,22 +140,22 @@ export function createCompactionSummaryMessage(
 ): CompactionSummaryMessage {
 	return {
 		role: "compactionSummary",
-		summary: summary,
+		summary,
 		tokensBefore,
 		timestamp: new Date(timestamp).getTime(),
 	};
 }
 
 /** Convert CustomMessageEntry to AgentMessage format */
-export function createHookMessage(
+export function createCustomMessage(
 	customType: string,
 	content: string | (TextContent | ImageContent)[],
 	display: boolean,
 	details: unknown | undefined,
 	timestamp: string,
-): HookMessage {
+): CustomMessage {
 	return {
-		role: "hookMessage",
+		role: "custom",
 		customType,
 		content,
 		display,
@@ -155,18 +170,22 @@ export function createHookMessage(
  * This is used by:
  * - Agent's transormToLlm option (for prompt calls and queued messages)
  * - Compaction's generateSummary (for summarization)
- * - Custom hooks and tools
+ * - Custom extensions and tools
  */
 export function convertToLlm(messages: AgentMessage[]): Message[] {
 	return messages
 		.map((m): Message | undefined => {
 			switch (m.role) {
 				case "bashExecution":
+					if (m.excludeFromContext) {
+						return undefined;
+					}
 					return {
 						role: "user",
 						content: [{ type: "text", text: bashExecutionToText(m) }],
 						timestamp: m.timestamp,
 					};
+				case "custom":
 				case "hookMessage": {
 					const content = typeof m.content === "string" ? [{ type: "text" as const, text: m.content }] : m.content;
 					return {