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

package/src/tools/debug.ts

@@ -0,0 +1,167 @@
+import type { Component } from "../tui";
+import { Text } from "../components/text";
+import type { Theme } from "../theme/theme";
+import { renderStatusLine } from "../render/status-line";
+import { framedToolCard } from "../render/tool-card";
+import {
+	formatExpandHint,
+	formatStatusIcon,
+	PREVIEW_LIMITS,
+	replaceTabs,
+	TRUNCATE_LENGTHS,
+	truncateToWidth,
+} from "../render/render-utils";
+import type { RenderResultOptions, ToolRenderer } from "./renderer";
+
+/** Display fields captured from a debugger session. */
+export interface DebugSessionSnapshot {
+	id: string;
+	adapter: string;
+	status: string;
+	cwd: string;
+	program?: string;
+	stopReason?: string;
+	frameName?: string;
+	instructionPointerReference?: string;
+	source?: { path?: string };
+	line?: number;
+	column?: number;
+	needsConfigurationDone: boolean;
+	exitCode?: number;
+}
+
+/** Debug execution metadata consumed by the transcript. */
+export interface DebugToolDetails {
+	action: string;
+	success: boolean;
+	snapshot?: DebugSessionSnapshot;
+}
+
+/** Debug arguments used to describe a pending request. */
+export interface DebugRenderArgs {
+	action?: string;
+	program?: string;
+	file?: string;
+	line?: number;
+	function?: string;
+	expression?: string;
+	command?: string;
+	memory_reference?: string;
+	instruction_reference?: string;
+	data_id?: string;
+	name?: string;
+}
+
+/** Formats a debugger stop location as a source path and coordinates. */
+export function formatLocation(snapshot: DebugSessionSnapshot | undefined): string | null {
+	if (!snapshot?.source?.path || snapshot.line === undefined) {
+		return null;
+	}
+	return `${snapshot.source.path}:${snapshot.line}${snapshot.column !== undefined ? `:${snapshot.column}` : ""}`;
+}
+
+/** Formats the debugger session snapshot for model and terminal output. */
+export function formatSessionSnapshot(snapshot: DebugSessionSnapshot): string[] {
+	const lines = [
+		`Session ${snapshot.id}`,
+		`Adapter: ${snapshot.adapter}`,
+		`Status: ${snapshot.status}`,
+		`CWD: ${snapshot.cwd}`,
+	];
+	if (snapshot.program) lines.push(`Program: ${snapshot.program}`);
+	if (snapshot.stopReason) lines.push(`Stop reason: ${snapshot.stopReason}`);
+	if (snapshot.frameName) lines.push(`Frame: ${snapshot.frameName}`);
+	if (snapshot.instructionPointerReference) {
+		lines.push(`Instruction pointer: ${snapshot.instructionPointerReference}`);
+	}
+	const location = formatLocation(snapshot);
+	if (location) lines.push(`Location: ${location}`);
+	if (snapshot.needsConfigurationDone) {
+		lines.push("Configuration: pending configurationDone; set breakpoints, then continue.");
+	}
+	if (snapshot.exitCode !== undefined) lines.push(`Exit code: ${snapshot.exitCode}`);
+	return lines;
+}
+
+function summarizeDebugCall(args: DebugRenderArgs): string {
+	const action = args.action ? args.action.replaceAll("_", " ") : "request";
+	if (args.program) {
+		return `${action} ${truncateToWidth(args.program, TRUNCATE_LENGTHS.TITLE)}`;
+	}
+	if (args.file && args.line !== undefined) {
+		return `${action} ${truncateToWidth(`${args.file}:${args.line}`, TRUNCATE_LENGTHS.TITLE)}`;
+	}
+	if (args.function) {
+		return `${action} ${truncateToWidth(args.function, TRUNCATE_LENGTHS.TITLE)}`;
+	}
+	if (args.expression) {
+		return `${action} ${truncateToWidth(args.expression, TRUNCATE_LENGTHS.TITLE)}`;
+	}
+	if (args.command) {
+		return `${action} ${truncateToWidth(args.command, TRUNCATE_LENGTHS.TITLE)}`;
+	}
+	if (args.memory_reference) {
+		return `${action} ${truncateToWidth(args.memory_reference, TRUNCATE_LENGTHS.TITLE)}`;
+	}
+	if (args.instruction_reference) {
+		return `${action} ${truncateToWidth(args.instruction_reference, TRUNCATE_LENGTHS.TITLE)}`;
+	}
+	if (args.data_id) {
+		return `${action} ${truncateToWidth(args.data_id, TRUNCATE_LENGTHS.TITLE)}`;
+	}
+	if (args.name) {
+		return `${action} ${truncateToWidth(args.name, TRUNCATE_LENGTHS.TITLE)}`;
+	}
+	return action;
+}
+
+/** Renders debugger calls and captured execution snapshots. */
+export const debugToolRenderer = {
+	animatedPartialResult: true,
+	renderCall(args: DebugRenderArgs, _options: RenderResultOptions, theme: Theme): Component {
+		const text = renderStatusLine({ icon: "pending", title: "Debug", description: summarizeDebugCall(args) }, theme);
+		return new Text(text, 0, 0);
+	},
+
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: DebugToolDetails; isError?: boolean },
+		options: RenderResultOptions,
+		theme: Theme,
+		args?: DebugRenderArgs,
+	): Component {
+		return framedToolCard(theme, () => {
+			const action = (args?.action ?? result.details?.action ?? "debug").replaceAll("_", " ");
+			const success = !options.isPartial && !result.isError;
+			const statusIcon = success
+				? theme.styledSymbol("tool.debug", "accent")
+				: formatStatusIcon(options.isPartial ? "running" : "error", theme, options.spinnerFrame);
+			const header = `${statusIcon} Debug ${action}`;
+			const summaryLines = result.details?.snapshot
+				? formatSessionSnapshot(result.details.snapshot).map(line => replaceTabs(line))
+				: [];
+			const text = result.content.find(block => block.type === "text")?.text ?? "No output";
+			const rawLines = replaceTabs(text).split("\n");
+			const previewLimit = options.expanded ? PREVIEW_LIMITS.EXPANDED_LINES : PREVIEW_LIMITS.COLLAPSED_LINES;
+			const displayedLines = rawLines
+				.slice(0, previewLimit)
+				.map(line => truncateToWidth(line, TRUNCATE_LENGTHS.LINE));
+			const remaining = rawLines.length - displayedLines.length;
+			if (remaining > 0) {
+				displayedLines.push(
+					theme.fg("muted", `… ${remaining} more lines ${formatExpandHint(theme, options.expanded, true)}`),
+				);
+			}
+			return {
+				header,
+				phase: options.isPartial ? "partial" : result.isError ? "error" : "success",
+				sections: [
+					...(summaryLines.length > 0 ? [{ label: theme.fg("toolTitle", "Session"), content: summaryLines }] : []),
+					{ label: theme.fg("toolTitle", "Output"), content: displayedLines },
+				],
+				applyBg: false,
+			};
+		});
+	},
+	mergeCallAndResult: true,
+	inline: true,
+} satisfies ToolRenderer<DebugRenderArgs, DebugToolDetails>;

