@oh-my-pi/pi-tui 1.337.0

package/src/components/select-list.ts

@@ -0,0 +1,184 @@
+import { isArrowDown, isArrowUp, isCtrlC, isEnter, isEscape } from "../keys.js";
+import type { Component } from "../tui.js";
+import { truncateToWidth } from "../utils.js";
+
+export interface SelectItem {
+	value: string;
+	label: string;
+	description?: string;
+}
+
+export interface SelectListTheme {
+	selectedPrefix: (text: string) => string;
+	selectedText: (text: string) => string;
+	description: (text: string) => string;
+	scrollInfo: (text: string) => string;
+	noMatch: (text: string) => string;
+}
+
+export class SelectList implements Component {
+	private items: SelectItem[] = [];
+	private filteredItems: SelectItem[] = [];
+	private selectedIndex: number = 0;
+	private maxVisible: number = 5;
+	private theme: SelectListTheme;
+
+	public onSelect?: (item: SelectItem) => void;
+	public onCancel?: () => void;
+	public onSelectionChange?: (item: SelectItem) => void;
+
+	constructor(items: SelectItem[], maxVisible: number, theme: SelectListTheme) {
+		this.items = items;
+		this.filteredItems = items;
+		this.maxVisible = maxVisible;
+		this.theme = theme;
+	}
+
+	setFilter(filter: string): void {
+		this.filteredItems = this.items.filter((item) => item.value.toLowerCase().startsWith(filter.toLowerCase()));
+		// Reset selection when filter changes
+		this.selectedIndex = 0;
+	}
+
+	setSelectedIndex(index: number): void {
+		this.selectedIndex = Math.max(0, Math.min(index, this.filteredItems.length - 1));
+	}
+
+	invalidate(): void {
+		// No cached state to invalidate currently
+	}
+
+	render(width: number): string[] {
+		const lines: string[] = [];
+
+		// If no items match filter, show message
+		if (this.filteredItems.length === 0) {
+			lines.push(this.theme.noMatch("  No matching commands"));
+			return lines;
+		}
+
+		// Calculate visible range with scrolling
+		const startIndex = Math.max(
+			0,
+			Math.min(this.selectedIndex - Math.floor(this.maxVisible / 2), this.filteredItems.length - this.maxVisible),
+		);
+		const endIndex = Math.min(startIndex + this.maxVisible, this.filteredItems.length);
+
+		// Render visible items
+		for (let i = startIndex; i < endIndex; i++) {
+			const item = this.filteredItems[i];
+			if (!item) continue;
+
+			const isSelected = i === this.selectedIndex;
+
+			let line = "";
+			if (isSelected) {
+				// Use arrow indicator for selection - entire line uses selectedText color
+				const prefixWidth = 2; // "→ " is 2 characters visually
+				const displayValue = item.label || item.value;
+
+				if (item.description && width > 40) {
+					// Calculate how much space we have for value + description
+					const maxValueWidth = Math.min(30, width - prefixWidth - 4);
+					const truncatedValue = truncateToWidth(displayValue, maxValueWidth, "");
+					const spacing = " ".repeat(Math.max(1, 32 - truncatedValue.length));
+
+					// Calculate remaining space for description using visible widths
+					const descriptionStart = prefixWidth + truncatedValue.length + spacing.length;
+					const remainingWidth = width - descriptionStart - 2; // -2 for safety
+
+					if (remainingWidth > 10) {
+						const truncatedDesc = truncateToWidth(item.description, remainingWidth, "");
+						// Apply selectedText to entire line content
+						line = this.theme.selectedText(`→ ${truncatedValue}${spacing}${truncatedDesc}`);
+					} else {
+						// Not enough space for description
+						const maxWidth = width - prefixWidth - 2;
+						line = this.theme.selectedText(`→ ${truncateToWidth(displayValue, maxWidth, "")}`);
+					}
+				} else {
+					// No description or not enough width
+					const maxWidth = width - prefixWidth - 2;
+					line = this.theme.selectedText(`→ ${truncateToWidth(displayValue, maxWidth, "")}`);
+				}
+			} else {
+				const displayValue = item.label || item.value;
+				const prefix = "  ";
+
+				if (item.description && width > 40) {
+					// Calculate how much space we have for value + description
+					const maxValueWidth = Math.min(30, width - prefix.length - 4);
+					const truncatedValue = truncateToWidth(displayValue, maxValueWidth, "");
+					const spacing = " ".repeat(Math.max(1, 32 - truncatedValue.length));
+
+					// Calculate remaining space for description
+					const descriptionStart = prefix.length + truncatedValue.length + spacing.length;
+					const remainingWidth = width - descriptionStart - 2; // -2 for safety
+
+					if (remainingWidth > 10) {
+						const truncatedDesc = truncateToWidth(item.description, remainingWidth, "");
+						const descText = this.theme.description(spacing + truncatedDesc);
+						line = prefix + truncatedValue + descText;
+					} else {
+						// Not enough space for description
+						const maxWidth = width - prefix.length - 2;
+						line = prefix + truncateToWidth(displayValue, maxWidth, "");
+					}
+				} else {
+					// No description or not enough width
+					const maxWidth = width - prefix.length - 2;
+					line = prefix + truncateToWidth(displayValue, maxWidth, "");
+				}
+			}
+
+			lines.push(line);
+		}
+
+		// Add scroll indicators if needed
+		if (startIndex > 0 || endIndex < this.filteredItems.length) {
+			const scrollText = `  (${this.selectedIndex + 1}/${this.filteredItems.length})`;
+			// Truncate if too long for terminal
+			lines.push(this.theme.scrollInfo(truncateToWidth(scrollText, width - 2, "")));
+		}
+
+		return lines;
+	}
+
+	handleInput(keyData: string): void {
+		// Up arrow - wrap to bottom when at top
+		if (isArrowUp(keyData)) {
+			this.selectedIndex = this.selectedIndex === 0 ? this.filteredItems.length - 1 : this.selectedIndex - 1;
+			this.notifySelectionChange();
+		}
+		// Down arrow - wrap to top when at bottom
+		else if (isArrowDown(keyData)) {
+			this.selectedIndex = this.selectedIndex === this.filteredItems.length - 1 ? 0 : this.selectedIndex + 1;
+			this.notifySelectionChange();
+		}
+		// Enter
+		else if (isEnter(keyData)) {
+			const selectedItem = this.filteredItems[this.selectedIndex];
+			if (selectedItem && this.onSelect) {
+				this.onSelect(selectedItem);
+			}
+		}
+		// Escape or Ctrl+C
+		else if (isEscape(keyData) || isCtrlC(keyData)) {
+			if (this.onCancel) {
+				this.onCancel();
+			}
+		}
+	}
+
+	private notifySelectionChange(): void {
+		const selectedItem = this.filteredItems[this.selectedIndex];
+		if (selectedItem && this.onSelectionChange) {
+			this.onSelectionChange(selectedItem);
+		}
+	}
+
+	getSelectedItem(): SelectItem | null {
+		const item = this.filteredItems[this.selectedIndex];
+		return item || null;
+	}
+}

