gsd-pi 2.38.0-dev.eeb3520 → 2.39.0-dev.20aba06

package/packages/pi-coding-agent/src/modes/interactive/controllers/chat-controller.ts

@@ -0,0 +1,302 @@
+import { Loader, Spacer, Text } from "@gsd/pi-tui";
+
+import type { InteractiveModeEvent, InteractiveModeStateHost } from "../interactive-mode-state.js";
+import { theme } from "../theme/theme.js";
+import { AssistantMessageComponent } from "../components/assistant-message.js";
+import { ToolExecutionComponent } from "../components/tool-execution.js";
+import { appKey } from "../components/keybinding-hints.js";
+
+export async function handleAgentEvent(host: InteractiveModeStateHost & {
+	init: () => Promise<void>;
+	getMarkdownThemeWithSettings: () => any;
+	addMessageToChat: (message: any, options?: any) => void;
+	formatWebSearchResult: (content: unknown) => string;
+	getRegisteredToolDefinition: (toolName: string) => any;
+	checkShutdownRequested: () => Promise<void>;
+	rebuildChatFromMessages: () => void;
+	flushCompactionQueue: (options?: { willRetry?: boolean }) => Promise<void>;
+	showStatus: (message: string) => void;
+	showError: (message: string) => void;
+	updatePendingMessagesDisplay: () => void;
+}, event: InteractiveModeEvent): Promise<void> {
+	if (!host.isInitialized) {
+		await host.init();
+	}
+
+	host.footer.invalidate();
+
+	switch (event.type) {
+		case "agent_start":
+			if (host.retryEscapeHandler) {
+				host.defaultEditor.onEscape = host.retryEscapeHandler;
+				host.retryEscapeHandler = undefined;
+			}
+			if (host.retryLoader) {
+				host.retryLoader.stop();
+				host.retryLoader = undefined;
+			}
+			if (host.loadingAnimation) {
+				host.loadingAnimation.stop();
+			}
+			host.statusContainer.clear();
+			host.loadingAnimation = new Loader(
+				host.ui,
+				(spinner) => theme.fg("accent", spinner),
+				(text) => theme.fg("muted", text),
+				host.defaultWorkingMessage,
+			);
+			host.statusContainer.addChild(host.loadingAnimation);
+			if (host.pendingWorkingMessage !== undefined) {
+				if (host.pendingWorkingMessage) {
+					host.loadingAnimation.setMessage(host.pendingWorkingMessage);
+				}
+				host.pendingWorkingMessage = undefined;
+			}
+			host.ui.requestRender();
+			break;
+
+		case "message_start":
+			if (event.message.role === "custom") {
+				host.addMessageToChat(event.message);
+				host.ui.requestRender();
+			} else if (event.message.role === "user") {
+				host.addMessageToChat(event.message);
+				host.updatePendingMessagesDisplay();
+				host.ui.requestRender();
+			} else if (event.message.role === "assistant") {
+				host.streamingComponent = new AssistantMessageComponent(
+					undefined,
+					host.hideThinkingBlock,
+					host.getMarkdownThemeWithSettings(),
+				);
+				host.streamingMessage = event.message;
+				host.chatContainer.addChild(host.streamingComponent);
+				host.streamingComponent.updateContent(host.streamingMessage);
+				host.ui.requestRender();
+			}
+			break;
+
+		case "message_update":
+			if (host.streamingComponent && event.message.role === "assistant") {
+				host.streamingMessage = event.message;
+				host.streamingComponent.updateContent(host.streamingMessage);
+				for (const content of host.streamingMessage.content) {
+					if (content.type === "toolCall") {
+						if (!host.pendingTools.has(content.id)) {
+							const component = new ToolExecutionComponent(
+								content.name,
+								content.arguments,
+								{ showImages: host.settingsManager.getShowImages() },
+								host.getRegisteredToolDefinition(content.name),
+								host.ui,
+							);
+							component.setExpanded(host.toolOutputExpanded);
+							host.chatContainer.addChild(component);
+							host.pendingTools.set(content.id, component);
+						} else {
+							host.pendingTools.get(content.id)?.updateArgs(content.arguments);
+						}
+					} else if (content.type === "serverToolUse") {
+						if (!host.pendingTools.has(content.id)) {
+							const component = new ToolExecutionComponent(
+								content.name,
+								content.input ?? {},
+								{ showImages: host.settingsManager.getShowImages() },
+								undefined,
+								host.ui,
+							);
+							component.setExpanded(host.toolOutputExpanded);
+							host.chatContainer.addChild(component);
+							host.pendingTools.set(content.id, component);
+						}
+					} else if (content.type === "webSearchResult") {
+						const component = host.pendingTools.get(content.toolUseId);
+						if (component) {
+							const searchContent = content.content;
+							const isError = searchContent && typeof searchContent === "object" && "type" in (searchContent as any) && (searchContent as any).type === "web_search_tool_result_error";
+							component.updateResult({
+								content: [{ type: "text", text: host.formatWebSearchResult(searchContent) }],
+								isError: !!isError,
+							});
+							host.pendingTools.delete(content.toolUseId);
+						}
+					}
+				}
+				host.ui.requestRender();
+			}
+			break;
+
+		case "message_end":
+			if (event.message.role === "user") break;
+			if (host.streamingComponent && event.message.role === "assistant") {
+				host.streamingMessage = event.message;
+				let errorMessage: string | undefined;
+				if (host.streamingMessage.stopReason === "aborted") {
+					const retryAttempt = host.session.retryAttempt;
+					errorMessage = retryAttempt > 0
+						? `Aborted after ${retryAttempt} retry attempt${retryAttempt > 1 ? "s" : ""}`
+						: "Operation aborted";
+					host.streamingMessage.errorMessage = errorMessage;
+				}
+				host.streamingComponent.updateContent(host.streamingMessage);
+				if (host.streamingMessage.stopReason === "aborted" || host.streamingMessage.stopReason === "error") {
+					if (!errorMessage) {
+						errorMessage = host.streamingMessage.errorMessage || "Error";
+					}
+					for (const [, component] of host.pendingTools.entries()) {
+						component.updateResult({ content: [{ type: "text", text: errorMessage }], isError: true });
+					}
+					host.pendingTools.clear();
+				} else {
+					for (const [, component] of host.pendingTools.entries()) {
+						component.setArgsComplete();
+					}
+				}
+				host.streamingComponent = undefined;
+				host.streamingMessage = undefined;
+				host.footer.invalidate();
+			}
+			host.ui.requestRender();
+			break;
+
+		case "tool_execution_start":
+			if (!host.pendingTools.has(event.toolCallId)) {
+				const component = new ToolExecutionComponent(
+					event.toolName,
+					event.args,
+					{ showImages: host.settingsManager.getShowImages() },
+					host.getRegisteredToolDefinition(event.toolName),
+					host.ui,
+				);
+				component.setExpanded(host.toolOutputExpanded);
+				host.chatContainer.addChild(component);
+				host.pendingTools.set(event.toolCallId, component);
+				host.ui.requestRender();
+			}
+			break;
+
+		case "tool_execution_update": {
+			const component = host.pendingTools.get(event.toolCallId);
+			if (component) {
+				component.updateResult({ ...event.partialResult, isError: false }, true);
+				host.ui.requestRender();
+			}
+			break;
+		}
+
+		case "tool_execution_end": {
+			const component = host.pendingTools.get(event.toolCallId);
+			if (component) {
+				component.updateResult({ ...event.result, isError: event.isError });
+				host.pendingTools.delete(event.toolCallId);
+				host.ui.requestRender();
+			}
+			break;
+		}
+
+		case "agent_end":
+			if (host.loadingAnimation) {
+				host.loadingAnimation.stop();
+				host.loadingAnimation = undefined;
+				host.statusContainer.clear();
+			}
+			if (host.streamingComponent) {
+				host.chatContainer.removeChild(host.streamingComponent);
+				host.streamingComponent = undefined;
+				host.streamingMessage = undefined;
+			}
+			host.pendingTools.clear();
+			await host.checkShutdownRequested();
+			host.ui.requestRender();
+			break;
+
+		case "auto_compaction_start":
+			host.autoCompactionEscapeHandler = host.defaultEditor.onEscape;
+			host.defaultEditor.onEscape = () => host.session.abortCompaction();
+			host.statusContainer.clear();
+			host.autoCompactionLoader = new Loader(
+				host.ui,
+				(spinner) => theme.fg("accent", spinner),
+				(text) => theme.fg("muted", text),
+				`${event.reason === "overflow" ? "Context overflow detected, " : ""}Auto-compacting... (${appKey(host.keybindings, "interrupt")} to cancel)`,
+			);
+			host.statusContainer.addChild(host.autoCompactionLoader);
+			host.ui.requestRender();
+			break;
+
+		case "auto_compaction_end":
+			if (host.autoCompactionEscapeHandler) {
+				host.defaultEditor.onEscape = host.autoCompactionEscapeHandler;
+				host.autoCompactionEscapeHandler = undefined;
+			}
+			if (host.autoCompactionLoader) {
+				host.autoCompactionLoader.stop();
+				host.autoCompactionLoader = undefined;
+				host.statusContainer.clear();
+			}
+			if (event.aborted) {
+				host.showStatus("Auto-compaction cancelled");
+			} else if (event.result) {
+				host.chatContainer.clear();
+				host.rebuildChatFromMessages();
+				host.addMessageToChat({
+					role: "compactionSummary",
+					tokensBefore: event.result.tokensBefore,
+					summary: event.result.summary,
+					timestamp: Date.now(),
+				});
+				host.footer.invalidate();
+			} else if (event.errorMessage) {
+				host.chatContainer.addChild(new Spacer(1));
+				host.chatContainer.addChild(new Text(theme.fg("error", event.errorMessage), 1, 0));
+			}
+			void host.flushCompactionQueue({ willRetry: event.willRetry });
+			host.ui.requestRender();
+			break;
+
+		case "auto_retry_start":
+			host.retryEscapeHandler = host.defaultEditor.onEscape;
+			host.defaultEditor.onEscape = () => host.session.abortRetry();
+			host.statusContainer.clear();
+			host.retryLoader = new Loader(
+				host.ui,
+				(spinner) => theme.fg("warning", spinner),
+				(text) => theme.fg("muted", text),
+				`Retrying (${event.attempt}/${event.maxAttempts}) in ${Math.round(event.delayMs / 1000)}s... (${appKey(host.keybindings, "interrupt")} to cancel)`,
+			);
+			host.statusContainer.addChild(host.retryLoader);
+			host.ui.requestRender();
+			break;
+
+		case "auto_retry_end":
+			if (host.retryEscapeHandler) {
+				host.defaultEditor.onEscape = host.retryEscapeHandler;
+				host.retryEscapeHandler = undefined;
+			}
+			if (host.retryLoader) {
+				host.retryLoader.stop();
+				host.retryLoader = undefined;
+				host.statusContainer.clear();
+			}
+			if (!event.success) {
+				host.showError(`Retry failed after ${event.attempt} attempts: ${event.finalError || "Unknown error"}`);
+			}
+			host.ui.requestRender();
+			break;
+
+		case "fallback_provider_switch":
+			host.showStatus(`Switched from ${event.from} → ${event.to} (${event.reason})`);
+			host.ui.requestRender();
+			break;
+
+		case "fallback_provider_restored":
+			host.showStatus(`Restored to ${event.provider}`);
+			host.ui.requestRender();
+			break;
+
+		case "fallback_chain_exhausted":
+			host.showError(event.reason);
+			host.ui.requestRender();
+			break;
+	}
+}

