@xynogen/pix-pretty 1.7.18 → 1.7.20

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-pretty",
-	"version": "1.7.18",
+	"version": "1.7.20",
 	"description": "Enhanced tool output rendering with syntax highlighting, file icons, tree views, diff rendering, and FFF search",
 	"type": "module",
 	"main": "src/index.ts",

package/src/types.ts

@@ -185,6 +185,7 @@ export type FindResultDetails = {
 	_type: "findResult";
 	text: string;
 	pattern: string;
+	path?: string;
 	matchCount: number;
 };
 
@@ -192,6 +193,7 @@ export type GrepResultDetails = {
 	_type: "grepResult";
 	text: string;
 	pattern: string;
+	path?: string;
 	matchCount: number;
 };
 

package/src/utils.test.ts

@@ -2,7 +2,14 @@ import { describe, expect, it } from "bun:test";
 
 import { MAX_PREVIEW_LINES } from "./config.js";
 import type { FgTheme } from "./types.js";
-import { pluralize, renderDimPreview } from "./utils.js";
+import {
+	formatCollapsedToolRow,
+	hideCollapsedToolCall,
+	pluralize,
+	renderCollapsedToolRow,
+	renderDimPreview,
+	setResultDetails,
+} from "./utils.js";
 
 // Strip ANSI escapes so assertions test content, not color codes.
 const ANSI = /\x1b\[[0-9;]*m/g;
@@ -29,6 +36,47 @@ describe("pluralize", () => {
 	});
 });
 
