@oh-my-pi/pi-tui 18.4.8 → 18.4.10

package/dist/types/tools/streaming-output.d.ts

@@ -6,12 +6,11 @@ export declare const DEFAULT_MAX_BYTES: number;
 /** Default UTF-8 byte budget per match line. */
 export declare const DEFAULT_MAX_COLUMN = 512;
 /**
- * Default artifact-on-disk cap for {@link OutputSink}.
- *
- * `0` means unbounded: by default, `artifact://<id>` references preserve the
- * complete raw stream instead of a capped head/tail sample.
+ * Default artifact-on-disk cap for {@link OutputSink}: 16 MiB, split into a
+ * {@link ARTIFACT_DEFAULT_HEAD_BYTES} head and a rolling tail. `0` means
+ * unbounded (the complete raw stream is preserved).
  */
-export declare const ARTIFACT_DEFAULT_MAX_BYTES = 0;
+export declare const ARTIFACT_DEFAULT_MAX_BYTES: number;
 /** Default head budget; the remainder becomes the rolling tail window. */
 export declare const ARTIFACT_DEFAULT_HEAD_BYTES: number;
 /** First failed artifact I/O operation; safe to persist without exposing filesystem errors. */
@@ -36,6 +35,11 @@ export interface OutputSummary {
     columnMax?: number;
     /** Artifact ID for internal URL access (artifact://<id>) when truncated */
     artifactId?: string;
+    /**
+     * Bytes the artifact cap dropped from the middle of the saved file. When
+     * set, `artifact://<id>` holds a head/tail sample, not the full output.
+     */
+    artifactElidedBytes?: number;
     /** Full raw output was not completely saved; artifactId is unavailable. */
     artifactError?: OutputArtifactError;
 }
@@ -67,17 +71,18 @@ export interface OutputSinkOptions {
     /** Minimum ms between onChunk calls. 0 = every chunk (default). */
     chunkThrottleMs?: number;
     /**
-     * Optional cap on bytes written to the artifact-on-disk file. When the cap
-     * is hit, the head window is preserved verbatim and subsequent output feeds
-     * a rolling tail window; on close, the sink writes a single
+     * Cap on bytes written to the artifact-on-disk file. When the cap is hit,
+     * the head window is preserved verbatim and subsequent output feeds a
+     * rolling tail window; on close, the sink writes a single
      * `[ARTIFACT TRUNCATED: …]` notice between them. Default
-     * {@link ARTIFACT_DEFAULT_MAX_BYTES} (unbounded).
+     * {@link ARTIFACT_DEFAULT_MAX_BYTES} (16 MiB); `0` = unbounded.
      */
     artifactMaxBytes?: number;
     /**
      * Bytes reserved for the head window of the capped artifact file. The
      * tail window receives `artifactMaxBytes - artifactHeadBytes`. Default
-     * {@link ARTIFACT_DEFAULT_HEAD_BYTES}; clamped to `[0, artifactMaxBytes]`.
+     * {@link ARTIFACT_DEFAULT_HEAD_BYTES}, but at most half of
+     * `artifactMaxBytes`; clamped to `[0, artifactMaxBytes]`.
      */
     artifactHeadBytes?: number;
 }

package/dist/types/tui.d.ts