package/packages/pi-coding-agent/src/modes/interactive/controllers/extension-ui-controller.ts

@@ -0,0 +1,59 @@
+import type { ExtensionUIContext } from "../../../core/extensions/index.js";
+
+import { Theme, getAvailableThemesWithPaths, getThemeByName, setTheme, setThemeInstance, theme } from "../theme/theme.js";
+import { appKey } from "../components/keybinding-hints.js";
+
+export function createExtensionUIContext(host: any): ExtensionUIContext {
+	return {
+		select: (title, options, opts) => host.showExtensionSelector(title, options, opts),
+		confirm: (title, message, opts) => host.showExtensionConfirm(title, message, opts),
+		input: (title, placeholder, opts) => host.showExtensionInput(title, placeholder, opts),
+		notify: (message, type) => host.showExtensionNotify(message, type),
+		onTerminalInput: (handler) => host.addExtensionTerminalInputListener(handler),
+		setStatus: (key, text) => host.setExtensionStatus(key, text),
+		setWorkingMessage: (message) => {
+			if (host.loadingAnimation) {
+				if (message) {
+					host.loadingAnimation.setMessage(message);
+				} else {
+					host.loadingAnimation.setMessage(`${host.defaultWorkingMessage} (${appKey(host.keybindings, "interrupt")} to interrupt)`);
+				}
+			} else {
+				host.pendingWorkingMessage = message;
+			}
+		},
+		setWidget: (key, content, options) => host.setExtensionWidget(key, content, options),
+		setFooter: (factory) => host.setExtensionFooter(factory),
+		setHeader: (factory) => host.setExtensionHeader(factory),
+		setTitle: (title) => host.ui.terminal.setTitle(title),
+		custom: (factory, options) => host.showExtensionCustom(factory, options),
+		pasteToEditor: (text) => host.editor.handleInput(`\x1b[200~${text}\x1b[201~`),
+		setEditorText: (text) => host.editor.setText(text),
+		getEditorText: () => host.editor.getText(),
+		editor: (title, prefill) => host.showExtensionEditor(title, prefill),
+		setEditorComponent: (factory) => host.setCustomEditorComponent(factory),
+		get theme() {
+			return theme;
+		},
+		getAllThemes: () => getAvailableThemesWithPaths(),
+		getTheme: (name) => getThemeByName(name),
+		setTheme: (themeOrName) => {
+			if (themeOrName instanceof Theme) {
+				setThemeInstance(themeOrName);
+				host.ui.requestRender();
+				return { success: true };
+			}
+			const result = setTheme(themeOrName, true);
+			if (result.success) {
+				if (host.settingsManager.getTheme() !== themeOrName) {
+					host.settingsManager.setTheme(themeOrName);
+				}
+				host.ui.requestRender();
+			}
+			return result;
+		},
+		getToolsExpanded: () => host.toolOutputExpanded,
+		setToolsExpanded: (expanded) => host.setToolsExpanded(expanded),
+	};
+}
+

