@xynogen/pix-pretty 1.1.0 → 1.3.0

package/README.md

@@ -56,12 +56,17 @@ Both work independently but complement each other for a cohesive visual experien
 
 ## Origin
 
-Tool rendering is a vendored fork of [`@heyhuynhgiabuu/pi-pretty`](https://github.com/buddingnewinsights/pi-pretty) with two key changes:
+Tool rendering replaced `npm:@heyhuynhgiabuu/pi-pretty` (which was previously replaced by `npm:@heyhuynhgiabuu/pi-diff`). This package is a clean reimplementation — no code was copied directly. Developed independently; changes are not submitted back and upstream changes are not pulled in.
 
-1. **Highlight engine: shiki → cli-highlight** - Simpler, synchronous, no WASM
-2. **FFF state dir: `~/.pi/agent/pi-pretty/fff` → `~/.cache/pi/fff`** - Standard XDG cache location
+Key divergences from upstream:
 
-Paste chip formatting is custom logic for Pi's paste marker system.
+1. **Highlight engine: shiki → cli-highlight** - Simpler, no WASM, synchronous
+2. **FFF state dir** - `~/.pi/agent/pi-pretty/fff` → `~/.cache/pi/fff` (XDG cache)
+3. **Split diff view for edit/write tools** - Full side-by-side diff with gutter, line numbers, syntax highlighting
+4. **Paste chip formatting** - Custom editor component for Pi's paste marker system (not in upstream)
+5. **Reasoning tag rendering** - Collapsible `<think>`/`<thinking>` blocks (not in upstream)
+
+Paste chip formatting and reasoning tag rendering are original additions with no upstream equivalent.
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-pretty",
-	"version": "1.1.0",
+	"version": "1.3.0",
 	"description": "Enhanced tool output rendering with syntax highlighting, file icons, tree views, FFF search, and paste chip formatting",
 	"type": "module",
 	"main": "src/index.ts",
@@ -40,8 +40,7 @@
 		"url": "https://github.com/xynogen/pix-mono/issues"
 	},
 	"publishConfig": {
-		"access": "public",
-		"provenance": true
+		"access": "public"
 	},
 	"dependencies": {
 		"cli-highlight": "^2.1.11",

package/src/ansi.ts

@@ -1,29 +1,19 @@
 import type { BgTheme } from "./types.js";
 
 export let RST = "\x1b[0m";
-
 export const BOLD = "\x1b[1m";
 
 export const FG_LNUM = "\x1b[38;2;100;100;100m";
-
 export const FG_DIM = "\x1b[38;2;80;80;80m";
-
 export const FG_RULE = "\x1b[38;2;50;50;50m";
-
 export const FG_GREEN = "\x1b[38;2;100;180;120m";
-
 export const FG_RED = "\x1b[38;2;200;100;100m";
-
 export const FG_YELLOW = "\x1b[38;2;220;180;80m";
-
 export const FG_BLUE = "\x1b[38;2;100;140;220m";
-
 const FG_MUTED = "\x1b[38;2;139;148;158m";
 
 const BG_DEFAULT = "\x1b[49m";
-
 export let BG_BASE = BG_DEFAULT; // tool box success/base bg — updated from theme's toolSuccessBg
-
 export let BG_ERROR = BG_DEFAULT; // tool box error bg — updated from theme's toolErrorBg
 
 /** Parse an ANSI 24-bit color escape into { r, g, b }. Handles both fg (38;2) and bg (48;2). */

package/src/commands/fff.ts

@@ -0,0 +1,60 @@
+import type { FffState } from "../fff.js";
+import type { CommandContextLike, PiPrettyApi } from "../types.js";
+
+// ── FFF slash commands ─────────────────────────────────────────────────
+
+export function registerFffCommands(pi: PiPrettyApi, fffState: FffState): void {
+	pi.registerCommand("fff-health", {
+		description: "Show FFF file finder health and indexer status",
+		handler: async (_args: string, ctx: CommandContextLike) => {
+			if (!fffState.finder || fffState.finder.isDestroyed) {
+				ctx.ui?.notify?.("FFF not initialized", "warning");
+				return;
+			}
+
+			const health = fffState.finder.healthCheck();
+			if (!health.ok) {
+				ctx.ui?.notify?.(`Health check failed: ${health.error}`, "error");
+				return;
+			}
+
+			const h = health.value;
+			const lines = [
+				`FFF v${h.version}`,
+				`Git: ${h.git.repositoryFound ? `yes (${h.git.workdir ?? "unknown"})` : "no"}`,
+				`Picker: ${h.filePicker.initialized ? `${h.filePicker.indexedFiles ?? 0} files` : "not initialized"}`,
+				`Frecency: ${h.frecency.initialized ? "active" : "disabled"}`,
+				`Query tracker: ${h.queryTracker.initialized ? "active" : "disabled"}`,
+				`Partial index: ${fffState.partialIndex ? "yes (scan timed out)" : "no"}`,
+			];
+
+			const progress = fffState.finder.getScanProgress();
+			if (progress.ok) {
+				lines.push(
+					`Scanning: ${progress.value.isScanning ? "yes" : "no"} (${progress.value.scannedFilesCount} files)`,
+				);
+			}
+
+			ctx.ui?.notify?.(lines.join("\n"), "info");
+		},
+	});
+
+	pi.registerCommand("fff-rescan", {
+		description: "Trigger FFF to rescan files",
+		handler: async (_args: string, ctx: CommandContextLike) => {
+			if (!fffState.finder || fffState.finder.isDestroyed) {
+				ctx.ui?.notify?.("FFF not initialized", "warning");
+				return;
+			}
+
+			const result = fffState.finder.scanFiles();
+			if (!result.ok) {
+				ctx.ui?.notify?.(`Rescan failed: ${result.error}`, "error");
+				return;
+			}
+
+			fffState.partialIndex = false;
+			ctx.ui?.notify?.("FFF rescan triggered", "info");
+		},
+	});
+}

package/src/diff-render.ts

@@ -201,12 +201,36 @@ function tabs(s: string): string {
 }
 
 function termW(): number {
+	// Delegate to utils.termW which has tty ioctl fallback + resize invalidation
+	const stderrCols = (process.stderr as { columns?: number }).columns;
 	const raw =
 		process.stdout.columns ||
-		(process.stderr as { columns?: number }).columns ||
+		stderrCols ||
 		Number.parseInt(process.env.COLUMNS ?? "", 10) ||
+		_readTtyColsDR() ||
 		DEFAULT_TERM_WIDTH;
-	return Math.max(80, Math.min(raw - 4, MAX_TERM_WIDTH));
+	return Math.max(80, Math.min(raw, MAX_TERM_WIDTH));
+}
+
+function _readTtyColsDR(): number | undefined {
+	try {
+		const { getWindowSize } = require("node:tty") as {
+			getWindowSize?: (fd: number) => [number, number];
+		};
+		if (getWindowSize) {
+			for (const fd of [1, 2, 0]) {
+				try {
+					const [cols] = getWindowSize(fd);
+					if (cols && cols > 0) return cols;
+				} catch {
+					/* not a tty */
+				}
+			}
+		}
+	} catch {
+		/* tty unavailable */
+	}
+	return undefined;
 }
 
 /** Pad/truncate `s` to exactly `w` visible chars. ANSI-aware. */
@@ -335,10 +359,53 @@ function stripes(w: number, _rowOffset: number): string {
 	return BG_BASE + FG_STRIPE + "╱".repeat(w) + RST;
 }
 
-function lnum(n: number | null, w: number, fg = FG_LNUM): string {
+/** Right-aligned line number. `noReset` keeps the active bg alive (no
+ *  trailing RST) so the caller can build one bg-continuous gutter segment. */
+function lnum(
+	n: number | null,
+	w: number,
+	fg = FG_LNUM,
+	noReset = false,
+): string {
 	if (n === null) return " ".repeat(w);
 	const v = String(n);
-	return `${fg}${" ".repeat(Math.max(0, w - v.length))}${v}${RST}`;
+	const pad = " ".repeat(Math.max(0, w - v.length));
+	return noReset ? `${fg}${pad}${v}` : `${fg}${pad}${v}${RST}`;
+}
+
+/** Build one bg-continuous gutter row. A single `gutterBg` is set up front and
+ *  only foreground colors switch inside it (fg changes never reset bg), so no
+ *  internal RST can punch a dark gap. The trailing space adopts `bodyBg` to
+ *  blend the gutter into the code body, then one RST closes the segment. */
+function buildGutter(opts: {
+	borderFg: string;
+	gutterBg: string;
+	bodyBg: string;
+	num: number | null;
+	numFg: string;
+	signFg: string;
+	sign: string;
+	nw: number;
+	continuation: boolean;
+}): string {
+	const {
+		borderFg,
+		gutterBg,
+		bodyBg,
+		num,
+		numFg,
+		signFg,
+		sign,
+		nw,
+		continuation,
+	} = opts;
+	const border = borderFg
+		? `${gutterBg}${borderFg}${BORDER_BAR}`
+		: `${BG_BASE} `;
+	const numCell = continuation
+		? " ".repeat(nw + 2)
+		: `${lnum(num, nw, numFg, true)}${signFg}${sign} `;
+	return `${border}${gutterBg}${numCell}${FG_RULE}│${bodyBg} ${RST}`;
 }
 
 function rule(w: number): string {
@@ -545,10 +612,19 @@ export async function renderUnified(
 		bodyBg = "",
 	): void {
 		const borderFg = sign === "-" ? dc.fgDel : sign === "+" ? dc.fgAdd : "";
-		const border = borderFg ? `${borderFg}${BORDER_BAR}${RST}` : `${BG_BASE} `;
 		const numFg = borderFg || FG_LNUM;
-		const gutter = `${border}${gutterBg}${lnum(num, nw, numFg)}${signFg}${sign}${RST} ${DIVIDER} `;
-		const contGutter = `${border}${gutterBg}${" ".repeat(nw + 1)}${RST} ${DIVIDER} `;
+		const gutterArgs = {
+			borderFg,
+			gutterBg,
+			bodyBg,
+			num,
+			numFg,
+			signFg,
+			sign,
+			nw,
+		};
+		const gutter = buildGutter({ ...gutterArgs, continuation: false });
+		const contGutter = buildGutter({ ...gutterArgs, continuation: true });
 		const rows = wrapAnsi(tabs(body), cw, adaptiveWrapRows(), bodyBg);
 		out.push(`${gutter}${rows[0]}${RST}`);
 		for (let r = 1; r < rows.length; r++)
@@ -796,7 +872,6 @@ export async function renderSplit(
 					: line.newNum;
 
 		const borderFg = isDel ? dc.fgDel : isAdd ? dc.fgAdd : "";
-		const border = borderFg ? `${borderFg}${BORDER_BAR}${RST}` : ` ${BG_BASE}`;
 		const numFg = borderFg || FG_LNUM;
 
 		let body: string;
@@ -808,18 +883,19 @@ export async function renderSplit(
 			body = `${BG_BASE}${DIM}${hl}`;
 		}
 
-		const gutter = `${border}${gBg}${lnum(num, nw, numFg)}${sFg}${BOLD}${sign}${RST} ${FG_RULE}│${RST} `;
-		const contGutter = `${border}${gBg}${" ".repeat(nw + 1)}${RST} ${FG_RULE}│${RST} `;
+		// Split view's non-bordered context rows lead with a space before bg;
+		// buildGutter handles bordered rows, so feed the same border convention.
+		const splitBorder = borderFg
+			? `${gBg}${borderFg}${BORDER_BAR}`
+			: ` ${BG_BASE}`;
+		const numCell = `${lnum(num, nw, numFg, true)}${sFg}${BOLD}${sign} `;
+		const gutter = `${splitBorder}${gBg}${numCell}${FG_RULE}│${cBg} ${RST}`;
+		const contGutter = `${splitBorder}${gBg}${" ".repeat(nw + 2)}${FG_RULE}│${cBg} ${RST}`;
 		const bodyRows = wrapAnsi(tabs(body), cw, adaptiveWrapRows(), cBg);
 		return { gutter, contGutter, bodyRows };
 	}
 
 	const out: string[] = [];
-	const hdrOld = `${BG_BASE}${" ".repeat(Math.max(0, nw - 2))}${dc.fgDel}${DIM}old${RST}`;
-	const hdrNew = `${BG_BASE}${" ".repeat(Math.max(0, nw - 2))}${dc.fgAdd}${DIM}new${RST}`;
-	out.push(
-		`${BG_BASE}${hdrOld}${" ".repeat(Math.max(0, half - nw - 1))}${FG_RULE}┊${RST}${hdrNew}`,
-	);
 	out.push(`${rule(half)}${FG_RULE}┊${RST}${rule(half)}`);
 
 	for (const r of vis) {
@@ -877,7 +953,7 @@ export async function renderSplit(
 				(rightIsEmpty
 					? stripes(cw, stripeRow)
 					: `${BG_EMPTY}${" ".repeat(cw)}${RST}`);
-			out.push(`${lg}${lb}${DIVIDER}${rg}${rb}`);
+			out.push(`${lg}${lb}${DIVIDER}${rg}${rb}${RST}`);
 			stripeRow++;
 		}
 	}

package/src/image.ts

@@ -3,11 +3,8 @@ import * as childProcess from "node:child_process";
 import type { ImageProtocol } from "./types.js";
 
 let _tmuxClientTermCache: string | null | undefined;
-
 let _tmuxAllowPassthroughCache: boolean | null | undefined;
-
 let _tmuxClientTermOverrideForTests: string | null | undefined;
-
 let _tmuxAllowPassthroughOverrideForTests: boolean | null | undefined;
 
 function isTmuxSession(): boolean {