@xynogen/pix-pretty 1.2.0 → 1.3.0

package/src/tools/read.ts

@@ -0,0 +1,177 @@
+import type {
+	AgentToolUpdateCallback,
+	ExtensionContext,
+	ReadToolInput,
+} from "@earendil-works/pi-coding-agent";
+
+import { FG_DIM, RST } from "../ansi.js";
+import { MAX_PREVIEW_LINES } from "../config.js";
+import { fileIcon } from "../icons.js";
+import { renderFileContent } from "../renderers.js";
+import type {
+	PiPrettyApi,
+	ReadParams,
+	RenderContextLike,
+	ThemeLike,
+	ToolFactory,
+	ToolResultLike,
+} from "../types.js";
+import {
+	fillToolBackground,
+	getTextContent,
+	humanSize,
+	isImageContent,
+	isTextContent,
+	normalizeLineEndings,
+	renderToolError,
+	setResultDetails,
+} from "../utils.js";
+import type { ToolContext } from "./context.js";
+
+export function registerReadTool(
+	pi: PiPrettyApi,
+	createReadTool: ToolFactory<ReadToolInput>,
+	ctx: ToolContext,
+): void {
+	const { cwd, sp, TextComponent } = ctx;
+	const origRead = createReadTool(cwd);
+
+	pi.registerTool({
+		...origRead,
+		name: "read",
+
+		async execute(
+			tid: string,
+			params: ReadParams,
+			sig: AbortSignal | undefined,
+			upd: AgentToolUpdateCallback<unknown> | undefined,
+			toolCtx: ExtensionContext,
+		) {
+			const result = (await origRead.execute(
+				tid,
+				params,
+				sig,
+				upd,
+				toolCtx,
+			)) as ToolResultLike;
+
+			const fp = params.path ?? "";
+			const offset = params.offset ?? 1;
+
+			const imageBlock = result.content?.find(isImageContent);
+			if (imageBlock) {
+				setResultDetails(result, {
+					_type: "readImage",
+					filePath: fp,
+					data: imageBlock.data,
+					mimeType: imageBlock.mimeType ?? "image/png",
+				});
+				return result;
+			}
+
+			const textContent = getTextContent(result);
+			if (textContent && fp) {
+				const normalizedContent = normalizeLineEndings(textContent);
+				const lineCount = normalizedContent.split("\n").length;
+				setResultDetails(result, {
+					_type: "readFile",
+					filePath: fp,
+					content: normalizedContent,
+					offset,
+					lineCount,
+				});
+			}
+
+			return result;
+		},
+
+		renderCall(
+			args: ReadParams,
+			theme: ThemeLike,
+			renderCtx: RenderContextLike,
+		) {
+			const fp = args.path ?? "";
+			const text = renderCtx.lastComponent ?? new TextComponent("", 0, 0);
+			const offset = args.offset
+				? ` ${theme.fg("muted", `from line ${args.offset}`)}`
+				: "";
+			const limit = args.limit
+				? ` ${theme.fg("muted", `(${args.limit} lines)`)}`
+				: "";
+			text.setText(
+				fillToolBackground(
+					`${theme.fg("toolTitle", theme.bold("read"))} ${theme.fg("accent", sp(fp))}${offset}${limit}`,
+				),
+			);
+			return text;
+		},
+
+		renderResult(
+			result: ToolResultLike,
+			_opt: unknown,
+			theme: ThemeLike,
+			renderCtx: RenderContextLike,
+		) {
+			const text = renderCtx.lastComponent ?? new TextComponent("", 0, 0);
+
+			if (renderCtx.isError) {
+				text.setText(renderToolError(getTextContent(result) || "Error", theme));
+				return text;
+			}
+
+			const d = result.details as Record<string, unknown> | undefined;
+
+			if (d?._type === "readImage") {
+				const byteSize = Math.ceil(((d.data as string).length * 3) / 4);
+				text.setText(
+					fillToolBackground(
+						`  ${fileIcon(d.filePath as string)}${FG_DIM}${d.mimeType ?? "image"} · ${humanSize(byteSize)}${RST}`,
+					),
+				);
+				return text;
+			}
+
+			if (d?._type === "readFile" && d.content) {
+				const key = `read:${d.filePath}:${d.offset}:${d.lineCount}:${process.stdout.columns ?? 80}`;
+				if (renderCtx.state._rk !== key) {
+					renderCtx.state._rk = key;
+					const info = `${FG_DIM}${d.lineCount} lines${RST}`;
+					renderCtx.state._rt = fillToolBackground(`  ${info}`);
+
+					const maxShow = renderCtx.expanded
+						? (d.lineCount as number)
+						: MAX_PREVIEW_LINES;
+					renderFileContent(
+						d.content as string,
+						d.filePath as string,
+						d.offset as number,
+						maxShow,
+					)
+						.then((rendered: string) => {
+							if (renderCtx.state._rk !== key) return;
+							renderCtx.state._rt = fillToolBackground(
+								`  ${info}\n${rendered}`,
+							);
+							renderCtx.invalidate();
+						})
+						.catch(() => {});
+				}
+				text.setText(
+					renderCtx.state._rt ??
+						fillToolBackground(`  ${FG_DIM}${d.lineCount} lines${RST}`),
+				);
+				return text;
+			}
+
+			const fallback = result.content?.[0];
+			const fallbackText =
+				fallback && isTextContent(fallback) ? fallback.text : "read";
+			text.setText(
+				fillToolBackground(
+					`  ${theme.fg("dim", String(fallbackText).slice(0, 120))}`,
+				),
+			);
+			return text;
+		},
+	});
+}

