@herbertgao/pi-extensions 2026.8.6 → 2026.8.8

package/node_modules/@narumitw/pi-btw/src/btw.ts

@@ -9,10 +9,7 @@ import {
 	BorderedLoader,
 	type ExtensionAPI,
 	type ExtensionCommandContext,
-	type KeybindingsManager,
-	type Theme,
 } from "@earendil-works/pi-coding-agent";
-import type { Component, TUI } from "@earendil-works/pi-tui";
 import type { MenuContext, RunMenuResult } from "@narumitw/pi-tui-kit";
 import {
 	type BtwBringToMainSegment,
@@ -26,11 +23,13 @@ import {
 	summarizeBringToMain,
 } from "./bring-to-main.js";
 import { type RunBtwFullscreen, runBtwFullscreen } from "./fullscreen-ui.js";
+import { pickMainEntry } from "./main-tree-picker.js";
 import {
 	type BtwCommandMenuResult,
 	type BtwResumeThreadSummary,
 	runBtwMenuPreservingEditor,
 	showBtwCommandMenu,
+	showBtwCustomPreservingEditor,
 } from "./menu.js";
 import {
 	type BtwSettings,
@@ -222,6 +221,7 @@ export interface BtwExtensionDependencies {
 		ctx: ExtensionCommandContext,
 		resumeThreads: readonly BtwResumeThreadSummary[],
 	) => Promise<BtwCommandMenuResult>;
+	pickMainEntry?: typeof pickMainEntry;
 	loadSettings?: typeof loadSettingsForCommand;
 	resolveModel?: typeof resolveBtwModelWithLoader;
 	runThread?: typeof runBtwThread;
@@ -230,6 +230,7 @@ export interface BtwExtensionDependencies {
 
 export default function btw(pi: ExtensionAPI, dependencies: BtwExtensionDependencies = {}) {
 	const showCommandMenu = dependencies.showCommandMenu ?? showCommandMenuForBtw;
+	const pickEntry = dependencies.pickMainEntry ?? pickMainEntry;
 	const loadSettings = dependencies.loadSettings ?? loadSettingsForCommand;
 	const resolveModel = dependencies.resolveModel ?? resolveBtwModelWithLoader;
 	const runThread = dependencies.runThread ?? runBtwThread;
@@ -259,9 +260,37 @@ export default function btw(pi: ExtensionAPI, dependencies: BtwExtensionDependen
 			}
 
 			let menuResult: BtwCommandMenuResult = "start";
+			let selectedConversationContext: string | undefined;
 			if (!question) {
-				menuResult = await showCommandMenu(pi, ctx, listResumeThreads());
-				if (menuResult === "closed") return;
+				while (true) {
+					menuResult = await showCommandMenu(pi, ctx, listResumeThreads());
+					if (menuResult === "closed") return;
+					if (menuResult !== "tree") break;
+
+					const treeResult = await pickEntry(pi, ctx);
+					if (treeResult.kind === "closed") return;
+					if (treeResult.kind === "back") continue;
+					try {
+						if (!ctx.sessionManager.getEntry(treeResult.entryId)) {
+							notifySafely(ctx, "The selected main-thread entry is no longer available", "warning");
+							continue;
+						}
+						const branch = ctx.sessionManager.getBranch(treeResult.entryId);
+						if (branch.at(-1)?.id !== treeResult.entryId) {
+							notifySafely(
+								ctx,
+								"The selected main-thread branch is no longer available",
+								"warning",
+							);
+							continue;
+						}
+						selectedConversationContext = buildConversationContext(branch);
+						menuResult = "start";
+						break;
+					} catch {
+						return;
+					}
+				}
 			}
 
 			const settings = await loadSettings(ctx);
@@ -291,7 +320,8 @@ export default function btw(pi: ExtensionAPI, dependencies: BtwExtensionDependen
 						state = {
 							id: `btw-${nextThreadNumber}`,
 							thread: createSideThread(
-								buildConversationContext(fullscreenCtx.sessionManager.getBranch()),
+								selectedConversationContext ??
+									buildConversationContext(fullscreenCtx.sessionManager.getBranch()),
 							),
 							thinkingLevel: settings.thinkingLevel ?? pi.getThinkingLevel(),
 							createdAt,
@@ -546,40 +576,6 @@ export async function runBtwThread({
 	}
 }
 
-type BtwCustomFactory<T> = (
-	tui: TUI,
-	theme: Theme,
-	keybindings: KeybindingsManager,
-	done: (result: T) => void,
-) => Component;
-
-async function showBtwCustomPreservingEditor<T>(
-	ctx: ExtensionCommandContext,
-	factory: BtwCustomFactory<T>,
-): Promise<T | undefined> {
-	let liveEditorText = ctx.ui.getEditorText();
-	let completed = false;
-	const result = await ctx.ui.custom<T>((tui, theme, keybindings, done) =>
-		factory(tui, theme, keybindings, (value) => {
-			try {
-				liveEditorText = ctx.ui.getEditorText();
-			} catch {
-				// Keep completion finite if session replacement invalidates the editor context.
-			}
-			completed = true;
-			done(value);
-		}),
-	);
-	if (completed) {
-		try {
-			if (ctx.ui.getEditorText() !== liveEditorText) ctx.ui.setEditorText(liveEditorText);
-		} catch {
-			// A replaced context owns a different editor and must not receive stale restoration.
-		}
-	}
-	return result;
-}
-
 interface ChooseBringToMainDependencies {
 	showMenu?: typeof showBtwMenu;
 	showPreview?: typeof showBringToMainPreview;

package/node_modules/@narumitw/pi-btw/src/fullscreen-ui.ts

@@ -1,8 +1,9 @@
 import { spawn } from "node:child_process";
-import type {
-	ExtensionCommandContext,
-	KeybindingsManager,
-	Theme,
+import {
+	copyToClipboard as copyToHostClipboard,
+	type ExtensionCommandContext,
+	type KeybindingsManager,
+	type Theme,
 } from "@earendil-works/pi-coding-agent";
 import {
 	type Component,
@@ -21,13 +22,21 @@ type BtwCustomFactory<T> = (
 	done: (result: T) => void,
 ) => (Component & { dispose?(): void }) | Promise<Component & { dispose?(): void }>;
 
-type BtwFullscreenTui = TUI & { flash?: (message: string, durationMs?: number) => void };
+type BtwFullscreenTui = TUI & {
+	flash?: (message: string, durationMs?: number) => void;
+	setLayoutRoot(component: Component | undefined): void;
+};
+
+export interface BtwFullscreenLayoutComponent extends Component {
+	getFullscreenLayout(): Component;
+}
 
-export type BtwFullscreenTuiFactory = (parent: TUI) => BtwFullscreenTui;
+export type BtwFullscreenTuiFactory = (parent: TUI, theme: Theme) => BtwFullscreenTui;
 
 export interface BtwFullscreenDependencies {
 	createTui?: BtwFullscreenTuiFactory;
 	openUrl?: (url: string) => void;
+	copyToClipboard?: (text: string) => Promise<void>;
 }
 
 export type RunBtwFullscreen = <T>(
@@ -51,7 +60,13 @@ export async function runBtwFullscreen<T>(
 ): Promise<T> {
 	const createTui =
 		dependencies.createTui ??
-		((parent: TUI) => createBtwFullscreenTui(parent, dependencies.openUrl ?? openUrlInBrowser));
+		((parent: TUI, theme: Theme) =>
+			createBtwFullscreenTui(
+				parent,
+				theme,
+				dependencies.openUrl ?? openUrlInBrowser,
+				dependencies.copyToClipboard ?? copyToHostClipboard,
+			));
 	let liveEditorText = ctx.ui.getEditorText();
 	let restoreEditor = false;
 	const outcome = await ctx.ui.custom<FullscreenOutcome<T>>(
@@ -85,10 +100,27 @@ export async function runBtwFullscreen<T>(
 	return outcome.value;
 }
 
-function createBtwFullscreenTui(parent: TUI, openUrl: (url: string) => void): BtwFullscreenTui {
+function createBtwFullscreenTui(
+	parent: TUI,
+	theme: Theme,
+	openUrl: (url: string) => void,
+	copyToClipboard: (text: string) => Promise<void>,
+): BtwFullscreenTui {
+	const styleSearchMatch = (text: string) =>
+		theme.bg("searchMatchBg", theme.fg("searchMatchText", text));
 	return new TuiAltScreen(parent.terminal, parent.getShowHardwareCursor(), undefined, {
 		mouse: true,
+		searchMatchStyle: (text) => theme.underline(styleSearchMatch(text)),
+		searchCurrentMatchStyle: (text) => theme.bold(theme.inverse(styleSearchMatch(text))),
 		openUrl,
+		copySelection: async (text) => {
+			try {
+				await copyToClipboard(text);
+				return true;
+			} catch {
+				return false;
+			}
+		},
 	});
 }
 
@@ -147,7 +179,7 @@ class BtwFullscreenHost<T> implements Component {
 			this.parent.stop({ preserveScreen: true });
 			parentStopped = true;
 			if (this.disposed) throw new FullscreenUiDisposedError();
-			this.fullscreen = this.createTui(this.parent);
+			this.fullscreen = this.createTui(this.parent, this.theme);
 			fullscreenCreated = true;
 			this.fullscreen.start();
 			outcome = { kind: "completed", value: await this.run(this.createContext()) };
@@ -223,6 +255,7 @@ class BtwFullscreenHost<T> implements Component {
 			let component: (Component & { dispose?(): void }) | undefined;
 			let overlay: OverlayHandle | undefined;
 			let mounted = false;
+			let layoutMounted = false;
 			let factorySettled = false;
 			let closed = false;
 			let promiseSettled = false;
@@ -243,6 +276,7 @@ class BtwFullscreenHost<T> implements Component {
 				let cleanupError: unknown;
 				try {
 					if (overlay) overlay.hide();
+					else if (mounted && layoutMounted) fullscreen.setLayoutRoot(undefined);
 					else if (mounted && component) fullscreen.removeChild(component);
 				} catch (error) {
 					cleanupError = error;
@@ -327,8 +361,13 @@ class BtwFullscreenHost<T> implements Component {
 						options.onHandle?.(overlay);
 					} else {
 						fullscreen.clear();
-						fullscreen.addChild(component);
 						mounted = true;
+						if (isFullscreenLayoutComponent(component)) {
+							layoutMounted = true;
+							fullscreen.setLayoutRoot(component.getFullscreenLayout());
+						} else {
+							fullscreen.addChild(component);
+						}
 						fullscreen.setFocus(component);
 						fullscreen.requestRender();
 					}
@@ -337,3 +376,9 @@ class BtwFullscreenHost<T> implements Component {
 		});
 	}
 }
+
+function isFullscreenLayoutComponent(
+	component: Component,
+): component is BtwFullscreenLayoutComponent {
+	return "getFullscreenLayout" in component && typeof component.getFullscreenLayout === "function";
+}

package/node_modules/@narumitw/pi-btw/src/main-tree-picker.ts

@@ -0,0 +1,390 @@
+import {
+	copyToClipboard,
+	type ExtensionAPI,
+	type ExtensionCommandContext,
+	type SessionEntry,
+	type SessionTreeNode,
+	TreeSelectorComponent,
+} from "@earendil-works/pi-coding-agent";
+import { type Component, type Focusable, Key, matchesKey } from "@earendil-works/pi-tui";
+import { showBtwCustomPreservingEditor } from "./menu.js";
+import { sanitizeSingleLine } from "./text.js";
+
+export type MainEntryPickResult =
+	| { kind: "selected"; entryId: string }
+	| { kind: "back" }
+	| { kind: "closed" };
+
+export interface MainThreadTreeSelector extends Component, Focusable {
+	onCopy?: (text: string | undefined) => void;
+	setViewLabel?(entryId: string, label: string | undefined, labelTimestamp?: string): void;
+	dispose?(): void;
+}
+
+export interface MainThreadTreeSelectorOptions {
+	tree: SessionTreeNode[];
+	currentLeafId: string | null;
+	terminalRows: number;
+	onSelect: (entryId: string) => void;
+	onCancel: () => void;
+	onCopy: (entryId: string | undefined, displayText: string | undefined) => void;
+	onLabelChange: (entryId: string, label: string | undefined) => void;
+}
+
+export interface MainThreadTreePickerDependencies {
+	createSelector?: (options: MainThreadTreeSelectorOptions) => MainThreadTreeSelector;
+	copyToClipboard?: (text: string, signal: AbortSignal) => Promise<void>;
+}
+
+class MainThreadTreePickerComponent implements Component, Focusable {
+	constructor(
+		private readonly selector: MainThreadTreeSelector,
+		private readonly onClose: () => void,
+	) {}
+
+	get focused(): boolean {
+		return this.selector.focused;
+	}
+
+	set focused(value: boolean) {
+		this.selector.focused = value;
+	}
+
+	get wantsKeyRelease(): boolean | undefined {
+		return this.selector.wantsKeyRelease;
+	}
+
+	render(width: number): string[] {
+		return this.selector.render(width);
+	}
+
+	handleInput(data: string): void {
+		if (matchesKey(data, Key.ctrl("c"))) {
+			this.onClose();
+			return;
+		}
+		this.selector.handleInput?.(data);
+	}
+
+	invalidate(): void {
+		this.selector.invalidate();
+	}
+
+	dispose(): void {
+		this.selector.dispose?.();
+		this.onClose();
+	}
+}
+
+export async function pickMainEntry(
+	pi: ExtensionAPI,
+	ctx: ExtensionCommandContext,
+	dependencies: MainThreadTreePickerDependencies = {},
+): Promise<MainEntryPickResult> {
+	let rawTree: SessionTreeNode[];
+	let currentLeafId: string | null;
+	try {
+		rawTree = ctx.sessionManager.getTree();
+		currentLeafId = ctx.sessionManager.getLeafId();
+	} catch {
+		return { kind: "closed" };
+	}
+
+	if (rawTree.length === 0) {
+		notifySafely(ctx, "No main-thread entries are available", "warning");
+		return { kind: "back" };
+	}
+
+	const tree = sanitizeTreeForDisplay(rawTree);
+	const rawCopyText = collectRawCopyText(rawTree);
+	const savedLabels = collectSavedLabels(rawTree);
+	const createSelector = dependencies.createSelector ?? createNativeTreeSelector;
+	const copy = dependencies.copyToClipboard ?? copyText;
+	const copyControllers = new Set<AbortController>();
+	const copyTasks = new Set<Promise<void>>();
+	const abortCopies = () => {
+		for (const controller of copyControllers) {
+			controller.abort(new Error("The main-thread tree picker closed"));
+		}
+	};
+	const result = await showBtwCustomPreservingEditor<MainEntryPickResult>(
+		ctx,
+		(tui, _theme, _keybindings, done) => {
+			let settled = false;
+			let selector: MainThreadTreeSelector | undefined;
+			const finish = (value: MainEntryPickResult) => {
+				if (settled) return;
+				settled = true;
+				abortCopies();
+				done(value);
+			};
+			const onCopy = (entryId: string | undefined, displayText: string | undefined) => {
+				if (settled) return;
+				const text = entryId ? rawCopyText.get(entryId) : displayText;
+				if (!text) {
+					notifySafely(ctx, "Selected entry has no text to copy", "warning");
+					return;
+				}
+				const controller = new AbortController();
+				copyControllers.add(controller);
+				let operation: Promise<void>;
+				try {
+					operation = copy(text, controller.signal);
+				} catch (error: unknown) {
+					operation = Promise.reject(error);
+				}
+				let task!: Promise<void>;
+				task = operation
+					.then(() => {
+						if (!settled) notifySafely(ctx, "Copied selected message", "info");
+					})
+					.catch((error: unknown) => {
+						if (!settled && !controller.signal.aborted) {
+							notifySafely(ctx, `Could not copy selected message: ${formatError(error)}`, "error");
+						}
+					})
+					.finally(() => {
+						copyControllers.delete(controller);
+						copyTasks.delete(task);
+					});
+				copyTasks.add(task);
+			};
+			const restoreLabel = (entryId: string) => {
+				const previous = savedLabels.get(entryId);
+				selector?.setViewLabel?.(entryId, previous?.label, previous?.labelTimestamp);
+				tui.requestRender();
+			};
+			const onLabelChange = (entryId: string, label: string | undefined) => {
+				if (settled) return;
+				try {
+					if (!ctx.sessionManager.getEntry(entryId)) {
+						restoreLabel(entryId);
+						notifySafely(ctx, "The selected main-thread entry is no longer available", "warning");
+						return;
+					}
+					const persistedLabel = label === undefined ? undefined : sanitizeSingleLine(label);
+					pi.setLabel(entryId, persistedLabel);
+					savedLabels.set(entryId, { label: persistedLabel });
+					selector?.setViewLabel?.(entryId, persistedLabel);
+					tui.requestRender();
+				} catch (error: unknown) {
+					restoreLabel(entryId);
+					notifySafely(ctx, `Could not update tree label: ${formatError(error)}`, "error");
+				}
+			};
+			selector = createSelector({
+				tree,
+				currentLeafId,
+				terminalRows: tui.terminal.rows,
+				onSelect: (entryId) => finish({ kind: "selected", entryId }),
+				onCancel: () => finish({ kind: "back" }),
+				onCopy,
+				onLabelChange,
+			});
+			return new MainThreadTreePickerComponent(selector, () => finish({ kind: "closed" }));
+		},
+	);
+	abortCopies();
+	await Promise.allSettled([...copyTasks]);
+
+	return result ?? { kind: "closed" };
+}
+
+function createNativeTreeSelector(options: MainThreadTreeSelectorOptions): MainThreadTreeSelector {
+	const selector = new TreeSelectorComponent(
+		options.tree,
+		options.currentLeafId,
+		options.terminalRows,
+		options.onSelect,
+		options.onCancel,
+		options.onLabelChange,
+	);
+	selector.onCopy = (displayText) =>
+		options.onCopy(selector.getTreeList().getSelectedNode()?.entry.id, displayText);
+	const result = selector as MainThreadTreeSelector;
+	result.setViewLabel = (entryId, label, labelTimestamp) =>
+		selector.getTreeList().updateNodeLabel(entryId, label, labelTimestamp);
+	return result;
+}
+
+function sanitizeTreeForDisplay(tree: readonly SessionTreeNode[]): SessionTreeNode[] {
+	return tree.map((node) => {
+		const result: SessionTreeNode = {
+			entry: sanitizeEntryForDisplay(node.entry),
+			children: sanitizeTreeForDisplay(node.children),
+		};
+		if (node.label !== undefined) result.label = sanitizeSingleLine(node.label);
+		if (node.labelTimestamp !== undefined) {
+			result.labelTimestamp = sanitizeSingleLine(node.labelTimestamp);
+		}
+		return result;
+	});
+}
+
+function sanitizeEntryForDisplay(entry: SessionEntry): SessionEntry {
+	switch (entry.type) {
+		case "message": {
+			const message = { ...entry.message } as Record<string, unknown>;
+			if ("content" in entry.message)
+				message.content = sanitizeDisplayContent(entry.message.content);
+			for (const key of ["role", "errorMessage", "command", "toolName"] as const) {
+				const value = message[key];
+				if (typeof value === "string") message[key] = sanitizeSingleLine(value);
+			}
+			return { ...entry, message } as unknown as SessionEntry;
+		}
+		case "custom_message":
+			return {
+				...entry,
+				customType: sanitizeSingleLine(entry.customType),
+				content: sanitizeDisplayContent(entry.content) as typeof entry.content,
+			};
+		case "compaction":
+			return { ...entry, summary: sanitizeSingleLine(entry.summary) };
+		case "branch_summary":
+			return { ...entry, summary: sanitizeSingleLine(entry.summary) };
+		case "model_change":
+			return {
+				...entry,
+				provider: sanitizeSingleLine(entry.provider),
+				modelId: sanitizeSingleLine(entry.modelId),
+			};
+		case "thinking_level_change":
+			return { ...entry, thinkingLevel: sanitizeSingleLine(entry.thinkingLevel) };
+		case "custom":
+			return { ...entry, customType: sanitizeSingleLine(entry.customType) };
+		case "label":
+			return {
+				...entry,
+				label: entry.label === undefined ? undefined : sanitizeSingleLine(entry.label),
+			};
+		case "session_info":
+			return {
+				...entry,
+				name: entry.name === undefined ? undefined : sanitizeSingleLine(entry.name),
+			};
+	}
+}
+
+function sanitizeDisplayContent(content: unknown): unknown {
+	if (typeof content === "string") return sanitizeSingleLine(content);
+	if (!Array.isArray(content)) return content;
+	return content.map((block) => {
+		if (block === null || typeof block !== "object" || !("type" in block)) return block;
+		if (block.type === "text" && "text" in block && typeof block.text === "string") {
+			return { ...block, text: sanitizeSingleLine(block.text) };
+		}
+		if (block.type === "toolCall") {
+			const copy = { ...block } as Record<string, unknown>;
+			if (typeof copy.name === "string") copy.name = sanitizeSingleLine(copy.name);
+			copy.arguments = sanitizeToolArguments(copy.arguments, new WeakMap());
+			return copy;
+		}
+		return block;
+	});
+}
+
+function sanitizeToolArguments(value: unknown, seen: WeakMap<object, unknown>): unknown {
+	if (typeof value === "string") return sanitizeSingleLine(value);
+	if (value === null || typeof value !== "object") return value;
+	const existing = seen.get(value);
+	if (existing !== undefined) return existing;
+	if (Array.isArray(value)) {
+		const result: unknown[] = [];
+		seen.set(value, result);
+		for (const item of value) result.push(sanitizeToolArguments(item, seen));
+		return result;
+	}
+	const result: Record<string, unknown> = {};
+	seen.set(value, result);
+	for (const [key, item] of Object.entries(value)) {
+		result[key] = sanitizeToolArguments(item, seen);
+	}
+	return result;
+}
+
+function collectRawCopyText(tree: readonly SessionTreeNode[]): Map<string, string> {
+	const result = new Map<string, string>();
+	const visit = (nodes: readonly SessionTreeNode[]) => {
+		for (const node of nodes) {
+			const text = getRawCopyText(node.entry);
+			if (text !== undefined) result.set(node.entry.id, text);
+			visit(node.children);
+		}
+	};
+	visit(tree);
+	return result;
+}
+
+function getRawCopyText(entry: SessionEntry): string | undefined {
+	let text: string | undefined;
+	if (entry.type === "message") {
+		if (entry.message.role === "bashExecution") text = entry.message.command;
+		else if ("content" in entry.message) {
+			text = extractRawText(entry.message.content);
+			if (!text && entry.message.role === "assistant") text = entry.message.errorMessage;
+		}
+	} else if (entry.type === "custom_message") text = extractRawText(entry.content);
+	else if (entry.type === "compaction" || entry.type === "branch_summary") text = entry.summary;
+	return text?.trim() ? text : undefined;
+}
+
+function extractRawText(content: unknown): string {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content
+		.filter(
+			(block): block is { type: "text"; text: string } =>
+				block !== null &&
+				typeof block === "object" &&
+				"type" in block &&
+				block.type === "text" &&
+				"text" in block &&
+				typeof block.text === "string",
+		)
+		.map((block) => block.text)
+		.join("");
+}
+
+interface SavedLabel {
+	label: string | undefined;
+	labelTimestamp?: string;
+}
+
+function collectSavedLabels(tree: readonly SessionTreeNode[]): Map<string, SavedLabel> {
+	const result = new Map<string, SavedLabel>();
+	const visit = (nodes: readonly SessionTreeNode[]) => {
+		for (const node of nodes) {
+			result.set(node.entry.id, {
+				label: node.label === undefined ? undefined : sanitizeSingleLine(node.label),
+				labelTimestamp:
+					node.labelTimestamp === undefined ? undefined : sanitizeSingleLine(node.labelTimestamp),
+			});
+			visit(node.children);
+		}
+	};
+	visit(tree);
+	return result;
+}
+
+async function copyText(text: string, signal: AbortSignal): Promise<void> {
+	signal.throwIfAborted();
+	await copyToClipboard(text);
+	signal.throwIfAborted();
+}
+
+function notifySafely(
+	ctx: ExtensionCommandContext,
+	message: string,
+	level: Parameters<ExtensionCommandContext["ui"]["notify"]>[1],
+): void {
+	try {
+		ctx.ui.notify(sanitizeSingleLine(message), level);
+	} catch {
+		// The command context may have been replaced while the selector was open.
+	}
+}
+
+function formatError(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}