@oh-my-pi/pi-tui 18.2.3 → 18.2.5

package/src/tools/ast-grep.ts

@@ -0,0 +1,171 @@
+import type { Component } from "../tui";
+import { Text } from "../components/text";
+import type { Theme } from "../theme/theme";
+import { Ellipsis, fileHyperlink, renderStatusLine, renderTreeList, truncateToWidth } from "../render";
+import {
+	appendParseErrorsBulletList,
+	createCachedComponent,
+	formatCount,
+	formatEmptyMessage,
+	formatErrorMessage,
+	formatParseErrorsCountLabel,
+	PREVIEW_LIMITS,
+	toPathList,
+} from "../render/render-utils";
+import { classifyGroupedLines, groupLineIndicesByBlank } from "./grouped-file-output";
+import type { OutputMeta } from "./output-meta";
+import type { RenderResultOptions, ToolRenderer } from "./renderer";
+
+/** Display metadata returned by ast-grep. */
+export interface AstGrepToolDetails {
+	matchCount: number;
+	fileCount: number;
+	filesSearched: number;
+	limitReached: boolean;
+	parseErrors?: string[];
+	/** Total parse error count before {@link PARSE_ERRORS_LIMIT} capping. Omitted when no errors. */
+	parseErrorsTotal?: number;
+	scopePath?: string;
+	files?: string[];
+	fileMatches?: Array<{ path: string; count: number }>;
+	meta?: OutputMeta;
+	/** Pre-formatted text for the user-visible TUI render. Mirrors `result.text` lines but uses
+	 * a `│` gutter and `*` to mark match lines. The TUI uses this directly so it never parses model-facing text. */
+	displayContent?: string;
+	/** Absolute base directory used during search. Used by the renderer to resolve
+	 * display-relative paths to absolute paths for OSC 8 hyperlinks. */
+	searchPath?: string;
+	/** Session cwd at search time. Display header/match paths are cwd-relative, so
+	 * the renderer resolves them against this; `searchPath` is the scope target. */
+	cwd?: string;
+}
+
+interface AstGrepRenderArgs {
+	pat?: string;
+	path?: string | string[];
+	/** Legacy pre-`path` argument name; kept so historical transcripts still render a scope. */
+	paths?: string[];
+	skip?: number;
+}
+
+const COLLAPSED_MATCH_LIMIT = PREVIEW_LIMITS.COLLAPSED_LINES * 2;
+
+/** Render AST grep calls and results. */
+export const astGrepToolRenderer = {
+	inline: true,
+	renderCall(args: AstGrepRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
+		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}`);
+
+		const description = args.pat ?? "?";
+		const text = renderStatusLine({ icon: "pending", title: "AST Grep", description, meta }, uiTheme);
+		return new Text(text, 0, 0);
+	},
+
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: AstGrepToolDetails; isError?: boolean },
+		options: RenderResultOptions,
+		uiTheme: Theme,
+		args?: AstGrepRenderArgs,
+	): Component {
+		const details = result.details;
+
+		if (result.isError) {
+			const errorText = result.content?.find(c => c.type === "text")?.text || "Unknown error";
+			return new Text(formatErrorMessage(errorText, uiTheme), 0, 0);
+		}
+
+		const matchCount = details?.matchCount ?? 0;
+		const fileCount = details?.fileCount ?? 0;
+		const filesSearched = details?.filesSearched ?? 0;
+		const limitReached = details?.limitReached ?? false;
+
+		if (matchCount === 0) {
+			const description = args?.pat;
+			const meta = ["0 matches"];
+			if (details?.scopePath) meta.push(`in ${details.scopePath}`);
+			if (filesSearched > 0) meta.push(`searched ${filesSearched}`);
+			const header = renderStatusLine({ icon: "warning", title: "AST Grep", description, meta }, uiTheme);
+			const lines = [header, formatEmptyMessage("No matches found", uiTheme)];
+			if (details?.parseErrors?.length) {
+				lines.push(uiTheme.fg("warning", "Query may be mis-scoped; narrow `path` before concluding absence"));
+				appendParseErrorsBulletList(lines, details.parseErrors, uiTheme, details.parseErrorsTotal);
+			}
+			return new Text(lines.join("\n"), 0, 0);
+		}
+
+		const summaryParts = [formatCount("match", matchCount), formatCount("file", fileCount)];
+		const meta = [...summaryParts];
+		if (details?.scopePath) meta.push(`in ${details.scopePath}`);
+		meta.push(`searched ${filesSearched}`);
+		if (limitReached) meta.push(uiTheme.fg("warning", "limit reached"));
+		const description = args?.pat;
+		const header = renderStatusLine(
+			{
+				...(limitReached
+					? { icon: "warning" as const }
+					: { iconOverride: uiTheme.fg("accent", uiTheme.symbol("icon.search")) }),
+				title: "AST Grep",
+				description,
+				meta,
+			},
+			uiTheme,
+		);
+
+		const textContent = result.details?.displayContent ?? result.content?.find(c => c.type === "text")?.text ?? "";
+		const allLines = textContent.split("\n");
+		// Resolve hyperlinks over the whole output so nested directory headers
+		// reconstruct across the blank-line groups the tree list collapses by.
+		const contexts = classifyGroupedLines(allLines, details?.cwd ?? details?.searchPath, details?.searchPath);
+		const styledLines = allLines.map((line, index) => {
+			const ctx = contexts[index]!;
+			if (ctx.kind === "dir") {
+				const styled = uiTheme.fg("accent", line);
+				return ctx.headerPath ? fileHyperlink(ctx.headerPath, styled) : styled;
+			}
+			if (ctx.kind === "file") {
+				const styled = uiTheme.fg(ctx.depth === 1 ? "accent" : "dim", line);
+				return ctx.headerPath ? fileHyperlink(ctx.headerPath, styled) : styled;
+			}
+			if (line.startsWith("  meta:")) return uiTheme.fg("dim", line);
+			return uiTheme.fg("toolOutput", line);
+		});
+		const matchGroups = groupLineIndicesByBlank(allLines)
+			.filter(indices => {
+				const first = allLines[indices[0]!]!;
+				return !first.startsWith("Result limit reached") && !first.startsWith("Parse issues:");
+			})
+			.map(indices => indices.map(index => styledLines[index]!));
+
+		const extraLines: string[] = [];
+		if (limitReached) {
+			extraLines.push(uiTheme.fg("warning", "limit reached; narrow path or increase limit"));
+		}
+		if (details?.parseErrors?.length) {
+			extraLines.push(
+				uiTheme.fg("warning", formatParseErrorsCountLabel(details.parseErrors, details.parseErrorsTotal)),
+			);
+		}
+
+		return createCachedComponent(
+			() => options.expanded,
+			width => {
+				const matchLines = renderTreeList(
+					{
+						items: matchGroups,
+						expanded: options.expanded,
+						maxCollapsed: matchGroups.length,
+						maxCollapsedLines: COLLAPSED_MATCH_LIMIT,
+						itemType: "match",
+						renderItem: group => group,
+					},
+					uiTheme,
+				);
+				return [header, ...matchLines, ...extraLines].map(l => truncateToWidth(l, width, Ellipsis.Omit));
+			},
+		);
+	},
+	mergeCallAndResult: true,
+} satisfies ToolRenderer<AstGrepRenderArgs, AstGrepToolDetails>;

package/src/tools/autoresearch.ts

@@ -0,0 +1,287 @@
+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 { TruncationResult } from "./streaming-output";
+
+/** Whether a lower or higher metric is better. */
+export type MetricDirection = "lower" | "higher";
+
+/** Disposition of a completed experiment. */
+export type ExperimentStatus = "keep" | "discard" | "crash" | "checks_failed";
+
+/** JSON-compatible additional structured experiment information. */
+export type ASIValue = string | number | boolean | null | ASIValue[] | { [key: string]: ASIValue };
+
+/** Named structured experiment observations. */
+export interface ASIData {
+	[key: string]: ASIValue;
+}
+
+/** Numeric metrics indexed by name. */
+export interface NumericMetricMap {
+	[key: string]: number;
+}
+
+/** Name and unit of an experiment metric. */
+export interface MetricDef {
+	name: string;
+	unit: string;
+}
+
+/** Recorded metric and disposition of an experiment run. */
+export interface ExperimentResult {
+	runNumber: number | null;
+	commit: string;
+	metric: number;
+	metrics: NumericMetricMap;
+	status: ExperimentStatus;
+	description: string;
+	timestamp: number;
+	segment: number;
+	confidence: number | null;
+	asi?: ASIData;
+	modifiedPaths: string[];
+	scopeDeviations: string[];
+	justification: string | null;
+	flagged: boolean;
+	flaggedReason: string | null;
+}
+
+/** Current experiment baseline, history, and scope. */
+export interface ExperimentState {
+	results: ExperimentResult[];
+	bestMetric: number | null;
+	bestDirection: MetricDirection;
+	metricName: string;
+	metricUnit: string;
+	secondaryMetrics: MetricDef[];
+	name: string | null;
+	goal: string | null;
+	currentSegment: number;
+	maxExperiments: number | null;
+	confidence: number | null;
+	scopePaths: string[];
+	offLimits: string[];
+	constraints: string[];
+	notes: string;
+	branch: string | null;
+	baselineCommit: string | null;
+	sessionId: number | null;
+}
+
+/** Live elapsed time and output metadata of a benchmark. */
+export interface RunExperimentProgressDetails {
+	phase: "running";
+	elapsed: string;
+	truncation?: TruncationResult;
+	fullOutputPath?: string;
+	runDirectory?: string;
+}
+
+/** Completed benchmark measurements, status, and output. */
+export interface RunDetails {
+	runNumber: number;
+	runDirectory: string;
+	benchmarkLogPath: string;
+	command: string;
+	exitCode: number | null;
+	durationSeconds: number;
+	passed: boolean;
+	crashed: boolean;
+	timedOut: boolean;
+	tailOutput: string;
+	parsedMetrics: NumericMetricMap | null;
+	parsedPrimary: number | null;
+	parsedAsi: ASIData | null;
+	metricName: string;
+	metricUnit: string;
+	preRunDirtyPaths: string[];
+	abandonedPriorRun: number | null;
+	truncation?: TruncationResult;
+	fullOutputPath?: string;
+}
+
+/** Logged experiment result and updated baseline state. */
+export interface LogDetails {
+	experiment: ExperimentResult;
+	state: ExperimentState;
+	wallClockSeconds: number | null;
+	scopeDeviations: string[];
+	justification: string | null;
+	flaggedRuns: Array<{ runId: number; reason: string }>;
+}
+
+/** Format an integer with comma-separated digit groups. */
+export function commas(value: number): string {
+	const sign = value < 0 ? "-" : "";
+	const digits = String(Math.trunc(Math.abs(value)));
+	const groups: string[] = [];
+	for (let index = digits.length; index > 0; index -= 3) {
+		groups.unshift(digits.slice(Math.max(0, index - 3), index));
+	}
+	return sign + groups.join(",");
+}
+
+/** Format a number with grouped digits and optional decimals. */
+export function fmtNum(value: number, decimals: number = 0): string {
+	if (decimals <= 0) return commas(Math.round(value));
+	const absolute = Math.abs(value);
+	const whole = Math.floor(absolute);
+	const fraction = (absolute - whole).toFixed(decimals).slice(1);
+	return `${value < 0 ? "-" : ""}${commas(whole)}${fraction}`;
+}
+
+/** Format an optional metric value with its unit. */
+export function formatNum(value: number | null, unit: string): string {
+	if (value === null) return "-";
+	if (Number.isInteger(value)) return `${fmtNum(value)}${unit}`;
+	return `${fmtNum(value, 2)}${unit}`;
+}
+
+/** Filename of the benchmark harness. */
+export const HARNESS_FILENAME = "autoresearch.sh";
+
+/** Default command that executes the benchmark harness. */
+export const DEFAULT_HARNESS_COMMAND = `bash ${HARNESS_FILENAME}`;
+
+/** Initialization outcome and experiment state. */
+export interface InitExperimentDetails {
+	state: ExperimentState;
+	createdSession: boolean;
+	bumpedSegment: boolean;
+	abandonedRuns: number;
+	harnessCommitted: boolean;
+	baselineCommit: string | null;
+}
+
+function renderInitCall(name: string, theme: Theme): string {
+	return `${theme.fg("toolTitle", theme.bold("init_experiment"))} ${theme.fg("accent", truncateToWidth(replaceTabs(name), 100))}`;
+}
+
+/** Render init-experiment tool calls and results. */
+export const initExperimentToolRenderer = {
+	renderCall(args, _options, theme): Text {
+		return new Text(renderInitCall(args.name, theme), 0, 0);
+	},
+	renderResult(result): Text {
+		const text = replaceTabs(result.content.find(part => part.type === "text")?.text ?? "");
+		return new Text(text, 0, 0);
+	},
+} satisfies ToolRenderer<{ name: string }, InitExperimentDetails>;
+
+function renderSummary(details: LogDetails, theme: Theme): string {
+	const { experiment, state } = details;
+	const color = experiment.status === "keep" ? "success" : experiment.status === "discard" ? "warning" : "error";
+	let summary = `${theme.fg(color, experiment.status.toUpperCase())} ${theme.fg("muted", truncateToWidth(replaceTabs(experiment.description), 100))}`;
+	summary += ` ${theme.fg("accent", `${state.metricName}=${formatNum(experiment.metric, state.metricUnit)}`)}`;
+	if (state.bestMetric !== null) {
+		summary += ` ${theme.fg("dim", `baseline ${formatNum(state.bestMetric, state.metricUnit)}`)}`;
+	}
+	if (state.confidence !== null) {
+		summary += ` ${theme.fg("dim", `conf ${state.confidence.toFixed(1)}x`)}`;
+	}
+	if (details.scopeDeviations.length > 0) {
+		summary += ` ${theme.fg("warning", `deviations:${details.scopeDeviations.length}`)}`;
+	}
+	return summary;
+}
+
+/** Render log-experiment tool calls and results. */
+export const logExperimentToolRenderer = {
+	renderCall(args, _options, theme): Text {
+		const color = args.status === "keep" ? "success" : args.status === "discard" ? "warning" : "error";
+		const description = truncateToWidth(replaceTabs(args.description), 100);
+		return new Text(
+			`${theme.fg("toolTitle", theme.bold("log_experiment"))} ${theme.fg(color, args.status)} ${theme.fg("muted", description)}`,
+			0,
+			0,
+		);
+	},
+	renderResult(result, _options, theme): Text {
+		const details = result.details;
+		if (!details) {
+			return new Text(replaceTabs(result.content.find(part => part.type === "text")?.text ?? ""), 0, 0);
+		}
+		return new Text(renderSummary(details, theme), 0, 0);
+	},
+} satisfies ToolRenderer<{ status: ExperimentStatus; description: string }, LogDetails>;
+
+function renderStatus(details: RunDetails, theme: Theme): string {
+	if (details.timedOut) {
+		return theme.fg("error", `TIMEOUT ${details.durationSeconds.toFixed(1)}s`);
+	}
+	if (details.exitCode !== 0) {
+		return theme.fg("error", `FAIL exit=${details.exitCode} ${details.durationSeconds.toFixed(1)}s`);
+	}
+	const metric =
+		details.parsedPrimary !== null
+			? ` ${details.metricName}=${formatNum(details.parsedPrimary, details.metricUnit)}`
+			: "";
+	return theme.fg("success", `PASS ${details.durationSeconds.toFixed(1)}s${metric}`);
+}
+
+function isRunDetails(value: unknown): value is RunDetails {
+	if (typeof value !== "object" || value === null) return false;
+	return "command" in value && "durationSeconds" in value;
+}
+
+function isProgressDetails(value: unknown): value is RunExperimentProgressDetails {
+	if (typeof value !== "object" || value === null) return false;
+	return "phase" in value && (value as { phase: unknown }).phase === "running";
+}
+
+/** Render run-experiment tool calls and results. */
+export const runExperimentToolRenderer = {
+	renderCall(_args, _options, theme): Text {
+		return new Text(
+			`${theme.fg("toolTitle", theme.bold("run_experiment"))} ${theme.fg("muted", DEFAULT_HARNESS_COMMAND)}`,
+			0,
+			0,
+		);
+	},
+	renderResult(result, options, theme): Text {
+		if (isProgressDetails(result.details)) {
+			const header = theme.fg("warning", `Running ${result.details.elapsed}...`);
+			const preview = replaceTabs(result.content.find(part => part.type === "text")?.text ?? "");
+			return new Text(preview ? `${header}\n${theme.fg("dim", preview)}` : header, 0, 0);
+		}
+		const details = result.details;
+		if (!details || !isRunDetails(details)) {
+			return new Text(replaceTabs(result.content.find(part => part.type === "text")?.text ?? ""), 0, 0);
+		}
+		const statusText = renderStatus(details, theme);
+		if (!options.expanded && details.tailOutput.trim().length === 0) {
+			return new Text(statusText, 0, 0);
+		}
+		const preview = replaceTabs(
+			options.expanded ? details.tailOutput : details.tailOutput.split("\n").slice(-5).join("\n"),
+		);
+		const suffix =
+			options.expanded && details.truncation && details.fullOutputPath
+				? `\n${theme.fg("warning", `Full output: ${shortenPath(details.fullOutputPath)}`)}`
+				: "";
+		return new Text(preview ? `${statusText}\n${theme.fg("dim", preview)}${suffix}` : statusText, 0, 0);
+	},
+} satisfies ToolRenderer<unknown, RunDetails | RunExperimentProgressDetails>;
+
+/** Persisted experiment notes after an update. */
+export interface UpdateNotesDetails {
+	notes: string;
+}
+
+/** Render update-notes tool calls and results. */
+export const updateNotesToolRenderer = {
+	renderCall(args, _options, theme): Text {
+		const preview = args.append_idea ?? args.body.slice(0, 100);
+		return new Text(
+			`${theme.fg("toolTitle", theme.bold("update_notes"))} ${theme.fg("muted", truncateToWidth(replaceTabs(preview), 100))}`,
+			0,
+			0,
+		);
+	},
+	renderResult(result, _options, theme: Theme): Text {
+		const text = replaceTabs(result.content.find(part => part.type === "text")?.text ?? "");
+		return new Text(theme.fg("muted", text), 0, 0);
+	},
+} satisfies ToolRenderer<{ body: string; append_idea?: string }, UpdateNotesDetails>;