osdy-pi 1.2.0 → 1.3.0

package/extensions/osdy-pi/runtime.test.ts

@@ -1,8 +1,50 @@
 import assert from "node:assert/strict";
+import { existsSync, readFileSync } from "node:fs";
+import { registerHooks } from "node:module";
 import test from "node:test";
+import { fileURLToPath } from "node:url";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-// @ts-expect-error Node's native TypeScript runner resolves test-only TypeScript source imports.
-import { PLUGIN_EVENTS, subscribeQuestionPromptAudioNotification } from "./plugin-events.ts";
+import ts from "typescript";
+
+registerHooks({
+	resolve(specifier, context, nextResolve) {
+		if (
+			specifier.startsWith(".") &&
+			specifier.endsWith(".js") &&
+			context.parentURL?.endsWith(".ts")
+		) {
+			const sourceUrl = new URL(`${specifier.slice(0, -3)}.ts`, context.parentURL);
+			if (existsSync(fileURLToPath(sourceUrl))) {
+				return { shortCircuit: true, url: sourceUrl.href };
+			}
+		}
+		return nextResolve(specifier, context);
+	},
+	load(url, context, nextLoad) {
+		if (url.endsWith(".ts")) {
+			const source = readFileSync(fileURLToPath(url), "utf8");
+			return {
+				format: "module",
+				shortCircuit: true,
+				source: ts.transpileModule(source, {
+					compilerOptions: {
+						module: ts.ModuleKind.ESNext,
+						target: ts.ScriptTarget.ES2022,
+					},
+				}).outputText,
+			};
+		}
+		return nextLoad(url, context);
+	},
+});
+
+const { PLUGIN_EVENTS, subscribeQuestionPromptAudioNotification } =
+	await import("./plugin-events.js");
+const {
+	createActiveSessionRefresh,
+	getOsdyCommandCompletions,
+	refreshCodexUsage,
+} = await import("./runtime.js");
 
 class TestEventBus {
 	event: string | undefined;
@@ -38,16 +80,322 @@ class TestSessionContextProvider {
 	}
 }
 
