@oh-my-pi/pi-tui 18.4.1 → 18.4.3

package/src/tools/bash.ts

@@ -130,19 +130,51 @@ function unescapePartialJsonString(value: string): string {
 	return output;
 }
 
-function extractPartialBashEnv(partialJson: string | undefined): Record<string, string> | undefined {
+// One-slot memo: every render path over one streamed args object (call
+// preview, result header, repaint) asks for the same buffer.
+let lastPartialEnvJson: string | undefined;
+let lastPartialEnv: Readonly<Record<string, string>> | undefined;
+
+function extractPartialBashEnv(partialJson: string | undefined): Readonly<Record<string, string>> | undefined {
 	if (!partialJson) return undefined;
+	if (partialJson === lastPartialEnvJson) return lastPartialEnv;
+	let env: Record<string, string> | undefined;
 	const envStart = partialJson.search(/"env"\s*:\s*\{/u);
-	if (envStart === -1) return undefined;
-	const objectStart = partialJson.indexOf("{", envStart);
-	if (objectStart === -1) return undefined;
-	const envBody = partialJson.slice(objectStart + 1);
-	const env: Record<string, string> = {};
-	const matcher = /"([A-Za-z_][A-Za-z0-9_]*)"\s*:\s*"((?:\\.|[^"\\])*)(?:"|$)/gu;
-	for (const match of envBody.matchAll(matcher)) {
-		env[match[1]!] = unescapePartialJsonString(match[2]!);
+	const objectStart = envStart === -1 ? -1 : partialJson.indexOf("{", envStart);
+	if (objectStart !== -1) {
+		// Scan only the env object: stop at its closing brace (outside strings)
+		// so the keys that follow it are not read as env assignments.
+		let objectEnd = partialJson.length;
+		let depth = 0;
+		for (let i = objectStart + 1; i < partialJson.length; i++) {
+			const ch = partialJson.charCodeAt(i);
+			if (ch === 0x22) {
+				// Skip the string body, honoring escapes; an unterminated string runs to the end.
+				for (i++; i < partialJson.length; i++) {
+					const inner = partialJson.charCodeAt(i);
+					if (inner === 0x5c) i++;
+					else if (inner === 0x22) break;
+				}
+			} else if (ch === 0x7b || ch === 0x5b) {
+				depth++;
+			} else if (ch === 0x7d || ch === 0x5d) {
+				if (depth === 0) {
+					objectEnd = i;
+					break;
+				}
+				depth--;
+			}
+		}
+		const envBody = partialJson.slice(objectStart + 1, objectEnd);
+		const matcher = /"([A-Za-z_][A-Za-z0-9_]*)"\s*:\s*"((?:\\.|[^"\\])*)(?:"|$)/gu;
+		for (const match of envBody.matchAll(matcher)) {
+			env ??= {};
+			env[match[1]!] = unescapePartialJsonString(match[2]!);
+		}
 	}
