@gajae-code/coding-agent 0.11.0 → 0.11.2

package/src/modes/action-registry.ts

@@ -0,0 +1,165 @@
+import type { AppKeybinding } from "../config/keybindings";
+
+export type FocusDomain = "composer" | "selector" | "overlay" | "global";
+
+export interface ActionMetadata {
+	id: AppKeybinding;
+	title: string;
+	category: string;
+	bindingId?: AppKeybinding;
+	domains: readonly FocusDomain[];
+	exclusiveGroup?: string | false;
+}
+
+const action = (
+	id: AppKeybinding,
+	title: string,
+	category: string,
+	domains: FocusDomain[],
+	exclusiveGroup?: string | false,
+): ActionMetadata => ({
+	id,
+	title,
+	category,
+	bindingId: id,
+	domains,
+	exclusiveGroup,
+});
+
+export const APP_ACTION_METADATA: readonly ActionMetadata[] = [
+	action("app.interrupt", "Interrupt", "Session", ["global"], false),
+	action("app.clear", "Clear", "Session", ["global"]),
+	action("app.exit", "Exit", "Session", ["global"]),
+	action("app.suspend", "Suspend", "Session", ["global"]),
+	action("app.thinking.cycle", "Cycle thinking level", "Thinking", ["composer"]),
+	action("app.thinking.toggle", "Toggle thinking", "Thinking", ["composer"]),
+	action("app.commandPalette.open", "Open command palette", "Navigation", ["composer"]),
+	action("app.model.cycleForward", "Next model", "Model", ["composer"]),
+	action("app.model.cycleBackward", "Previous model", "Model", ["composer"]),
+	action("app.model.select", "Select model", "Model", ["composer"]),
+	action("app.model.selectTemporary", "Select temporary model", "Model", ["composer"]),
+	action("app.tools.expand", "Toggle tool expansion", "Tools", ["composer"]),
+	action("app.tool.backgroundFold", "Fold foreground tool", "Tools", ["composer"]),
+	action("app.editor.external", "Open external editor", "Editor", ["composer"]),
+	action("app.message.followUp", "Send follow-up", "Messages", ["composer"]),
+	action("app.message.queue", "Queue message", "Messages", ["composer"]),
+	action("app.message.dequeue", "Edit queued message", "Messages", ["composer"]),
+	action("app.clipboard.pasteImage", "Paste image", "Clipboard", ["composer"]),
+	action("app.clipboard.copyLine", "Copy line", "Clipboard", ["composer"]),
+	action("app.clipboard.copyPrompt", "Copy prompt", "Clipboard", ["composer"]),
+	action("app.session.new", "New session", "Session", ["composer"]),
+	action("app.session.tree", "Session tree", "Session", ["composer"]),
+	action("app.session.fork", "Fork session", "Session", ["composer"]),
+	action("app.session.resume", "Resume session", "Session", ["composer"]),
+	action("app.session.observe", "Observe sessions", "Session", ["composer"]),
+	action("app.session.dashboard", "Show sessions dashboard", "Session", ["composer"]),
+	action("app.jobs.open", "Open jobs", "Jobs", ["composer"]),
+	action("app.session.togglePath", "Toggle session path", "Session", ["selector"]),
+	action("app.session.toggleSort", "Toggle session sort", "Session", ["selector"]),
+	action("app.session.rename", "Rename session", "Session", ["selector"]),
+	action("app.session.delete", "Delete session", "Session", ["selector"]),
+	action("app.session.deleteNoninvasive", "Delete selected session", "Session", ["selector"]),
+	action("app.tree.foldOrUp", "Fold tree item", "Session", ["selector"]),
+	action("app.tree.unfoldOrDown", "Unfold tree item", "Session", ["selector"]),
+	action("app.plan.toggle", "Toggle plan mode", "Mode", ["composer"]),
+	action("app.history.search", "Search history", "Navigation", ["composer"]),
+	action("app.stt.toggle", "Toggle speech-to-text", "Speech", ["composer"]),
+	action("app.irc.sidebar.toggle", "Toggle IRC sidebar", "IRC", ["composer"]),
+	action("app.transcript.browse", "Browse transcript", "Transcript", ["composer"]),
+	action("app.transcript.prevTurn", "Previous transcript turn", "Transcript", ["composer"]),
+	action("app.transcript.nextTurn", "Next transcript turn", "Transcript", ["composer"]),
+	action("app.mode.cycle", "Cycle mode", "Mode", ["composer"]),
+	action("app.tasks.toggle", "Toggle tasks pane", "Jobs", ["composer"]),
+	action("app.queue.togglePane", "Toggle queue pane", "Messages", ["composer"]),
+	action("app.message.sendNow", "Send message now", "Messages", ["composer"]),
+];
+
+export interface ActionDefinition<Context> extends ActionMetadata {
+	availability(context: Context): boolean;
+	execute(context: Context): void | Promise<void>;
+}
+
+export interface ActionRegistryOptions<Context> {
+	context: Context;
+	showError(error: string): void;
+}
+
+export class ActionRegistry<Context> {
+	readonly #actions = new Map<AppKeybinding, ActionDefinition<Context>>();
+	readonly #busy = new Set<AppKeybinding>();
+	readonly #busyGroups = new Set<string>();
+	readonly #availability = new Map<AppKeybinding, boolean>();
+	#availabilityResetQueued = false;
+
+	constructor(private readonly options: ActionRegistryOptions<Context>) {}
+
+	register(action: ActionDefinition<Context>): void {
+		if (this.#actions.has(action.id)) throw new Error(`Action already registered: ${action.id}`);
+		this.#actions.set(action.id, action);
+	}
+
+	get(id: AppKeybinding): ActionDefinition<Context> | undefined {
+		return this.#actions.get(id);
+	}
+	all(): readonly ActionDefinition<Context>[] {
+		return [...this.#actions.values()];
+	}
+
+	#reportError(id: AppKeybinding, phase: "availability" | "execution", error: unknown): void {
+		const cause = error instanceof Error ? error.message : String(error);
+		try {
+			this.options.showError(`Action ${id} ${phase} failed: ${cause}`);
+		} catch {
+			// Error reporting must not escape an action dispatch.
+		}
+	}
+
+	#evaluateAvailability(id: AppKeybinding, action: ActionDefinition<Context>): boolean {
+		const cached = this.#availability.get(id);
+		if (cached !== undefined) return cached;
+		let available: boolean;
+		try {
+			available = Boolean(action.availability(this.options.context));
+		} catch (error) {
+			this.#reportError(id, "availability", error);
+			available = false;
+		}
+		this.#availability.set(id, available);
+		if (!this.#availabilityResetQueued) {
+			this.#availabilityResetQueued = true;
+			queueMicrotask(() => {
+				this.#availability.clear();
+				this.#availabilityResetQueued = false;
+			});
+		}
+		return available;
+	}
+
+	#exclusiveGroup(action: ActionDefinition<Context>): string | undefined {
+		return action.exclusiveGroup === false ? undefined : (action.exclusiveGroup ?? "default");
+	}
+
+	isAvailable(id: AppKeybinding): boolean {
+		const action = this.#actions.get(id);
+		return action ? this.#evaluateAvailability(id, action) : false;
+	}
+
+	async execute(id: AppKeybinding): Promise<boolean> {
+		const current = this.#actions.get(id);
+		if (!current || this.#busy.has(id) || !this.#evaluateAvailability(id, current)) return false;
+		const group = this.#exclusiveGroup(current);
+		if (group && this.#busyGroups.has(group)) return false;
+		this.#busy.add(id);
+		if (group) this.#busyGroups.add(group);
+		try {
+			await current.execute(this.options.context);
+			return true;
+		} catch (error) {
+			this.#reportError(id, "execution", error);
+			return false;
+		} finally {
+			this.#busy.delete(id);
+			if (group) this.#busyGroups.delete(group);
+		}
+	}
+}

package/src/modes/components/chrome.ts

@@ -0,0 +1,40 @@
+import { Container, type SelectItem, SelectList, Text } from "@gajae-code/tui";
+import { getSelectListTheme, theme } from "../../modes/theme/theme";
+import { DynamicBorder } from "./dynamic-border";
+
+export interface FramedSelectOptions {
+	maxVisible?: number;
+	selectedValue?: string;
+	onSelect?: (item: SelectItem) => void;
+	onCancel?: () => void;
+	onSelectionChange?: (item: SelectItem) => void;
+}
+
+export interface FramedSelect {
+	container: Container;
+	selectList: SelectList;
+}
+
+/** Build the shared border/list selector chrome used by compact mode selectors. */
+export function FramedSelect(
+	title: string | undefined,
+	items: ReadonlyArray<SelectItem>,
+	opts: FramedSelectOptions = {},
+): FramedSelect {
+	const container = new Container();
+	container.addChild(new DynamicBorder());
+	if (title) {
+		container.addChild(new Text(theme.bold(theme.fg("accent", title)), 0, 0));
+	}
+
+	const selectList = new SelectList(items, opts.maxVisible ?? Math.min(items.length, 10), getSelectListTheme());
+	const selectedIndex =
+		opts.selectedValue === undefined ? -1 : items.findIndex(item => item.value === opts.selectedValue);
+	if (selectedIndex !== -1) selectList.setSelectedIndex(selectedIndex);
+	selectList.onSelect = item => opts.onSelect?.(item);
+	selectList.onCancel = () => opts.onCancel?.();
+	if (opts.onSelectionChange) selectList.onSelectionChange = opts.onSelectionChange;
+	container.addChild(selectList);
+	container.addChild(new DynamicBorder());
+	return { container, selectList };
+}

package/src/modes/components/command-palette.ts

@@ -0,0 +1,168 @@
+import {
+	type Component,
+	Container,
+	fuzzyFilter,
+	Input,
+	matchesKey,
+	padding,
+	truncateToWidth,
+	visibleWidth,
+} from "@gajae-code/tui";
+import { sanitizeStatusText } from "../shared";
+import { theme } from "../theme/theme";
+import { DynamicBorder } from "./dynamic-border";
+
+export interface CommandPaletteAction {
+	id: string;
+	label: string;
+	handler: () => void | Promise<void>;
+}
+
+export interface CommandPaletteEntry {
+	id: string;
+	label: string;
+	description?: string;
+	category?: string;
+	keybinding?: string;
+	bindingHint?: string;
+	searchText?: string;
+	handler?: () => void | Promise<void>;
+	disabled?: boolean;
+}
+
+function sanitizePaletteText(text: string): string {
+	return sanitizeStatusText(text.toWellFormed());
+}
+
+function isSafePaletteEntryId(id: string): boolean {
+	return id.length > 0 && !/[\s\u0000-\u001f\u007f-\u009f]/u.test(id);
+}
+
+class CommandPaletteList implements Component {
+	#entries: CommandPaletteEntry[];
+	#filteredEntries: CommandPaletteEntry[];
+	#selectedIndex = 0;
+	readonly #searchInput = new Input();
+	onSelect?: (entry: CommandPaletteEntry) => void;
+	onCancel?: () => void;
+
+	constructor(entries: CommandPaletteEntry[]) {
+		this.#entries = entries.map(entry => ({
+			...entry,
+			label: sanitizePaletteText(entry.label),
+			description: sanitizePaletteText(entry.description ?? entry.category ?? ""),
+			category: entry.category === undefined ? undefined : sanitizePaletteText(entry.category),
+			keybinding:
+				entry.keybinding === undefined && entry.bindingHint === undefined
+					? undefined
+					: sanitizePaletteText(entry.keybinding ?? entry.bindingHint ?? ""),
+			bindingHint: entry.bindingHint === undefined ? undefined : sanitizePaletteText(entry.bindingHint),
+			searchText: entry.searchText === undefined ? undefined : sanitizePaletteText(entry.searchText),
+		}));
+		this.#filteredEntries = this.#entries;
+	}
+
+	#filter(query: string): void {
+		this.#filteredEntries = fuzzyFilter(this.#entries, query, entry =>
+			[entry.label, entry.description, entry.keybinding ?? "", entry.searchText ?? ""].join(" "),
+		);
+		this.#selectedIndex = Math.max(0, Math.min(this.#selectedIndex, this.#filteredEntries.length - 1));
+	}
+
+	invalidate(): void {}
+
+	getEntries(): readonly CommandPaletteEntry[] {
+		return this.#filteredEntries;
+	}
+
+	render(width: number): string[] {
+		const lines = [theme.fg("muted", "  Search commands"), ...this.#searchInput.render(width), ""];
+		if (this.#filteredEntries.length === 0) {
+			lines.push(theme.fg("muted", "  No matching commands"));
+			return lines;
+		}
+
+		const maxVisible = 8;
+		const start = Math.max(
+			0,
+			Math.min(this.#selectedIndex - Math.floor(maxVisible / 2), this.#filteredEntries.length - maxVisible),
+		);
+		const end = Math.min(start + maxVisible, this.#filteredEntries.length);
+		for (let index = start; index < end; index += 1) {
+			const entry = this.#filteredEntries[index];
+			if (!entry) continue;
+			const selected = index === this.#selectedIndex;
+			const cursor = `${theme.nav.cursor} `;
+			const prefix = selected ? theme.fg("accent", cursor) : padding(visibleWidth(cursor));
+			const keybinding = entry.keybinding ? theme.fg("muted", entry.keybinding) : "";
+			const availableLabelWidth = Math.max(
+				1,
+				width - visibleWidth(prefix) - visibleWidth(keybinding) - (keybinding ? 1 : 0),
+			);
+			const label = truncateToWidth(entry.label, availableLabelWidth);
+			const labelPadding = padding(Math.max(0, availableLabelWidth - visibleWidth(label)));
+			const renderedLabel = selected ? theme.bold(label) : label;
+			lines.push(
+				entry.disabled
+					? theme.fg("muted", prefix + renderedLabel + labelPadding + (keybinding ? ` ${keybinding}` : ""))
+					: prefix + renderedLabel + labelPadding + (keybinding ? ` ${keybinding}` : ""),
+			);
+			lines.push(theme.fg("dim", truncateToWidth(`  ${entry.description ?? ""}`, width)));
+		}
+		if (start > 0 || end < this.#filteredEntries.length) {
+			lines.push(theme.fg("muted", `  (${this.#selectedIndex + 1}/${this.#filteredEntries.length})`));
+		}
+		lines.push("", theme.fg("muted", "  [Enter to run, Esc to close]"));
+		return lines;
+	}
+
+	handleInput(data: string): void {
+		if (matchesKey(data, "escape")) {
+			this.onCancel?.();
+			return;
+		}
+		if (matchesKey(data, "up")) {
+			this.#selectedIndex = Math.max(0, this.#selectedIndex - 1);
+			return;
+		}
+		if (matchesKey(data, "down")) {
+			this.#selectedIndex = Math.min(this.#filteredEntries.length - 1, this.#selectedIndex + 1);
+			return;
+		}
+		if (matchesKey(data, "enter") || matchesKey(data, "return") || data === "\n") {
+			const entry = this.#filteredEntries[this.#selectedIndex];
+			if (entry && !entry.disabled && isSafePaletteEntryId(entry.id)) this.onSelect?.(entry);
+			return;
+		}
+		this.#searchInput.handleInput(data);
+		this.#filter(this.#searchInput.getValue());
+	}
+}
+
+export class CommandPaletteComponent extends Container {
+	#list: CommandPaletteList;
+
+	constructor(entries: CommandPaletteEntry[], onSelect: (entry: CommandPaletteEntry) => void, onCancel: () => void) {
+		super();
+		this.addChild(new DynamicBorder());
+		this.#list = new CommandPaletteList(entries);
+		this.#list.onSelect = onSelect;
+		this.#list.onCancel = onCancel;
+		this.addChild(this.#list);
+		this.addChild(new DynamicBorder());
+	}
+
+	override render(width: number): string[] {
+		return super.render(width).map(line => truncateToWidth(line, width));
+	}
+	handleInput(data: string): void {
+		this.#list.handleInput(data);
+	}
+
+	getEntries(): readonly CommandPaletteEntry[] {
+		return this.#list.getEntries();
+	}
+}
+
+/** Backward-compatible name retained for extensions and existing call sites. */
+export class CommandPalette extends CommandPaletteComponent {}

package/src/modes/components/custom-editor.ts

@@ -402,7 +402,7 @@ export class CustomEditor extends Editor {
 			}
 		}
 
-		// Pass to parent for normal handling
+		// Pass to parent for normal handling.
 		super.handleInput(data);
 	}
 }