package/packages/pi-coding-agent/src/modes/interactive/controllers/input-controller.ts

@@ -0,0 +1,68 @@
+import { dispatchSlashCommand } from "../slash-command-handlers.js";
+import type { InteractiveModeStateHost } from "../interactive-mode-state.js";
+
+export function setupEditorSubmitHandler(host: InteractiveModeStateHost & {
+	getSlashCommandContext: () => any;
+	handleBashCommand: (command: string, excludeFromContext?: boolean) => Promise<void>;
+	showWarning: (message: string) => void;
+	updateEditorBorderColor: () => void;
+	isExtensionCommand: (text: string) => boolean;
+	queueCompactionMessage: (text: string, mode: "steer" | "followUp") => void;
+	updatePendingMessagesDisplay: () => void;
+	flushPendingBashComponents: () => void;
+}): void {
+	host.defaultEditor.onSubmit = async (text: string) => {
+		text = text.trim();
+		if (!text) return;
+
+		if (text.startsWith("/")) {
+			const handled = await dispatchSlashCommand(text, host.getSlashCommandContext());
+			if (handled) {
+				host.editor.setText("");
+				return;
+			}
+		}
+
+		if (text.startsWith("!")) {
+			const isExcluded = text.startsWith("!!");
+			const command = isExcluded ? text.slice(2).trim() : text.slice(1).trim();
+			if (command) {
+				if (host.session.isBashRunning) {
+					host.showWarning("A bash command is already running. Press Esc to cancel it first.");
+					host.editor.setText(text);
+					return;
+				}
+				host.editor.addToHistory?.(text);
+				await host.handleBashCommand(command, isExcluded);
+				host.isBashMode = false;
+				host.updateEditorBorderColor();
+				return;
+			}
+		}
+
+		if (host.session.isCompacting) {
+			if (host.isExtensionCommand(text)) {
+				host.editor.addToHistory?.(text);
+				host.editor.setText("");
+				await host.session.prompt(text);
+			} else {
+				host.queueCompactionMessage(text, "steer");
+			}
+			return;
+		}
+
+		if (host.session.isStreaming) {
+			host.editor.addToHistory?.(text);
+			host.editor.setText("");
+			await host.session.prompt(text, { streamingBehavior: "steer" });
+			host.updatePendingMessagesDisplay();
+			host.ui.requestRender();
+			return;
+		}
+
+		host.flushPendingBashComponents();
+		host.onInputCallback?.(text);
+		host.editor.addToHistory?.(text);
+	};
+}
+

