gsd-pi 2.76.0 → 2.77.0-dev.538325aea

package/packages/gsd-agent-modes/src/modes/interactive/components/extension-editor.ts

@@ -0,0 +1,151 @@
+/**
+ * Multi-line editor component for extensions.
+ * Supports Ctrl+G for external editor.
+ */
+
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import {
+	Container,
+	Editor,
+	type EditorOptions,
+	type Focusable,
+	Spacer,
+	Text,
+	type TUI,
+} from "@gsd/pi-tui";
+import { getKeybindings } from "../../../pi-tui-compat.js";
+import { KeybindingsManager } from "@gsd/agent-core";
+import { getEditorTheme } from "../../../pi-coding-agent-compat.js";
+import { theme } from "../../../theme.js";
+import { DynamicBorder } from "./dynamic-border.js";
+import { appKeyHint, keyHint } from "./keybinding-hints.js";
+
+export class ExtensionEditorComponent extends Container implements Focusable {
+	private editor: Editor;
+	private onSubmitCallback: (value: string) => void;
+	private onCancelCallback: () => void;
+	private tui: TUI;
+	private keybindings: KeybindingsManager;
+
+	private _focused = false;
+	get focused(): boolean {
+		return this._focused;
+	}
+	set focused(value: boolean) {
+		this._focused = value;
+		this.editor.focused = value;
+	}
+
+	constructor(
+		tui: TUI,
+		keybindings: KeybindingsManager,
+		title: string,
+		prefill: string | undefined,
+		onSubmit: (value: string) => void,
+		onCancel: () => void,
+		options?: EditorOptions,
+	) {
+		super();
+
+		this.tui = tui;
+		this.keybindings = keybindings;
+		this.onSubmitCallback = onSubmit;
+		this.onCancelCallback = onCancel;
+
+		// Add top border
+		this.addChild(new DynamicBorder());
+		this.addChild(new Spacer(1));
+
+		// Add title
+		this.addChild(new Text(theme.fg("accent", title), 1, 0));
+		this.addChild(new Spacer(1));
+
+		// Create editor
+		this.editor = new Editor(tui, getEditorTheme(), options);
+		if (prefill) {
+			this.editor.setText(prefill);
+		}
+		// Wire up Enter to submit (Shift+Enter for newlines, like the main editor)
+		this.editor.onSubmit = (text: string) => {
+			this.onSubmitCallback(text);
+		};
+		this.addChild(this.editor);
+
+		this.addChild(new Spacer(1));
+
+		// Add hint
+		const hasExternalEditor = !!(process.env.VISUAL || process.env.EDITOR);
+		const hint =
+			keyHint("selectConfirm", "submit") +
+			"  " +
+			keyHint("newLine", "newline") +
+			"  " +
+			keyHint("selectCancel", "cancel") +
+			(hasExternalEditor ? `  ${appKeyHint(this.keybindings, "externalEditor", "external editor")}` : "");
+		this.addChild(new Text(hint, 1, 0));
+
+		this.addChild(new Spacer(1));
+
+		// Add bottom border
+		this.addChild(new DynamicBorder());
+	}
+
+	handleInput(keyData: string): void {
+		const kb = getKeybindings();
+		// Escape or Ctrl+C to cancel
+		if (kb.matches(keyData, "selectCancel")) {
+			this.onCancelCallback();
+			return;
+		}
+
+		// External editor (app keybinding)
+		if (this.keybindings.matches(keyData, "externalEditor")) {
+			this.openExternalEditor();
+			return;
+		}
+
+		// Forward to editor
+		this.editor.handleInput(keyData);
+	}
+
+	private openExternalEditor(): void {
+		const editorCmd = process.env.VISUAL || process.env.EDITOR;
+		if (!editorCmd) {
+			// No editor configured — nothing to do.
+			// The main interactive-mode handler shows a warning with an iTerm2 hint;
+			// this component is a secondary editor so we silently bail.
+			return;
+		}
+
+		const currentText = this.editor.getText();
+		const tmpFile = path.join(os.tmpdir(), `pi-extension-editor-${Date.now()}.md`);
+
+		try {
+			fs.writeFileSync(tmpFile, currentText, "utf-8");
+			this.tui.stop();
+
+			const [editor, ...editorArgs] = editorCmd.split(" ");
+			const result = spawnSync(editor, [...editorArgs, tmpFile], {
+				stdio: "inherit",
+				shell: process.platform === "win32",
+			});
+
+			if (result.status === 0) {
+				const newContent = fs.readFileSync(tmpFile, "utf-8").replace(/\n$/, "");
+				this.editor.setText(newContent);
+			}
+		} finally {
+			try {
+				fs.unlinkSync(tmpFile);
+			} catch {
+				// Ignore cleanup errors
+			}
+			this.tui.start();
+			// Force full re-render since external editor uses alternate screen
+			this.tui.requestRender(true);
+		}
+	}
+}