package/src/components/settings-list.ts

@@ -0,0 +1,188 @@
+import { isArrowDown, isArrowUp, isCtrlC, isEnter, isEscape } from "../keys.js";
+import type { Component } from "../tui.js";
+import { truncateToWidth, visibleWidth } from "../utils.js";
+
+export interface SettingItem {
+	/** Unique identifier for this setting */
+	id: string;
+	/** Display label (left side) */
+	label: string;
+	/** Optional description shown when selected */
+	description?: string;
+	/** Current value to display (right side) */
+	currentValue: string;
+	/** If provided, Enter/Space cycles through these values */
+	values?: string[];
+	/** If provided, Enter opens this submenu. Receives current value and done callback. */
+	submenu?: (currentValue: string, done: (selectedValue?: string) => void) => Component;
+}
+
+export interface SettingsListTheme {
+	label: (text: string, selected: boolean) => string;
+	value: (text: string, selected: boolean) => string;
+	description: (text: string) => string;
+	cursor: string;
+	hint: (text: string) => string;
+}
+
+export class SettingsList implements Component {
+	private items: SettingItem[];
+	private theme: SettingsListTheme;
+	private selectedIndex = 0;
+	private maxVisible: number;
+	private onChange: (id: string, newValue: string) => void;
+	private onCancel: () => void;
+
+	// Submenu state
+	private submenuComponent: Component | null = null;
+	private submenuItemIndex: number | null = null;
+
+	constructor(
+		items: SettingItem[],
+		maxVisible: number,
+		theme: SettingsListTheme,
+		onChange: (id: string, newValue: string) => void,
+		onCancel: () => void,
+	) {
+		this.items = items;
+		this.maxVisible = maxVisible;
+		this.theme = theme;
+		this.onChange = onChange;
+		this.onCancel = onCancel;
+	}
+
+	/** Update an item's currentValue */
+	updateValue(id: string, newValue: string): void {
+		const item = this.items.find((i) => i.id === id);
+		if (item) {
+			item.currentValue = newValue;
+		}
+	}
+
+	invalidate(): void {
+		this.submenuComponent?.invalidate?.();
+	}
+
+	render(width: number): string[] {
+		// If submenu is active, render it instead
+		if (this.submenuComponent) {
+			return this.submenuComponent.render(width);
+		}
+
+		return this.renderMainList(width);
+	}
+
+	private renderMainList(width: number): string[] {
+		const lines: string[] = [];
+
+		if (this.items.length === 0) {
+			lines.push(this.theme.hint("  No settings available"));
+			return lines;
+		}
+
+		// Calculate visible range with scrolling
+		const startIndex = Math.max(
+			0,
+			Math.min(this.selectedIndex - Math.floor(this.maxVisible / 2), this.items.length - this.maxVisible),
+		);
+		const endIndex = Math.min(startIndex + this.maxVisible, this.items.length);
+
+		// Calculate max label width for alignment
+		const maxLabelWidth = Math.min(30, Math.max(...this.items.map((item) => visibleWidth(item.label))));
+
+		// Render visible items
+		for (let i = startIndex; i < endIndex; i++) {
+			const item = this.items[i];
+			if (!item) continue;
+
+			const isSelected = i === this.selectedIndex;
+			const prefix = isSelected ? this.theme.cursor : "  ";
+			const prefixWidth = visibleWidth(prefix);
+
+			// Pad label to align values
+			const labelPadded = item.label + " ".repeat(Math.max(0, maxLabelWidth - visibleWidth(item.label)));
+			const labelText = this.theme.label(labelPadded, isSelected);
+
+			// Calculate space for value
+			const separator = "  ";
+			const usedWidth = prefixWidth + maxLabelWidth + visibleWidth(separator);
+			const valueMaxWidth = width - usedWidth - 2;
+
+			const valueText = this.theme.value(truncateToWidth(item.currentValue, valueMaxWidth, ""), isSelected);
+
+			lines.push(prefix + labelText + separator + valueText);
+		}
+
+		// Add scroll indicator if needed
+		if (startIndex > 0 || endIndex < this.items.length) {
+			const scrollText = `  (${this.selectedIndex + 1}/${this.items.length})`;
+			lines.push(this.theme.hint(truncateToWidth(scrollText, width - 2, "")));
+		}
+
+		// Add description for selected item
+		const selectedItem = this.items[this.selectedIndex];
+		if (selectedItem?.description) {
+			lines.push("");
+			lines.push(this.theme.description(`  ${truncateToWidth(selectedItem.description, width - 4, "")}`));
+		}
+
+		// Add hint
+		lines.push("");
+		lines.push(this.theme.hint("  Enter/Space to change · Esc to cancel"));
+
+		return lines;
+	}
+
+	handleInput(data: string): void {
+		// If submenu is active, delegate all input to it
+		// The submenu's onCancel (triggered by escape) will call done() which closes it
+		if (this.submenuComponent) {
+			this.submenuComponent.handleInput?.(data);
+			return;
+		}
+
+		// Main list input handling
+		if (isArrowUp(data)) {
+			this.selectedIndex = this.selectedIndex === 0 ? this.items.length - 1 : this.selectedIndex - 1;
+		} else if (isArrowDown(data)) {
+			this.selectedIndex = this.selectedIndex === this.items.length - 1 ? 0 : this.selectedIndex + 1;
+		} else if (isEnter(data) || data === " ") {
+			this.activateItem();
+		} else if (isEscape(data) || isCtrlC(data)) {
+			this.onCancel();
+		}
+	}
+
+	private activateItem(): void {
+		const item = this.items[this.selectedIndex];
+		if (!item) return;
+
+		if (item.submenu) {
+			// Open submenu, passing current value so it can pre-select correctly
+			this.submenuItemIndex = this.selectedIndex;
+			this.submenuComponent = item.submenu(item.currentValue, (selectedValue?: string) => {
+				if (selectedValue !== undefined) {
+					item.currentValue = selectedValue;
+					this.onChange(item.id, selectedValue);
+				}
+				this.closeSubmenu();
+			});
+		} else if (item.values && item.values.length > 0) {
+			// Cycle through values
+			const currentIndex = item.values.indexOf(item.currentValue);
+			const nextIndex = (currentIndex + 1) % item.values.length;
+			const newValue = item.values[nextIndex];
+			item.currentValue = newValue;
+			this.onChange(item.id, newValue);
+		}
+	}
+
+	private closeSubmenu(): void {
+		this.submenuComponent = null;
+		// Restore selection to the item that opened the submenu
+		if (this.submenuItemIndex !== null) {
+			this.selectedIndex = this.submenuItemIndex;
+			this.submenuItemIndex = null;
+		}
+	}
+}

