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

package/src/tools/ast-edit.ts

@@ -14,7 +14,11 @@ import {
 } from "../render/render-utils";
 import { classifyGroupedLines, groupLineIndicesByBlank } from "./grouped-file-output";
 import type { OutputMeta } from "./output-meta";
-import type { RenderResultOptions, ToolRenderer } from "./renderer";
+import type { NativeToolHead, NativeToolView, RenderResultOptions, ToolRenderer } from "./renderer";
+import { code, compact, diff, node, span, text } from "../native/describe";
+import type { NativeChild, NativeNode } from "../native/node";
+import { diffStatsMeta, displayPath, errorText, fileDiffSection, noteText, resultText, statsText } from "./native-view";
+import { getLanguageFromPath } from "../lang-from-path";
 
 /** Display metadata returned by ast-edit. */
 export interface AstEditToolDetails {
@@ -82,6 +86,86 @@ function patternPreview(pat: string | undefined): string | undefined {
 	return collapsed || undefined;
 }
 
+const AST_EDIT_HEADER_RE = /^(#+)\s+(.*)$/;
+const AST_EDIT_CHANGE_LINE_RE = /^([+\- ])\s*(\d+)(?:│|[:|])(.*)$/;
+const AST_EDIT_HEADER_SUFFIX_RE = /\s+\([^)]*\)\s*$/;
+
+/** One file's proposed rewrite: its unified diff text and change counts. */
+interface AstEditFileDiff {
+	path: string;
+	lines: string[];
+	added: number;
+	removed: number;
+	lastOld?: number;
+}
+
+/**
+ * Parse ast-edit display content (`# dir/`, `## file (N replacements)`,
+ * `-12│old` / `+12│new`) into one unified diff per file.
+ */
+function parseAstEditChanges(lines: readonly string[]): AstEditFileDiff[] {
+	const files: AstEditFileDiff[] = [];
+	const dirs: string[] = [];
+	let file: AstEditFileDiff | undefined;
+	const flush = () => {
+		if (file && file.lines.length > 0) files.push(file);
+		file = undefined;
+	};
+	for (const line of lines) {
+		const header = AST_EDIT_HEADER_RE.exec(line);
+		if (header) {
+			flush();
+			const depth = header[1]!.length;
+			const rest = header[2]!.trimEnd().replace(AST_EDIT_HEADER_SUFFIX_RE, "");
+			dirs.length = depth - 1;
+			if (rest.endsWith("/")) {
+				dirs[depth - 1] = rest.slice(0, -1);
+				continue;
+			}
+			const prefix = dirs.filter(Boolean).join("/");
+			file = { path: prefix ? `${prefix}/${rest}` : rest, lines: [], added: 0, removed: 0 };
+			continue;
+		}
+		if (!file || line.trim().length === 0) continue;
+		const change = AST_EDIT_CHANGE_LINE_RE.exec(line);
+		if (!change) continue;
+		const lineNumber = Number.parseInt(change[2]!, 10);
+		if (file.lastOld === undefined || lineNumber > file.lastOld + 1 || lineNumber < file.lastOld) {
+			file.lines.push(`@@ -${lineNumber} +${lineNumber} @@`);
+		}
+		file.lastOld = lineNumber;
+		if (change[1] === "+") file.added++;
+		else if (change[1] === "-") file.removed++;
+		file.lines.push(`${change[1]}${change[3]}`);
+	}
+	flush();
+	return files;
+}
+
+/** A file's proposed rewrite as a `diff`: highlighted by the path's language, no path header. */
+function astEditDiff(file: AstEditFileDiff): NativeNode {
+	return diff(file.lines.join("\n"), { lang: getLanguageFromPath(file.path) });
+}
+
+/** The single rewrite pattern (`target:"pattern"`), or the rewrite count, for the head. */
+function astEditPatternHead(args: AstEditRenderArgs | undefined): Pick<NativeToolHead, "target" | "targetKind"> {
+	const rewriteCount = args?.ops?.length ?? 0;
+	if (rewriteCount === 1) {
+		const pattern = patternPreview(args?.ops?.[0]?.pat);
+		return pattern ? { target: pattern, targetKind: "pattern" } : {};
+	}
+	return rewriteCount > 1 ? { target: `${rewriteCount} rewrites`, targetKind: "text" } : {};
+}
+
+/** Scope facts for the final quiet line: `in src · searched 12 files · limit reached; narrow path`. */
+function astEditScopeStats(details: AstEditToolDetails | undefined): NativeNode | undefined {
+	const parts: string[] = [];
+	if (details?.scopePath) parts.push(`in ${details.scopePath}`);
+	if (details?.filesSearched) parts.push(`searched ${formatCount("file", details.filesSearched)}`);
+	if (details?.limitReached) parts.push("limit reached; narrow path");
+	return statsText(parts);
+}
+
 /** Render AST edit calls and results. */
 export const astEditToolRenderer = {
 	inline: true,
@@ -206,5 +290,94 @@ export const astEditToolRenderer = {
 			};
 		});
 	},