+describe("collapsed tool rows", () => {
+	const rowTheme = { fg: (_key: string, text: string) => text, bold: (text: string) => text };
+
+	it("renders a consistent status, tool, target, and metadata row", () => {
+		expect(formatCollapsedToolRow(rowTheme, "read", "src/a.ts", "12 lines")).toBe(
+			"✓ read src/a.ts · 12 lines",
+		);
+		expect(plain(renderCollapsedToolRow(rowTheme, "read", "src/a.ts", "12 lines"))).toContain(
+			"✓ read src/a.ts · 12 lines",
+		);
+	});
+
+	it("hides only collapsed, non-expanded call rows", () => {
+		let value = "unchanged";
+		expect(hideCollapsedToolCall({ collapsed: true }, false, (text) => (value = text))).toBe(true);
+		expect(value).toBe("");
+		expect(hideCollapsedToolCall({ collapsed: true }, true, () => {})).toBe(false);
+	});
+});
+
+describe("setResultDetails", () => {
+	it("preserves upstream metadata while adding renderer details", () => {
+		const result = {
+			content: [{ type: "text" as const, text: "output" }],
+			details: {
+				truncation: { truncated: true, totalLines: 500 },
+				fullOutputPath: "/tmp/full.log",
+			},
+		};
+
+		setResultDetails(result, { _type: "bashResult", exitCode: 0 });
+
+		expect(result.details as Record<string, unknown>).toEqual({
+			truncation: { truncated: true, totalLines: 500 },
+			fullOutputPath: "/tmp/full.log",
+			_type: "bashResult",
+			exitCode: 0,
+		});
+	});
+});
+
 describe("renderDimPreview", () => {
 	it("renders 'done' for empty input", () => {
 		expect(plain(renderDimPreview("", theme))).toContain("done");
@@ -79,7 +127,9 @@ describe("renderDimPreview", () => {
 		expect(plain(raw)).toContain("foo bar foo");
 	});
 
-	it("does not throw on an invalid highlight regex", () => {
-		expect(() => renderDimPreview("text", theme, { highlight: "(" })).not.toThrow();
+	it("treats regex metacharacters as literal highlight text", () => {
+		const raw = renderDimPreview("call(foo)", theme, { highlight: "(" });
+		expect(plain(raw)).toContain("call(foo)");
+		expect(raw).toContain("\x1b[");
 	});
 });

package/src/utils.ts

@@ -52,6 +52,55 @@ export function pluralize(count: number, noun: string, plural?: string): string
 	return `${count} ${count === 1 ? noun : (plural ?? `${noun}s`)}`;
 }
 
+export type CollapsedToolStatus = "success" | "error" | "warning";
+
+type CollapsedToolTheme = {
+	fg: (
+		key: "success" | "error" | "warning" | "toolTitle" | "muted" | "dim",
+		text: string,
+	) => string;
+	bold: (text: string) => string;
+};
+
+/** Format the shared one-row content without assuming a render shell. */
+export function formatCollapsedToolRow(
+	theme: CollapsedToolTheme,
+	tool: string,
+	target: string,
+	meta = "",
+	status: CollapsedToolStatus = "success",
+): string {
+	const icon = status === "success" ? "✓" : status === "warning" ? "⚡" : "✗";
+	const parts = [
+		`${theme.fg(status, icon)} ${theme.fg("toolTitle", theme.bold(tool))}`,
+		target ? theme.fg("muted", target) : "",
+		meta ? `${theme.fg("dim", "·")} ${theme.fg("dim", meta)}` : "",
+	].filter(Boolean);
+	return parts.join(" ");
+}
+
+/** Render shared one-row content for tools using the self-rendered shell. */
+export function renderCollapsedToolRow(
+	theme: CollapsedToolTheme,
+	tool: string,
+	target: string,
+	meta = "",
+	status: CollapsedToolStatus = "success",
+): string {
+	return fillToolBackground(`  ${formatCollapsedToolRow(theme, tool, target, meta, status)}`);
+}
+
+/** Hide renderCall after its paired result has auto-collapsed. */
+export function hideCollapsedToolCall(
+	state: { collapsed?: boolean },
+	expanded: boolean,
+	setText: (text: string) => void,
+): boolean {
+	if (!state.collapsed || expanded) return false;
+	setText("");
+	return true;
+}
+
 export type DimPreviewOptions = {
 	maxLines?: number;
 	header?: string;
@@ -59,21 +108,23 @@ export type DimPreviewOptions = {
 	highlight?: string;
 };
 
-function safeHighlightRegex(pattern: string): RegExp | null {
-	try {
-		return new RegExp(`(${pattern})`, "gi");
-	} catch {
-		return null;
-	}
-}
+function dimLineWithHighlight(line: string, theme: FgTheme, pattern?: string): string {
+	if (!pattern) return theme.fg("dim", line);
+	const foldedLine = line.toLocaleLowerCase();
+	const foldedPattern = pattern.toLocaleLowerCase();
+	if (!foldedPattern) return theme.fg("dim", line);
 
-function dimLineWithHighlight(line: string, theme: FgTheme, re: RegExp | null): string {
-	if (!re) return theme.fg("dim", line);
-	// split with capture group: odd indexes are matches
-	return line
-		.split(re)
-		.map((part, i) => (i % 2 ? `${FG_GREEN}${BOLD}${part}${RST}` : theme.fg("dim", part)))
-		.join("");
+	const parts: string[] = [];
+	let start = 0;
+	for (;;) {
+		const match = foldedLine.indexOf(foldedPattern, start);
+		if (match < 0) break;
+		if (match > start) parts.push(theme.fg("dim", line.slice(start, match)));
+		parts.push(`${FG_GREEN}${BOLD}${line.slice(match, match + pattern.length)}${RST}`);
+		start = match + pattern.length;
+	}
+	if (start < line.length) parts.push(theme.fg("dim", line.slice(start)));
+	return parts.length > 0 ? parts.join("") : theme.fg("dim", line);
 }
 
 export function renderDimPreview(
@@ -82,12 +133,12 @@ export function renderDimPreview(
 	opts: DimPreviewOptions = {},
 ): string {
 	const maxLines = opts.maxLines ?? MAX_PREVIEW_LINES;
-	const re = opts.highlight ? safeHighlightRegex(opts.highlight) : null;
+	const highlight = opts.highlight;
 	const output = normalizeLineEndings(text).trim() || "done";
 	const lines = output.split("\n");
 	const preview = lines
 		.slice(0, maxLines)
-		.map((line) => `  ${dimLineWithHighlight(line, theme, re)}`);
+		.map((line) => `  ${dimLineWithHighlight(line, theme, highlight)}`);
 	if (opts.header) preview.unshift(`  ${theme.fg("dim", opts.header)}`);
 	if (lines.length > maxLines) {
 		const more = pluralize(lines.length - maxLines, "more line");
@@ -208,8 +259,13 @@ export function getTextContent(result: ToolResultLike): string {
 	);
 }
 
+/** Add renderer metadata without discarding execution metadata from the upstream tool. */
 export function setResultDetails<T>(result: ToolResultLike, details: T): void {
-	result.details = details;
+	const upstream =
+		result.details && typeof result.details === "object"
+			? (result.details as Record<string, unknown>)
+			: undefined;
+	result.details = upstream ? { ...upstream, ...details } : details;
 }
 
 export function makeTextResult<TDetails>(