@oh-my-pi/pi-coding-agent 8.0.20 → 8.2.0

package/src/modes/print-mode.ts

@@ -5,9 +5,8 @@
  * - `omp -p "prompt"` - text output
  * - `omp --mode json "prompt"` - JSON event stream
  */
-
 import type { AssistantMessage, ImageContent } from "@oh-my-pi/pi-ai";
-import type { AgentSession } from "@oh-my-pi/pi-coding-agent/session/agent-session";
+import type { AgentSession } from "../session/agent-session";
 
 /**
  * Options for print mode.
@@ -44,12 +43,12 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 			// ExtensionActions
 			{
 				sendMessage: (message, options) => {
-					session.sendCustomMessage(message, options).catch((e) => {
+					session.sendCustomMessage(message, options).catch(e => {
 						process.stderr.write(`Extension sendMessage failed: ${e instanceof Error ? e.message : String(e)}\n`);
 					});
 				},
 				sendUserMessage: (content, options) => {
-					session.sendUserMessage(content, options).catch((e) => {
+					session.sendUserMessage(content, options).catch(e => {
 						process.stderr.write(
 							`Extension sendUserMessage failed: ${e instanceof Error ? e.message : String(e)}\n`,
 						);
@@ -64,14 +63,14 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 				getActiveTools: () => session.getActiveToolNames(),
 				getAllTools: () => session.getAllToolNames(),
 				setActiveTools: (toolNames: string[]) => session.setActiveToolsByName(toolNames),
-				setModel: async (model) => {
+				setModel: async model => {
 					const key = await session.modelRegistry.getApiKey(model);
 					if (!key) return false;
 					await session.setModel(model);
 					return true;
 				},
 				getThinkingLevel: () => session.thinkingLevel,
-				setThinkingLevel: (level) => session.setThinkingLevel(level),
+				setThinkingLevel: level => session.setThinkingLevel(level),
 			},
 			// ExtensionContextActions
 			{
@@ -81,7 +80,7 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 				hasPendingMessages: () => session.queuedMessageCount > 0,
 				shutdown: () => {},
 				getContextUsage: () => session.getContextUsage(),
-				compact: async (instructionsOrOptions) => {
+				compact: async instructionsOrOptions => {
 					const instructions = typeof instructionsOrOptions === "string" ? instructionsOrOptions : undefined;
 					const options =
 						instructionsOrOptions && typeof instructionsOrOptions === "object"
@@ -94,14 +93,14 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 			{
 				getContextUsage: () => session.getContextUsage(),
 				waitForIdle: () => session.agent.waitForIdle(),
-				newSession: async (options) => {
+				newSession: async options => {
 					const success = await session.newSession({ parentSession: options?.parentSession });
 					if (success && options?.setup) {
 						await options.setup(session.sessionManager);
 					}
 					return { cancelled: !success };
 				},
-				branch: async (entryId) => {
+				branch: async entryId => {
 					const result = await session.branch(entryId);
 					return { cancelled: result.cancelled };
 				},
@@ -109,7 +108,7 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 					const result = await session.navigateTree(targetId, { summarize: options?.summarize });
 					return { cancelled: result.cancelled };
 				},
-				compact: async (instructionsOrOptions) => {
+				compact: async instructionsOrOptions => {
 					const instructions = typeof instructionsOrOptions === "string" ? instructionsOrOptions : undefined;
 					const options =
 						instructionsOrOptions && typeof instructionsOrOptions === "object"
@@ -120,7 +119,7 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 			},
 			// No UI context
 		);
-		extensionRunner.onError((err) => {
+		extensionRunner.onError(err => {
 			process.stderr.write(`Extension error (${err.extensionPath}): ${err.error}\n`);
 		});
 		// Emit session_start event
@@ -130,7 +129,7 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 	}
 
 	// Always subscribe to enable session persistence via _handleAgentEvent
-	session.subscribe((event) => {
+	session.subscribe(event => {
 		// In JSON mode, output all events
 		if (mode === "json") {
 			process.stdout.write(`${JSON.stringify(event)}\n`);
@@ -173,7 +172,7 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 	// Ensure stdout is fully flushed before returning
 	// This prevents race conditions where the process exits before all output is written
 	await new Promise<void>((resolve, reject) => {
-		process.stdout.write("", (err) => {
+		process.stdout.write("", err => {
 			if (err) reject(err);
 			else resolve();
 		});

package/src/modes/rpc/rpc-client.ts

@@ -3,13 +3,12 @@
  *
  * Spawns the agent in RPC mode and provides a typed API for all operations.
  */
