pi-open-tui 0.3.13 → 0.3.14

package/extensions/open-tui/editor.ts

@@ -40,6 +40,8 @@ export interface InlineFooterRenderer {
 
 interface HiddenThinkingLabelComponent {
 	children: unknown[];
+	outputPad?: unknown;
+	render(width: number): string[];
 	setHiddenThinkingLabel(label: string): void;
 	setHideThinkingBlock(hide: boolean): void;
 	updateContent(message: unknown, isStreaming?: boolean): void;
@@ -48,6 +50,7 @@ interface HiddenThinkingLabelComponent {
 function isHiddenThinkingLabelComponent(value: object): value is HiddenThinkingLabelComponent {
 	const component = value as unknown as Record<string, unknown>;
 	return Array.isArray(component.children)
+		&& typeof component.render === "function"
 		&& typeof component.setHiddenThinkingLabel === "function"
 		&& typeof component.setHideThinkingBlock === "function"
 		&& typeof component.updateContent === "function";
@@ -71,6 +74,13 @@ function findLatestHiddenThinkingLabel(tui: TUI): HiddenThinkingLabelComponent {
 	return latest;
 }
 
+/** Width Pi's hidden-thinking `Text(label, outputPad, 0)` wraps at when its message renders at `width`. */
+function hiddenThinkingTextWidth(width: number, outputPad: unknown): number {
+	const pad = typeof outputPad === "number" && Number.isFinite(outputPad) ? Math.max(0, Math.floor(outputPad)) : 1;
+	const paddingX = Math.min(pad, Math.max(0, Math.floor((width - 1) / 2)));
+	return Math.max(1, width - paddingX * 2);
+}
+
 function removeSoftwareCursor(line: string, cursorMarker = ""): string {
 	return line.replace(/\x1b\[7m([\s\S]*?)\x1b\[0m/g, (_match, cursor: string) => {
 		const replacement = `${cursorMarker}${cursor}`;
@@ -308,6 +318,42 @@ export class OpenTuiEditor extends CustomEditor {
 	}
 }
 
+type StreamWrite = (...args: unknown[]) => boolean;
+
+/**
+ * Calls `requestRepaint` after each raw write to a TTY stream. Pi's fullscreen renderer only
+ * rewrites changed rows, so text other extensions print straight to the terminal would
+ * otherwise stay over the editor and footer until a resize.
+ */
+export function repaintAfterStreamWrites(
+	requestRepaint: () => void,
+	stream: NodeJS.WriteStream = process.stderr,
+): () => void {
+	if (!stream.isTTY) return () => {};
+	const original = stream.write as unknown as StreamWrite;
+	let enabled = true;
+	const patched = ((...args: unknown[]) => {
+		const callback = typeof args[args.length - 1] === "function"
+			? (args.pop() as (error?: Error | null) => void)
+			: undefined;
+		// Repaint from the write callback so the redraw lands after the stray text.
+		return original.call(stream, ...args, (error?: Error | null) => {
+			try {
+				if (enabled) requestRepaint();
+			} catch {
+				// A failed repaint must not break the caller's write; logging it here would recurse.
+			}
+			callback?.(error);
+		});
+	}) as typeof stream.write;
+	stream.write = patched;
+	return () => {
+		enabled = false;
+		// A later wrapper may still delegate to ours; leave it as a passthrough then.
+		if (stream.write === patched) stream.write = original as unknown as typeof stream.write;
+	};
+}
+
 export function installEditor(
 	_pi: ExtensionAPI,
 	ctx: ExtensionContext,
@@ -319,41 +365,69 @@ export function installEditor(
 	let previousHardwareCursor: boolean | undefined;
 	let currentCursorStyle = cursorStyle;
 	let hiddenThinkingTarget: HiddenThinkingLabelComponent | undefined;
+	let restoreHiddenThinkingRender: (() => void) | undefined;
+	let buildHiddenThinkingLabel: ((width: number) => string) | undefined;
 	const getActiveTui = (): TUI => {
 		if (!activeTui) throw new Error("Open TUI editor is not mounted");
 		return activeTui;
 	};
+	const resetHiddenThinkingTarget = (): void => {
+		restoreHiddenThinkingRender?.();
+		restoreHiddenThinkingRender = undefined;
+		hiddenThinkingTarget = undefined;
+		buildHiddenThinkingLabel = undefined;
+	};
+	// Build the label at the width Pi actually renders the message with; layout
+	// extensions (e.g. pi-sidebar) can make it much narrower than the terminal.
+	const patchHiddenThinkingRender = (target: HiddenThinkingLabelComponent): void => {
+		const originalRender = target.render;
+		let lastWidth: number | undefined;
+		let lastBuild: ((width: number) => string) | undefined;
+		target.render = function (this: HiddenThinkingLabelComponent, width: number): string[] {
+			const build = buildHiddenThinkingLabel;
+			const textWidth = hiddenThinkingTextWidth(width, this.outputPad);
+			if (build && (build !== lastBuild || textWidth !== lastWidth)) {
+				lastBuild = build;
+				lastWidth = textWidth;
+				this.setHiddenThinkingLabel(build(textWidth));
+			}
+			return originalRender.call(this, width);
+		};
+		restoreHiddenThinkingRender = () => {
+			target.render = originalRender;
+		};
+	};
+	// Only the fullscreen renderer clears and rewrites the whole screen on a forced render.
+	const restoreStderr = repaintAfterStreamWrites(() => {
+		if (activeTui?.mode === "fullscreen") activeTui.requestRender(true);
+	});
 
 	ctx.ui.setEditorComponent((tui, editorTheme, keybindings) => {
 		activeTui = tui;
-		hiddenThinkingTarget = undefined;
+		resetHiddenThinkingTarget();
 		previousHardwareCursor = tui.getShowHardwareCursor();
 		activeEditor = new OpenTuiEditor(tui, editorTheme, keybindings, currentCursorStyle, inlineFooter);
 		return activeEditor;
 	});
 	return {
-		getViewportWidth(): number {
-			const columns = getActiveTui().terminal.columns;
-			if (typeof columns !== "number" || !Number.isFinite(columns)) {
-				throw new Error("Open TUI editor terminal has an invalid width");
-			}
-			return Math.max(1, Math.floor(columns));
-		},
-		setLatestHiddenThinkingLabel(label: string): void {
+		/** `build` receives the hidden-thinking text width and runs again whenever that width changes. */
+		setLatestHiddenThinkingLabel(build: (width: number) => string): void {
 			const tui = getActiveTui();
-			hiddenThinkingTarget ??= findLatestHiddenThinkingLabel(tui);
-			hiddenThinkingTarget.setHiddenThinkingLabel(label);
+			if (!hiddenThinkingTarget) {
+				hiddenThinkingTarget = findLatestHiddenThinkingLabel(tui);
+				patchHiddenThinkingRender(hiddenThinkingTarget);
+			}
+			buildHiddenThinkingLabel = build;
 			tui.requestRender();
 		},
-		resetHiddenThinkingLabelTarget(): void {
-			hiddenThinkingTarget = undefined;
-		},
+		resetHiddenThinkingLabelTarget: resetHiddenThinkingTarget,
 		setCursorStyle(nextCursorStyle: CursorStyle): void {
 			currentCursorStyle = nextCursorStyle;
 			activeEditor?.setCursorStyle(nextCursorStyle, previousHardwareCursor);
 		},
 		cleanup(): void {
-			hiddenThinkingTarget = undefined;
+			restoreStderr();
+			resetHiddenThinkingTarget();
 			ctx.ui.setEditorComponent(undefined);
 			if (activeTui) {
 				if (currentCursorStyle !== "block") activeTui.terminal.write(DEFAULT_CURSOR_STYLE_SEQUENCE);

package/extensions/open-tui/index.ts

@@ -24,9 +24,6 @@ import {
 } from "./peek.ts";
 
 type PendingUiChange = "install" | "uninstall";
-const HIDDEN_THINKING_HORIZONTAL_PADDING = 2;
-// Pi's fullscreen transcript can reserve one more column for its scrollbar.
-const HIDDEN_THINKING_SCROLLBAR_RESERVE = 1;
 
 export function getPendingUiChange(enabled: boolean, active: boolean): PendingUiChange | undefined {
 	if (enabled === active) return undefined;
@@ -78,29 +75,16 @@ export default function (pi: ExtensionAPI) {
 	/** Pi decides whether this label is visible; our toggle only controls updates. */
 	const isPeekEnabled = () => sessionLifecycle.isCurrent() && config.enabled && config.thinkingPeek.lines > 0 && active;
 
-	/** Keep each native hidden-thinking label row within Pi's narrowest transcript width. */
-	const hiddenThinkingLabelWidth = (): number => {
-		if (!editor) throw new Error("Open TUI editor is not installed");
-		return Math.max(
-			1,
-			editor.getViewportWidth() - HIDDEN_THINKING_HORIZONTAL_PADDING - HIDDEN_THINKING_SCROLLBAR_RESERVE,
-		);
-	};
-
 	const setPeekLabel = (ctx?: ExtensionContext): void => {
 		if (!isPeekEnabled() || peek.phase === "idle") return;
 		const target = ctx ?? lastCtx;
 		if (!target || !isTuiContext(target)) return;
 		if (!editor) throw new Error("Open TUI editor is not installed");
-		editor.setLatestHiddenThinkingLabel(
-			buildPeekLabel(
-				peek,
-				peekFrame,
-				resolveGlyphs(config.icons.mode),
-				hiddenThinkingLabelWidth(),
-				config.thinkingPeek.lines,
-			),
-		);
+		const snapshot = { ...peek };
+		const frame = peekFrame;
+		const glyphs = resolveGlyphs(config.icons.mode);
+		const lines = config.thinkingPeek.lines;
+		editor.setLatestHiddenThinkingLabel((width) => buildPeekLabel(snapshot, frame, glyphs, width, lines));
 		peekLabelActive = true;
 	};
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-open-tui",
-  "version": "0.3.13",
+  "version": "0.3.14",
   "description": "A polished TUI for Pi coding agent: animated logo header, Starship-style footer, rounded editor with model metadata, and prompt-box user messages.",
   "type": "module",
   "repository": {