@selesai/code 0.9.15 → 0.10.1

package/dist/extensions/pi-zentui/test/editor-metadata-format.test.ts

@@ -0,0 +1,405 @@
+import { stripVTControlCharacters } from "node:util";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { describe, expect, it } from "vitest";
+import { defaultConfig } from "../extensions/zentui/config";
+import {
+	type EditorMetadataValues,
+	renderEditorMetadataFormat,
+	renderEditorMetadataFormatSplit,
+	sanitizeEditorMetadataText,
+} from "../extensions/zentui/editor-metadata-format";
+import { composeEditorMetadataLine, renderPolishedEditorFrame } from "../extensions/zentui/ui";
+
+function makeTheme(): Theme {
+	return {
+		fg(color: string, text: string) {
+			return `[${color}]${text}`;
+		},
+		bold(text: string) {
+			return text;
+		},
+		italic(text: string) {
+			return text;
+		},
+		underline(text: string) {
+			return text;
+		},
+	} as unknown as Theme;
+}
+
+function makeAnsiTheme(): Theme {
+	return {
+		fg(_color: string, text: string) {
+			return `\x1b[31m${text}\x1b[39m`;
+		},
+		bold(text: string) {
+			return text;
+		},
+		italic(text: string) {
+			return text;
+		},
+		underline(text: string) {
+			return text;
+		},
+	} as unknown as Theme;
+}
+
+const values: EditorMetadataValues = {
+	model: "Model Label",
+	modelId: "model-id",
+	modelName: "Model Name",
+	provider: "Provider",
+	thinking: "high",
+	sessionName: "Session",
+	contextPercent: 26.8,
+	contextWindow: 272_000,
+	inputTokens: 76_000,
+	outputTokens: 1_600,
+	cacheHitRate: 73.4,
+};
+
+function render(format: string, overrides: Partial<EditorMetadataValues> = {}): string {
+	return renderEditorMetadataFormat(
+		format,
+		{ ...values, ...overrides },
+		makeTheme(),
+		defaultConfig,
+	);
+}
+
+describe("renderEditorMetadataFormat", () => {
+	it("renders all supported variables in both syntaxes", () => {
+		expect(render(`$model|\${model_id}|$model_name|\${provider}|$thinking|\${session_name}`)).toBe(
+			"[accent]Model Label[border]|[accent]model-id[border]|[accent]Model Name[border]|[text]Provider[border]|[muted]high[border]|[border]Session",
+		);
+	});
+
+	it("renders usage variables in both syntaxes without duplicating cache metadata", () => {
+		expect(render(`$context | \${tokens} | $cache_hit`)).toBe(
+			"[border]26.8%/272k[border] | [border]↑76k ↓1.6k[border] | [border]73.4%",
+		);
+		expect(render(`\${context} | $tokens | \${cache_hit}`)).toBe(
+			"[border]26.8%/272k[border] | [border]↑76k ↓1.6k[border] | [border]73.4%",
+		);
+		expect(render("$tokens")).not.toContain("73.4%");
+		expect(render("$cache_hit")).not.toMatch(/[↑↓]/);
+		expect(render("($context)( · $tokens)( · $cache_hit)")).toBe(
+			"[border]26.8%/272k[border] · [border]↑76k ↓1.6k[border] · [border]73.4%",
+		);
+	});
+
+	it("renders unavailable cache-hit metadata as zero", () => {
+		expect(render("before( · $cache_hit)", { cacheHitRate: undefined })).toBe(
+			"[border]before[border] · [border]0.0%",
+		);
+	});
+
+	it("uses conditional groups for optional values", () => {
+		expect(render("$model( · $thinking)", { thinking: "off" })).toBe("[accent]Model Label");
+		expect(render("$model( · $thinking)")).toBe("[accent]Model Label[border] · [muted]high");
+		expect(
+			render("$model( · $model_name)( · $session_name)", { modelName: "", sessionName: "" }),
+		).toBe("[accent]Model Label");
+		expect(render("before((literal))after")).toBe("[border]before[border]literal[border]after");
+	});
+
+	it("renders unknown variables and fill as empty", () => {
+		expect(render("a$unknown-b$fill-c($unknown)($fill)")).toBe("[border]a[border]-b[border]-c");
+	});
+
+	it("preserves the default layout and hides thinking when off", () => {
+		expect(render(defaultConfig.editorMetadataFormat, { thinking: "off" })).toBe(
+			"[accent]Model Label[border]  [text]Provider",
+		);
+		expect(render(defaultConfig.editorMetadataFormat)).toBe(
+			"[accent]Model Label[border]  [text]Provider[border]  [muted]high",
+		);
+	});
+
+	it("routes semantic and neutral styles", () => {
+		const config = {
+			...defaultConfig,
+			colors: {
+				...defaultConfig.colors,
+				editorModel: "success",
+				editorProvider: "syntaxKeyword",
+				editorThinking: "thinkingText",
+				editorThinkingHigh: "thinkingHigh",
+			},
+		};
+		const rendered = renderEditorMetadataFormat(
+			"$model $model_id $model_name $provider $thinking $session_name literal",
+			values,
+			makeTheme(),
+			config,
+		);
+		expect(rendered).toContain("[success]Model Label");
+		expect(rendered).toContain("[success]model-id");
+		expect(rendered).toContain("[success]Model Name");
+		expect(rendered).toContain("[syntaxKeyword]Provider");
+		expect(rendered).toContain("[thinkingHigh]high");
+		expect(rendered).toContain("[border]Session");
+		expect(rendered).toContain("[border] literal");
+	});
+
+	it("falls back to the shared thinking color", () => {
+		const config = {
+			...defaultConfig,
+			colors: { ...defaultConfig.colors, editorThinking: "thinkingText" },
+		};
+		expect(
+			renderEditorMetadataFormat("$thinking", { ...values, thinking: "low" }, makeTheme(), config),
+		).toBe("[thinkingText]low");
+	});
+
+	it.each([
+		[
+			{
+				editorThinking: "thinkingText",
+				editorThinkingXhigh: "thinkingXhigh",
+				editorThinkingMax: "thinkingMax",
+			},
+			"thinkingMax",
+		],
+		[{ editorThinking: "thinkingText", editorThinkingXhigh: "thinkingXhigh" }, "thinkingXhigh"],
+		[{ editorThinking: "thinkingText" }, "thinkingText"],
+	] as const)("resolves max thinking through its compatibility chain", (colors, expected) => {
+		const config = {
+			...defaultConfig,
+			colors: { ...defaultConfig.colors, ...colors },
+		};
+		expect(
+			renderEditorMetadataFormat("$thinking", { ...values, thinking: "max" }, makeTheme(), config),
+		).toBe(`[${expected}]max`);
+	});
+
+	it.each(["opencode", "opencode-copy-friendly"] as const)(
+		"plumbs usage metadata through the %s frame",
+		(style) => {
+			const config = structuredClone(defaultConfig);
+			config.components.editor.style = style;
+			config.components.editor.styles[style].metadataFormat = "$context $tokens $cache_hit";
+			const frame = renderPolishedEditorFrame({
+				width: 120,
+				editorLines: ["typed text"],
+				uiTheme: makeTheme(),
+				config,
+				modelMeta: {
+					modelLabel: values.model,
+					providerLabel: values.provider,
+					contextPercent: values.contextPercent,
+					contextWindow: values.contextWindow,
+					inputTokens: values.inputTokens,
+					outputTokens: values.outputTokens,
+					cacheHitRate: values.cacheHitRate,
+				},
+			});
+			const rendered = frame.join("\n");
+			expect(rendered).toContain("26.8%/272k");
+			expect(rendered).toContain("↑76k ↓1.6k");
+			expect(rendered).toContain("73.4%");
+		},
+	);
+
+	it("sanitizes literals and values without collapsing ordinary spaces", () => {
+		const rendered = render(
+			"\u001b]8;;https://example.com/$provider\u0007lit\u001b]8;;\u0007  x\n\ty:$model",
+			{
+				model: "\u001b]8;;https://example.com\u0007bad\u001b]8;;\u0007\r\n  model\u0000",
+			},
+		);
+		expect(rendered).toBe("[border]lit  x y:[accent]bad   model");
+		expect(rendered).not.toMatch(/[\u0000-\u001f\u007f-\u009f]/);
+	});
+});
+
+describe("editor metadata zones", () => {
+	it("keeps no-fill rendering byte-for-byte equivalent", () => {
+		const format = "$model( · $provider)(nested $fill)";
+		const legacy = renderEditorMetadataFormat(format, values, makeTheme(), defaultConfig);
+		const zones = renderEditorMetadataFormatSplit(format, values, makeTheme(), defaultConfig);
+		expect(zones).toEqual({ left: legacy, middle: "", right: "" });
+		expect(composeEditorMetadataLine(zones, undefined, 5)).toBe(legacy);
+	});
+
+	it("keeps nested fill non-structural when a top-level fill creates zones", () => {
+		expect(
+			renderEditorMetadataFormatSplit(
+				"$model$fill(nested $fill)",
+				values,
+				makeTheme(),
+				defaultConfig,
+			),
+		).toEqual({ left: "[accent]Model Label", middle: "", right: "" });
+	});
+
+	it("aligns one-fill left and right zones", () => {
+		expect(
+			composeEditorMetadataLine({ left: "left", middle: "", right: "right" }, undefined, 12),
+		).toBe("left   right");
+	});
+
+	it("centers the middle within the available gap", () => {
+		expect(
+			composeEditorMetadataLine({ left: "LLLLLLLLLL", middle: "MMM", right: "R" }, undefined, 20),
+		).toBe("LLLLLLLLLL   MMM   R");
+	});
+
+	it("drops conditional empty zones and keeps content after extra fills on the right", () => {
+		const conditional = renderEditorMetadataFormatSplit(
+			"$model$fill( · $session_name)$fill($context)",
+			{ ...values, sessionName: "" },
+			makeTheme(),
+			defaultConfig,
+		);
+		expect(conditional).toEqual({
+			left: "[accent]Model Label",
+			middle: "",
+			right: "[border]26.8%/272k",
+		});
+
+		const extra = renderEditorMetadataFormatSplit(
+			"$model$fill$provider$fill$thinking$fill$session_name",
+			values,
+			makeTheme(),
+			defaultConfig,
+		);
+		expect(extra).toEqual({
+			left: "[accent]Model Label",
+			middle: "[text]Provider",
+			right: "[muted]high[border]Session",
+		});
+	});
+
+	it("omits an unfittable middle instead of truncating it", () => {
+		const line = composeEditorMetadataLine(
+			{ left: "left", middle: "middle", right: "right" },
+			undefined,
+			11,
+		);
+		expect(line).toBe("left  right");
+		expect(line).not.toContain("middle");
+	});
+
+	it("reserves operational right status, then configured left, then configured right", () => {
+		const wide = composeEditorMetadataLine(
+			{ left: "left", middle: "", right: "right" },
+			"INSERT",
+			24,
+		);
+		expect(visibleWidth(wide)).toBe(24);
+		expect(wide.endsWith("right INSERT")).toBe(true);
+
+		expect(
+			stripVTControlCharacters(
+				composeEditorMetadataLine(
+					{ left: "left-long", middle: "middle", right: "configured-right" },
+					"INSERT",
+					12,
+				),
+			),
+		).toBe("left- INSERT");
+		expect(
+			stripVTControlCharacters(
+				composeEditorMetadataLine({ left: "left", middle: "", right: "right" }, "INSERT", 4),
+			),
+		).toBe("INSE");
+	});
+
+	it("keeps ANSI, CJK, combining marks, and emoji within the cell budget", () => {
+		const line = composeEditorMetadataLine(
+			{
+				left: "\x1b[31m界e\u0301👩‍💻abcdef\x1b[0m",
+				middle: "中🙂",
+				right: "右🙂tail",
+			},
+			"INSERT",
+			22,
+		);
+		expect(visibleWidth(line)).toBeLessThanOrEqual(22);
+		const plain = stripVTControlCharacters(line);
+		expect(plain).toContain("界e\u0301👩‍💻");
+		expect(plain).toContain("INSERT");
+		expect(plain).not.toContain("�");
+	});
+
+	it.each([
+		["opencode", 2, "regular-left", "regular-right"],
+		["opencode-copy-friendly", 1, "copy-left", "copy-right"],
+	] as const)(
+		"uses the %s metadata format and its chrome budget",
+		(style, chromeWidth, expectedLeft, expectedRight) => {
+			const config = structuredClone(defaultConfig);
+			config.components.editor.style = style;
+			config.components.editor.styles.opencode.metadataFormat =
+				"regular-left$" + "{fill}regular-right";
+			config.components.editor.styles["opencode-copy-friendly"].metadataFormat =
+				"copy-left$" + "{fill}copy-right";
+			const width = 40;
+			const frame = renderPolishedEditorFrame({
+				width,
+				editorLines: ["draft"],
+				uiTheme: makeAnsiTheme(),
+				config,
+				modelMeta: { modelLabel: "model", providerLabel: "provider" },
+			});
+			const metadata = frame.find(
+				(line) => line.includes(expectedLeft) && line.includes(expectedRight),
+			);
+			expect(metadata).toBeDefined();
+			expect(visibleWidth(metadata ?? "")).toBe(width);
+			const plain = stripVTControlCharacters(metadata ?? "");
+			expect(plain.indexOf(expectedLeft)).toBe(chromeWidth);
+			expect(plain.endsWith(expectedRight)).toBe(true);
+		},
+	);
+});
+
+describe("sanitizeEditorMetadataText", () => {
+	it("removes SGR and BEL while preserving regular spaces", () => {
+		expect(sanitizeEditorMetadataText("a  b\r\n\tc\u0000\u0007\u001b[31md\u001b[0m")).toBe(
+			"a  b cd",
+		);
+	});
+
+	it("preserves hyperlink labels between ST-terminated OSC 8 sequences", () => {
+		expect(
+			sanitizeEditorMetadataText(
+				"before \u001b]8;;https://example.com\u001b\\visible label\u001b]8;;\u001b\\ after",
+			),
+		).toBe("before visible label after");
+	});
+
+	it("removes C1 OSC, DCS, and CSI payloads", () => {
+		expect(
+			sanitizeEditorMetadataText(
+				"a\u009d8;;https://example.com\u009cb\u0090hidden payload\u009cc\u009b31md",
+			),
+		).toBe("abcd");
+	});
+
+	it("resumes after CAN or SUB cancels ESC-prefixed control sequences", () => {
+		expect(sanitizeEditorMetadataText("safe\u001b]8;;url\u0018 visible")).toBe("safe visible");
+		expect(sanitizeEditorMetadataText("safe\u001bPpayload\u001a visible")).toBe("safe visible");
+		expect(sanitizeEditorMetadataText("safe\u001b[31\u0018 visible")).toBe("safe visible");
+		expect(sanitizeEditorMetadataText("safe\u001b[31\u001a visible")).toBe("safe visible");
+	});
+
+	it("resumes after CAN or SUB cancels C1 control sequences", () => {
+		expect(sanitizeEditorMetadataText("safe\u009d8;;url\u001a visible")).toBe("safe visible");
+		expect(sanitizeEditorMetadataText("safe\u0090payload\u0018 visible")).toBe("safe visible");
+		expect(sanitizeEditorMetadataText("safe\u009b31\u0018 visible")).toBe("safe visible");
+		expect(sanitizeEditorMetadataText("safe\u009b31\u001a visible")).toBe("safe visible");
+	});
+
+	it("drops unterminated control sequences conservatively", () => {
+		expect(sanitizeEditorMetadataText("safe\u001b]8;;https://example.com/unsafe")).toBe("safe");
+		expect(sanitizeEditorMetadataText("safe\u0090unsafe payload")).toBe("safe");
+		expect(sanitizeEditorMetadataText("safe\u009b31")).toBe("safe");
+	});
+
+	it("normalizes NEL, line separators, and paragraph separators", () => {
+		expect(sanitizeEditorMetadataText("a\u0085\u2028\u2029b  c")).toBe("a b  c");
+	});
+});