+	describeCall(args: AstEditRenderArgs): NativeToolView {
+		return {
+			tool: {
+				title: "AST Edit",
+				...astEditPatternHead(args),
+				meta: args.paths?.length ? [`in ${args.paths.map(displayPath).join(", ")}`] : undefined,
+			},
+		};
+	},
+
+	describeResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: AstEditToolDetails; isError?: boolean },
+		_options: RenderResultOptions,
+		args?: AstEditRenderArgs,
+	): NativeToolView {
+		const details = result.details;
+		const patternHead = astEditPatternHead(args);
+		if (result.isError) {
+			return {
+				tool: { title: "AST Edit", ...patternHead },
+				tone: "error",
+				body: [errorText(resultText(result) || "Unknown error")],
+			};
+		}
+		const parseErrors = details?.parseErrors ?? [];
+		const parseNote: NativeChild | undefined =
+			parseErrors.length > 0
+				? node(
+						"section",
+						{
+							head: [span(formatParseErrorsCountLabel(parseErrors, details?.parseErrorsTotal), "warning")],
+							collapsible: true,
+							collapsed: true,
+						},
+						[code(parseErrors.join("\n"))],
+						"parse-errors",
+					)
+				: undefined;
+		const totalReplacements = details?.totalReplacements ?? 0;
+		if (totalReplacements === 0) {
+			return {
+				tool: { title: "AST Edit", ...patternHead, meta: ["0 replacements"] },
+				tone: "warning",
+				body: compact<NativeChild>([parseNote, astEditScopeStats(details)]),
+			};
+		}
+		const limitReached = details?.limitReached ?? false;
+		const allLines = (details?.displayContent ?? resultText(result)).split("\n");
+		const kept = groupLineIndicesByBlank(allLines)
+			.filter(indices => {
+				const first = allLines[indices[0]!]!;
+				return !first.startsWith("Safety cap reached") && !first.startsWith("Parse issues:");
+			})
+			.flatMap(indices => indices.map(index => allLines[index]!));
+		const files = parseAstEditChanges(kept);
+		const fileCount = Math.max(details?.filesTouched ?? 0, files.length);
+		let added = 0;
+		let removed = 0;
+		for (const file of files) {
+			added += file.added;
+			removed += file.removed;
+		}
+		// Same shape as edit: one file heads the call by path with a bare diff;
+		// several head it as `N files` with one borderless section per file.
+		const single = fileCount === 1 && files.length === 1 ? files[0] : undefined;
+		const changes: NativeChild[] = single
+			? [astEditDiff(single)]
+			: files.map(file => fileDiffSection(file, [astEditDiff(file)], { role: "omp.tool.ast_edit.file" }));
+		// The head names the files, so a single rewrite's pattern moves to a quiet context line.
+		const pattern = args?.ops?.length === 1 ? patternPreview(args.ops[0]?.pat) : undefined;
+		return {
+			tool: {
+				title: "AST Edit",
+				target: single ? displayPath(single.path) : formatCount("file", fileCount),
+				targetKind: single ? "path" : "text",
+				meta: compact([diffStatsMeta(added, removed), formatCount("replacement", totalReplacements)]),
+				badges: details?.applied ? undefined : [{ text: "proposed", tone: "warning" }],
+			},
+			tone: limitReached ? "warning" : undefined,
+			body: compact<NativeChild>([
+				pattern !== undefined &&
+					text([span(pattern, "code")], { lines: 1, truncate: "end", role: "omp.tool.context" }),
+				...(changes.length > 0 ? changes : [noteText(kept.join("\n"))]),
+				parseNote,
+				astEditScopeStats(details),
+			]),
+			preview: { lines: COLLAPSED_CHANGE_LIMIT },
+		};
+	},
 	mergeCallAndResult: true,
 } satisfies ToolRenderer<AstEditRenderArgs, AstEditToolDetails>;

