gsd-pi 2.79.0-dev.ece5fd8ba → 2.80.0-dev.710c06e97

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

@@ -64,6 +64,7 @@ import { getChangelogPath, getNewEntries, parseChangelog } from "../../utils/cha
 import { readClipboardImage } from "../../utils/clipboard-image.js";
 import { ensureTool } from "../../utils/tools-manager.js";
 import { AssistantMessageComponent } from "./components/assistant-message.js";
+import { AdaptiveLayoutComponent } from "./components/adaptive-layout.js";
 import { BashExecutionComponent } from "./components/bash-execution.js";
 import { BorderedLoader } from "./components/bordered-loader.js";
 import { BranchSummaryMessageComponent } from "./components/branch-summary-message.js";
@@ -170,6 +171,47 @@ type CompactionQueuedMessage = {
 	mode: "steer" | "followUp";
 };
 
+export type ExtensionNotifyType = "info" | "warning" | "error" | "success" | undefined;
+
+export function shouldRenderExtensionNotifyInChat(type: ExtensionNotifyType): boolean {
+	return type !== "warning";
+}
+
+export interface ExtensionNotifyRenderResult {
+	rendered: boolean;
+	statusSpacer?: Spacer;
+	statusText?: Text;
+}
+
+export function renderExtensionNotifyInChat(
+	chatContainer: Container,
+	message: string,
+	type?: ExtensionNotifyType,
+): ExtensionNotifyRenderResult {
+	if (!shouldRenderExtensionNotifyInChat(type)) {
+		return { rendered: false };
+	}
+
+	const spacer = new Spacer(1);
+	chatContainer.addChild(spacer);
+
+	if (type === "error") {
+		chatContainer.addChild(new Text(theme.fg("error", `Error: ${message}`), 1, 0));
+		return { rendered: true };
+	}
+	if (type === "success") {
+		chatContainer.addChild(new DynamicBorder((text) => theme.fg("success", text)));
+		chatContainer.addChild(new Text(theme.fg("success", message), 1, 0));
+		chatContainer.addChild(new DynamicBorder((text) => theme.fg("success", text)));
+		chatContainer.addChild(new Spacer(1));
+		return { rendered: true };
+	}
+
+	const statusText = new Text(theme.fg("dim", message), 1, 0);
+	chatContainer.addChild(statusText);
+	return { rendered: true, statusSpacer: spacer, statusText };
+}
+
 /**
  * Options for InteractiveMode initialization.
  */