package/src/modes/components/custom-provider-wizard.ts

@@ -1,4 +1,4 @@
-import { Container, Input, matchesKey, Spacer, Text, TruncatedText } from "@gajae-code/tui";
+import { Container, Input, matchesKey, SecretInput, Spacer, Text, TruncatedText } from "@gajae-code/tui";
 import type { ProviderCompatibility, ProviderSetupInput } from "../../setup/provider-onboarding";
 import { theme } from "../theme/theme";
 import { matchesAppInterrupt } from "../utils/keybinding-matchers";
@@ -29,7 +29,7 @@ export type CustomProviderWizardSubmit = ProviderSetupInput;
 
 export class CustomProviderWizardComponent extends Container {
 	#contentContainer: Container;
-	#input: Input | null = null;
+	#input: Input | SecretInput | null = null;
 	#step: WizardStep = "compatibility";
 	#selectedIndex = 0;
 	#lastSubmitError: string | null = null;
@@ -82,6 +82,7 @@ export class CustomProviderWizardComponent extends Container {
 	handleInput(keyData: string): void {
 		if (matchesAppInterrupt(keyData)) {
 			if (this.#step === "compatibility") {
+				this.#clearLiteralCredential();
 				this.#onCancel();
 				return;
 			}
@@ -90,6 +91,10 @@ export class CustomProviderWizardComponent extends Container {
 		}
 
 		if (this.#input) {
+			if (this.#input instanceof SecretInput) {
+				this.#input.handleInput(keyData);
+				return;
+			}
 			if (matchesKey(keyData, "enter") || matchesKey(keyData, "return") || keyData === "\n") {
 				this.#saveInputAndProceed();
 				return;
@@ -138,16 +143,16 @@ export class CustomProviderWizardComponent extends Container {
 				this.#renderCredentialSourceStep();
 				break;
 			case "credential":
-				this.#renderInputStep(
-					"Step 5: Credential",
-					this.#state.credentialSource === "env"
-						? "Enter the API key environment variable name:"
-						: "Paste the API key:",
-					this.#state.credential,
-					this.#state.credentialSource === "env"
-						? "e.g. OPENAI_API_KEY"
-						: "The key will be stored in models.yml and redacted in output.",
-				);
+				if (this.#state.credentialSource === "env") {
+					this.#renderInputStep(
+						"Step 5: Credential",
+						"Enter the API key environment variable name:",
+						this.#state.credential,
+						"e.g. OPENAI_API_KEY",
+					);
+				} else {
+					this.#renderSecretInputStep();
+				}
 				break;
 			case "models":
 				this.#renderInputStep(
@@ -198,6 +203,27 @@ export class CustomProviderWizardComponent extends Container {
 		this.#addHelp("[Enter to continue, Esc to go back]");
 	}
 
+	#renderSecretInputStep(): void {
+		this.#contentContainer.addChild(new Text(theme.fg("accent", "Step 5: Credential")));
+		this.#contentContainer.addChild(new Spacer(1));
+		this.#contentContainer.addChild(new Text("Paste the API key:", 0, 0));
+		this.#contentContainer.addChild(new Spacer(1));
+		const input = new SecretInput();
+		input.onSubmit = secret => {
+			const credential = secret.consume().trim();
+			if (!credential) return;
+			this.#state.credential = credential;
+			this.#step = "models";
+			this.#renderStep();
+			this.#onRender();
+		};
+		this.#input = input;
+		this.#contentContainer.addChild(input);
+		this.#contentContainer.addChild(new Spacer(1));
+		this.#addHelp("The key will be stored securely and redacted in output.");
+		this.#addHelp("[Enter to continue, Esc to go back]");
+	}
+
 	#renderConfirmStep(force: boolean): void {
 		this.#contentContainer.addChild(
 			new Text(theme.fg("accent", force ? "Provider exists — replace it?" : "Confirm custom provider")),
@@ -235,7 +261,8 @@ export class CustomProviderWizardComponent extends Container {
 	}
 
 	#saveInputAndProceed(): void {
-		const value = this.#input?.getValue().trim() ?? "";
+		if (!(this.#input instanceof Input)) return;
+		const value = this.#input.getValue().trim();
 		if (!value) return;
 		if (this.#step === "provider-id") {
 			this.#state.providerId = value;
@@ -277,7 +304,7 @@ export class CustomProviderWizardComponent extends Container {
 	}
 
 	#buildInput(force: boolean): CustomProviderWizardSubmit {
-		return {
+		const input = {
 			compatibility: this.#state.compatibility,
 			providerId: this.#state.providerId,
 			baseUrl: this.#state.baseUrl,
@@ -289,6 +316,16 @@ export class CustomProviderWizardComponent extends Container {
 				.filter(Boolean),
 			force,
 		};
+
+		return input;
+	}
+
+	complete(): void {
+		this.#clearLiteralCredential();
+	}
+
+	#clearLiteralCredential(): void {
+		if (this.#state.credentialSource === "literal") this.#state.credential = "";
 	}
 
 	#moveSelection(delta: number): void {

package/src/modes/components/index.ts

@@ -3,6 +3,7 @@ export * from "./assistant-message";
 export * from "./bash-execution";
 export * from "./bordered-loader";
 export * from "./branch-summary-message";
+export * from "./chrome";
 export * from "./compaction-summary-message";
 export * from "./countdown-timer";
 export * from "./custom-editor";
@@ -23,11 +24,11 @@ export * from "./read-tool-group";
 export * from "./session-selector";
 export * from "./settings-selector";
 export * from "./show-images-selector";
-export * from "./status-line";
 export * from "./theme-selector";
 export * from "./thinking-selector";
 export * from "./todo-reminder";
 export * from "./tool-execution";
+export * from "./tool-status-header";
 export * from "./tree-selector";
 export * from "./ttsr-notification";
 export * from "./user-message";

package/src/modes/components/pet-selector.ts

@@ -1,6 +1,5 @@
-import { Container, PET_SKIN_IDS, PET_SKINS, SelectList } from "@gajae-code/tui";
-import { getSelectListTheme } from "../theme/theme";
-import { DynamicBorder } from "./dynamic-border";
+import { Container, PET_SKIN_IDS, PET_SKINS, type SelectList } from "@gajae-code/tui";
+import { FramedSelect } from "./chrome";
 import type { PetMode } from "./gajae-pet-widget";
 import { createPetSelectItems } from "./pet-capability";
 
@@ -31,20 +30,15 @@ export class PetSelectorComponent extends Container {
 
 		const items = createPetSelectItems(PET_OPTIONS, current, available);
 
-		this.addChild(new DynamicBorder());
-
-		this.#selectList = new SelectList(items, 10, getSelectListTheme());
-		const currentIndex = PET_OPTIONS.findIndex(option => option.value === current);
-		if (currentIndex !== -1) {
-			this.#selectList.setSelectedIndex(currentIndex);
-		}
-
-		this.#selectList.onSelect = item => onSelect(item.value as PetMode);
-		this.#selectList.onCancel = () => onCancel();
-		this.#selectList.onSelectionChange = item => onPreview(item.value as PetMode);
-
-		this.addChild(this.#selectList);
-		this.addChild(new DynamicBorder());
+		const framed = FramedSelect(undefined, items, {
+			maxVisible: 10,
+			selectedValue: current,
+			onSelect: item => onSelect(item.value as PetMode),
+			onCancel,
+			onSelectionChange: item => onPreview(item.value as PetMode),
+		});
+		this.#selectList = framed.selectList;
+		this.addChild(framed.container);
 	}
 
 	getSelectList(): SelectList {