package/src/tools/ast-grep.ts

@@ -12,9 +12,13 @@ import {
 	PREVIEW_LIMITS,
 	toPathList,
 } from "../render/render-utils";
-import { classifyGroupedLines, groupLineIndicesByBlank } from "./grouped-file-output";
+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";
 import type { OutputMeta } from "./output-meta";
-import type { RenderResultOptions, ToolRenderer } from "./renderer";
+import type { NativeToolView, RenderResultOptions, ToolRenderer } from "./renderer";
 
 /** Display metadata returned by ast-grep. */
 export interface AstGrepToolDetails {
@@ -167,5 +171,81 @@ export const astGrepToolRenderer = {
 			},
 		);
 	},
+	describeCall(args: AstGrepRenderArgs): NativeToolView {
+		const meta: string[] = [];
+		const scopePaths = toPathList(args.path ?? args.paths);
+		if (scopePaths.length) meta.push(`in ${scopePaths.join(", ")}`);
+		if (args.skip !== undefined && args.skip > 0) meta.push(`skip:${args.skip}`);
+		return { head: toolHead("AST Grep", span(args.pat ?? "?", "code"), ...meta) };
+	},
+
+	describeResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: AstGrepToolDetails; isError?: boolean },
+		_options: RenderResultOptions,
+		args?: AstGrepRenderArgs,
+	): NativeToolView {
+		const details = result.details;
+		const pattern = span(args?.pat ?? "?", "code");
+		if (result.isError) {
+			return {
+				head: toolHead("AST Grep", pattern),
+				tone: "error",
+				body: [errorText(resultText(result) || "Unknown error")],
+			};
+		}
+		const matchCount = details?.matchCount ?? 0;
+		const filesSearched = details?.filesSearched ?? 0;
+		const limitReached = details?.limitReached ?? false;
+		const parseErrors = details?.parseErrors ?? [];
+		const parseNote =
+			parseErrors.length > 0
+				? node(
+						"section",
+						{
+							head: [span(formatParseErrorsCountLabel(parseErrors, details?.parseErrorsTotal), "warning")],
+							collapsible: true,
+							collapsed: true,
+						},
+						[code(parseErrors.join("\n"))],
+						"parse-errors",
+					)
+				: undefined;
+		if (matchCount === 0) {
+			const meta = ["0 matches"];
+			if (details?.scopePath) meta.push(`in ${details.scopePath}`);
+			if (filesSearched > 0) meta.push(`searched ${filesSearched}`);
+			return {
+				head: toolHead("AST Grep", pattern, ...meta),
+				tone: "warning",
+				body: compact<NativeChild>([
+					noteText("No matches found"),
+					parseErrors.length > 0 &&
+						noteText("Query may be mis-scoped; narrow `path` before concluding absence", "warning"),
+					parseNote,
+				]),
+			};
+		}
+		const meta = [formatCount("match", matchCount), formatCount("file", details?.fileCount ?? 0)];
+		if (details?.scopePath) meta.push(`in ${details.scopePath}`);
+		meta.push(`searched ${filesSearched}`);
+		const head = toolHead("AST Grep", pattern, ...meta);
+		if (limitReached) head.push(span(" limit reached", "warning"));
+		const allLines = (details?.displayContent ?? resultText(result)).split("\n");
+		const kept = groupLineIndicesByBlank(allLines)
+			.filter(indices => {
+				const first = allLines[indices[0]!]!;
+				return !first.startsWith("Result limit reached") && !first.startsWith("Parse issues:");
+			})
+			.flatMap(indices => [...indices.map(index => allLines[index]!), ""]);
+		return {
+			head,
+			body: compact<NativeChild>([
+				...describeGroupedOutput(kept, { lang: getLanguageFromPath }),
+				limitReached && noteText("limit reached; narrow path or increase limit", "warning"),
+				parseNote,
+			]),
+			preview: { lines: COLLAPSED_MATCH_LIMIT },
+		};
+	},
 	mergeCallAndResult: true,
 } satisfies ToolRenderer<AstGrepRenderArgs, AstGrepToolDetails>;