+void test("header command completes only catalog choices and is persisted through session wiring", () => {
+	assert.deepEqual(getOsdyCommandCompletions("header"), [
+		{ value: "header osdy-theme", label: "header osdy-theme" },
+		{ value: "header neon", label: "header neon" },
+		{ value: "header status", label: "header status" },
+	]);
+	assert.deepEqual(getOsdyCommandCompletions("header n"), [
+		{ value: "header neon", label: "header neon" },
+	]);
+	assert.deepEqual(getOsdyCommandCompletions("classic"), []);
+
+	const source = readFileSync(new URL("./runtime.ts", import.meta.url), "utf8");
+	assert.match(
+		source,
+		/async function handleHeaderCommand[\s\S]*?state\.headerVariant = action;[\s\S]*?applyOsdyPi\([\s\S]*?saveVisualSettings\(state, settingsStore\)/,
+	);
+	assert.match(source, /headerVariant: state\.headerVariant/);
+	assert.match(source, /state\.headerVariant = editorSettings\.headerVariant;/);
+	assert.doesNotMatch(source, /registerCommand\(`osdy-pi-\$\{variant\}`/);
+	assert.doesNotMatch(source, /\["osdy-theme", "classic"\]/);
+	assert.doesNotMatch(source, /if \(isHeaderVariant\(action\)\)/);
+});
+
+void test("mascot command completes current, Bts, and status while persisting with immediate refresh", () => {
+	assert.deepEqual(getOsdyCommandCompletions("mascot"), [
+		{ value: "mascot current", label: "mascot current" },
+		{ value: "mascot bts", label: "mascot bts" },
+		{ value: "mascot status", label: "mascot status" },
+	]);
+	assert.deepEqual(getOsdyCommandCompletions("mascot b"), [
+		{ value: "mascot bts", label: "mascot bts" },
+	]);
+	assert.deepEqual(getOsdyCommandCompletions("mascot d"), []);
+
+	const source = readFileSync(new URL("./runtime.ts", import.meta.url), "utf8");
+	assert.match(
+		source,
+		/state\.mascot = action;[\s\S]*?applyOsdyPi\([\s\S]*?saveVisualSettings\(state, settingsStore\)/,
+	);
+	assert.match(source, /state\.mascot = editorSettings\.mascot;/);
+	assert.match(source, /function mascotLabel\(mascot: MascotChoice\): string/);
+	assert.match(source, /osdy-pi mascot: \$\{mascotLabel\(state\.mascot\)\}/);
+});
+
+void test("account switching requests an editor render independently of usage refresh", () => {
+	const source = readFileSync(new URL("./runtime.ts", import.meta.url), "utf8");
+
+	assert.match(
+		source,
+		/registerAccountProfilesCommand\(pi, \{[\s\S]*?requestRender: \(\) => \{[\s\S]*?state\.tui\?\.requestRender\(\);[\s\S]*?\},[\s\S]*?refreshUsage: async \(\) => \{[\s\S]*?const activeSessionContext = sessionContext;[\s\S]*?await refreshCurrentCodexUsage\(activeSessionContext\)/,
+	);
+});
+
+void test("usage refresh resolves the active session instead of a distinct command context", async () => {
+	const activeSessionContext = { id: "active-session" };
+	const commandContext = { id: "command-context" };
+	const refreshedContexts: Array<{ id: string }> = [];
+	const refreshActiveSessionUsage = createActiveSessionRefresh(
+		() => activeSessionContext,
+		(context) => {
+			refreshedContexts.push(context);
+			return Promise.resolve();
+		},
+	);
+
+	assert.notEqual(commandContext, activeSessionContext);
+	await refreshActiveSessionUsage();
+	assert.deepEqual(refreshedContexts, [activeSessionContext]);
+});
+
+void test("agent settlement refreshes enabled active Codex sessions without comparing event context identity", () => {
+	const source = readFileSync(new URL("./runtime.ts", import.meta.url), "utf8");
+	const agentSettledHandler = source.match(
+		/pi\.on\("agent_settled", \(\) => \{([\s\S]*?)\n\t\}\);/,
+	)?.[1];
+	const agentEndHandler = source.match(
+		/pi\.on\("agent_end", \(_event, ctx\) => \{([\s\S]*?)\n\t\}\);/,
+	)?.[1];
+
+	assert.ok(agentSettledHandler);
+	assert.match(
+		agentSettledHandler,
+		/const activeSessionContext = sessionContext;[\s\S]*?state\.enabled[\s\S]*?activeSessionContext &&[\s\S]*?activeSessionContext\.model\?\.provider === "openai-codex"[\s\S]*?void refreshCurrentCodexUsage\(activeSessionContext\)/,
+	);
+	assert.doesNotMatch(agentSettledHandler, /activeSessionContext\s*===\s*ctx/);
+	assert.ok(agentEndHandler);
+	assert.doesNotMatch(agentEndHandler, /refreshCurrentCodexUsage/);
+});
+
+void test("Codex usage state refresh repaints the shared TUI after loading and error", async () => {
+	const renderedStates: string[] = [];
+	const state = {
+		codexUsage: { kind: "idle" } as const,
+		tui: {
+			requestRender: () => renderedStates.push(state.codexUsage.kind),
+		},
+	};
+
+	await refreshCodexUsage(
+		{
+			modelRegistry: {
+				getProviderAuth: () => Promise.resolve(undefined),
+			},
+		},
+		state,
+		new AbortController(),
+	);
+
+	assert.deepEqual(renderedStates, ["loading", "error"]);
+	assert.equal(state.codexUsage.kind, "error");
+});
+
+void test("Codex usage refresh repaints the shared TUI with its ready quota snapshot", async () => {
+	const snapshot = {
+		planType: "plus",
+		ordinaryUsageAllowed: true,
+		buckets: [
+			{
+				id: "codex",
+				label: undefined,
+				primary: { usedPercent: 37, windowMinutes: 300, resetsAt: undefined },
+				secondary: undefined,
+			},
+		],
+		credits: undefined,
+		fetchedAt: 1_900_000_000_000,
+	};
+	const renderedStates: string[] = [];
+	const state = {
+		codexUsage: { kind: "idle" } as const,
+		tui: {
+			requestRender: () => renderedStates.push(state.codexUsage.kind),
+		},
+	};
+	const accessToken = `header.${Buffer.from(
+		JSON.stringify({
+			"https://api.openai.com/auth": { chatgpt_account_id: "account-id" },
+		}),
+	).toString("base64url")}.signature`;
+
+	await refreshCodexUsage(
+		{
+			modelRegistry: {
+				getProviderAuth: () => Promise.resolve({ auth: { apiKey: accessToken } }),
+			},
+		},
+		state,
+		new AbortController(),
+		() => Promise.resolve(snapshot),
+	);
+
+	assert.deepEqual(renderedStates, ["loading", "ready"]);
+	assert.deepEqual(state.codexUsage, { kind: "ready", snapshot });
+});
+
+void test("Codex refresh discards prior usage snapshots and shutdown resets usage state", () => {
+	const source = readFileSync(new URL("./runtime.ts", import.meta.url), "utf8");
+	assert.match(
+		source,
+		/state\.codexUsage = \{ kind: "loading", snapshot: undefined \}/,
+	);
+	assert.match(source, /kind: "error",[\s\S]*?snapshot: undefined,/);
+	assert.match(
+		source,
+		/pi\.on\("session_shutdown", \(\) => \{[\s\S]*?codexUsageAbort\?\.abort\(\);[\s\S]*?state\.codexUsage = \{ kind: "idle" \}/,
+	);
+});
+
+void test("agent and tool completion reclaim the Gentle changed-files widget", () => {
+	const source = readFileSync(new URL("./runtime.ts", import.meta.url), "utf8");
+	const agentEndHandler = source.match(
+		/pi\.on\("agent_end", \(_event, ctx\) => \{([\s\S]*?)\n\t\}\);/,
+	)?.[1];
+	const toolExecutionEndHandler = source.match(
+		/pi\.on\("tool_execution_end", \(event, ctx\) => \{([\s\S]*?)\n\t\}\);/,
+	)?.[1];
+
+	assert.ok(agentEndHandler);
+	assert.ok(toolExecutionEndHandler);
+	assert.match(
+		agentEndHandler,
+		/if \(state\.enabled\) clearGentleShellChangesWidget\(ctx\)/,
+	);
+	assert.match(
+		toolExecutionEndHandler,
+		/if \(state\.enabled\) clearGentleShellChangesWidget\(ctx\)/,
+	);
+});
+
+void test("session shutdown does not restore the captured fallback editor", () => {
+	const source = readFileSync(new URL("./runtime.ts", import.meta.url), "utf8");
+	const shutdownHandler = source.match(
+		/pi\.on\("session_shutdown", \(\) => \{([\s\S]*?)\n\t\}\);/,
+	)?.[1];
+
+	assert.ok(shutdownHandler);
+	assert.doesNotMatch(shutdownHandler, /disableOsdyPi|setEditorComponent/);
+});
+
+void test("persisted disabled startup leaves Gentle UI unclaimed and simple startup stays native", () => {
+	const source = readFileSync(new URL("./runtime.ts", import.meta.url), "utf8");
+	const sessionStartHandler = source.match(
+		/pi\.on\("session_start", async \(_event, ctx\) => \{([\s\S]*?)\n\t\}\);/,
+	)?.[1];
+
+	assert.ok(sessionStartHandler);
+	assert.match(
+		sessionStartHandler,
+		/state\.fallbackEditorFactory = ctx\.ui\.getEditorComponent\(\);[\s\S]*?state\.enabled = editorSettings\.enabled;[\s\S]*?if \(!state\.enabled\) return;/,
+	);
+	assert.match(
+		sessionStartHandler,
+		/state\.editorMode = editorSettings\.editorMode;[\s\S]*?claimOsdyVisualLayer\(/,
+	);
+	assert.match(
+		sessionStartHandler,
+		/if \(!state\.enabled\) return;[\s\S]*?startResponsive\(\)/,
+	);
+	assert.match(
+		source,
+		/const startResponsive = \(\): void => \{[\s\S]*?responsiveCoordinator = createResponsiveCoordinator\(/,
+	);
+});
+
+void test("enable, disable, and their on/off aliases persist the complete visual settings", () => {
+	const source = readFileSync(new URL("./runtime.ts", import.meta.url), "utf8");
+
+	assert.match(source, /\["enable", "on"\]\.includes\(action\)/);
+	assert.match(source, /\["disable", "off"\]\.includes\(action\)/);
+	assert.match(
+		source,
+		/settingsStore\.save\(\{[\s\S]*?enabled: state\.enabled,[\s\S]*?editorMode: state\.editorMode,[\s\S]*?workingTreeEnabled: state\.workingTreeEnabled,[\s\S]*?\}\)/,
+	);
+});
+
+void test("does not import or register the response-card Markdown transformer", () => {
+	const source = readFileSync(new URL("./runtime.ts", import.meta.url), "utf8");
+
+	assert.doesNotMatch(source, /response-card/);
+	assert.doesNotMatch(source, /pi\.registerMarkdownTransformer\(/);
+});
+
+void test("every registered theme defines non-empty assistant message tokens", () => {
+	const manifest = JSON.parse(
+		readFileSync(new URL("../../package.json", import.meta.url), "utf8"),
+	) as { pi: { themes: string[] } };
+
+	assert.equal(manifest.pi.themes.length, 14);
+	for (const themePath of manifest.pi.themes) {
+		const theme = JSON.parse(
+			readFileSync(
+				new URL(`../../${themePath.replace(/^\.\//, "")}`, import.meta.url),
+				"utf8",
+			),
+		) as { colors: Record<string, unknown> };
+		for (const token of [
+			"assistantMessageBg",
+			"assistantMessageAccentBg",
+			"assistantMessageText",
+		]) {
+			const value = theme.colors[token];
+			assert.equal(
+				typeof value === "string" && value.trim() !== "",
+				true,
+				`${themePath} must define a non-empty ${token}`,
+			);
+		}
+		assert.equal(
+			theme.colors.assistantMessageAccentBg,
+			theme.colors.accent,
+			`${themePath} assistant stripe must match its accent`,
+		);
+		assert.equal(
+			theme.colors.userMessageAccentBg,
+			"#FFFFFF",
+			`${themePath} user stripe must be white`,
+		);
+	}
+});
+
+void test("Tokyo Night uses original palette tokens for message stripes", () => {
+	const theme = JSON.parse(
+		readFileSync(
+			new URL("../../themes/osdy-pi-tokyo-night.json", import.meta.url),
+			"utf8",
+		),
+	) as { colors: Record<string, unknown> };
+
+	assert.deepEqual(
+		{
+			assistantMessageBg: theme.colors.assistantMessageBg,
+			assistantMessageAccentBg: theme.colors.assistantMessageAccentBg,
+			assistantMessageText: theme.colors.assistantMessageText,
+			userMessageAccentBg: theme.colors.userMessageAccentBg,
+			userMessageBg: theme.colors.userMessageBg,
+			userMessageText: theme.colors.userMessageText,
+		},
+		{
+			assistantMessageBg: "elevated",
+			assistantMessageAccentBg: "blue",
+			assistantMessageText: "text",
+			userMessageAccentBg: "#FFFFFF",
+			userMessageBg: "panel",
+			userMessageText: "text",
+		},
+	);
+});
+
 void test("question prompts subscribe through the plugin event bus", () => {
 	const api = new TestExtensionApi();
 	const sessionContextProvider = new TestSessionContextProvider();
 	const notifiedContexts: ExtensionContext[] = [];
 
-	subscribeQuestionPromptAudioNotification(
-		api,
-		sessionContextProvider,
-		{ onQuestionRequested: (ctx) => notifiedContexts.push(ctx) },
-	);
+	subscribeQuestionPromptAudioNotification(api, sessionContextProvider, {
+		onQuestionRequested: (ctx) => notifiedContexts.push(ctx),
+	});
 
 	assert.equal(api.events.event, PLUGIN_EVENTS.QUESTION_PROMPT);
 	assert.equal(api.lifecycleOnCallCount, 0);