package/dist/extensions/pi-zentui/test/editor-transfer.test.ts

@@ -0,0 +1,260 @@
+import { describe, expect, it, vi } from "vitest";
+import { replaceEditorComponentWithExpandedText } from "../extensions/zentui/editor-transfer";
+
+type Editor = {
+	getText(): string;
+	setText(text: string): void;
+	getExpandedText?: () => string;
+};
+
+type Factory = () => Editor;
+
+function piLikeUi(initialEditor: Editor, operations: string[], initialFactory?: Factory) {
+	let active = initialEditor;
+	let configuredFactory = initialFactory;
+	return {
+		get active() {
+			return active;
+		},
+		get configuredFactory() {
+			return configuredFactory;
+		},
+		getEditorComponent() {
+			operations.push("getEditorComponent");
+			return configuredFactory;
+		},
+		getEditorText() {
+			operations.push("getEditorText");
+			return active.getExpandedText?.() ?? active.getText();
+		},
+		setEditorText(text: string) {
+			operations.push(`setEditorText:${text}`);
+			active.setText(text);
+		},
+		setEditorComponent(factory: Factory | undefined) {
+			operations.push("setEditorComponent");
+			configuredFactory = factory;
+			const currentText = active.getText();
+			if (!factory) return;
+			const next = factory();
+			next.setText(currentText);
+			active = next;
+		},
+	};
+}
+
+function textEditor(initial = ""): Editor {
+	let text = initial;
+	return {
+		getText: () => text,
+		setText(next) {
+			text = next;
+		},
+	};
+}
+
+describe("safe editor component transfer", () => {
+	it("expands a collapsed paste before Pi snapshots the replaced editor", () => {
+		const marker = "[paste #1 +12 lines]";
+		const expanded = Array.from({ length: 12 }, (_, index) => `line ${index + 1}`).join("\n");
+		let oldText = marker;
+		const operations: string[] = [];
+		const oldEditor: Editor = {
+			getText: () => oldText,
+			getExpandedText: () => (oldText === marker ? expanded : oldText),
+			setText(text) {
+				oldText = text;
+			},
+		};
+		const ui = piLikeUi(oldEditor, operations);
+		const next = textEditor();
+
+		const result = replaceEditorComponentWithExpandedText(ui, () => next);
+
+		expect(result).toEqual({ ok: true });
+		expect(operations).toEqual([
+			"getEditorComponent",
+			"getEditorText",
+			`setEditorText:${expanded}`,
+			"setEditorComponent",
+		]);
+		expect(ui.active).toBe(next);
+		expect(next.getText()).toBe(expanded);
+		expect(next.getText()).not.toContain(marker);
+	});
+
+	it.each(["ordinary prompt", ""])("transfers normal prompt text: %j", (text) => {
+		const operations: string[] = [];
+		const ui = piLikeUi(textEditor(text), operations);
+		const next = textEditor();
+
+		expect(replaceEditorComponentWithExpandedText(ui, () => next)).toEqual({ ok: true });
+		expect(next.getText()).toBe(text);
+	});
+
+	it("uses the public getText fallback for a third-party editor without getExpandedText", () => {
+		const operations: string[] = [];
+		const ui = piLikeUi(textEditor("third-party draft"), operations);
+		const next = textEditor();
+
+		expect(replaceEditorComponentWithExpandedText(ui, () => next)).toEqual({ ok: true });
+		expect(next.getText()).toBe("third-party draft");
+	});
+
+	it("does not replace when the public transfer API is unavailable", () => {
+		const setEditorComponent = vi.fn();
+		expect(replaceEditorComponentWithExpandedText({ setEditorComponent }, undefined)).toEqual({
+			ok: false,
+			reason: "unsupported-transfer-api",
+		});
+		expect(setEditorComponent).not.toHaveBeenCalled();
+	});
+
+	it("does not replace when the previous factory cannot be snapshotted", () => {
+		const getEditorText = vi.fn();
+		const setEditorComponent = vi.fn();
+		const result = replaceEditorComponentWithExpandedText(
+			{
+				getEditorComponent() {
+					throw new Error("factory snapshot failed");
+				},
+				getEditorText,
+				setEditorText() {},
+				setEditorComponent,
+			},
+			undefined,
+		);
+
+		expect(result).toEqual({ ok: false, reason: "editor-factory-snapshot-failed" });
+		expect(getEditorText).not.toHaveBeenCalled();
+		expect(setEditorComponent).not.toHaveBeenCalled();
+	});
+
+	it("does not replace when expanded text snapshotting fails", () => {
+		const setEditorText = vi.fn();
+		const setEditorComponent = vi.fn();
+		const result = replaceEditorComponentWithExpandedText(
+			{
+				getEditorComponent: () => undefined,
+				getEditorText() {
+					throw new Error("snapshot failed");
+				},
+				setEditorText,
+				setEditorComponent,
+			},
+			undefined,
+		);
+
+		expect(result).toEqual({ ok: false, reason: "editor-text-snapshot-failed" });
+		expect(setEditorText).not.toHaveBeenCalled();
+		expect(setEditorComponent).not.toHaveBeenCalled();
+	});
+
+	it("rejects a non-string snapshot without replacing", () => {
+		const setEditorComponent = vi.fn();
+		const result = replaceEditorComponentWithExpandedText(
+			{
+				getEditorComponent: () => undefined,
+				getEditorText: () => undefined,
+				setEditorText() {},
+				setEditorComponent,
+			},
+			undefined,
+		);
+		expect(result).toEqual({ ok: false, reason: "editor-text-snapshot-failed" });
+		expect(setEditorComponent).not.toHaveBeenCalled();
+	});
+
+	it("does not replace when writing expanded text back fails", () => {
+		const setEditorComponent = vi.fn();
+		const result = replaceEditorComponentWithExpandedText(
+			{
+				getEditorComponent: () => undefined,
+				getEditorText: () => "expanded",
+				setEditorText() {
+					throw new Error("write failed");
+				},
+				setEditorComponent,
+			},
+			undefined,
+		);
+
+		expect(result).toEqual({ ok: false, reason: "editor-text-preparation-failed" });
+		expect(setEditorComponent).not.toHaveBeenCalled();
+	});
+
+	it("restores the previous factory after an assignment-first replacement failure", () => {
+		const operations: string[] = [];
+		const previousEditor = textEditor("marker");
+		const previousFactory = () => previousEditor;
+		const ui = piLikeUi(previousEditor, operations, previousFactory);
+		const failingFactory = () => {
+			throw new Error("replacement failed after assignment");
+		};
+
+		const result = replaceEditorComponentWithExpandedText(ui, failingFactory);
+
+		expect(result).toEqual({
+			ok: false,
+			reason: "editor-replacement-failed-with-rollback",
+		});
+		expect(ui.configuredFactory).toBe(previousFactory);
+		expect(ui.active.getText()).toBe("marker");
+		expect(operations).toEqual([
+			"getEditorComponent",
+			"getEditorText",
+			"setEditorText:marker",
+			"setEditorComponent",
+			"setEditorComponent",
+		]);
+	});
+
+	it("reports when assignment-first replacement rollback also throws", () => {
+		const previousFactory = () => textEditor("previous");
+		let configuredFactory: Factory | undefined = previousFactory;
+		let setterCalls = 0;
+		const result = replaceEditorComponentWithExpandedText(
+			{
+				getEditorComponent: () => configuredFactory,
+				getEditorText: () => "expanded payload",
+				setEditorText() {},
+				setEditorComponent(factory) {
+					configuredFactory = factory;
+					setterCalls += 1;
+					throw new Error(setterCalls === 1 ? "replacement failed" : "rollback failed");
+				},
+			},
+			() => textEditor("next"),
+		);
+
+		expect(result).toEqual({
+			ok: false,
+			reason: "editor-replacement-rollback-failed",
+		});
+		expect(setterCalls).toBe(2);
+	});
+
+	it("submits the exact original multiline paste payload after replacement", () => {
+		const marker = "[paste #7 +4 lines]";
+		const payload = "alpha\nbeta\ngamma\ndelta";
+		let oldText = marker;
+		const submitted: string[] = [];
+		const oldEditor: Editor = {
+			getText: () => oldText,
+			getExpandedText: () => (oldText === marker ? payload : oldText),
+			setText(text) {
+				oldText = text;
+			},
+		};
+		const operations: string[] = [];
+		const ui = piLikeUi(oldEditor, operations);
+		const next = textEditor();
+
+		expect(replaceEditorComponentWithExpandedText(ui, () => next)).toEqual({ ok: true });
+		const onSubmit = (text: string) => submitted.push(text);
+		onSubmit(next.getText());
+
+		expect(submitted).toEqual([payload]);
+		expect(submitted[0]).not.toContain("[paste #");
+	});
+});