package/src/tools/autoresearch.ts

@@ -1,7 +1,13 @@
 import { Text } from "../components/text";
 import type { Theme } from "../theme/theme";
 import { replaceTabs, truncateToWidth, shortenPath } from "../render/render-utils";
-import type { ToolRenderer } from "./renderer";
+import type { TspTone } from "@oh-my-pi/pi-wire";
+import { ansi, compact, kv, node, row, span, text } from "../native/describe";
+import type { NativeNode } from "../native/node";
+import { OwnerMemo } from "../native/memo";
+import { plainText } from "../native/spans";
+import { errorView, resultText, toolHead } from "./native-view";
+import type { NativeToolView, ToolRenderer, ToolRenderResult } from "./renderer";
 import type { TruncationResult } from "./streaming-output";
 
 /** Whether a lower or higher metric is better. */
@@ -155,6 +161,35 @@ export interface InitExperimentDetails {
 	baselineCommit: string | null;
 }
 
+/** Tone of an experiment disposition: kept succeeds, discarded warns, the rest fail. */
+function experimentTone(status: ExperimentStatus): TspTone {
+	return status === "keep" ? "success" : status === "discard" ? "warning" : "error";
+}
+
+/** Plain first line of a free-form argument, for single-line heads. */
+function firstLine(value: string | undefined): string {
+	return (
+		plainText(value ?? "")
+			.trim()
+			.split("\n")[0] ?? ""
+	);
+}
+
+/** Result text as a wrapped body, or an error card. */
+function describeTextResult(
+	title: string,
+	result: ToolRenderResult<unknown>,
+	style?: string,
+): NativeToolView | undefined {
+	const output = resultText(result);
+	if (result.isError) return errorView(title, output);
+	const body = plainText(output).trimEnd();
+	return body ? { body: [text(style ? [span(body, style)] : body, { wrap: "word" })] } : undefined;
+}
+
+const logResultMemo = new OwnerMemo<NativeToolView | undefined>();
+const runResultMemo = new OwnerMemo<NativeToolView | undefined>();
+
 function renderInitCall(name: string, theme: Theme): string {
 	return `${theme.fg("toolTitle", theme.bold("init_experiment"))} ${theme.fg("accent", truncateToWidth(replaceTabs(name), 100))}`;
 }
@@ -168,8 +203,42 @@ export const initExperimentToolRenderer = {
 		const text = replaceTabs(result.content.find(part => part.type === "text")?.text ?? "");
 		return new Text(text, 0, 0);
 	},
+	describeCall(args): NativeToolView {
+		return { head: toolHead("init_experiment", span(firstLine(args.name), "accent")) };
+	},
+	describeResult(result): NativeToolView | undefined {
+		return describeTextResult("init_experiment", result);
+	},
 } satisfies ToolRenderer<{ name: string }, InitExperimentDetails>;
 
+/** Native log summary: disposition badge, description, and metric/baseline grid. */
+function describeSummary(details: LogDetails): NativeToolView {
+	const { experiment, state } = details;
+	const tone = experimentTone(experiment.status);
+	const deviations = details.scopeDeviations.length;
+	return {
+		tone,
+		body: compact([
+			row(
+				[
+					node("badge", { text: experiment.status.toUpperCase(), tone }),
+					text([span(plainText(experiment.description), "muted")], { wrap: "word", grow: 1 }),
+				],
+				{ gap: "sm" },
+			),
+			kv([
+				[plainText(state.metricName), [span(formatNum(experiment.metric, state.metricUnit), "accent num")]],
+				[
+					"baseline",
+					state.bestMetric !== null ? [span(formatNum(state.bestMetric, state.metricUnit), "num")] : undefined,
+				],
+				["confidence", state.confidence !== null ? [span(`${state.confidence.toFixed(1)}x`, "num")] : undefined],
+				["deviations", deviations > 0 ? [span(String(deviations), "warning")] : undefined],
+			]),
+		]),
+	};
+}
+
 function renderSummary(details: LogDetails, theme: Theme): string {
 	const { experiment, state } = details;
 	const color = experiment.status === "keep" ? "success" : experiment.status === "discard" ? "warning" : "error";
@@ -205,8 +274,46 @@ export const logExperimentToolRenderer = {
 		}
 		return new Text(renderSummary(details, theme), 0, 0);
 	},
