@oh-my-pi/pi-tui 18.4.2 → 18.4.4

package/src/tools/eval.ts

@@ -1,7 +1,18 @@
 import type { Component } from "../index";
 import { Markdown, Text } from "../index";
 import { sanitizeText } from "@oh-my-pi/pi-utils";
-import type { RenderResultOptions, ToolRenderer } from "./renderer";
+import type {
+	NativeToolHead,
+	NativeToolView,
+	RenderResultContextOptions,
+	RenderResultOptions,
+	ToolRenderer,
+} from "./renderer";
+import type { TspSpan } from "@oh-my-pi/pi-wire";
+import { ansi, code as codeNode, compact, keyed, md, node, span, text } from "../native/describe";
+import type { NativeChild, NativeNode } from "../native/node";
+import { plainText } from "../native/spans";
+import { footnoteText, resultText } from "./native-view";
 import { renderAgentTreeRow } from "./agent-tree";
 import { truncateToVisualLines } from "../chrome/visual-truncate";
 import { getMarkdownTheme, type Theme } from "../theme/theme";
@@ -15,6 +26,7 @@ import {
 	JSON_TREE_MAX_LINES_EXPANDED,
 	JSON_TREE_SCALAR_LEN_COLLAPSED,
 	JSON_TREE_SCALAR_LEN_EXPANDED,
+	describeJsonTree,
 	renderJsonTreeLines,
 } from "./json-tree";
 import { formatStyledTruncationWarning, stripOutputNotice } from "./output-meta";
@@ -546,6 +558,161 @@ function formatCellOutputLines(
 	return { lines: formatted.lines, hiddenCount: formatted.hiddenCount };
 }
 