-
 import type { AgentEvent, AgentMessage, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent } from "@oh-my-pi/pi-ai";
-import type { BashResult } from "@oh-my-pi/pi-coding-agent/exec/bash-executor";
-import type { SessionStats } from "@oh-my-pi/pi-coding-agent/session/agent-session";
-import type { CompactionResult } from "@oh-my-pi/pi-coding-agent/session/compaction/index";
 import { createSanitizerStream, createSplitterStream, createTextDecoderStream, ptree } from "@oh-my-pi/pi-utils";
+import type { BashResult } from "../../exec/bash-executor";
+import type { SessionStats } from "../../session/agent-session";
+import type { CompactionResult } from "../../session/compaction";
 import type { RpcCommand, RpcResponse, RpcSessionState } from "./rpc-types";
 
 /** Distributive Omit that works with union types */
@@ -372,7 +371,7 @@ export class RpcClient {
 	waitForIdle(timeout = 60000): Promise<void> {
 		const { promise, resolve, reject } = Promise.withResolvers<void>();
 		let settled = false;
-		const unsubscribe = this.onEvent((event) => {
+		const unsubscribe = this.onEvent(event => {
 			if (event.type === "agent_end") {
 				settled = true;
 				unsubscribe();
@@ -397,7 +396,7 @@ export class RpcClient {
 		const { promise, resolve, reject } = Promise.withResolvers<AgentEvent[]>();
 		const events: AgentEvent[] = [];
 		let settled = false;
-		const unsubscribe = this.onEvent((event) => {
+		const unsubscribe = this.onEvent(event => {
 			events.push(event);
 			if (event.type === "agent_end") {
 				settled = true;
@@ -470,12 +469,12 @@ export class RpcClient {
 		})();
 
 		this.pendingRequests.set(id, {
-			resolve: (response) => {
+			resolve: response => {
 				if (settled) return;
 				settled = true;
 				resolve(response);
 			},
-			reject: (error) => {
+			reject: error => {
 				if (settled) return;
 				settled = true;
 				reject(error);

package/src/modes/rpc/rpc-mode.ts

@@ -10,15 +10,11 @@
  * - Events: AgentSessionEvent objects streamed as they occur
  * - Extension UI: Extension UI requests are emitted, client responds with extension_ui_response
  */
-
-import type {
-	ExtensionUIContext,
-	ExtensionUIDialogOptions,
-} from "@oh-my-pi/pi-coding-agent/extensibility/extensions/index";
-import { type Theme, theme } from "@oh-my-pi/pi-coding-agent/modes/theme/theme";
-import type { AgentSession } from "@oh-my-pi/pi-coding-agent/session/agent-session";
 import { readLines } from "@oh-my-pi/pi-utils";
 import { nanoid } from "nanoid";
+import type { ExtensionUIContext, ExtensionUIDialogOptions } from "../../extensibility/extensions";
+import { type Theme, theme } from "../../modes/theme/theme";
+import type { AgentSession } from "../../session/agent-session";
 import type {
 	RpcCommand,
 	RpcExtensionUIRequest,
@@ -128,7 +124,7 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 				dialogOptions,
 				undefined,
 				{ method: "select", title, options, timeout: dialogOptions?.timeout },
-				(response) =>
+				response =>
 					"cancelled" in response && response.cancelled
 						? undefined
 						: "value" in response
@@ -142,7 +138,7 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 				dialogOptions,
 				false,
 				{ method: "confirm", title, message, timeout: dialogOptions?.timeout },
-				(response) =>
+				response =>
 					"cancelled" in response && response.cancelled
 						? false
 						: "confirmed" in response
@@ -160,7 +156,7 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 				dialogOptions,
 				undefined,
 				{ method: "input", title, placeholder, timeout: dialogOptions?.timeout },
-				(response) =>
+				response =>
 					"cancelled" in response && response.cancelled
 						? undefined
 						: "value" in response
@@ -274,17 +270,17 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 			return theme;
 		}
 
-		getAllThemes(): { name: string; path: string | undefined }[] {
-			return [];
+		getAllThemes(): Promise<{ name: string; path: string | undefined }[]> {
+			return Promise.resolve([]);
 		}
 
-		getTheme(_name: string): Theme | undefined {
-			return undefined;
+		getTheme(_name: string): Promise<Theme | undefined> {
+			return Promise.resolve(undefined);
 		}
 
-		setTheme(_theme: string | Theme): { success: boolean; error?: string } {
+		setTheme(_theme: string | Theme): Promise<{ success: boolean; error?: string }> {
 			// Theme switching not supported in RPC mode
-			return { success: false, error: "Theme switching not supported in RPC mode" };
+			return Promise.resolve({ success: false, error: "Theme switching not supported in RPC mode" });
 		}
 
 		setEditorComponent(): void {
@@ -299,12 +295,12 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 			// ExtensionActions
 			{
 				sendMessage: (message, options) => {
-					session.sendCustomMessage(message, options).catch((e) => {
+					session.sendCustomMessage(message, options).catch(e => {
 						output(error(undefined, "extension_send", e.message));
 					});
 				},
 				sendUserMessage: (content, options) => {
-					session.sendUserMessage(content, options).catch((e) => {
+					session.sendUserMessage(content, options).catch(e => {
 						output(error(undefined, "extension_send_user", e.message));
 					});
 				},
@@ -317,14 +313,14 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 				getActiveTools: () => session.getActiveToolNames(),
 				getAllTools: () => session.getAllToolNames(),
 				setActiveTools: (toolNames: string[]) => session.setActiveToolsByName(toolNames),
-				setModel: async (model) => {
+				setModel: async model => {
 					const key = await session.modelRegistry.getApiKey(model);
 					if (!key) return false;
 					await session.setModel(model);
 					return true;
 				},
 				getThinkingLevel: () => session.thinkingLevel,
-				setThinkingLevel: (level) => session.setThinkingLevel(level),
+				setThinkingLevel: level => session.setThinkingLevel(level),
 			},
 			// ExtensionContextActions
 			{
@@ -336,7 +332,7 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 					shutdownState.requested = true;
 				},
 				getContextUsage: () => session.getContextUsage(),
-				compact: async (instructionsOrOptions) => {
+				compact: async instructionsOrOptions => {
 					const instructions = typeof instructionsOrOptions === "string" ? instructionsOrOptions : undefined;
 					const options =
 						instructionsOrOptions && typeof instructionsOrOptions === "object"
@@ -349,7 +345,7 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 			{
 				getContextUsage: () => session.getContextUsage(),
 				waitForIdle: () => session.agent.waitForIdle(),
-				newSession: async (options) => {
+				newSession: async options => {
 					const success = await session.newSession({ parentSession: options?.parentSession });
 					// Note: setup callback runs but no UI feedback in RPC mode
 					if (success && options?.setup) {
@@ -357,7 +353,7 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 					}
 					return { cancelled: !success };
 				},
-				branch: async (entryId) => {
+				branch: async entryId => {
 					const result = await session.branch(entryId);
 					return { cancelled: result.cancelled };
 				},
@@ -365,7 +361,7 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 					const result = await session.navigateTree(targetId, { summarize: options?.summarize });
 					return { cancelled: result.cancelled };
 				},
-				compact: async (instructionsOrOptions) => {
+				compact: async instructionsOrOptions => {
 					const instructions = typeof instructionsOrOptions === "string" ? instructionsOrOptions : undefined;
 					const options =
 						instructionsOrOptions && typeof instructionsOrOptions === "object"
@@ -376,7 +372,7 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 			},
 			new RpcExtensionUIContext(pendingExtensionRequests, output),
 		);
-		extensionRunner.onError((err) => {
+		extensionRunner.onError(err => {
 			output({ type: "extension_error", extensionPath: err.extensionPath, event: err.event, error: err.error });
 		});
 		// Emit session_start event
@@ -386,7 +382,7 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 	}
 
 	// Output all agent events as JSON
-	session.subscribe((event) => {
+	session.subscribe(event => {
 		output(event);
 	});
 
@@ -408,7 +404,7 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 						images: command.images,
 						streamingBehavior: command.streamingBehavior,
 					})
-					.catch((e) => output(error(id, "prompt", e.message)));
+					.catch(e => output(error(id, "prompt", e.message)));
 				return success(id, "prompt");
 			}
 
@@ -461,7 +457,7 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 
 			case "set_model": {
 				const models = session.getAvailableModels();
-				const model = models.find((m) => m.provider === command.provider && m.id === command.modelId);
+				const model = models.find(m => m.provider === command.provider && m.id === command.modelId);
 				if (!model) {
 					return error(id, "set_model", `Model not found: ${command.provider}/${command.modelId}`);
 				}

package/src/modes/rpc/rpc-types.ts

@@ -4,12 +4,11 @@
  * Commands are sent as JSON lines on stdin.
  * Responses and events are emitted as JSON lines on stdout.
  */
-
 import type { AgentMessage, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, Model } from "@oh-my-pi/pi-ai";
-import type { BashResult } from "@oh-my-pi/pi-coding-agent/exec/bash-executor";
-import type { SessionStats } from "@oh-my-pi/pi-coding-agent/session/agent-session";
-import type { CompactionResult } from "@oh-my-pi/pi-coding-agent/session/compaction/index";
+import type { BashResult } from "../../exec/bash-executor";
+import type { SessionStats } from "../../session/agent-session";
+import type { CompactionResult } from "../../session/compaction";
 
 // ============================================================================
 // RPC Commands (stdin)

package/src/modes/theme/mermaid-cache.ts

@@ -0,0 +1,89 @@
+import {
+	extractMermaidBlocks,
+	type MermaidImage,
+	type MermaidRenderOptions,
+	renderMermaidToPng,
+} from "@oh-my-pi/pi-tui";
+
+const cache = new Map<string, MermaidImage>();
+const pending = new Map<string, Promise<MermaidImage | null>>();
+
+const defaultOptions: MermaidRenderOptions = {
+	theme: "dark",
+	backgroundColor: "transparent",
+};
+
+let onRenderNeeded: (() => void) | null = null;
+
+/**
+ * Set callback to trigger TUI re-render when mermaid images become available.
+ */
+export function setMermaidRenderCallback(callback: (() => void) | null): void {
+	onRenderNeeded = callback;
+}
+
+/**
+ * Get a pre-rendered mermaid image by hash.
+ * Returns null if not cached or rendering failed.
+ */
+export function getMermaidImage(hash: string): MermaidImage | null {
+	return cache.get(hash) ?? null;
+}
+
+/**
+ * Pre-render all mermaid blocks in markdown text.
+ * Renders in parallel, deduplicates concurrent requests.
+ * Calls render callback when new images are cached.
+ */
+export async function prerenderMermaid(
+	markdown: string,
+	options: MermaidRenderOptions = defaultOptions,
+): Promise<void> {
+	const blocks = extractMermaidBlocks(markdown);
+	if (blocks.length === 0) return;
+
+	const promises: Promise<boolean>[] = [];
+
+	for (const { source, hash } of blocks) {
+		if (cache.has(hash)) continue;
+
+		let promise = pending.get(hash);
+		if (!promise) {
+			promise = renderMermaidToPng(source, options);
+			pending.set(hash, promise);
+		}
+
+		promises.push(
+			promise.then(image => {
+				pending.delete(hash);
+				if (image) {
+					cache.set(hash, image);
+					return true;
+				}
+				return false;
+			}),
+		);
+	}
+
+	const results = await Promise.all(promises);
+	const newImages = results.some(added => added);
+
+	if (newImages && onRenderNeeded) {
+		onRenderNeeded();
+	}
+}
+
+/**
+ * Check if markdown contains mermaid blocks that aren't cached yet.
+ */
+export function hasPendingMermaid(markdown: string): boolean {
+	const blocks = extractMermaidBlocks(markdown);
+	return blocks.some(({ hash }) => !cache.has(hash));
+}
+
+/**
+ * Clear the mermaid cache.
+ */
+export function clearMermaidCache(): void {
+	cache.clear();
+}