Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/activity/__serial__/widget-wiring.test.ts

Raw
import type {
	ExtensionUIContext,
	Theme,
} from "@earendil-works/pi-coding-agent";
import { afterEach, expect, it, vi } from "vitest";
import {
	createPiSession,
	type PiSession,
} from "../../../test/fixture/create-pi-session.ts";
import activityExtension from "../index.ts";
import type { ActivitySnapshot } from "../types.ts";

// Controlled manager events isolate extension wiring, not OS process termination.
const state = vi.hoisted(() => ({
	items: [] as ActivitySnapshot[],
	acknowledged: new Set<string>(),
	listeners: new Set<() => void>(),
	disposed: 0,
}));
vi.mock("../runtime.ts", () => ({
	ActivityManager: class {
		list() {
			return state.items.map((item) => ({ ...item }));
		}
		attention() {
			return this.list().filter(
				(item) =>
					item.status === "running" ||
					item.status === "stopping" ||
					(item.status === "failed" && !state.acknowledged.has(item.id)),
			);
		}
		subscribe(listener: () => void) {
			state.listeners.add(listener);
			return () => state.listeners.delete(listener);
		}
		async dispose() {
			state.disposed++;
		}
	},
}));

let fixture: PiSession | undefined;
afterEach(async () => {
	vi.useRealTimers();
	await fixture?.dispose();
	fixture = undefined;
	state.items = [];
	state.acknowledged.clear();
	state.listeners.clear();
	state.disposed = 0;
});

async function bind(mode: "tui" | "rpc") {
	fixture = await createPiSession({ extensionFactories: [activityExtension] });
	expect(fixture.errors).toEqual([]);
	const runner = fixture.session.extensionRunner;
	const setWidget = vi.fn<ExtensionUIContext["setWidget"]>();
	const setStatus = vi.fn<ExtensionUIContext["setStatus"]>();
	runner.setUIContext({ ...runner.getUIContext(), setWidget, setStatus }, mode);
	await runner.emit({ type: "session_start" });
	const definition = fixture.extensions
		.flatMap((extension) => [...extension.tools.values()])
		.find((entry) => entry.definition.name === "activity")?.definition;
	if (!definition) throw new Error("Missing activity definition");
	await definition.execute(
		"fixture-list",
		{ action: "list" },
		undefined,
		undefined,
		runner.createContext(),
	);
	setWidget.mockClear();
	setStatus.mockClear();
	vi.useFakeTimers();
	return { runner, setWidget, setStatus };
}

function publish(status: ActivitySnapshot["status"]) {
	state.items = [
		{
			id: "fixture-process",
			kind: "process",
			title: "Build fixture",
			status,
			createdAt: 0,
			sequence: 1,
			notify: false,
		},
	];
	for (const listener of state.listeners) listener();
}

it("debounces native above-editor status, updates unchanged counts, suppresses output-only updates and clears on shutdown", async () => {
	const { runner, setWidget, setStatus } = await bind("tui");
	const theme = { fg: (_color: unknown, text: string) => text } as Theme;
	const latest = () => {
		const [key, factory, options] = setWidget.mock.calls.at(-1) ?? [];
		expect(key).toBe("activity");
		expect(options).toEqual({ placement: "aboveEditor" });
		if (typeof factory !== "function")
			throw new Error("Missing widget factory");
		return factory({} as Parameters<typeof factory>[0], theme)
			.render(100)
			.join("\n");
	};

	publish("running");
	publish("running");
	expect(setWidget).not.toHaveBeenCalled();
	await vi.advanceTimersByTimeAsync(100);
	expect(setWidget).toHaveBeenCalledTimes(1);
	expect(latest()).toContain("Running · Build fixture");

	publish("running");
	await vi.advanceTimersByTimeAsync(100);
	expect(setWidget).toHaveBeenCalledTimes(1);

	publish("stopping");
	await vi.advanceTimersByTimeAsync(100);
	expect(setWidget).toHaveBeenCalledTimes(2);
	expect(latest()).toContain("Stopping… · Build fixture");
	expect(setStatus).not.toHaveBeenCalled();

	publish("stopped");
	await runner.emit({ type: "session_shutdown", reason: "quit" });
	expect(setWidget).toHaveBeenLastCalledWith("activity", undefined);
	expect(state.listeners.size).toBe(0);
	expect(state.disposed).toBe(1);
	const calls = setWidget.mock.calls.length;
	await vi.advanceTimersByTimeAsync(100);
	expect(setWidget).toHaveBeenCalledTimes(calls);
	expect(setStatus).toHaveBeenCalledWith("activity", undefined);
});

it("hides finished successes immediately and failures once acknowledged", async () => {
	const { runner, setWidget } = await bind("tui");
	publish("completed");
	await vi.advanceTimersByTimeAsync(100);
	expect(setWidget.mock.calls.every(([, factory]) => !factory)).toBe(true);

	publish("failed");
	await vi.advanceTimersByTimeAsync(100);
	expect(typeof setWidget.mock.calls.at(-1)?.[1]).toBe("function");

	state.acknowledged.add("fixture-process");
	for (const listener of state.listeners) listener();
	await vi.advanceTimersByTimeAsync(100);
	expect(setWidget).toHaveBeenLastCalledWith("activity", undefined, {
		placement: "aboveEditor",
	});
	await runner.emit({ type: "session_shutdown", reason: "quit" });
});

it("does not register terminal widgets in RPC mode", async () => {
	const { runner, setWidget, setStatus } = await bind("rpc");
	publish("running");
	await vi.advanceTimersByTimeAsync(100);
	await runner.emit({ type: "session_shutdown", reason: "quit" });
	expect(setWidget).not.toHaveBeenCalled();
	expect(setStatus).not.toHaveBeenCalled();
});