+/** Plain one-line summary of a status event: op plus its scalar fields. */
+function describeStatusEvent(event: EvalStatusEvent): NativeNode {
+	const spans: TspSpan[] = [span(event.op, "accent")];
+	for (const key in event) {
+		if (key === "op" || key === "resolvedThinkingLevel") continue;
+		const value = event[key];
+		if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+			spans.push(span(` ${key}=`, "muted"), span(sanitizeText(String(value))));
+		}
+	}
+	return text(spans, { truncate: "end", role: "omp.tool.eval.status" });
+}
+
+/**
+ * The eval head (§7.3): a single cell's title as the verb (else "Eval"; with
+ * several cells each section carries its own title), a badge per language in
+ * first-use order, a `background` badge for a backgrounded job, and the cell
+ * count when there are several.
+ */
+function evalToolHead(
+	title: string | undefined,
+	languages: readonly EvalLanguage[],
+	cellCount: number,
+	details?: EvalToolDetails,
+): NativeToolHead {
+	const badges: { text: string; title?: string }[] = [...new Set(languages)].map(language => ({ text: language }));
+	if (details?.async?.state === "running") {
+		badges.push({ text: "background", title: `Backgrounded as job ${details.async.jobId}` });
+	}
+	return {
+		title: (cellCount > 1 ? "" : plainText(title ?? "").trim()) || "Eval",
+		badges: badges.length > 0 ? badges : undefined,
+		meta: cellCount > 1 ? [`${cellCount} cells`] : undefined,
+	};
+}
+
+/** Box-drawing `console.table` output split out of plain text: `text` runs and parsed tables, in order. */
+type EvalOutputPart =
+	| { readonly kind: "text"; readonly text: string }
+	| { readonly kind: "table"; readonly head: readonly string[]; readonly rows: readonly string[][] };
+
+/** The cells of a `│ a │ b │` row, trimmed; undefined when the line is not a table row. */
+function tableRowCells(line: string): string[] | undefined {
+	const plain = plainText(line).trim();
+	if (plain.length < 2 || !plain.startsWith("│") || !plain.endsWith("│")) return undefined;
+	return plain
+		.slice(1, -1)
+		.split("│")
+		.map(cell => cell.trim());
+}
+
+/**
+ * Split `console.table` blocks (`┌…┐` header `├…┤` rows `└…┘`, as Node/Bun
+ * print them) out of cell output so they render as a `table`; anything that
+ * does not parse as one stays text.
+ */
+function splitConsoleTables(output: string): EvalOutputPart[] {
+	const lines = output.split("\n");
+	const parts: EvalOutputPart[] = [];
+	let textStart = 0;
+	const flushText = (end: number): void => {
+		const chunk = lines
+			.slice(textStart, end)
+			.join("\n")
+			.replace(/^\n+|\s+$/g, "");
+		if (chunk.length > 0) parts.push({ kind: "text", text: chunk });
+	};
+	for (let i = 0; i < lines.length; i++) {
+		if (!plainText(lines[i]!).trimStart().startsWith("┌")) continue;
+		const head = tableRowCells(lines[i + 1] ?? "");
+		if (
+			!head ||
+			!plainText(lines[i + 2] ?? "")
+				.trimStart()
+				.startsWith("├")
+		)
+			continue;
+		const rows: string[][] = [];
+		let end = i + 3;
+		for (; end < lines.length; end++) {
+			const cells = tableRowCells(lines[end]!);
+			if (!cells) break;
+			rows.push(cells);
+		}
+		if (
+			!plainText(lines[end] ?? "")
+				.trimStart()
+				.startsWith("└")
+		)
+			continue;
+		if (rows.some(row => row.length !== head.length)) continue;
+		flushText(i);
+		parts.push({ kind: "table", head, rows });
+		i = end;
+		textStart = end + 1;
+	}
+	flushText(lines.length);
+	return parts;
+}
+
+/** One cell's output: markdown, else terminal text with any `console.table` blocks as tables. */
+function evalOutputNodes(output: string, markdown: boolean, running: boolean, error: boolean): NativeNode[] {
+	if (output.trim().length === 0) return [];
+	if (markdown && !error) return [md(output)];
+	const tone = error ? "error" : undefined;
+	return splitConsoleTables(output).map(part =>
+		part.kind === "text"
+			? ansi(part.text, { follow: running, tone, role: "omp.tool.eval.output" })
+			: node("table", {
+					// Node's index column header is noise in a real table.
+					cols: part.head.map((head, i) => ({ id: `c${i}`, head: head === "(index)" ? "" : head })),
+					rows: part.rows.map((cells, r) => ({
+						id: `r${r}`,
+						cells: Object.fromEntries(cells.map((cell, i) => [`c${i}`, cell])),
+					})),
+					role: "omp.tool.eval.table",
+				}),
+	);
+}
+
+/** Inputs of one eval cell section. */
+interface EvalCellSection {
+	readonly language: EvalLanguage;
+	readonly code: string;
+	readonly title?: string;
+	readonly status?: EvalCellResult["status"];
+	readonly durationMs?: number;
+	readonly output?: readonly NativeChild[];
+}
+
+/**
+ * One cell as a borderless section: its highlighted code (no line numbers),
+ * then its output. Only multi-cell calls caption the section (`2/3 title ·
+ * 1.2s`); a single cell's title is the tool head, never repeated.
+ */
+function evalCellSection(cell: EvalCellSection, index: number, total: number): NativeNode {
+	let head: TspSpan[] | undefined;
+	if (total > 1) {
+		head = [span(`${index + 1}/${total}`, "muted")];
+		const title = plainText(cell.title ?? "").trim();
+		if (title) head.push(span(` ${title}`, "toolTitle"));
+		if (cell.status === "error") head.push(span(" · failed", "error"));
+		if (cell.durationMs !== undefined) head.push(span(` · ${(cell.durationMs / 1000).toFixed(2)}s`, "muted"));
+	}
+	return node(
+		"section",
+		{ head, role: "omp.tool.eval.cell", tone: cell.status === "error" ? "error" : undefined },
+		[
+			keyed(codeNode(cell.code, { lang: languageForHighlighter(cell.language), numbers: false }), "code"),
+			...(cell.output ?? []),
+		],
+		`cell-${index}`,
+	);
+}
+
 /** Render eval code cells, structured display output, and progress events. */
 export const evalToolRenderer = {
 	animatedPendingPreview: true,
@@ -845,6 +1012,95 @@ export const evalToolRenderer = {
 		};
 	},
 
