@quandev104/pi-style 0.1.1

package/extension-src/pi-style/features/tools/boxed/shared.ts

@@ -0,0 +1,157 @@
+// Shared context/view types + common helpers for the boxed tool renderers.
+
+import type { Component } from "@earendil-works/pi-tui";
+import type { BoxTheme } from "../../../shared/box.js";
+import {
+	boxedToolWidthKey,
+	clearCompactBoxedFooter,
+	formatBoxedFooter,
+	formatBoxedFooterFromValues,
+	getTextOutput,
+	renderCompactBoxedFooter,
+	renderCompactBoxedToolCall,
+	resolveRelativePath,
+	shortenPath,
+} from "../../../shared/box.js";
+import { getStateElapsedMs, recordExecutionStarted } from "./session-config.js";
+
+/** Renderer context delivered by Pi's ToolExecutionComponent (getRenderContext). */
+export interface BoxedToolContext {
+	readonly args: Record<string, unknown>;
+	readonly toolCallId: string;
+	readonly state: Record<string, unknown>;
+	readonly cwd: string;
+	readonly executionStarted: boolean;
+	readonly argsComplete: boolean;
+	readonly isPartial: boolean;
+	readonly expanded: boolean;
+	readonly showImages: boolean;
+	readonly isError: boolean;
+	readonly lastComponent?: unknown;
+}
+
+/** Result view delivered to result renderers: { content, details }. */
+export interface BoxedToolResult {
+	readonly content?: readonly unknown[];
+	readonly details?: unknown;
+}
+
+export type BoxedCallRenderer = (
+	args: Record<string, unknown>,
+	theme: BoxTheme,
+	context: BoxedToolContext,
+) => Component;
+export type BoxedResultRenderer = (
+	result: BoxedToolResult,
+	options: { expanded: boolean; isPartial: boolean },
+	theme: BoxTheme,
+	context: BoxedToolContext,
+) => Component;
+
+export interface BoxedToolDefinition {
+	readonly call: BoxedCallRenderer;
+	readonly result: BoxedResultRenderer;
+}
+
+export function pendingFlag(context: BoxedToolContext): boolean {
+	return Boolean(context.isPartial);
+}
+
+/** Normalized display path: shortens HOME and resolves relative to the session cwd. */
+export function displayPath(rawPath: string, context: BoxedToolContext): string {
+	const path = String(rawPath ?? "");
+	if (!path) return "(unknown)";
+	return shortenPath(resolveRelativePath(path, context.cwd));
+}
+
+export function pathRangeDetail(rawPath: string, offset: unknown, limit: unknown, context: BoxedToolContext): string {
+	const path = displayPath(rawPath, context);
+	let range = "";
+	if (offset !== undefined || limit !== undefined) {
+		const start = offset ?? 1;
+		const end = limit !== undefined ? Number(start) + Number(limit) - 1 : "";
+		range = `:${start}${end ? `-${end}` : ""}`;
+	}
+	return path ? `${path}${range}` : "(unknown)";
+}
+
+/** Compact boxed call header for summary-style tools (read/write/ls/find/grep). */
+export function compactCall(
+	theme: BoxTheme,
+	toolName: string,
+	detailLine: string,
+	options: { detailKey: string; context: BoxedToolContext },
+): Component {
+	return renderCompactBoxedToolCall(theme, toolName, detailLine, {
+		widthKey: boxedToolWidthKey(toolName, options.detailKey),
+		state: options.context.state,
+		isError: Boolean(options.context.isError),
+		isPartial: Boolean(options.context.isPartial),
+		isPending: pendingFlag(options.context),
+	});
+}
+
+/** Record wall-clock start when execution begins (first render with executionStarted). */
+export function noteExecutionStart(context: BoxedToolContext): void {
+	recordExecutionStarted(context.state, context.executionStarted);
+}
+
+export function stateElapsedMs(context: BoxedToolContext): number | undefined {
+	return getStateElapsedMs(context.state);
+}
+
+/** Footer parts with state-based elapsed when result.details lacks timing. */
+export function boxedFooterWithState(
+	theme: BoxTheme,
+	result: BoxedToolResult | undefined,
+	context: BoxedToolContext,
+	extraParts: string[] = [],
+): string {
+	return formatBoxedFooterFromValues(theme, stateElapsedMs(context), getTextOutput(result), extraParts);
+}
+
+export function compactFooterWithState(
+	theme: BoxTheme,
+	result: BoxedToolResult,
+	context: BoxedToolContext,
+	options: { isError?: boolean; isPartial?: boolean } = {},
+): Component {
+	const elapsedMs = stateElapsedMs(context);
+	return renderCompactBoxedFooter(theme, result, {
+		state: context.state,
+		isError: Boolean(options.isError ?? context.isError),
+		isPartial: Boolean(options.isPartial ?? context.isPartial),
+		...(elapsedMs === undefined ? {} : { elapsedMs }),
+	});
+}
+
+export function resultFooterLines(
+	theme: BoxTheme,
+	result: BoxedToolResult,
+	context: BoxedToolContext,
+	extraParts: string[] = [],
+): string[] {
+	return [formatBoxedFooter(theme, result, extraParts, stateElapsedMs(context))];
+}
+
+export function clearFooterState(context: BoxedToolContext): void {
+	clearCompactBoxedFooter(context.state);
+}
+
+/** Result-details truncation line count when the native tool truncated output. */
+export function truncationOutputLines(result: BoxedToolResult | undefined): number | undefined {
+	if (!result) return undefined;
+	const details = result.details as { truncation?: { outputLines?: number } } | undefined;
+	const value = details?.truncation?.outputLines;
+	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+/** Result-details grep match-limit reached counter. */
+export function matchLimitReached(result: BoxedToolResult | undefined): number | undefined {
+	if (!result) return undefined;
+	const details = result.details as { matchLimitReached?: number } | undefined;
+	const value = details?.matchLimitReached;
+	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+export { boxedToolWidthKey, getTextOutput, resolveRelativePath, shortenPath };

package/extension-src/pi-style/features/tools/boxed/write.ts

@@ -0,0 +1,89 @@
+// Boxed write tool renderer
+// (renderCall/renderResult only).
+
+import { stripAnsi } from "../../../shared/ansi.js";
+import { boxedToolWidthKey, getTextOutput, renderBoxedToolResult, stripTrailingNotice } from "../../../shared/box.js";
+import {
+	type BoxedToolDefinition,
+	clearFooterState,
+	compactCall,
+	compactFooterWithState,
+	displayPath,
+	noteExecutionStart,
+	resultFooterLines,
+} from "./shared.js";
+
+function parseWriteSummary(output: string): string | undefined {
+	const normalized = stripTrailingNotice(stripAnsi(output ?? "")).trim();
+	if (!normalized) return undefined;
+
+	const byteMatch = normalized.match(/\bwrote\s+(\d+)\s+bytes?\b/i);
+	if (byteMatch) {
+		const bytes = Number(byteMatch[1]);
+		if (Number.isFinite(bytes)) {
+			return `↳ Wrote ${bytes} ${bytes === 1 ? "byte" : "bytes"}.`;
+		}
+	}
+
+	const lineMatch = normalized.match(/\bwrote\s+(\d+)\s+lines?\b/i);
+	if (lineMatch) {
+		const count = Number(lineMatch[1]);
+		if (Number.isFinite(count)) {
+			return `↳ Wrote ${count} ${count === 1 ? "line" : "lines"}.`;
+		}
+	}
+
+	return undefined;
+}
+
+export const writeTool: BoxedToolDefinition = {
+	call(args, theme, context) {
+		noteExecutionStart(context);
+		const detail = displayPath(String(args?.path ?? args?.file_path ?? ""), context);
+		return compactCall(theme, "Write", `${theme.fg("dim", "Path: ")}${detail}`, {
+			detailKey: detail,
+			context,
+		});
+	},
+	result(result, options, theme, context) {
+		clearFooterState(context);
+		const output = getTextOutput(result);
+		const detail = displayPath(String(context?.args?.path ?? context?.args?.file_path ?? ""), context);
+		const widthKey = boxedToolWidthKey("Write", detail);
+
+		if (context.isError) {
+			return renderBoxedToolResult(theme, () => [theme.fg("error", stripAnsi(output).trim() || "Error")], {
+				widthKey,
+				footerLines: resultFooterLines(theme, result, context),
+				isError: true,
+			});
+		}
+
+		if (!options.expanded) return compactFooterWithState(theme, result, context);
+
+		const content = String(context?.args?.content ?? "");
+		const lineCount = content ? content.split("\n").length : 0;
+		if (lineCount > 0) {
+			const summary = `↳ Wrote ${lineCount} ${lineCount === 1 ? "line" : "lines"}.`;
+			return renderBoxedToolResult(theme, () => [theme.fg("dim", summary)], {
+				widthKey,
+				footerLines: resultFooterLines(theme, result, context),
+			});
+		}
+
+		const summary = parseWriteSummary(output);
+		if (summary) {
+			return renderBoxedToolResult(theme, () => [theme.fg("dim", summary)], {
+				widthKey,
+				footerLines: resultFooterLines(theme, result, context),
+			});
+		}
+
+		const normalized = stripTrailingNotice(stripAnsi(output)).trim();
+		const fallback = normalized ? `↳ ${normalized}` : "↳ Wrote file.";
+		return renderBoxedToolResult(theme, () => [theme.fg("dim", fallback)], {
+			widthKey,
+			footerLines: resultFooterLines(theme, result, context),
+		});
+	},
+};