package/packages/gsd-agent-modes/src/modes/interactive/components/extension-input.ts

@@ -0,0 +1,100 @@
+/**
+ * Simple text input component for extensions.
+ */
+
+import { Container, type Focusable, Input, Spacer, Text, type TUI } from "@gsd/pi-tui";
+import { getKeybindings } from "../../../pi-tui-compat.js";
+
+// vendor-seam: dual-module-path -- Input from pi-tui exposes secure/placeholder at runtime
+// but the pi-tui type declarations don't include them. Extension interface bridges the gap.
+interface GSDInputExtension {
+	secure?: boolean;
+	placeholder?: string;
+}
+import { theme } from "../../../theme.js";
+import { CountdownTimer } from "./countdown-timer.js";
+import { DynamicBorder } from "./dynamic-border.js";
+import { keyHint } from "./keybinding-hints.js";
+
+export interface ExtensionInputOptions {
+	tui?: TUI;
+	timeout?: number;
+	secure?: boolean;
+}
+
+export class ExtensionInputComponent extends Container implements Focusable {
+	private input: Input;
+	private onSubmitCallback: (value: string) => void;
+	private onCancelCallback: () => void;
+	private titleText: Text;
+	private baseTitle: string;
+	private countdown: CountdownTimer | undefined;
+
+	// Focusable implementation - propagate to input for IME cursor positioning
+	private _focused = false;
+	get focused(): boolean {
+		return this._focused;
+	}
+	set focused(value: boolean) {
+		this._focused = value;
+		this.input.focused = value;
+	}
+
+	constructor(
+		title: string,
+		placeholder: string | undefined,
+		onSubmit: (value: string) => void,
+		onCancel: () => void,
+		opts?: ExtensionInputOptions,
+	) {
+		super();
+
+		this.onSubmitCallback = onSubmit;
+		this.onCancelCallback = onCancel;
+		this.baseTitle = title;
+
+		this.addChild(new DynamicBorder());
+		this.addChild(new Spacer(1));
+
+		this.titleText = new Text(theme.fg("accent", title), 1, 0);
+		this.addChild(this.titleText);
+		this.addChild(new Spacer(1));
+
+		if (opts?.timeout && opts.timeout > 0 && opts.tui) {
+			this.countdown = new CountdownTimer(
+				opts.timeout,
+				opts.tui,
+				(s) => this.titleText.setText(theme.fg("accent", `${this.baseTitle} (${s}s)`)),
+				() => this.onCancelCallback(),
+			);
+		}
+
+		this.input = new Input();
+		const extInput = this.input as unknown as GSDInputExtension;
+		extInput.secure = opts?.secure === true;
+		if (placeholder) {
+			extInput.placeholder = placeholder;
+		}
+		this.addChild(this.input);
+		this.addChild(new Spacer(1));
+		this.addChild(new Text(`${keyHint("selectConfirm", "submit")}  ${keyHint("selectCancel", "cancel")}`, 1, 0));
+		this.addChild(new Spacer(1));
+		this.addChild(new DynamicBorder());
+	}
+
+	handleInput(keyData: string): void {
+		const kb = getKeybindings();
+		if (kb.matches(keyData, "selectConfirm") || keyData === "\n") {
+			if (this.input.getValue().trim() === "") return;
+			this.onSubmitCallback(this.input.getValue());
+		} else if (kb.matches(keyData, "selectCancel")) {
+			this.onCancelCallback();
+		} else {
+			this.input.handleInput(keyData);
+		}
+	}
+
+	dispose(): void {
+		this.countdown?.dispose();
+	}
+}