+	describeCall(args: EvalRenderArgs, _options: RenderResultOptions): NativeToolView {
+		const cells = getRenderCells(args);
+		return {
+			tool: evalToolHead(
+				cells[0]?.title,
+				cells.map(cell => cell.language),
+				cells.length,
+			),
+			body: cells.map((cell, i) => evalCellSection(cell, i, cells.length)),
+			preview: { lines: EVAL_DEFAULT_PREVIEW_LINES },
+		};
+	},
+
+	describeResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: EvalToolDetails; isError?: boolean },
+		options: RenderResultContextOptions & { renderContext?: EvalRenderContext },
+		args?: EvalRenderArgs,
+	): NativeToolView {
+		const details = result.details;
+		const isPartial = options.isPartial === true;
+		const previewLines = options.renderContext?.previewLines ?? EVAL_DEFAULT_PREVIEW_LINES;
+		const jsonNodes = (details?.jsonOutputs ?? []).map((value, index) =>
+			keyed(describeJsonTree(value, { hiddenRootKeys: [] }), `display-${index}`),
+		);
+		// A notice and truncation go to one quiet final line (a background job is a head badge).
+		const footer = footnoteText(compact([details?.notice]), details?.meta);
+		const cellResults = details?.cells;
+		let cells: NativeNode[];
+		let head: NativeToolHead;
+		if (cellResults && cellResults.length > 0) {
+			const languages = cellResults.map(cell => cell.language ?? details?.language ?? "python");
+			head = evalToolHead(cellResults[0]!.title, languages, cellResults.length, details);
+			cells = cellResults.map((cell, i) => {
+				const language = languages[i]!;
+				return evalCellSection(
+					{
+						language,
+						code: formatEvalCodeForDisplay(cell.code, language),
+						title: cell.title,
+						status: cell.status,
+						durationMs: cell.durationMs,
+						output: [
+							...evalOutputNodes(
+								cell.output,
+								cell.hasMarkdown === true,
+								cell.status === "running",
+								cell.status === "error",
+							),
+							...(cell.statusEvents ?? []).map(describeStatusEvent),
+						],
+					},
+					i,
+					cellResults.length,
+				);
+			});
+		} else {
+			// No per-cell results (older details): the call's cells, with the whole output under the last.
+			const argCells = getRenderCells(args);
+			const languages = details?.languages ?? (details?.language ? [details.language] : []);
+			head = evalToolHead(
+				argCells[0]?.title,
+				argCells.length > 0 ? argCells.map(cell => cell.language) : languages,
+				argCells.length,
+				details,
+			);
+			const rawOutput = options.renderContext?.output ?? resultText(result).trimEnd();
+			const output = [
+				...evalOutputNodes(
+					stripOutputNotice(rawOutput, details?.meta).trimEnd(),
+					false,
+					isPartial,
+					result.isError === true,
+				),
+				...(details?.statusEvents ?? []).map(describeStatusEvent),
+			];
+			cells =
+				argCells.length > 0
+					? argCells.map((cell, i) =>
+							evalCellSection(i === argCells.length - 1 ? { ...cell, output } : cell, i, argCells.length),
+						)
+					: output;
+		}
+		return {
+			tool: head,
+			body: compact<NativeChild>([...cells, ...jsonNodes, footer]),
+			preview: { lines: previewLines },
+		};
+	},
+
 	mergeCallAndResult: true,
 	inline: true,
 } satisfies ToolRenderer<EvalRenderArgs, EvalToolDetails>;

package/src/tools/fetch.ts

@@ -1,15 +1,25 @@
 import { isReadableUrlPath, readSelectorRangeStart } from "./read";
 import type { Component } from "../tui";
 import { Text } from "../components/text";
