@selesai/code 0.9.14 → 0.10.0

package/dist/extensions/pi-zentui/test/live-context-integration.test.ts

@@ -0,0 +1,378 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("../extensions/zentui/config", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("../extensions/zentui/config")>();
+	return {
+		...actual,
+		ensureConfigExists: () => {},
+		loadConfig: () => ({
+			...actual.defaultConfig,
+			projectRefreshIntervalMs: 0,
+			components: {
+				...actual.defaultConfig.components,
+				editor: {
+					...actual.defaultConfig.components.editor,
+					enabled: true,
+					styles: {
+						...actual.defaultConfig.components.editor.styles,
+						opencode: {
+							...actual.defaultConfig.components.editor.styles.opencode,
+							metadataFormat: "$context $tokens $cache_hit",
+						},
+					},
+				},
+				footer: {
+					...actual.defaultConfig.components.footer,
+					style: "starship",
+				},
+			},
+			features: { ...actual.defaultConfig.features, editor: false, statusLine: true },
+		}),
+	};
+});
+
+vi.mock("../extensions/zentui/git", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("../extensions/zentui/git")>();
+	return {
+		...actual,
+		readGitStatus: async () => ({ kind: "ok" as const, status: actual.emptyGitStatus() }),
+	};
+});
+
+vi.mock("../extensions/zentui/runtime", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("../extensions/zentui/runtime")>();
+	return { ...actual, readRuntimeInfo: async () => ({ kind: "ok" as const, runtime: undefined }) };
+});
+
+vi.mock("../extensions/zentui/package-version", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("../extensions/zentui/package-version")>();
+	return {
+		...actual,
+		readPackageVersionResult: async () => ({ kind: "ok" as const, result: null }),
+	};
+});
+
+import zentui from "../extensions/zentui/index";
+
+type Handler = (event: unknown, ctx: unknown) => unknown | Promise<unknown>;
+type Footer = { render(width: number): string[]; dispose?: () => void };
+type FooterFactory = (...args: unknown[]) => Footer;
+type Editor = { render(width: number): string[]; setText(text: string): void };
+type EditorFactory = (...args: unknown[]) => Editor;
+
+function makeTheme(): Theme {
+	return {
+		fg(_color: string, text: string) {
+			return text;
+		},
+		bold(text: string) {
+			return text;
+		},
+		italic(text: string) {
+			return text;
+		},
+		underline(text: string) {
+			return text;
+		},
+		strikethrough(text: string) {
+			return text;
+		},
+		getThinkingBorderColor() {
+			return (text: string) => text;
+		},
+	} as unknown as Theme;
+}
+
+function assistant(totalTokens: number, stopReason = "stop") {
+	return {
+		role: "assistant",
+		content: [],
+		api: "anthropic-messages",
+		provider: "anthropic",
+		model: "test",
+		usage: {
+			input: totalTokens === 0 ? 0 : 101,
+			output: totalTokens === 0 ? 0 : 202,
+			cacheRead: totalTokens === 0 ? 0 : 303,
+			cacheWrite: totalTokens === 0 ? 0 : 404,
+			totalTokens,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+		},
+		stopReason,
+		timestamp: 1,
+	};
+}
+
+function persistedEntry(
+	id: string,
+	input: number,
+	output: number,
+	cost: number,
+	cacheRead = 0,
+	cacheWrite = 0,
+) {
+	return {
+		type: "message",
+		id,
+		message: {
+			role: "assistant",
+			usage: {
+				input,
+				output,
+				cacheRead,
+				cacheWrite,
+				totalTokens: input + output,
+				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: cost },
+			},
+		},
+	};
+}
+
+function loadExtension() {
+	const handlers = new Map<string, Handler[]>();
+	zentui({
+		on(name: string, handler: Handler) {
+			handlers.set(name, [...(handlers.get(name) ?? []), handler]);
+		},
+		registerCommand() {},
+		getThinkingLevel() {
+			return "off";
+		},
+	} as never);
+	return handlers;
+}
+
+async function emit(
+	handlers: Map<string, Handler[]>,
+	name: string,
+	ctx: unknown,
+	event: unknown = {},
+) {
+	for (const handler of handlers.get(name) ?? []) await handler(event, ctx);
+}
+
+function createHarness(
+	options: {
+		model?: { id: string; provider: string; contextWindow: number };
+		contextUsage?: { tokens: number; contextWindow: number; percent: number } | null;
+	} = {},
+) {
+	let footerFactory: FooterFactory | undefined;
+	let editorFactory: EditorFactory | undefined;
+	let editorText = "";
+	const requestRender = vi.fn();
+	const editorRequestRender = vi.fn();
+	const entries = [persistedEntry("old", 5, 6, 0.123)];
+	const state = {
+		model:
+			"model" in options
+				? options.model
+				: { id: "test", provider: "anthropic", contextWindow: 10_000 },
+		contextUsage:
+			"contextUsage" in options
+				? options.contextUsage
+				: { tokens: 1_000, contextWindow: 10_000, percent: 10 },
+	};
+	const theme = makeTheme();
+	const ctx = {
+		hasUI: true,
+		mode: "tui",
+		cwd: process.cwd(),
+		get model() {
+			return state.model;
+		},
+		sessionManager: {
+			getBranch: () => entries,
+			getEntries: () => entries,
+			getSessionName: () => undefined,
+		},
+		getContextUsage: () => state.contextUsage,
+		ui: {
+			theme,
+			getEditorText() {
+				return editorText;
+			},
+			setEditorText(text: string) {
+				editorText = text;
+			},
+			setFooter(factory: FooterFactory | undefined) {
+				footerFactory = factory;
+			},
+			setEditorComponent(factory: EditorFactory | undefined) {
+				editorFactory = factory;
+			},
+			getEditorComponent() {
+				return editorFactory;
+			},
+		},
+	};
+	return {
+		ctx,
+		entries,
+		state,
+		requestRender,
+		editorRequestRender,
+		createFooter() {
+			if (!footerFactory) throw new Error("footer was not installed");
+			return footerFactory({ requestRender }, theme, {
+				onBranchChange: () => () => {},
+				getExtensionStatuses: () => new Map<string, string>(),
+			});
+		},
+		createEditor() {
+			if (!editorFactory) throw new Error("editor was not installed");
+			const editor = editorFactory(
+				{ requestRender: editorRequestRender, terminal: { rows: 24, cols: 160 } },
+				{ borderColor: (text: string) => text, selectList: {} },
+				{},
+			);
+			editor.setText("typed text");
+			return editor;
+		},
+	};
+}
+
+function rendered(footer: Footer): string {
+	return footer.render(160).join("\n");
+}
+
+function renderedEditor(editor: Editor): string {
+	return editor.render(160).join("\n");
+}
+
+async function settleProjectRefresh(): Promise<void> {
+	await Promise.resolve();
+	await Promise.resolve();
+	await Promise.resolve();
+}
+
+afterEach(() => {
+	vi.useRealTimers();
+	vi.restoreAllMocks();
+});
+
+describe("live streaming context event integration", () => {
+	it("coalesces registered updates, uses the newest cumulative total, and finalizes canonically", async () => {
+		vi.useFakeTimers();
+		const handlers = loadExtension();
+		const harness = createHarness();
+		await emit(handlers, "session_start", harness.ctx);
+		await settleProjectRefresh();
+		const footer = harness.createFooter();
+		const editor = harness.createEditor();
+		expect(renderedEditor(editor)).toContain("10.0%/10k ↑5 ↓6 0.0%");
+		harness.requestRender.mockClear();
+		harness.editorRequestRender.mockClear();
+
+		await emit(handlers, "message_update", harness.ctx, { message: assistant(1_000) });
+		await emit(handlers, "message_update", harness.ctx, { message: assistant(1_100) });
+		vi.advanceTimersByTime(249);
+		expect(harness.requestRender).not.toHaveBeenCalled();
+		vi.advanceTimersByTime(1);
+		expect(harness.requestRender).toHaveBeenCalledTimes(1);
+		expect(harness.editorRequestRender).toHaveBeenCalledTimes(1);
+		expect(rendered(footer)).toContain("11.0%/10k");
+		expect(rendered(footer)).toContain("↑5 ↓6");
+		expect(rendered(footer)).toContain("$0.123");
+		expect(renderedEditor(editor)).toContain("11.0%/10k ↑5 ↓6 0.0%");
+
+		await emit(handlers, "message_end", harness.ctx, { message: assistant(1_100) });
+		expect(rendered(footer)).toContain("11.0%/10k");
+		expect(rendered(footer)).toContain("↑5 ↓6");
+		expect(rendered(footer)).toContain("$0.123");
+		expect(renderedEditor(editor)).toContain("11.0%/10k ↑5 ↓6 0.0%");
+
+		harness.state.contextUsage = { tokens: 1_200, contextWindow: 10_000, percent: 12 };
+		harness.entries.push(persistedEntry("new", 7, 8, 0.2, 21, 2));
+		await emit(handlers, "agent_end", harness.ctx);
+		const finalized = rendered(footer);
+		expect(finalized).toContain("12.0%/10k");
+		expect(finalized).toContain("↑12 ↓14");
+		expect(finalized).toContain("$0.323");
+		const finalizedEditor = renderedEditor(editor);
+		expect(finalizedEditor).toContain("12.0%/10k ↑12 ↓14 70.0%");
+		expect(finalizedEditor.match(/70\.0%/g)).toHaveLength(1);
+
+		footer.dispose?.();
+		await emit(handlers, "session_shutdown", harness.ctx);
+	});
+
+	it("uses the official context window when the current model is absent and ignores zero usage", async () => {
+		vi.useFakeTimers();
+		const handlers = loadExtension();
+		const harness = createHarness({ model: undefined });
+		await emit(handlers, "session_start", harness.ctx);
+		await settleProjectRefresh();
+		const footer = harness.createFooter();
+
+		await emit(handlers, "message_update", harness.ctx, { message: assistant(1_100) });
+		vi.advanceTimersByTime(250);
+		expect(rendered(footer)).toContain("11.0%/10k");
+
+		await emit(handlers, "agent_start", harness.ctx);
+		harness.requestRender.mockClear();
+		await emit(handlers, "message_update", harness.ctx, { message: assistant(0) });
+		vi.advanceTimersByTime(250);
+		expect(harness.requestRender).not.toHaveBeenCalled();
+		expect(rendered(footer)).toContain("10.0%/10k");
+
+		footer.dispose?.();
+		await emit(handlers, "session_shutdown", harness.ctx);
+	});
+
+	it("clears live usage at wired boundaries and recovers after null compaction", async () => {
+		vi.useFakeTimers();
+		const handlers = loadExtension();
+		const harness = createHarness();
+		await emit(handlers, "session_start", harness.ctx);
+		await settleProjectRefresh();
+		const footer = harness.createFooter();
+		const seedLive = async (tokens = 1_100) => {
+			await emit(handlers, "message_update", harness.ctx, { message: assistant(tokens) });
+			vi.advanceTimersByTime(250);
+			expect(rendered(footer)).toContain(`${(tokens / 100).toFixed(1)}%/10k`);
+		};
+
+		await seedLive();
+		await emit(handlers, "agent_start", harness.ctx);
+		expect(rendered(footer)).toContain("10.0%/10k");
+
+		await seedLive();
+		await emit(handlers, "model_select", harness.ctx);
+		expect(rendered(footer)).toContain("10.0%/10k");
+
+		await seedLive();
+		await emit(handlers, "tool_execution_start", harness.ctx);
+		expect(rendered(footer)).toContain("10.0%/10k");
+
+		await seedLive();
+		await emit(handlers, "session_tree", harness.ctx);
+		expect(rendered(footer)).toContain("10.0%/10k");
+
+		await emit(handlers, "turn_start", harness.ctx);
+		await seedLive();
+		await emit(handlers, "message_end", harness.ctx, { message: assistant(1_100, "error") });
+		expect(rendered(footer)).toContain("10.0%/10k");
+
+		await emit(handlers, "turn_start", harness.ctx);
+		await seedLive();
+		await emit(handlers, "message_end", harness.ctx, { message: assistant(1_100, "aborted") });
+		expect(rendered(footer)).toContain("10.0%/10k");
+
+		await seedLive();
+		harness.state.contextUsage = null;
+		await emit(handlers, "session_compact", harness.ctx);
+		expect(rendered(footer)).toContain("?/10k");
+		await seedLive(1_500);
+
+		harness.state.contextUsage = { tokens: 1_000, contextWindow: 10_000, percent: 10 };
+		await emit(handlers, "agent_start", harness.ctx);
+		await emit(handlers, "message_update", harness.ctx, { message: assistant(1_200) });
+		harness.requestRender.mockClear();
+		await emit(handlers, "session_shutdown", harness.ctx);
+		vi.advanceTimersByTime(250);
+		expect(harness.requestRender).not.toHaveBeenCalled();
+		expect(rendered(footer)).toContain("10.0%/10k");
+	});
+});