package/src/tools/default-renderer.ts

@@ -0,0 +1,172 @@
+import type { Component } from "../index";
+import { isRecord } from "@oh-my-pi/pi-utils";
+import type { RenderResultOptions } from "./renderer";
+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 {
+	formatArgsInline,
+	JSON_TREE_MAX_DEPTH_COLLAPSED,
+	JSON_TREE_MAX_DEPTH_EXPANDED,
+	JSON_TREE_MAX_LINES_COLLAPSED,
+	JSON_TREE_MAX_LINES_EXPANDED,
+	JSON_TREE_SCALAR_LEN_COLLAPSED,
+	JSON_TREE_SCALAR_LEN_EXPANDED,
+	renderJsonTreeLines,
+} from "./json-tree";
+import { formatExpandHint } from "../render/render-utils";
+
+/** Inputs rendered by the fallback card used when a tool has no bespoke renderer. */
+export interface DefaultToolRenderInput {
+	/** Human-readable tool label. */
+	label: string;
+	/** Tool arguments, shown inline when collapsed and as a tree when expanded. */
+	args: unknown;
+	/** Settled or streaming result; omitted while only the call is available. */
+	result?: {
+		output: string;
+		isError?: boolean;
+		/** Synthetic placeholder for a call skipped mid-batch to service steering/peer
+		 * input — the tool never ran, so it renders neutral (info) rather than as an error. */
+		skipped?: boolean;
+	};
+	/** Current expansion and lifecycle state. */
+	options: RenderResultOptions;
+}
+
+/** Header/body assembly shared by the string and Component APIs. */
+interface DefaultToolSnapshot {
+	status: StatusLineOptions;
+	phase: ToolCardPhase;
+	body: readonly string[];
+}
+
+/** Compute the single header/body assembly behind both default-tool entry points. */
+function buildDefaultToolSnapshot(
+	input: DefaultToolRenderInput,
+	uiTheme: Theme,
+	contentWidth: number,
+): DefaultToolSnapshot {
+	const { options, result } = input;
+	const status: StatusLineOptions = {
+		icon: options.isPartial
+			? options.spinnerFrame !== undefined
+				? "running"
+				: "pending"
+			: result?.skipped
+				? "info"
+				: result?.isError
+					? "error"
+					: "done",
+		spinnerFrame: options.spinnerFrame,
+		title: input.label,
+	};
+	if (result?.skipped) status.titleColor = "muted";
+	const phase: ToolCardPhase = options.isPartial
+		? options.spinnerFrame !== undefined
+			? "running"
+			: "partial"
+		: result?.skipped
+			? "info"
+			: result?.isError
+				? "error"
+				: "success";
+
+	const body: string[] = [];
+	const args = isRecord(input.args) ? input.args : undefined;
+	if (!options.expanded && args && Object.keys(args).length > 0) {
+		const inlineBudget = Math.max(20, contentWidth - Bun.stringWidth(uiTheme.tree.last) - 2);
+		const preview = formatArgsInline(args, inlineBudget);
+		if (preview) {
+			body.push(` ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("dim", preview)}`);
+		}
+	}
+
+	if (options.expanded && input.args !== undefined) {
+		body.push("");
+		body.push(uiTheme.fg("dim", "Args"));
+		const tree = renderJsonTreeLines(
+			input.args,
+			uiTheme,
+			JSON_TREE_MAX_DEPTH_EXPANDED,
+			JSON_TREE_MAX_LINES_EXPANDED,
+			JSON_TREE_SCALAR_LEN_EXPANDED,
+		);
+		body.push(...tree.lines);
+		if (tree.truncated) {
+			body.push(uiTheme.fg("dim", "…"));
+		}
+		body.push("");
+	}
+
+	if (result) {
+		const textContent = result.output.trimEnd();
+		if (!textContent) {
+			body.push(uiTheme.fg("dim", "(no output)"));
+		} else {
+			let renderedAsJson = false;
+			if (textContent.startsWith("{") || textContent.startsWith("[")) {
+				try {
+					const parsed = JSON.parse(textContent);
+					const maxDepth = options.expanded ? JSON_TREE_MAX_DEPTH_EXPANDED : JSON_TREE_MAX_DEPTH_COLLAPSED;
+					const maxLines = options.expanded ? JSON_TREE_MAX_LINES_EXPANDED : JSON_TREE_MAX_LINES_COLLAPSED;
+					const maxScalarLen = options.expanded ? JSON_TREE_SCALAR_LEN_EXPANDED : JSON_TREE_SCALAR_LEN_COLLAPSED;
+					const tree = renderJsonTreeLines(parsed, uiTheme, maxDepth, maxLines, maxScalarLen);
+
+					if (tree.lines.length > 0) {
+						body.push(...tree.lines);
+						if (!options.expanded) {
+							body.push(formatExpandHint(uiTheme, options.expanded, true));
+						} else if (tree.truncated) {
+							body.push(uiTheme.fg("dim", "…"));
+						}
+						renderedAsJson = true;
+					}
+				} catch {
+					// Non-JSON output that starts with a bracket is rendered as plain text.
+				}
+			}
+			if (!renderedAsJson) {
+				body.push(
+					...formatOutputPaneLines(
+						{
+							lines: textContent.split("\n"),
+							expanded: options.expanded,
+							collapsedMaxLines: 4,
+							expandedMaxLines: 12,
+							styleLine: line => truncateToWidth(styleToolOutputLine(line, uiTheme), contentWidth),
+							showExpandHintWhenUncapped: true,
+						},
+						uiTheme,
+					).lines,
+				);
+			}
+		}
+	}
+
+	return { status, phase, body };
+}
+
+/** Format one generic tool call/result card at the available content width. */
+export function formatDefaultToolExecution(
+	input: DefaultToolRenderInput,
+	contentWidth: number,
+	uiTheme: Theme,
+): string {
+	const snapshot = buildDefaultToolSnapshot(input, uiTheme, contentWidth);
+	return [renderStatusLine(snapshot.status, uiTheme), ...snapshot.body].join("\n");
+}
+
+/** Render the generic fallback as the state-tinted card used by direct custom tools. */
+export function renderDefaultToolExecution(input: DefaultToolRenderInput, uiTheme: Theme): Component {
+	return plainToolCard(
+		uiTheme,
+		({ contentWidth }) => {
+			const snapshot = buildDefaultToolSnapshot(input, uiTheme, contentWidth);
+			return { status: snapshot.status, phase: snapshot.phase, body: snapshot.body };
+		},
+		{ paddingX: 1, paddingY: 1, ignoreTight: true },
+	);
+}