package/src/tools/write.ts

@@ -0,0 +1,231 @@
+import { existsSync, readFileSync } from "node:fs";
+import type {
+	AgentToolUpdateCallback,
+	ExtensionContext,
+	ToolRenderResultOptions,
+	WriteToolInput,
+} from "@earendil-works/pi-coding-agent";
+
+import { MAX_RENDER_LINES } from "../config.js";
+import { parseDiff } from "../diff.js";
+import {
+	diffThemeCacheKey,
+	renderSplit,
+	resolveDiffColors,
+	summarize,
+} from "../diff-render.js";
+import { hlBlock } from "../highlight.js";
+import { lang } from "../lang.js";
+import type {
+	PiPrettyApi,
+	RenderContextLike,
+	ThemeLike,
+	ToolFactory,
+	ToolResultLike,
+	WriteParams,
+	WriteRenderState,
+} from "../types.js";
+import {
+	fillToolBackground,
+	getTextContent,
+	isTextContent,
+	renderToolError,
+	setResultDetails,
+	termW,
+} from "../utils.js";
+import type { ToolContext } from "./context.js";
+
+export function registerWriteTool(
+	pi: PiPrettyApi,
+	createWriteTool: ToolFactory<WriteToolInput>,
+	ctx: ToolContext,
+	trackInvalidator: (id: string, inv: () => void) => void,
+): void {
+	const { cwd, sp, TextComponent } = ctx;
+	const origWrite = createWriteTool(cwd);
+
+	pi.registerTool({
+		...origWrite,
+		name: "write",
+
+		async execute(
+			tid: string,
+			params: WriteParams,
+			sig: AbortSignal | undefined,
+			upd: AgentToolUpdateCallback<unknown> | undefined,
+			toolCtx: ExtensionContext,
+		) {
+			const fp = params.path ?? params.file_path ?? "";
+			let old: string | null = null;
+			try {
+				if (fp && existsSync(fp)) old = readFileSync(fp, "utf-8");
+			} catch {
+				old = null;
+			}
+
+			const result = (await origWrite.execute(
+				tid,
+				params as unknown as Parameters<typeof origWrite.execute>[1],
+				sig,
+				upd,
+				toolCtx,
+			)) as ToolResultLike;
+			const content = params.content ?? "";
+
+			if (old !== null && old !== content) {
+				const diff = parseDiff(old, content);
+				setResultDetails(result, {
+					_type: "diff",
+					summary: summarize(diff.added, diff.removed),
+					oldContent: old,
+					newContent: content,
+					language: lang(fp),
+				});
+			} else if (old === null) {
+				setResultDetails(result, {
+					_type: "new",
+					lines: content ? content.split("\n").length : 0,
+					content,
+					filePath: fp,
+				});
+			} else {
+				setResultDetails(result, { _type: "noChange" });
+			}
+			return result;
+		},
+
+		renderCall(
+			args: WriteParams,
+			theme: ThemeLike,
+			renderCtx: RenderContextLike<WriteRenderState>,
+		) {
+			const fp = args?.path ?? args?.file_path ?? "";
+			const isNew = !fp || !existsSync(fp);
+			const label = isNew ? "create" : "write";
+			const text = renderCtx.lastComponent ?? new TextComponent("", 0, 0);
+			const hdr = `${theme.fg("toolTitle", theme.bold(label))} ${theme.fg("accent", sp(fp))}`;
+
+			if (args?.content && isNew) {
+				const previewKey = `create:${diffThemeCacheKey(theme)}:${fp}:${String(args.content).length}`;
+				if (renderCtx.state._previewKey !== previewKey) {
+					renderCtx.state._previewKey = previewKey;
+					renderCtx.state._previewText = hdr;
+					const lg = lang(fp);
+					hlBlock(String(args.content), lg)
+						.then((lines) => {
+							if (renderCtx.state._previewKey !== previewKey) return;
+							const maxShow = renderCtx.expanded ? lines.length : 16;
+							const preview = lines.slice(0, maxShow).join("\n");
+							const rem = lines.length - maxShow;
+							let out = `${hdr}\n\n${preview}`;
+							if (rem > 0)
+								out += `\n${theme.fg("muted", `… (${rem} more lines, ${lines.length} total)`)}`;
+							renderCtx.state._previewText = out;
+							renderCtx.invalidate();
+						})
+						.catch(() => {});
+				}
+				text.setText(renderCtx.state._previewText ?? hdr);
+				return text;
+			}
+
+			text.setText(fillToolBackground(hdr));
+			return text;
+		},
+
+		renderResult(
+			result: ToolResultLike,
+			_opt: ToolRenderResultOptions,
+			theme: ThemeLike,
+			renderCtx: RenderContextLike<WriteRenderState>,
+		) {
+			const text = renderCtx.lastComponent ?? new TextComponent("", 0, 0);
+			if (renderCtx.isError) {
+				text.setText(renderToolError(getTextContent(result) || "Error", theme));
+				return text;
+			}
+			const d = result.details as Record<string, unknown> | undefined;
+
+			if (d?._type === "diff") {
+				const key = `wd:${diffThemeCacheKey(theme)}:${termW()}:${d.summary}:${(d.newContent as string).length}:${d.language ?? ""}`;
+				if (renderCtx.toolCallId)
+					trackInvalidator(renderCtx.toolCallId, renderCtx.invalidate);
+				if (renderCtx.state._wdk !== key) {
+					renderCtx.state._wdk = key;
+					renderCtx.state._wdt = `  ${d.summary}\n${theme.fg("muted", "  rendering diff…")}`;
+					const dc = resolveDiffColors(theme);
+					const diff = parseDiff(
+						d.oldContent as string,
+						d.newContent as string,
+					);
+					renderSplit(
+						diff,
+						d.language as string | undefined,
+						MAX_RENDER_LINES,
+						dc,
+					)
+						.then((rendered) => {
+							if (renderCtx.state._wdk !== key) return;
+							renderCtx.state._wdt = `  ${d.summary}\n${rendered}`;
+							renderCtx.invalidate();
+						})
+						.catch(() => {
+							if (renderCtx.state._wdk !== key) return;
+							renderCtx.state._wdt = `  ${d.summary}`;
+							renderCtx.invalidate();
+						});
+				}
+				text.setText(renderCtx.state._wdt ?? `  ${d.summary}`);
+				return text;
+			}
+
+			if (d?._type === "noChange") {
+				text.setText(
+					fillToolBackground(`  ${theme.fg("muted", "✓ no changes")}`),
+				);
+				return text;
+			}
+
+			if (d?._type === "new") {
+				const {
+					lines: lineCount,
+					content: rawContent,
+					filePath: fp,
+				} = d as { lines: number; content: string; filePath: string };
+				const base = `  ${theme.fg("success", `✓ new file (${lineCount} lines)`)}`;
+				const pk = `nf:${diffThemeCacheKey(theme)}:${fp}:${lineCount}`;
+				if (renderCtx.state._nfk !== pk) {
+					renderCtx.state._nfk = pk;
+					renderCtx.state._nft = base;
+					if (rawContent) {
+						hlBlock(rawContent, lang(fp))
+							.then((hlLines) => {
+								if (renderCtx.state._nfk !== pk) return;
+								const maxShow = renderCtx.expanded ? hlLines.length : 12;
+								const preview = hlLines.slice(0, maxShow).join("\n");
+								const rem = hlLines.length - maxShow;
+								let out = `${base}\n${preview}`;
+								if (rem > 0)
+									out += `\n${theme.fg("muted", `  … ${rem} more lines`)}`;
+								renderCtx.state._nft = out;
+								renderCtx.invalidate();
+							})
+							.catch(() => {});
+					}
+				}
+				text.setText(renderCtx.state._nft ?? base);
+				return text;
+			}
+
+			const fallback = result.content?.[0];
+			const fallbackText =
+				fallback && isTextContent(fallback) ? fallback.text : "written";
+			text.setText(
+				fillToolBackground(
+					`  ${theme.fg("dim", String(fallbackText).slice(0, 120))}`,
+				),
+			);
+			return text;
+		},
+	});
+}