package/dist/extensions/pi-zentui/test/live-context.test.ts

@@ -0,0 +1,139 @@
+import type { AssistantMessage, Usage } from "@earendil-works/pi-ai";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+	calculateLiveContextTokens,
+	LiveContextController,
+	liveContextFromMessage,
+} from "../extensions/zentui/live-context";
+import { SessionLifecycle } from "../extensions/zentui/session-lifecycle";
+
+function usage(patch: Partial<Usage> = {}): Usage {
+	return {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		totalTokens: 0,
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+		...patch,
+	};
+}
+
+function assistant(messageUsage: Usage, stopReason: AssistantMessage["stopReason"] = "stop") {
+	return {
+		role: "assistant" as const,
+		content: [],
+		api: "anthropic-messages" as const,
+		provider: "anthropic",
+		model: "test",
+		usage: messageUsage,
+		stopReason,
+		timestamp: 1,
+	};
+}
+
+afterEach(() => {
+	vi.useRealTimers();
+});
+
+describe("live context usage", () => {
+	it("prefers totalTokens and otherwise includes cache components", () => {
+		expect(
+			calculateLiveContextTokens(
+				usage({ input: 400, output: 300, cacheRead: 200, cacheWrite: 100, totalTokens: 777 }),
+			),
+		).toBe(777);
+		expect(
+			calculateLiveContextTokens(
+				usage({ input: 400, output: 300, cacheRead: 200, cacheWrite: 100 }),
+			),
+		).toBe(1_000);
+	});
+
+	it("ignores zero usage, non-assistant messages, and failed assistant snapshots", () => {
+		expect(calculateLiveContextTokens(usage())).toBeUndefined();
+		expect(liveContextFromMessage({ role: "user" })).toBeUndefined();
+		expect(liveContextFromMessage(assistant(usage({ totalTokens: 100 }), "error"))).toBeUndefined();
+		expect(
+			liveContextFromMessage(assistant(usage({ totalTokens: 100 }), "aborted")),
+		).toBeUndefined();
+	});
+
+	it("keeps the newest cumulative snapshot instead of summing deltas", () => {
+		vi.useFakeTimers();
+		const lifecycle = new SessionLifecycle();
+		lifecycle.start();
+		const render = vi.fn();
+		const controller = new LiveContextController(lifecycle, render);
+
+		controller.update(assistant(usage({ totalTokens: 1_000 })));
+		controller.update(assistant(usage({ totalTokens: 1_100 })));
+		expect(controller.get()).toEqual({ tokens: 1_100 });
+		vi.advanceTimersByTime(250);
+
+		expect(render).toHaveBeenCalledTimes(1);
+		expect(controller.get()).toEqual({ tokens: 1_100 });
+	});
+
+	it("coalesces bursts to at most one render per 250ms with the newest usage", () => {
+		vi.useFakeTimers();
+		const lifecycle = new SessionLifecycle();
+		lifecycle.start();
+		const renderedTokens: number[] = [];
+		let controller: LiveContextController;
+		controller = new LiveContextController(lifecycle, () => {
+			renderedTokens.push(controller.get()?.tokens ?? 0);
+		});
+
+		for (const totalTokens of [100, 200, 300, 400]) {
+			controller.update(assistant(usage({ totalTokens })));
+		}
+		expect(vi.getTimerCount()).toBe(1);
+		vi.advanceTimersByTime(249);
+		expect(renderedTokens).toEqual([]);
+		vi.advanceTimersByTime(1);
+		expect(renderedTokens).toEqual([400]);
+
+		controller.update(assistant(usage({ totalTokens: 500 })));
+		vi.advanceTimersByTime(250);
+		expect(renderedTokens).toEqual([400, 500]);
+	});
+
+	it("cancels old generations without suppressing scheduling after direct lifecycle restarts", () => {
+		vi.useFakeTimers();
+		const lifecycle = new SessionLifecycle();
+		lifecycle.start();
+		const renderedTokens: number[] = [];
+		let controller: LiveContextController;
+		controller = new LiveContextController(lifecycle, () => {
+			renderedTokens.push(controller.get()?.tokens ?? 0);
+		});
+
+		controller.update(assistant(usage({ totalTokens: 100 })));
+		lifecycle.shutdown();
+		vi.advanceTimersByTime(250);
+		expect(renderedTokens).toEqual([]);
+
+		lifecycle.start();
+		controller.update(assistant(usage({ totalTokens: 200 })));
+		vi.advanceTimersByTime(250);
+		expect(renderedTokens).toEqual([200]);
+
+		controller.update(assistant(usage({ totalTokens: 300 })));
+		lifecycle.start();
+		controller.update(assistant(usage({ totalTokens: 400 })));
+		vi.advanceTimersByTime(250);
+		expect(renderedTokens).toEqual([200, 400]);
+	});
+
+	it("recovers from a cleared compaction boundary when live usage resumes", () => {
+		const lifecycle = new SessionLifecycle();
+		lifecycle.start();
+		const controller = new LiveContextController(lifecycle, () => {});
+		controller.update(assistant(usage({ totalTokens: 100 })));
+		controller.clear();
+		expect(controller.get()).toBeUndefined();
+		controller.update(assistant(usage({ totalTokens: 150 })));
+		expect(controller.get()).toEqual({ tokens: 150 });
+	});
+});