@selesai/code 0.13.12 → 0.13.14

package/dist/extensions/pi-zentui/test/thinking-experimental-missing-export.test.ts

@@ -0,0 +1,44 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("@earendil-works/pi-coding-agent", async (importOriginal) => ({
+	...(await importOriginal<typeof import("@earendil-works/pi-coding-agent")>()),
+	AssistantMessageComponent: undefined,
+}));
+
+describe("Streaming (Experimental) optional private export", () => {
+	it("loads fail-open and preserves the selected mode when the private constructor is absent", async () => {
+		const { ThinkingExperimentalController } = await import(
+			"../extensions/zentui/thinking-experimental"
+		);
+		const config = { enabled: true, mode: "streaming" as const };
+		const value = new ThinkingExperimentalController(() => config);
+		const ctx = {
+			mode: "tui",
+			hasUI: true,
+			ui: { onTerminalInput: vi.fn() },
+			sessionManager: { getEntries: () => [] },
+		};
+
+		expect(value.state).toMatchObject({ available: false, active: false });
+		expect(value.startSession(ctx as never)).toMatchObject({
+			applied: false,
+			reason: expect.stringContaining("unavailable"),
+		});
+		expect(config).toEqual({ enabled: true, mode: "streaming" });
+		value.shutdown();
+	});
+
+	it("does not statically import or deep-import the private renderer", () => {
+		const source = readFileSync(
+			join(import.meta.dirname, "../extensions/zentui/thinking-experimental.ts"),
+			"utf8",
+		);
+		expect(source).not.toMatch(
+			/import\s*\{[^}]*AssistantMessageComponent[^}]*\}\s*from\s*["']@earendil-works\/pi-coding-agent["']/s,
+		);
+		expect(source).not.toMatch(/pi-coding-agent\/(?:dist|src)\//);
+		expect(source).toContain("AssistantMessageComponent?: PrivateAssistantConstructor");
+	});
+});

package/dist/extensions/pi-zentui/test/thinking-experimental-rows.test.ts