-import type { RenderResultOptions } from "./renderer";
+import type { NativeToolHead, NativeToolView, RenderResultOptions } from "./renderer";
+import type { TspSpan } from "@oh-my-pi/pi-wire";
+import { compact, span, text } from "../native/describe";
+import { plainText } from "../native/spans";
+import { errorText, noteText, resultText, statsText } from "./native-view";
 import { type Theme, theme } from "../theme/theme";
 import type { OutputMeta } from "./output-meta";
 import { truncate } from "@oh-my-pi/pi-utils";
 import { renderStatusLine, urlHyperlink } from "../render";
 import { framedToolCard } from "../render/tool-card";
-import { formatExpandHint, getDomain, sanitizeDisplayLines } from "../render/render-utils";
+import {
+	formatExpandHint,
+	formatMoreItems,
+	getDomain,
+	PREVIEW_LIMITS,
+	sanitizeDisplayLines,
+} from "../render/render-utils";
 import { applyListLimit } from "./list-limit";
-import { formatStyledArtifactReference } from "./output-meta";
+import { formatFullOutputReference, formatStyledArtifactReference } from "./output-meta";
 
 /** Display metadata for fetch tool results. */
 export interface ReadUrlToolDetails {
@@ -98,6 +108,15 @@ function formatReadUrlDescription(input: string): string {
 	return urlHyperlink(target, label);
 }
 
+/** Link span for a URL read target: `domain /path`, linked to the resolved target. */
+function readUrlLinkSpan(input: string): TspSpan {
+	const target = readUrlLinkTarget(input);
+	const displayUrl = target.match(/^www\./i) ? `https://${target}` : target;
+	const urlPath = displayUrl.replace(/^https?:\/\/[^/]+/, "");
+	const label = `${getDomain(displayUrl)}${urlPath ? ` ${urlPath}` : ""}`.trim() || target;
+	return span(plainText(label), "link", { href: target });
+}
+
 function formatReadUrlMetadataValue(url: string, uiTheme: Theme): string {
 	return urlHyperlink(url, uiTheme.fg("mdLinkUrl", url));
 }
@@ -116,6 +135,86 @@ export function renderReadUrlCall(
 	return new Text(text, 0, 0);
 }
 
+/** Native head of a URL read: `Read` plus the linked, one-line URL. */
+function readUrlHead(input: string, meta: readonly string[] = []): NativeToolHead {
+	const link = input ? readUrlLinkSpan(input) : undefined;
+	return {
+		title: "Read",
+		target: link?.t || undefined,
+		targetKind: "text",
+		href: link?.href,
+		meta: meta.length > 0 ? meta : undefined,
+	};
+}
+
+/** TSP call view of a URL read: the head only, inline while pending. */
+export function describeReadUrlCall(args: { path?: string; url?: string; raw?: boolean }): NativeToolView {
+	return { tool: readUrlHead(args.path ?? args.url ?? "", args.raw ? ["raw"] : []), inline: true };
+}
+
+/** TSP result view of a URL read: a bounded content preview over one quiet stats line. */
+export function describeReadUrlResult(result: {
+	content: Array<{ type: string; text?: string }>;
+	details?: ReadUrlToolDetails;
+	isError?: boolean;
+}): NativeToolView {
+	const details = result.details;
+	if (result.isError || !details) {
+		const urlText = details?.finalUrl ?? details?.url ?? "";
+		const message = plainText(resultText(result) || "No response data").replace(/^Error:\s*/, "");
+		return {
+			tool: readUrlHead(urlText),
+			tone: "error",
+			body: [errorText(message.trim() || "Read failed")],
+		};
+	}
+
+	const truncation = details.meta?.truncation;
+	const truncated = Boolean(details.truncated || truncation);
+	const contentText = result.content[0]?.text ?? "";
+	const contentBody = contentText.includes("---\n\n")
+		? contentText.split("---\n\n").slice(1).join("---\n\n")
+		: contentText;
+	const contentLines = contentBody.split("\n").filter(l => l.trim());
+	const shown = contentLines.slice(0, PREVIEW_LIMITS.EXPANDED_LINES);
+	const hidden = contentLines.length - shown.length;
+	const redirected = details.url !== details.finalUrl;
+
+	const stats = statsText(
+		[
+			plainText(details.contentType || "unknown"),
+			details.method ? plainText(details.method) : "",
+			`${contentLines.length} line${contentLines.length === 1 ? "" : "s"}`,
+			`${contentBody.trim().length} chars`,
+			hidden > 0 ? formatMoreItems(hidden, "line") : "",
+			...details.notes.map(note => plainText(note)),
+		].filter(Boolean),
+	);
+	return {
+		tool: readUrlHead(details.finalUrl, redirected ? [`from ${plainText(getDomain(details.url))}`] : []),
+		tone: truncated ? "warning" : undefined,
+		body: compact([
+			shown.length > 0
+				? text([span(plainText(shown.map(line => line.trimEnd()).join("\n")), "dim")], { wrap: "word" })
+				: noteText("(no content)"),
+			stats,
+			truncated
+				? text(
+						[
+							span(
+								truncation?.artifactId
+									? `Output truncated · ${formatFullOutputReference(truncation.artifactId)}`
+									: "Output truncated",
+								"warning",
+							),
+						],
+						{ wrap: "word", role: "omp.tool.notice" },
+					)
+				: undefined,
+		]),
+	};
+}
+
 /** Render URL read result with tree-based layout */
 export function renderReadUrlResult(
 	result: { content: Array<{ type: string; text?: string }>; details?: ReadUrlToolDetails; isError?: boolean },

package/src/tools/find.ts

@@ -27,7 +27,12 @@ import {
 import type { Theme, ThemeColor } from "../theme/theme";
 import type { Component } from "../tui";
 import type { OutputMeta } from "./output-meta";
-import type { RenderResultOptions, ToolRenderer } from "./renderer";
+import type { NativeToolHead, NativeToolView, RenderResultOptions, ToolRenderer } from "./renderer";
+import type { TspTone } from "@oh-my-pi/pi-wire";
+import { code, col, compact, keyed, node, span, text } from "../native/describe";
+import type { NativeChild, NativeNode } from "../native/node";
+import { getLanguageFromPath } from "../lang-from-path";
+import { fileHref, fileRow, inlineErrorView } from "./native-view";
 import { splitUrlScheme } from "./url-scheme-host";
 
 /** A verified line range with its yes-probability and a one-line preview. */
@@ -148,6 +153,49 @@ function renderHit(hit: FindHit, rangeLimit: number, cwd: string | undefined, th
 	return lines;
 }
 
+function scoreTone(p: number): TspTone {
+	return p >= STRONG ? "success" : p >= PLAUSIBLE ? "warning" : "muted";
+}
+
+/**
+ * One hit (§7.3 find): a 22px row of the score bar, the path and `12 lines
+ * judged`, then its strongest ranges as numbered `code` (no path header).
+ */
+function describeHit(hit: FindHit, rangeLimit: number, cwd: string | undefined): NativeNode {
+	const ranges = [...hit.ranges].sort((a, b) => b.p - a.p || a.start - b.start).slice(0, rangeLimit);
+	const tone = scoreTone(hit.contentScore);
+	const score = hit.contentScore.toFixed(2);
+	const isUrlHit = splitUrlScheme(hit.rel) !== undefined;
+	const head = fileRow(hit.rel, {
+		lead: node("progress", { value: hit.contentScore, tone, title: `score ${score}`, max: { w: 40 } }),
+		detail: [
+			span(score, tone),
+			span(
+				hit.truncated ? ` · ${hit.linesSeen} lines judged, partial` : ` · ${hit.linesSeen} lines judged`,
+				"muted",
+			),
+		],
+		href: isUrlHit || cwd === undefined ? undefined : fileHref(path.join(cwd, hit.rel)),
+		key: "hit",
+	});
+	const lang = getLanguageFromPath(hit.rel);
+	const snippets = ranges.map(range =>
+		keyed(
+			code(range.snippet.trimEnd(), { lang, start: range.start, numbers: true, title: range.p.toFixed(2) }),
+			`${range.start}-${range.end}`,
+		),
+	);
+	return keyed(col([head, ...snippets], { gap: "xs", role: "omp.tool.find.hit" }), hit.rel);
+}
+
+/** Native find head: the query, then `meta` (result counts), or the call's keywords and scope. */
+function findNativeHead(
+	query: string | undefined,
+	meta: readonly NonNullable<NativeToolHead["meta"]>[number][],
+): NativeToolHead {
+	return { title: "Find", target: query ?? "", targetKind: "query", meta };
+}
+
 function quoteQuery(query: string | undefined): string | undefined {
 	return query === undefined ? undefined : `"${query}"`;
 }
@@ -263,6 +311,84 @@ export const findToolRenderer = {
 			{ paddingX: 1 },
 		);
 	},
+	describeCall(args: FindRenderArgs): NativeToolView {
+		const keywords = args.grep_keywords ?? [];
+		return {
+			tool: findNativeHead(
+				args.query,
+				compact([keywords.length > 0 && keywords.join(" "), args.path && `in ${args.path}`]),
+			),
+			inline: true,
+		};
+	},
+
+	/**
+	 * Inline (§7.3 find): `Find “query”  2 hits · 8 files`, then per hit its
+	 * score bar, path and coverage over the strongest snippets. The search
+	 * accounting (τ, tokens, cost, time) is the footnote's tooltip.
+	 */
+	describeResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: FindToolDetails; isError?: boolean },
+		options: RenderResultOptions,
+		args?: FindRenderArgs,
+	): NativeToolView {
+		const details = result.details;
+		const progress = result.content?.find(c => c.type === "text")?.text ?? "";
+		const query = args?.query ?? details?.query;
+		if (result.isError) return inlineErrorView(findNativeHead(query, []), progress || "Unknown error");
+		if (options.isPartial || details === undefined) {
+			return {
+				tool: findNativeHead(query, progress ? [[span(progress, "muted", { fx: "shimmer" })]] : []),
+				inline: true,
+			};
+		}
+		const { hits, stats, threshold } = details;
+		const scope = details.scopePath === undefined ? undefined : `in ${details.scopePath}`;
+		const failed = stats.errors > 0 ? [span(`${stats.errors} failed`, "warning")] : undefined;
+		const accounting = [
+			`${stats.filesRead} files read`,
+			`τ ${threshold.toFixed(2)}`,
+			`${formatNumber(stats.inputTokens)} tokens`,
+			`$${stats.cost.toFixed(4)}`,
+			formatDuration(details.elapsedMs),
+		].join(" · ");
+		const failures = stats.failures.map((failure, i) =>
+			keyed(text([span(failure, "warning")], { wrap: "word", role: "omp.tool.notice" }), `fail${i}`),
+		);
+		if (hits.length === 0) {
+			return {
+				tool: findNativeHead(query, compact(["0 hits", scope, failed])),
+				tone: "warning",
+				inline: true,
+				body: failures.length > 0 ? failures : undefined,
+			};
+		}
+		const shown = options.expanded ? hits : hits.slice(0, COLLAPSED_HITS);
+		const rangeLimit = options.expanded ? RANGES_EXPANDED : RANGES_COLLAPSED;
+		const hidden = hits.length - shown.length;
+		const footParts = compact([
+			hidden > 0 && formatCount("more hit", hidden),
+			`keywords: ${details.keywords.join(", ")}`,
+		]);
+		// One quiet last line; the accounting ANSI prints in the head rides its tooltip.
+		const foot = keyed(
+			text([span(footParts.join(" · "), "muted")], { wrap: "word", role: "omp.tool.stats", title: accounting }),
+			"foot",
+		);
+		return {
+			tool: findNativeHead(
+				query,
+				compact([`${formatCount("hit", hits.length)} · ${formatCount("file", stats.filesRead)}`, scope, failed]),
+			),
+			inline: true,
+			body: compact<NativeChild>([
+				...shown.map(hit => describeHit(hit, rangeLimit, details.cwd)),
+				...failures,
+				foot,
+			]),
+			preview: { lines: PREVIEW_LIMITS.EXPANDED_LINES },
+		};
+	},
 	mergeCallAndResult: true,
 	animatedPendingPreview: true,
 	animatedPartialResult: true,