@xynogen/pix-pretty 1.0.0

package/src/types.ts

@@ -0,0 +1,275 @@
+import type { ImageContent, TextContent } from "@earendil-works/pi-ai";
+import type {
+	AgentToolResult,
+	AgentToolUpdateCallback,
+	BashToolInput,
+	EditToolInput,
+	ExtensionCommandContext,
+	ExtensionContext,
+	FindToolInput,
+	GrepToolInput,
+	LsToolInput,
+	ReadToolInput,
+	WriteToolInput,
+} from "@earendil-works/pi-coding-agent";
+import type { FileFinder } from "@ff-labs/fff-node";
+
+// We keep the original shiki-shaped types as plain string aliases so the
+// language map and function signatures stay 1:1 with upstream pi-pretty.
+export type BundledLanguage = string;
+
+export type BundledTheme = string;
+
+// ---------------------------------------------------------------------------
+// Multi-grep ripgrep fallback contracts
+// ---------------------------------------------------------------------------
+
+export type ConstraintParseResult =
+	| { ok: true; globs: string[]; tokens: string[] }
+	| { ok: false; error: string };
+
+export type MultiGrepRipgrepFallbackParams = {
+	cwd: string;
+	patterns: string[];
+	path?: string;
+	constraints?: string;
+	context?: number;
+	limit: number;
+	ignoreCase: boolean;
+	signal?: AbortSignal;
+};
+
+export type MultiGrepRipgrepFallbackResult = {
+	text: string;
+	matchCount: number;
+	limitReached: boolean;
+};
+
+export type MultiGrepRipgrepFallback = (
+	params: MultiGrepRipgrepFallbackParams,
+) => Promise<MultiGrepRipgrepFallbackResult>;
+
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+
+export type BgTheme = { getBgAnsi?: (key: string) => string };
+
+export type FgTheme = {
+	fg: (key: string, text: string) => string;
+	// Optional raw-ANSI accessor pi's theme exposes; used by the diff renderer
+	// to pull toolDiffAdded/Removed/Context colors. Absent on minimal themes.
+	getFgAnsi?: (key: string) => string;
+};
+
+export type ImageProtocol = "iterm2" | "kitty" | "none";
+
+export type ToolTextContent = TextContent;
+
+export type ToolImageContent = ImageContent;
+
+export type ToolContent = TextContent | ImageContent;
+
+export type ToolResultLike<TDetails = unknown> = AgentToolResult<
+	TDetails | undefined
+>;
+
+type TextComponentLike = {
+	setText(value: string): void;
+	getText?: () => string;
+};
+
+export type TextComponentCtor = new (
+	text?: string,
+	x?: number,
+	y?: number,
+) => TextComponentLike;
+
+export type ThemeLike = BgTheme & FgTheme & { bold: (text: string) => string };
+
+export type RenderContextLike<
+	TState extends Record<string, string | undefined> = Record<
+		string,
+		string | undefined
+	>,
+> = {
+	lastComponent?: TextComponentLike;
+	state: TState;
+	expanded: boolean;
+	isError: boolean;
+	invalidate: () => void;
+};
+
+type SessionContextLike = ExtensionContext;
+
+export type CommandContextLike = ExtensionCommandContext;
+
+type ToolExecutor<TParams, TDetails = unknown> = (
+	toolCallId: string,
+	params: TParams,
+	signal?: AbortSignal,
+	onUpdate?: AgentToolUpdateCallback<TDetails | undefined>,
+	ctx?: ExtensionContext,
+) => Promise<ToolResultLike<TDetails>>;
+
+export type ToolFactory<TParams, TDetails = unknown> = (cwd: string) => {
+	name?: string;
+	description?: string;
+	label?: string;
+	parameters?: unknown;
+	execute: ToolExecutor<TParams, TDetails>;
+};
+
+export type PiPrettySdk = {
+	createReadToolDefinition?: ToolFactory<ReadToolInput>;
+	createReadTool?: ToolFactory<ReadToolInput>;
+	createBashToolDefinition?: ToolFactory<BashToolInput>;
+	createBashTool?: ToolFactory<BashToolInput>;
+	createLsToolDefinition?: ToolFactory<LsToolInput>;
+	createLsTool?: ToolFactory<LsToolInput>;
+	createFindToolDefinition?: ToolFactory<FindToolInput>;
+	createFindTool?: ToolFactory<FindToolInput>;
+	createGrepToolDefinition?: ToolFactory<GrepToolInput>;
+	createGrepTool?: ToolFactory<GrepToolInput>;
+	createEditToolDefinition?: ToolFactory<EditToolInput>;
+	createEditTool?: ToolFactory<EditToolInput>;
+	createWriteToolDefinition?: ToolFactory<WriteToolInput>;
+	createWriteTool?: ToolFactory<WriteToolInput>;
+	getAgentDir?: () => string;
+};
+
+export type PiPrettyApi = {
+	registerTool: (tool: unknown) => void;
+	registerCommand: (
+		name: string,
+		command: {
+			description?: string;
+			handler: (args: string, ctx: CommandContextLike) => Promise<void> | void;
+		},
+	) => void;
+	on: (
+		event: string,
+		handler: (event: unknown, ctx: SessionContextLike) => Promise<void> | void,
+	) => void;
+};
+
+export type OptionalFffModule = { FileFinder: typeof FileFinder };
+
+export type FffBackedFinder = FileFinder;
+
+export type ReadParams = ReadToolInput;
+
+export type BashParams = BashToolInput;
+
+export type EditParams = EditToolInput;
+
+export type WriteParams = WriteToolInput;
+
+// A single old→new replacement extracted from an edit tool call (supports both
+// the single oldText/newText shape and the batched `edits[]` shape).
+export type EditOperation = { oldText: string; newText: string };
+
+export type LsParams = LsToolInput;
+
+export type FindParams = FindToolInput;
+
+export type GrepParams = GrepToolInput;
+
+export type MultiGrepParams = {
+	patterns: string[];
+	path?: string;
+	constraints?: string;
+	context?: number;
+	limit?: number;
+};
+
+export type GrepRenderState = { _gk?: string; _gt?: string };
+
+export type EditRenderState = { _pk?: string; _pt?: string };
+
+export type WriteRenderState = {
+	_previewKey?: string;
+	_previewText?: string;
+	_wdk?: string;
+	_wdt?: string;
+	_nfk?: string;
+	_nft?: string;
+};
+
+export type MultiGrepRenderState = { _mgk?: string; _mgt?: string };
+
+export type FindResultDetails = {
+	_type: "findResult";
+	text: string;
+	pattern: string;
+	matchCount: number;
+};
+
+export type GrepResultDetails = {
+	_type: "grepResult";
+	text: string;
+	pattern: string;
+	matchCount: number;
+};
+
+export type RenderDetails =
+	| { _type: "readImage"; filePath: string; data: string; mimeType: string }
+	| {
+			_type: "readFile";
+			filePath: string;
+			content: string;
+			offset: number;
+			lineCount: number;
+	  }
+	| {
+			_type: "bashResult";
+			text: string;
+			exitCode: number | null;
+			command: string;
+	  }
+	| { _type: "lsResult"; text: string; path: string; entryCount: number }
+	| FindResultDetails
+	| GrepResultDetails
+	| EditInfoDetails
+	| MultiEditInfoDetails
+	| WriteDiffDetails
+	| WriteNewDetails
+	| WriteNoChangeDetails;
+
+// --- edit/write render detail payloads (stored on result.details) ---
+export type EditInfoDetails = {
+	_type: "editInfo";
+	summary: string;
+	editLine: number;
+};
+
+export type MultiEditInfoDetails = {
+	_type: "multiEditInfo";
+	summary: string;
+	editCount: number;
+	diffLineCount: number;
+};
+
+export type WriteDiffDetails = {
+	_type: "diff";
+	summary: string;
+	oldContent: string;
+	newContent: string;
+	language: string | undefined;
+};
+
+export type WriteNewDetails = {
+	_type: "new";
+	lines: number;
+	content: string;
+	filePath: string;
+};
+
+export type WriteNoChangeDetails = { _type: "noChange" };
+
+export interface PiPrettyDeps {
+	sdk: PiPrettySdk;
+	TextComponent: TextComponentCtor;
+	fffModule?: OptionalFffModule;
+	multiGrepRipgrepFallback?: MultiGrepRipgrepFallback;
+}