package/packages/gsd-agent-modes/src/modes/interactive/components/extension-selector.ts

@@ -0,0 +1,156 @@
+/**
+ * Generic selector component for extensions.
+ * Displays a list of string options with keyboard navigation.
+ * Options starting with SEPARATOR_PREFIX are rendered as non-selectable group headers.
+ */
+
+import { Container, Spacer, Text, type TUI } from "@gsd/pi-tui";
+import { getKeybindings } from "../../../pi-tui-compat.js";
+import { theme } from "../../../theme.js";
+import { CountdownTimer } from "./countdown-timer.js";
+import { DynamicBorder } from "./dynamic-border.js";
+import { keyHint, rawKeyHint } from "./keybinding-hints.js";
+
+/** Prefix that marks an option as a non-selectable group header. */
+export const SEPARATOR_PREFIX = "───";
+
+export interface ExtensionSelectorOptions {
+	tui?: TUI;
+	timeout?: number;
+}
+
+export class ExtensionSelectorComponent extends Container {
+	private options: string[];
+	private selectedIndex = 0;
+	private listContainer: Container;
+	private onSelectCallback: (option: string) => void;
+	private onCancelCallback: () => void;
+	private titleText: Text;
+	private baseTitle: string;
+	private countdown: CountdownTimer | undefined;
+
+	constructor(
+		title: string,
+		options: string[],
+		onSelect: (option: string) => void,
+		onCancel: () => void,
+		opts?: ExtensionSelectorOptions,
+	) {
+		super();
+
+		this.options = options;
+		this.onSelectCallback = onSelect;
+		this.onCancelCallback = onCancel;
+		this.baseTitle = title;
+
+		this.addChild(new DynamicBorder());
+		this.addChild(new Spacer(1));
+
+		this.titleText = new Text(theme.fg("accent", title), 1, 0);
+		this.addChild(this.titleText);
+		this.addChild(new Spacer(1));
+
+		if (opts?.timeout && opts.timeout > 0 && opts.tui) {
+			this.countdown = new CountdownTimer(
+				opts.timeout,
+				opts.tui,
+				(s) => this.titleText.setText(theme.fg("accent", `${this.baseTitle} (${s}s)`)),
+				() => this.onCancelCallback(),
+			);
+		}
+
+		this.listContainer = new Container();
+		this.addChild(this.listContainer);
+		this.addChild(new Spacer(1));
+		this.addChild(
+			new Text(
+				rawKeyHint("↑↓", "navigate") +
+					"  " +
+					keyHint("selectConfirm", "select") +
+					"  " +
+					keyHint("selectCancel", "cancel"),
+				1,
+				0,
+			),
+		);
+		this.addChild(new Spacer(1));
+		this.addChild(new DynamicBorder());
+
+		// Start on the first selectable (non-separator) item
+		this.selectedIndex = this.nextSelectable(0, 1);
+		this.updateList();
+	}
+
+	private isSeparator(index: number): boolean {
+		return this.options[index]?.startsWith(SEPARATOR_PREFIX) ?? false;
+	}
+
+	/**
+	 * Find the next selectable index starting from `from` in the given direction.
+	 * Returns `from` clamped to bounds if nothing selectable is found.
+	 */
+	private nextSelectable(from: number, direction: 1 | -1): number {
+		let idx = from;
+		while (idx >= 0 && idx < this.options.length && this.isSeparator(idx)) {
+			idx += direction;
+		}
+		if (idx < 0 || idx >= this.options.length) {
+			return Math.max(0, Math.min(from, this.options.length - 1));
+		}
+		// If all items are separators, idx may still point to one — fall back to original index
+		if (this.isSeparator(idx)) {
+			return Math.max(0, Math.min(from, this.options.length - 1));
+		}
+		return idx;
+	}
+
+	private updateList(): void {
+		this.listContainer.clear();
+		for (let i = 0; i < this.options.length; i++) {
+			const option = this.options[i];
+			if (this.isSeparator(i)) {
+				this.listContainer.addChild(new Text(theme.fg("borderAccent", `  ${option}`), 1, 0));
+				continue;
+			}
+			const isSelected = i === this.selectedIndex;
+			const text = isSelected
+				? theme.fg("accent", "→ ") + theme.fg("accent", option)
+				: `  ${theme.fg("text", option)}`;
+			this.listContainer.addChild(new Text(text, 1, 0));
+		}
+	}
+
+	handleInput(keyData: string): void {
+		const kb = getKeybindings();
+		if (kb.matches(keyData, "selectUp") || keyData === "k") {
+			let next = this.selectedIndex - 1;
+			if (next < 0) next = this.options.length - 1;
+			next = this.nextSelectable(next, -1);
+			if (this.isSeparator(next)) {
+				next = this.nextSelectable(this.options.length - 1, -1);
+			}
+			this.selectedIndex = next;
+			this.updateList();
+		} else if (kb.matches(keyData, "selectDown") || keyData === "j") {
+			let next = this.selectedIndex + 1;
+			if (next >= this.options.length) next = 0;
+			next = this.nextSelectable(next, 1);
+			if (this.isSeparator(next)) {
+				next = this.nextSelectable(0, 1);
+			}
+			this.selectedIndex = next;
+			this.updateList();
+		} else if (kb.matches(keyData, "selectConfirm") || keyData === "\n") {
+			const selected = this.options[this.selectedIndex];
+			if (selected && !this.isSeparator(this.selectedIndex)) {
+				this.onSelectCallback(selected);
+			}
+		} else if (kb.matches(keyData, "selectCancel")) {
+			this.onCancelCallback();
+		}
+	}
+
+	dispose(): void {
+		this.countdown?.dispose();
+	}
+}

