@xopcai/xopc 0.0.102 → 0.0.104

package/dist/src/tui/tui-transcript-tree-picker.js

@@ -0,0 +1,604 @@
+import { searchableSelectListTheme, theme } from "./theme.js";
+import { formatKeyIds, formatKeyText } from "./format-tui-hotkeys.js";
+import { filterTuiTranscriptTreeEntries, formatTuiTranscriptTreeEntryDisplayText } from "./tui-transcript-tree.js";
+import { SearchableSelectList } from "./components/searchable-select-list.js";
+import { randomUUID } from "node:crypto";
+import { Input, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+//#region src/tui/tui-transcript-tree-picker.ts
+function formatSelectNavigationHint(keybindings) {
+	return `${formatKeyIds(keybindings, "tui.select.up", { capitalize: true })}/${formatKeyIds(keybindings, "tui.select.down", { capitalize: true })}`;
+}
+function formatTranscriptTreeOpenedHint(keybindings) {
+	return `Transcript tree (${formatSelectNavigationHint(keybindings)} · type to filter · ${formatKeyIds(keybindings, "tui.select.confirm", { capitalize: true })} inspect · ${formatKeyIds(keybindings, "tui.select.cancel", { capitalize: true })} close)`;
+}
+function formatTranscriptTreeFilterHint(keybindings, filterMode) {
+	const base = formatTranscriptTreeOpenedHint(keybindings);
+	const fold = formatKeyIds(keybindings, "app.tree.foldOrUp", { capitalize: true });
+	const unfold = formatKeyIds(keybindings, "app.tree.unfoldOrDown", { capitalize: true });
+	const editLabel = formatKeyIds(keybindings, "app.tree.editLabel", { capitalize: true });
+	const cycle = formatKeyIds(keybindings, "app.tree.filter.cycleForward", { capitalize: true });
+	return `${base}${filterMode === "default" ? "" : ` [${filterMode}]`} · ${fold}/${unfold} fold · ${editLabel} label · ${cycle} filter`;
+}
+const TRANSCRIPT_TREE_HELP_ITEMS = [
+	{
+		keys: ["tui.select.up", "tui.select.down"],
+		label: "move"
+	},
+	{
+		keys: ["tui.editor.cursorLeft", "tui.editor.cursorRight"],
+		label: "page"
+	},
+	{
+		keys: ["app.tree.foldOrUp", "app.tree.unfoldOrDown"],
+		label: "branch"
+	},
+	{
+		keys: ["app.tree.editLabel"],
+		label: "label"
+	},
+	{
+		keys: ["app.tree.toggleLabelTimestamp"],
+		label: "label time"
+	},
+	{
+		keys: [
+			"app.tree.filter.default",
+			"app.tree.filter.noTools",
+			"app.tree.filter.userOnly",
+			"app.tree.filter.labeledOnly",
+			"app.tree.filter.all"
+		],
+		label: "filters",
+		labelFirst: true
+	},
+	{
+		keys: ["app.tree.filter.cycleForward", "app.tree.filter.cycleBackward"],
+		label: "cycle",
+		labelFirst: true
+	}
+];
+function formatTranscriptTreeHelpLines(keybindings, width) {
+	const availableWidth = Math.max(1, width);
+	const items = TRANSCRIPT_TREE_HELP_ITEMS.map(({ keys, label, labelFirst }) => {
+		const keyText = formatTranscriptTreeHelpKeys(keybindings, keys);
+		if (!keyText) return label;
+		return labelFirst ? `${label} ${keyText}` : `${keyText} ${label}`;
+	});
+	const indent = "  ";
+	const separator = " · ";
+	const lines = [];
+	let current = "";
+	for (const item of items) {
+		const indentedItem = `${indent}${item}`;
+		const candidate = current ? `${current}${separator}${item}` : indentedItem;
+		if (!current || visibleWidth(candidate) <= availableWidth) {
+			current = candidate;
+			continue;
+		}
+		lines.push(truncateToWidth(current, availableWidth, ""));
+		current = visibleWidth(indentedItem) <= availableWidth ? indentedItem : item;
+	}
+	if (current) lines.push(truncateToWidth(current, availableWidth, ""));
+	return lines;
+}
+function formatTranscriptTreeHelpKeys(keybindings, ids) {
+	const keys = ids.map((id) => keybindings.getKeys(id)[0]).filter((key) => key !== void 0);
+	if (keys.length === 0) return "";
+	return formatTranscriptTreeHelpKeyText(compactTranscriptTreeHelpKeys(keys.map(String)));
+}
+function compactTranscriptTreeHelpKeys(keys) {
+	if (keys.length === 1) return keys[0] ?? "";
+	const parts = keys.map((key) => {
+		const separatorIndex = key.lastIndexOf("+");
+		return separatorIndex === -1 ? {
+			prefix: "",
+			suffix: key
+		} : {
+			prefix: key.slice(0, separatorIndex + 1),
+			suffix: key.slice(separatorIndex + 1)
+		};
+	});
+	const prefix = parts[0]?.prefix ?? "";
+	return prefix && parts.every((part) => part.prefix === prefix) ? `${prefix}${parts.map((part) => part.suffix).join("/")}` : keys.join("/");
+}
+function formatTranscriptTreeHelpKeyText(key) {
+	return formatKeyText(key, { capitalize: true }).replace(/\bpageUp\b/gi, "pgup").replace(/\bpageDown\b/gi, "pgdn").replace(/\bup\b/gi, "↑").replace(/\bdown\b/gi, "↓").replace(/\bleft\b/gi, "←").replace(/\bright\b/gi, "→");
+}
+function formatUserMessageForkOpenedHint(keybindings) {
+	return `Fork from message (${formatSelectNavigationHint(keybindings)} · type to filter · ${formatKeyIds(keybindings, "tui.select.confirm", { capitalize: true })} fork · ${formatKeyIds(keybindings, "tui.select.cancel", { capitalize: true })} close)`;
+}
+function defaultTranscriptForkKey(currentSessionKey, entryId) {
+	const suffix = randomUUID().slice(0, 8);
+	return `${currentSessionKey}:fork:${entryId.replace(/[^a-z0-9_.-]+/gi, "-")}-${suffix}`;
+}
+function formatLabelTimestamp(timestamp, now = /* @__PURE__ */ new Date()) {
+	const date = new Date(timestamp);
+	if (Number.isNaN(date.getTime())) return "";
+	const time = `${date.getHours().toString().padStart(2, "0")}:${date.getMinutes().toString().padStart(2, "0")}`;
+	if (date.getFullYear() === now.getFullYear() && date.getMonth() === now.getMonth() && date.getDate() === now.getDate()) return time;
+	const month = date.getMonth() + 1;
+	const day = date.getDate();
+	if (date.getFullYear() === now.getFullYear()) return `${month}/${day} ${time}`;
+	return `${date.getFullYear().toString().slice(-2)}/${month}/${day} ${time}`;
+}
+function transcriptTreeLabel(entry, options = {}) {
+	const marker = options.prefix ?? (entry.depth === 0 ? "- " : "  └─ ");
+	const activeMarker = entry.isOnActivePath || entry.isCurrentLeaf ? "• " : "";
+	const turn = entry.turn > 0 ? `#${entry.turn} ` : "";
+	const labelTime = options.showLabelTimestamps && entry.labelTimestamp ? `${formatLabelTimestamp(entry.labelTimestamp)} ` : "";
+	return `${marker}${activeMarker}${turn}${entry.userLabel ? `[${entry.userLabel}] ${labelTime}` : ""}${formatTuiTranscriptTreeEntryDisplayText(entry)}`;
+}
+function transcriptTreeSelectItems(entries, options = {}) {
+	const prefixes = transcriptTreePrefixes(entries, options.allEntries ?? entries);
+	return entries.map((entry) => {
+		const displayText = formatTuiTranscriptTreeEntryDisplayText(entry);
+		return {
+			value: entry.id,
+			label: `${formatTranscriptFoldMarker(entry.id, options)}${transcriptTreeLabel(entry, {
+				...options,
+				prefix: prefixes.get(entry.id)
+			})}`,
+			description: entry.createdAt ?? entry.id,
+			searchText: [
+				entry.id,
+				entry.parentId ?? "",
+				entry.label,
+				displayText,
+				entry.userLabel ?? "",
+				entry.labelTimestamp ?? "",
+				entry.isOnActivePath || entry.isCurrentLeaf ? "active current" : "",
+				entry.role ?? "",
+				entry.preview ?? "",
+				entry.createdAt ?? ""
+			].join(" ")
+		};
+	});
+}
+function transcriptTreePrefixes(entries, allEntries = entries) {
+	const byId = new Map(allEntries.map((entry) => [entry.id, entry]));
+	const visibleIds = new Set(entries.map((entry) => entry.id));
+	const parentByEntryId = /* @__PURE__ */ new Map();
+	const childrenByParentId = /* @__PURE__ */ new Map();
+	const nearestVisibleParent = (entry, index) => {
+		let parentId = entry.parentId;
+		while (parentId) {
+			if (visibleIds.has(parentId)) return parentId;
+			parentId = byId.get(parentId)?.parentId;
+		}
+		if (entry.depth > 0) for (let i = index - 1; i >= 0; i -= 1) {
+			const candidate = entries[i];
+			if (candidate && candidate.depth < entry.depth) return candidate.id;
+		}
+		return null;
+	};
+	for (const [index, entry] of entries.entries()) {
+		const parentId = nearestVisibleParent(entry, index);
+		parentByEntryId.set(entry.id, parentId);
+		const children = childrenByParentId.get(parentId) ?? [];
+		children.push(entry.id);
+		childrenByParentId.set(parentId, children);
+	}
+	const prefixes = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const visibleParentId = parentByEntryId.get(entry.id) ?? null;
+		if (visibleParentId === null) {
+			prefixes.set(entry.id, "- ");
+			continue;
+		}
+		const ancestors = [];
+		let parentId = visibleParentId;
+		while (parentId) {
+			ancestors.unshift(parentId);
+			parentId = parentByEntryId.get(parentId) ?? null;
+		}
+		let prefix = "  ";
+		for (const ancestor of ancestors.slice(1)) prefix += hasFollowingSibling(ancestor, parentByEntryId.get(ancestor) ?? null, childrenByParentId) ? "│  " : "   ";
+		prefix += hasFollowingSibling(entry.id, visibleParentId, childrenByParentId) ? "├─ " : "└─ ";
+		prefixes.set(entry.id, prefix);
+	}
+	return prefixes;
+}
+function hasFollowingSibling(entryId, parentId, childrenByParentId) {
+	const siblings = childrenByParentId.get(parentId) ?? [];
+	return siblings.indexOf(entryId) < siblings.length - 1;
+}
+function formatTranscriptFoldMarker(entryId, options) {
+	if (options.foldedIds?.has(entryId)) return "⊞ ";
+	if (options.foldableIds?.has(entryId)) return "⊟ ";
+	return "";
+}
+const TREE_FILTER_MODES = [
+	"default",
+	"no-tools",
+	"user-only",
+	"labeled-only",
+	"all"
+];
+function transcriptTreeStatusLabels(mode, showLabelTimestamps) {
+	const labels = [];
+	if (mode === "no-tools") labels.push("[no-tools]");
+	if (mode === "user-only") labels.push("[user]");
+	if (mode === "labeled-only") labels.push("[labeled]");
+	if (mode === "all") labels.push("[all]");
+	if (showLabelTimestamps) labels.push("[+label time]");
+	return labels.length > 0 ? ` ${labels.join(" ")}` : "";
+}
+function filterTranscriptTreeSelectItems(items, query) {
+	const tokens = query.toLowerCase().split(/\s+/).filter(Boolean);
+	if (tokens.length === 0) return items;
+	return items.filter((item) => {
+		const searchText = item.searchText ?? "";
+		const text = [
+			item.label,
+			item.description ?? "",
+			searchText
+		].join(" ").toLowerCase();
+		return tokens.every((token) => text.includes(token));
+	});
+}
+var TranscriptTreeSelectList = class {
+	list;
+	filterMode;
+	labelInput = null;
+	labelEntry = null;
+	showLabelTimestamps = false;
+	foldedEntryIds = /* @__PURE__ */ new Set();
+	lastSelectedEntryId;
+	onSelect;
+	onCancel;
+	onFilterChange;
+	onLabelSubmit;
+	constructor(entries, initialFilterMode, keybindings, maxVisible) {
+		this.entries = entries;
+		this.keybindings = keybindings;
+		this.maxVisible = maxVisible;
+		this.filterMode = initialFilterMode;
+		this.list = new SearchableSelectList(transcriptTreeSelectItems(filterTuiTranscriptTreeEntries(entries, this.filterMode), { showLabelTimestamps: this.showLabelTimestamps }), maxVisible, searchableSelectListTheme, {
+			searchPromptText: "Type to search: ",
+			filterItems: filterTranscriptTreeSelectItems
+		});
+		this.list.onSelect = (item) => this.onSelect?.(item);
+		this.list.onCancel = () => this.onCancel?.();
+		this.refreshItems({ selectedId: this.initialSelectedEntryId() });
+	}
+	get focused() {
+		return this.labelInput?.focused ?? this.list.focused;
+	}
+	set focused(value) {
+		if (this.labelInput) {
+			this.labelInput.focused = value;
+			return;
+		}
+		this.list.focused = value;
+	}
+	getFilterMode() {
+		return this.filterMode;
+	}
+	initialSelectedEntryId() {
+		return this.entries.find((entry) => entry.isCurrentLeaf)?.id ?? [...this.entries].reverse().find((entry) => entry.isOnActivePath)?.id;
+	}
+	filteredEntries(mode) {
+		const baseEntries = filterTuiTranscriptTreeEntries(this.entries, mode);
+		if (this.foldedEntryIds.size === 0) return baseEntries;
+		const byId = new Map(this.entries.map((entry) => [entry.id, entry]));
+		return baseEntries.filter((entry) => {
+			let parentId = entry.parentId;
+			while (parentId) {
+				if (this.foldedEntryIds.has(parentId)) return false;
+				parentId = byId.get(parentId)?.parentId;
+			}
+			return true;
+		});
+	}
+	visibleUnfoldedEntries(mode = this.filterMode) {
+		return filterTuiTranscriptTreeEntries(this.entries, mode);
+	}
+	hasVisibleChild(entryId) {
+		const maps = this.visibleTreeMaps(this.visibleUnfoldedEntries());
+		return this.isFoldableEntryId(entryId, maps);
+	}
+	isFoldableEntryId(entryId, maps) {
+		const children = maps.childrenByParentId.get(entryId);
+		if (!children || children.length === 0) return false;
+		const parentId = maps.parentByEntryId.get(entryId);
+		if (!parentId) return true;
+		return (maps.childrenByParentId.get(parentId)?.length ?? 0) > 1;
+	}
+	nearestVisibleEntryId(entryId, visibleEntries) {
+		if (!entryId) return void 0;
+		const visibleIds = new Set(visibleEntries.map((entry) => entry.id));
+		const byId = new Map(this.entries.map((entry) => [entry.id, entry]));
+		let currentId = entryId;
+		while (currentId) {
+			if (visibleIds.has(currentId)) return currentId;
+			currentId = byId.get(currentId)?.parentId;
+		}
+	}
+	visibleTreeMaps(visibleEntries) {
+		const visibleIds = new Set(visibleEntries.map((entry) => entry.id));
+		const byId = new Map(this.entries.map((entry) => [entry.id, entry]));
+		const childrenByParentId = /* @__PURE__ */ new Map();
+		const parentByEntryId = /* @__PURE__ */ new Map();
+		const indexByEntryId = /* @__PURE__ */ new Map();
+		childrenByParentId.set(null, []);
+		const nearestVisibleParent = (entry) => {
+			let parentId = entry.parentId;
+			while (parentId) {
+				if (visibleIds.has(parentId)) return parentId;
+				parentId = byId.get(parentId)?.parentId;
+			}
+			return null;
+		};
+		visibleEntries.forEach((entry, index) => {
+			const parentId = nearestVisibleParent(entry);
+			parentByEntryId.set(entry.id, parentId);
+			indexByEntryId.set(entry.id, index);
+			const siblings = childrenByParentId.get(parentId) ?? [];
+			siblings.push(entry.id);
+			childrenByParentId.set(parentId, siblings);
+		});
+		return {
+			childrenByParentId,
+			parentByEntryId,
+			indexByEntryId
+		};
+	}
+	moveToBranchSegment(direction) {
+		const selectedId = this.list.getSelectedItem()?.value;
+		if (!selectedId) return;
+		const visibleEntries = this.filteredEntries(this.filterMode);
+		const maps = this.visibleTreeMaps(visibleEntries);
+		let currentId = selectedId;
+		if (direction === "down") while (true) {
+			const children = maps.childrenByParentId.get(currentId) ?? [];
+			if (children.length === 0) {
+				this.list.setSelectedValue(currentId);
+				return;
+			}
+			if (children.length > 1) {
+				this.list.setSelectedValue(children[0]);
+				return;
+			}
+			currentId = children[0];
+		}
+		while (true) {
+			const parentId = maps.parentByEntryId.get(currentId) ?? null;
+			if (parentId === null) {
+				this.list.setSelectedValue(currentId);
+				return;
+			}
+			if ((maps.childrenByParentId.get(parentId) ?? []).length > 1) {
+				const segmentIndex = maps.indexByEntryId.get(currentId);
+				const selectedIndex = maps.indexByEntryId.get(selectedId);
+				if (segmentIndex !== void 0 && selectedIndex !== void 0 && segmentIndex < selectedIndex) {
+					this.list.setSelectedValue(currentId);
+					return;
+				}
+			}
+			currentId = parentId;
+		}
+	}
+	refreshItems(options = {}) {
+		const mode = options.mode ?? this.filterMode;
+		const selectedId = options.selectedId ?? this.list.getSelectedItem()?.value ?? this.lastSelectedEntryId;
+		const visibleEntries = this.filteredEntries(mode);
+		const unfoldedVisibleEntries = this.visibleUnfoldedEntries(mode);
+		const unfoldedMaps = this.visibleTreeMaps(unfoldedVisibleEntries);
+		const foldableIds = new Set(unfoldedVisibleEntries.filter((entry) => this.isFoldableEntryId(entry.id, unfoldedMaps)).map((entry) => entry.id));
+		this.list.setItems(transcriptTreeSelectItems(visibleEntries, {
+			showLabelTimestamps: this.showLabelTimestamps,
+			foldedIds: this.foldedEntryIds,
+			foldableIds,
+			allEntries: this.entries
+		}));
+		const targetId = this.nearestVisibleEntryId(selectedId, visibleEntries);
+		if (targetId) this.list.setSelectedValue(targetId);
+		this.rememberSelectedEntry();
+	}
+	setFilterMode(mode) {
+		const selectedId = this.list.getSelectedItem()?.value;
+		this.filterMode = mode;
+		this.foldedEntryIds.clear();
+		this.refreshItems({
+			mode,
+			selectedId
+		});
+		this.onFilterChange?.(mode);
+	}
+	foldSelectedEntry() {
+		const selectedId = this.list.getSelectedItem()?.value;
+		if (!selectedId || !this.hasVisibleChild(selectedId) || this.foldedEntryIds.has(selectedId)) return false;
+		this.foldedEntryIds.add(selectedId);
+		this.refreshItems({ selectedId });
+		return true;
+	}
+	unfoldSelectedEntry() {
+		const selectedId = this.list.getSelectedItem()?.value;
+		if (!selectedId || !this.foldedEntryIds.delete(selectedId)) return false;
+		this.refreshItems({ selectedId });
+		return true;
+	}
+	clearSearchAndFolds() {
+		if (this.list.getSearchQuery().length === 0) return false;
+		const selectedId = this.list.getSelectedItem()?.value ?? this.lastSelectedEntryId;
+		this.foldedEntryIds.clear();
+		this.refreshItems({ selectedId });
+		this.list.clearSearch({ selectedValue: selectedId });
+		this.rememberSelectedEntry();
+		return true;
+	}
+	pageSelection(direction) {
+		const visibleEntries = this.filteredEntries(this.filterMode);
+		const selectedId = this.list.getSelectedItem()?.value;
+		const selectedIndex = selectedId ? visibleEntries.findIndex((entry) => entry.id === selectedId) : 0;
+		const currentIndex = selectedIndex >= 0 ? selectedIndex : 0;
+		const delta = direction === "up" ? -this.maxVisible : this.maxVisible;
+		const nextEntry = visibleEntries[Math.max(0, Math.min(visibleEntries.length - 1, currentIndex + delta))];
+		if (nextEntry) this.list.setSelectedValue(nextEntry.id);
+	}
+	updateEntryLabel(entryId, label) {
+		const entry = this.entries.find((candidate) => candidate.id === entryId);
+		if (!entry) return;
+		if (label?.trim()) {
+			entry.userLabel = label.trim();
+			entry.labelTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+		} else {
+			delete entry.userLabel;
+			delete entry.labelTimestamp;
+		}
+		this.refreshItems();
+	}
+	toggleFilterMode(mode) {
+		this.setFilterMode(this.filterMode === mode ? "default" : mode);
+	}
+	cycleFilter(delta) {
+		const next = TREE_FILTER_MODES[(TREE_FILTER_MODES.indexOf(this.filterMode) + delta + TREE_FILTER_MODES.length) % TREE_FILTER_MODES.length];
+		this.setFilterMode(next);
+	}
+	rememberSelectedEntry() {
+		const selectedId = this.list.getSelectedItem()?.value;
+		if (selectedId) this.lastSelectedEntryId = selectedId;
+	}
+	handleInput(keyData) {
+		if (this.labelInput) {
+			if (this.keybindings.matches(keyData, "tui.select.confirm")) {
+				const value = this.labelInput.getValue().trim();
+				const entry = this.labelEntry;
+				this.labelInput = null;
+				this.labelEntry = null;
+				if (entry) this.onLabelSubmit?.(entry, value || void 0);
+				return;
+			}
+			if (this.keybindings.matches(keyData, "tui.select.cancel")) {
+				this.labelInput = null;
+				this.labelEntry = null;
+				return;
+			}
+			this.labelInput.handleInput(keyData);
+			return;
+		}
+		if (this.keybindings.matches(keyData, "app.tree.filter.default")) {
+			this.setFilterMode("default");
+			return;
+		}
+		if (this.keybindings.matches(keyData, "app.tree.filter.noTools")) {
+			this.toggleFilterMode("no-tools");
+			return;
+		}
+		if (this.keybindings.matches(keyData, "app.tree.filter.userOnly")) {
+			this.toggleFilterMode("user-only");
+			return;
+		}
+		if (this.keybindings.matches(keyData, "app.tree.filter.labeledOnly")) {
+			this.toggleFilterMode("labeled-only");
+			return;
+		}
+		if (this.keybindings.matches(keyData, "app.tree.filter.all")) {
+			this.toggleFilterMode("all");
+			return;
+		}
+		if (this.keybindings.matches(keyData, "app.tree.filter.cycleForward")) {
+			this.cycleFilter(1);
+			return;
+		}
+		if (this.keybindings.matches(keyData, "app.tree.filter.cycleBackward")) {
+			this.cycleFilter(-1);
+			return;
+		}
+		if (this.keybindings.matches(keyData, "app.tree.foldOrUp")) {
+			if (!this.foldSelectedEntry()) this.moveToBranchSegment("up");
+			return;
+		}
+		if (this.keybindings.matches(keyData, "app.tree.unfoldOrDown")) {
+			if (!this.unfoldSelectedEntry()) this.moveToBranchSegment("down");
+			return;
+		}
+		if (this.keybindings.matches(keyData, "tui.editor.cursorLeft") || this.keybindings.matches(keyData, "tui.select.pageUp")) {
+			this.pageSelection("up");
+			return;
+		}
+		if (this.keybindings.matches(keyData, "tui.editor.cursorRight") || this.keybindings.matches(keyData, "tui.select.pageDown")) {
+			this.pageSelection("down");
+			return;
+		}
+		if (this.keybindings.matches(keyData, "tui.select.cancel")) {
+			if (this.clearSearchAndFolds()) return;
+			this.onCancel?.();
+			return;
+		}
+		if (this.keybindings.matches(keyData, "app.tree.editLabel")) {
+			const item = this.list.getSelectedItem();
+			const entry = item ? this.entries.find((candidate) => candidate.id === item.value) : void 0;
+			if (entry) {
+				this.labelEntry = entry;
+				this.labelInput = new Input();
+				if (entry.userLabel) this.labelInput.setValue(entry.userLabel);
+				this.labelInput.focused = this.list.focused;
+			}
+			return;
+		}
+		if (this.keybindings.matches(keyData, "app.tree.toggleLabelTimestamp")) {
+			this.showLabelTimestamps = !this.showLabelTimestamps;
+			this.refreshItems();
+			return;
+		}
+		const queryBefore = this.list.getSearchQuery();
+		const selectedId = this.list.getSelectedItem()?.value ?? this.lastSelectedEntryId;
+		if (this.list.getSelectedItem()?.value) this.lastSelectedEntryId = this.list.getSelectedItem()?.value;
+		this.list.handleInput(keyData);
+		if (this.list.getSearchQuery() !== queryBefore) {
+			if (this.foldedEntryIds.size > 0) {
+				this.foldedEntryIds.clear();
+				this.refreshItems({ selectedId });
+				return;
+			}
+			if (selectedId) this.list.setSelectedValue(selectedId);
+			this.rememberSelectedEntry();
+		}
+	}
+	render(width) {
+		const stats = this.list.getSelectionStats();
+		const statusText = theme.dim(`(${stats.selected}/${stats.total})${transcriptTreeStatusLabels(this.filterMode, this.showLabelTimestamps)}`);
+		if (this.labelInput) {
+			const target = this.labelEntry?.userLabel ?? this.labelEntry?.label ?? this.labelEntry?.id ?? "entry";
+			const confirm = formatKeyIds(this.keybindings, "tui.select.confirm", { capitalize: true });
+			const cancel = formatKeyIds(this.keybindings, "tui.select.cancel", { capitalize: true });
+			return [
+				statusText,
+				theme.dim(`label ${target} (empty to clear)`),
+				...this.labelInput.render(Math.max(1, width)),
+				theme.dim(`${confirm} save · ${cancel} cancel`)
+			];
+		}
+		const listLines = this.list.render(width);
+		return [
+			statusText,
+			...stats.total === 0 ? listLines.map((line) => line.includes("No matches") ? searchableSelectListTheme.noMatch("  No entries found") : line) : listLines,
+			"",
+			...formatTranscriptTreeHelpLines(this.keybindings, width).map((line) => theme.dim(line))
+		];
+	}
+	invalidate() {
+		this.list.invalidate();
+	}
+	getSelectedItem() {
+		return this.list.getSelectedItem();
+	}
+};
+function userMessageForkSelectItems(entries) {
+	return entries.filter((entry) => entry.role === "user").map((entry, index, all) => ({
+		value: entry.id,
+		label: entry.preview?.trim() || `User message ${index + 1}`,
+		description: `Message ${index + 1} of ${all.length}`,
+		searchText: [
+			entry.id,
+			entry.preview ?? "",
+			entry.contentText ?? "",
+			entry.createdAt ?? ""
+		].join(" ")
+	}));
+}
+//#endregion
+export { TranscriptTreeSelectList, defaultTranscriptForkKey, formatTranscriptTreeFilterHint, formatTranscriptTreeHelpLines, formatTranscriptTreeOpenedHint, formatUserMessageForkOpenedHint, transcriptTreeSelectItems, userMessageForkSelectItems };
+
+//# sourceMappingURL=tui-transcript-tree-picker.js.map