Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/loop/__tests__/companion.test.ts

Raw
import { Theme } from "@earendil-works/pi-coding-agent";
import { visibleWidth } from "@earendil-works/pi-tui";
import { describe, expect, it } from "vitest";
import {
	blend,
	type CompanionState,
	createCompanion,
	FOREARM,
	figure,
	framing,
	H,
	MAX_ZOOM,
	MIN_ZOOM,
	onHip,
	type Pose,
	type Rig,
	rig,
	solve,
	UPPER_ARM,
	W,
} from "../src/companion.ts";

const theme = new Theme(
	{
		accent: "#d080a0",
		dim: "#666666",
		muted: "#888888",
		warning: "#c08040",
		thinkingXhigh: "#888888",
		text: "#eeeeee",
	} as ConstructorParameters<typeof Theme>[0],
	{ selectedBg: "" } as ConstructorParameters<typeof Theme>[1],
	"truecolor",
	{ appearance: "dark" },
);
const poses: Pose[] = ["posing", "peek", "pout", "lounge", "celebrate"];
const strip = (line: string) => line.replace(/\x1b\[[0-9;]*m/gu, "");

function state(overrides: Partial<CompanionState> = {}): CompanionState {
	return {
		status: "active",
		pending: false,
		attempts: 3,
		turns: 6,
		budgets: { minutes: null, turns: 30, attempts: 10 },
		failed: { gate: "tests", at: -10_000 },
		updatedAt: 0,
		...overrides,
	};
}

/** Leftmost painted column of her body; hearts only float above it. */
function leftEdge(lines: string[]): number {
	return Math.min(
		...lines
			.slice(6, H / 2)
			.map((line) => strip(line).search(/\S/u))
			.filter((index) => index >= 0),
	);
}

describe("companion figure", () => {
	it("paints a bounded figure from a small, deliberate palette", () => {
		for (const pose of poses) {
			const pixels = figure(rig(pose, 1.3), 1.3);
			expect(pixels).toHaveLength(H);
			expect(pixels.every((row) => row.length === W)).toBe(true);
			const painted = pixels.flat().filter(Boolean);
			expect(painted.length).toBeGreaterThan(120);
			// Hand-picked ramps: enough tones for form, never blended mush.
			const tones = new Set(painted.map((c) => c?.join())).size;
			expect(tones).toBeGreaterThan(8);
			expect(tones).toBeLessThanOrEqual(32);
		}
	});

	it("animates over time and eases between key poses", () => {
		// Held poses still breathe.
		const a = JSON.stringify(figure(rig("posing", 0), 0, 3));
		const b = JSON.stringify(figure(rig("posing", 1.4), 1.4, 3));
		expect(a).not.toBe(b);
		const from = rig("posing", 0);
		const to = rig("celebrate", 0, 1);
		expect(blend(from, to, 0)).toMatchObject({
			sway: from.sway,
			eyes: from.eyes,
		});
		expect(blend(from, to, 1)).toMatchObject({ lift: to.lift, eyes: to.eyes });
		const halfway = blend(from, to, 0.5).lift;
		expect(halfway).toBeCloseTo((from.lift + to.lift) / 2);
	});

	it("renders more detail the closer the camera gets", () => {
		const pose = rig("peek", 1);
		const tones = (zoom: number) =>
			new Set(
				figure(pose, 1, zoom)
					.flat()
					.filter(Boolean)
					.map((c) => c?.join()),
			);
		const far = figure(pose, 1, MIN_ZOOM);
		const near = figure(pose, 1, MAX_ZOOM);
		expect(far).toHaveLength(H);
		expect(near).toHaveLength(H);
		expect(near[0]?.length).toBeGreaterThan(far[0]?.length ?? 0);
		const painted = (zoom: number) =>
			figure(pose, 1, zoom).flat().filter(Boolean).length;
		expect(painted(MAX_ZOOM)).toBeGreaterThan(painted(MIN_ZOOM) * 4);
		// Green irises and white sclera only exist in close-ups.
		const iris = "62,132,84";
		expect(tones(MAX_ZOOM).has(iris)).toBe(true);
		expect(tones(1).has(iris)).toBe(false);
		// The camera tilts up so her head stays in frame.
		expect(near.slice(0, 3).flat().some(Boolean)).toBe(true);
	});

	it("holds a pose, then eases slowly into the next", () => {
		const held = [2, 6, 10].map((t) => rig("posing", t).sway);
		expect(Math.max(...held) - Math.min(...held)).toBeLessThan(0.7);
		expect(
			Math.abs(rig("posing", 10).sway - rig("posing", 20).sway),
		).toBeGreaterThan(1);
		// The change takes seconds, not a frame.
		const step = Math.abs(rig("posing", 16.5).sway - rig("posing", 16.4).sway);
		expect(step).toBeLessThan(0.2);
	});

	it("gives her bust gravity, arm lift and collision", () => {
		const bikini = "255,186,142";
		const cups = (r: Rig) => {
			const px = figure(r, 0, 3, {
				width: 80,
				center: 40,
				facing: 1,
				focus: 12,
			});
			const hits: Array<[number, number]> = [];
			px.forEach((row, y) =>
				row.forEach((c, x) => {
					if (c?.join() === bikini) hits.push([x, y]);
				}),
			);
			const mean = (i: 0 | 1) =>
				hits.reduce((sum, h) => sum + h[i], 0) / (hits.length || 1);
			return {
				x: mean(0),
				y: mean(1),
				top: Math.min(...hits.map((h) => h[1])),
			};
		};
		const base = rig("pout", 0);
		// Arms raised over her head lift the bust.
		const raised = cups({
			...base,
			hands: [
				[10.4, 2.8],
				[13.6, 2.8],
			],
		});
		expect(raised.top).toBeLessThan(cups(base).top);
		// A forearm pressed across her chest pushes the soft tissue aside.
		const pressed = cups({ ...base, hands: [base.hands[0], [10.5, 12.5]] });
		expect(
			Math.abs(pressed.x - cups(base).x) + Math.abs(pressed.y - cups(base).y),
		).toBeGreaterThan(0.5);
	});

	it("keeps bone lengths fixed whatever the target", () => {
		for (const target of [
			[7, 17.6],
			[13.8, 2.6],
			[30, 30],
			[8.3, 9.6],
		] as const) {
			const root = [8.4, 9.4] as const;
			const { joint, end } = solve(root, target, UPPER_ARM, FOREARM, -1);
			expect(Math.hypot(joint[0] - root[0], joint[1] - root[1])).toBeCloseTo(
				UPPER_ARM,
				3,
			);
			expect(Math.hypot(end[0] - joint[0], end[1] - joint[1])).toBeCloseTo(
				FOREARM,
				3,
			);
		}
	});

	it("frames close on her face, torso and hips, never the whole figure", () => {
		let close = 0;
		for (let t = 0; t < 96; t++) {
			const shot = framing("posing", t, t);
			expect(shot.zoom).toBeGreaterThanOrEqual(1.7);
			expect(shot.zoom).toBeLessThanOrEqual(MAX_ZOOM);
			expect(shot.focus).toBeGreaterThanOrEqual(5);
			expect(shot.focus).toBeLessThanOrEqual(17);
			if (shot.zoom >= 2.8) close++;
		}
		expect(close / 96).toBeGreaterThan(0.85);
		expect(framing("posing", 15, 15).focus).toBe(5);
		for (const pose of ["peek", "pout", "lounge"] as const)
			expect(framing(pose, 5, 5).zoom).toBeGreaterThanOrEqual(2.4);
		expect(framing("celebrate", 0, 1).zoom).toBeLessThan(
			framing("celebrate", 0, 8).zoom,
		);
	});

	it("dips in anticipation, stretches overhead, then blows kisses away from her face", () => {
		expect(rig("celebrate", 0, 0.3).lift).toBeGreaterThan(0.2);
		expect(rig("celebrate", 0, 0.3).squash).toBeLessThan(1);
		for (const since of [1, 2, 3, 5])
			expect(rig("celebrate", since, since).lift).toBeGreaterThanOrEqual(-0.15);
		// Both hands end up above her head during the stretch.
		const stretch = rig("celebrate", 4, 4);
		expect(stretch.hands[0][1]).toBeLessThan(3);
		expect(stretch.hands[1][1]).toBeLessThan(3);
		// The kiss arrives after the stretch, and the hand never covers her face.
		expect([7.2, 7.5, 8].some((s) => rig("celebrate", s, s).kiss)).toBe(true);
		for (let since = 6; since < 10; since += 0.1) {
			const [x, y] = rig("celebrate", since, since).hands[1];
			expect(Math.hypot(x - 12, y - 5)).toBeGreaterThan(2.5);
		}
	});

	it("rests her hands on her hips in power poses", () => {
		for (const pose of ["pout", "peek", "lounge"] as const) {
			const { hands, sway } = rig(pose, 1);
			expect(hands[0]).toEqual(onHip(sway, -1));
		}
	});
});

describe("companion widget", () => {
	it("stays put and lets the camera move calmly", () => {
		let now = 0;
		const widget = createCompanion(
			{ requestRender() {} } as never,
			theme,
			() => state(),
			() => now,
		);
		try {
			const width = 100;
			let previous = leftEdge(widget.render(width));
			for (let i = 0; i < 200; i++) {
				now += 80;
				const lines = widget.render(width);
				for (const line of lines)
					expect(visibleWidth(line)).toBeLessThanOrEqual(width);
				const edge = leftEdge(lines);
				// No jumps: the frame changes by at most a cell or two at a time.
				expect(Math.abs(edge - previous)).toBeLessThanOrEqual(2);
				previous = edge;
			}
		} finally {
			widget.dispose();
		}
	});

	it("shows subtle run facts and reacts to loop states", () => {
		let now = 0;
		let current = state({ failed: { gate: "tests", at: 0 } });
		const widget = createCompanion(
			{ requestRender() {} } as never,
			theme,
			() => current,
			() => now,
		);
		try {
			const info = (lines: string[]) => strip(lines.at(-1) ?? "");
			const pout = widget.render(100);
			expect(pout).toHaveLength(H / 2 + 1);
			expect(info(pout)).toMatch(/3\/10.*6\/30.*tests/u);
			expect(info(pout)).toMatch(/tests|again/u);
			current = state({ status: "paused" });
			now = 10_000;
			expect(info(widget.render(100))).toMatch(/wait|ready/u);
			current = state({ status: "succeeded", updatedAt: now });
			expect(info(widget.render(100))).toMatch(/done|winner/u);
			expect(info(widget.render(100))).not.toMatch(/tests$/u);
			now += 41_000;
			expect(widget.render(100)).toEqual([]);
			current = state({ status: "stopped" });
			expect(widget.render(100)).toEqual([]);
		} finally {
			widget.dispose();
		}
	});

	it("moves the camera smoothly between framings", () => {
		let now = 0;
		let current = state();
		const widget = createCompanion(
			{ requestRender() {} } as never,
			theme,
			() => current,
			() => now,
		);
		const extent = (lines: string[]) => {
			const rows = lines.slice(0, H / 2).map(strip);
			const left = Math.min(
				...rows.map((r) => r.search(/\S/u)).filter((i) => i >= 0),
			);
			const right = Math.max(...rows.map((r) => r.trimEnd().length));
			const top = rows.findIndex((r) => r.trim());
			return { width: right - left, top };
		};
		try {
			widget.render(120);
			// Gates start running: the camera dollies in for a close-up.
			current = state({ pending: true });
			let previous = extent(widget.render(120));
			let grew = 0;
			for (let i = 0; i < 120; i++) {
				now += 80;
				const next = extent(widget.render(120));
				// No snaps: each frame changes size by at most a couple of cells.
				expect(Math.abs(next.width - previous.width)).toBeLessThanOrEqual(3);
				grew += next.width - previous.width;
				previous = next;
			}
			expect(grew).toBeGreaterThan(6);
		} finally {
			widget.dispose();
		}
	});

	it("draws soft-tissue offsets for bust and hips and keeps them stable", () => {
		// The widget's springs feed these offsets; close-ups must show them.
		const r = rig("posing", 0);
		const at = (focus: number, rr = r) =>
			JSON.stringify(
				figure(rr, 0, 3, { width: 80, center: 40, facing: 1, focus }),
			);
		expect(at(12, { ...r, bust: [0, 0.5] })).not.toBe(at(12));
		expect(at(19, { ...r, jiggle: 0.5 })).not.toBe(at(19));
		// Long, uneven frame gaps must not destabilise the springs.
		let now = 0;
		const widget = createCompanion(
			{ requestRender() {} } as never,
			theme,
			() => state(),
			() => now,
		);
		try {
			for (const gap of [80, 500, 40, 900, 80, 80, 1_500, 80]) {
				now += gap;
				const lines = widget.render(100);
				expect(lines).toHaveLength(H / 2 + 1);
				expect(lines.join("")).not.toMatch(/NaN/u);
			}
		} finally {
			widget.dispose();
		}
	});

	it("renders a frame quickly enough for 8 fps", () => {
		let now = 0;
		const widget = createCompanion(
			{ requestRender() {} } as never,
			theme,
			() => state(),
			() => now,
		);
		try {
			const start = performance.now();
			for (let i = 0; i < 40; i++) {
				now += 125;
				widget.render(160);
			}
			expect((performance.now() - start) / 40).toBeLessThan(25);
		} finally {
			widget.dispose();
		}
	});
});