@oh-my-pi/pi-coding-agent 15.9.67 → 15.10.1

package/src/modes/controllers/selector-controller.ts

@@ -7,7 +7,6 @@ import { getAgentDbPath, getProjectDir, normalizePathForComparison } from "@oh-m
 import { getRoleInfo } from "../../config/model-registry";
 import { formatModelSelectorValue } from "../../config/model-resolver";
 import { settings } from "../../config/settings";
-import { DebugSelectorComponent } from "../../debug";
 import { disableProvider, enableProvider } from "../../discovery";
 import { clearPluginRootsAndCaches, resolveActiveProjectRegistryPath } from "../../discovery/helpers";
 import {
@@ -51,6 +50,7 @@ import { SessionObserverOverlayComponent } from "../components/session-observer-
 import { SessionSelectorComponent } from "../components/session-selector";
 import { SettingsSelectorComponent } from "../components/settings-selector";
 import { ToolExecutionComponent } from "../components/tool-execution";
+import { TranscriptBlock } from "../components/transcript-container";
 import { TreeSelectorComponent } from "../components/tree-selector";
 import { UserMessageSelectorComponent } from "../components/user-message-selector";
 import type { SessionObserverRegistry } from "../session-observer-registry";
@@ -932,28 +932,28 @@ export class SelectorController {
 		try {
 			await this.ctx.session.modelRegistry.authStorage.login(providerId as OAuthProvider, {
 				onAuth: (info: { url: string; instructions?: string }) => {
-					this.ctx.chatContainer.addChild(new Spacer(1));
-					this.ctx.chatContainer.addChild(new Text(theme.fg("dim", info.url), 1, 0));
+					const block = new TranscriptBlock();
+					block.addChild(new Text(theme.fg("dim", info.url), 1, 0));
 					const hyperlink = `\x1b]8;;${info.url}\x07Click here to login\x1b]8;;\x07`;
-					this.ctx.chatContainer.addChild(new Text(theme.fg("accent", hyperlink), 1, 0));
+					block.addChild(new Text(theme.fg("accent", hyperlink), 1, 0));
 					if (info.instructions) {
-						this.ctx.chatContainer.addChild(new Spacer(1));
-						this.ctx.chatContainer.addChild(new Text(theme.fg("warning", info.instructions), 1, 0));
+						block.addChild(new Spacer(1));
+						block.addChild(new Text(theme.fg("warning", info.instructions), 1, 0));
 					}
 					if (useManualInput) {
-						this.ctx.chatContainer.addChild(new Spacer(1));
-						this.ctx.chatContainer.addChild(new Text(theme.fg("dim", MANUAL_LOGIN_TIP), 1, 0));
+						block.addChild(new Spacer(1));
+						block.addChild(new Text(theme.fg("dim", MANUAL_LOGIN_TIP), 1, 0));
 					}
-					this.ctx.ui.requestRender();
+					this.ctx.present(block);
 					this.ctx.openInBrowser(info.url);
 				},
 				onPrompt: async (prompt: { message: string; placeholder?: string }) => {
-					this.ctx.chatContainer.addChild(new Spacer(1));
-					this.ctx.chatContainer.addChild(new Text(theme.fg("warning", prompt.message), 1, 0));
+					const promptBlock = new TranscriptBlock();
+					promptBlock.addChild(new Text(theme.fg("warning", prompt.message), 1, 0));
 					if (prompt.placeholder) {
-						this.ctx.chatContainer.addChild(new Text(theme.fg("dim", prompt.placeholder), 1, 0));
+						promptBlock.addChild(new Text(theme.fg("dim", prompt.placeholder), 1, 0));
 					}
-					this.ctx.ui.requestRender();
+					this.ctx.present(promptBlock);
 					const { promise, resolve } = Promise.withResolvers<string>();
 					const codeInput = new Input();
 					codeInput.onSubmit = () => {
@@ -970,18 +970,17 @@ export class SelectorController {
 					return promise;
 				},
 				onProgress: (message: string) => {
-					this.ctx.chatContainer.addChild(new Text(theme.fg("dim", message), 1, 0));
-					this.ctx.ui.requestRender();
+					this.ctx.present(new Text(theme.fg("dim", message), 1, 0));
 				},
 				onManualCodeInput: useManualInput ? () => manualInput.waitForInput(providerId) : undefined,
 			});
 			await this.ctx.session.modelRegistry.refresh();
-			this.ctx.chatContainer.addChild(new Spacer(1));
-			this.ctx.chatContainer.addChild(
+			const block = new TranscriptBlock();
+			block.addChild(
 				new Text(theme.fg("success", `${theme.status.success} Successfully logged in to ${providerId}`), 1, 0),
 			);
-			this.ctx.chatContainer.addChild(new Text(theme.fg("dim", `Credentials saved to ${getAgentDbPath()}`), 1, 0));
-			this.ctx.ui.requestRender();
+			block.addChild(new Text(theme.fg("dim", `Credentials saved to ${getAgentDbPath()}`), 1, 0));
+			this.ctx.present(block);
 		} catch (error: unknown) {
 			this.ctx.showError(`Login failed: ${error instanceof Error ? error.message : String(error)}`);
 		} finally {
@@ -1003,20 +1002,18 @@ export class SelectorController {
 
 			await authStorage.logout(providerId);
 			await this.ctx.session.modelRegistry.refresh();
-			this.ctx.chatContainer.addChild(new Spacer(1));
-			this.ctx.chatContainer.addChild(
+			const block = new TranscriptBlock();
+			block.addChild(
 				new Text(theme.fg("success", `${theme.status.success} Successfully logged out of ${providerId}`), 1, 0),
 			);
-			this.ctx.chatContainer.addChild(
-				new Text(theme.fg("dim", `Credentials removed from ${getAgentDbPath()}`), 1, 0),
-			);
+			block.addChild(new Text(theme.fg("dim", `Credentials removed from ${getAgentDbPath()}`), 1, 0));
 			const remainingSource = authStorage.describeCredentialSource(providerId, this.ctx.session.sessionId);
 			if (remainingSource) {
-				this.ctx.chatContainer.addChild(
+				block.addChild(
 					new Text(theme.fg("warning", `${providerId} is still authenticated via ${remainingSource}`), 1, 0),
 				);
 			}
-			this.ctx.ui.requestRender();
+			this.ctx.present(block);
 		} catch (error: unknown) {
 			this.ctx.showError(`Logout failed: ${error instanceof Error ? error.message : String(error)}`);
 		}
@@ -1080,7 +1077,8 @@ export class SelectorController {
 		});
 	}
 
-	showDebugSelector(): void {
+	async showDebugSelector(): Promise<void> {
+		const { DebugSelectorComponent } = await import("../../debug");
 		this.showSelector(done => {
 			const selector = new DebugSelectorComponent(this.ctx, done);
 			return { component: selector, focus: selector };

package/src/modes/controllers/streaming-reveal.ts

@@ -0,0 +1,212 @@
+import type { AssistantMessage } from "@oh-my-pi/pi-ai";
+import { getSegmenter } from "@oh-my-pi/pi-tui";
+import type { AssistantMessageComponent } from "../components/assistant-message";
+
+export const STREAMING_REVEAL_FRAME_MS = 1000 / 30;
+export const MIN_STEP = 3;
+export const CATCHUP_FRAMES = 8;
+
+type AssistantContentBlock = AssistantMessage["content"][number];
+type StreamingRevealComponent = Pick<AssistantMessageComponent, "updateContent">;
+
+type StreamingRevealControllerOptions = {
+	getSmoothStreaming(): boolean;
+	getHideThinkingBlock(): boolean;
+	requestRender(): void;
+};
+
+function countGraphemes(text: string): number {
+	let count = 0;
+	for (const _segment of getSegmenter().segment(text)) {
+		count += 1;
+	}
+	return count;
+}
+
+function sliceGraphemes(text: string, units: number): string {
+	if (units <= 0 || text.length === 0) return "";
+	let count = 0;
+	for (const { index, segment } of getSegmenter().segment(text)) {
+		count += 1;
+		if (count >= units) {
+			const end = index + segment.length;
+			return end >= text.length ? text : text.slice(0, end);
+		}
+	}
+	return text;
+}
+
+export function visibleUnits(message: AssistantMessage, hideThinking: boolean): number {
+	let total = 0;
+	for (const block of message.content) {
+		if (block.type === "text") {
+			total += countGraphemes(block.text);
+		} else if (block.type === "thinking" && !hideThinking) {
+			total += countGraphemes(block.thinking);
+		}
+	}
+	return total;
+}
+
+function revealTextBlock(
+	block: Extract<AssistantContentBlock, { type: "text" }>,
+	remaining: number,
+): AssistantContentBlock {
+	if (remaining <= 0) return block.text.length === 0 ? block : { ...block, text: "" };
+	const units = countGraphemes(block.text);
+	if (remaining >= units) return block;
+	return { ...block, text: sliceGraphemes(block.text, remaining) };
+}
+
+function revealThinkingBlock(
+	block: Extract<AssistantContentBlock, { type: "thinking" }>,
+	remaining: number,
+): AssistantContentBlock {
+	if (remaining <= 0) return block.thinking.length === 0 ? block : { ...block, thinking: "" };
+	const units = countGraphemes(block.thinking);
+	if (remaining >= units) return block;
+	return { ...block, thinking: sliceGraphemes(block.thinking, remaining) };
+}
+
+export function buildDisplayMessage(
+	target: AssistantMessage,
+	revealed: number,
+	hideThinking: boolean,
+): AssistantMessage {
+	let remaining = Math.max(0, Math.floor(revealed));
+	const content: AssistantContentBlock[] = [];
+	for (const block of target.content) {
+		if (block.type === "text") {
+			content.push(revealTextBlock(block, remaining));
+			remaining = Math.max(0, remaining - countGraphemes(block.text));
+		} else if (block.type === "thinking" && !hideThinking) {
+			content.push(revealThinkingBlock(block, remaining));
+			remaining = Math.max(0, remaining - countGraphemes(block.thinking));
+		} else {
+			content.push(block);
+		}
+	}
+	return { ...target, content };
+}
+
+export function nextStep(backlog: number): number {
+	return Math.max(MIN_STEP, Math.ceil(Math.max(0, backlog) / CATCHUP_FRAMES));
+}
+
+export class StreamingRevealController {
+	readonly #getSmoothStreaming: () => boolean;
+	readonly #getHideThinkingBlock: () => boolean;
+	readonly #requestRender: () => void;
+	#target: AssistantMessage | undefined;
+	#component: StreamingRevealComponent | undefined;
+	#timer: NodeJS.Timeout | undefined;
+	#revealed = 0;
+	#hideThinkingBlock = false;
+	#smoothStreaming = true;
+
+	constructor(options: StreamingRevealControllerOptions) {
+		this.#getSmoothStreaming = options.getSmoothStreaming;
+		this.#getHideThinkingBlock = options.getHideThinkingBlock;
+		this.#requestRender = options.requestRender;
+	}
+
+	begin(component: StreamingRevealComponent, message: AssistantMessage): void {
+		this.stop();
+		this.#component = component;
+		this.#target = message;
+		this.#revealed = 0;
+		this.#hideThinkingBlock = this.#getHideThinkingBlock();
+		this.#smoothStreaming = this.#getSmoothStreaming();
+		if (!this.#smoothStreaming) {
+			component.updateContent(message);
+			return;
+		}
+		const total = visibleUnits(message, this.#hideThinkingBlock);
+		if (message.content.some(block => block.type === "toolCall")) {
+			// A tool call is a transcript-order boundary: finish any leading
+			// assistant text before EventController renders the separate tool card.
+			this.#revealed = total;
+			component.updateContent(buildDisplayMessage(message, this.#revealed, this.#hideThinkingBlock));
+			return;
+		}
+		this.#renderCurrent();
+		this.#syncTimer(total);
+	}
+
+	setTarget(message: AssistantMessage): void {
+		this.#target = message;
+		if (!this.#component) return;
+		if (!this.#smoothStreaming) {
+			this.#component.updateContent(message);
+			return;
+		}
+		const total = visibleUnits(message, this.#hideThinkingBlock);
+		if (message.content.some(block => block.type === "toolCall")) {
+			// A tool call is a transcript-order boundary: finish any leading
+			// assistant text before EventController renders the separate tool card.
+			this.#revealed = total;
+			this.#stopTimer();
+			this.#component.updateContent(buildDisplayMessage(message, this.#revealed, this.#hideThinkingBlock));
+			return;
+		}
+		if (this.#revealed > total) {
+			this.#revealed = total;
+		}
+		this.#renderCurrent();
+		this.#syncTimer(total);
+	}
+
+	stop(): void {
+		this.#stopTimer();
+		this.#target = undefined;
+		this.#component = undefined;
+		this.#revealed = 0;
+	}
+
+	#renderCurrent(): void {
+		if (!this.#target || !this.#component) return;
+		this.#component.updateContent(buildDisplayMessage(this.#target, this.#revealed, this.#hideThinkingBlock));
+	}
+
+	#syncTimer(total = this.#target ? visibleUnits(this.#target, this.#hideThinkingBlock) : 0): void {
+		if (!this.#target || !this.#component || this.#revealed >= total) {
+			this.#stopTimer();
+			return;
+		}
+		this.#startTimer();
+	}
+
+	#startTimer(): void {
+		if (this.#timer) return;
+		this.#timer = setInterval(() => {
+			this.#tick();
+		}, STREAMING_REVEAL_FRAME_MS);
+		this.#timer.unref?.();
+	}
+
+	#stopTimer(): void {
+		if (!this.#timer) return;
+		clearInterval(this.#timer);
+		this.#timer = undefined;
+	}
+
+	#tick(): void {
+		const target = this.#target;
+		const component = this.#component;
+		if (!target || !component) {
+			this.stop();
+			return;
+		}
+		const total = visibleUnits(target, this.#hideThinkingBlock);
+		if (this.#revealed >= total) {
+			this.#stopTimer();
+			return;
+		}
+		this.#revealed = Math.min(total, this.#revealed + nextStep(total - this.#revealed));
+		component.updateContent(buildDisplayMessage(target, this.#revealed, this.#hideThinkingBlock));
+		this.#requestRender();
+		if (this.#revealed >= total) {
+			this.#stopTimer();
+		}
+	}
+}

package/src/modes/controllers/tan-command-controller.ts

@@ -0,0 +1,173 @@
+import * as fs from "node:fs/promises";
+import type { AssistantMessage } from "@oh-my-pi/pi-ai";
+import { prompt, Snowflake } from "@oh-my-pi/pi-utils";
+import backgroundTanDispatchPrompt from "../../prompts/system/background-tan-dispatch.md" with { type: "text" };
+import { AgentRegistry, MAIN_AGENT_ID } from "../../registry/agent-registry";
+import * as sdk from "../../sdk";
+import type { AgentSession } from "../../session/agent-session";
+import { SessionManager } from "../../session/session-manager";
+import { createMCPProxyTools, createSubagentSettings } from "../../task/executor";
+import type { InteractiveModeContext } from "../types";
+
+const TAN_LABEL_PREVIEW_LENGTH = 80;
+
+function previewWork(work: string): string {
+	const singleLine = work.trim().replace(/\s+/g, " ");
+	if (singleLine.length <= TAN_LABEL_PREVIEW_LENGTH) return singleLine;
+	return `${singleLine.slice(0, TAN_LABEL_PREVIEW_LENGTH - 1)}…`;
+}
+
+function extractAssistantText(message: AssistantMessage | undefined): string {
+	if (!message) return "";
+	return message.content
+		.filter(content => content.type === "text")
+		.map(content => content.text)
+		.join("")
+		.trim();
+}
+
+async function removeCloneSession(cloneFile: string): Promise<void> {
+	await Promise.allSettled([
+		fs.rm(cloneFile, { force: true }),
+		fs.rm(cloneFile.slice(0, -6), { recursive: true, force: true }),
+	]);
+}
+
+export class TanCommandController {
+	constructor(private readonly ctx: InteractiveModeContext) {}
+
+	async start(work: string): Promise<void> {
+		const trimmedWork = work.trim();
+		if (!trimmedWork) {
+			this.ctx.showStatus("Usage: /tan <work>");
+			return;
+		}
+
+		const session = this.ctx.session;
+		if (session.isStreaming) {
+			this.ctx.showWarning("Wait for the current response to finish or abort it before using /tan.");
+			return;
+		}
+
+		const model = session.model;
+		if (!model) {
+			this.ctx.showError("No active model available for /tan.");
+			return;
+		}
+
+		const manager = session.asyncJobManager;
+		if (!manager) {
+			this.ctx.showError("Background jobs are disabled; enable async jobs to use /tan.");
+			return;
+		}
+
+		const parentFile = this.ctx.sessionManager.getSessionFile();
+		if (!parentFile) {
+			this.ctx.showError("/tan requires a persisted session.");
+			return;
+		}
+
+		const parentSessionId = session.sessionId;
+		const thinkingLevel = session.configuredThinkingLevel();
+		const systemPrompt = [...session.systemPrompt];
+		const toolNames = session.getActiveToolNames();
+		const modelRegistry = session.modelRegistry;
+		const ownerId = session.getAgentId() ?? MAIN_AGENT_ID;
+		const mcpManager = this.ctx.mcpManager;
+		const cwd = this.ctx.sessionManager.getCwd();
+		// Nest the clone inside the parent's artifact directory (like a subagent
+		// session) rather than as a top-level sibling, so it shares the parent's
+		// artifacts in place — no copy needed.
+		const sessionDir = parentFile.slice(0, -6);
+		const settings = createSubagentSettings(this.ctx.settings);
+		const customTools = mcpManager ? createMCPProxyTools(mcpManager) : undefined;
+		const enableLsp = this.ctx.settings.get("task.enableLsp") !== false;
+		const agentRegistry = AgentRegistry.global();
+		const cloneId = `Tan-${Snowflake.next()}`;
+		const label = `/tan ${previewWork(trimmedWork)}`;
+
+		await this.ctx.sessionManager.ensureOnDisk();
+		await this.ctx.sessionManager.flush();
+
+		let cloneFile = "";
+		let jobId = "";
+		try {
+			const cloneManager = await SessionManager.forkFrom(parentFile, cwd, sessionDir, undefined, {
+				suppressBreadcrumb: true,
+			});
+			cloneFile = cloneManager.getSessionFile() ?? "";
+			if (!cloneFile) throw new Error("Forked session did not create a session file.");
+
+			jobId = manager.register(
+				"task",
+				label,
+				async ({ signal }) => {
+					if (signal.aborted) throw new Error("Aborted before execution");
+
+					let clone: AgentSession | undefined;
+					try {
+						const created = await sdk.createAgentSession({
+							cwd,
+							sessionManager: cloneManager,
+							model,
+							thinkingLevel,
+							systemPrompt,
+							toolNames,
+							providerSessionId: `${parentSessionId}:tan:${Snowflake.next()}`,
+							providerPromptCacheKey: parentSessionId,
+							modelRegistry,
+							authStorage: modelRegistry.authStorage,
+							settings,
+							hasUI: false,
+							enableMCP: false,
+							customTools,
+							enableLsp,
+							agentId: cloneId,
+							agentDisplayName: "tan",
+							parentTaskPrefix: cloneId,
+							agentRegistry,
+							disableExtensionDiscovery: true,
+						});
+						clone = created.session;
+						const abortClone = () => {
+							void clone?.abort();
+						};
+						signal.addEventListener("abort", abortClone, { once: true });
+						try {
+							if (signal.aborted) {
+								abortClone();
+								throw new Error("Aborted before execution");
+							}
+							await clone.prompt(trimmedWork, { attribution: "user" });
+							await clone.waitForIdle();
+							return extractAssistantText(clone.getLastAssistantMessage()) || "(no output)";
+						} finally {
+							signal.removeEventListener("abort", abortClone);
+						}
+					} finally {
+						await clone?.dispose();
+					}
+				},
+				{ ownerId },
+			);
+		} catch (error) {
+			if (cloneFile) await removeCloneSession(cloneFile);
+			this.ctx.showError(error instanceof Error ? error.message : String(error));
+			return;
+		}
+
+		const content = prompt.render(backgroundTanDispatchPrompt, { jobId, work: trimmedWork });
+		await session.sendCustomMessage(
+			{
+				customType: "background-tan-dispatch",
+				content,
+				display: true,
+				attribution: "user",
+				details: { jobId, work: trimmedWork, sessionFile: cloneFile },
+			},
+			{ triggerTurn: false },
+		);
+		this.ctx.rebuildChatFromMessages();
+		this.ctx.showStatus(`Dispatched background tan ${jobId}`);
+	}
+}

package/src/modes/index.ts

@@ -2,11 +2,13 @@ import { emergencyTerminalRestore } from "@oh-my-pi/pi-tui";
 import { postmortem } from "@oh-my-pi/pi-utils";
 
 /**
- * Run modes for the coding agent.
+ * Interactive mode and embeddable RPC client exports for the coding agent.
+ *
+ * Branch-specific runners live in their concrete modules so importing this
+ * barrel does not pull print, RPC server, or ACP server mode into the normal
+ * TUI graph.
  */
-export { runAcpMode } from "./acp";
 export { InteractiveMode, type InteractiveModeOptions } from "./interactive-mode";
-export { type PrintModeOptions, runPrintMode } from "./print-mode";
 export {
 	defineRpcClientTool,
 	type ModelInfo,
@@ -17,7 +19,6 @@ export {
 	type RpcClientToolResult,
 	type RpcEventListener,
 } from "./rpc/rpc-client";
-export { runRpcMode } from "./rpc/rpc-mode";
 export type {
 	RpcCommand,
 	RpcHostToolCallRequest,