@oh-my-pi/pi-coding-agent 3.37.0 → 4.0.0

package/src/modes/interactive/theme/theme.ts

@@ -1012,10 +1012,12 @@ function detectColorMode(): ColorMode {
 		return "truecolor";
 	}
 	const term = process.env.TERM || "";
-	if (term.includes("256color")) {
+	// Only fall back to 256color for truly limited terminals
+	if (term === "dumb" || term === "" || term === "linux") {
 		return "256color";
 	}
-	return "256color";
+	// Assume truecolor for everything else - virtually all modern terminals support it
+	return "truecolor";
 }
 
 function hexToRgb(hex: string): { r: number; g: number; b: number } {
@@ -1599,6 +1601,35 @@ export function getAvailableThemes(): string[] {
 	return Array.from(themes).sort();
 }
 
+export interface ThemeInfo {
+	name: string;
+	path: string | undefined;
+}
+
+export function getAvailableThemesWithPaths(): ThemeInfo[] {
+	const result: ThemeInfo[] = [];
+
+	// Built-in themes (embedded, no file path)
+	for (const name of Object.keys(getBuiltinThemes())) {
+		result.push({ name, path: undefined });
+	}
+
+	// Custom themes
+	const customThemesDir = getCustomThemesDir();
+	if (fs.existsSync(customThemesDir)) {
+		for (const file of fs.readdirSync(customThemesDir)) {
+			if (file.endsWith(".json")) {
+				const name = file.slice(0, -5);
+				if (!result.some((themeInfo) => themeInfo.name === name)) {
+					result.push({ name, path: path.join(customThemesDir, file) });
+				}
+			}
+		}
+	}
+
+	return result.sort((a, b) => a.name.localeCompare(b.name));
+}
+
 function loadThemeJson(name: string): ThemeJson {
 	const builtinThemes = getBuiltinThemes();
 	if (name in builtinThemes) {
@@ -1679,6 +1710,14 @@ function loadTheme(name: string, mode?: ColorMode, symbolPresetOverride?: Symbol
 	return createTheme(themeJson, mode, symbolPresetOverride);
 }
 
+export function getThemeByName(name: string): Theme | undefined {
+	try {
+		return loadTheme(name);
+	} catch {
+		return undefined;
+	}
+}
+
 function detectTerminalBackground(): "dark" | "light" {
 	const colorfgbg = process.env.COLORFGBG || "";
 	if (colorfgbg) {
@@ -1748,6 +1787,15 @@ export function setTheme(name: string, enableWatcher: boolean = false): { succes
 	}
 }
 
+export function setThemeInstance(themeInstance: Theme): void {
+	theme = themeInstance;
+	currentThemeName = "<in-memory>";
+	stopThemeWatcher();
+	if (onThemeChangeCallback) {
+		onThemeChangeCallback();
+	}
+}
+
 /**
  * Set the symbol preset override, recreating the theme with the new preset.
  */

package/src/modes/print-mode.ts

@@ -9,43 +9,90 @@
 import type { AssistantMessage, ImageContent } from "@oh-my-pi/pi-ai";
 import type { AgentSession } from "../core/agent-session";
 
+/**
+ * Options for print mode.
+ */
+export interface PrintModeOptions {
+	/** Output mode: "text" for final response only, "json" for all events */
+	mode: "text" | "json";
+	/** Array of additional prompts to send after initialMessage */
+	messages?: string[];
+	/** First message to send (may contain @file content) */
+	initialMessage?: string;
+	/** Images to attach to the initial message */
+	initialImages?: ImageContent[];
+}
+
 /**
  * Run in print (single-shot) mode.
  * Sends prompts to the agent and outputs the result.
- *
- * @param session The agent session
- * @param mode Output mode: "text" for final response only, "json" for all events
- * @param messages Array of prompts to send
- * @param initialMessage Optional first message (may contain @file content)
- * @param initialImages Optional images for the initial message
  */
-export async function runPrintMode(
-	session: AgentSession,
-	mode: "text" | "json",
-	messages: string[],
-	initialMessage?: string,
-	initialImages?: ImageContent[],
-): Promise<void> {
-	// Extension runner already has no-op UI context by default (set in loader)
-	// Set up extensions for print mode (no UI)
+export async function runPrintMode(session: AgentSession, options: PrintModeOptions): Promise<void> {
+	const { mode, messages = [], initialMessage, initialImages } = options;
+	// Set up extensions for print mode (no UI, no command context)
 	const extensionRunner = session.extensionRunner;
 	if (extensionRunner) {
-		extensionRunner.initialize({
-			getModel: () => session.model,
-			sendMessageHandler: (message, options) => {
-				session.sendCustomMessage(message, options).catch((e) => {
-					console.error(`Extension sendMessage failed: ${e instanceof Error ? e.message : String(e)}`);
-				});
+		extensionRunner.initialize(
+			// ExtensionActions
+			{
+				sendMessage: (message, options) => {
+					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) => {
+						process.stderr.write(
+							`Extension sendUserMessage failed: ${e instanceof Error ? e.message : String(e)}\n`,
+						);
+					});
+				},
+				appendEntry: (customType, data) => {
+					session.sessionManager.appendCustomEntry(customType, data);
+				},
+				getActiveTools: () => session.getActiveToolNames(),
+				getAllTools: () => session.getAllToolNames(),
+				setActiveTools: (toolNames: string[]) => session.setActiveToolsByName(toolNames),
+				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),
 			},
-			appendEntryHandler: (customType, data) => {
-				session.sessionManager.appendCustomEntry(customType, data);
+			// ExtensionContextActions
+			{
+				getModel: () => session.model,
+				isIdle: () => !session.isStreaming,
+				abort: () => session.abort(),
+				hasPendingMessages: () => session.queuedMessageCount > 0,
+				shutdown: () => {},
 			},
-			getActiveToolsHandler: () => session.getActiveToolNames(),
-			getAllToolsHandler: () => session.getAllToolNames(),
-			setActiveToolsHandler: (toolNames: string[]) => session.setActiveToolsByName(toolNames),
-		});
+			// ExtensionCommandContextActions - commands invokable via prompt("/command")
+			{
+				waitForIdle: () => session.agent.waitForIdle(),
+				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) => {
+					const result = await session.branch(entryId);
+					return { cancelled: result.cancelled };
+				},
+				navigateTree: async (targetId, options) => {
+					const result = await session.navigateTree(targetId, { summarize: options?.summarize });
+					return { cancelled: result.cancelled };
+				},
+			},
+			// No UI context
+		);
 		extensionRunner.onError((err) => {
-			console.error(`Extension error (${err.extensionPath}): ${err.error}`);
+			process.stderr.write(`Extension error (${err.extensionPath}): ${err.error}\n`);
 		});
 		// Emit session_start event
 		await extensionRunner.emit({
@@ -57,7 +104,7 @@ export async function runPrintMode(
 	session.subscribe((event) => {
 		// In JSON mode, output all events
 		if (mode === "json") {
-			console.log(JSON.stringify(event));
+			process.stdout.write(`${JSON.stringify(event)}\n`);
 		}
 	});
 
@@ -81,14 +128,14 @@ export async function runPrintMode(
 
 			// Check for error/aborted
 			if (assistantMsg.stopReason === "error" || assistantMsg.stopReason === "aborted") {
-				console.error(assistantMsg.errorMessage || `Request ${assistantMsg.stopReason}`);
+				process.stderr.write(`${assistantMsg.errorMessage || `Request ${assistantMsg.stopReason}`}\n`);
 				process.exit(1);
 			}
 
 			// Output text content
 			for (const content of assistantMsg.content) {
 				if (content.type === "text") {
-					console.log(content.text);
+					process.stdout.write(`${content.text}\n`);
 				}
 			}
 		}

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

@@ -13,8 +13,8 @@
 
 import { nanoid } from "nanoid";
 import type { AgentSession } from "../../core/agent-session";
-import type { ExtensionUIContext } from "../../core/extensions/index";
-import { theme } from "../interactive/theme/theme";
+import type { ExtensionUIContext, ExtensionUIDialogOptions } from "../../core/extensions/index";
+import { type Theme, theme } from "../interactive/theme/theme";
 import type {
 	RpcCommand,
 	RpcExtensionUIRequest,
@@ -38,7 +38,7 @@ export type {
  */
 export async function runRpcMode(session: AgentSession): Promise<never> {
 	const output = (obj: RpcResponse | RpcExtensionUIRequest | object) => {
-		console.log(JSON.stringify(obj));
+		process.stdout.write(`${JSON.stringify(obj)}\n`);
 	};
 
 	const success = <T extends RpcCommand["type"]>(
@@ -57,71 +57,101 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 	};
 
 	// Pending extension UI requests waiting for response
-	const pendingExtensionRequests = new Map<
-		string,
-		{ resolve: (value: any) => void; reject: (error: Error) => void }
-	>();
+	type PendingExtensionRequest = {
+		resolve: (response: RpcExtensionUIResponse) => void;
+		reject: (error: Error) => void;
+	};
+
+	const pendingExtensionRequests = new Map<string, PendingExtensionRequest>();
+
+	// Shutdown request flag (wrapped in object to allow mutation with const)
+	const shutdownState = { requested: false };
+
+	/** Helper for dialog methods with signal/timeout support */
+	function createDialogPromise<T>(
+		opts: ExtensionUIDialogOptions | undefined,
+		defaultValue: T,
+		request: Record<string, unknown>,
+		parseResponse: (response: RpcExtensionUIResponse) => T,
+	): Promise<T> {
+		if (opts?.signal?.aborted) return Promise.resolve(defaultValue);
+
+		const id = nanoid();
+		return new Promise((resolve, reject) => {
+			let timeoutId: ReturnType<typeof setTimeout> | undefined;
+
+			const cleanup = () => {
+				if (timeoutId) clearTimeout(timeoutId);
+				opts?.signal?.removeEventListener("abort", onAbort);
+				pendingExtensionRequests.delete(id);
+			};
+
+			const onAbort = () => {
+				cleanup();
+				resolve(defaultValue);
+			};
+			opts?.signal?.addEventListener("abort", onAbort, { once: true });
+
+			if (opts?.timeout !== undefined) {
+				timeoutId = setTimeout(() => {
+					cleanup();
+					resolve(defaultValue);
+				}, opts.timeout);
+			}
+
+			pendingExtensionRequests.set(id, {
+				resolve: (response: RpcExtensionUIResponse) => {
+					cleanup();
+					resolve(parseResponse(response));
+				},
+				reject,
+			});
+			output({ type: "extension_ui_request", id, ...request } as RpcExtensionUIRequest);
+		});
+	}
 
 	/**
 	 * Create an extension UI context that uses the RPC protocol.
 	 */
 	const createExtensionUIContext = (): ExtensionUIContext => ({
-		async select(title: string, options: string[]): Promise<string | undefined> {
-			const id = nanoid();
-			return new Promise((resolve, reject) => {
-				pendingExtensionRequests.set(id, {
-					resolve: (response: RpcExtensionUIResponse) => {
-						if ("cancelled" in response && response.cancelled) {
-							resolve(undefined);
-						} else if ("value" in response) {
-							resolve(response.value);
-						} else {
-							resolve(undefined);
-						}
-					},
-					reject,
-				});
-				output({ type: "extension_ui_request", id, method: "select", title, options } as RpcExtensionUIRequest);
-			});
-		},
-
-		async confirm(title: string, message: string): Promise<boolean> {
-			const id = nanoid();
-			return new Promise((resolve, reject) => {
-				pendingExtensionRequests.set(id, {
-					resolve: (response: RpcExtensionUIResponse) => {
-						if ("cancelled" in response && response.cancelled) {
-							resolve(false);
-						} else if ("confirmed" in response) {
-							resolve(response.confirmed);
-						} else {
-							resolve(false);
-						}
-					},
-					reject,
-				});
-				output({ type: "extension_ui_request", id, method: "confirm", title, message } as RpcExtensionUIRequest);
-			});
-		},
-
-		async input(title: string, placeholder?: string): Promise<string | undefined> {
-			const id = nanoid();
-			return new Promise((resolve, reject) => {
-				pendingExtensionRequests.set(id, {
-					resolve: (response: RpcExtensionUIResponse) => {
-						if ("cancelled" in response && response.cancelled) {
-							resolve(undefined);
-						} else if ("value" in response) {
-							resolve(response.value);
-						} else {
-							resolve(undefined);
-						}
-					},
-					reject,
-				});
-				output({ type: "extension_ui_request", id, method: "input", title, placeholder } as RpcExtensionUIRequest);
-			});
-		},
+		select: (title, options, dialogOptions) =>
+			createDialogPromise(
+				dialogOptions,
+				undefined,
+				{ method: "select", title, options, timeout: dialogOptions?.timeout },
+				(response) =>
+					"cancelled" in response && response.cancelled
+						? undefined
+						: "value" in response
+							? response.value
+							: undefined,
+			),
+
+		confirm: (title, message, dialogOptions) =>
+			createDialogPromise(
+				dialogOptions,
+				false,
+				{ method: "confirm", title, message, timeout: dialogOptions?.timeout },
+				(response) =>
+					"cancelled" in response && response.cancelled
+						? false
+						: "confirmed" in response
+							? response.confirmed
+							: false,
+			),
+
+		input: (title, placeholder, dialogOptions) =>
+			createDialogPromise(
+				dialogOptions,
+				undefined,
+				{ method: "input", title, placeholder, timeout: dialogOptions?.timeout },
+				(response) =>
+					"cancelled" in response && response.cancelled
+						? undefined
+						: "value" in response
+							? response.value
+							: undefined,
+			),
 
 		notify(message: string, type?: "info" | "warning" | "error"): void {
 			// Fire and forget - no response needed
@@ -195,6 +225,7 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 			return new Promise((resolve, reject) => {
 				pendingExtensionRequests.set(id, {
 					resolve: (response: RpcExtensionUIResponse) => {
+						pendingExtensionRequests.delete(id);
 						if ("cancelled" in response && response.cancelled) {
 							resolve(undefined);
 						} else if ("value" in response) {
@@ -212,27 +243,88 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 		get theme() {
 			return theme;
 		},
+
+		getAllThemes() {
+			return [];
+		},
+
+		getTheme(_name: string) {
+			return undefined;
+		},
+
+		setTheme(_theme: string | Theme) {
+			// Theme switching not supported in RPC mode
+			return { success: false, error: "Theme switching not supported in RPC mode" };
+		},
+
+		setFooter() {},
+		setHeader() {},
+		setEditorComponent() {},
 	});
 
 	// Set up extensions with RPC-based UI context
 	const extensionRunner = session.extensionRunner;
 	if (extensionRunner) {
-		extensionRunner.initialize({
-			getModel: () => session.agent.state.model,
-			sendMessageHandler: (message, options) => {
-				session.sendCustomMessage(message, options).catch((e) => {
-					output(error(undefined, "extension_send", e.message));
-				});
+		extensionRunner.initialize(
+			// ExtensionActions
+			{
+				sendMessage: (message, options) => {
+					session.sendCustomMessage(message, options).catch((e) => {
+						output(error(undefined, "extension_send", e.message));
+					});
+				},
+				sendUserMessage: (content, options) => {
+					session.sendUserMessage(content, options).catch((e) => {
+						output(error(undefined, "extension_send_user", e.message));
+					});
+				},
+				appendEntry: (customType, data) => {
+					session.sessionManager.appendCustomEntry(customType, data);
+				},
+				getActiveTools: () => session.getActiveToolNames(),
+				getAllTools: () => session.getAllToolNames(),
+				setActiveTools: (toolNames: string[]) => session.setActiveToolsByName(toolNames),
+				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),
 			},
-			appendEntryHandler: (customType, data) => {
-				session.sessionManager.appendCustomEntry(customType, data);
+			// ExtensionContextActions
+			{
+				getModel: () => session.agent.state.model,
+				isIdle: () => !session.isStreaming,
+				abort: () => session.abort(),
+				hasPendingMessages: () => session.queuedMessageCount > 0,
+				shutdown: () => {
+					shutdownState.requested = true;
+				},
 			},
-			getActiveToolsHandler: () => session.getActiveToolNames(),
-			getAllToolsHandler: () => session.getAllToolNames(),
-			setActiveToolsHandler: (toolNames: string[]) => session.setActiveToolsByName(toolNames),
-			uiContext: createExtensionUIContext(),
-			hasUI: false,
-		});
+			// ExtensionCommandContextActions - commands invokable via prompt("/command")
+			{
+				waitForIdle: () => session.agent.waitForIdle(),
+				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) {
+						await options.setup(session.sessionManager);
+					}
+					return { cancelled: !success };
+				},
+				branch: async (entryId) => {
+					const result = await session.branch(entryId);
+					return { cancelled: result.cancelled };
+				},
+				navigateTree: async (targetId, options) => {
+					const result = await session.navigateTree(targetId, { summarize: options?.summarize });
+					return { cancelled: result.cancelled };
+				},
+			},
+			createExtensionUIContext(),
+		);
 		extensionRunner.onError((err) => {
 			output({ type: "extension_error", extensionPath: err.extensionPath, event: err.event, error: err.error });
 		});
@@ -466,6 +558,20 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 		}
 	};
 
+	/**
+	 * Check if shutdown was requested and perform shutdown if so.
+	 * Called after handling each command when waiting for the next command.
+	 */
+	async function checkShutdownRequested(): Promise<void> {
+		if (!shutdownState.requested) return;
+
+		if (extensionRunner?.hasHandlers("session_shutdown")) {
+			await extensionRunner.emit({ type: "session_shutdown" });
+		}
+
+		process.exit(0);
+	}
+
 	// Listen for JSON input using Bun's stdin
 	const decoder = new TextDecoder();
 	let buffer = "";
@@ -486,7 +592,6 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 					const response = parsed as RpcExtensionUIResponse;
 					const pending = pendingExtensionRequests.get(response.id);
 					if (pending) {
-						pendingExtensionRequests.delete(response.id);
 						pending.resolve(response);
 					}
 					continue;
@@ -496,6 +601,9 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 				const command = parsed as RpcCommand;
 				const response = await handleCommand(command);
 				output(response);
+
+				// Check for deferred shutdown request (idle between commands)
+				await checkShutdownRequested();
 			} catch (e: any) {
 				output(error(undefined, "parse", `Failed to parse command: ${e.message}`));
 			}

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

@@ -180,9 +180,16 @@ export type RpcResponse =
 
 /** Emitted when an extension needs user input */
 export type RpcExtensionUIRequest =
-	| { type: "extension_ui_request"; id: string; method: "select"; title: string; options: string[] }
-	| { type: "extension_ui_request"; id: string; method: "confirm"; title: string; message: string }
-	| { type: "extension_ui_request"; id: string; method: "input"; title: string; placeholder?: string }
+	| { type: "extension_ui_request"; id: string; method: "select"; title: string; options: string[]; timeout?: number }
+	| { type: "extension_ui_request"; id: string; method: "confirm"; title: string; message: string; timeout?: number }
+	| {
+			type: "extension_ui_request";
+			id: string;
+			method: "input";
+			title: string;
+			placeholder?: string;
+			timeout?: number;
+	  }
 	| { type: "extension_ui_request"; id: string; method: "editor"; title: string; prefill?: string }
 	| {
 			type: "extension_ui_request";

package/src/prompts/system-prompt.md

@@ -1,35 +1,43 @@
-You are an expert coding assistant. You help users with coding tasks by reading files, executing commands, editing code, and writing new files.
+You are a senior software engineer with deep expertise in debugging, refactoring, and system design. You read files, execute commands, edit code, and write new files to complete coding tasks.
 
-Available tools:
-{{toolsList}}
-{{antiBashSection}}Guidelines:
-{{guidelines}}
-
-Core behavior:
-- Keep going until the task is fully resolved; do not stop early.
-- Verify with tools; ask for clarification when required.
-- Before tool calls, send a brief preamble describing the next action.
-- Provide short progress updates for long tasks; give a brief heads-up before writing large changes.
-- Follow AGENTS.md instructions by scope: nearest file applies, deeper files override higher-level ones.
-- If update_plan is available, use it for non-trivial multi-step work and keep it updated; skip planning for simple tasks.
-- If a command fails due to sandboxing or needs elevated access, request approval and rerun.
-- Follow project validation/testing guidance; if checks are not run, suggest them in next steps.
-- Resolve blockers before yielding; do not guess.
-- Use tools to ground answers when external or deterministic info is needed; avoid speculation when a tool can verify.
-- Ask for missing or ambiguous tool parameters instead of guessing; confirm before actions.
-- Minimize tool calls and context usage by narrowing queries and summarizing only what is needed.
-- After each tool result, check relevance; iterate or clarify if results conflict or are insufficient.
-- Use concise, scannable responses; include file paths in backticks; use short bullets for multi-item lists; avoid dumping large files.
+<critical>
+Keep working until the user's task is fully resolved. Use tools to verify—never guess.
+</critical>
 
 <environment>
 {{environmentInfo}}
 </environment>
 
-Documentation:
-- Main documentation: {{readmePath}}
-- Additional docs: {{docsPath}}
-- Examples: {{examplesPath}} (hooks, custom tools, SDK)
-- When asked to create: custom models/providers (README.md), hooks (docs/hooks.md, examples/hooks/), custom tools (docs/custom-tools.md, docs/tui.md, examples/custom-tools/), themes (docs/theme.md), skills (docs/skills.md)
-- Always read the doc, examples, AND follow .md cross-references before implementing
+<tools>
+{{toolsList}}
+</tools>
+{{antiBashSection}}
+<guidelines>
+{{guidelines}}
+</guidelines>
+
+<instructions>
+## Execution
+- Before each tool call, state the action in one sentence.
+- After each result, verify relevance; iterate if results conflict or are insufficient.
+- Plan multi-step work with update_plan when available; skip for simple tasks.
+- On sandbox/permission failures, request approval and retry.
+
+## Verification
+- Ground answers with tools when deterministic info is needed.
+- Ask for missing parameters instead of assuming.
+- Follow project testing guidance; suggest validation if not run.
+
+## Communication
+- Concise, scannable responses; file paths in backticks.
+- Brief progress updates on long tasks; heads-up before large changes.
+- Short bullets for lists; avoid dumping large files.
+
+## Project Integration
+- Follow AGENTS.md by scope: nearest file applies, deeper overrides higher.
+- Resolve blockers before yielding.
+</instructions>
 
-Final reminder: Complete the full user request before ending your turn.
+<critical>
+Complete the full user request before ending your turn. This matters.
+</critical>