@quandev104/pi-style 0.1.1

package/extension-src/pi-style/shared/disposable-store.ts

@@ -0,0 +1,28 @@
+export interface Disposable {
+	dispose(): void | Promise<void>;
+}
+
+export class DisposableStore implements Disposable {
+	private readonly items: Disposable[] = [];
+	private disposed = false;
+	add<T extends Disposable>(item: T): T {
+		if (this.disposed) {
+			void item.dispose();
+			return item;
+		}
+		this.items.push(item);
+		return item;
+	}
+	addCallback(callback: () => void | Promise<void>): void {
+		this.add({ dispose: callback });
+	}
+	get size(): number {
+		return this.items.length;
+	}
+	async dispose(): Promise<void> {
+		if (this.disposed) return;
+		this.disposed = true;
+		for (let i = this.items.length - 1; i >= 0; i--) await this.items[i]?.dispose();
+		this.items.length = 0;
+	}
+}

package/extension-src/pi-style/shared/elapsed.ts

@@ -0,0 +1,88 @@
+// Tool metrics: elapsed wall time + output size formatting and annotation.
+
+const ELAPSED_KEY = "__elapsedMs";
+const OUTPUT_CHARS_KEY = "__outputChars";
+
+export interface MetricResultLike {
+	readonly content?: readonly unknown[];
+	readonly details?: unknown;
+}
+
+function getTextOutputLength(result: MetricResultLike): number {
+	if (!Array.isArray(result.content)) return 0;
+	let length = 0;
+	let seenText = false;
+	for (const contentBlock of result.content) {
+		if (!contentBlock || typeof contentBlock !== "object") continue;
+		const block = contentBlock as { type?: unknown; text?: unknown };
+		if (block.type !== "text") continue;
+		if (seenText) length += 1; // matches getTextOutput() joining text blocks with newlines
+		length += String(block.text ?? "").replace(/\r/g, "").length;
+		seenText = true;
+	}
+	return length;
+}
+
+function formatCompactCount(value: number): string {
+	if (value < 1000) return `${Math.round(value)}`;
+	if (value < 10000) return `${(value / 1000).toFixed(1)}k`;
+	if (value < 1000000) return `${Math.round(value / 1000)}k`;
+	if (value < 10000000) return `${(value / 1000000).toFixed(1)}M`;
+	return `${Math.round(value / 1000000)}M`;
+}
+
+export function formatElapsedMs(ms: number | undefined): string {
+	if (typeof ms !== "number" || !Number.isFinite(ms)) return "";
+	if (ms < 1000) return `${Math.round(ms)}ms`;
+	const s = ms / 1000;
+	return s < 10 ? `${s.toFixed(1)}s` : `${Math.round(s)}s`;
+}
+
+export function formatOutputChars(chars: number | undefined): string {
+	if (typeof chars !== "number" || !Number.isFinite(chars) || chars <= 0) return "";
+	return `${formatCompactCount(chars)} ${chars === 1 ? "char" : "chars"}`;
+}
+
+export function formatToolMetricsFromValues(elapsedMs: number | undefined, outputChars: number | undefined): string {
+	return [formatElapsedMs(elapsedMs), formatOutputChars(outputChars)].filter(Boolean).join(" · ");
+}
+
+export function getElapsedMs(result: MetricResultLike | undefined): number | undefined {
+	if (!result || typeof result.details !== "object" || result.details === null) return undefined;
+	const elapsed = (result.details as Record<string, unknown>)[ELAPSED_KEY];
+	return typeof elapsed === "number" && Number.isFinite(elapsed) ? elapsed : undefined;
+}
+
+export function formatElapsed(result: MetricResultLike | undefined): string {
+	return formatElapsedMs(getElapsedMs(result));
+}
+
+export function formatOutputSize(result: MetricResultLike | undefined): string {
+	return formatOutputChars(
+		(result?.details as Record<string, unknown> | undefined)?.[OUTPUT_CHARS_KEY] as number | undefined,
+	);
+}
+
+export function formatToolMetrics(result: MetricResultLike | undefined): string {
+	return [formatElapsed(result), formatOutputSize(result)].filter(Boolean).join(" · ");
+}
+
+/** Annotate elapsed/output metrics into a result's details (only when absent). */
+export function annotateToolResultMetrics(result: MetricResultLike | undefined, elapsedMs?: number): void {
+	if (!result || typeof result !== "object") return;
+	if (!result.details || typeof result.details !== "object") {
+		(result as { details?: unknown }).details = {};
+	}
+	const details = result.details as Record<string, unknown>;
+	const existingElapsed = details[ELAPSED_KEY];
+	if (
+		typeof elapsedMs === "number" &&
+		Number.isFinite(elapsedMs) &&
+		(typeof existingElapsed !== "number" || !Number.isFinite(existingElapsed))
+	) {
+		details[ELAPSED_KEY] = elapsedMs;
+	}
+	if (typeof details[OUTPUT_CHARS_KEY] !== "number" || !Number.isFinite(details[OUTPUT_CHARS_KEY])) {
+		details[OUTPUT_CHARS_KEY] = getTextOutputLength(result);
+	}
+}

