gsd-pi 2.38.0-dev.eeb3520 → 2.39.0-dev.38f11d1

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;
+