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

package/src/tools/native-view.ts

@@ -0,0 +1,292 @@
+/**
+ * Shared pieces of the tool renderers' TSP describe hooks: result text,
+ * card heads, error views, notes and notices. No layout: every helper returns
+ * semantic nodes/spans only, with ANSI-free, sanitized text.
+ */
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+import type { TspSpan, TspText, TspTone } from "@oh-my-pi/pi-wire";
+import { code, keyed, node, row, span, text } from "../native/describe";
+import type { NativeChild, NativeNode } from "../native/node";
+import { type ParsedDiagnostic, parseDiagnosticMessage, shortenPath } from "../render/render-utils";
+import { plainText } from "../native/spans";
+import type { FileDiagnosticsResult } from "./lsp";
+import { formatArtifactErrorNotice, formatTruncationMetaNotice, type OutputMeta } from "./output-meta";
+import type { NativeToolHead, NativeToolView, ToolRenderResult } from "./renderer";
+
+/** A path for native heads: relative to the working directory when inside it, else `~`-shortened. */
+export function displayPath(filePath: string): string {
+	if (path.isAbsolute(filePath)) {
+		const rel = path.relative(process.cwd(), filePath);
+		if (rel && !rel.startsWith("..") && !path.isAbsolute(rel)) return rel;
+	}
+	return shortenPath(filePath);
+}
+
+/** `file://` link for a head's path target, when the path is absolute. */
+export function fileHref(filePath: string | undefined): string | undefined {
+	return filePath && path.isAbsolute(filePath) ? pathToFileURL(filePath).href : undefined;
+}
+
+/** Diff stats as one head `meta` string, `+8 −1` (U+2212 minus), or undefined when nothing changed. */
+export function diffStatsMeta(added: number, removed: number): string | undefined {
+	const parts: string[] = [];
+	if (added > 0) parts.push(`+${added}`);
+	if (removed > 0) parts.push(`\u2212${removed}`);
+	return parts.length > 0 ? parts.join(" ") : undefined;
+}
+
+/**
+ * One file of a multi-file edit: a borderless `section` headed by the path
+ * (→ rename) and its `+a −d`, over the file's body (its diff, diagnostics).
+ */
+export function fileDiffSection(
+	file: { path: string; rename?: string; added?: number; removed?: number },
+	body: readonly NativeChild[],
+	p: { role: string; tone?: TspTone },
+): NativeNode {
+	const head: TspSpan[] = [span(displayPath(file.path), "path")];
+	if (file.rename) head.push(span(" → ", "muted"), span(displayPath(file.rename), "path"));
+	if (file.added) head.push(span(` +${file.added}`, "ins"));
+	if (file.removed) head.push(span(` \u2212${file.removed}`, "del"));
+	return node("section", { head, role: p.role, tone: p.tone }, body, file.path);
+}
+
+/**
+ * One 22px file row (role `omp.tool.file`) for read groups, grep files, glob
+ * lists and find hits: a leading glyph (the file icon unless `lead` replaces
+ * it), the path with a dim directory and a strong name (cut in the middle),
+ * a quiet `range` suffix (`:13-36`), then an optional count `chip` and a
+ * muted `detail`.
+ */
+export function fileRow(
+	filePath: string,
+	p: {
+		range?: string;
+		chip?: { text: string; title?: string };
+		detail?: TspText;
+		href?: string;
+		lead?: NativeNode;
+		icon?: string;
+		tone?: TspTone;
+		title?: string;
+		key?: string;
+	} = {},
+): NativeNode {
+	const isDir = filePath.endsWith("/");
+	const bare = isDir ? filePath.slice(0, -1) : filePath;
+	const cut = bare.lastIndexOf("/") + 1;
+	const spans: TspSpan[] = [];
+	if (cut > 0) spans.push(span(bare.slice(0, cut), "dim"));
+	spans.push(span(`${bare.slice(cut) || "…"}${isDir ? "/" : ""}`, "strong", p.href ? { href: p.href } : undefined));
+	if (p.range) spans.push(span(p.range, "muted"));
+	const children: NativeChild[] = [
+		p.lead ?? node("icon", { name: p.icon ?? (isDir ? "folder" : "file"), tone: p.tone }),
+		text(spans, { lines: 1, truncate: "middle", shrink: 1, title: p.title ?? filePath }),
+	];
+	if (p.chip) children.push(node("badge", { text: p.chip.text, title: p.chip.title }));
+	if (p.detail !== undefined) {
+		const detail = typeof p.detail === "string" ? [span(plainText(p.detail), "muted")] : p.detail;
+		children.push(text(detail, { lines: 1, truncate: "end", shrink: 1 }));
+	}
+	return keyed(row(children, { role: "omp.tool.file", tone: p.tone }), p.key ?? filePath);
+}
+
+/** Longest error excerpt an inline head carries before the body takes the full message. */
+const ERROR_GIST_CHARS = 120;
+
+/**
+ * Inline error view (§7.3 read error): error tone, the message's first line
+ * after `—` in the head's meta, so a collapsed inline call never hides it,
+ * and the full message as the body only when the head had to cut it short.
+ */
+export function inlineErrorView(head: NativeToolHead, message: string): NativeToolView {
+	const full = plainText(message).trim() || "failed";
+	const first = full.split("\n", 1)[0]!.trim();
+	const gist = first.length > ERROR_GIST_CHARS ? `${first.slice(0, ERROR_GIST_CHARS - 1)}…` : first;
+	return {
+		tool: { ...head, meta: [...(head.meta ?? []), [span(`— ${gist}`, "muted")]] },
+		tone: "error",
+		inline: true,
+		body: gist === full ? undefined : [errorText(full)],
+	};
+}
+
+/** Text blocks of a tool result joined by newlines, or `""`. */
+export function resultText(result: ToolRenderResult<unknown>): string {
+	let out = "";
+	for (const block of result.content ?? []) {
+		if (block.type === "text" && typeof block.text === "string") out += out ? `\n${block.text}` : block.text;
+	}
+	return out;
+}
+
+/**
+ * Card head: the bold `toolTitle` title, then detail spans; string details
+ * become muted plain text, empty details are skipped.
+ */
+export function toolHead(title: string, ...details: readonly (TspSpan | string | undefined)[]): TspSpan[] {
+	const spans: TspSpan[] = [span(title, "toolTitle strong")];
+	for (const detail of details) {
+		if (detail === undefined) continue;
+		const value = typeof detail === "string" ? span(plainText(detail), "muted") : detail;
+		if (!value.t) continue;
+		spans.push(span(" "), value);
+	}
+	return spans;
+}
+
+/** Error body: wrapped error text, or a JSON `code` block when the message is structured. */
+export function errorText(message: string): NativeNode {
+	const body = plainText(message).trim();
+	return body.includes("\n") && /^[{[]/.test(body)
+		? code(body, { lang: "json", tone: "error", role: "omp.tool.error" })
+		: text([span(body, "error")], { wrap: "word", role: "omp.tool.error" });
+}
+
+/** Error card view: error tone, the tool head and the error body (`<title> failed` when empty). */
+export function errorView(title: string, message: string, ...meta: readonly (string | undefined)[]): NativeToolView {
+	return {
+		head: toolHead(title, ...meta),
+		tone: "error",
+		body: [errorText(plainText(message).trim() || `${title} failed`)],
+	};
+}
+
+/** Wrapped placeholder or secondary line (`(no output)`, `No matches`, …); `lines` clamps it. */
+export function noteText(message: string, token = "muted", lines?: number): NativeNode {
+	return text([span(plainText(message), token)], lines === undefined ? { wrap: "word" } : { wrap: "word", lines });
+}
+
+/** Muted `a · b · c` metadata line, or undefined when there are no parts. */
+export function statsText(parts: readonly string[]): NativeNode | undefined {
+	if (parts.length === 0) return undefined;
+	return text([span(parts.join(" · "), "muted")], { wrap: "word", role: "omp.tool.stats" });
+}
+
+/** Warning line for truncation / artifact capture failures, or undefined. */
+export function truncationNotice(meta: OutputMeta | undefined): NativeNode | undefined {
+	if (!meta?.truncation && !meta?.artifactError) return undefined;
+	const parts: string[] = [];
+	if (meta.truncation) parts.push(formatTruncationMetaNotice(meta.truncation, meta.source));
+	if (meta.artifactError) parts.push(formatArtifactErrorNotice(meta.artifactError));
+	return text([span(parts.join(". "), "warning")], { wrap: "word", role: "omp.tool.notice" });
+}
+
+/**
+ * The one final quiet line of a tool body (§7.2): `a · b` facts, then any
+ * truncation / artifact-capture notice from `meta`; undefined when empty.
+ */
+export function footnoteText(parts: readonly string[], meta?: OutputMeta): NativeNode | undefined {
+	const all = parts.map(part => plainText(part)).filter(part => part.length > 0);
+	if (meta?.truncation) all.push(formatTruncationMetaNotice(meta.truncation, meta.source));
+	if (meta?.artifactError) all.push(formatArtifactErrorNotice(meta.artifactError));
+	if (all.length === 0) return undefined;
+	const notice = meta?.truncation !== undefined || meta?.artifactError !== undefined;
+	return {
+		...text([span(all.join(" · "), "muted")], { wrap: "word", role: notice ? "omp.tool.notice" : "omp.tool.stats" }),
+		key: "foot",
+	};
+}
+
+/** Diagnostic rows shown before `+N more`. */
+const DIAGNOSTIC_ROWS = 5;
+
+const SEVERITY_RANK: Record<ParsedDiagnostic["severity"], number> = { error: 0, warning: 1, info: 2, hint: 3 };
+const SEVERITY_ICON: Record<ParsedDiagnostic["severity"], string> = {
+	error: "x-circle",
+	warning: "warn",
+	info: "info",
+	hint: "lightbulb",
+};
+const SEVERITY_TONE: Record<ParsedDiagnostic["severity"], TspTone> = {
+	error: "error",
+	warning: "warning",
+	info: "info",
+	hint: "muted",
+};
+
+/** A diagnostic's severity glyph: `x-circle` error, `warn` warning, `info`, `lightbulb` hint, in the severity tone. */
+export function diagnosticGlyph(severity: ParsedDiagnostic["severity"]): NativeNode {
+	return node("icon", { name: SEVERITY_ICON[severity] ?? "warn", tone: SEVERITY_TONE[severity], aria: severity });
+}
+
+/** One diagnostic row: severity icon · `line:col` (with the file when `withPath`) · message and source. */
+function diagnosticRow(diagnostic: ParsedDiagnostic, withPath: boolean, key: string): NativeNode {
+	const where = `${withPath ? `${displayPath(diagnostic.filePath)}:` : ""}${diagnostic.line}:${diagnostic.col}`;
+	const message: TspSpan[] = [span(diagnostic.message)];
+	const source = [diagnostic.source, diagnostic.code].filter(Boolean).join(" ");
+	if (source) message.push(span(` ${source}`, "muted"));
+	return row(
+		[
+			node("icon", {
+				name: SEVERITY_ICON[diagnostic.severity] ?? "warn",
+				tone: SEVERITY_TONE[diagnostic.severity],
+				aria: diagnostic.severity,
+			}),
+			text([span(where, "muted")], { wrap: "none" }),
+			text(message, { wrap: "word" }),
+		],
+		{ role: "omp.tool.diagnostic", key },
+	);
+}
+
+/**
+ * LSP diagnostics section for write/edit results: rows of severity icon ·
+ * `line:col` · message, most severe first, capped at five with `+N more`.
+ * Rows name the file too when the messages span several files (or `withPath`).
+ * Undefined when there is nothing to show.
+ */
+export function diagnosticsSection(
+	diagnostics: FileDiagnosticsResult | undefined,
+	opts?: { withPath?: boolean },
+): NativeNode | undefined {
+	if (!diagnostics || diagnostics.messages.length === 0) return undefined;
+	const parsed: ParsedDiagnostic[] = [];
+	const unparsed: string[] = [];
+	for (const message of diagnostics.messages) {
+		const diagnostic = parseDiagnosticMessage(plainText(message).trim());
+		if (diagnostic) parsed.push(diagnostic);
+		else if (message.trim()) unparsed.push(plainText(message).trim());
+	}
+	parsed.sort(
+		(a, b) => (SEVERITY_RANK[a.severity] ?? 4) - (SEVERITY_RANK[b.severity] ?? 4) || a.line - b.line || a.col - b.col,
+	);
+	const withPath = opts?.withPath === true || new Set(parsed.map(d => d.filePath)).size > 1;
+	const rows: NativeNode[] = [
+		...parsed.map((d, i) => diagnosticRow(d, withPath, `d${i}`)),
+		...unparsed.map((message, i) =>
+			text([span(message)], { wrap: "word", role: "omp.tool.diagnostic", key: `u${i}` }),
+		),
+	];
+	const shown = rows.slice(0, DIAGNOSTIC_ROWS);
+	const hidden = rows.length - shown.length;
+	if (hidden > 0) {
+		shown.push(text([span(`+${hidden} more`, "muted")], { role: "omp.tool.stats", key: "more" }));
+	}
+	return node(
+		"section",
+		{
+			head: [span("Diagnostics")],
+			tone: diagnostics.errored ? "error" : "warning",
+			role: "omp.tool.diagnostics",
+		},
+		shown,
+		"diagnostics",
+	);
+}
+
+/** Head chip counting LSP diagnostics across files (`2 diagnostics`), or undefined when there are none. */
+export function diagnosticsBadge(
+	files: readonly (FileDiagnosticsResult | undefined)[],
+): { text: string; tone: TspTone } | undefined {
+	let count = 0;
+	let errored = false;
+	for (const file of files) {
+		if (!file) continue;
+		count += file.messages.length;
+		errored ||= file.errored;
+	}
+	if (count === 0) return undefined;
+	return { text: count === 1 ? "1 diagnostic" : `${count} diagnostics`, tone: errored ? "error" : "warning" };
+}

package/src/tools/proc-render.ts

@@ -11,7 +11,11 @@ import {
 	type ToolUIColor,
 } from "../render/render-utils";
 import type { Theme } from "../theme/theme";
-import type { RenderResultOptions } from "./renderer";
+import type { NativeToolView, RenderResultOptions } from "./renderer";
+import type { TspSpan, TspTone } from "@oh-my-pi/pi-wire";
+import { ansi, compact, node, span, text } from "../native/describe";
+import type { NativeChild, NativeNode } from "../native/node";
+import { errorText, noteText, toolHead } from "./native-view";
 import type { AgentActivitySnapshot, CoordinationDetails, JobSnapshot } from "./wait";
 import type { IrcDeliveryReceipt } from "./irc";
 import type { DaemonSnapshot } from "./daemon";
@@ -268,3 +272,219 @@ export function renderProcRead(
 		];
 	}, options);
 }