package/packages/gsd-agent-modes/src/modes/interactive/components/footer.ts

@@ -0,0 +1,257 @@
+import { type Component, truncateToWidth, visibleWidth } from "@gsd/pi-tui";
+import type { AgentSession } from "@gsd/agent-types";
+import type { ReadonlyFooterDataProvider } from "@gsd/agent-types";
+import { theme } from "../../../theme.js";
+import { providerDisplayName } from "./model-selector.js";
+
+interface GSDSessionState {
+	activeInferenceModel?: string;
+}
+
+interface GSDAgentSessionExt {
+	getLastTurnCost?(): number;
+}
+
+/**
+ * Sanitize text for display in a single-line status.
+ * Removes newlines, tabs, carriage returns, and other control characters.
+ */
+function sanitizeStatusText(text: string): string {
+	// Replace newlines, tabs, carriage returns with space, then collapse multiple spaces
+	return text
+		.replace(/[\r\n\t]/g, " ")
+		.replace(/ +/g, " ")
+		.trim();
+}
+
+/**
+ * Format token counts (similar to web-ui)
+ */
+function formatTokens(count: number): string {
+	if (count < 1000) return count.toString();
+	if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
+	if (count < 1000000) return `${Math.round(count / 1000)}k`;
+	if (count < 10000000) return `${(count / 1000000).toFixed(1)}M`;
+	return `${Math.round(count / 1000000)}M`;
+}
+
+/**
+ * Format a cost value for compact display.
+ * Uses fewer decimal places for larger amounts.
+ * @internal Exported for testing only.
+ */
+export function formatPromptCost(cost: number): string {
+	if (cost < 0.001) return `$${cost.toFixed(4)}`;
+	if (cost < 0.01) return `$${cost.toFixed(3)}`;
+	if (cost < 1) return `$${cost.toFixed(3)}`;
+	return `$${cost.toFixed(2)}`;
+}
+
+/**
+ * Footer component that shows pwd, token stats, and context usage.
+ * Computes token/context stats from session, gets git branch and extension statuses from provider.
+ */
+export class FooterComponent implements Component {
+	private autoCompactEnabled = true;
+
+	constructor(
+		private session: AgentSession,
+		private footerData: ReadonlyFooterDataProvider,
+	) {}
+
+	setAutoCompactEnabled(enabled: boolean): void {
+		this.autoCompactEnabled = enabled;
+	}
+
+	/**
+	 * No-op: git branch caching now handled by provider.
+	 * Kept for compatibility with existing call sites in interactive-mode.
+	 */
+	invalidate(): void {
+		// No-op: git branch is cached/invalidated by provider
+	}
+
+	/**
+	 * Clean up resources.
+	 * Git watcher cleanup now handled by provider.
+	 */
+	dispose(): void {
+		// Git watcher cleanup handled by provider
+	}
+
+	render(width: number): string[] {
+		const state = this.session.state;
+
+		const usageTotals = this.session.sessionManager.getUsageTotals();
+		const totalInput = usageTotals.input;
+		const totalOutput = usageTotals.output;
+		const totalCacheRead = usageTotals.cacheRead;
+		const totalCacheWrite = usageTotals.cacheWrite;
+		const totalCost = usageTotals.cost;
+
+		// Use activeInferenceModel during streaming to show the model actually
+		// being used, not the configured model which may have been switched mid-turn.
+		const activeInferenceModelId = (state as unknown as GSDSessionState).activeInferenceModel;
+		const displayModel = activeInferenceModelId
+			? this.session.modelRegistry.getAll().find((model) => model.id === activeInferenceModelId) ?? this.session.model
+			: this.session.model;
+
+		// Calculate context usage from session (handles compaction correctly).
+		// After compaction, tokens are unknown until the next LLM response.
+		const contextUsage = this.session.getContextUsage();
+		const contextWindow = contextUsage?.contextWindow ?? displayModel?.contextWindow ?? 0;
+		const contextPercentValue = contextUsage?.percent ?? 0;
+		const contextPercent = contextUsage?.percent !== null ? contextPercentValue.toFixed(1) : "?";
+
+		// Replace home directory with ~
+		let pwd = process.cwd();
+		const home = process.env.HOME || process.env.USERPROFILE;
+		if (home && pwd.startsWith(home)) {
+			pwd = `~${pwd.slice(home.length)}`;
+		}
+
+		// Add git branch if available
+		const branch = this.footerData.getGitBranch();
+		if (branch) {
+			pwd = `${pwd} (${branch})`;
+		}
+
+		// Add session name if set
+		const sessionName = this.session.sessionManager.getSessionName();
+		if (sessionName) {
+			pwd = `${pwd} • ${sessionName}`;
+		}
+
+		// Build stats line as separate groups joined by a dim middle-dot separator
+		const sep = ` ${theme.fg("dim", "\u00B7")} `;
+
+		// Group 1: token I/O
+		const tokenGroup: string[] = [];
+		if (totalInput) tokenGroup.push(`↑${formatTokens(totalInput)}`);
+		if (totalOutput) tokenGroup.push(`↓${formatTokens(totalOutput)}`);
+
+		// Group 2: cache metrics
+		const cacheGroup: string[] = [];
+		if (totalCacheRead) cacheGroup.push(`cr:${formatTokens(totalCacheRead)}`);
+		if (totalCacheWrite) cacheGroup.push(`cw:${formatTokens(totalCacheWrite)}`);
+
+		// Group 3: cost
+		const costGroup: string[] = [];
+		const usingSubscription = displayModel ? this.session.modelRegistry.isUsingOAuth(displayModel) : false;
+		if (totalCost || usingSubscription) {
+			const costStr = `$${totalCost.toFixed(3)}${usingSubscription ? " (sub)" : ""}`;
+			costGroup.push(costStr);
+		}
+
+		// Per-prompt cost annotation (opt-in via show_token_cost preference, #1515)
+		if (process.env.GSD_SHOW_TOKEN_COST === "1") {
+			const lastTurnCost = (this.session as unknown as GSDAgentSessionExt).getLastTurnCost?.() ?? 0;
+			if (lastTurnCost > 0) {
+				costGroup.push(`(last: ${formatPromptCost(lastTurnCost)})`);
+			}
+		}
+
+		// Group 4: context percentage (colorized)
+		let contextPercentStr: string;
+		const autoIndicator = this.autoCompactEnabled ? " (auto)" : "";
+		const contextPercentDisplay =
+			contextPercent === "?"
+				? `?/${formatTokens(contextWindow)}${autoIndicator}`
+				: `${contextPercent}%/${formatTokens(contextWindow)}${autoIndicator}`;
+		if (contextPercentValue > 90) {
+			contextPercentStr = theme.fg("error", contextPercentDisplay);
+		} else if (contextPercentValue > 70) {
+			contextPercentStr = theme.fg("warning", contextPercentDisplay);
+		} else {
+			contextPercentStr = contextPercentDisplay;
+		}
+
+		// Assemble groups: items within a group are space-separated,
+		// groups are separated by a dim middle-dot
+		const groups: string[] = [];
+		if (tokenGroup.length > 0) groups.push(tokenGroup.join(" "));
+		if (cacheGroup.length > 0) groups.push(cacheGroup.join(" "));
+		if (costGroup.length > 0) groups.push(costGroup.join(" "));
+		groups.push(contextPercentStr);
+
+		let statsLeft = groups.join(sep);
+
+		// Add model name on the right side, plus thinking level if model supports it
+		const modelName = displayModel?.id || "no-model";
+
+		let statsLeftWidth = visibleWidth(statsLeft);
+
+		// If statsLeft is too wide, truncate it
+		if (statsLeftWidth > width) {
+			statsLeft = truncateToWidth(statsLeft, width, "...");
+			statsLeftWidth = visibleWidth(statsLeft);
+		}
+
+		// Calculate available space for padding (minimum 2 spaces between stats and model)
+		const minPadding = 2;
+
+		// Add thinking level indicator if model supports reasoning
+		let rightSideWithoutProvider = modelName;
+		if (displayModel?.reasoning) {
+			const thinkingLevel = state.thinkingLevel || "off";
+			rightSideWithoutProvider =
+				thinkingLevel === "off" ? `${modelName} • thinking off` : `${modelName} • ${thinkingLevel}`;
+		}
+
+		// Prepend the provider in parentheses if there are multiple providers and there's enough room
+		let rightSide = rightSideWithoutProvider;
+		if (this.footerData.getAvailableProviderCount() > 1 && displayModel) {
+			rightSide = `(${providerDisplayName(displayModel.provider)}) ${rightSideWithoutProvider}`;
+			if (statsLeftWidth + minPadding + visibleWidth(rightSide) > width) {
+				// Too wide, fall back
+				rightSide = rightSideWithoutProvider;
+			}
+		}
+
+		const rightSideWidth = visibleWidth(rightSide);
+		const totalNeeded = statsLeftWidth + minPadding + rightSideWidth;
+
+		let statsLine: string;
+		if (totalNeeded <= width) {
+			// Both fit - add padding to right-align model
+			const padding = " ".repeat(width - statsLeftWidth - rightSideWidth);
+			statsLine = statsLeft + padding + rightSide;
+		} else {
+			// Need to truncate right side
+			const availableForRight = width - statsLeftWidth - minPadding;
+			if (availableForRight > 0) {
+				const truncatedRight = truncateToWidth(rightSide, availableForRight, "");
+				const truncatedRightWidth = visibleWidth(truncatedRight);
+				const padding = " ".repeat(Math.max(0, width - statsLeftWidth - truncatedRightWidth));
+				statsLine = statsLeft + padding + truncatedRight;
+			} else {
+				// Not enough space for right side at all
+				statsLine = statsLeft;
+			}
+		}
+
+		// Apply dim to each part separately. statsLeft may contain color codes (for context %)
+		// that end with a reset, which would clear an outer dim wrapper. So we dim the parts
+		// before and after the colored section independently.
+		const dimStatsLeft = theme.fg("dim", statsLeft);
+		const remainder = statsLine.slice(statsLeft.length); // padding + rightSide
+		const dimRemainder = theme.fg("dim", remainder);
+
+		const pwdLine = truncateToWidth(theme.fg("dim", pwd), width, theme.fg("dim", "..."));
+		const lines = [pwdLine, dimStatsLeft + dimRemainder];
+
+		// Add extension statuses on a single line, sorted by key alphabetically
+		const extensionStatuses = this.footerData.getExtensionStatuses();
+		if (extensionStatuses.size > 0) {
+			const sortedStatuses = Array.from(extensionStatuses.entries())
+				.sort(([a], [b]) => a.localeCompare(b))
+				.map(([, text]) => sanitizeStatusText(text));
+			const statusLine = sortedStatuses.join(" ");
+			// Match the rest of the footer styling: extension statuses should render
+			// in the same dim color as pwd/stats, with a dim ellipsis on truncation.
+			lines.push(truncateToWidth(theme.fg("dim", statusLine), width, theme.fg("dim", "...")));
+		}
+
+		return lines;
+	}
+}

