@oh-my-pi/pi-tui 18.12.0 → 18.12.2

package/src/tools/ast-grep.ts

@@ -14,7 +14,6 @@ import {
 	toPathList,
 } from "../render/render-utils";
 import { classifyGroupedLines, describeGroupedOutput, groupLineIndicesByBlank } from "./grouped-file-output";
-import { getLanguageFromPath } from "../lang-from-path";
 import { code, compact, node, span } from "../native/describe";
 import type { NativeChild } from "../native/node";
 import { errorText, noteText, resultText, toolHead } from "./native-view";
@@ -279,7 +278,7 @@ export const astGrepToolRenderer = {
 		return {
 			head,
 			body: compact<NativeChild>([
-				...describeGroupedOutput(kept, { lang: getLanguageFromPath }),
+				...describeGroupedOutput(kept),
 				limitReached && noteText("limit reached; narrow path or use skip", "warning"),
 				parseNote,
 			]),

package/src/tools/edit.ts

@@ -1222,7 +1222,7 @@ export const editToolRenderer = {
 				diffText = args.previewDiff ?? args.diff ?? "";
 				body.push(editDiff(diffText, rawPath));
 			} else if (args.diff || args.newText || args.patch) {
-				body.push(code(args.diff ?? args.newText ?? args.patch ?? "", { lang: getLanguageFromPath(rawPath) }));
+				body.push(code(args.diff ?? args.newText ?? args.patch ?? "", { path: rawPath || undefined }));
 			} else if (renderContext?.editDiffPreview) {
 				const preview = renderContext.editDiffPreview;
 				if ("error" in preview && preview.error) body.push(errorText(preview.error));
@@ -1362,9 +1362,9 @@ function editToolHead(facts: EditHeadFacts): NativeToolHead {
 	};
 }
 
-/** A file's diff: hunks highlighted by the path's language, no path header (the head or section names the file). */
+/** A file's diff: Tern highlights the hunks by the file's grammar and draws no path header (the head or section names the file). */
 function editDiff(diffText: string, filePath: string): NativeNode {
-	return nativeDiff(diffText, { lang: filePath ? getLanguageFromPath(filePath) : undefined });
+	return nativeDiff(diffText, { path: filePath || undefined });
 }
 
 /** One file's edit result for native views: head facts plus its body (diff or error, then diagnostics). */

package/src/tools/eval.ts

@@ -36,7 +36,6 @@ import {
 } from "./json-tree";
 import { formatStyledTruncationWarning, stripOutputNotice } from "./output-meta";
 import { splitPathAndSel } from "./read";
-import { getLanguageFromPath } from "../lang-from-path";
 import {
 	DEFAULT_TERMINAL_PREVIEW_LINES,
 	PREVIEW_LIMITS,
@@ -65,31 +64,57 @@ export interface EvalStatusEvent {
 	[key: string]: unknown;
 }
 
+/** One column of a table view. */
+export interface EvalTableColumn {
+	head: string;
+	/** Numeric values: renderers right-align the column. */
+	numeric?: boolean;
+}
+
+/**
+ * A pretty rendering of something a cell printed, shown to the user in place
+ * of its text; the model only ever sees the text.
+ * - `table`: a data frame or `console.table`; leading index columns are plain
+ *   columns, and a truncated frame's elided rows/columns are `…` cells.
+ * - `json`: a structured value (dict/list, object/array) as a collapsible tree.
+ * - `markdown`: an object's Markdown representation.
+ */
+export type EvalView =
+	| { kind: "table"; columns: EvalTableColumn[]; rows: string[][] }
+	| { kind: "json"; value: unknown }
+	| { kind: "markdown"; text: string };
+
+/**
+ * A view and the exact printed text it stands for. Renderers locate `text` in
+ * the cell's `output` (entries in print order) and show the view there; an
+ * entry whose text is no longer in the output (truncated) is skipped.
+ */
+export interface EvalViewEntry {
+	text: string;
+	view: EvalView;
+}
+
 /** Per-cell execution result for transcript rendering. */
 export interface EvalCellResult {
 	index: number;
 	title?: string;
 	code: string;
 	language?: EvalLanguage;
+	/** What the model saw: the cell's printed text plus image notes. */
 	output: string;
-	/**
-	 * `output` without its `display[N]:` JSON sections, which renderers show
-	 * from `jsonOutputs` instead. Absent when the cell displayed no JSON.
-	 */
-	textOutput?: string;
+	/** Pretty views of spans of `output`, in print order. */
+	views?: EvalViewEntry[];
 	status: "pending" | "running" | "complete" | "error";
 	durationMs?: number;
 	exitCode?: number;
 	statusEvents?: EvalStatusEvent[];
 	/** Discrete events dropped from the front of `statusEvents` (see {@link recordStatusEvent}). */
 	statusEventsElided?: number;
-	hasMarkdown?: boolean;
 }
 
 /** Tool result detail object surfaced to the UI/transcript. */
 export interface EvalToolDetails {
 	cells?: EvalCellResult[];
-	jsonOutputs?: unknown[];
 	images?: ImageContent[];
 	statusEvents?: EvalStatusEvent[];
 	/** Discrete events dropped from the front of `statusEvents` (see {@link recordStatusEvent}). */
@@ -593,8 +618,7 @@ function formatCellOutputLines(
 	theme: Theme,
 	width: number,
 ): { lines: readonly string[]; hiddenCount: number } {
-	// JSON displays render once, as the `jsonOutputs` tree below the last cell.
-	const output = cell.textOutput ?? cell.output;
+	const output = cell.output;
 	if (!output) {
 		return { lines: [], hiddenCount: 0 };
 	}
@@ -607,23 +631,47 @@ function formatCellOutputLines(
 	// exact hidden-count row, so the pane marker stays off here.
 	const innerWidth = outputBlockContentWidth(width);
 
-	if (cell.hasMarkdown && cell.status !== "error") {
-		const md = new Markdown(output, 0, 0, getMarkdownTheme());
-		const allLines = md.render(innerWidth);
+	const isError = cell.status === "error";
+	const styleText = (line: string): string => theme.fg(isError ? "error" : "toolOutput", replaceTabs(line));
+	// A table's printed text is already a terminal table, aligned to the line it starts on: keep it as text.
+	const parts = splitEvalOutput(
+		output,
+		cell.views?.filter(entry => entry.view.kind !== "table"),
+	);
+	if (parts.some(part => part.kind === "view")) {
+		// Printed text keeps its place; json and markdown views replace theirs with a tree / rendered Markdown.
+		const treeDepth = expanded ? JSON_TREE_MAX_DEPTH_EXPANDED : JSON_TREE_MAX_DEPTH_COLLAPSED;
+		const treeLineCap = expanded ? JSON_TREE_MAX_LINES_EXPANDED : JSON_TREE_MAX_LINES_COLLAPSED;
+		const treeScalarLen = expanded ? JSON_TREE_SCALAR_LEN_EXPANDED : JSON_TREE_SCALAR_LEN_COLLAPSED;
+		const allLines: string[] = [];
+		for (const part of parts) {
+			if (part.kind === "text") {
+				for (const line of part.text.split("\n")) allLines.push(styleText(line));
+				continue;
+			}
+			const view = part.view;
+			if (view.kind === "json") {
+				const tree = renderJsonTreeLines(view.value, theme, treeDepth, treeLineCap, treeScalarLen);
+				allLines.push(...tree.lines);
+				if (tree.truncated) allLines.push(theme.fg("dim", "…"));
+			} else if (view.kind === "markdown") {
+				allLines.push(...new Markdown(view.text, 0, 0, getMarkdownTheme()).render(innerWidth));
+			}
+		}
 		const formatted = formatOutputPaneLines(
 			{
 				lines: allLines,
 				expanded,
 				collapsedMaxLines: previewLines,
 				edge: "tail",
+				visual: true,
+				width: innerWidth,
 				showHiddenMarker: false,
 			},
 			theme,
 		);
 		return { lines: formatted.lines, hiddenCount: formatted.hiddenCount };
 	}
-
-	const isError = cell.status === "error";
 	const formatted = formatOutputPaneLines(
 		{
 			lines: output.split("\n"),
@@ -632,7 +680,7 @@ function formatCellOutputLines(
 			edge: "tail",
 			visual: true,
 			width: innerWidth,
-			styleLine: line => theme.fg(isError ? "error" : "toolOutput", replaceTabs(line)),
+			styleLine: styleText,
 			showHiddenMarker: false,
 		},
 		theme,
@@ -664,13 +712,12 @@ function describeStatusEvent(event: EvalStatusEvent, expanded: boolean): NativeN
 	if (!preview) return line;
 	const head = cappedHeadLines(sanitizeDisplayLines(preview), PREVIEW_LIMITS.OUTPUT_EXPANDED).lines;
 	const path = eventString(event.path);
-	const lang = path ? getLanguageFromPath(splitPathAndSel(path).path) : undefined;
 	return node("col", { role: "omp.tool.eval.status.event", gap: "none" }, [
 		keyed(line, "line"),
 		keyed(
 			code(head.join("\n"), {
 				role: "omp.tool.eval.status.preview",
-				lang,
+				path: path ? splitPathAndSel(path).path : undefined,
 				wrap: false,
 				preview: { lines: PREVIEW_LIMITS.COLLAPSED_LINES },
 			}),
@@ -702,96 +749,79 @@ function evalToolHead(
 	};
 }
 
-/** 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());
-}
+/** One ordered piece of a cell's output: printed text, or a view shown in place of the text it matched. */
+export type EvalOutputPart = { kind: "text"; text: string } | { kind: "view"; view: EvalView };
 
 /**
- * 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.
+ * Split `output` around its views, in order: each view's `text` is searched
+ * from the end of the previous match, unmatched entries are skipped, and
+ * blank text between views is dropped (newlines bordering a view trimmed).
  */
-function splitConsoleTables(output: string): EvalOutputPart[] {
-	const lines = output.split("\n");
+export function splitEvalOutput(output: string, views: readonly EvalViewEntry[] | undefined): EvalOutputPart[] {
 	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 });
+	const pushText = (chunk: string, trimStart: boolean, trimEnd: boolean): void => {
+		let text = chunk;
+		if (trimStart) text = text.replace(/^\n+/, "");
+		if (trimEnd) text = text.replace(/\n+$/, "");
+		if (text.trim().length > 0) parts.push({ kind: "text", text });
 	};
-	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;
+	let cursor = 0;
+	for (const entry of views ?? []) {
+		if (!entry.text) continue;
+		const at = output.indexOf(entry.text, cursor);
+		if (at < 0) continue;
+		pushText(output.slice(cursor, at), cursor > 0, true);
+		parts.push({ kind: "view", view: entry.view });
+		cursor = at + entry.text.length;
 	}
-	flushText(lines.length);
+	pushText(output.slice(cursor), cursor > 0, cursor > 0);
 	return parts;
 }
 
+/** A table view as a native `table`; numeric columns align to the end. */
+function evalTableNode(view: Extract<EvalView, { kind: "table" }>, key: string): NativeNode {
+	return node(
+		"table",
+		{
+			cols: view.columns.map((column, c) => ({
+				id: `c${c}`,
+				head: column.head,
+				align: column.numeric ? "end" : undefined,
+			})),
+			rows: view.rows.map((cells, r) => ({
+				id: `r${r}`,
+				cells: Object.fromEntries(cells.map((cell, c) => [`c${c}`, cell])),
+			})),
+			role: "omp.tool.eval.table",
+		},
+		undefined,
+		key,
+	);
+}
+
 /**
- * One cell's outputs: markdown, else terminal text (following its tail,
- * clamped to the last `previewLines` while folded) with any `console.table`
- * blocks as tables.
+ * One cell's outputs in order: printed text (following its tail, clamped to
+ * the last `previewLines` while folded) with each view in place of its text.
  */
-function evalOutputNodes(output: string, markdown: boolean, previewLines: number): NativeNode[] {
+function evalOutputNodes(
+	output: string,
+	views: readonly EvalViewEntry[] | undefined,
+	previewLines: number,
+): NativeNode[] {
 	if (output.trim().length === 0) return [];
-	if (markdown) return [keyed(md(output), "output")];
-	return splitConsoleTables(output).map((part, i) =>
-		part.kind === "text"
-			? runOutput(part.text, { role: "omp.tool.eval.output", previewLines, key: i === 0 ? "output" : `output-${i}` })
-			: node(
-					"table",
-					{
-						// Node's index column header is noise in a real table.
-						cols: part.head.map((head, c) => ({ id: `c${c}`, head: head === "(index)" ? "" : head })),
-						rows: part.rows.map((cells, r) => ({
-							id: `r${r}`,
-							cells: Object.fromEntries(cells.map((cell, c) => [`c${c}`, cell])),
-						})),
-						role: "omp.tool.eval.table",
-					},
-					undefined,
-					`table-${i}`,
-				),
-	);
+	return splitEvalOutput(output, views).map((part, i) => {
+		if (part.kind === "text") {
+			return runOutput(part.text, {
+				role: "omp.tool.eval.output",
+				previewLines,
+				key: i === 0 ? "output" : `output-${i}`,
+			});
+		}
+		const view = part.view;
+		if (view.kind === "table") return evalTableNode(view, `table-${i}`);
+		if (view.kind === "json") return keyed(describeJsonTree(view.value, { hiddenRootKeys: [] }), `json-${i}`);
+		return keyed(md(view.text), `markdown-${i}`);
+	});
 }
 
 /** Status lines a folded cell keeps: the newest ones. */
@@ -958,18 +988,6 @@ export const evalToolRenderer = {
 		// the styled `warningLine` below carries the same text in ⟨…⟩ form.
 		const output = stripOutputNotice(rawOutput, details?.meta).trimEnd();
 
-		const jsonOutputs = details?.jsonOutputs ?? [];
-		const treeExpanded = options.renderContext?.expanded ?? options.expanded;
-		const treeDepth = treeExpanded ? JSON_TREE_MAX_DEPTH_EXPANDED : JSON_TREE_MAX_DEPTH_COLLAPSED;
-		const treeLineCap = treeExpanded ? JSON_TREE_MAX_LINES_EXPANDED : JSON_TREE_MAX_LINES_COLLAPSED;
-		const treeScalarLen = treeExpanded ? JSON_TREE_SCALAR_LEN_EXPANDED : JSON_TREE_SCALAR_LEN_COLLAPSED;
-		const labelOutputs = jsonOutputs.length > 1;
-		const jsonLines = jsonOutputs.flatMap((value, index) => {
-			const tree = renderJsonTreeLines(value, uiTheme, treeDepth, treeLineCap, treeScalarLen);
-			const body = tree.truncated ? [...tree.lines, uiTheme.fg("dim", "…")] : tree.lines;
-			return labelOutputs ? [uiTheme.fg("dim", `display[${index + 1}]`), ...body] : body;
-		});
-
 		const timeoutSeconds = options.renderContext?.timeout;
 		const timeoutLine =
 			typeof timeoutSeconds === "number"
@@ -1093,7 +1111,6 @@ export const evalToolRenderer = {
 							lines.push("");
 						}
 					}
-					lines.push(...jsonLines);
 					if (timeoutLine) {
 						lines.push(timeoutLine);
 					}
@@ -1116,9 +1133,6 @@ export const evalToolRenderer = {
 			});
 		}
 
-		const displayOutput = output;
-		const combinedOutput = [displayOutput, ...jsonLines].filter(Boolean).join("\n");
-
 		const statusEvents = details?.statusEvents ?? [];
 		const statusLines = renderStatusEvents(
 			statusEvents,
@@ -1127,12 +1141,12 @@ export const evalToolRenderer = {
 			details?.statusEventsElided,
 		);
 
-		if (!combinedOutput && statusLines.length === 0) {
+		if (!output && statusLines.length === 0) {
 			const lines = [timeoutLine, noticeLine, asyncLine, warningLine].filter(Boolean) as string[];
 			return new Text(lines.join("\n"), 0, 0);
 		}
 
-		if (!combinedOutput && statusLines.length > 0) {
+		if (!output && statusLines.length > 0) {
 			const lines = [
 				uiTheme.fg("dim", "Status"),
 				...statusLines,
@@ -1145,7 +1159,7 @@ export const evalToolRenderer = {
 		}
 
 		if (options.renderContext?.expanded ?? options.expanded) {
-			const styledOutput = combinedOutput
+			const styledOutput = output
 				.split("\n")
 				.map(line => uiTheme.fg("toolOutput", line))
 				.join("\n");
@@ -1160,7 +1174,7 @@ export const evalToolRenderer = {
 			return new Text(lines.join("\n"), 0, 0);
 		}
 
-		const styledOutput = combinedOutput
+		const styledOutput = output
 			.split("\n")
 			.map(line => uiTheme.fg("toolOutput", line))
 			.join("\n");
@@ -1250,9 +1264,6 @@ export const evalToolRenderer = {
 		const cancelled = options.cancelled === true;
 		const expanded = options.renderContext?.expanded ?? options.expanded;
 		const previewLines = options.renderContext?.previewLines ?? EVAL_DEFAULT_PREVIEW_LINES;
-		const jsonNodes = (details?.jsonOutputs ?? []).map((value, index) =>
-			keyed(describeJsonTree(value, { hiddenRootKeys: [] }), `display-${index}`),
-		);
 		// The call's notice and truncation join the last run's foot facts (a background job is a head badge).
 		const callFacts = { facts: compact([details?.notice]), meta: details?.meta };
 		const cellResults = details?.cells;
@@ -1278,15 +1289,7 @@ export const evalToolRenderer = {
 						language,
 						code: formatEvalCodeForDisplay(cell.code, language),
 						title: cell.title,
-						outputs: [
-							...evalOutputNodes(
-								cell.textOutput ?? cell.output,
-								cell.hasMarkdown === true && cell.status !== "error",
-								previewLines,
-							),
-
-							...(i === cellResults.length - 1 ? jsonNodes : []),
-						],
+						outputs: [...evalOutputNodes(cell.output, cell.views, previewLines)],
 						status: evalStatusSection(cell, expanded),
 						foot: state && {
 							state,
@@ -1311,10 +1314,7 @@ export const evalToolRenderer = {
 		const rawOutput = options.renderContext?.output ?? resultText(result).trimEnd();
 		const state: RunState = cancelled ? "cancelled" : isPartial ? "running" : result.isError ? "failed" : "done";
 		const last: Omit<EvalCellRun, "language" | "code" | "title"> = {
-			outputs: [
-				...evalOutputNodes(stripOutputNotice(rawOutput, details?.meta).trimEnd(), false, previewLines),
-				...jsonNodes,
-			],
+			outputs: evalOutputNodes(stripOutputNotice(rawOutput, details?.meta).trimEnd(), undefined, previewLines),
 			status: evalStatusSection(details ?? {}, expanded),
 			foot: { state, elapsedMs: options.elapsedMs, ...callFacts },
 		};

package/src/tools/find.ts

@@ -37,7 +37,6 @@ import type {
 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";
 
@@ -214,10 +213,14 @@ function describeHit(hit: FindHit, rangeLimit: number, cwd: string | undefined,
 		href: isUrlHit || cwd === undefined ? undefined : fileHref(path.join(cwd, rawRel)),
 		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) }),
+			code(range.snippet.trimEnd(), {
+				path: hit.rel,
+				start: range.start,
+				numbers: true,
+				title: range.p.toFixed(2),
+			}),
 			`${range.start}-${range.end}`,
 		),
 	);

package/src/tools/grep.ts

@@ -9,7 +9,6 @@ import type {
 	RenderResultOptions,
 	ToolRenderer,
 } from "./renderer";
-import { getLanguageFromPath } from "../lang-from-path";
 import { compact } from "../native/describe";
 import type { NativeChild } from "../native/node";
 import { footnoteText, inlineErrorView, resultText } from "./native-view";
@@ -557,7 +556,6 @@ export const grepToolRenderer = {
 			inline: true,
 			body: compact<NativeChild>([
 				...describeGroupedOutput(textContent.split("\n"), {
-					lang: getLanguageFromPath,
 					maxFiles: options.expanded ? undefined : NATIVE_COLLAPSED_FILES,
 					file: details?.files?.length === 1 ? details.files[0] : undefined,
 				}),

package/src/tools/grouped-file-output.ts

@@ -314,12 +314,13 @@ export interface NumberedLine {
  * Numbered `code` for possibly non-contiguous source lines: one block per run
  * of consecutive line numbers (`start` = the run's first line, match lines
  * `mark`ed), with a `…` row wherever the numbers jump or an elision marker
- * (`n: null`) sits. No path header: the row or head above names the file.
+ * (`n: null`) sits. `path` is the file the lines come from: Tern picks their
+ * grammar from it and draws no header (the row or head above names the file).
  * `wrap` soft-wraps long lines instead of scrolling the block sideways.
  */
 export function numberedCode(
 	lines: readonly NumberedLine[],
-	opts: { lang?: string; wrap?: boolean } = {},
+	opts: { path?: string; wrap?: boolean } = {},
 ): NativeNode[] {
 	const out: NativeNode[] = [];
 	let run: { start: number; text: string[]; marks: { line: number; tone: TspTone }[] } | undefined;
@@ -332,7 +333,7 @@ export function numberedCode(
 				code(run.text.join("\n"), {
 					start: run.start,
 					numbers: true,
-					lang: opts.lang,
+					path: opts.path,
 					wrap: opts.wrap,
 					marks: run.marks.length > 0 ? run.marks : undefined,
 				}),
@@ -367,7 +368,7 @@ export function numberedCode(
  */
 export function describeGroupedOutput(
 	lines: readonly string[],
-	options: { lang?: (path: string) => string | undefined; maxFiles?: number; file?: string } = {},
+	options: { maxFiles?: number; file?: string } = {},
 ): NativeNode[] {
 	const files: NativeNode[] = [];
 	const loose: NativeNode[] = [];
@@ -380,7 +381,7 @@ export function describeGroupedOutput(
 	const flushLines = () => {
 		const target = current?.children ?? loose;
 		if (numbered.length > 0) {
-			target.push(...numberedCode(numbered, { lang: current ? options.lang?.(current.path) : undefined }));
+			target.push(...numberedCode(numbered, { path: current?.path }));
 			numbered = [];
 		}
 		if (plain.length > 0) {

package/src/tools/read.ts

@@ -431,12 +431,12 @@ export function readContentCode(
 	content: string,
 	start: number,
 	numbers: readonly (number | null)[] | undefined,
-	lang: string | undefined,
+	path: string | undefined,
 ): NativeNode[] {
 	const lines = content.split("\n");
 	return numberedCode(
 		lines.map((text, i) => ({ n: numbers && numbers.length === lines.length ? numbers[i]! : start + i, text })),
-		{ lang, wrap: true },
+		{ path, wrap: true },
 	);
 }
 
@@ -766,7 +766,7 @@ export const readToolRenderer = {
 					contentText,
 					details?.displayContent?.startLine ?? readRangeStart(rawPath, args),
 					details?.displayContent?.lineNumbers,
-					getLanguageFromPath(renderPath.path),
+					renderPath.path,
 				);
 		return { tool: head, inline: true, body: compact<NativeChild>([media, ...content, foot]) };
 	},

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

@@ -26,6 +26,7 @@ export const SEARCH_PROVIDER_LABELS = {
 	tavily: "Tavily",
 	firecrawl: "Firecrawl",
 	brave: "Brave",
+	deepseek: "DeepSeek",
 	kimi: "Kimi",
 	synthetic: "Synthetic",
 	ollama: "Ollama",

package/src/tools/write.ts

@@ -164,10 +164,12 @@ function describeFigure(figure: ToolFigure | undefined): NativeNode | undefined
 	return { ...md(text, { role: "omp.tool.write.figure", stream: !figure.closed }), key: "figure" };
 }
 
-/** The written content as numbered code, keyed so it keeps its node as the figure above it comes and goes. */
+/**
+ * The written content as numbered code, highlighted by Tern from the file's path,
+ * keyed so it keeps its node as the figure above it comes and goes.
+ */
 function describeSource(rawPath: string, content: string): NativeNode {
-	const lang = rawPath ? getLanguageFromPath(rawPath) : undefined;
-	return { ...code(content, { lang, numbers: true, wrap: true }), key: "source" };
+	return { ...code(content, { path: rawPath || undefined, numbers: true, wrap: true }), key: "source" };
 }
 
 function countLines(text: string): number {

package/src/tui.ts

@@ -107,6 +107,11 @@ const PAINT_END_NO_SYNC = ENABLE_AUTOWRAP;
 // native text selection.
 const MOUSE_TRACKING_ON = "\x1b[?1000h\x1b[?1003h\x1b[?1006h";
 const MOUSE_TRACKING_OFF = "\x1b[?1006l\x1b[?1003l\x1b[?1000l";
+// Cell-size replies: CSI 6 ; height ; width t in pixels, and iTerm2's
+// OSC 1337 ; ReportCellSize = height ; width [; scale] ST in points.
+const CELL_SIZE_REPLY = /^\x1b\[6;(\d+);(\d+)t$/;
+const ITERM2_CELL_SIZE_REPLY =
+	/^\x1b\]1337;ReportCellSize=(\d+(?:\.\d+)?);(\d+(?:\.\d+)?)(?:;(\d+(?:\.\d+)?))?(?:\x07|\x1b\\)$/;
 
 type MouseTrackingState = "off" | "inline" | "full";
 
@@ -2562,6 +2567,9 @@ export class TUI extends Container {
 		// Query terminal for cell size in pixels: CSI 16 t
 		// Response format: CSI 6 ; height ; width t
 		this.terminal.write("\x1b[16t");
+		// iTerm2 never answers CSI 16 t. Without a size, rows reserved for an image
+		// and crops of a partly scrolled one assume 9x18 cells and land offset.
+		if (TERMINAL.imageProtocol === ImageProtocol.Iterm2) this.terminal.write("\x1b]1337;ReportCellSize\x1b\\");
 	}
 
 	/**
@@ -3051,14 +3059,19 @@ export class TUI extends Container {
 	}
 
 	#consumeCellSizeResponse(data: string): boolean {
-		// Response format: ESC [ 6 ; height ; width t
-		const match = data.match(/^\x1b\[6;(\d+);(\d+)t$/);
-		if (!match) {
-			return false;
+		let heightPx: number;
+		let widthPx: number;
+		const pixels = CELL_SIZE_REPLY.exec(data);
+		if (pixels) {
+			heightPx = parseInt(pixels[1], 10);
+			widthPx = parseInt(pixels[2], 10);
+		} else {
+			const points = ITERM2_CELL_SIZE_REPLY.exec(data);
+			if (!points) return false;
+			const scale = points[3] ? Number(points[3]) : 1;
+			heightPx = Math.round(Number(points[1]) * scale);
+			widthPx = Math.round(Number(points[2]) * scale);
 		}
-
-		const heightPx = parseInt(match[1], 10);
-		const widthPx = parseInt(match[2], 10);
 		if (heightPx <= 0 || widthPx <= 0) {
 			return true;
 		}