package/src/utils.ts

@@ -0,0 +1,180 @@
+import { relative } from "node:path";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+
+import {
+	ANSI_CAPTURE_RE,
+	BG_BASE,
+	BG_ERROR,
+	FG_LNUM,
+	FG_RULE,
+	RST,
+} from "./ansi.js";
+import type {
+	FgTheme,
+	ToolContent,
+	ToolImageContent,
+	ToolResultLike,
+	ToolTextContent,
+} from "./types.js";
+
+export function renderToolError(error: string, theme: FgTheme): string {
+	return fillToolBackground(`\n${theme.fg("error", error)}`, BG_ERROR);
+}
+
+export function normalizeLineEndings(text: string): string {
+	return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+
+function preserveToolBackground(ansi: string, bg: string): string {
+	return ansi.replace(ANSI_CAPTURE_RE, (seq, params: string) => {
+		const codes = params.split(";");
+		return params === "0" || codes.includes("49") ? `${seq}${bg}` : seq;
+	});
+}
+
+export function fillToolBackground(text: string, bg = BG_BASE): string {
+	const width = termW();
+	return text
+		.split("\n")
+		.map((line) => {
+			const normalized = preserveToolBackground(line, bg);
+			const fitted = preserveToolBackground(
+				truncateToWidth(normalized, width, ""),
+				bg,
+			);
+			const padding = Math.max(0, width - visibleWidth(fitted));
+			return `${bg}${fitted}${" ".repeat(padding)}${RST}`;
+		})
+		.join("\n");
+}
+
+export function termW(): number {
+	const stderrWithColumns = process.stderr as NodeJS.WriteStream & {
+		columns?: number;
+	};
+	const raw =
+		process.stdout.columns ||
+		stderrWithColumns.columns ||
+		Number.parseInt(process.env.COLUMNS ?? "", 10) ||
+		200;
+	return Math.max(1, Math.min(raw - 4, 210));
+}
+
+export function shortPath(cwd: string, home: string, p: string): string {
+	if (!p) return "";
+	const r = relative(cwd, p);
+	if (!r.startsWith("..") && !r.startsWith("/")) return r;
+	return p.replace(home, "~");
+}
+
+export function rule(w: number): string {
+	return `${FG_RULE}${"─".repeat(w)}${RST}`;
+}
+
+export function lnum(n: number, w: number): string {
+	const v = String(n);
+	return `${FG_LNUM}${" ".repeat(Math.max(0, w - v.length))}${v}${RST}`;
+}
+
+// ---------------------------------------------------------------------------
+// Human-readable file size
+// ---------------------------------------------------------------------------
+
+export function humanSize(bytes: number): string {
+	if (bytes < 1024) return `${bytes}B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+	return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+// ---------------------------------------------------------------------------
+// File-type icons — Nerd Font glyphs (Seti-UI + Devicons, stable in NF v3+)
+//
+// Requires a Nerd Font installed (e.g., JetBrainsMono Nerd Font, FiraCode NF).
+// Fallback: set PRETTY_ICONS=none to disable icons.
+// ---------------------------------------------------------------------------
+
+export function isTextContent(
+	content: ToolContent,
+): content is ToolTextContent {
+	return content.type === "text";
+}
+
+export function isImageContent(
+	content: ToolContent,
+): content is ToolImageContent {
+	return content.type === "image";
+}
+
+export function getTextContent(result: ToolResultLike): string {
+	return (
+		result.content
+			?.filter(isTextContent)
+			.map((content) => content.text || "")
+			.join("\n") ?? ""
+	);
+}
+
+export function setResultDetails<T>(result: ToolResultLike, details: T): void {
+	result.details = details;
+}
+
+export function makeTextResult<TDetails>(
+	text: string,
+	details: TDetails,
+): ToolResultLike<TDetails> {
+	return {
+		content: [{ type: "text", text }],
+		details,
+	};
+}
+
+export function appendNotices(text: string, notices: string[]): string {
+	return notices.length ? `${text}\n\n[${notices.join(". ")}]` : text;
+}
+
+export function countRipgrepMatches(text: string): number {
+	return text
+		.trim()
+		.split("\n")
+		.filter((line) => /^.+?[:-]\d+[:-]/.test(line)).length;
+}
+
+export function getErrorMessage(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
+
+export function trimToUndefined(value: string | undefined): string | undefined {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : undefined;
+}
+
+function escapeRegexLiteral(text: string): string {
+	return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export function buildLiteralAlternationPattern(patterns: string[]): string {
+	return patterns
+		.map(escapeRegexLiteral)
+		.sort((a, b) => b.length - a.length)
+		.join("|");
+}
+
+export function shouldIgnoreCaseForPatterns(patterns: string[]): boolean {
+	return patterns.every((pattern) => pattern.toLowerCase() === pattern);
+}
+
+export function getConstraintBackedPath(
+	constraints: string | undefined,
+): string | undefined {
+	const trimmed = trimToUndefined(constraints);
+	if (
+		!trimmed ||
+		/\s/.test(trimmed) ||
+		trimmed.includes("!") ||
+		trimmed.endsWith("/") ||
+		/[*?[{]/.test(trimmed)
+	) {
+		return undefined;
+	}
+	return trimmed;
+}