@@ -111,6 +111,9 @@ export interface Component {
      * last time.
      */
     render(width: number): readonly string[];
+    /** Inline decision panels must keep displaced settled transcript rows in
+     * native scrollback even when mounted inside a transient editor container. */
+    readonly retireDisplacedTranscript?: boolean;
     /**
      * Describe the component semantically for a Tern Surface Protocol
      * terminal (see `native/node.ts`). Called instead of `render()` when the
@@ -330,6 +333,11 @@ export declare class TUI extends Container {
         options?: OverlayOptions;
         preFocus: Component | null;
         hidden: boolean;
+        /**
+         * A sheet the user clicked away from (see {@link TUI.#focusFromPointer}):
+         * it stays up but no longer holds the keys, until focus moves back into it.
+         */
+        released: boolean;
     }[];
     constructor(terminal: Terminal, showHardwareCursor?: boolean, options?: TUIOptions);
     /**

package/dist/types/windows-input-mode.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Decode Windows console win32-input-mode key records into the key sequences
+ * the rest of the TUI already understands.
+ *
+ * Hosts without the kitty keyboard protocol (Windows Terminal before 1.25)
+ * deliver Shift+Enter as a bare `\r` (indistinguishable from Enter) and
+ * Ctrl+Enter as `\n`. Enabling `CSI ? 9001 h` makes the console host serving
+ * this process report every key as `CSI Vk ; Sc ; Uc ; Kd ; Cs ; Rc _`, which
+ * carries the full modifier state. Paste text, mouse reports and terminal
+ * replies keep arriving as plain VT, so only key records need translating.
+ *
+ * Unmodified and legacy-expressible keys translate to the bytes a legacy
+ * terminal sends; chords legacy encoding loses (modified Enter/Tab/Escape,
+ * Ctrl+Shift+letter, …) translate to kitty CSI-u, which key matching already
+ * parses.
+ */
+/** Stateful decoder: joins UTF-16 surrogate halves that arrive as separate records. */
+export declare class Win32InputModeDecoder {
+    #private;
+    /**
+     * Translate one stdin sequence. Returns `undefined` when `data` is not a
+     * win32-input-mode record (pass it through unchanged), otherwise the key
+     * events it produces — empty for key releases and bare modifier presses.
+     */
+    decode(data: string): string[] | undefined;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-tui",
-	"version": "18.4.8",
+	"version": "18.4.10",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"homepage": "https://omp.sh",
 	"author": {
@@ -41,14 +41,14 @@
 		"gen:glyphs": "bun scripts/gen-glyphs.ts"
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.4.8",
-		"@oh-my-pi/pi-agent-core": "18.4.8",
-		"@oh-my-pi/pi-ai": "18.4.8",
-		"@oh-my-pi/pi-catalog": "18.4.8",
-		"@oh-my-pi/pi-natives": "18.4.8",
-		"@oh-my-pi/pi-utils": "18.4.8",
-		"@oh-my-pi/pi-wire": "18.4.8",
-		"@oh-my-pi/snapcompact": "18.4.8"
+		"@oh-my-pi/omptype": "18.4.10",
+		"@oh-my-pi/pi-agent-core": "18.4.10",
+		"@oh-my-pi/pi-ai": "18.4.10",
+		"@oh-my-pi/pi-catalog": "18.4.10",
+		"@oh-my-pi/pi-natives": "18.4.10",
+		"@oh-my-pi/pi-utils": "18.4.10",
+		"@oh-my-pi/pi-wire": "18.4.10",
+		"@oh-my-pi/snapcompact": "18.4.10"
 	},
 	"devDependencies": {
 		"kitty-vt-wasm": "^0.2.0"

package/src/apps/debug/log-viewer.ts

@@ -1,10 +1,15 @@
+import type { TspPickerGroup, TspPickerItem, TspTone } from "@oh-my-pi/pi-wire";
 import { formatKeyHint, formatKeyHints } from "../../app-keybindings";
 import type { Component } from "../../tui";
+import { code } from "../../native/describe";
+import { Memo } from "../../native/memo";
+import type { DescribeContext, NativeNode, NativeUiEvent } from "../../native/node";
+import { CLOSE_ACTION, picker, pickerAction, pickerEvent, pickerHits, pickerQuery } from "../../native/picker";
 import { matchesKey } from "../../keys";
 import { Input } from "../../components/input";
 import { routeSgrMouseInput, type SgrMouseEvent } from "../../mouse";
 import { padding, truncateToWidth, visibleWidth } from "../../utils";
-import { sanitizeText } from "@oh-my-pi/pi-utils";
+import { isRecord, sanitizeText } from "@oh-my-pi/pi-utils";
 import { theme } from "../../theme/theme";
 import { sanitizeDisplayText } from "../../overlays/extensions/display-text";
 import { DebugViewerFrame, type DebugViewerFrameContent, type DebugViewerFrameContext } from "./viewer-frame";
@@ -24,6 +29,15 @@ export const LOAD_OLDER_LABEL = "### MOVE UP TO LOAD MORE...";
 const INITIAL_LOG_CHUNK = 50;
 const LOAD_OLDER_CHUNK = 50;
 const MIN_LOG_VIEWER_WIDTH = 48;
+/** Picker item id of the "load older entries" row. */
+const OLDER_ITEM = "older";
+/** Status-dot tone of a log level. */
+const LEVEL_TONES: Readonly<Record<string, TspTone>> = {
+	error: "error",
+	warn: "warning",
+	info: "info",
+	debug: "muted",
+};
 
 type LogEntry = {
 	rawLine: string;
@@ -40,6 +54,47 @@ type DebugLogViewerModelOptions = {
 	loadOlderLogs?: (limitDays?: number) => Promise<string>;
 };
 
+/**
+ * One log entry as a picker row: the message as the label, the remaining
+ * fields as `key=value` detail, the local time and pid as facts and the
+ * level as the status dot. Lines that aren't JSON objects show as they are.
+ */
+function logPickerItem(id: string, rawLine: string): TspPickerItem {
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(rawLine);
+	} catch {}
+	if (!isRecord(parsed)) {
+		return { id, label: sanitizeDisplayText(rawLine).replace(/\s+/g, " "), mono: true };
+	}
+	const { timestamp, level, pid, message, ...rest } = parsed;
+	let detail = "";
+	for (const key in rest) {
+		const value = rest[key];
+		detail += `${detail ? " " : ""}${key}=${typeof value === "string" ? value : JSON.stringify(value)}`;
+	}
+	const time = typeof timestamp === "string" ? new Date(timestamp) : undefined;
+	return {
+		id,
+		label: sanitizeDisplayText(typeof message === "string" ? message : rawLine).replace(/\s+/g, " "),
+		detail: detail ? sanitizeDisplayText(detail).replace(/\s+/g, " ") : undefined,
+		dot: typeof level === "string" ? LEVEL_TONES[level] : undefined,
+		facts: {
+			time: time && Number.isFinite(time.getTime()) ? time.toLocaleTimeString(undefined, { hour12: false }) : "",
+			pid: typeof pid === "number" ? String(pid) : "",
+		},
+	};
+}
+
+/** A log line pretty-printed for the preview pane: indented JSON when it parses, else the sanitized line. */
+function logPreviewText(rawLine: string): { text: string; lang?: string } {
+	try {
+		return { text: JSON.stringify(JSON.parse(rawLine), null, 2), lang: "json" };
+	} catch {
+		return { text: sanitizeDisplayText(rawLine) };
+	}
+}
+
 type ViewerRow =
 	| {
 			kind: "warning";
@@ -516,6 +571,10 @@ export class DebugLogViewerComponent implements Component {
 	#statusMessage: string | undefined;
 	#loadingOlder = false;
 	#bodyLineToRowIndex: Array<number | undefined> = [];
+	readonly #native = new Memo();
+	/** Picker rows by log index, valid while {@link #nativeItemsCount} entries are loaded (a prepend shifts indices). */
+	#nativeItems = new Map<number, TspPickerItem>();
+	#nativeItemsCount = 0;
 
 	constructor(options: DebugLogViewerComponentOptions) {
 		this.#deps = options.deps;
@@ -606,6 +665,24 @@ export class DebugLogViewerComponent implements Component {
 			return;
 		}
 
+		// Page and end keys jump the cursor; the frame (or the native list)
+		// keeps it in view.
+		const jump = matchesKey(keyData, "pageUp")
+			? -this.#frame.getBodyHeight()
+			: matchesKey(keyData, "pageDown")
+				? this.#frame.getBodyHeight()
+				: matchesKey(keyData, "home")
+					? -this.#model.rows.length
+					: matchesKey(keyData, "end")
+						? this.#model.rows.length
+						: 0;
+		if (jump !== 0) {
+			this.#statusMessage = undefined;
+			this.#model.moveCursor(jump, false);
+			this.#onUpdate?.();
+			return;
+		}
+
 		if (matchesKey(keyData, "right")) {
 			this.#statusMessage = undefined;
 			if (this.#model.cursorRowKind === "load-older") {
@@ -666,12 +743,169 @@ export class DebugLogViewerComponent implements Component {
 
 	invalidate(): void {
 		this.#frame.invalidate();
+		this.#native.clear();
 	}
 
 	dispose(): void {
 		this.#frame.dispose();
 	}
 
+	/** A `picker` sheet floats over the transcript instead of taking the screen. */
+	nativeSheet(cx: DescribeContext): boolean {
+		return cx.supports("picker");
+	}
+
+	/**
+	 * The logs as a picker sheet: the filter as its query, one row per entry
+	 * (message, fields, time, pid, level dot) with the session boundary as a
+	 * group head, the range selection checked, the entry under the cursor
+	 * pretty-printed below, and the keys' actions in the bar. Without the
+	 * `picker` kind it falls back to rows.
+	 */
+	describe(cx: DescribeContext): NativeNode | null {
+		if (!cx.supports("picker")) return null;
+		const model = this.#model;
+		const query = this.#filter.getValue();
+		const cursor = this.#filter.getCursor();
+		const selected = model.getSelectedLogIndices();
+		return this.#native.get(
+			[
+				model.rows,
+				model.cursorRowIndex,
+				selected.join(","),
+				model.logCount,
+				model.isProcessFilterEnabled(),
+				model.canLoadOlder(),
+				query,
+				cursor,
+				this.#loadingOlder,
+				this.#statusMessage,
+			],
+			() => {
+				if (this.#nativeItemsCount !== model.logCount) {
+					this.#nativeItems = new Map();
+					this.#nativeItemsCount = model.logCount;
+				}
+				const items: TspPickerItem[] = [];
+				const order: (string | TspPickerGroup)[] = [];
+				const hits: Record<string, [number, number][]> = {};
+				const needle = query.toLowerCase();
+				for (const viewerRow of model.rows) {
+					if (viewerRow.kind === "warning") {
+						order.push({ group: "session", label: "This session" });
+						continue;
+					}
+					if (viewerRow.kind === "load-older") {
+						items.push({ id: OLDER_ITEM, label: "Load older entries", tone: "muted" });
+						order.push(OLDER_ITEM);
+						continue;
+					}
+					let item = this.#nativeItems.get(viewerRow.logIndex);
+					if (!item) {
+						item = logPickerItem(`l${viewerRow.logIndex}`, model.getRawLine(viewerRow.logIndex));
+						this.#nativeItems.set(viewerRow.logIndex, item);
+					}
+					items.push(item);
+					order.push(item.id);
+					if (needle && typeof item.label === "string") {
+						const found = pickerHits(item.label, [needle]);
+						if (found.length > 0) hits[item.id] = found;
+					}
+				}
+				const cursorLog = model.cursorLogIndex;
+				const preview = cursorLog === undefined ? undefined : logPreviewText(model.getRawLine(cursorLog));
+				const subtitle = [
+					`${model.visibleLogCount}/${model.logCount} entries`,
+					selected.length > 1 ? `${selected.length} selected` : undefined,
+					this.#loadingOlder ? "loading older…" : undefined,
+				]
+					.filter(part => part !== undefined)
+					.join(" · ");
+				return picker(
+					{
+						title: "Recent logs",
+						subtitle,
+						noun: "entries",
+						size: "lg",
+						layout: "rows",
+						preview: preview ? "below" : "none",
+						...pickerQuery(this.#filter),
+						placeholder: "Filter logs…",
+						columns: [
+							{ id: "pid", format: "dim", priority: 0 },
+							{ id: "time", format: "dim", priority: 1 },
+						],
+						items,
+						order,
+						hits,
+						selected:
+							model.cursorRowKind === "load-older"
+								? OLDER_ITEM
+								: cursorLog === undefined
+									? null
+									: `l${cursorLog}`,
+						current: selected.length > 1 ? selected.map(index => `l${index}`) : [],
+						total: model.logCount,
+						empty: query ? "No matching log entries" : "No log entries",
+						message: this.#statusMessage,
+						actions: [
+							pickerAction("copy", "Copy", "ctrl+c", { primary: true }),
+							pickerAction("all", "Select all", "ctrl+a"),
+							pickerAction("pid", "This process", "ctrl+p", { on: model.isProcessFilterEnabled() }),
+							pickerAction("older", "Load older", "ctrl+o", {
+								disabled: model.canLoadOlder() ? undefined : "No older log entries",
+							}),
+							CLOSE_ACTION,
+						],
+					},
+					preview && cursorLog !== undefined
+						? [{ ...code(preview.text, { lang: preview.lang, wrap: true }), key: `entry:${cursorLog}` }]
+						: undefined,
+				);
+			},
+		);
+	}
+
+	/**
+	 * Pointer actions run the keys' code: a row click moves the cursor there,
+	 * a second click copies it (or loads older entries from that row), and the
+	 * bar's buttons mirror their keys.
+	 */
+	handleNativeEvent(event: NativeUiEvent): void {
+		const ev = pickerEvent(event);
+		if (!ev) return;
+		this.#statusMessage = undefined;
+		if (ev.kind === "action") {
+			switch (ev.act) {
+				case "copy":
+					this.#copySelected();
+					return;
+				case "all":
+					this.#model.selectAllVisible();
+					return;
+				case "pid":
+					this.#model.toggleProcessFilter();
+					return;
+				case "older":
+					void this.#handleLoadOlder(this.#frame.getBodyHeight() + 1);
+					return;
+				case "close":
+					this.#onExit();
+					return;
+			}
+			return;
+		}
+		const rowIndex = this.#model.rows.findIndex(viewerRow =>
+			ev.item === OLDER_ITEM
+				? viewerRow.kind === "load-older"
+				: viewerRow.kind === "log" && `l${viewerRow.logIndex}` === ev.item,
+		);
+		if (rowIndex < 0 || !this.#model.moveCursorToRow(rowIndex, false)) return;
+		if (ev.kind !== "activate") return;
+		if (ev.item === OLDER_ITEM) void this.#handleLoadOlder();
+		else this.#copySelected();
+	}
+
 	render(width: number): readonly string[] {
 		return this.#frame.render(Math.max(MIN_LOG_VIEWER_WIDTH, width));
 	}
@@ -715,7 +949,7 @@ export class DebugLogViewerComponent implements Component {
 	}
 
 	#controlsText(): string {
-		return `${formatKeyHint("escape")} close · ${formatKeyHint("ctrl+c")} copy · ${formatKeyHints(["up", "down"])}/wheel move · click toggle · ${formatKeyHints(["shift+up", "shift+down"])} select · ${formatKeyHints(["left", "right"])} collapse/expand · ${formatKeyHint("ctrl+a")} all · ${formatKeyHint("ctrl+o")} older · ${formatKeyHint("ctrl+p")} pid`;
+		return `${formatKeyHint("escape")} close · ${formatKeyHint("ctrl+c")} copy · ${formatKeyHints(["up", "down"])}/wheel move · ${formatKeyHints(["pageUp", "pageDown"])} page · ${formatKeyHints(["home", "end"])} first/last · click toggle · ${formatKeyHints(["shift+up", "shift+down"])} select · ${formatKeyHints(["left", "right"])} collapse/expand · ${formatKeyHint("ctrl+a")} all · ${formatKeyHint("ctrl+o")} older · ${formatKeyHint("ctrl+p")} pid`;
 	}
 
 	#filterText(): string {

package/src/apps/debug/protocol-probe.ts

@@ -23,6 +23,8 @@ import { Text } from "../../components/text";
 import { ImageProtocol, NotifyProtocol, TERMINAL } from "../../terminal-capabilities";
 import { DynamicBorder } from "../../chrome/dynamic-border";
 import { theme } from "../../theme/theme";
+import { ansi } from "../../native/describe";
+import type { NativeNode } from "../../native/node";
 
 const PNG_SIGNATURE = Uint8Array.of(0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a);
 
@@ -148,13 +150,20 @@ function imageProtocolLabel(): string {
 /**
  * Deliberate exception to the normal text/data components: OSC 66 probes must
  * reach the terminal byte-for-byte, without sanitization, wrapping, clipping,
- * or padding that could invalidate the protocol sample.
+ * or padding that could invalidate the protocol sample. A native terminal
+ * gets the same bytes as one `ansi` block.
  */
 class RawLines implements Component {
 	readonly #lines: readonly string[];
+	readonly #native: NativeNode;
 
 	constructor(lines: readonly string[]) {
 		this.#lines = lines.slice();
+		this.#native = ansi(this.#lines.join("\n"));
+	}
+
+	describe(): NativeNode {
+		return this.#native;
 	}
 
 	render(): readonly string[] {