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

package/src/tools/debug.ts

@@ -11,7 +11,11 @@ import {
 	TRUNCATE_LENGTHS,
 	truncateToWidth,
 } from "../render/render-utils";
-import type { RenderResultOptions, ToolRenderer } from "./renderer";
+import type { NativeToolView, RenderResultOptions, ToolRenderer, ToolRenderResult } from "./renderer";
+import { ansi, kv } from "../native/describe";
+import type { NativeChild } from "../native/node";
+import { OwnerMemo } from "../native/memo";
+import { errorView, noteText, resultText, toolHead } from "./native-view";
 
 /** Display fields captured from a debugger session. */
 export interface DebugSessionSnapshot {
@@ -115,6 +119,68 @@ function summarizeDebugCall(args: DebugRenderArgs): string {
 	return action;
 }
 
+/** Untruncated `[action, target]` for native heads; mirrors {@link summarizeDebugCall}'s field precedence. */
+function debugCallParts(args: DebugRenderArgs | undefined, fallbackAction: string): [string, string | undefined] {
+	const action = (args?.action ?? fallbackAction).replaceAll("_", " ");
+	if (!args) return [action, undefined];
+	const target =
+		args.program ||
+		(args.file && args.line !== undefined ? `${args.file}:${args.line}` : undefined) ||
+		args.function ||
+		args.expression ||
+		args.command ||
+		args.memory_reference ||
+		args.instruction_reference ||
+		args.data_id ||
+		args.name ||
+		undefined;
+	return [action, target];
+}
+
+function describeDebugResult(
+	result: ToolRenderResult<DebugToolDetails>,
+	args: DebugRenderArgs | undefined,
+): NativeToolView {
+	const [action, target] = debugCallParts(args, result.details?.action ?? "debug");
+	const output = resultText(result);
+	if (result.isError) return errorView("Debug", output || "Debug failed", action, target);
+	const snapshot = result.details?.snapshot;
+	const body: NativeChild[] = [];
+	let sessionRows = 0;
+	if (snapshot) {
+		const location = formatLocation(snapshot);
+		const rows: [string, string | undefined][] = [
+			["Session", snapshot.id],
+			["Adapter", snapshot.adapter],
+			["Status", snapshot.status],
+			["CWD", snapshot.cwd],
+			["Program", snapshot.program],
+			["Stop reason", snapshot.stopReason],
+			["Frame", snapshot.frameName],
+			["Instruction pointer", snapshot.instructionPointerReference],
+			["Location", location ?? undefined],
+			[
+				"Configuration",
+				snapshot.needsConfigurationDone ? "pending configurationDone; set breakpoints, then continue." : undefined,
+			],
+			["Exit code", snapshot.exitCode !== undefined ? String(snapshot.exitCode) : undefined],
+		];
+		const grid = kv(rows);
+		if (grid) {
+			body.push(grid);
+			sessionRows = rows.filter(([, value]) => value).length;
+		}
+	}
+	body.push(output ? ansi(output) : noteText("No output"));
+	return {
+		head: toolHead("Debug", action, target),
+		body,
+		preview: { lines: sessionRows + PREVIEW_LIMITS.COLLAPSED_LINES },
+	};
+}
+
+const debugResultMemo = new OwnerMemo<NativeToolView | undefined>();
+
 /** Renders debugger calls and captured execution snapshots. */
 export const debugToolRenderer = {
 	animatedPartialResult: true,
@@ -162,6 +228,17 @@ export const debugToolRenderer = {
 			};
 		});
 	},
+	describeCall(args: DebugRenderArgs): NativeToolView {
+		const [action, target] = debugCallParts(args, "request");
+		return { head: toolHead("Debug", action, target) };
+	},
+	describeResult(
+		result: ToolRenderResult<DebugToolDetails>,
+		_options: RenderResultOptions,
+		args?: DebugRenderArgs,
+	): NativeToolView | undefined {
+		return debugResultMemo.get(result, [], () => describeDebugResult(result, args));
+	},
 	mergeCallAndResult: true,
 	inline: true,
 } satisfies ToolRenderer<DebugRenderArgs, DebugToolDetails>;

package/src/tools/default-renderer.ts

@@ -1,12 +1,15 @@
 import type { Component } from "../index";
 import { isRecord } from "@oh-my-pi/pi-utils";