@@ -205,6 +247,7 @@ export class InteractiveMode {
 	private ui: TUI;
 	private chatContainer: Container;
 	private pendingMessagesContainer: Container;
+	private adaptiveLayout: AdaptiveLayoutComponent;
 	private statusContainer: Container;
 	private pinnedMessageContainer: Container;
 	private defaultEditor: CustomEditor;
@@ -220,6 +263,7 @@ export class InteractiveMode {
 	private loadingAnimation: Loader | undefined = undefined;
 	private pendingWorkingMessage: string | undefined = undefined;
 	private readonly defaultWorkingMessage = "Working...";
+	private lastBlockingError: string | undefined = undefined;
 
 	private lastSigintTime = 0;
 	private lastEscapeTime = 0;
@@ -326,6 +370,14 @@ export class InteractiveMode {
 		this.headerContainer = new Container();
 		this.chatContainer = new Container();
 		this.pendingMessagesContainer = new Container();
+		this.adaptiveLayout = new AdaptiveLayoutComponent(() => ({
+			override: this.settingsManager.getAdaptiveMode(),
+			activeToolCount: this.pendingTools.size,
+			gsdPhase: this.pendingWorkingMessage,
+			lastError: this.lastBlockingError,
+			sessionName: this.sessionManager.getSessionName(),
+			cwd: process.cwd(),
+		}));
 		this.statusContainer = new Container();
 		this.pinnedMessageContainer = new Container();
 		this.widgetContainerAbove = new Container();
@@ -530,6 +582,7 @@ export class InteractiveMode {
 			}
 		}
 
+		this.ui.addChild(this.adaptiveLayout);
 		this.ui.addChild(this.chatContainer);
 		this.ui.addChild(this.pendingMessagesContainer);
 		this.ui.addChild(this.statusContainer);
@@ -1180,6 +1233,7 @@ export class InteractiveMode {
 						this.streamingComponent = undefined;
 						this.streamingMessage = undefined;
 						this.pendingTools.clear();
+						this.clearBlockingError();
 
 						// Render any messages added via setup, or show empty session
 						this.renderInitialMessages();
@@ -1833,16 +1887,16 @@ export class InteractiveMode {
 	/**
 	 * Show a notification for extensions.
 	 */
-	private showExtensionNotify(message: string, type?: "info" | "warning" | "error" | "success"): void {
-		if (type === "error") {
-			this.showError(message);
-		} else if (type === "warning") {
-			this.showWarning(message);
-		} else if (type === "success") {
-			this.showSuccess(message);
-		} else {
-			this.showStatus(message, { append: true });
+	private showExtensionNotify(message: string, type?: ExtensionNotifyType): void {
+		const result = renderExtensionNotifyInChat(this.chatContainer, message, type);
+		if (!result.rendered) {
+			return;
+		}
+		if (result.statusSpacer && result.statusText) {
+			this.lastStatusSpacer = result.statusSpacer;
+			this.lastStatusText = result.statusText;
 		}
+		this.ui.requestRender();
 	}
 
 	/** Show a custom component with keyboard focus. Overlay mode renders on top of existing content. */
@@ -2839,11 +2893,16 @@ export class InteractiveMode {
 	}
 
 	showError(errorMessage: string): void {
+		this.lastBlockingError = errorMessage;
 		this.chatContainer.addChild(new Spacer(1));
 		this.chatContainer.addChild(new Text(theme.fg("error", `Error: ${errorMessage}`), 1, 0));
 		this.ui.requestRender();
 	}
 
+	clearBlockingError(): void {
+		this.lastBlockingError = undefined;
+	}
+
 	showWarning(warningMessage: string): void {
 		this.chatContainer.addChild(new Spacer(1));
 		this.chatContainer.addChild(new Text(theme.fg("warning", `Warning: ${warningMessage}`), 1, 0));
@@ -3154,6 +3213,7 @@ export class InteractiveMode {
 					quietStartup: this.settingsManager.getQuietStartup(),
 					clearOnShrink: this.settingsManager.getClearOnShrink(),
 					timestampFormat: this.settingsManager.getTimestampFormat(),
+					adaptiveMode: this.settingsManager.getAdaptiveMode(),
 				},
 				{
 					onAutoCompactChange: (enabled) => {
@@ -3260,6 +3320,10 @@ export class InteractiveMode {
 					onTimestampFormatChange: (format) => {
 						this.settingsManager.setTimestampFormat(format);
 					},
+					onAdaptiveModeChange: (mode) => {
+						this.settingsManager.setAdaptiveMode(mode);
+						this.ui.requestRender();
+					},
 					onCancel: () => {
 						done();
 						this.ui.requestRender();
@@ -3648,6 +3712,7 @@ export class InteractiveMode {
 		this.streamingComponent = undefined;
 		this.streamingMessage = undefined;
 		this.pendingTools.clear();
+		this.clearBlockingError();
 
 		// Switch session via AgentSession (emits extension session events)
 		await this.session.switchSession(sessionPath);
@@ -3969,6 +4034,7 @@ export class InteractiveMode {
 		this.streamingMessage = undefined;
 		this.pendingTools.clear();
 		this.pendingImages.length = 0;
+		this.clearBlockingError();
 
 		// Reset contextual tips for the new session
 		this.contextualTips.reset();

package/packages/pi-coding-agent/src/modes/interactive/slash-command-handlers.test.ts

@@ -0,0 +1,95 @@
+// GSD2 - Slash command tests for interactive TUI settings commands
+
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { Container } from "@gsd/pi-tui";
+import { SettingsManager } from "../../core/settings-manager.js";
+import { dispatchSlashCommand, type SlashCommandContext } from "./slash-command-handlers.js";
+
+function makeContext(settingsManager = SettingsManager.inMemory()): SlashCommandContext {
+	const statuses: string[] = [];
+	const warnings: string[] = [];
+	const renders: string[] = [];
+	return {
+		session: {} as never,
+		ui: {} as never,
+		keybindings: {} as never,
+		chatContainer: new Container(),
+		statusContainer: new Container(),
+		editorContainer: new Container(),
+		headerContainer: new Container(),
+		pendingMessagesContainer: new Container(),
+		editor: {} as never,
+		defaultEditor: {} as never,
+		sessionManager: {} as never,
+		settingsManager,
+		invalidateFooter() {},
+		showStatus(message: string) {
+			statuses.push(message);
+		},
+		showError(message: string) {
+			throw new Error(message);
+		},
+		showWarning(message: string) {
+			warnings.push(message);
+		},
+		showSelector() {},
+		updateEditorBorderColor() {},
+		getMarkdownThemeWithSettings: () => ({} as never),
+		requestRender() {
+			renders.push("render");
+		},
+		updateTerminalTitle() {},
+		showSettingsSelector() {},
+		showModelsSelector: async () => {},
+		handleModelCommand: async () => {},
+		showUserMessageSelector() {},
+		showTreeSelector() {},
+		showProviderManager() {},
+		showOAuthSelector: async () => {},
+		showSessionSelector() {},
+		handleClearCommand: async () => {},
+		handleReloadCommand: async () => {},
+		handleDebugCommand() {},
+		shutdown: async () => {},
+		executeCompaction: async () => undefined,
+		handleBashCommand: async () => {},
+		_testStatuses: statuses,
+		_testWarnings: warnings,
+		_testRenders: renders,
+	} as SlashCommandContext & {
+		_testStatuses: string[];
+		_testWarnings: string[];
+		_testRenders: string[];
+	};
+}
+
+describe("dispatchSlashCommand /tui", () => {
+	it("persists /tui mode validation to terminal adaptive mode", async () => {
+		const settingsManager = SettingsManager.inMemory();
+		const ctx = makeContext(settingsManager) as SlashCommandContext & {
+			_testStatuses: string[];
+			_testRenders: string[];
+		};
+
+		const handled = await dispatchSlashCommand("/tui mode validation", ctx);
+
+		assert.equal(handled, true);
+		assert.equal(settingsManager.getAdaptiveMode(), "validation");
+		assert.deepEqual(ctx._testStatuses, ["TUI mode: validation"]);
+		assert.equal(ctx._testRenders.length, 1);
+	});
+
+	it("rejects unknown TUI modes without changing settings", async () => {
+		const settingsManager = SettingsManager.inMemory({ terminal: { adaptiveMode: "workflow" } });
+		const ctx = makeContext(settingsManager) as SlashCommandContext & {
+			_testWarnings: string[];
+		};
+
+		const handled = await dispatchSlashCommand("/tui mode poster", ctx);
+
+		assert.equal(handled, true);
+		assert.equal(settingsManager.getAdaptiveMode(), "workflow");
+		assert.match(ctx._testWarnings[0], /Usage: \/tui mode/);
+	});
+});

package/packages/pi-coding-agent/src/modes/interactive/slash-command-handlers.ts

@@ -31,7 +31,7 @@ import {
 import type { AgentSession } from "../../core/agent-session.js";
 import type { AppAction, KeybindingsManager } from "../../core/keybindings.js";
 import type { SessionManager } from "../../core/session-manager.js";
-import type { SettingsManager } from "../../core/settings-manager.js";
+import type { AdaptiveTuiMode, SettingsManager } from "../../core/settings-manager.js";
 import { copyToClipboard } from "../../utils/clipboard.js";
 import { getChangelogPath, parseChangelog } from "../../utils/changelog.js";
 import { ArminComponent } from "./components/armin.js";
@@ -235,6 +235,10 @@ export async function dispatchSlashCommand(
 		await ctx.handleBashCommand(command, { loginShell: true });
 		return true;
 	}
+	if (text === "/tui" || text.startsWith("/tui ")) {
+		handleTuiCommand(text, ctx);
+		return true;
+	}
 
 	return false;
 }
@@ -665,6 +669,25 @@ function handleEditModeCommand(arg: string | undefined, ctx: SlashCommandContext
 	ctx.showStatus(`Edit mode: ${next}${next === "hashline" ? " (LINE#ID anchored edits)" : " (text-match edits)"}`);
 }
 
+function handleTuiCommand(text: string, ctx: SlashCommandContext): void {
+	const parts = text.trim().split(/\s+/);
+	const mode = parts[1] === "mode" ? parts[2] : parts[1];
+	const valid: AdaptiveTuiMode[] = ["auto", "chat", "workflow", "validation", "debug", "compact"];
+
+	if (!mode) {
+		ctx.showStatus(`TUI mode: ${ctx.settingsManager.getAdaptiveMode()}`);
+		return;
+	}
+	if (!valid.includes(mode as AdaptiveTuiMode)) {
+		ctx.showWarning(`Usage: /tui mode ${valid.join("|")}`);
+		return;
+	}
+
+	ctx.settingsManager.setAdaptiveMode(mode as AdaptiveTuiMode);
+	ctx.showStatus(`TUI mode: ${mode}`);
+	ctx.requestRender();
+}
+
 function handleArminSaysHi(ctx: SlashCommandContext): void {
 	ctx.chatContainer.addChild(new Spacer(1));
 	ctx.chatContainer.addChild(new ArminComponent(ctx.ui));

package/packages/pi-coding-agent/src/modes/interactive/theme/theme-schema.ts

@@ -70,6 +70,19 @@ export const ThemeJsonSchema = Type.Object({
     thinkingXhigh: ColorValueSchema,
     // Bash Mode (1 color)
     bashMode: ColorValueSchema,
+    // Adaptive TUI semantic tokens (optional; defaults are derived from core colors)
+    surfaceBorder: Type.Optional(ColorValueSchema),
+    surfaceMuted: Type.Optional(ColorValueSchema),
+    surfaceTitle: Type.Optional(ColorValueSchema),
+    surfaceAccent: Type.Optional(ColorValueSchema),
+    toolRunning: Type.Optional(ColorValueSchema),
+    toolSuccess: Type.Optional(ColorValueSchema),
+    toolError: Type.Optional(ColorValueSchema),
+    toolMuted: Type.Optional(ColorValueSchema),
+    modeWorkflow: Type.Optional(ColorValueSchema),
+    modeValidation: Type.Optional(ColorValueSchema),
+    modeDebug: Type.Optional(ColorValueSchema),
+    modeCompact: Type.Optional(ColorValueSchema),
   }),
   export: Type.Optional(
     Type.Object({

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

@@ -69,7 +69,19 @@ export type ThemeColor =
 	| "thinkingMedium"
 	| "thinkingHigh"
 	| "thinkingXhigh"
-	| "bashMode";
+	| "bashMode"
+	| "surfaceBorder"
+	| "surfaceMuted"
+	| "surfaceTitle"
+	| "surfaceAccent"
+	| "toolRunning"
+	| "toolSuccess"
+	| "toolError"
+	| "toolMuted"
+	| "modeWorkflow"
+	| "modeValidation"
+	| "modeDebug"
+	| "modeCompact";
 
 export type ThemeBg =
 	| "selectedBg"
@@ -374,6 +386,24 @@ function getBuiltinThemes(): Record<string, ThemeJson> {
 	return builtinThemes;
 }
 
+function withSemanticColorDefaults(colors: ThemeJson["colors"]): ThemeJson["colors"] {
+	return {
+		...colors,
+		surfaceBorder: colors.surfaceBorder ?? colors.border,
+		surfaceMuted: colors.surfaceMuted ?? colors.borderMuted,
+		surfaceTitle: colors.surfaceTitle ?? colors.toolTitle,
+		surfaceAccent: colors.surfaceAccent ?? colors.borderAccent,
+		toolRunning: colors.toolRunning ?? colors.warning,
+		toolSuccess: colors.toolSuccess ?? colors.success,
+		toolError: colors.toolError ?? colors.error,
+		toolMuted: colors.toolMuted ?? colors.muted,
+		modeWorkflow: colors.modeWorkflow ?? colors.accent,
+		modeValidation: colors.modeValidation ?? colors.warning,
+		modeDebug: colors.modeDebug ?? colors.error,
+		modeCompact: colors.modeCompact ?? colors.muted,
+	};
+}
+
 export function getAvailableThemes(): string[] {
 	const themes = new Set<string>(Object.keys(getBuiltinThemes()));
 	const customThemesDir = getCustomThemesDir();
@@ -493,7 +523,7 @@ function loadThemeJson(name: string): ThemeJson {
 
 function createTheme(themeJson: ThemeJson, mode?: ColorMode, sourcePath?: string): Theme {
 	const colorMode = mode ?? detectColorMode();
-	const resolvedColors = resolveThemeColors(themeJson.colors, themeJson.vars);
+	const resolvedColors = resolveThemeColors(withSemanticColorDefaults(themeJson.colors), themeJson.vars);
 	const fgColors: Record<ThemeColor, string | number> = {} as Record<ThemeColor, string | number>;
 	const bgColors: Record<ThemeBg, string | number> = {} as Record<ThemeBg, string | number>;
 	const bgColorKeys: Set<string> = new Set([

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

@@ -0,0 +1,40 @@
+// GSD2 - Tests for adaptive TUI mode selection
+
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+
+import { resolveTuiMode } from "./tui-mode.js";
+
+describe("resolveTuiMode", () => {
+	test("explicit overrides beat auto selection", () => {
+		assert.equal(
+			resolveTuiMode({ terminalWidth: 60, override: "debug", gsdPhase: "validating-milestone" }),
+			"debug",
+		);
+	});
+
+	test("prioritizes compact layouts on narrow terminals", () => {
+		assert.equal(
+			resolveTuiMode({ terminalWidth: 60, override: "auto", hasBlockingError: true, gsdPhase: "validating-milestone" }),
+			"compact",
+		);
+	});
+
+	test("uses debug mode for blocking errors on roomy terminals", () => {
+		assert.equal(resolveTuiMode({ terminalWidth: 100, hasBlockingError: true }), "debug");
+	});
+
+	test("uses validation mode for validation and completion phases", () => {
+		assert.equal(resolveTuiMode({ terminalWidth: 100, gsdPhase: "validating-milestone" }), "validation");
+		assert.equal(resolveTuiMode({ terminalWidth: 100, gsdPhase: "complete-milestone" }), "validation");
+	});
+
+	test("uses workflow mode when tools or non-validation phases are active", () => {
+		assert.equal(resolveTuiMode({ terminalWidth: 100, activeToolCount: 1 }), "workflow");
+		assert.equal(resolveTuiMode({ terminalWidth: 100, gsdPhase: "execute-phase" }), "workflow");
+	});
+
+	test("falls back to chat mode for plain conversation", () => {
+		assert.equal(resolveTuiMode({ terminalWidth: 100 }), "chat");
+	});
+});

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

@@ -0,0 +1,29 @@
+// GSD2 - Adaptive mode selection for the interactive terminal UI
+
+export type TuiMode = "chat" | "workflow" | "validation" | "debug" | "compact";
+export type TuiAdaptiveMode = "auto" | TuiMode;
+
+export interface TuiModeContext {
+	terminalWidth: number;
+	override?: TuiAdaptiveMode;
+	gsdPhase?: string;
+	activeToolCount?: number;
+	hasBlockingError?: boolean;
+}
+
+export function resolveTuiMode(context: TuiModeContext): TuiMode {
+	if (context.override && context.override !== "auto") return context.override;
+	if (context.terminalWidth < 72) return "compact";
+	if (context.hasBlockingError) return "debug";
+
+	const phase = context.gsdPhase?.toLowerCase() ?? "";
+	if (phase.includes("validat") || phase.includes("complete") || phase.includes("review")) {
+		return "validation";
+	}
+
+	if ((context.activeToolCount ?? 0) > 0 || phase.length > 0) {
+		return "workflow";
+	}
+
+	return "chat";
+}