@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-zentui/extensions/zentui/user-message-styles.ts

@@ -1,23 +1,33 @@
 import type { Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
+import * as PiCodingAgent from "@earendil-works/pi-coding-agent";
 import {
 	Markdown,
 	type MarkdownTheme,
 	truncateToWidth,
 	visibleWidth,
 } from "@earendil-works/pi-tui";
+import { componentColor } from "./component-colors";
 import type { ZentuiConfig } from "./config";
 import {
 	EDITOR_ACCENT_FALLBACK,
 	EDITOR_BORDER_FALLBACK,
 	renderStyleForSourceOrFallbackStrict,
 } from "./style";
-import { sanitizeUserMessageSourceText } from "./user-message-osc";
+import {
+	sanitizeRenderedUserMessageLines,
+	sanitizeUserMessageSourceText,
+} from "./user-message-osc";
 
 export type UserMessageStyleRenderInput = {
 	text: string;
 	width: number;
 	theme?: Theme;
 	config: ZentuiConfig;
+	markdown?: {
+		theme: MarkdownTheme;
+		defaultTextStyle: ConstructorParameters<typeof Markdown>[4];
+		options: ConstructorParameters<typeof Markdown>[5];
+	};
 };
 
 function themeFg(theme: Theme | undefined, color: ThemeColor, text: string): string {
@@ -26,6 +36,8 @@ function themeFg(theme: Theme | undefined, color: ThemeColor, text: string): str
 
 export function makeMarkdownTheme(theme: Theme | undefined): MarkdownTheme {
 	return {
+		// OMP Markdown also requires its host symbol palette and additional native hooks.
+		...("describe" in Markdown.prototype ? PiCodingAgent.getMarkdownTheme() : {}),
 		heading: (text) => themeFg(theme, "mdHeading", text),
 		link: (text) => themeFg(theme, "mdLink", text),
 		linkUrl: (text) => themeFg(theme, "mdLinkUrl", text),
@@ -43,10 +55,33 @@ export function makeMarkdownTheme(theme: Theme | undefined): MarkdownTheme {
 	};
 }
 
-function renderMarkdown(text: string, width: number, theme: Theme | undefined): string[] {
-	const renderer = new Markdown(text, 0, 0, makeMarkdownTheme(theme), {
-		color: (content) => themeFg(theme, "accent", content),
-	});
+function renderMarkdown(input: UserMessageStyleRenderInput, width: number): string[] {
+	const { text, theme, markdown } = input;
+	const transform = markdown?.options?.transform;
+	const renderer = new Markdown(
+		text,
+		0,
+		0,
+		markdown?.theme ?? makeMarkdownTheme(theme),
+		markdown?.defaultTextStyle ?? {
+			color: (content) => themeFg(theme, "accent", content),
+		},
+		// OMP's native Markdown uses the sixth argument for numeric code-block
+		// indentation, not Pi's parser options. Leave its supported default intact.
+		"describe" in Markdown.prototype
+			? undefined
+			: {
+					...markdown?.options,
+					preserveOrderedListMarkers: true,
+					preserveBackslashEscapes: true,
+					...(transform
+						? {
+								transform: (source: string, availableWidth: number) =>
+									sanitizeUserMessageSourceText(transform(source, availableWidth)),
+							}
+						: {}),
+				},
+	);
 	const lines = renderer.render(Math.max(1, width));
 	return lines.length > 0 ? lines : [""];
 }
@@ -65,7 +100,7 @@ function accent(theme: Theme | undefined, config: ZentuiConfig, text: string): s
 		? renderStyleForSourceOrFallbackStrict(
 				theme,
 				config.components.userMessages.colorSource,
-				config.colors.editorAccent,
+				componentColor(config, "userMessages", "accent"),
 				EDITOR_ACCENT_FALLBACK,
 				text,
 			)
@@ -77,7 +112,7 @@ function border(theme: Theme | undefined, config: ZentuiConfig, text: string): s
 		? renderStyleForSourceOrFallbackStrict(
 				theme,
 				config.components.userMessages.colorSource,
-				config.colors.editorBorder,
+				componentColor(config, "userMessages", "border"),
 				EDITOR_BORDER_FALLBACK,
 				text,
 			)
@@ -88,11 +123,12 @@ function renderRail(theme: Theme | undefined, config: ZentuiConfig): string {
 	return `${accent(theme, config, config.icons.rail)} `;
 }
 
-function renderFramed({ text, width, theme, config }: UserMessageStyleRenderInput): string[] {
+function renderFramed(input: UserMessageStyleRenderInput): string[] {
+	const { width, theme, config } = input;
 	if (width <= 0) return [""];
 	const rail = renderRail(theme, config);
 	const contentWidth = Math.max(1, width - visibleWidth(rail));
-	const body = renderMarkdown(text, contentWidth, theme);
+	const body = renderMarkdown(input, contentWidth);
 	const row = (line: string) => {
 		const available = Math.max(0, width - visibleWidth(rail));
 		return truncateToWidth(`${rail}${fillLine(line, available)}`, width, "");
@@ -101,45 +137,43 @@ function renderFramed({ text, width, theme, config }: UserMessageStyleRenderInpu
 	return [rule, row(""), ...body.map(row), row(""), rule];
 }
 
-function renderFramedCopyFriendly({
-	text,
-	width,
-	theme,
-	config,
-}: UserMessageStyleRenderInput): string[] {
+function renderFramedCopyFriendly(input: UserMessageStyleRenderInput): string[] {
+	const { width, theme, config } = input;
 	if (width <= 0) return [""];
 	const prefix = width > 1 ? " " : "";
-	const body = renderMarkdown(text, width - prefix.length, theme).map((line) =>
+	const body = renderMarkdown(input, width - prefix.length).map((line) =>
 		fillLine(`${prefix}${line}`, width),
 	);
 	const rule = truncateToWidth(border(theme, config, "─".repeat(width)), width, "");
 	return [rule, "", ...body, "", rule];
 }
 
-function renderCompact({ text, width, theme, config }: UserMessageStyleRenderInput): string[] {
+function renderCompact(input: UserMessageStyleRenderInput): string[] {
+	const { width, theme, config } = input;
 	if (width <= 0) return [""];
 	const rail = renderRail(theme, config);
 	const railWidth = visibleWidth(rail);
 	if (width <= railWidth) {
-		return renderMarkdown(text, width, theme).map((line) =>
+		return renderMarkdown(input, width).map((line) =>
 			truncateToWidth(trimMarkdownPadding(line), width, ""),
 		);
 	}
 	const contentWidth = width - railWidth;
-	return renderMarkdown(text, contentWidth, theme).map((line) =>
+	return renderMarkdown(input, contentWidth).map((line) =>
 		truncateToWidth(`${rail}${trimMarkdownPadding(line)}`, width, ""),
 	);
 }
 
-function renderLabeled({ text, width, theme, config }: UserMessageStyleRenderInput): string[] {
+function renderLabeled(input: UserMessageStyleRenderInput): string[] {
+	const { width, theme, config } = input;
 	if (width <= 0) return [""];
 	if (width <= 2) {
-		return renderMarkdown(text, width, theme).map((line) => truncateToWidth(line, width, ""));
+		return renderMarkdown(input, width).map((line) => truncateToWidth(line, width, ""));
 	}
 
 	const horizontalPadding = width >= 5 ? 1 : 0;
 	const contentWidth = Math.max(1, width - 2 - horizontalPadding * 2);
-	const body = renderMarkdown(text, contentWidth, theme);
+	const body = renderMarkdown(input, contentWidth);
 	const top =
 		width >= 9
 			? `${border(theme, config, "╭─")}${accent(theme, config, " User ")}${border(
@@ -166,27 +200,29 @@ export function userMessageStyleCacheKey(config: ZentuiConfig): string {
 			return [
 				"framed",
 				messages.colorSource,
-				config.colors.editorAccent ?? "",
-				config.colors.editorBorder ?? "",
+				componentColor(config, "userMessages", "accent") ?? "<inherit>",
+				componentColor(config, "userMessages", "border") ?? "<inherit>",
 				config.icons.rail,
 			].join("\0");
 		case "framed-copy-friendly":
-			return ["framed-copy-friendly", messages.colorSource, config.colors.editorBorder ?? ""].join(
-				"\0",
-			);
+			return [
+				"framed-copy-friendly",
+				messages.colorSource,
+				componentColor(config, "userMessages", "border") ?? "<inherit>",
+			].join("\0");
 		case "compact":
 			return [
 				"compact",
 				messages.colorSource,
-				config.colors.editorAccent ?? "",
+				componentColor(config, "userMessages", "accent") ?? "<inherit>",
 				config.icons.rail,
 			].join("\0");
 		case "labeled":
 			return [
 				"labeled",
 				messages.colorSource,
-				config.colors.editorAccent ?? "",
-				config.colors.editorBorder ?? "",
+				componentColor(config, "userMessages", "accent") ?? "<inherit>",
+				componentColor(config, "userMessages", "border") ?? "<inherit>",
 				"User:v1",
 			].join("\0");
 	}
@@ -208,8 +244,10 @@ function renderSelectedUserMessageStyle(input: UserMessageStyleRenderInput): str
 export function renderUserMessageStyle(input: UserMessageStyleRenderInput): string[] {
 	// Raw user input is a terminal trust boundary. Strip every source control,
 	// including OSC 8; Markdown may add its own validated links afterward.
-	return renderSelectedUserMessageStyle({
-		...input,
-		text: sanitizeUserMessageSourceText(input.text),
-	});
+	return sanitizeRenderedUserMessageLines(
+		renderSelectedUserMessageStyle({
+			...input,
+			text: sanitizeUserMessageSourceText(input.text),
+		}),
+	);
 }

package/dist/extensions/pi-zentui/extensions/zentui/user-message.ts

@@ -1,5 +1,5 @@
 import { type Theme, UserMessageComponent } from "@earendil-works/pi-coding-agent";
-import { wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { type Markdown, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import type { ZentuiConfig } from "./config";
 import { installPrototypePatch, removePrototypePatch } from "./prototype-patch-registry";
 import {
@@ -7,7 +7,11 @@ import {
 	sanitizeRenderedUserMessageText,
 	sanitizeUserMessageSourceText,
 } from "./user-message-osc";
-import { renderUserMessageStyle, userMessageStyleCacheKey } from "./user-message-styles";
+import {
+	renderUserMessageStyle,
+	type UserMessageStyleRenderInput,
+	userMessageStyleCacheKey,
+} from "./user-message-styles";
 
 const OSC133_ZONE_START = "\x1b]133;A\x07";
 const OSC133_ZONE_END = "\x1b]133;B\x07";
@@ -15,17 +19,18 @@ const OSC133_ZONE_FINAL = "\x1b]133;C\x07";
 
 type PatchableUserMessagePrototype = {
 	children?: unknown[];
+	describe?: () => unknown;
 };
 
 type Cleanup = () => void;
 
 type UserMessageRenderCache = {
-	hasMarkdownText: boolean;
-	text?: string;
-	width?: number;
+	markdown: object;
+	text: string;
+	width: number;
 	theme?: Theme;
-	configKey?: string;
-	renderedLines?: string[];
+	configKey: string;
+	renderedLines: string[];
 };
 
 const userMessageRenderCache = new WeakMap<object, UserMessageRenderCache>();
@@ -38,30 +43,197 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-function findMarkdownText(value: unknown): string | undefined {
-	if (!isRecord(value)) return undefined;
-	if (typeof value.text === "string") return value.text;
+function isNativeMarkdown(renderer: unknown): boolean {
+	return (
+		isRecord(renderer) &&
+		renderer.constructor?.name === "Markdown" &&
+		typeof renderer.text === "string" &&
+		["render", "setText", "invalidate"].every((key) => typeof renderer[key] === "function")
+	);
+}
 
-	const children = value.children;
-	if (!Array.isArray(children)) return undefined;
+const sanitizedMarkdownCache = new WeakMap<
+	object,
+	{ lines: unknown; sourceText: string; text: string; options: unknown }
+>();
 
-	for (const child of children) {
-		const text = findMarkdownText(child);
-		if (text !== undefined) return text;
+// Framing eligibility is deliberately narrower than the source trust boundary.
+// Unknown renderers still fail open: rendered controls alone cannot distinguish
+// raw input from renderer-generated hyperlinks or theme styles.
+function withSanitizedMarkdownSources<T>(instance: unknown, render: (adapted: boolean) => T): T {
+	const restore: Array<() => void> = [];
+	const visited = new Set<object>();
+	const visit = (value: unknown) => {
+		if (!isRecord(value) || visited.has(value)) return;
+		visited.add(value);
+		if (isNativeMarkdown(value)) {
+			const text = Object.getOwnPropertyDescriptor(value, "text");
+			const options = Object.getOwnPropertyDescriptor(value, "options");
+			const cachedText = Object.getOwnPropertyDescriptor(value, "cachedText");
+			if (!text?.writable || !options?.writable || !cachedText?.writable) return;
+			if (!isRecord(options.value)) return;
+			const transform = options.value.transform;
+			if (transform !== undefined && typeof transform !== "function") return;
+			const cached = sanitizedMarkdownCache.get(value);
+			// Source sanitization depends only on the immutable raw string, not on
+			// width, theme, options or native output invalidation. Reuse just that
+			// result; the guarded native render and its cache checks still run.
+			const source =
+				cached && cached.sourceText === text.value
+					? cached.text
+					: sanitizeUserMessageSourceText(text.value);
+			const safeOptions = {
+				...options.value,
+				...(transform
+					? {
+							transform: (input: string, width: number) =>
+								sanitizeUserMessageSourceText(
+									Reflect.apply(transform, options.value, [input, width]),
+								),
+						}
+					: {}),
+			};
+			restore.push(() => {
+				Object.defineProperty(value, "text", text);
+				Object.defineProperty(value, "options", options);
+				// Never let a native/unpatched render reuse a source-sanitized cache.
+				// Keep the lines only for the next guarded render; invalidate() clears
+				// them normally, and cleanup needs no retained component references.
+				sanitizedMarkdownCache.set(value, {
+					lines: value.cachedText === source ? value.cachedLines : undefined,
+					sourceText: text.value,
+					text: source,
+					options: options.value,
+				});
+				Object.defineProperty(value, "cachedText", { ...cachedText, value: undefined });
+			});
+			value.text = source;
+			value.options = safeOptions;
+			value.cachedText =
+				cached?.lines &&
+				cached.lines === value.cachedLines &&
+				cached.text === source &&
+				cached.options === options.value
+					? source
+					: undefined;
+			return;
+		}
+		if (Array.isArray(value.children)) for (const child of value.children) visit(child);
+	};
+	try {
+		try {
+			visit(instance);
+		} catch {
+			// Uninspectable predecessor state remains outside the native adapter.
+		}
+		return render(restore.length > 0);
+	} finally {
+		for (const undo of restore.reverse()) undo();
 	}
-
-	return undefined;
 }
 
-function getCachedMarkdownText(instance: object): string | undefined {
-	const cached = userMessageRenderCache.get(instance);
-	if (cached?.hasMarkdownText) return cached.text;
-
-	const text = findMarkdownText(instance);
-	if (text !== undefined) {
-		userMessageRenderCache.set(instance, { ...cached, hasMarkdownText: true, text });
+// Normal user messages have no public framing renderer. Only adapt the native
+// zero-padding Markdown child; unfamiliar component trees delegate unchanged.
+// Shape checks also support separate same-version Pi TUI package instances.
+function nativeMarkdown(instance: PatchableUserMessagePrototype):
+	| {
+			renderer: Markdown;
+			text: string;
+			input: UserMessageStyleRenderInput["markdown"];
+	  }
+	| undefined {
+	// OMP keeps Markdown state in ECMAScript private fields. Its public native
+	// description exposes the complete source without truncated debug previews.
+	const direct = instance.children;
+	if (
+		Array.isArray(direct) &&
+		direct.length === 1 &&
+		isRecord(direct[0]) &&
+		typeof direct[0].describe === "function" &&
+		isRecord(instance) &&
+		typeof instance.describe === "function"
+	) {
+		const bubble = Reflect.apply(instance.describe, instance, []);
+		const source = Reflect.apply(direct[0].describe, direct[0], []);
+		if (
+			!isRecord(bubble) ||
+			!isRecord(bubble.p) ||
+			bubble.p.role !== "omp.user" ||
+			!Array.isArray(bubble.c) ||
+			!bubble.c.every(
+				(child) =>
+					isRecord(child) &&
+					(child.k === "md" || (isRecord(child.p) && child.p.role === "omp.user.tools")),
+			) ||
+			!isRecord(source) ||
+			source.k !== "md" ||
+			!isRecord(source.p) ||
+			typeof source.p.text !== "string"
+		)
+			return undefined;
+		return {
+			renderer: direct[0] as unknown as Markdown,
+			text: source.p.text,
+			input: undefined,
+		};
+	}
+	const children = direct;
+	if (!Array.isArray(children) || children.length !== 1) return undefined;
+	// Pi >=1.0 holds the Markdown directly (it pads/colors itself); older Pi
+	// wrapped it in a Box. Accept both shapes.
+	let renderer = children[0];
+	const direct1 = isNativeMarkdown(renderer);
+	if (isRecord(renderer) && !direct1) {
+		const box = renderer;
+		if (!Array.isArray(box.children) || box.children.length !== 1) return undefined;
+		renderer = box.children[0];
 	}
-	return text;
+	if (!isNativeMarkdown(renderer)) return undefined;
+	const child = renderer as unknown as Record<string, unknown>;
+	if (typeof child.text !== "string" || !isRecord(child.theme)) return undefined;
+	// Box-wrapped (older Pi) Markdown must be unpadded; Pi >=1.0 pads it itself.
+	if (!direct1 && (child.paddingX !== 0 || child.paddingY !== 0)) return undefined;
+	for (const key of [
+		"heading",
+		"link",
+		"linkUrl",
+		"code",
+		"codeBlock",
+		"codeBlockBorder",
+		"quote",
+		"quoteBorder",
+		"hr",
+		"listBullet",
+		"bold",
+		"italic",
+		"underline",
+		"strikethrough",
+	]) {
+		if (typeof child.theme[key] !== "function") return undefined;
+	}
+	if (child.options !== undefined && !isRecord(child.options)) return undefined;
+	if (
+		isRecord(child.options) &&
+		child.options.transform !== undefined &&
+		typeof child.options.transform !== "function"
+	)
+		return undefined;
+	if (child.defaultTextStyle !== undefined && !isRecord(child.defaultTextStyle)) return undefined;
+	// Pi >=1.0 puts the message background in defaultTextStyle; Zentui frames draw their own.
+	const { bgColor: _bg, ...textStyle } = (child.defaultTextStyle ?? {}) as Record<string, unknown>;
+	return {
+		renderer: renderer as unknown as Markdown,
+		text: child.text,
+		input: {
+			theme: child.theme as unknown as NonNullable<
+				UserMessageStyleRenderInput["markdown"]
+			>["theme"],
+			defaultTextStyle: (child.defaultTextStyle === undefined
+				? undefined
+				: textStyle) as NonNullable<UserMessageStyleRenderInput["markdown"]>["defaultTextStyle"],
+			options: child.options as NonNullable<UserMessageStyleRenderInput["markdown"]>["options"],
+		},
+	};
 }
 
 function renderZentuiUserMessage(
@@ -72,12 +244,14 @@ function renderZentuiUserMessage(
 ): string[] | undefined {
 	if (!isRecord(instance)) return undefined;
 
-	const text = getCachedMarkdownText(instance);
-	if (text === undefined) return undefined;
+	const native = nativeMarkdown(instance);
+	if (!native) return undefined;
+	const text = native.text;
 	const configKey = userMessageStyleCacheKey(config);
 	const cached = userMessageRenderCache.get(instance);
 	if (
-		cached?.hasMarkdownText &&
+		cached?.markdown === native.renderer &&
+		cached.text === text &&
 		cached.width === width &&
 		cached.theme === theme &&
 		cached.configKey === configKey &&
@@ -87,13 +261,14 @@ function renderZentuiUserMessage(
 	}
 
 	const lines = renderUserMessageStyle({
+		markdown: native.input,
 		text,
 		width,
 		theme,
 		config,
 	});
 	userMessageRenderCache.set(instance, {
-		hasMarkdownText: true,
+		markdown: native.renderer,
 		text,
 		width,
 		theme,
@@ -130,7 +305,9 @@ function renderSafeSourceFallback(
 ): string[] | undefined {
 	let text: string | undefined;
 	try {
-		text = isRecord(instance) ? getCachedMarkdownText(instance) : undefined;
+		// A plain fallback is only for an eligible frame that failed to render.
+		// Never replace an unfamiliar predecessor tree (and its siblings) with it.
+		text = isRecord(instance) ? nativeMarkdown(instance)?.text : undefined;
 	} catch {
 		return undefined;
 	}
@@ -171,7 +348,15 @@ export function installUserMessageStyle(
 			"user-message-render",
 			({ predecessor, receiver, args }) => {
 				const renderPredecessor = () =>
-					sanitizePredecessorRender(Reflect.apply(predecessor, receiver, args));
+					withSanitizedMarkdownSources(receiver, (adapted) => {
+						const result = sanitizePredecessorRender(Reflect.apply(predecessor, receiver, args));
+						return adapted &&
+							Array.isArray(result) &&
+							result.length > 0 &&
+							result.every((row) => typeof row === "string")
+							? withPromptZoneMarkers(result)
+							: result;
+					});
 				const width = args[0];
 				if (typeof width !== "number") return renderPredecessor();
 				try {
@@ -181,15 +366,15 @@ export function installUserMessageStyle(
 						getTheme(),
 						getConfig(),
 					);
-					if (!lines) return renderPredecessor();
-					return lines.length ? withPromptZoneMarkers(lines) : lines;
+					if (lines) return lines.length ? withPromptZoneMarkers(lines) : lines;
 				} catch {
 					const safeFallback = renderSafeSourceFallback(
 						receiver as PatchableUserMessagePrototype,
 						width,
 					);
-					return safeFallback ?? renderPredecessor();
+					if (safeFallback) return safeFallback;
 				}
+				return renderPredecessor();
 			},
 		);
 	} catch (error) {