package/packages/pi-coding-agent/src/modes/interactive/controllers/model-controller.ts

@@ -0,0 +1,71 @@
+import type { Model } from "@gsd/pi-ai";
+
+export async function handleModelCommand(host: any, searchTerm?: string): Promise<void> {
+	if (!searchTerm) {
+		host.showModelSelector();
+		return;
+	}
+
+	const model = await findExactModelMatch(host, searchTerm);
+	if (model) {
+		try {
+			await host.session.setModel(model);
+			host.footer.invalidate();
+			host.updateEditorBorderColor();
+			host.showStatus(`Model: ${model.id}`);
+			host.checkDaxnutsEasterEgg(model);
+		} catch (error) {
+			host.showError(error instanceof Error ? error.message : String(error));
+		}
+		return;
+	}
+
+	host.showModelSelector(searchTerm);
+}
+
+export async function findExactModelMatch(host: any, searchTerm: string): Promise<Model<any> | undefined> {
+	const term = searchTerm.trim();
+	if (!term) return undefined;
+
+	let targetProvider: string | undefined;
+	let targetModelId = "";
+
+	if (term.includes("/")) {
+		const parts = term.split("/", 2);
+		targetProvider = parts[0]?.trim().toLowerCase();
+		targetModelId = parts[1]?.trim().toLowerCase() ?? "";
+	} else {
+		targetModelId = term.toLowerCase();
+	}
+
+	if (!targetModelId) return undefined;
+
+	const models = await getModelCandidates(host);
+	const exactMatches = models.filter((item) => {
+		const idMatch = item.id.toLowerCase() === targetModelId;
+		const providerMatch = !targetProvider || item.provider.toLowerCase() === targetProvider;
+		return idMatch && providerMatch;
+	});
+
+	return exactMatches.length === 1 ? exactMatches[0] : undefined;
+}
+
+export async function getModelCandidates(host: any): Promise<Model<any>[]> {
+	if (host.session.scopedModels.length > 0) {
+		return host.session.scopedModels.map((scoped: any) => scoped.model);
+	}
+
+	host.session.modelRegistry.refresh();
+	try {
+		return await host.session.modelRegistry.getAvailable();
+	} catch {
+		return [];
+	}
+}
+
+export async function updateAvailableProviderCount(host: any): Promise<void> {
+	const models = await getModelCandidates(host);
+	const uniqueProviders = new Set(models.map((m) => m.provider));
+	host.footerDataProvider.setAvailableProviderCount(uniqueProviders.size);
+}
+