+	describeCall(args): NativeToolView {
+		return {
+			head: toolHead(
+				"log_experiment",
+				args.status ? span(args.status, experimentTone(args.status)) : undefined,
+				span(firstLine(args.description), "muted"),
+			),
+		};
+	},
+	describeResult(result): NativeToolView | undefined {
+		return logResultMemo.get(result, [], () => {
+			const details = result.details;
+			if (result.isError || !details) return describeTextResult("log_experiment", result);
+			return describeSummary(details);
+		});
+	},
 } satisfies ToolRenderer<{ status: ExperimentStatus; description: string }, LogDetails>;
 
+/** Native run status: TIMEOUT/FAIL/PASS badge with duration and primary metric. */
+function describeStatus(details: RunDetails): { tone: TspTone; node: NativeNode } {
+	const duration = `${details.durationSeconds.toFixed(1)}s`;
+	let tone: TspTone = "success";
+	let label = "PASS";
+	let meta = duration;
+	if (details.timedOut) {
+		tone = "error";
+		label = "TIMEOUT";
+	} else if (details.exitCode !== 0) {
+		tone = "error";
+		label = "FAIL";
+		meta = `exit=${details.exitCode} ${duration}`;
+	} else if (details.parsedPrimary !== null) {
+		meta = `${duration} ${plainText(details.metricName)}=${formatNum(details.parsedPrimary, details.metricUnit)}`;
+	}
+	return {
+		tone,
+		node: row([node("badge", { text: label, tone }), text([span(meta, tone)], { truncate: "end" })], { gap: "sm" }),
+	};
+}
+
 function renderStatus(details: RunDetails, theme: Theme): string {
 	if (details.timedOut) {
 		return theme.fg("error", `TIMEOUT ${details.durationSeconds.toFixed(1)}s`);
@@ -263,6 +370,40 @@ export const runExperimentToolRenderer = {
 				: "";
 		return new Text(preview ? `${statusText}\n${theme.fg("dim", preview)}${suffix}` : statusText, 0, 0);
 	},
+	describeCall(): NativeToolView {
+		return { head: toolHead("run_experiment", span(DEFAULT_HARNESS_COMMAND, "muted")) };
+	},
+	describeResult(result): NativeToolView | undefined {
+		return runResultMemo.get(result, [], () => {
+			const details = result.details;
+			if (isProgressDetails(details)) {
+				const output = resultText(result);
+				return {
+					tone: "warning",
+					preview: { lines: 6 },
+					body: compact([
+						node("spinner", { label: [span(`Running ${plainText(details.elapsed)}…`, "warning")] }),
+						output.trim() ? ansi(output, { follow: true }) : undefined,
+					]),
+				};
+			}
+			if (result.isError || !details || !isRunDetails(details)) return describeTextResult("run_experiment", result);
+			const status = describeStatus(details);
+			return {
+				tone: status.tone,
+				preview: { lines: 6 },
+				body: compact([
+					status.node,
+					details.tailOutput.trim() ? ansi(details.tailOutput, { follow: true }) : undefined,
+					details.truncation && details.fullOutputPath
+						? text([span("Full output: ", "warning"), span(shortenPath(details.fullOutputPath), "path")], {
+								truncate: "middle",
+							})
+						: undefined,
+				]),
+			};
+		});
+	},
 } satisfies ToolRenderer<unknown, RunDetails | RunExperimentProgressDetails>;
 
 /** Persisted experiment notes after an update. */
@@ -284,4 +425,11 @@ export const updateNotesToolRenderer = {
 		const text = replaceTabs(result.content.find(part => part.type === "text")?.text ?? "");
 		return new Text(theme.fg("muted", text), 0, 0);
 	},
+	describeCall(args): NativeToolView {
+		const preview = args.append_idea ?? args.body?.slice(0, 100);
+		return { head: toolHead("update_notes", span(firstLine(preview), "muted")) };
+	},
+	describeResult(result): NativeToolView | undefined {
+		return describeTextResult("update_notes", result, "muted");
+	},
 } satisfies ToolRenderer<{ body: string; append_idea?: string }, UpdateNotesDetails>;