package/src/tsconfig.json

@@ -7,7 +7,7 @@
 		"esModuleInterop": true,
 		"skipLibCheck": true,
 		"noEmit": true,
-		"types": ["node"],
+		"types": ["node", "bun"],
 		"allowImportingTsExtensions": true
 	},
 	"include": ["*.ts", "*.d.ts", "../_types/**/*.d.ts"]

package/src/types.ts

@@ -98,6 +98,8 @@ export type RenderContextLike<
 	expanded: boolean;
 	isError: boolean;
 	invalidate: () => void;
+	/** Stable id for this tool execution — used to key resize invalidators. */
+	toolCallId?: string;
 };
 
 type SessionContextLike = ExtensionContext;
@@ -211,7 +213,12 @@ export type MultiGrepParams = {
 
 export type GrepRenderState = { _gk?: string; _gt?: string };
 
-export type EditRenderState = { _pk?: string; _pt?: string };
+export type EditRenderState = {
+	_pk?: string;
+	_pt?: string;
+	_edk?: string;
+	_edt?: string;
+};
 
 export type WriteRenderState = {
 	_previewKey?: string;
@@ -258,6 +265,7 @@ export type RenderDetails =
 	| GrepResultDetails
 	| EditInfoDetails
 	| MultiEditInfoDetails
+	| EditDiffDetails
 	| WriteDiffDetails
 	| WriteNewDetails
 	| WriteNoChangeDetails;
@@ -267,6 +275,11 @@ export type EditInfoDetails = {
 	_type: "editInfo";
 	summary: string;
 	editLine: number;
+	/** Full diff payload for split-view rendering */
+	oldContent: string;
+	newContent: string;
+	language: string | undefined;
+	filePath: string;
 };
 
 export type MultiEditInfoDetails = {
@@ -274,6 +287,13 @@ export type MultiEditInfoDetails = {
 	summary: string;
 	editCount: number;
 	diffLineCount: number;
+	/** Per-operation diffs for split-view rendering */
+	ops: Array<{
+		oldContent: string;
+		newContent: string;
+		language: string | undefined;
+		filePath: string;
+	}>;
 };
 
 export type WriteDiffDetails = {
@@ -293,6 +313,15 @@ export type WriteNewDetails = {
 
 export type WriteNoChangeDetails = { _type: "noChange" };
 
+export type EditDiffDetails = {
+	_type: "editDiff";
+	summary: string;
+	oldContent: string;
+	newContent: string;
+	language: string | undefined;
+	filePath: string;
+};
+
 export interface PiPrettyDeps {
 	sdk: PiPrettySdk;
 	TextComponent: TextComponentCtor;

package/src/utils.ts

@@ -48,7 +48,14 @@ export function fillToolBackground(text: string, bg = BG_BASE): string {
 		.join("\n");
 }
 
+let _cachedTermW: number | undefined;
+
+/** Read terminal width — checks all available sources in priority order.
+ *  Falls back to querying the controlling tty via fd 1/2/stdin ioctl.
+ *  Result is cached and invalidated on SIGWINCH / stdout resize. */
 export function termW(): number {
+	if (_cachedTermW !== undefined) return _cachedTermW;
+
 	const stderrWithColumns = process.stderr as NodeJS.WriteStream & {
 		columns?: number;
 	};
@@ -56,8 +63,44 @@ export function termW(): number {
 		process.stdout.columns ||
 		stderrWithColumns.columns ||
 		Number.parseInt(process.env.COLUMNS ?? "", 10) ||
-		200;
-	return Math.max(1, Math.min(raw - 4, 210));
+		_readTtyColumns() ||
+		120;
+	_cachedTermW = Math.max(1, Math.min(raw, 210));
+
+	// Invalidate on resize so next call re-reads
+	process.stdout.once("resize", () => {
+		_cachedTermW = undefined;
+	});
+	process.stdin.once("resize", () => {
+		_cachedTermW = undefined;
+	});
+
+	return _cachedTermW;
+}
+
+/** Synchronously query the tty size via Node's built-in ioctl binding.
+ *  Works even when stdout/stderr are piped, as long as stdin is a tty. */
+function _readTtyColumns(): number | undefined {
+	try {
+		// Node exposes getWindowSize() on tty.ReadStream / tty.WriteStream
+		const { getWindowSize } = require("node:tty") as {
+			getWindowSize?: (fd: number) => [number, number];
+		};
+		if (getWindowSize) {
+			// Try fd 1 (stdout), 2 (stderr), 0 (stdin) in order
+			for (const fd of [1, 2, 0]) {
+				try {
+					const [cols] = getWindowSize(fd);
+					if (cols && cols > 0) return cols;
+				} catch {
+					/* fd not a tty */
+				}
+			}
+		}
+	} catch {
+		/* tty module unavailable */
+	}
+	return undefined;
 }
 
 export function shortPath(cwd: string, home: string, p: string): string {