package/packages/pi-coding-agent/src/modes/interactive/interactive-mode-state.ts

@@ -0,0 +1,37 @@
+import type { AgentSessionEvent } from "../../core/agent-session.js";
+
+export interface InteractiveModeStateHost {
+	defaultEditor: any;
+	editor: any;
+	session: any;
+	ui: any;
+	footer: any;
+	keybindings: any;
+	statusContainer: any;
+	chatContainer: any;
+	settingsManager: any;
+	pendingTools: Map<string, any>;
+	toolOutputExpanded: boolean;
+	hideThinkingBlock: boolean;
+	isBashMode: boolean;
+	onInputCallback?: (text: string) => void;
+	isInitialized: boolean;
+	loadingAnimation?: any;
+	pendingWorkingMessage?: string;
+	defaultWorkingMessage: string;
+	streamingComponent?: any;
+	streamingMessage?: any;
+	retryEscapeHandler?: () => void;
+	retryLoader?: any;
+	autoCompactionLoader?: any;
+	autoCompactionEscapeHandler?: () => void;
+	compactionQueuedMessages: Array<{ text: string; mode: "steer" | "followUp" }>;
+	extensionSelector?: any;
+	extensionInput?: any;
+	extensionEditor?: any;
+	editorContainer: any;
+	keybindingsManager?: any;
+}
+
+export type InteractiveModeEvent = AgentSessionEvent;
+