gsd-pi 2.76.0 → 2.77.0-dev.538325aea

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

@@ -0,0 +1,63 @@
+import type { ExtensionUIContext } from "@gsd/agent-types";
+
+import { Theme } from "@gsd/pi-coding-agent";
+import { getAvailableThemesWithPaths, getThemeByName, setTheme, setThemeInstance } from "../../../pi-coding-agent-compat.js";
+import { theme } from "../../../theme.js";
+import { appKey } from "../components/keybinding-hints.js";
+import type { InteractiveModeStateHost } from "../interactive-mode-state.js";
+
+export function createExtensionUIContext(host: InteractiveModeStateHost): 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;
+		},
+		// vendor-seam: dual-module-path -- theme API returns pi-internal types that don't match ExtensionUIContext shape
+		getAllThemes: () => getAvailableThemesWithPaths() as unknown as ReturnType<ExtensionUIContext["getAllThemes"]>,
+		getTheme: (name) => getThemeByName(name) as unknown as ReturnType<ExtensionUIContext["getTheme"]>,
+		setTheme: (themeOrName) => {
+			if (themeOrName instanceof Theme) {
+				// vendor-seam: dual-module-path -- setThemeInstance expects pi-internal Theme nominal type
+				setThemeInstance(themeOrName as unknown as Parameters<typeof setThemeInstance>[0]);
+				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/gsd-agent-modes/src/modes/interactive/controllers/input-controller.test.ts

@@ -0,0 +1,183 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { setupEditorSubmitHandler } from "./input-controller.js";
+
+type HostOptions = {
+	knownSlashCommands?: string[];
+};
+
+function getSlashCommandName(text: string): string {
+	const trimmed = text.trim();
+	const spaceIndex = trimmed.indexOf(" ");
+	return spaceIndex === -1 ? trimmed.slice(1) : trimmed.slice(1, spaceIndex);
+}
+
+function createHost(options: HostOptions = {}) {
+	const prompted: string[] = [];
+	const errors: string[] = [];
+	const warnings: string[] = [];
+	const history: string[] = [];
+	const knownSlashCommands = new Set(options.knownSlashCommands ?? []);
+	let editorText = "";
+	let settingsOpened = 0;
+
+	const editor = {
+		setText(text: string) {
+			editorText = text;
+		},
+		getText() {
+			return editorText;
+		},
+		addToHistory(text: string) {
+			history.push(text);
+		},
+	};
+
+	const host = {
+		defaultEditor: editor as typeof editor & { onSubmit?: (text: string) => Promise<void> },
+		editor,
+		session: {
+			isBashRunning: false,
+			isCompacting: false,
+			isStreaming: false,
+			prompt: async (text: string) => {
+				prompted.push(text);
+			},
+		},
+		ui: {
+			requestRender() {},
+		},
+		getSlashCommandContext: () => ({
+			showSettingsSelector: () => {
+				settingsOpened += 1;
+			},
+		}),
+		handleBashCommand: async () => {},
+		showWarning(message: string) {
+			warnings.push(message);
+		},
+		showError(message: string) {
+			errors.push(message);
+		},
+		updateEditorBorderColor() {},
+		isExtensionCommand() {
+			return false;
+		},
+		isKnownSlashCommand(text: string) {
+			return knownSlashCommands.has(getSlashCommandName(text));
+		},
+		queueCompactionMessage() {},
+		updatePendingMessagesDisplay() {},
+		flushPendingBashComponents() {},
+	};
+
+	setupEditorSubmitHandler(host as any);
+
+	return {
+		host: host as typeof host & { defaultEditor: typeof editor & { onSubmit: (text: string) => Promise<void> } },
+		prompted,
+		errors,
+		warnings,
+		history,
+		getEditorText: () => editorText,
+		getSettingsOpened: () => settingsOpened,
+	};
+}
+
+test("input-controller: built-in slash commands stay in TUI dispatch", async () => {
+	const { host, prompted, errors, getSettingsOpened, getEditorText } = createHost();
+
+	await host.defaultEditor.onSubmit("/settings");
+
+	assert.equal(getSettingsOpened(), 1, "built-in /settings should open the settings selector");
+	assert.deepEqual(prompted, [], "built-in slash commands should not reach session.prompt");
+	assert.deepEqual(errors, [], "built-in slash commands should not show errors");
+	assert.equal(getEditorText(), "", "built-in slash commands should clear the editor after handling");
+});
+
+test("input-controller: extension slash commands fall through to session.prompt", async () => {
+	const { host, prompted, errors, history } = createHost({ knownSlashCommands: ["gsd"] });
+
+	await host.defaultEditor.onSubmit("/gsd help");
+
+	assert.deepEqual(prompted, ["/gsd help"], "known extension slash commands should reach session.prompt");
+	assert.deepEqual(errors, [], "known extension slash commands should not show unknown-command errors");
+	assert.deepEqual(history, ["/gsd help"], "known extension slash commands should still be added to history");
+});
+
+test("input-controller: prompt template slash commands fall through to session.prompt", async () => {
+	const { host, prompted, errors } = createHost({ knownSlashCommands: ["daily"] });
+
+	await host.defaultEditor.onSubmit("/daily focus area");
+
+	assert.deepEqual(prompted, ["/daily focus area"]);
+	assert.deepEqual(errors, []);
+});
+
+test("input-controller: skill slash commands fall through to session.prompt", async () => {
+	const { host, prompted, errors } = createHost({ knownSlashCommands: ["skill:create-skill"] });
+
+	await host.defaultEditor.onSubmit("/skill:create-skill routing bug");
+
+	assert.deepEqual(prompted, ["/skill:create-skill routing bug"]);
+	assert.deepEqual(errors, []);
+});
+
+test("input-controller: disabled skill slash commands stay unknown", async () => {
+	const { host, prompted, errors } = createHost();
+
+	await host.defaultEditor.onSubmit("/skill:create-skill routing bug");
+
+	assert.deepEqual(prompted, []);
+	assert.deepEqual(errors, ["Unknown command: /skill:create-skill. Use slash autocomplete to see available commands."]);
+});
+
+test("input-controller: /export prefix does not swallow unrelated slash commands", async () => {
+	const { host, prompted, errors } = createHost();
+
+	await host.defaultEditor.onSubmit("/exportfoo");
+
+	assert.deepEqual(prompted, []);
+	assert.deepEqual(errors, ["Unknown command: /exportfoo. Use slash autocomplete to see available commands."]);
+});
+
+test("input-controller: truly unknown slash commands stop before session.prompt", async () => {
+	const { host, prompted, errors, getEditorText } = createHost();
+
+	await host.defaultEditor.onSubmit("/definitely-not-a-command");
+
+	assert.deepEqual(prompted, [], "unknown slash commands should not reach session.prompt");
+	assert.deepEqual(
+		errors,
+		["Unknown command: /definitely-not-a-command. Use slash autocomplete to see available commands."],
+	);
+	assert.equal(getEditorText(), "", "unknown slash commands should clear the editor after showing the error");
+});
+
+test("input-controller: absolute file paths are not treated as slash commands (#3478)", async () => {
+	const { host, prompted, errors } = createHost();
+
+	await host.defaultEditor.onSubmit("/Users/name/Desktop/screenshot.png");
+
+	assert.deepEqual(errors, [], "file paths should not trigger unknown command error");
+	assert.deepEqual(prompted, ["/Users/name/Desktop/screenshot.png"], "file paths should be sent as plain input");
+});
+
+test("input-controller: Linux absolute paths are not treated as slash commands (#3478)", async () => {
+	const { host, prompted, errors } = createHost();
+
+	await host.defaultEditor.onSubmit("/home/user/documents/file.txt");
+
+	assert.deepEqual(errors, [], "Linux paths should not trigger unknown command error");
+	assert.deepEqual(prompted, ["/home/user/documents/file.txt"], "Linux paths should be sent as plain input");
+});
+
+test("input-controller: /tmp paths are not treated as slash commands (#3478)", async () => {
+	const { host, prompted, errors } = createHost();
+
+	await host.defaultEditor.onSubmit("/tmp/some-file.log");
+
+	assert.deepEqual(errors, []);
+	assert.deepEqual(prompted, ["/tmp/some-file.log"]);
+});

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

@@ -0,0 +1,140 @@
+import { dispatchSlashCommand, type SlashCommandContext } from "../slash-command-handlers.js";
+import type { InteractiveModeStateHost } from "../interactive-mode-state.js";
+import type { ContextualTips } from "@gsd/agent-types";
+
+export function setupEditorSubmitHandler(host: InteractiveModeStateHost & {
+	getSlashCommandContext: () => SlashCommandContext;
+	handleBashCommand: (command: string, excludeFromContext?: boolean) => Promise<void>;
+	showWarning: (message: string) => void;
+	showError: (message: string) => void;
+	showTip: (message: string) => void;
+	updateEditorBorderColor: () => void;
+	isExtensionCommand: (text: string) => boolean;
+	isKnownSlashCommand: (text: string) => boolean;
+	queueCompactionMessage: (text: string, mode: "steer" | "followUp") => void;
+	updatePendingMessagesDisplay: () => void;
+	flushPendingBashComponents: () => void;
+	contextualTips: ContextualTips;
+	getContextPercent: () => number | undefined;
+	options?: { submitPromptsDirectly?: boolean };
+}): void {
+	host.defaultEditor.onSubmit = async (text: string) => {
+		text = text.trim();
+		if (!text) return;
+
+		if (text.startsWith("/") && !looksLikeFilePath(text)) {
+			const handled = await dispatchSlashCommand(text, host.getSlashCommandContext());
+			if (handled) {
+				host.editor.setText("");
+				return;
+			}
+			if (!host.isKnownSlashCommand(text)) {
+				const command = text.split(/\s/)[0];
+				host.showError(`Unknown command: ${command}. Use slash autocomplete to see available commands.`);
+				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;
+				}
+				// Track included bash commands for double-bang tip
+				if (!isExcluded) {
+					host.contextualTips.recordBashIncluded();
+				}
+				host.editor.addToHistory?.(text);
+				await host.handleBashCommand(command, isExcluded);
+				host.isBashMode = false;
+				host.updateEditorBorderColor();
+				return;
+			}
+		}
+
+		// Evaluate contextual tips before sending to agent
+		const tip = host.contextualTips.evaluate({
+			input: text,
+			isStreaming: host.session.isStreaming,
+			thinkingLevel: host.session.thinkingLevel,
+			contextPercent: host.getContextPercent(),
+		});
+		if (tip) {
+			host.showTip(tip);
+		}
+
+		if (host.session.isCompacting) {
+			if (host.isExtensionCommand(text)) {
+				host.editor.addToHistory?.(text);
+				host.editor.setText("");
+				try {
+					await host.session.prompt(text);
+				} catch (error: unknown) {
+					const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+					host.showError(errorMessage);
+				}
+			} 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();
+
+		if (host.onInputCallback) {
+			host.onInputCallback(text);
+			host.editor.addToHistory?.(text);
+			return;
+		}
+
+		if (host.options?.submitPromptsDirectly) {
+			host.editor.addToHistory?.(text);
+			try {
+				await host.session.prompt(text);
+			} catch (error: unknown) {
+				const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+				host.showError(errorMessage);
+			}
+			return;
+		}
+
+		host.editor.addToHistory?.(text);
+		// submitPromptsDirectly is false — still dispatch via session.prompt so user input
+		// is not silently discarded.
+		try {
+			await host.session.prompt(text);
+		} catch (error: unknown) {
+			const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+			host.showError(errorMessage);
+		}
+	};
+}
+
+/**
+ * Distinguish absolute file paths from slash commands (#3478).
+ * Drag-and-drop inserts paths like "/Users/name/Desktop/file.png" which
+ * should be treated as plain text input, not a /Users command.
+ *
+ * Heuristic: a slash command is a single token like "/help" or "/gsd auto".
+ * File paths have a second "/" within the first token (e.g., "/Users/...").
+ */
+function looksLikeFilePath(text: string): boolean {
+	const firstToken = text.split(/\s/)[0];
+	// Slash commands: /help, /gsd, /commit — single "/" at start only.
+	// File paths: /Users/name/file, /home/user/file, /tmp/x — contain "/" after position 0.
+	return firstToken.indexOf("/", 1) !== -1;
+}

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

@@ -0,0 +1,77 @@
+import type { Api, Model } from "@gsd/pi-ai";
+import type { ScopedModel } from "../../../pi-coding-agent-compat.js";
+import type { InteractiveModeStateHost } from "../interactive-mode-state.js";
+
+export async function handleModelCommand(host: InteractiveModeStateHost, 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: InteractiveModeStateHost, searchTerm: string): Promise<Model<Api> | 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: InteractiveModeStateHost): Promise<Model<Api>[]> {
+	if (host.session.scopedModels.length > 0) {
+		// Filter scoped models by provider auth readiness so callers like
+		// findExactModelMatch can't resolve a scoped-but-unconfigured model.
+		const registry = host.session.modelRegistry;
+		return host.session.scopedModels
+			.filter((scoped: ScopedModel) => registry.isProviderRequestReady(scoped.model.provider))
+			.map((scoped: ScopedModel) => scoped.model);
+	}
+
+	host.session.modelRegistry.refresh();
+	try {
+		return await host.session.modelRegistry.getAvailable();
+	} catch {
+		return [];
+	}
+}
+
+export async function updateAvailableProviderCount(host: InteractiveModeStateHost): Promise<void> {
+	const models = await getModelCandidates(host);
+	const uniqueProviders = new Set(models.map((m) => m.provider));
+	host.footerDataProvider.setAvailableProviderCount(uniqueProviders.size);
+}

package/packages/gsd-agent-modes/src/modes/interactive/interactive-mode-ordering.test.ts

@@ -0,0 +1,44 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { buildAssistantReplaySegments } from "./interactive-mode.js";
+
+test("buildAssistantReplaySegments preserves tool-first ordering", () => {
+	const segments = buildAssistantReplaySegments([
+		{ type: "toolCall", id: "t1", name: "read", arguments: {} },
+		{ type: "text", text: "Done." },
+	]);
+
+	assert.deepEqual(segments, [
+		{ kind: "tool", contentIndex: 0 },
+		{ kind: "assistant", startIndex: 1, endIndex: 1 },
+	]);
+});
+
+test("buildAssistantReplaySegments preserves interleaved assistant-tool-assistant runs", () => {
+	const segments = buildAssistantReplaySegments([
+		{ type: "text", text: "Let me check." },
+		{ type: "serverToolUse", id: "s1", name: "mcp__fs__glob", input: {} },
+		{ type: "thinking", thinking: "Tool result looks good." },
+		{ type: "text", text: "Here is the answer." },
+	]);
+
+	assert.deepEqual(segments, [
+		{ kind: "assistant", startIndex: 0, endIndex: 0 },
+		{ kind: "tool", contentIndex: 1 },
+		{ kind: "assistant", startIndex: 2, endIndex: 3 },
+	]);
+});
+
+test("buildAssistantReplaySegments ignores non-rendered non-tool blocks", () => {
+	const segments = buildAssistantReplaySegments([
+		{ type: "text", text: "before" },
+		{ type: "webSearchResult", toolUseId: "s1", content: {} },
+		{ type: "text", text: "after" },
+	]);
+
+	assert.deepEqual(segments, [
+		{ kind: "assistant", startIndex: 0, endIndex: 0 },
+		{ kind: "assistant", startIndex: 2, endIndex: 2 },
+	]);
+});

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

@@ -0,0 +1,49 @@
+import type { AgentSessionEvent } from "@gsd/agent-core";
+import type { AgentSession, KeybindingsManager } from "@gsd/agent-core";
+import type { AssistantMessage } from "@gsd/pi-ai";
+import type { Container, EditorComponent, Loader, TUI } from "@gsd/pi-tui";
+import type { AssistantMessageComponent } from "./components/assistant-message.js";
+import type { CustomEditor } from "./components/custom-editor.js";
+import type { ExtensionEditorComponent } from "./components/extension-editor.js";
+import type { ExtensionInputComponent } from "./components/extension-input.js";
+import type { ExtensionSelectorComponent } from "./components/extension-selector.js";
+import type { FooterComponent } from "./components/footer.js";
+import type { ToolExecutionComponent } from "./components/tool-execution.js";
+
+export interface InteractiveModeStateHost {
+	defaultEditor: CustomEditor;
+	editor: EditorComponent;
+	session: AgentSession;
+	ui: TUI;
+	footer: FooterComponent;
+	keybindings: KeybindingsManager;
+	statusContainer: Container;
+	chatContainer: Container;
+	pinnedMessageContainer: Container;
+	settingsManager: AgentSession["settingsManager"];
+	pendingTools: Map<string, ToolExecutionComponent>;
+	toolOutputExpanded: boolean;
+	hideThinkingBlock: boolean;
+	isBashMode: boolean;
+	onInputCallback?: (text: string) => void;
+	isInitialized: boolean;
+	loadingAnimation?: Loader;
+	pendingWorkingMessage?: string;
+	defaultWorkingMessage: string;
+	streamingComponent?: AssistantMessageComponent;
+	streamingMessage?: AssistantMessage;
+	retryEscapeHandler?: () => void;
+	retryLoader?: Loader;
+	autoCompactionLoader?: Loader;
+	autoCompactionEscapeHandler?: () => void;
+	compactionQueuedMessages: Array<{ text: string; mode: "steer" | "followUp" }>;
+	extensionSelector?: ExtensionSelectorComponent;
+	extensionInput?: ExtensionInputComponent;
+	extensionEditor?: ExtensionEditorComponent;
+	editorContainer: Container;
+	keybindingsManager?: KeybindingsManager;
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	[key: string]: any;
+}
+
+export type InteractiveModeEvent = AgentSessionEvent;