package/src/components/spacer.ts

@@ -0,0 +1,28 @@
+import type { Component } from "../tui.js";
+
+/**
+ * Spacer component that renders empty lines
+ */
+export class Spacer implements Component {
+	private lines: number;
+
+	constructor(lines: number = 1) {
+		this.lines = lines;
+	}
+
+	setLines(lines: number): void {
+		this.lines = lines;
+	}
+
+	invalidate(): void {
+		// No cached state to invalidate currently
+	}
+
+	render(_width: number): string[] {
+		const result: string[] = [];
+		for (let i = 0; i < this.lines; i++) {
+			result.push("");
+		}
+		return result;
+	}
+}

package/src/components/tab-bar.ts

@@ -0,0 +1,140 @@
+/**
+ * Tab Bar Component
+ *
+ * A horizontal tab bar for switching between views/panels.
+ * Renders as: "Label:  Tab1   Tab2   Tab3  (tab to cycle)"
+ *
+ * Navigation:
+ * - Tab / Arrow Right: Next tab (wraps around)
+ * - Shift+Tab / Arrow Left: Previous tab (wraps around)
+ */
+
+import { isArrowLeft, isArrowRight, isShiftTab, isTab } from "../keys.js";
+import type { Component } from "../tui.js";
+
+/** Tab definition */
+export interface Tab {
+	/** Unique identifier for the tab */
+	id: string;
+	/** Display label shown in the tab bar */
+	label: string;
+}
+
+/** Theme for styling the tab bar */
+export interface TabBarTheme {
+	/** Style for the label prefix (e.g., "Settings:") */
+	label: (text: string) => string;
+	/** Style for the currently active tab */
+	activeTab: (text: string) => string;
+	/** Style for inactive tabs */
+	inactiveTab: (text: string) => string;
+	/** Style for the hint text (e.g., "(tab to cycle)") */
+	hint: (text: string) => string;
+}
+
+/**
+ * Horizontal tab bar component.
+ *
+ * @example
+ * ```ts
+ * const tabs = [
+ *   { id: "config", label: "Config" },
+ *   { id: "tools", label: "Tools" },
+ * ];
+ * const tabBar = new TabBar("Settings", tabs, theme);
+ * tabBar.onTabChange = (tab) => console.log(`Switched to ${tab.id}`);
+ * ```
+ */
+export class TabBar implements Component {
+	private tabs: Tab[];
+	private activeIndex: number = 0;
+	private theme: TabBarTheme;
+	private label: string;
+
+	/** Callback fired when the active tab changes */
+	public onTabChange?: (tab: Tab, index: number) => void;
+
+	constructor(label: string, tabs: Tab[], theme: TabBarTheme, initialIndex: number = 0) {
+		this.label = label;
+		this.tabs = tabs;
+		this.theme = theme;
+		this.activeIndex = initialIndex;
+	}
+
+	/** Get the currently active tab */
+	getActiveTab(): Tab {
+		return this.tabs[this.activeIndex];
+	}
+
+	/** Get the index of the currently active tab */
+	getActiveIndex(): number {
+		return this.activeIndex;
+	}
+
+	/** Set the active tab by index (clamped to valid range) */
+	setActiveIndex(index: number): void {
+		const newIndex = Math.max(0, Math.min(index, this.tabs.length - 1));
+		if (newIndex !== this.activeIndex) {
+			this.activeIndex = newIndex;
+			this.onTabChange?.(this.tabs[this.activeIndex], this.activeIndex);
+		}
+	}
+
+	/** Move to the next tab (wraps to first tab after last) */
+	nextTab(): void {
+		this.setActiveIndex((this.activeIndex + 1) % this.tabs.length);
+	}
+
+	/** Move to the previous tab (wraps to last tab before first) */
+	prevTab(): void {
+		this.setActiveIndex((this.activeIndex - 1 + this.tabs.length) % this.tabs.length);
+	}
+
+	invalidate(): void {
+		// No cached state to invalidate
+	}
+
+	/**
+	 * Handle keyboard input for tab navigation.
+	 * @returns true if the input was handled, false otherwise
+	 */
+	handleInput(data: string): boolean {
+		if (isTab(data) || isArrowRight(data)) {
+			this.nextTab();
+			return true;
+		}
+		if (isShiftTab(data) || isArrowLeft(data)) {
+			this.prevTab();
+			return true;
+		}
+		return false;
+	}
+
+	/** Render the tab bar as a single line */
+	render(_width: number): string[] {
+		const parts: string[] = [];
+
+		// Label prefix
+		parts.push(this.theme.label(`${this.label}:`));
+		parts.push("  ");
+
+		// Tab buttons
+		for (let i = 0; i < this.tabs.length; i++) {
+			const tab = this.tabs[i];
+			if (i === this.activeIndex) {
+				parts.push(this.theme.activeTab(` ${tab.label} `));
+			} else {
+				parts.push(this.theme.inactiveTab(` ${tab.label} `));
+			}
+			if (i < this.tabs.length - 1) {
+				parts.push("  ");
+			}
+		}
+
+		// Navigation hint
+		parts.push("  ");
+		parts.push(this.theme.hint("(tab to cycle)"));
+
+		return [parts.join("")];
+	}
+}