+
+// =============================================================================
+// Native (TSP) views
+// =============================================================================
+
+function daemonMetaText(daemon: DaemonSnapshot): string {
+	const meta: string[] = [daemon.state];
+	if (daemon.pid !== undefined) meta.push(`pid ${daemon.pid}`);
+	meta.push(
+		`${daemon.exitedAt === undefined ? "up" : "ran"} ${formatDuration(Math.max(0, (daemon.exitedAt ?? Date.now()) - daemon.startedAt))}`,
+	);
+	if (daemon.detached) meta.push("detached");
+	else if (daemon.persist) meta.push("persistent");
+	return meta.join(" · ");
+}
+
+function jobTone(status: JobSnapshot["status"]): TspTone {
+	return status === "failed"
+		? "error"
+		: status === "cancelled"
+			? "warning"
+			: status === "running"
+				? "info"
+				: "success";
+}
+
+function jobItem(job: JobSnapshot, badge?: { text: string; tone: TspTone }): NativeNode {
+	return node(
+		"item",
+		{
+			label: [span(job.type, "accent"), span(" "), span(safe(job.id), "toolOutput")],
+			detail: [span(safe(job.label), "muted")],
+			value: badge ? [span(badge.text, badge.tone)] : [span(formatDuration(job.durationMs), "muted")],
+			tone: badge?.tone ?? jobTone(job.status),
+		},
+		undefined,
+		job.id,
+	);
+}
+
+function quotedPreview(body: string, tone = "muted"): NativeNode | undefined {
+	if (!body.trim()) return undefined;
+	return text([span(body, tone)], { wrap: "word", role: "omp.tool.proc.preview" });
+}
+
+const RECEIPT_TONE: Record<IrcDeliveryReceipt["outcome"], TspTone> = {
+	injected: "success",
+	woken: "success",
+	revived: "warning",
+	failed: "error",
+};
+
+/** TSP view of an `agent://` write (IRC message). */
+export function describeAgentWrite(
+	to: string,
+	body: string,
+	result: ToolResult | undefined,
+	details: CoordinationDetails | undefined,
+): NativeToolView {
+	const recipient = safe(details?.to || to || "…");
+	const receipts = details?.receipts ?? [];
+	const delivered = receipts.filter(receipt => receipt.outcome !== "failed").length;
+	const failed = receipts.length - delivered;
+	const meta: TspSpan[] = [];
+	if (recipient === "all") meta.push(span("broadcast", "muted"));
+	if (receipts.length === 1) meta.push(span(receipts[0]!.outcome, RECEIPT_TONE[receipts[0]!.outcome]));
+	else if (receipts.length > 1) {
+		if (delivered) meta.push(span(`${delivered} delivered`, "success"));
+		if (failed) meta.push(span(`${failed} failed`, "error"));
+	}
+	const head = toolHead("IRC", span(recipient, "accent"), ...meta);
+	const error = result?.isError === true || (failed > 0 && delivered === 0);
+	if (result?.isError && receipts.length === 0) {
+		return { head, tone: "error", body: [errorText(firstText(result) || "Message delivery failed.")] };
+	}
+	const children = compact<NativeChild>([
+		quotedPreview(body),
+		result !== undefined && receipts.length === 0 && noteText(firstText(result) || "No live peers to broadcast to."),
+		(receipts.length > 1 || failed > 0) &&
+			node(
+				"list",
+				{ role: "omp.tool.irc.receipts" },
+				receipts.map(receipt =>
+					node(
+						"item",
+						{
+							label: [span(safe(receipt.to), "toolOutput")],
+							value: [span(receipt.outcome, RECEIPT_TONE[receipt.outcome])],
+							detail: receipt.error ? [span(safe(receipt.error), "error")] : undefined,
+							tone: RECEIPT_TONE[receipt.outcome],
+						},
+						undefined,
+						receipt.to,
+					),
+				),
+			),
+	]);
+	return { head, tone: error ? "error" : undefined, body: children };
+}
+
+/** TSP view of a `proc://` write (stdin, mode change, kill). */
+export function describeProcWrite(
+	id: string,
+	action: ProcWriteAction,
+	content: string | undefined,
+	result: ToolResult | undefined,
+	details: ProcWriteDetails | undefined,
+): NativeToolView {
+	const daemon = details && "daemon" in details ? details.daemon : undefined;
+	const head = toolHead(
+		`Proc ${action}`,
+		span(safe(id || "…"), "accent"),
+		daemon ? daemonMetaText(daemon) : action === "mode" && content ? safe(content) : undefined,
+	);
+	if (result?.isError) {
+		return { head, tone: "error", body: [errorText(firstText(result) || "Process operation failed.")] };
+	}
+	const body = compact<NativeChild>([content && action === "stdin" ? quotedPreview(content) : undefined]);
+	if (details && "op" in details && details.op === "cancel") {
+		const jobs = details.jobs ?? [];
+		body.push(
+			node(
+				"list",
+				{ role: "omp.tool.proc.cancelled" },
+				(details.cancelled ?? []).map(outcome => {
+					const job = jobs.find(item => item.id === outcome.id);
+					const badge = {
+						text: outcome.status,
+						tone: outcome.status === "cancelled" ? "warning" : "error",
+					} as const;
+					return job
+						? jobItem(job, badge)
+						: node(
+								"item",
+								{ label: [span(safe(outcome.id), "toolOutput")], value: [span(badge.text, badge.tone)] },
+								undefined,
+								outcome.id,
+							);
+				}),
+			),
+		);
+	}
+	return { head, tone: result !== undefined && action === "kill" ? "warning" : undefined, body };
+}
+
+/** TSP view of a `proc://` read: job/service detail, logs, or the process table. */
+export function describeProcRead(
+	id: string,
+	result: ToolResult | undefined,
+	details: ProcReadDetails | undefined,
+): NativeToolView {
+	const daemon = details?.daemon;
+	const title = id ? "Proc" : "Proc jobs & services";
+	const head = toolHead(title, id ? span(safe(id), "accent") : undefined, daemon ? daemonMetaText(daemon) : undefined);
+	if (result?.isError) {
+		return { head, tone: "error", body: [errorText(firstText(result) || "Process read failed.")] };
+	}
+	if (!result) return { head };
+	if (details?.job) {
+		const log = details.log ?? details.job.errorText ?? details.job.resultText ?? "";
+		return {
+			head,
+			body: compact<NativeChild>([
+				node("list", {}, [jobItem(details.job)]),
+				log.trim().length > 0 && ansi(log, { role: "omp.tool.proc.log" }),
+			]),
+		};
+	}
+	if (daemon) {
+		const output = details.terminalRows?.join("\n") ?? details.log ?? "";
+		return { head, body: [ansi(output, { follow: daemon.exitedAt === undefined, role: "omp.tool.proc.log" })] };
+	}
+	if (id && !details?.jobs && !details?.daemons && !details?.agents) {
+		return { head, body: compact<NativeChild>([quotedPreview(firstText(result), "toolOutput")]) };
+	}
+	const jobs = details?.jobs ?? [];
+	const services = details?.daemons ?? [];
+	const agents = details?.agents ?? [];
+	const items: NativeNode[] = [
+		...jobs.map(job => jobItem(job)),
+		...services.map(service =>
+			node(
+				"item",
+				{
+					label: [span("service", "accent"), span(" "), span(safe(service.name), "toolOutput")],
+					detail: [span(daemonMetaText(service), "muted")],
+					tone:
+						service.state === "failed"
+							? "error"
+							: service.state === "ready" || service.state === "running"
+								? "success"
+								: "warning",
+				},
+				undefined,
+				`service:${service.name}`,
+			),
+		),
+		...agents.map(agent =>
+			node(
+				"item",
+				{
+					label: [span("agent", agent.live ? "accent" : "warning"), span(" "), span(safe(agent.id), "toolOutput")],
+					value: [span(formatDuration(agent.ageMs), "muted")],
+				},
+				undefined,
+				`agent:${agent.id}`,
+			),
+		),
+	];
+	const counts = [`${jobs.length} jobs`, `${services.length} services`];
+	if (agents.length) counts.push(`${agents.length} agents`);
+	return {
+		head: toolHead(title, id ? span(safe(id), "accent") : undefined, counts.join(" · ")),
+		body: [node("list", { empty: "No background jobs or services.", role: "omp.tool.proc.table" }, items)],
+	};
+}