-import type { RenderResultOptions } from "./renderer";
+import type { NativeToolHead, NativeToolView, RenderResultOptions } from "./renderer";
+import { ansi } from "../native/describe";
+import { noteText } from "./native-view";
 import type { Theme } from "../theme/theme";
 import { formatOutputPaneLines, styleToolOutputLine } from "../render/output-pane";
 import { renderStatusLine, type StatusLineOptions } from "../render/status-line";
 import { plainToolCard, type ToolCardPhase } from "../render/tool-card";
 import { truncateToWidth } from "../render/render-utils";
 import {
+	describeJsonTree,
 	formatArgsInline,
 	JSON_TREE_MAX_DEPTH_COLLAPSED,
 	JSON_TREE_MAX_DEPTH_EXPANDED,
@@ -159,6 +162,37 @@ export function formatDefaultToolExecution(
 	return [renderStatusLine(snapshot.status, uiTheme), ...snapshot.body].join("\n");
 }
 
+/** Inline args summary budget in characters (a data cap, not a width). */
+const NATIVE_ARGS_SUMMARY_CHARS = 160;
+/** Result text kept for the native card body. */
+const NATIVE_RESULT_MAX_CHARS = 64 * 1024;
+
+/**
+ * TSP view of the generic fallback card: the tool label with a one-line args
+ * summary as the head target; the result as a JSON tree or raw `ansi` output.
+ */
+export function describeDefaultToolExecution(input: DefaultToolRenderInput): NativeToolView {
+	const { result } = input;
+	const args = isRecord(input.args) ? input.args : undefined;
+	const summary =
+		args && Object.keys(args).length > 0
+			? formatArgsInline(args, NATIVE_ARGS_SUMMARY_CHARS, { characterBudget: true })
+			: undefined;
+	const tool: NativeToolHead = { title: input.label, target: summary || undefined, targetKind: "text" };
+	if (!result) return { tool };
+	const output = result.output.trimEnd().slice(0, NATIVE_RESULT_MAX_CHARS);
+	const tone = result.skipped ? "info" : result.isError ? "error" : undefined;
+	if (!output) return { tool, tone, body: [noteText("(no output)")] };
+	if (output.startsWith("{") || output.startsWith("[")) {
+		try {
+			return { tool, tone, body: [describeJsonTree(JSON.parse(output))] };
+		} catch {
+			// Not JSON: shown as raw output below.
+		}
+	}
+	return { tool, tone, body: [ansi(output)] };
+}
+
 /** Render the generic fallback as the state-tinted card used by direct custom tools. */
 export function renderDefaultToolExecution(input: DefaultToolRenderInput, uiTheme: Theme): Component {
 	return plainToolCard(

package/src/tools/edit.ts

@@ -6,9 +6,22 @@ import { type EditInspection, editInspect } from "@oh-my-pi/pi-natives";
 import type { Component } from "../tui";
 import { sliceWithWidth, visibleWidth, wrapTextWithAnsi } from "../utils";
 import { sanitizeText } from "@oh-my-pi/pi-utils";
-import type { RenderResultOptions, ToolRenderer } from "./renderer";
+import type { NativeToolHead, NativeToolView, RenderResultOptions, ToolRenderer } from "./renderer";
+import { code, compact, node, span } from "../native/describe";
+import type { NativeChild, NativeNode } from "../native/node";
+import {
+	diagnosticsBadge,
+	diagnosticsSection,
+	diffStatsMeta,
+	displayPath,
+	errorText,
+	fileDiffSection,
+	fileHref,
+	noteText,
+	resultText,
+} from "./native-view";
 import type { FileDiagnosticsResult } from "./lsp";
-import { renderDiff as renderDiffColored } from "../chrome/diff";
+import { nativeDiff, renderDiff as renderDiffColored } from "../chrome/diff";
 import { getLanguageFromPath } from "../lang-from-path";
 import type { Theme } from "../theme/theme";
 import type { OutputMeta } from "./output-meta";
@@ -1111,6 +1124,116 @@ export const editToolRenderer = {
 		});
 	},
 
+	describeCall(
+		args: EditRenderArgs,
+		options: RenderResultOptions & { renderContext?: EditRenderContext },
+	): NativeToolView {
+		const renderContext = options.renderContext;
+		const { rawPath, rename, op, fileCount, applyPatchError } = resolveEditCallFacts(
+			args,
+			options.isPartial,
+			renderContext?.editMode,
+		);
+		const body: NativeChild[] = [];
+		let tool: NativeToolHead;
+		const multi = renderContext?.perFileDiffPreview;
+		if (multi && multi.length > 1 && multi.some(p => p.diff || p.error)) {
+			let added = 0;
+			let removed = 0;
+			for (const preview of multi) {
+				const stats = preview.diff ? getDiffStats(preview.diff) : undefined;
+				added += stats?.added ?? 0;
+				removed += stats?.removed ?? 0;
+				body.push(
+					fileDiffSection(
+						{ path: preview.path, added: stats?.added, removed: stats?.removed },
+						[preview.error ? errorText(preview.error) : editDiff(preview.diff ?? "", preview.path)],
+						{ role: "omp.tool.edit.file", tone: preview.error ? "error" : undefined },
+					),
+				);
+			}
+			tool = editToolHead({ op, files: Math.max(fileCount, multi.length), added, removed });
+		} else {
+			let diffText: string | undefined;
+			let firstChangedLine: number | undefined;
+			if (args.previewDiff || (args.diff && args.op)) {
+				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) }));
+			} else if (renderContext?.editDiffPreview) {
+				const preview = renderContext.editDiffPreview;
+				if ("error" in preview && preview.error) body.push(errorText(preview.error));
+				else if (preview.diff) {
+					diffText = preview.diff;
+					firstChangedLine = preview.firstChangedLine;
+					body.push(editDiff(preview.diff, rawPath));
+				}
+			}
+			const stats = diffText ? getDiffStats(diffText) : undefined;
+			tool = editToolHead({
+				op,
+				path: rawPath,
+				files: fileCount,
+				line: firstChangedLine,
+				rename,
+				added: stats?.added ?? 0,
+				removed: stats?.removed ?? 0,
+			});
+		}
+		if (applyPatchError) body.push(errorText(applyPatchError));
+		return { tool, body, tone: applyPatchError ? "error" : undefined };
+	},
+
+	describeResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: EditToolDetails; isError?: boolean },
+		options: RenderResultOptions & { renderContext?: EditRenderContext },
+		args?: EditRenderArgs,
+	): NativeToolView {
+		const edits = Array.isArray(args?.edits) ? args.edits : undefined;
+		const perFileResults = result.details?.perFileResults;
+		const totalFiles = edits ? countEditFiles(edits) : 0;
+		if (perFileResults && (perFileResults.length > 1 || totalFiles > 1)) {
+			const remaining = Math.max(0, totalFiles - perFileResults.length);
+			let added = 0;
+			let removed = 0;
+			// Files are borderless sections inside the one tool frame.
+			const body: NativeChild[] = perFileResults.map(fileResult => {
+				const file = editFileParts({ content: [], details: fileResult, isError: fileResult.isError }, options);
+				added += file.added;
+				removed += file.removed;
+				return fileDiffSection(file, file.body, {
+					role: "omp.tool.edit.file",
+					tone: file.isError ? "error" : undefined,
+				});
+			});
+			if (remaining > 0) {
+				body.push(
+					node("spinner", {
+						label: [span(`${remaining} more file${remaining > 1 ? "s" : ""} pending…`, "muted")],
+					}),
+				);
+			}
+			const failed = perFileResults.some(file => file.isError);
+			return {
+				tool: editToolHead({
+					files: Math.max(totalFiles, perFileResults.length),
+					added,
+					removed,
+					diagnostics: perFileResults.map(file => file.diagnostics),
+				}),
+				body,
+				tone: failed ? "error" : undefined,
+			};
+		}
+		const file = editFileParts(result, options, args);
+		return {
+			tool: editToolHead({ ...file, href: fileHref(file.resolvedPath), diagnostics: [file.fileDiagnostics] }),
+			body: file.body,
+			tone: file.isError ? "error" : undefined,
+		};
+	},
+
 	renderResult(
 		result: { content: Array<{ type: string; text?: string }>; details?: EditToolDetails; isError?: boolean },
 		options: RenderResultOptions & { renderContext?: EditRenderContext },
@@ -1127,6 +1250,128 @@ export const editToolRenderer = {
 	},
 } satisfies ToolRenderer<EditRenderArgs, EditToolDetails>;
 