-	return Object.keys(env).length > 0 ? env : undefined;
+	lastPartialEnvJson = partialJson;
+	lastPartialEnv = env ? Object.freeze(env) : undefined;
+	return lastPartialEnv;
 }
 
 function formatWallTimeSeconds(wallTimeMs: number): string {
@@ -243,8 +275,12 @@ export function createShellRenderer<TArgs>(config: ShellRendererConfig<TArgs>) {
 	return {
 		renderCall(args: TArgs, options: RenderResultOptions, uiTheme: Theme): Component {
 			const renderArgs = toBashRenderArgs(args, config);
-			const cmdLines = formatBashCommandLines(renderArgs, uiTheme);
+			// Highlighting the whole (possibly still-streaming) command is the
+			// expensive part: defer it to the first paint, once per component,
+			// so a rebuild that is replaced before painting never pays for it.
+			let cmdLines: string[] | undefined;
 			return framedToolCard(uiTheme, () => {
+				cmdLines ??= formatBashCommandLines(renderArgs, uiTheme);
 				const header =
 					config.showHeader === false
 						? undefined
@@ -275,7 +311,7 @@ export function createShellRenderer<TArgs>(config: ShellRendererConfig<TArgs>) {
 			args?: TArgs,
 		): Component {
 			const renderArgs = toBashRenderArgs(args, config);
-			const cmdLines = args ? formatBashCommandLines(renderArgs, uiTheme) : undefined;
+			let cmdLines: string[] | undefined;
 			const isError = result.isError === true;
 			const isPartial = options.isPartial === true;
 			const success = !isPartial && !isError;
@@ -438,7 +474,11 @@ export function createShellRenderer<TArgs>(config: ShellRendererConfig<TArgs>) {
 							{
 								// Viewport-sized tail window in every state — streaming and final
 								// render identically; only ctrl+o uncaps.
-								content: capPreviewLines(cmdLines ?? [], uiTheme, { expanded }),
+								content: capPreviewLines(
+									args ? (cmdLines ??= formatBashCommandLines(renderArgs, uiTheme)) : [],
+									uiTheme,
+									{ expanded },
+								),
 							},
 							{ label: uiTheme.fg("toolTitle", "Output"), content: outputLines },
 						],

package/src/tools/edit.ts

@@ -239,16 +239,14 @@ function decodePartialJsonStringFragment(fragment: string): string {
 	}
 }
 
-function extractPartialJsonString(partialJson: string | undefined, key: string): string | undefined {
-	if (!partialJson) return undefined;
-	const pattern = new RegExp(`"${key}"\\s*:\\s*"((?:\\\\.|[^"\\\\])*)`, "u");
-	const match = pattern.exec(partialJson);
-	if (!match) return undefined;
-	return decodePartialJsonStringFragment(match[1]);
-}
+// `"path": "<possibly unterminated string>` in a raw streamed args buffer.
+const PARTIAL_JSON_PATH_RE = /"path"\s*:\s*"((?:\\.|[^"\\])*)/u;
 
 function getPartialJsonEditPath(args: EditRenderArgs): string | undefined {
-	return filePathFromEditEntry(extractPartialJsonString(args.__partialJson, "path"));
+	const partialJson = args.__partialJson;
+	if (!partialJson) return undefined;
+	const match = PARTIAL_JSON_PATH_RE.exec(partialJson);
+	return match ? decodePartialJsonStringFragment(match[1]!) : undefined;
 }
 
 /** Count distinct file paths in an edits array. */
@@ -427,8 +425,33 @@ function hasEditCallPayload(args: EditRenderArgs, renderContext: EditRenderConte
 	return false;
 }
 
+/**
+ * Head-window preview of streamed replacement text. Only the displayed head is
+ * sanitized and split; the hidden-line count comes from a raw newline scan.
+ * That matches sanitizing the whole text because, on ESC-free input,
+ * `sanitizeText` only deletes individual code units and never a `\n`: the
+ * cut sits on a `\n`, so it cannot split a surrogate pair. The one non-local
+ * rule — a lone surrogate anywhere drops every U+FFFD — is replayed on the
+ * head. ESC-bearing text (ANSI stripping can span lines) takes the full path.
+ */
 function renderPlainTextPreview(text: string, uiTheme: Theme, _filePath?: string): string {
-	const previewLines = cappedHeadLines(sanitizeText(text).split("\n"), CALL_TEXT_PREVIEW_LINES);
+	let previewLines: { lines: readonly string[]; hidden: number };
+	let headEnd = -1;
+	if (!text.includes("\x1b")) {
+		for (let newlines = 0; newlines < CALL_TEXT_PREVIEW_LINES; newlines++) {
+			headEnd = text.indexOf("\n", headEnd + 1);
+			if (headEnd === -1) break;
+		}
+	}
+	if (headEnd === -1) {
+		previewLines = cappedHeadLines(sanitizeText(text).split("\n"), CALL_TEXT_PREVIEW_LINES);
+	} else {
+		let head = sanitizeText(text.slice(0, headEnd));
+		if (head.includes("\ufffd") && !text.isWellFormed()) head = head.replaceAll("\ufffd", "");
+		let hidden = 1;
+		for (let i = text.indexOf("\n", headEnd + 1); i !== -1; i = text.indexOf("\n", i + 1)) hidden++;
+		previewLines = { lines: head.split("\n"), hidden };
+	}
 	let preview = "\n\n";
 	for (const line of previewLines.lines) {
 		preview += `${uiTheme.fg("toolOutput", truncateToWidth(replaceTabs(line), CALL_TEXT_PREVIEW_WIDTH))}\n`;
@@ -751,17 +774,30 @@ interface EditCallFacts {
  * fields tolerate a small lag) or when the payload shrinks (rewind). The
  * final frame (`isPartial === false`) always recomputes. This turns the
  * per-frame O(n) stringify+parse+scan into O(n^2/K) total per call.
+ *
+ * The reveal hands over a fresh args object on every frame, so the gate
+ * keys on the streamed raw payload (`__partialJson`) rather than on args
+ * identity: a frame reuses the facts only when its payload extends, byte for
+ * byte, the payload the facts were derived from, and every direct field the
+ * facts read (path, file_path, rename, op, edits) is unchanged. Final args
+ * carry no `__partialJson`, so the completed call always derives exact facts.
  */
 const EDIT_FACTS_MIN_GROWTH = 512;
-let lastFactsCache:
-	| {
-			editArgs: EditRenderArgs;
-			isPartial: boolean;
-			editMode: EditMode | undefined;
-			length: number;
-			facts: EditCallFacts;
-	  }
-	| undefined;
+interface EditFactsCacheEntry {
+	editArgs: EditRenderArgs;
+	isPartial: boolean;
+	editMode: EditMode | undefined;
+	length: number;
+	/** Streamed raw payload the facts were derived from; set only for streamed `input` payloads. */
+	streamedPayload: string | undefined;
+	filePath: unknown;
+	path: unknown;
+	rename: unknown;
+	op: Operation | undefined;
+	edits: EditRenderEntry[] | undefined;
+	facts: EditCallFacts;
+}
+let lastFactsCache: EditFactsCacheEntry | undefined;
 
 function editFactsInputLength(editArgs: EditRenderArgs): number {
 	const input = editArgs.input ?? editArgs._input;
@@ -772,27 +808,72 @@ function editFactsInputLength(editArgs: EditRenderArgs): number {
 	return Array.isArray(editArgs.edits) ? editArgs.edits.length : 0;
 }
 
+/**
+ * Raw streamed payload of a mid-stream `input` edit, or undefined when the
+ * args are final (no `__partialJson`) or carry no `input` string — only the
+ * `input` payloads pay the expensive whole-payload inspect per frame.
+ */
+function streamedInputPayload(editArgs: EditRenderArgs): string | undefined {
+	if (typeof (editArgs.input ?? editArgs._input) !== "string") return undefined;
+	const payload = editArgs.__partialJson;
+	return typeof payload === "string" ? payload : undefined;
+}
+
+/**
+ * Whether a fresh streamed frame continues the payload `cached` was derived
+ * from within the growth gate. Exact: the cached payload must be a verbatim
+ * prefix of the new one, so a rewind or another call's payload never reuses.
+ */
+function continuesCachedPayload(cached: EditFactsCacheEntry, editArgs: EditRenderArgs): boolean {
+	const base = cached.streamedPayload;
+	if (base === undefined) return false;
+	const payload = streamedInputPayload(editArgs);
+	if (payload === undefined || payload.length < base.length) return false;
+	if (payload.length - base.length >= EDIT_FACTS_MIN_GROWTH) return false;
+	if (
+		editArgs.file_path !== cached.filePath ||
+		editArgs.path !== cached.path ||
+		editArgs.rename !== cached.rename ||
+		editArgs.op !== cached.op ||
+		editArgs.edits !== cached.edits
+	) {
+		return false;
+	}
+	return payload.startsWith(base);
+}
+
 function resolveEditCallFacts(
 	editArgs: EditRenderArgs,
 	isPartial: boolean,
 	editMode: EditMode | undefined,
 ): EditCallFacts {
 	const cached = lastFactsCache;
-	if (
-		cached !== undefined &&
-		cached.editArgs === editArgs &&
-		cached.isPartial === isPartial &&
-		cached.editMode === editMode
-	) {
-		const length = editFactsInputLength(editArgs);
-		// Same args object, still growing gradually: reuse. A rewind
-		// (shorter), a jump past the gate, or the final frame recomputes.
-		if (isPartial && length >= cached.length && length - cached.length < EDIT_FACTS_MIN_GROWTH) {
+	if (cached !== undefined && isPartial && cached.isPartial && cached.editMode === editMode) {
+		if (cached.editArgs === editArgs) {
+			const length = editFactsInputLength(editArgs);
+			// Same args object, still growing gradually: reuse. A rewind
+			// (shorter), a jump past the gate, or the final frame recomputes.
+			if (length >= cached.length && length - cached.length < EDIT_FACTS_MIN_GROWTH) {
+				return cached.facts;
+			}
+		} else if (continuesCachedPayload(cached, editArgs)) {
 			return cached.facts;
 		}
 	}
 	const facts = resolveEditCallFactsUncached(editArgs, isPartial, editMode);
-	lastFactsCache = { editArgs, isPartial, editMode, length: editFactsInputLength(editArgs), facts };
+	lastFactsCache = {
+		editArgs,
+		isPartial,
+		editMode,
+		length: editFactsInputLength(editArgs),
+		streamedPayload: streamedInputPayload(editArgs),
+		filePath: editArgs.file_path,
+		path: editArgs.path,
+		rename: editArgs.rename,
+		op: editArgs.op,
+		edits: editArgs.edits,
+		facts,
+	};
 	return facts;
 }
 

package/src/tools/streaming-output.ts

@@ -718,6 +718,12 @@ const MAX_PENDING = 10;
 export class TailBuffer {
 	#pending: string[] = [];
 	#pos = 0; // byte count of the currently-held tail (after trims)
+	// `#pending[0]` and its byte count. Clean = well-formed and `#headBytes` is its exact
+	// UTF-8 length (a head compacted from chunks that split a surrogate pair is neither).
+	#headBytes = 0;
+	#headClean = true;
+	// Every chunk after `#pending[0]` is well-formed (no lone surrogates).
+	#restWellFormed = true;
 
 	constructor(readonly maxBytes: number) {}
 
@@ -726,8 +732,7 @@ export class TailBuffer {
 
 		const max = this.maxBytes;
 		if (max === 0) {
-			this.#pending.length = 0;
-			this.#pos = 0;
+			this.#setHead("", 0, true);
 			return;
 		}
 
@@ -736,19 +741,17 @@ export class TailBuffer {
 		// If the incoming chunk alone is >= budget, it fully dominates the tail.
 		if (n >= max) {
 			const { text: t, bytes } = truncateTailBytes(text, max);
-			this.#pending[0] = t;
-			this.#pending.length = 1;
-			this.#pos = bytes;
+			// A chunk of exactly `max` bytes comes back verbatim, lone surrogates included.
+			this.#setHead(t, bytes, t.isWellFormed());
 			return;
 		}
 
-		this.#pos += n;
-
 		if (this.#pending.length === 0) {
-			this.#pending[0] = text;
-			this.#pending.length = 1;
+			this.#setHead(text, n, text.isWellFormed());
 		} else {
+			this.#pos += n;
 			this.#pending.push(text);
+			if (this.#restWellFormed && !text.isWellFormed()) this.#restWellFormed = false;
 			if (this.#pending.length > MAX_PENDING) this.#compact();
 		}
 
@@ -770,9 +773,22 @@ export class TailBuffer {
 
 	// -- private ---------------------------------------------------------------
 
+	/** Replace the whole buffer with a single chunk. */
+	#setHead(text: string, bytes: number, clean: boolean): void {
+		this.#pending[0] = text;
+		this.#pending.length = 1;
+		this.#pos = bytes;
+		this.#headBytes = bytes;
+		this.#headClean = clean;
+		this.#restWellFormed = true;
+	}
+
 	#compact(): void {
 		this.#pending[0] = this.#pending.join("");
 		this.#pending.length = 1;
+		this.#headBytes = this.#pos;
+		this.#headClean = this.#headClean && this.#restWellFormed;
+		this.#restWellFormed = true;
 	}
 
 	#flush(): string {
@@ -783,17 +799,64 @@ export class TailBuffer {
 
 	#trimTo(max: number): void {
 		if (max === 0) {
-			this.#pending.length = 0;
-			this.#pos = 0;
+			this.#setHead("", 0, true);
 			return;
 		}
 		if (this.#pos <= max) return;
 
-		const joined = this.#flush();
-		const { text, bytes } = truncateTailBytes(joined, max);
-		this.#pos = bytes;
-		this.#pending[0] = text;
-		this.#pending.length = 1;
+		// Steady state (one `text()` per appended chunk): the overflow lies inside the
+		// already-trimmed head, so only the head's front is cut and the chunks after it
+		// are kept verbatim instead of re-encoding the whole window. Those chunks must be
+		// well-formed: the full path round-trips them through UTF-8, which rewrites lone
+		// surrogates (and heals pairs split across chunk boundaries).
+		const restBytes = this.#pos - this.#headBytes;
+		if (restBytes < max && this.#restWellFormed) {
+			const head = this.#pending[0];
+			const keep = max - restBytes;
+			const drop = this.#headBytes - keep;
+			if (head.length === this.#headBytes) {
+				// All-ASCII head: byte offsets are char offsets and every byte is a boundary.
+				this.#pending[0] = head.slice(drop);
+				this.#headBytes = keep;
+			} else if (this.#headClean && drop <= keep) {
+				// Walk code points to the first boundary at or after `drop` bytes.
+				let dropped = 0;
+				let index = 0;
+				while (dropped < drop) {
+					const code = head.charCodeAt(index);
+					if (code < 0x80) {
+						dropped += 1;
+						index += 1;
+					} else if (code < 0x800) {
+						dropped += 2;
+						index += 1;
+					} else if (code >= 0xd800 && code <= 0xdbff) {
+						// Well-formed, so a high surrogate always starts a pair.
+						dropped += 4;
+						index += 2;
+					} else {
+						dropped += 3;
+						index += 1;
+					}
+				}
+				this.#pending[0] = head.slice(index);
+				this.#headBytes -= dropped;
+			} else {
+				// A head that already fits comes back verbatim, lone surrogates included.
+				const { text, bytes } = truncateTailBytes(head, keep);
+				this.#pending[0] = text;
+				this.#headBytes = bytes;
+				this.#headClean = text.isWellFormed();
+				this.#pos = this.#headBytes + restBytes;
+				return;
+			}
+			this.#headClean = true;
+			this.#pos = this.#headBytes + restBytes;
+			return;
+		}
+
+		const { text, bytes } = truncateTailBytes(this.#flush(), max);
+		this.#setHead(text, bytes, text.isWellFormed());
 	}
 }
 

package/src/tools/web-search-types.ts

@@ -0,0 +1,99 @@
+/**
+ * Web search response types shared by the coding agent's search providers and
+ * the transcript renderer in {@link ./web-search}. Render-free, so provider code
+ * can import it without loading UI components.
+ */
+
+/**
+ * Display label for every search implementation: `web/*` engines and the
+ * chat-model groundings. Keys are the ids providers report in
+ * {@link SearchResponse.provider} and search errors.
+ */
+export const SEARCH_PROVIDER_LABELS = {
+	parallel: "Parallel",
+	perplexity: "Perplexity",
+	gemini: "Gemini",
+	anthropic: "Anthropic",
+	codex: "OpenAI Codex",
+	openai: "OpenAI API",
+	xai: "xAI",
+	openrouter: "OpenRouter",
+	zai: "Z.AI",
+	exa: "Exa",
+	tinyfish: "TinyFish",
+	jina: "Jina",
+	kagi: "Kagi",
+	tavily: "Tavily",
+	firecrawl: "Firecrawl",
+	brave: "Brave",
+	kimi: "Kimi",
+	synthetic: "Synthetic",
+	ollama: "Ollama",
+	searxng: "SearXNG",
+	startpage: "Startpage",
+	duckduckgo: "DuckDuckGo",
+	ecosia: "Ecosia",
+	google: "Google",
+	mojeek: "Mojeek",
+	public: "Public Web",
+} as const;
+
+/** Id of a search implementation; see {@link SEARCH_PROVIDER_LABELS}. */
+export type SearchProviderId = keyof typeof SEARCH_PROVIDER_LABELS;
+
+/** Label for a provider id; ids from older transcripts fall back to the raw id. */
+export function getSearchProviderLabel(id: SearchProviderId): string {
+	return SEARCH_PROVIDER_LABELS[id] ?? id;
+}
+
+/** Source returned by search (all providers) */
+export interface SearchSource {
+	title: string;
+	url: string;
+	snippet?: string;
+	/** ISO date string or relative ("2d ago") */
+	publishedDate?: string;
+	/** Age in seconds for consistent formatting */
+	ageSeconds?: number;
+	author?: string;
+}
+
+/** Citation with text reference (LLM-mediated providers) */
+export interface SearchCitation {
+	url: string;
+	title: string;
+	citedText?: string;
+}
+
+/** Usage metrics */
+export interface SearchUsage {
+	inputTokens?: number;
+	outputTokens?: number;
+	/** Anthropic: number of web search requests made */
+	searchRequests?: number;
+	/** Perplexity: combined token count */
+	totalTokens?: number;
+}
+
+/** Unified response across providers */
+export interface SearchResponse {
+	provider: SearchProviderId | "none";
+	/** Synthesized answer text (LLM-mediated providers) */
+	answer?: string;
+	/** Search result sources */
+	sources: SearchSource[];
+	/** Text citations with context */
+	citations?: SearchCitation[];
+	/** Intermediate search queries (anthropic) */
+	searchQueries?: string[];
+	/** Follow-up question suggestions (provider-dependent) */
+	relatedQuestions?: string[];
+	/** Token usage metrics */
+	usage?: SearchUsage;
+	/** Model used */
+	model?: string;
+	/** Request ID for debugging */
+	requestId?: string;
+	/** Authentication mode used by the provider (e.g. oauth, api-key) */
+	authMode?: string;
+}