@@ -0,0 +1,297 @@
+import { Markdown, type MarkdownTheme, visibleWidth } from "@earendil-works/pi-tui";
+import { describe, expect, it, vi } from "vitest";
+import { createThinkingStepsRows } from "../extensions/zentui/thinking-experimental";
+import { parseThinkingSteps } from "../extensions/zentui/thinking-steps";
+
+const identityTheme = Object.fromEntries(
+	[
+		"heading",
+		"link",
+		"linkUrl",
+		"code",
+		"codeBlock",
+		"codeBlockBorder",
+		"quote",
+		"quoteBorder",
+		"hr",
+		"listBullet",
+		"bold",
+		"italic",
+		"strikethrough",
+		"underline",
+	].map((key) => [key, (text: string) => text]),
+) as unknown as MarkdownTheme;
+
+function plain(row: string): string {
+	return row
+		.replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, "")
+		.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+		.trimEnd();
+}
+
+function rows(
+	source: string,
+	mode: "rail" | "tree",
+	width = 80,
+	incomplete = false,
+	paddingX = 0,
+	markdownTheme = identityTheme,
+	options: ConstructorParameters<typeof Markdown>[5] = { renderLatex: true },
+) {
+	const style = { color: (text: string) => text, italic: true };
+	const native = new Markdown(source, paddingX, 0, markdownTheme, style, options);
+	const steps = parseThinkingSteps(source);
+	if (!steps) throw new Error("fixture must parse");
+	const accent = vi.fn((_: "accent", text: string) => `\x1b[35m${text}\x1b[0m`);
+	const component = createThinkingStepsRows(
+		native,
+		{
+			text: source,
+			paddingX,
+			paddingY: 0,
+			theme: markdownTheme,
+			defaultTextStyle: style,
+			options,
+		},
+		steps,
+		mode,
+		incomplete,
+		() => ({ fg: accent }),
+	);
+	return { rendered: component.render(width), component, native, accent };
+}
+
+describe("Experimental native Rail/Tree rows", () => {
+	it("renders all Rail labels and the latest five Tree labels with active/settled markers", () => {
+		const source = Array.from({ length: 7 }, (_, index) => `# Label ${index + 1}`).join("\n");
+		expect(rows(source, "rail", 80, true).rendered.map(plain)).toEqual([
+			"│ Thinking",
+			"│ Label 1",
+			"│ Label 2",
+			"│ Label 3",
+			"│ Label 4",
+			"│ Label 5",
+			"│ Label 6",
+			"│ • Label 7",
+		]);
+		expect(rows(source, "tree").rendered.map(plain)).toEqual([
+			"┆ Thinking",
+			"├─ · Label 3",
+			"├─ · Label 4",
+			"├─ · Label 5",
+			"├─ · Label 6",
+			"└─ · Label 7",
+		]);
+	});
+
+	it.each(["rail", "tree"] as const)(
+		"renders SGR-decorated thinking structurally in %s without carrying source SGR forward",
+		(mode) => {
+			const truecolor = "\x1b[38;2;137;180;250m";
+			const muted = "\x1b[38;2;186;194;222m";
+			const reset = "\x1b[39m";
+			const source = `${truecolor}# First${reset}\n${muted}body${reset}\n${truecolor}# Second${reset}`;
+			const output = rows(source, mode).rendered;
+			expect(output.map(plain)).toEqual(
+				mode === "rail"
+					? ["│ Thinking", "│ First", "│ Second"]
+					: ["┆ Thinking", "├─ · First", "└─ · Second"],
+			);
+			expect(output.join("\n")).not.toContain(truecolor);
+			expect(output.join("\n")).not.toContain(muted);
+			expect(output.join("\n")).not.toContain(reset);
+		},
+	);
+
+	it("fails open when stripping SGR reconstructs image syntax", () => {
+		const source = "# ![im\x1b[31mage](asset.png)";
+		const value = rows(source, "tree");
+		expect(value.rendered).toEqual(value.native.render(80));
+	});
+
+	it("preserves native label Markdown callbacks and accents connectors separately", () => {
+		const italic = vi.fn((text: string) => `<i>${text}</i>`);
+		const code = vi.fn((text: string) => `<c>${text}</c>`);
+		const link = vi.fn((text: string) => `<a>${text}</a>`);
+		const current = rows("# *emphasis* `code` [link](https://example.com)", "rail", 80, false, 0, {
+			...identityTheme,
+			italic,
+			code,
+			link,
+		});
+		current.rendered.map(plain);
+		expect(italic).toHaveBeenCalled();
+		expect(code).toHaveBeenCalledWith("code");
+		expect(link).toHaveBeenCalled();
+		expect(current.accent).toHaveBeenCalledWith("accent", "│ ");
+	});
+
+	it("preserves host transform, HTML, and literal-LaTeX behavior on fresh label Markdown", () => {
+		const capabilityTransform = vi.fn(() => "**transformed-capability**");
+		const capabilityOutput = plain(
+			new Markdown(
+				"plain-capability",
+				0,
+				0,
+				{
+					...identityTheme,
+					bold: (text) => `<b>${text}</b>`,
+				},
+				undefined,
+				{
+					transform: capabilityTransform,
+				},
+			).render(78)[0] ?? "",
+		);
+		const hostExecutesTransform = capabilityOutput === "<b>transformed-capability</b>";
+		expect(capabilityOutput).toBe(
+			hostExecutesTransform ? "<b>transformed-capability</b>" : "plain-capability",
+		);
+		expect(capabilityTransform).toHaveBeenCalledTimes(hostExecutesTransform ? 1 : 0);
+
+		const source = "native <span>HTML</span> $x^2$";
+		const transform = vi.fn((text: string) => text.replace("native", "**native**"));
+		const bold = vi.fn((text: string) => `<b>${text}</b>`);
+		const theme = { ...identityTheme, bold };
+		const options = { transform, renderLatex: false };
+		const nativeLabel = plain(
+			new Markdown(source, 0, 0, theme, undefined, options).render(78)[0] ?? "",
+		);
+		expect(nativeLabel).toContain("$x^2$");
+		expect(transform).toHaveBeenCalledTimes(hostExecutesTransform ? 1 : 0);
+		transform.mockClear();
+		bold.mockClear();
+
+		const output = rows(`# ${source}`, "rail", 80, false, 0, theme, options).rendered.map(plain);
+		expect(output[1]).toBe(`│ ${nativeLabel}`);
+		if (hostExecutesTransform) {
+			expect(transform.mock.calls).toEqual([
+				["**Thinking**", 78],
+				[source, 78],
+			]);
+			expect(bold.mock.calls).toEqual([["Thinking"], ["native"]]);
+		} else {
+			expect(transform).not.toHaveBeenCalled();
+			expect(bold.mock.calls).toEqual([["Thinking"]]);
+		}
+		expect(output[1]).toContain("HTML");
+		expect(output[1]).toContain("$x^2$");
+	});
+
+	it.each([
+		{
+			name: "ordered-list source markers",
+			source: "7) ordered marker",
+			option: "preserveOrderedListMarkers" as const,
+			expectedWhenSupported: "7) ordered marker",
+			expectedWhenDisabled: "7. ordered marker",
+		},
+		{
+			name: "backslash escapes",
+			source: String.raw`escaped \*asterisks\*`,
+			option: "preserveBackslashEscapes" as const,
+			expectedWhenSupported: String.raw`escaped \*asterisks\*`,
+			expectedWhenDisabled: "escaped *asterisks*",
+		},
+	])("preserves $name behavior exactly when the host supports it", (fixture) => {
+		const enabledOptions = { [fixture.option]: true, renderLatex: false };
+		const disabledOptions = { [fixture.option]: false, renderLatex: false };
+		const nativeEnabled = plain(
+			new Markdown(fixture.source, 0, 0, identityTheme, undefined, enabledOptions).render(78)[0] ??
+				"",
+		);
+		const nativeDisabled = plain(
+			new Markdown(fixture.source, 0, 0, identityTheme, undefined, disabledOptions).render(78)[0] ??
+				"",
+		);
+		const output = rows(
+			`# ${fixture.source}`,
+			"rail",
+			80,
+			false,
+			0,
+			identityTheme,
+			enabledOptions,
+		).rendered.map(plain);
+
+		expect(nativeDisabled).toBe(fixture.expectedWhenDisabled);
+		expect(output[1]).toBe(`│ ${nativeEnabled}`);
+		if (nativeEnabled !== nativeDisabled) {
+			expect(nativeEnabled).toBe(fixture.expectedWhenSupported);
+		} else {
+			expect(output[1]).toBe(`│ ${nativeDisabled}`);
+		}
+	});
+
+	it.each(["界語 emoji 👨‍👩‍👧‍👦", "cafe\u0301 punctuation /().;:"])(
+		"crops %s to one ANSI-safe bounded row",
+		(label) => {
+			for (const width of [10, 20, 80]) {
+				const rendered = rows(`# ${label.repeat(10)}`, "tree", width, true).rendered;
+				expect(rendered).toHaveLength(2);
+				expect(rendered.every((row) => visibleWidth(row) <= width)).toBe(true);
+				expect(plain(rendered[1] ?? "")).toContain("…");
+			}
+		},
+	);
+
+	it("uses one-cell ellipsis, preserves outer padding, and invalidates derived Markdown", () => {
+		const value = rows("# long label", "rail", 5, false, 1);
+		expect(value.rendered.every((row) => visibleWidth(row) <= 5)).toBe(true);
+		expect(plain(value.rendered[1] ?? "")).toBe(" │ …");
+		const invalidate = vi.spyOn(value.native, "invalidate");
+		value.component.invalidate();
+		expect(invalidate).toHaveBeenCalledOnce();
+	});
+
+	it("renders an Error label through native Markdown semantics", () => {
+		const value = rows("# Error: **retry** with `safe-code`", "rail");
+		expect(value.rendered.map(plain)).toEqual(["│ Thinking", "│ Error: retry with safe-code"]);
+	});
+
+	it("fails open to the complete native run for an image label", () => {
+		const value = rows("# ![image](asset.png)", "rail");
+		expect(value.rendered).toEqual(value.native.render(80));
+	});
+
+	it.each(["empty", "throw"] as const)(
+		"fails open to the complete native run when a derived label render is %s",
+		(failure) => {
+			const original = Markdown.prototype.render;
+			const render = vi
+				.spyOn(Markdown.prototype, "render")
+				.mockImplementation(function derivedFailure(this: Markdown, width: number) {
+					const text = (this as unknown as { text?: string }).text;
+					if (text === "fallback label") {
+						if (failure === "throw") throw new Error("derived render failed");
+						return [];
+					}
+					return Reflect.apply(original, this, [width]);
+				});
+			try {
+				const value = rows("# fallback label", "rail");
+				expect(value.rendered).toEqual(value.native.render(80));
+			} finally {
+				render.mockRestore();
+			}
+		},
+	);
+
+	it("fails open to native rows when current-theme connector rendering throws", () => {
+		const source = "# theme fallback";
+		const native = new Markdown(source, 0, 0, identityTheme);
+		const steps = parseThinkingSteps(source);
+		if (!steps) throw new Error("fixture must parse");
+		const component = createThinkingStepsRows(
+			native,
+			{ text: source, paddingX: 0, paddingY: 0, theme: identityTheme },
+			steps,
+			"tree",
+			false,
+			() => {
+				throw new Error("theme unavailable");
+			},
+		);
+		expect(component.render(80)).toEqual(native.render(80));
+	});
+});