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

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

@@ -96,11 +96,11 @@ import sandstone from "./sandstone.json" with { type: "json" };
 import titanium from "./titanium.json" with { type: "json" };
 
 export const defaultThemes = {
-	"alabaster": alabaster,
-	"amethyst": amethyst,
-	"anthracite": anthracite,
-	"basalt": basalt,
-	"birch": birch,
+	alabaster: alabaster,
+	amethyst: amethyst,
+	anthracite: anthracite,
+	basalt: basalt,
+	birch: birch,
 	"dark-abyss": dark_abyss,
 	"dark-arctic": dark_arctic,
 	"dark-aurora": dark_aurora,
@@ -143,7 +143,7 @@ export const defaultThemes = {
 	"dark-tundra": dark_tundra,
 	"dark-twilight": dark_twilight,
 	"dark-volcanic": dark_volcanic,
-	"graphite": graphite,
+	graphite: graphite,
 	"light-arctic": light_arctic,
 	"light-aurora-day": light_aurora_day,
 	"light-canyon": light_canyon,
@@ -182,14 +182,14 @@ export const defaultThemes = {
 	"light-tokyo-night": light_tokyo_night,
 	"light-wetland": light_wetland,
 	"light-zenith": light_zenith,
-	"limestone": limestone,
-	"mahogany": mahogany,
-	"marble": marble,
-	"obsidian": obsidian,
-	"onyx": onyx,
-	"pearl": pearl,
-	"porcelain": porcelain,
-	"quartz": quartz,
-	"sandstone": sandstone,
-	"titanium": titanium,
+	limestone: limestone,
+	mahogany: mahogany,
+	marble: marble,
+	obsidian: obsidian,
+	onyx: onyx,
+	pearl: pearl,
+	porcelain: porcelain,
+	quartz: quartz,
+	sandstone: sandstone,
+	titanium: titanium,
 };

package/src/modes/print-mode.ts

@@ -7,34 +7,7 @@
  */
 
 import type { AssistantMessage, ImageContent } from "@oh-my-pi/pi-ai";
-import { APP_NAME, VERSION } from "../config";
 import type { AgentSession } from "../core/agent-session";
-import { logger } from "../core/logger";
-
-/**
- * Print session header to stderr (text mode only).
- */
-function printHeader(session: AgentSession): void {
-	const model = session.model;
-	const lines = [
-		`${APP_NAME} v${VERSION}`,
-		"--------",
-		`workdir: ${process.cwd()}`,
-		`model: ${model?.id ?? "unknown"}`,
-		`provider: ${model?.provider ?? "unknown"}`,
-		`thinking: ${session.thinkingLevel}`,
-		`session: ${session.sessionId}`,
-		"--------",
-	];
-	console.error(lines.join("\n"));
-}
-
-/**
- * Print session footer to stderr (text mode only).
- */
-function printFooter(): void {
-	console.error("--------");
-}
 
 /**
  * Run in print (single-shot) mode.
@@ -53,61 +26,33 @@ export async function runPrintMode(
 	initialMessage?: string,
 	initialImages?: ImageContent[],
 ): Promise<void> {
-	// Print header to stderr (text mode only)
-	if (mode === "text") {
-		printHeader(session);
-	}
-
-	// Hook runner already has no-op UI context by default (set in main.ts)
-	// Set up hooks for print mode (no UI)
-	const hookRunner = session.hookRunner;
-	if (hookRunner) {
-		hookRunner.initialize({
+	// Extension runner already has no-op UI context by default (set in loader)
+	// Set up extensions for print mode (no UI)
+	const extensionRunner = session.extensionRunner;
+	if (extensionRunner) {
+		extensionRunner.initialize({
 			getModel: () => session.model,
-			sendMessageHandler: (message, triggerTurn) => {
-				session.sendHookMessage(message, triggerTurn).catch((e) => {
-					console.error(`Hook sendMessage failed: ${e instanceof Error ? e.message : String(e)}`);
+			sendMessageHandler: (message, options) => {
+				session.sendCustomMessage(message, options).catch((e) => {
+					console.error(`Extension sendMessage failed: ${e instanceof Error ? e.message : String(e)}`);
 				});
 			},
 			appendEntryHandler: (customType, data) => {
 				session.sessionManager.appendCustomEntry(customType, data);
 			},
+			getActiveToolsHandler: () => session.getActiveToolNames(),
+			getAllToolsHandler: () => session.getAllToolNames(),
+			setActiveToolsHandler: (toolNames: string[]) => session.setActiveToolsByName(toolNames),
 		});
-		hookRunner.onError((err) => {
-			console.error(`Hook error (${err.hookPath}): ${err.error}`);
+		extensionRunner.onError((err) => {
+			console.error(`Extension error (${err.extensionPath}): ${err.error}`);
 		});
 		// Emit session_start event
-		await hookRunner.emit({
+		await extensionRunner.emit({
 			type: "session_start",
 		});
 	}
 
-	// Emit session start event to custom tools (no UI in print mode)
-	for (const { tool } of session.customTools) {
-		if (tool.onSession) {
-			try {
-				await tool.onSession(
-					{
-						reason: "start",
-						previousSessionFile: undefined,
-					},
-					{
-						sessionManager: session.sessionManager,
-						modelRegistry: session.modelRegistry,
-						model: session.model,
-						isIdle: () => !session.isStreaming,
-						hasQueuedMessages: () => session.queuedMessageCount > 0,
-						abort: () => {
-							session.abort();
-						},
-					},
-				);
-			} catch (err) {
-				logger.warn("Tool onSession error", { error: String(err) });
-			}
-		}
-	}
-
 	// Always subscribe to enable session persistence via _handleAgentEvent
 	session.subscribe((event) => {
 		// In JSON mode, output all events
@@ -147,9 +92,6 @@ export async function runPrintMode(
 				}
 			}
 		}
-
-		// Print footer to stderr
-		printFooter();
 	}
 
 	// Ensure stdout is fully flushed before returning

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

@@ -210,10 +210,17 @@ export class RpcClient {
 	}
 
 	/**
-	 * Queue a message while agent is streaming.
+	 * Queue a steering message to interrupt the agent mid-run.
 	 */
-	async queueMessage(message: string): Promise<void> {
-		await this.send({ type: "queue_message", message });
+	async steer(message: string): Promise<void> {
+		await this.send({ type: "steer", message });
+	}
+
+	/**
+	 * Queue a follow-up message to be processed after the agent finishes.
+	 */
+	async followUp(message: string): Promise<void> {
+		await this.send({ type: "follow_up", message });
 	}
 
 	/**
@@ -226,7 +233,7 @@ export class RpcClient {
 	/**
 	 * Start a new session, optionally with parent tracking.
 	 * @param parentSession - Optional parent session path for lineage tracking
-	 * @returns Object with `cancelled: true` if a hook cancelled the new session
+	 * @returns Object with `cancelled: true` if an extension cancelled the new session
 	 */
 	async newSession(parentSession?: string): Promise<{ cancelled: boolean }> {
 		const response = await this.send({ type: "new_session", parentSession });
@@ -285,10 +292,17 @@ export class RpcClient {
 	}
 
 	/**
-	 * Set queue mode.
+	 * Set steering mode.
+	 */
+	async setSteeringMode(mode: "all" | "one-at-a-time"): Promise<void> {
+		await this.send({ type: "set_steering_mode", mode });
+	}
+
+	/**
+	 * Set follow-up mode.
 	 */
-	async setQueueMode(mode: "all" | "one-at-a-time"): Promise<void> {
-		await this.send({ type: "set_queue_mode", mode });
+	async setFollowUpMode(mode: "all" | "one-at-a-time"): Promise<void> {
+		await this.send({ type: "set_follow_up_mode", mode });
 	}
 
 	/**
@@ -353,7 +367,7 @@ export class RpcClient {
 
 	/**
 	 * Switch to a different session file.
-	 * @returns Object with `cancelled: true` if a hook cancelled the switch
+	 * @returns Object with `cancelled: true` if an extension cancelled the switch
 	 */
 	async switchSession(sessionPath: string): Promise<{ cancelled: boolean }> {
 		const response = await this.send({ type: "switch_session", sessionPath });
@@ -362,7 +376,7 @@ export class RpcClient {
 
 	/**
 	 * Branch from a specific message.
-	 * @returns Object with `text` (the message text) and `cancelled` (if hook cancelled)
+	 * @returns Object with `text` (the message text) and `cancelled` (if extension cancelled)
 	 */
 	async branch(entryId: string): Promise<{ text: string; cancelled: boolean }> {
 		const response = await this.send({ type: "branch", entryId });