@linxiraos/pi-tui 1.1.26 → 1.2.0

package/src/tools/streaming-output.d.ts

@@ -31,6 +31,15 @@ export interface OutputSummary {
     columnDroppedBytes?: number;
     /** Number of distinct lines that hit the per-line column cap. */
     columnTruncatedLines?: number;
+    /**
+     * 1-indexed first and last lines the column cap cut, numbered as in the
+     * artifact. Absent when the numbering cannot match the artifact (an inline
+     * substitute was capped, or `replace()` rewrote the buffer).
+     */
+    columnTruncatedRange?: {
+        first: number;
+        last: number;
+    };
     /** Configured per-line column cap in effect (UTF-8 bytes), when > 0. */
     columnMax?: number;
     /** Artifact ID for internal URL access (artifact://<id>) when truncated */
@@ -236,7 +245,8 @@ export declare class OutputSink {
     constructor(options?: OutputSinkOptions);
     /**
      * Push a chunk of output. The buffer management and onChunk callback run
-     * synchronously. File sink writes are deferred and serialized internally.
+     * synchronously; onChunk fires after the chunk is stored, so {@link preview}
+     * already includes it. File sink writes are deferred and serialized internally.
      *
      * `inline` substitutes a bounded representation for the in-memory buffer and
      * live preview while the complete chunk is mirrored to the artifact.
@@ -260,6 +270,15 @@ export declare class OutputSink {
      * branch in `dump()` against stale totals.
      */
     replace(text: string): void;
+    /**
+     * Current inline view without finalizing: the body {@link dump} would
+     * return right now (head + elision marker + rolling tail), minus any notice
+     * and minus the newline `dump()` appends after output that ends in a bare
+     * carriage return. Each call trims the rolling tail to its budget (a copy
+     * of the tail window once it overflowed), so call it from a throttled
+     * onChunk (`chunkThrottleMs`), not once per raw chunk.
+     */
+    preview(): string;
     dump(notice?: string): Promise<OutputSummary>;
     /**
      * Release the artifact spill descriptor on an exit path that skips

package/src/tools/streaming-output.ts

@@ -1,3 +1,4 @@
+import * as fs from "node:fs";
 import type { AgentToolUpdateCallback } from "@linxiraos/pi-agent-core";
 import { formatBytes, materializeString, sanitizeText } from "@linxiraos/pi-utils";
 import { sanitizeWithOptionalSixelPassthrough } from "../render/sixel";
@@ -51,6 +52,12 @@ export interface OutputSummary {
 	columnDroppedBytes?: number;
 	/** Number of distinct lines that hit the per-line column cap. */
 	columnTruncatedLines?: number;
+	/**
+	 * 1-indexed first and last lines the column cap cut, numbered as in the
+	 * artifact. Absent when the numbering cannot match the artifact (an inline
+	 * substitute was capped, or `replace()` rewrote the buffer).
+	 */
+	columnTruncatedRange?: { first: number; last: number };
 	/** Configured per-line column cap in effect (UTF-8 bytes), when > 0. */
 	columnMax?: number;
 	/** Artifact ID for internal URL access (artifact://<id>) when truncated */
@@ -232,6 +239,10 @@ function truncateBytesWindowed(
 				? data.substring(0, Math.min(data.length, maxBytes))
 				: data.substring(Math.max(0, data.length - maxBytes));
 
+		// All-ASCII window: one byte per char, so it is exactly `maxBytes` bytes on a boundary.
+		const windowBytes = Buffer.byteLength(window, "utf-8");
+		if (windowBytes === window.length) return { text: window, bytes: windowBytes };
+
 		const buf = Buffer.from(window, "utf-8");
 
 		if (mode === "head") {
@@ -875,6 +886,8 @@ export class TailBuffer {
 export class OutputSink {
 	#buffer = "";
 	#bufferBytes = 0;
+	/** The overflowed tail window may exceed its budget until {@link #trimTail} runs. */
+	#tailUntrimmed = false;
 	#head = "";
 	#headBytes = 0;
 	#headLines = 0; // newline count inside #head
@@ -894,6 +907,10 @@ export class OutputSink {
 	#columnEllipsisAdded = false;
 	#columnDroppedBytes = 0;
 	#columnTruncatedLines = 0;
+	#columnFirstCutLine = 0;
+	#columnLastCutLine = 0;
+	/** Set once a cut line's number may not match the artifact; the range is then withheld. */
+	#columnCutLinesUnmapped = false;
 	#file?: {
 		path: string;
 		artifactId?: string;
@@ -1001,7 +1018,8 @@ export class OutputSink {
 
 	/**
 	 * Push a chunk of output. The buffer management and onChunk callback run
-	 * synchronously. File sink writes are deferred and serialized internally.
+	 * synchronously; onChunk fires after the chunk is stored, so {@link preview}
+	 * already includes it. File sink writes are deferred and serialized internally.
 	 *
 	 * `inline` substitutes a bounded representation for the in-memory buffer and
 	 * live preview while the complete chunk is mirrored to the artifact.
@@ -1014,6 +1032,8 @@ export class OutputSink {
 		const substituted = inline !== undefined;
 		const inlineChunk = inline === undefined ? chunk : sanitizeText(inline);
 
+		this.#store(chunk, inlineChunk, substituted);
+
 		// Throttled onChunk: coalesce chunks arriving inside the throttle window.
 		// A timer flushes quiet tails at the throttle boundary; dump() catches a
 		// final pending chunk when the process exits before that timer fires.
@@ -1028,9 +1048,15 @@ export class OutputSink {
 				this.#schedulePendingChunkFlush();
 			}
 		}
+	}
 
+	/** Count, cap, mirror, and retain one sanitized chunk. */
+	#store(chunk: string, inlineChunk: string, substituted: boolean): void {
 		const rawBytes = Buffer.byteLength(chunk, "utf-8");
 		this.#totalBytes += rawBytes;
+		// Line the chunk starts on, as numbered in the artifact; 0 when the capped
+		// inline text is a substitute whose lines do not map onto the artifact.
+		const firstLine = substituted ? 0 : this.#totalLines + 1;
 
 		if (chunk.length > 0) {
 			this.#sawData = true;
@@ -1041,7 +1067,7 @@ export class OutputSink {
 		// Per-line column cap. State persists across chunks so a mid-line split
 		// still respects the budget. Operates on the inline chunk; the complete
 		// chunk is mirrored to the artifact before any cap is applied.
-		const capped = this.#maxColumns > 0 ? this.#applyColumnCap(inlineChunk) : inlineChunk;
+		const capped = this.#maxColumns > 0 ? this.#applyColumnCap(inlineChunk, firstLine) : inlineChunk;
 		const cappedBytes = capped === inlineChunk ? inlineBytes : Buffer.byteLength(capped, "utf-8");
 		const cappedThisChunk = cappedBytes < inlineBytes;
 		if (substituted) this.#truncated = true;
@@ -1089,11 +1115,13 @@ export class OutputSink {
 	 * cap; subsequent bytes are skipped until the next `\n`. State persists
 	 * across calls so a long line split across chunks still produces one marker.
 	 */
-	#applyColumnCap(chunk: string): string {
+	#applyColumnCap(chunk: string, firstLine: number): string {
 		if (chunk.length === 0) return chunk;
+		if (!this.#columnEllipsisAdded && this.#fitsColumnCap(chunk)) return chunk;
 		const max = this.#maxColumns;
 		const parts: string[] = [];
 		let cursor = 0;
+		let line = firstLine;
 		while (cursor < chunk.length) {
 			const nlIdx = chunk.indexOf(NL, cursor);
 			const segEnd = nlIdx === -1 ? chunk.length : nlIdx;
@@ -1124,6 +1152,12 @@ export class OutputSink {
 						parts.push(ELLIPSIS);
 						this.#columnDroppedBytes += segBytes - keptBytes;
 						this.#columnTruncatedLines++;
+						if (line > 0) {
+							if (this.#columnFirstCutLine === 0) this.#columnFirstCutLine = line;
+							this.#columnLastCutLine = line;
+						} else {
+							this.#columnCutLinesUnmapped = true;
+						}
 						this.#currentLineBytes += keptBytes + ellipsisBytes;
 						this.#columnEllipsisAdded = true;
 					}
@@ -1134,10 +1168,37 @@ export class OutputSink {
 			this.#currentLineBytes = 0;
 			this.#columnEllipsisAdded = false;
 			cursor = nlIdx + 1;
+			if (line > 0) line++;
 		}
 		return parts.join("");
 	}
 
+	/**
+	 * Fast path for {@link #applyColumnCap}: when every line segment fits the
+	 * remaining cap even at the 3-bytes-per-code-unit UTF-8 worst case, the
+	 * chunk passes through unchanged and only the trailing line width is
+	 * measured. Returns false (state untouched) when any line might trip the cap.
+	 */
+	#fitsColumnCap(chunk: string): boolean {
+		const max = this.#maxColumns;
+		let room = max - this.#currentLineBytes;
+		let cursor = 0;
+		for (;;) {
+			const nlIdx = chunk.indexOf(NL, cursor);
+			const segEnd = nlIdx === -1 ? chunk.length : nlIdx;
+			if ((segEnd - cursor) * 3 > room) return false;
+			if (nlIdx === -1) break;
+			cursor = nlIdx + 1;
+			room = max;
+		}
+		if (cursor === 0) {
+			this.#currentLineBytes += Buffer.byteLength(chunk, "utf-8");
+		} else {
+			this.#currentLineBytes = cursor === chunk.length ? 0 : Buffer.byteLength(chunk.substring(cursor), "utf-8");
+		}
+		return true;
+	}
+
 	// The rolling tail budget is whatever the head window has not consumed of
 	// the inline budget: `spillThreshold - #headBytes`. While the head window
 	// fills it shrinks toward `spillThreshold - headLimit`; after `replace()`
@@ -1171,15 +1232,27 @@ export class OutputSink {
 			const { text, bytes } = truncateTailBytes(chunk, threshold);
 			this.#buffer = text;
 			this.#bufferBytes = bytes;
-		} else {
-			// Intermediate size is bounded (<= threshold + dataBytes), safe to concat.
-			this.#buffer += chunk;
-			this.#bufferBytes += dataBytes;
-
-			const { text, bytes } = truncateTailBytes(this.#buffer, threshold);
-			this.#buffer = text;
-			this.#bufferBytes = bytes;
+			this.#tailUntrimmed = false;
+			return;
 		}
+		// Amortize the trim: let the window grow to 2× the budget before cutting it
+		// back, so steady-state chunks cost an append instead of a window copy.
+		// `#trimTail()` restores the exact budget before the buffer is read.
+		this.#buffer += chunk;
+		this.#bufferBytes += dataBytes;
+		this.#tailUntrimmed = true;
+		if (this.#bufferBytes > threshold * 2) this.#trimTail();
+	}
+
+	/** Cut an overflowed tail window back to the current tail budget. */
+	#trimTail(): void {
+		if (!this.#tailUntrimmed) return;
+		this.#tailUntrimmed = false;
+		const threshold = Math.max(0, this.#spillThreshold - this.#headBytes);
+		if (this.#bufferBytes <= threshold) return;
+		const { text, bytes } = truncateTailBytes(this.#buffer, threshold);
+		this.#buffer = text;
+		this.#bufferBytes = bytes;
 	}
 
 	/**
@@ -1309,6 +1382,10 @@ export class OutputSink {
 	async #createFileSink(): Promise<void> {
 		if (!this.#artifactPath || this.#fileReady || this.#artifactError) return;
 		try {
+			// Bun's Windows FileSink defers the open: an unopenable target (e.g. a
+			// directory) only fails on the first write, misreported as a write
+			// failure. Probe the open eagerly so it stays classified — and terminal.
+			if (process.platform === "win32") fs.closeSync(fs.openSync(this.#artifactPath, "w"));
 			const sink = Bun.file(this.#artifactPath).writer();
 			this.#file = { path: this.#artifactPath, artifactId: this.#artifactId, sink };
 			this.#fileReady = true;
@@ -1367,6 +1444,7 @@ export class OutputSink {
 		this.#clearPendingChunkTimer();
 		this.#buffer = text;
 		this.#bufferBytes = Buffer.byteLength(text, "utf-8");
+		this.#tailUntrimmed = false;
 		this.#head = "";
 		this.#headBytes = 0;
 		this.#headLines = 0;
@@ -1379,6 +1457,8 @@ export class OutputSink {
 		this.#columnEllipsisAdded = false;
 		this.#columnDroppedBytes = 0;
 		this.#columnTruncatedLines = 0;
+		// The artifact keeps the replaced stream, so later line numbers no longer match it.
+		this.#columnCutLinesUnmapped = true;
 		this.#pendingChunk = "";
 		this.#pendingCarriageReturn = false;
 	}
@@ -1453,22 +1533,31 @@ export class OutputSink {
 		}
 	}
 
-	async dump(notice?: string): Promise<OutputSummary> {
-		if (this.#pendingCarriageReturn) {
-			this.#pendingCarriageReturn = false;
-			this.push(NL);
-		}
-		const noticeLine = notice ? `[${notice}]\n` : "";
+	/**
+	 * Current inline view without finalizing: the body {@link dump} would
+	 * return right now (head + elision marker + rolling tail), minus any notice
+	 * and minus the newline `dump()` appends after output that ends in a bare
+	 * carriage return. Each call trims the rolling tail to its budget (a copy
+	 * of the tail window once it overflowed), so call it from a throttled
+	 * onChunk (`chunkThrottleMs`), not once per raw chunk.
+	 */
+	preview(): string {
+		return this.#composeBody().body;
+	}
 
-		// Flush any chunk still held back by the throttle so the live preview
-		// ends with the complete stream.
-		this.#flushPendingChunk();
+	/**
+	 * Compose the visible output. With head retention, splice head + marker +
+	 * tail when content was elided. Otherwise return the rolling buffer.
+	 */
+	#composeBody(): {
+		body: string;
+		outputBytes: number;
+		outputLines: number;
+		elidedBytes?: number;
+		elidedLines?: number;
+	} {
+		this.#trimTail();
 		const totalLines = this.#sawData ? this.#totalLines + 1 : 0;
-
-		await this.#finalizeFile();
-
-		// Compose the visible output. With head retention, splice head + marker
-		// + tail when content was elided. Otherwise return the rolling buffer.
 		const headBytes = this.#headBytes;
 		const tailBuf = this.#buffer;
 		const tailBytes = this.#bufferBytes;
@@ -1479,39 +1568,50 @@ export class OutputSink {
 		// so column-dropped bytes don't inflate the "elided from middle" count.
 		const effectiveTotalBytes = Math.max(0, this.#totalBytes - this.#columnDroppedBytes);
 
-		let body: string;
-		let outputBytes: number;
-		let outputLines: number;
-		let elidedBytes: number | undefined;
-		let elidedLines: number | undefined;
-
 		if (headBytes > 0 && effectiveTotalBytes > headBytes + tailBytes) {
 			// Middle was elided. Emit head + marker + tail.
-			elidedBytes = Math.max(0, effectiveTotalBytes - headBytes - tailBytes);
-			elidedLines = Math.max(0, totalLines - headLines - tailLines);
+			const elidedBytes = Math.max(0, effectiveTotalBytes - headBytes - tailBytes);
+			const elidedLines = Math.max(0, totalLines - headLines - tailLines);
 			const marker = formatMiddleElisionMarker(elidedLines, elidedBytes);
 			const markerBytes = Buffer.byteLength(marker, "utf-8");
 			const headSep = this.#head.endsWith("\n") ? "" : "\n";
 			const tailSep = tailBuf.startsWith("\n") ? "" : "\n";
-			body = `${this.#head}${headSep}${marker}${tailSep}${tailBuf}`;
-			outputBytes =
-				headBytes +
-				markerBytes +
-				tailBytes +
-				Buffer.byteLength(headSep, "utf-8") +
-				Buffer.byteLength(tailSep, "utf-8");
-			outputLines = headLines + 1 + tailLines;
-			this.#truncated = true;
-		} else if (headBytes > 0) {
+			return {
+				body: `${this.#head}${headSep}${marker}${tailSep}${tailBuf}`,
+				outputBytes: headBytes + markerBytes + tailBytes + headSep.length + tailSep.length,
+				outputLines: headLines + 1 + tailLines,
+				elidedBytes,
+				elidedLines,
+			};
+		}
+		if (headBytes > 0) {
 			// Head + tail combine into the full buffered output (no overlap or elision).
-			body = `${this.#head}${tailBuf}`;
-			outputBytes = headBytes + tailBytes;
-			outputLines = body.length > 0 ? countNewlines(body) + 1 : 0;
-		} else {
-			body = tailBuf;
-			outputBytes = tailBytes;
-			outputLines = tailLines;
+			const body = `${this.#head}${tailBuf}`;
+			return {
+				body,
+				outputBytes: headBytes + tailBytes,
+				outputLines: body.length > 0 ? countNewlines(body) + 1 : 0,
+			};
 		}
+		return { body: tailBuf, outputBytes: tailBytes, outputLines: tailLines };
+	}
+
+	async dump(notice?: string): Promise<OutputSummary> {
+		if (this.#pendingCarriageReturn) {
+			this.#pendingCarriageReturn = false;
+			this.push(NL);
+		}
+		const noticeLine = notice ? `[${notice}]\n` : "";
+
+		// Flush any chunk still held back by the throttle so the live preview
+		// ends with the complete stream.
+		this.#flushPendingChunk();
+		const totalLines = this.#sawData ? this.#totalLines + 1 : 0;
+
+		await this.#finalizeFile();
+
+		const { body, outputBytes, outputLines, elidedBytes, elidedLines } = this.#composeBody();
+		if (elidedBytes !== undefined) this.#truncated = true;
 
 		return {
 			output: `${noticeLine}${body}`,
@@ -1525,6 +1625,10 @@ export class OutputSink {
 			columnDroppedBytes: this.#columnDroppedBytes > 0 ? this.#columnDroppedBytes : undefined,
 			columnTruncatedLines: this.#columnTruncatedLines > 0 ? this.#columnTruncatedLines : undefined,
 			columnMax: this.#columnTruncatedLines > 0 ? this.#maxColumns : undefined,
+			columnTruncatedRange:
+				this.#columnFirstCutLine > 0 && !this.#columnCutLinesUnmapped
+					? { first: this.#columnFirstCutLine, last: this.#columnLastCutLine }
+					: undefined,
 			artifactId: this.#artifactError ? undefined : this.#file?.artifactId,
 			artifactElidedBytes:
 				this.#artifactError || !this.#file?.artifactId || this.#artifactElidedBytes === 0

package/src/tools/task.d.ts

@@ -1,10 +1,9 @@
 import type { Usage } from "@linxiraos/pi-ai";
 import type { ThemeColor } from "../theme/theme";
 import type { ConfiguredThinkingLevel } from "../render/render-utils";
+import type { RenderResultOptions, NativeToolView, ToolRenderResult } from "./renderer";
 import { type Component } from "../tui";
-import type { RenderResultOptions } from "./renderer";
 import { type Theme } from "../theme/theme";
-import type { NativeToolView, ToolRenderResult } from "./renderer";
 /** Render context threaded in from `ToolExecutionComponent.#buildRenderContext`. */
 interface TaskRenderContext {
     hasResult?: boolean;
@@ -255,7 +254,7 @@ export interface AgentProgress {
     resolvedModelRoute?: string;
     /** True when a live advisor was attached to this run's session, not merely enabled in settings. */
     advisor?: boolean;
-    /** The agent's latest self-estimate of task completion (0–100), from the periodic `task.completionProbeMs` side request. */
+    /** The agent's latest self-estimate of task completion (0–100), from the periodic `task.completionProbe` side request. */
     completionPercent?: number;
     /** Data extracted by registered subprocess tool handlers (keyed by tool name) */
     extractedToolData?: Record<string, unknown[]>;