@sayknow-cli/coding-agent 0.3.16 → 0.4.0

package/src/modes/components/tool-transcript-format.ts

@@ -0,0 +1,393 @@
+import { wrapTextWithAnsi } from "@sayknow-cli/tui";
+import { sanitizeText } from "@sayknow-cli/utils";
+import { renderJsonTreeLines } from "../../tools/json-tree";
+import { renderStatusLine } from "../../tui";
+import type { Theme } from "../theme/theme";
+import { validateDisplayLine } from "./ansi-display-validator";
+import { renderDiff } from "./diff";
+
+export const MAX_TOOL_ARGS_CHARS = 500;
+export const TOOL_RESULT_MAX_EXPANDED_LINES = 100;
+export const INPUT_MAX_SOURCE_BYTES = 1_048_576;
+export const INPUT_MAX_SOURCE_LINES = 50_000;
+export const INPUT_MAX_SCALAR_LEN = 8_192;
+export const INPUT_MAX_JSON_DEPTH = 32;
+export const INPUT_MAX_JSON_NODES = 20_000;
+
+export type ToolDisplaySections = {
+	callLines: string[];
+	statusLines: string[];
+	resultText: string;
+};
+
+/**
+ * Produces final, terminal-safe rich display lines for an expanded tool entry.
+ * It owns validation, width-aware wrapping, and the result-only visible cap.
+ */
+export function renderToolDisplayLines(
+	descriptor: ToolTranscriptRenderDescriptor,
+	contentWidth: number,
+	theme: Theme,
+): string[] {
+	const bounded =
+		descriptor.inputTruncated || exceedsInputBudget(descriptor) ? truncatedDescriptor(descriptor) : descriptor;
+	const sections = bounded.inputTruncated ? truncatedPlainSections(bounded) : richSections(bounded, theme);
+	const wrap = (lines: string[]) =>
+		balanceWrappedSgr(lines.flatMap(line => wrapTextWithAnsi(validateDisplayLine(line), Math.max(1, contentWidth))));
+	const result = cappedResultLines(sections.resultText);
+	const resultLines = wrap(result.lines);
+	const shown = resultLines.slice(0, TOOL_RESULT_MAX_EXPANDED_LINES);
+	if (result.omittedLineCount > 0) shown.push(`... ${result.omittedLineCount} more lines`);
+	else if (resultLines.length > TOOL_RESULT_MAX_EXPANDED_LINES)
+		shown.push(`... ${resultLines.length - TOOL_RESULT_MAX_EXPANDED_LINES} more lines`);
+	return [...wrap(sections.callLines), ...wrap(sections.statusLines), ...shown];
+}
+
+function truncatedPlainSections(descriptor: ToolTranscriptRenderDescriptor): ToolDisplaySections {
+	return {
+		callLines: [descriptor.name, ...composeToolCall(descriptor).split("\n").filter(Boolean)],
+		statusLines: [!descriptor.hasResult ? "⏳ pending" : descriptor.isError ? "✗ Error" : "✓ done"],
+		resultText: `... input truncated for rendering (press r for raw)\n${boundedPlainResult(descriptor.resultContent)}`,
+	};
+}
+
+function truncatedDescriptor(descriptor: ToolTranscriptRenderDescriptor): ToolTranscriptRenderDescriptor {
+	return {
+		...descriptor,
+		name: descriptor.name.slice(0, 256),
+		args: exceedsStructuredInputBudget(descriptor.args) ? {} : descriptor.args,
+		intent: exceedsScalarInputBudget(descriptor.intent) ? undefined : descriptor.intent,
+		resultContent: boundedPlainResult(descriptor.resultContent),
+		details: undefined,
+		detailsData: undefined,
+		inputTruncated: true,
+	};
+}
+
+function balanceWrappedSgr(lines: string[]): string[] {
+	let active: string[] = [];
+	return lines.map(line => {
+		const prefix = active.join("");
+		const matches = [...line.matchAll(/\x1b\[([0-9;]*)m/g)];
+		for (const match of matches) {
+			if (
+				match[1]!
+					.split(";")
+					.some(parameter => ["0", "22", "23", "24", "25", "27", "28", "29", "39", "49"].includes(parameter))
+			)
+				active = [];
+			else active = [match[0]];
+		}
+		const last = matches.at(-1);
+		return `${prefix}${line}${prefix || (last && !last[1]!.split(";").includes("0")) ? "\x1b[0m" : ""}`;
+	});
+}
+
+function plainSections(descriptor: ToolTranscriptRenderDescriptor, theme: Theme): ToolDisplaySections {
+	return {
+		callLines: [theme.fg("accent", descriptor.name), ...composeToolCall(descriptor).split("\n").filter(Boolean)],
+		statusLines: [statusLine(descriptor, theme)],
+		resultText: boundedPlainResult(descriptor.resultContent),
+	};
+}
+
+function richSections(descriptor: ToolTranscriptRenderDescriptor, theme: Theme): ToolDisplaySections {
+	const sections = plainSections(descriptor, theme);
+	const diff = extractDiff(descriptor.detailsData) ?? descriptor.details;
+	if ((descriptor.name === "edit" || descriptor.name === "write" || descriptor.name === "apply_patch") && diff) {
+		sections.resultText = renderDiff(diff, { filePath: extractPath(descriptor.detailsData) });
+	} else if (descriptor.detailsData && typeof descriptor.detailsData === "object") {
+		sections.resultText = renderJsonTreeLines(
+			descriptor.detailsData,
+			theme,
+			INPUT_MAX_JSON_DEPTH,
+			TOOL_RESULT_MAX_EXPANDED_LINES * 2,
+			INPUT_MAX_SCALAR_LEN,
+		).lines.join("\n");
+	}
+	return sections;
+}
+
+function statusLine(descriptor: ToolTranscriptRenderDescriptor, theme: Theme): string {
+	const status = !descriptor.hasResult
+		? "⏳ pending"
+		: descriptor.isError
+			? `✗ ${descriptor.resultContent.split("\n", 1)[0]?.trim() || "Error"}`
+			: "✓ done";
+	return renderStatusLine(
+		{ title: status, titleColor: descriptor.isError ? "error" : descriptor.hasResult ? "success" : "warning" },
+		theme,
+	);
+}
+
+function boundedPlainResult(text: string): string {
+	const boundedBytes =
+		Buffer.byteLength(text) > INPUT_MAX_SOURCE_BYTES
+			? Buffer.from(text).subarray(0, INPUT_MAX_SOURCE_BYTES).toString()
+			: text;
+	let end = boundedBytes.length;
+	let lineCount = 1;
+	for (let index = 0; index < boundedBytes.length; index++) {
+		if (boundedBytes[index] !== "\n") continue;
+		if (lineCount === INPUT_MAX_SOURCE_LINES) {
+			end = index;
+			break;
+		}
+		lineCount += 1;
+	}
+	return boundedBytes.slice(0, end);
+}
+
+function cappedResultLines(result: string): { lines: string[]; omittedLineCount: number } {
+	let lineCount = 1;
+	let prefixEnd = result.length;
+	for (let index = 0; index < result.length; index++) {
+		if (result[index] !== "\n") continue;
+		if (lineCount === TOOL_RESULT_MAX_EXPANDED_LINES) prefixEnd = index;
+		lineCount += 1;
+	}
+	return {
+		lines: result.slice(0, prefixEnd).split("\n"),
+		omittedLineCount: Math.max(0, lineCount - TOOL_RESULT_MAX_EXPANDED_LINES),
+	};
+}
+
+function extractDiff(value: unknown): string | undefined {
+	if (!value || typeof value !== "object") return undefined;
+	const record = value as Record<string, unknown>;
+	if (typeof record.diff === "string") return record.diff;
+	if (Array.isArray(record.perFileResults))
+		return record.perFileResults
+			.map(item =>
+				item && typeof item === "object" && typeof (item as Record<string, unknown>).diff === "string"
+					? (item as Record<string, unknown>).diff
+					: "",
+			)
+			.filter(Boolean)
+			.join("\n");
+	return undefined;
+}
+
+function extractPath(value: unknown): string | undefined {
+	if (!value || typeof value !== "object") return undefined;
+	const record = value as Record<string, unknown>;
+	return typeof record.path === "string" ? record.path : undefined;
+}
+
+/**
+ * Field-specific input budgets:
+ * - resultContent is bounded by total bytes and lines.
+ * - args and detailsData are bounded by cumulative bytes, per-scalar length, depth, and nodes.
+ * - intent and details are bounded by per-scalar length.
+ */
+function exceedsInputBudget(descriptor: ToolTranscriptRenderDescriptor): boolean {
+	return (
+		exceedsResultContentBudget(descriptor.resultContent) ||
+		exceedsStructuredInputBudget(descriptor.args) ||
+		exceedsScalarInputBudget(descriptor.intent) ||
+		exceedsScalarInputBudget(descriptor.details) ||
+		exceedsStructuredInputBudget(descriptor.detailsData)
+	);
+}
+
+function exceedsResultContentBudget(value: string): boolean {
+	return Buffer.byteLength(value) > INPUT_MAX_SOURCE_BYTES || value.split("\n").length - 1 > INPUT_MAX_SOURCE_LINES;
+}
+
+function exceedsScalarInputBudget(value: unknown): boolean {
+	return typeof value === "string" && value.length > INPUT_MAX_SCALAR_LEN;
+}
+
+function exceedsStructuredInputBudget(value: unknown): boolean {
+	let nodes = 0;
+	let bytes = 0;
+	let exceeded = false;
+	const visit = (item: unknown, depth: number): void => {
+		if (exceeded) return;
+		nodes++;
+		if (nodes > INPUT_MAX_JSON_NODES || depth > INPUT_MAX_JSON_DEPTH) {
+			exceeded = true;
+			return;
+		}
+		if (typeof item === "string") {
+			bytes += Buffer.byteLength(item);
+			if (item.length > INPUT_MAX_SCALAR_LEN || bytes > INPUT_MAX_SOURCE_BYTES) exceeded = true;
+			return;
+		}
+		if (Array.isArray(item)) for (const child of item) visit(child, depth + 1);
+		else if (item && typeof item === "object") for (const child of Object.values(item)) visit(child, depth + 1);
+	};
+	visit(value, 0);
+	return exceeded;
+}
+
+export type ToolTranscriptRenderDescriptor = Readonly<{
+	name: string;
+	args: Record<string, unknown>;
+	intent?: string;
+	resultContent: string;
+	details?: string;
+	detailsData?: unknown;
+	isError: boolean;
+	isPartial: boolean;
+	hasResult: boolean;
+	inputTruncated: boolean;
+}>;
+
+export type BuildToolTranscriptEntryInput = {
+	canonicalPayload: import("../transcript-item-registry").TranscriptSourcePayload;
+	renderDescriptor: ToolTranscriptRenderDescriptor;
+	capabilities: import("../transcript-item-registry").TranscriptItemCapabilities;
+	identity: { id: string; label: string; display?: "full" };
+};
+
+/**
+ * Shared tool projection for the main transcript and session observer.
+ * `payload` is canonical/copyable source; display is derived only from the
+ * sanitized, frozen descriptor. The observer's whole-entry 100-line cap and
+ * the main view's tool-only result cap intentionally remain surface-specific.
+ */
+export function buildToolTranscriptEntry(
+	input: BuildToolTranscriptEntryInput,
+): import("./transcript-viewer-overlay").TranscriptViewerEntry {
+	const { canonicalPayload: payload, renderDescriptor, capabilities, identity } = input;
+	const fields: ToolTranscriptFields = {
+		name: renderDescriptor.name,
+		args: renderDescriptor.args,
+		intent: renderDescriptor.intent,
+		resultText: renderDescriptor.resultContent,
+		isError: renderDescriptor.isError,
+		hasResult: renderDescriptor.hasResult,
+	};
+	return {
+		id: identity.id,
+		kind: "tool",
+		label: identity.label,
+		payload,
+		renderDescriptor,
+		...capabilities,
+		richRenderEligible: identity.display !== "full",
+		getDisplayText: expanded =>
+			identity.display === "full" ? composeToolText(fields) : toolDisplayText(fields, expanded),
+	};
+}
+
+/** Sanitizes and freezes all display-only values before tool formatting. */
+export function createToolTranscriptRenderDescriptor(input: {
+	name: unknown;
+	args: unknown;
+	intent?: unknown;
+	resultContent: unknown;
+	details?: unknown;
+	detailsData?: unknown;
+	isError?: unknown;
+	isPartial?: unknown;
+	hasResult?: unknown;
+	inputTruncated?: unknown;
+}): ToolTranscriptRenderDescriptor {
+	const argsTruncated = exceedsStructuredInputBudget(input.args);
+	const detailsDataTruncated = exceedsStructuredInputBudget(input.detailsData);
+	return freezeDisplayValue({
+		name: sanitizeString(input.name),
+		args: argsTruncated ? {} : ((sanitizeDisplayValue(input.args) ?? {}) as Record<string, unknown>),
+		intent: typeof input.intent === "string" ? sanitizeString(input.intent) : undefined,
+		resultContent: sanitizeString(input.resultContent),
+		details: typeof input.details === "string" ? sanitizeString(input.details) : undefined,
+		detailsData: detailsDataTruncated ? undefined : sanitizeDisplayValue(input.detailsData),
+		isError: Boolean(input.isError),
+		isPartial: Boolean(input.isPartial),
+		hasResult: Boolean(input.hasResult),
+		inputTruncated: Boolean(input.inputTruncated) || argsTruncated || detailsDataTruncated,
+	});
+}
+
+function sanitizeString(value: unknown): string {
+	return typeof value === "string" ? sanitizeText(value) : "";
+}
+
+function sanitizeDisplayValue(value: unknown): unknown {
+	if (typeof value === "string") return sanitizeText(value);
+	if (Array.isArray(value)) return value.map(sanitizeDisplayValue);
+	if (!value || typeof value !== "object") return value;
+	return Object.fromEntries(
+		Object.entries(value).map(([key, item]) => [sanitizeText(key), sanitizeDisplayValue(item)]),
+	);
+}
+
+function freezeDisplayValue<T>(value: T): T {
+	if (value && typeof value === "object") {
+		for (const item of Object.values(value)) freezeDisplayValue(item);
+		Object.freeze(value);
+	}
+	return value;
+}
+
+type ToolCallFields = {
+	name: string;
+	args: Record<string, unknown>;
+	intent?: string;
+};
+
+type ToolResultFields = {
+	resultText: string;
+	isError: boolean;
+	hasResult: boolean;
+};
+
+export type ToolTranscriptFields = ToolCallFields & ToolResultFields;
+
+export function formatToolArgs(name: string, args: Record<string, unknown>): string {
+	if (name === "read" || name === "write" || name === "edit") return args.path ? `path: ${args.path}` : "";
+	if (name === "bash") return typeof args.command === "string" ? args.command.replaceAll("\t", "    ") : "";
+	if (name === "search")
+		return [
+			args.pattern ? `pattern: ${args.pattern}` : "",
+			Array.isArray(args.paths) ? `paths: ${args.paths.join(", ")}` : "",
+		]
+			.filter(Boolean)
+			.join(", ");
+	return Object.entries(args)
+		.filter(([key]) => !key.startsWith("_"))
+		.map(([key, value]) => `${key}: ${typeof value === "string" ? value : JSON.stringify(value)}`)
+		.join(", ")
+		.slice(0, MAX_TOOL_ARGS_CHARS);
+}
+
+export function composeToolCall({ name, args, intent }: ToolCallFields): string {
+	return [formatToolArgs(name, args), intent].filter(Boolean).join("\n");
+}
+
+export function composeToolResult({ resultText, isError, hasResult }: ToolResultFields): string {
+	const text = resultText.trim();
+	if (!hasResult) return "⏳ pending";
+	if (isError) return `✗ ${text || "Error"}`;
+	return text || "✓ done";
+}
+
+export function composeToolText(fields: ToolTranscriptFields): string {
+	return [composeToolCall(fields), composeToolResult(fields)].filter(Boolean).join("\n");
+}
+
+/**
+ * Caps result output without allocating an array for every source line. The final
+ * line count still requires scanning the result so the omitted-line count is exact.
+ */
+function expandedToolResult(result: string): string {
+	let lineCount = 1;
+	let prefixEnd = result.length;
+	for (let index = 0; index < result.length; index++) {
+		if (result[index] !== "\n") continue;
+		if (lineCount === TOOL_RESULT_MAX_EXPANDED_LINES) prefixEnd = index;
+		lineCount += 1;
+	}
+	const prefix = result.slice(0, prefixEnd);
+	return lineCount > TOOL_RESULT_MAX_EXPANDED_LINES
+		? `${prefix}\n... ${lineCount - TOOL_RESULT_MAX_EXPANDED_LINES} more lines`
+		: prefix;
+}
+
+export function toolDisplayText(fields: ToolTranscriptFields, expanded: boolean): string {
+	const call = composeToolCall(fields);
+	if (!expanded) return call;
+	return [call, expandedToolResult(composeToolResult(fields))].filter(Boolean).join("\n");
+}