+/** Facts behind a native edit head: one file (path, first changed line, rename) or a file count. */
+interface EditHeadFacts {
+	op?: Operation;
+	path?: string;
+	/** Distinct files in the call; more than one heads the call as `N files`. */
+	files?: number;
+	line?: number;
+	href?: string;
+	rename?: string;
+	added: number;
+	removed: number;
+	diagnostics?: readonly (FileDiagnosticsResult | undefined)[];
+}
+
+/**
+ * Native edit head (§7.3): `Edit · path:line · +8 −1 · → new/path` for one
+ * file, `Edit · 3 files · +21 −4` for several; a diagnostics chip when LSP reported.
+ */
+function editToolHead(facts: EditHeadFacts): NativeToolHead {
+	const multi = (facts.files ?? 0) > 1;
+	const meta = compact([
+		diffStatsMeta(facts.added, facts.removed),
+		!multi && facts.rename ? `→ ${displayPath(facts.rename)}` : undefined,
+	]);
+	const badge = facts.diagnostics && diagnosticsBadge(facts.diagnostics);
+	const target = multi
+		? `${facts.files} files`
+		: facts.path
+			? `${displayPath(facts.path)}${facts.line ? `:${facts.line}` : ""}`
+			: undefined;
+	return {
+		title: multi ? "Edit" : getOperationTitle(facts.op),
+		target,
+		targetKind: multi ? "text" : "path",
+		href: multi ? undefined : facts.href,
+		meta: meta.length > 0 ? meta : undefined,
+		badges: badge ? [badge] : undefined,
+	};
+}
+
+/** A file's diff: hunks highlighted by the path's language, 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 });
+}
+
+/** One file's edit result for native views: head facts plus its body (diff or error, then diagnostics). */
+interface EditFileParts extends Omit<EditHeadFacts, "diagnostics"> {
+	path: string;
+	/** Absolute path the edit resolved to, when known. */
+	resolvedPath?: string;
+	isError: boolean;
+	fileDiagnostics?: FileDiagnosticsResult;
+	body: NativeChild[];
+}
+
+function editFileParts(
+	result: {
+		content: Array<{ type: string; text?: string }>;
+		details?: EditToolDetails | EditToolPerFileResult;
+		isError?: boolean;
+	},
+	options: RenderResultOptions & { renderContext?: EditRenderContext },
+	args?: EditRenderArgs,
+): EditFileParts {
+	const details = result.details;
+	const isError = result.isError ?? (details && "isError" in details ? details.isError : false) ?? false;
+	const firstEdit = Array.isArray(args?.edits) ? args.edits[0] : undefined;
+	const firstHashlineInputEntry = getHashlineInputRenderSummary(args ?? {}, options.renderContext?.editMode)
+		?.entries[0];
+	const moveSource =
+		details && "sourcePath" in details && typeof details.sourcePath === "string" ? details.sourcePath : undefined;
+	const detailPath = details && "path" in details && typeof details.path === "string" ? details.path : undefined;
+	const rawPath =
+		moveSource ??
+		(typeof args?.file_path === "string"
+			? args.file_path
+			: typeof args?.path === "string"
+				? args.path
+				: (filePathFromEditEntry(firstEdit?.path) ?? detailPath ?? firstHashlineInputEntry?.path ?? ""));
+	const op = args?.op || firstEdit?.op || details?.op;
+	const rename =
+		(typeof args?.rename === "string" ? args.rename : undefined) ??
+		filePathFromEditEntry(firstEdit?.rename) ??
+		filePathFromEditEntry(firstEdit?.move) ??
+		(details && "move" in details && typeof details.move === "string" ? details.move : undefined);
+	const editDiffPreview = details ? undefined : options.renderContext?.editDiffPreview;
+	const previewDiff = editDiffPreview && !("error" in editDiffPreview) ? editDiffPreview.diff : undefined;
+	const diffText = isError ? undefined : details?.diff || previewDiff;
+	const firstChangedLine =
+		(editDiffPreview && "firstChangedLine" in editDiffPreview ? editDiffPreview.firstChangedLine : undefined) ||
+		(details && !isError ? details.firstChangedLine : undefined);
+	const shownPath = displayPath(detailPath ?? rawPath);
+	const body: NativeChild[] = [];
+	if (isError) {
+		const displayErrorText = details && "displayErrorText" in details ? details.displayErrorText : undefined;
+		const message =
+			displayErrorText || (details && "errorText" in details && details.errorText) || resultText(result);
+		if (message) body.push(errorText(message));
+	} else if (diffText) {
+		body.push(editDiff(diffText, detailPath ?? rawPath));
+	} else if (editDiffPreview && "error" in editDiffPreview) {
+		body.push(errorText(editDiffPreview.error));
+	} else if (details && op !== "delete" && op !== "create" && !rename) {
+		body.push(noteText(`No changes were made${shownPath ? ` to ${shownPath}` : ""}.`));
+	}
+	const diagnostics = diagnosticsSection(details?.diagnostics);
+	if (diagnostics) body.push(diagnostics);
+	const stats = diffText ? getDiffStats(diffText) : undefined;
+	return {
+		op,
+		path: rawPath,
+		line: firstChangedLine,
+		rename,
+		resolvedPath: detailPath,
+		added: stats?.added ?? 0,
+		removed: stats?.removed ?? 0,
+		isError: Boolean(isError),
+		fileDiagnostics: details?.diagnostics,
+		body,
+	};
+}
+
 function renderSingleFileResult(
 	result: {
 		content: Array<{ type: string; text?: string }>;