package/src/components/text.ts

@@ -0,0 +1,106 @@
+import type { Component } from "../tui.js";
+import { applyBackgroundToLine, visibleWidth, wrapTextWithAnsi } from "../utils.js";
+
+/**
+ * Text component - displays multi-line text with word wrapping
+ */
+export class Text implements Component {
+	private text: string;
+	private paddingX: number; // Left/right padding
+	private paddingY: number; // Top/bottom padding
+	private customBgFn?: (text: string) => string;
+
+	// Cache for rendered output
+	private cachedText?: string;
+	private cachedWidth?: number;
+	private cachedLines?: string[];
+
+	constructor(text: string = "", paddingX: number = 1, paddingY: number = 1, customBgFn?: (text: string) => string) {
+		this.text = text;
+		this.paddingX = paddingX;
+		this.paddingY = paddingY;
+		this.customBgFn = customBgFn;
+	}
+
+	setText(text: string): void {
+		this.text = text;
+		this.cachedText = undefined;
+		this.cachedWidth = undefined;
+		this.cachedLines = undefined;
+	}
+
+	setCustomBgFn(customBgFn?: (text: string) => string): void {
+		this.customBgFn = customBgFn;
+		this.cachedText = undefined;
+		this.cachedWidth = undefined;
+		this.cachedLines = undefined;
+	}
+
+	invalidate(): void {
+		this.cachedText = undefined;
+		this.cachedWidth = undefined;
+		this.cachedLines = undefined;
+	}
+
+	render(width: number): string[] {
+		// Check cache
+		if (this.cachedLines && this.cachedText === this.text && this.cachedWidth === width) {
+			return this.cachedLines;
+		}
+
+		// Don't render anything if there's no actual text
+		if (!this.text || this.text.trim() === "") {
+			const result: string[] = [];
+			this.cachedText = this.text;
+			this.cachedWidth = width;
+			this.cachedLines = result;
+			return result;
+		}
+
+		// Replace tabs with 3 spaces
+		const normalizedText = this.text.replace(/\t/g, "   ");
+
+		// Calculate content width (subtract left/right margins)
+		const contentWidth = Math.max(1, width - this.paddingX * 2);
+
+		// Wrap text (this preserves ANSI codes but does NOT pad)
+		const wrappedLines = wrapTextWithAnsi(normalizedText, contentWidth);
+
+		// Add margins and background to each line
+		const leftMargin = " ".repeat(this.paddingX);
+		const rightMargin = " ".repeat(this.paddingX);
+		const contentLines: string[] = [];
+
+		for (const line of wrappedLines) {
+			// Add margins
+			const lineWithMargins = leftMargin + line + rightMargin;
+
+			// Apply background if specified (this also pads to full width)
+			if (this.customBgFn) {
+				contentLines.push(applyBackgroundToLine(lineWithMargins, width, this.customBgFn));
+			} else {
+				// No background - just pad to width with spaces
+				const visibleLen = visibleWidth(lineWithMargins);
+				const paddingNeeded = Math.max(0, width - visibleLen);
+				contentLines.push(lineWithMargins + " ".repeat(paddingNeeded));
+			}
+		}
+
+		// Add top/bottom padding (empty lines)
+		const emptyLine = " ".repeat(width);
+		const emptyLines: string[] = [];
+		for (let i = 0; i < this.paddingY; i++) {
+			const line = this.customBgFn ? applyBackgroundToLine(emptyLine, width, this.customBgFn) : emptyLine;
+			emptyLines.push(line);
+		}
+
+		const result = [...emptyLines, ...contentLines, ...emptyLines];
+
+		// Update cache
+		this.cachedText = this.text;
+		this.cachedWidth = width;
+		this.cachedLines = result;
+
+		return result.length > 0 ? result : [""];
+	}
+}