package/packages/gsd-agent-modes/src/modes/interactive/components/index.ts

@@ -0,0 +1,35 @@
+// UI Components for extensions
+export { ArminComponent } from "./armin.js";
+// TEMPORARY — remove after interactive/ extraction (Plan 03-02)
+export { ConfigSelectorComponent } from "./config-selector.js";
+export { AssistantMessageComponent } from "./assistant-message.js";
+export { BashExecutionComponent } from "./bash-execution.js";
+export { BorderedLoader } from "./bordered-loader.js";
+export { BranchSummaryMessageComponent } from "./branch-summary-message.js";
+export { CompactionSummaryMessageComponent } from "./compaction-summary-message.js";
+export { CustomEditor } from "./custom-editor.js";
+export { CustomMessageComponent } from "./custom-message.js";
+export { DaxnutsComponent } from "./daxnuts.js";
+export { type RenderDiffOptions, renderDiff } from "./diff.js";
+export { DynamicBorder } from "./dynamic-border.js";
+export { ExtensionEditorComponent } from "./extension-editor.js";
+export { ExtensionInputComponent } from "./extension-input.js";
+export { ExtensionSelectorComponent, SEPARATOR_PREFIX } from "./extension-selector.js";
+export { FooterComponent } from "./footer.js";
+export { appKey, appKeyHint, editorKey, keyHint, rawKeyHint } from "./keybinding-hints.js";
+export { LoginDialogComponent } from "./login-dialog.js";
+export { ModelSelectorComponent } from "./model-selector.js";
+export { OAuthSelectorComponent } from "./oauth-selector.js";
+export { ProviderManagerComponent } from "./provider-manager.js";
+export { type ModelsCallbacks, type ModelsConfig, ScopedModelsSelectorComponent } from "./scoped-models-selector.js";
+export { SessionSelectorComponent } from "./session-selector.js";
+export { type SettingsCallbacks, type SettingsConfig, SettingsSelectorComponent } from "./settings-selector.js";
+export { ShowImagesSelectorComponent } from "./show-images-selector.js";
+export { SkillInvocationMessageComponent } from "./skill-invocation-message.js";
+export { ThemeSelectorComponent } from "./theme-selector.js";
+export { ThinkingSelectorComponent } from "./thinking-selector.js";
+export { ToolExecutionComponent, type ToolExecutionOptions } from "./tool-execution.js";
+export { TreeSelectorComponent } from "./tree-selector.js";
+export { UserMessageComponent } from "./user-message.js";
+export { UserMessageSelectorComponent } from "./user-message-selector.js";
+export { truncateToVisualLines, type VisualTruncateResult } from "./visual-truncate.js";