package/extension-src/pi-style/shared/render-budget.ts

@@ -0,0 +1,367 @@
+// Render budget + ANSI-safe width/truncation/wrapping helpers for boxed tool
+// presentation.
+
+import {
+	truncateToWidth as tuiTruncateToWidth,
+	visibleWidth as tuiVisibleWidth,
+	wrapTextWithAnsi,
+} from "@earendil-works/pi-tui";
+
+export const MAX_RENDER_LINE_CHARS = 2000;
+export const DEFAULT_COLLAPSED_RENDER_LINES = 10;
+export const MAX_BOXED_RESULT_RENDERED_HEAD_LINES = 40;
+export const MAX_BOXED_RESULT_RENDERED_TAIL_LINES = 8;
+export const MAX_BOXED_RESULT_RENDERED_LINES = 160;
+
+const RENDER_TRUNCATION_SUFFIX = "… (truncated)";
+const TRUNCATE_ELLIPSIS = "…";
+const ANSI_RESET = "\x1b[0m";
+const ESC = "\x1b";
+const SGR_PREFIX_PATTERN = new RegExp(`^(?:${ESC}\\[[0-9;]*m)+`);
+const SGR_SUFFIX_PATTERN = new RegExp(`(?:${ESC}\\[[0-9;]*m)+$`);
+
+type SimpleSgrWrappedText = {
+	prefix: string;
+	body: string;
+	suffix: string;
+	kind: "sgrAscii" | "sgrSimple";
+};
+
+type FastTextKind = "ascii" | "sgrAscii" | "simple" | "sgrSimple";
+
+type FastTextWidth = {
+	visibleWidth: number;
+	kind: FastTextKind;
+};
+
+type FastTruncateResult = {
+	text: string;
+	visibleWidth: number;
+	kind: FastTextKind;
+};
+
+export type FastBoxLineContent = {
+	text: string;
+	visibleWidth: number;
+	kind: FastTextKind;
+};
+
+export type BoxedResultRenderBudget = {
+	headLines: number;
+	tailLines: number;
+	maxRenderedLines: number;
+};
+
+/**
+ * Cut a string to a maximum UTF-16 length without splitting a surrogate pair
+ * (emoji / supplementary-plane characters). A plain `slice` on a non-ASCII
+ * boundary produces a lone surrogate that renders as the U+FFFD replacement
+ * character (�).
+ */
+export function truncateAtCodePointBoundary(text: string, maxChars: number): string {
+	if (text.length <= maxChars) return text;
+	const code = text.charCodeAt(maxChars);
+	const end = code >= 0xdc00 && code <= 0xdfff ? maxChars - 1 : maxChars;
+	return text.slice(0, end);
+}
+
+export function clampRenderLine(line: string, maxChars = MAX_RENDER_LINE_CHARS): string {
+	if (line.length <= maxChars) return line;
+	return truncateAtCodePointBoundary(line, maxChars) + RENDER_TRUNCATION_SUFFIX;
+}
+
+function isPrintableAsciiCode(code: number): boolean {
+	return code >= 0x20 && code <= 0x7e;
+}
+
+function isSimpleWidthOneGlyphCode(code: number): boolean {
+	if (code >= 0x2500 && code <= 0x257f) return true; // box drawing
+	if (code >= 0x2580 && code <= 0x259f) return true; // block elements
+	if (code >= 0x25a0 && code <= 0x25ff) return true; // geometric shapes used by UI status marks
+	if (code >= 0x2800 && code <= 0x28ff) return true; // braille loader frames
+	return (
+		code === 0x00b2 || // ²
+		code === 0x00b7 || // ·
+		code === 0x03c0 || // π
+		code === 0x2013 || // –
+		code === 0x2014 || // —
+		code === 0x2022 || // •
+		code === 0x2026 || // …
+		code === 0x2191 || // ↑
+		code === 0x2192 || // →
+		code === 0x2193 || // ↓
+		code === 0x21b3 || // ↳
+		code === 0x2205 || // ∅
+		code === 0x2248 || // ≈
+		code === 0x22ef || // ⋯
+		code === 0x2387 || // ⎇
+		code === 0x23f9 || // ⏹
+		code === 0x270e || // ✎
+		code === 0x2713 || // ✓
+		code === 0x2717 || // ✗
+		code === 0x276f || // ❯
+		code === 0x2794 // ➔
+	);
+}
+
+function isSimpleWidthOneCode(code: number): boolean {
+	return isPrintableAsciiCode(code) || isSimpleWidthOneGlyphCode(code);
+}
+
+function breakLongAsciiWord(word: string, width: number): string[] {
+	const lines: string[] = [];
+	for (let i = 0; i < word.length; i += width) {
+		lines.push(word.slice(i, i + width));
+	}
+	return lines.length > 0 ? lines : [""];
+}
+
+function wrapPrintableAsciiLine(line: string, width: number): string[] {
+	if (!line) return [""];
+	if (line.length <= width) return [line];
+
+	const wrapped: string[] = [];
+	let currentLine = "";
+	let currentVisibleLength = 0;
+	let tokenStart = 0;
+
+	while (tokenStart < line.length) {
+		const tokenIsSpace = line[tokenStart] === " ";
+		let tokenEnd = tokenStart + 1;
+		while (tokenEnd < line.length && (line[tokenEnd] === " ") === tokenIsSpace) tokenEnd++;
+
+		const token = line.slice(tokenStart, tokenEnd);
+		const tokenVisibleLength = token.length;
+		if (tokenVisibleLength > width && !tokenIsSpace) {
+			if (currentLine) {
+				wrapped.push(currentLine.trimEnd());
+				currentLine = "";
+				currentVisibleLength = 0;
+			}
+			const broken = breakLongAsciiWord(token, width);
+			wrapped.push(...broken.slice(0, -1));
+			currentLine = broken[broken.length - 1] ?? "";
+			currentVisibleLength = currentLine.length;
+			tokenStart = tokenEnd;
+			continue;
+		}
+
+		const totalNeeded = currentVisibleLength + tokenVisibleLength;
+		if (totalNeeded > width && currentVisibleLength > 0) {
+			wrapped.push(currentLine.trimEnd());
+			if (tokenIsSpace) {
+				currentLine = "";
+				currentVisibleLength = 0;
+			} else {
+				currentLine = token;
+				currentVisibleLength = tokenVisibleLength;
+			}
+		} else {
+			currentLine += token;
+			currentVisibleLength += tokenVisibleLength;
+		}
+
+		tokenStart = tokenEnd;
+	}
+
+	if (currentLine) wrapped.push(currentLine);
+	return wrapped.length > 0 ? wrapped.map((wrappedLine) => wrappedLine.trimEnd()) : [""];
+}
+
+function matchSimpleSgrWrappedText(text: string): SimpleSgrWrappedText | null {
+	const prefixMatch = SGR_PREFIX_PATTERN.exec(text);
+	const suffixMatch = SGR_SUFFIX_PATTERN.exec(text);
+	if (!prefixMatch || !suffixMatch) return null;
+	const prefix = prefixMatch[0];
+	const suffix = suffixMatch[0];
+	const bodyStart = prefix.length;
+	const bodyEnd = suffixMatch.index;
+	if (bodyEnd < bodyStart) return null;
+
+	const body = text.slice(bodyStart, bodyEnd);
+	const bodyWidth = knownVisibleWidth(body);
+	if (!bodyWidth || bodyWidth.kind === "sgrAscii" || bodyWidth.kind === "sgrSimple") return null;
+	return { prefix, body, suffix, kind: bodyWidth.kind === "ascii" ? "sgrAscii" : "sgrSimple" };
+}
+
+function wrapSimpleSgrWrappedText(
+	text: string,
+	width: number,
+): { lines: string[]; kind: "sgrAscii" | "sgrSimple" } | null {
+	const match = matchSimpleSgrWrappedText(text);
+	if (!match) return null;
+	return {
+		lines: wrapPrintableAsciiLine(match.body, width).map((line) => `${match.prefix}${line}${match.suffix}`),
+		kind: match.kind,
+	};
+}
+
+function readSgrSequenceEnd(text: string, offset: number): number {
+	if (text.charCodeAt(offset) !== 0x1b || text[offset + 1] !== "[") return -1;
+	let cursor = offset + 2;
+	while (cursor < text.length) {
+		const code = text.charCodeAt(cursor);
+		if (code === 0x6d) return cursor + 1; // m
+		if (code !== 0x3b && (code < 0x30 || code > 0x39)) return -1; // ; or 0-9
+		cursor++;
+	}
+	return -1;
+}
+
+function knownVisibleWidth(text: string): FastTextWidth | null {
+	let width = 0;
+	let sawSgr = false;
+	let sawSimpleGlyph = false;
+	for (let i = 0; i < text.length; ) {
+		const sgrEnd = readSgrSequenceEnd(text, i);
+		if (sgrEnd > i) {
+			sawSgr = true;
+			i = sgrEnd;
+			continue;
+		}
+		const code = text.charCodeAt(i);
+		if (!isSimpleWidthOneCode(code)) return null;
+		if (!isPrintableAsciiCode(code)) sawSimpleGlyph = true;
+		width++;
+		i++;
+	}
+	if (sawSgr) return { visibleWidth: width, kind: sawSimpleGlyph ? "sgrSimple" : "sgrAscii" };
+	return { visibleWidth: width, kind: sawSimpleGlyph ? "simple" : "ascii" };
+}
+
+function knownEllipsisWidth(text: string): number | null {
+	if (text === TRUNCATE_ELLIPSIS) return 1;
+	return knownVisibleWidth(text)?.visibleWidth ?? null;
+}
+
+function truncatePrintableAscii(
+	text: string,
+	width: number,
+	ellipsis = TRUNCATE_ELLIPSIS,
+): { text: string; visibleWidth: number } {
+	if (width <= 0) return { text: "", visibleWidth: 0 };
+	if (text.length <= width) return { text, visibleWidth: text.length };
+	const ellipsisWidth = knownEllipsisWidth(ellipsis);
+	if (ellipsisWidth === null) return { text: text.slice(0, width), visibleWidth: width };
+	if (ellipsisWidth >= width) {
+		if (ellipsis === TRUNCATE_ELLIPSIS) return { text: TRUNCATE_ELLIPSIS, visibleWidth: 1 };
+		return { text: ellipsis.slice(0, width), visibleWidth: Math.min(width, ellipsis.length) };
+	}
+	const targetWidth = Math.max(0, width - ellipsisWidth);
+	return { text: `${text.slice(0, targetWidth)}${ellipsis}`, visibleWidth: targetWidth + ellipsisWidth };
+}
+
+function truncateSgrAscii(
+	text: string,
+	width: number,
+	ellipsis: string,
+	visibleWidth: number,
+): { text: string; visibleWidth: number } | null {
+	if (visibleWidth <= width) return { text, visibleWidth };
+	const ellipsisWidth = knownEllipsisWidth(ellipsis);
+	if (ellipsisWidth === null) return null;
+	if (ellipsisWidth >= width) return truncatePrintableAscii(ellipsis, width, "");
+
+	const targetWidth = Math.max(0, width - ellipsisWidth);
+	let keptWidth = 0;
+	let output = "";
+	for (let i = 0; i < text.length && keptWidth < targetWidth; ) {
+		const sgrEnd = readSgrSequenceEnd(text, i);
+		if (sgrEnd > i) {
+			output += text.slice(i, sgrEnd);
+			i = sgrEnd;
+			continue;
+		}
+		const code = text.charCodeAt(i);
+		if (!isSimpleWidthOneCode(code)) return null;
+		output += text[i] ?? "";
+		keptWidth++;
+		i++;
+	}
+	return { text: `${output}${ANSI_RESET}${ellipsis}${ANSI_RESET}`, visibleWidth: keptWidth + ellipsisWidth };
+}
+
+function fastTruncateText(text: string, width: number, ellipsis = TRUNCATE_ELLIPSIS): FastTruncateResult | null {
+	const knownWidth = knownVisibleWidth(text);
+	if (!knownWidth) return null;
+	if (knownWidth.kind === "ascii" || knownWidth.kind === "simple")
+		return { ...truncatePrintableAscii(text, width, ellipsis), kind: knownWidth.kind };
+
+	const simple = matchSimpleSgrWrappedText(text);
+	if (simple) {
+		const truncated = truncatePrintableAscii(simple.body, width, ellipsis);
+		return {
+			text: `${simple.prefix}${truncated.text}${simple.suffix}`,
+			visibleWidth: truncated.visibleWidth,
+			kind: simple.kind,
+		};
+	}
+
+	const truncated = truncateSgrAscii(text, width, ellipsis, knownWidth.visibleWidth);
+	return truncated ? { ...truncated, kind: knownWidth.kind } : null;
+}
+
+export function safeVisibleWidth(text: string): number {
+	const fastWidth = knownVisibleWidth(text);
+	if (fastWidth) return fastWidth.visibleWidth;
+	if (text === TRUNCATE_ELLIPSIS) return 1;
+	return tuiVisibleWidth(text);
+}
+
+export function safeTruncateToWidth(text: string, maxWidth: number, ellipsis = "...", pad = false): string {
+	const width = Math.floor(maxWidth);
+	if (!Number.isFinite(width) || width <= 0) return "";
+	if (text.length === 0) return pad ? " ".repeat(width) : "";
+
+	const truncated = fastTruncateText(text, width, ellipsis);
+	if (truncated)
+		return pad ? `${truncated.text}${" ".repeat(Math.max(0, width - truncated.visibleWidth))}` : truncated.text;
+
+	return tuiTruncateToWidth(text, maxWidth, ellipsis, pad);
+}
+
+export function fastBoxLineContent(content: string, width: number): FastBoxLineContent | null {
+	const contentWidth = Math.floor(width);
+	if (!Number.isFinite(contentWidth) || contentWidth <= 0) return null;
+
+	return fastTruncateText(content, contentWidth);
+}
+
+export function safeWrapTextWithAnsi(text: string, width: number, maxChars = MAX_RENDER_LINE_CHARS): string[] {
+	const clamped = clampRenderLine(text, maxChars);
+	const wrapWidth = Math.floor(width);
+	if (!Number.isFinite(wrapWidth) || wrapWidth <= 0) {
+		return wrapTextWithAnsi(clamped, width);
+	}
+	const clampedWidth = knownVisibleWidth(clamped);
+	if (clampedWidth?.kind === "ascii" || clampedWidth?.kind === "simple") {
+		return wrapPrintableAsciiLine(clamped, wrapWidth);
+	}
+	const simpleSgrWrapped = wrapSimpleSgrWrappedText(clamped, wrapWidth);
+	if (simpleSgrWrapped) {
+		return simpleSgrWrapped.lines;
+	}
+	return wrapTextWithAnsi(clamped, width);
+}
+
+export function boxedResultRenderBudget(
+	rawLineBudget: number = DEFAULT_COLLAPSED_RENDER_LINES,
+): BoxedResultRenderBudget {
+	const rawLines = Math.max(
+		0,
+		Math.floor(Number.isFinite(rawLineBudget) ? rawLineBudget : DEFAULT_COLLAPSED_RENDER_LINES),
+	);
+	const maxRenderedLines = Math.max(1, Math.min(rawLines * 3, MAX_BOXED_RESULT_RENDERED_LINES));
+	const tailLines = Math.min(
+		Math.ceil(rawLines * 0.15),
+		MAX_BOXED_RESULT_RENDERED_TAIL_LINES,
+		Math.max(0, maxRenderedLines - 1),
+	);
+	const headLines = Math.min(
+		rawLines,
+		MAX_BOXED_RESULT_RENDERED_HEAD_LINES,
+		Math.max(1, maxRenderedLines - tailLines - 1),
+	);
+
+	return { headLines, tailLines, maxRenderedLines };
+}