pi-usereq 0.6.0 → 0.10.0

package/pi.dev-src/pi-mono/coding-agent/test/test-harness.ts

@@ -0,0 +1,446 @@
+/**
+ * Test harness for AgentSession runtime testing.
+ *
+ * Provides:
+ * - A faux stream function with declarative response sequencing
+ * - A one-call factory for a fully wired AgentSession with real in-memory dependencies
+ * - Event capture for assertions
+ */
+
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { AgentTool } from "@mariozechner/pi-agent-core";
+import { Agent } from "@mariozechner/pi-agent-core";
+import type {
+	AssistantMessage,
+	AssistantMessageEvent,
+	AssistantMessageEventStream,
+	Context,
+	Model,
+	SimpleStreamOptions,
+	StopReason,
+	TextContent,
+	ThinkingContent,
+	ToolCall,
+	Usage,
+} from "@mariozechner/pi-ai";
+import { createAssistantMessageEventStream } from "@mariozechner/pi-ai";
+import { AgentSession, type AgentSessionEvent } from "../src/core/agent-session.js";
+import { AuthStorage } from "../src/core/auth-storage.js";
+import { ModelRegistry } from "../src/core/model-registry.js";
+import { SessionManager } from "../src/core/session-manager.js";
+import type { Settings } from "../src/core/settings-manager.js";
+import { SettingsManager } from "../src/core/settings-manager.js";
+import type { ExtensionFactory, ResourceLoader } from "../src/index.js";
+import {
+	type CreateTestExtensionsResultInput,
+	createTestExtensionsResult,
+	createTestResourceLoader,
+} from "./utilities.js";
+
+// ============================================================================
+// Faux model
+// ============================================================================
+
+const FAUX_PROVIDER = "faux";
+const FAUX_MODEL_ID = "faux-1";
+const FAUX_API = "anthropic-messages" as const;
+
+export const fauxModel: Model<typeof FAUX_API> = {
+	id: FAUX_MODEL_ID,
+	name: "Faux Model",
+	api: FAUX_API,
+	provider: FAUX_PROVIDER,
+	baseUrl: "http://localhost:0",
+	reasoning: false,
+	input: ["text", "image"],
+	cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+	contextWindow: 128000,
+	maxTokens: 16384,
+};
+
+// ============================================================================
+// Response description
+// ============================================================================
+
+export interface FauxResponse {
+	/** Text content blocks. String shorthand becomes a single text block. */
+	text?: string;
+	/** Tool calls to include in the response. */
+	toolCalls?: Array<{ id?: string; name: string; args: Record<string, unknown> }>;
+	/** Thinking content. */
+	thinking?: string;
+	/** Stop reason. Defaults to "stop", or "toolUse" if toolCalls are present, or "error" if error is set. */
+	stopReason?: StopReason;
+	/** Error message. Sets stopReason to "error" if not explicitly set. */
+	error?: string;
+	/** Usage numbers. Merged with defaults (input: 100, output: 50). */
+	usage?: Partial<Usage>;
+	/** Delay in ms before the response starts. */
+	delayMs?: number;
+	/** Model overrides (provider, model id) for responses that should look like they came from a different model. */
+	model?: { provider?: string; id?: string };
+}
+
+/** Shorthand: a string becomes a simple text response. */
+export type FauxResponseInput = FauxResponse | string;
+
+// ============================================================================
+// Faux stream function
+// ============================================================================
+
+function normalizeResponse(input: FauxResponseInput): FauxResponse {
+	if (typeof input === "string") {
+		return { text: input };
+	}
+	return input;
+}
+
+function buildUsage(partial?: Partial<Usage>): Usage {
+	const input = partial?.input ?? 100;
+	const output = partial?.output ?? 50;
+	const cacheRead = partial?.cacheRead ?? 0;
+	const cacheWrite = partial?.cacheWrite ?? 0;
+	return {
+		input,
+		output,
+		cacheRead,
+		cacheWrite,
+		totalTokens: partial?.totalTokens ?? input + output + cacheRead + cacheWrite,
+		cost: partial?.cost ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+	};
+}
+
+let toolCallIdCounter = 0;
+
+function buildAssistantMessage(resp: FauxResponse): AssistantMessage {
+	const content: (TextContent | ThinkingContent | ToolCall)[] = [];
+
+	if (resp.thinking) {
+		content.push({ type: "thinking", thinking: resp.thinking });
+	}
+	if (resp.text !== undefined) {
+		content.push({ type: "text", text: resp.text });
+	}
+	if (resp.toolCalls) {
+		for (const tc of resp.toolCalls) {
+			content.push({
+				type: "toolCall",
+				id: tc.id ?? `faux_tc_${++toolCallIdCounter}`,
+				name: tc.name,
+				arguments: tc.args,
+			});
+		}
+	}
+
+	// If no content was added at all, add empty text
+	if (content.length === 0 && !resp.error) {
+		content.push({ type: "text", text: "" });
+	}
+
+	let stopReason: StopReason;
+	if (resp.stopReason) {
+		stopReason = resp.stopReason;
+	} else if (resp.error) {
+		stopReason = "error";
+	} else if (resp.toolCalls && resp.toolCalls.length > 0) {
+		stopReason = "toolUse";
+	} else {
+		stopReason = "stop";
+	}
+
+	return {
+		role: "assistant",
+		content,
+		api: FAUX_API,
+		provider: resp.model?.provider ?? FAUX_PROVIDER,
+		model: resp.model?.id ?? FAUX_MODEL_ID,
+		usage: buildUsage(resp.usage),
+		stopReason,
+		errorMessage: resp.error,
+		timestamp: Date.now(),
+	};
+}
+
+// ============================================================================
+// Token-level streaming
+// ============================================================================
+
+/** Split a string into chunks of varying size (3-5 chars) for simulating token-by-token streaming. */
+function chunkString(text: string): string[] {
+	const chunks: string[] = [];
+	let i = 0;
+	while (i < text.length) {
+		const size = 3 + Math.floor(Math.random() * 3); // 3, 4, or 5
+		chunks.push(text.slice(i, i + size));
+		i += size;
+	}
+	return chunks.length > 0 ? chunks : [""];
+}
+
+/**
+ * Stream a complete AssistantMessage through an EventStream with realistic
+ * intermediate delta events for each content block.
+ */
+function streamWithDeltas(stream: AssistantMessageEventStream, message: AssistantMessage): void {
+	const isError = message.stopReason === "error" || message.stopReason === "aborted";
+
+	// Build partial progressively as we stream content blocks
+	const partial: AssistantMessage = { ...message, content: [] };
+	stream.push({ type: "start", partial: { ...partial } });
+
+	for (let i = 0; i < message.content.length; i++) {
+		const block = message.content[i];
+
+		if (block.type === "thinking") {
+			partial.content = [...partial.content, { type: "thinking", thinking: "" }];
+			stream.push({ type: "thinking_start", contentIndex: i, partial: { ...partial } });
+
+			for (const chunk of chunkString(block.thinking)) {
+				(partial.content[i] as ThinkingContent).thinking += chunk;
+				stream.push(makeEvent("thinking_delta", i, chunk, partial));
+			}
+
+			stream.push({
+				type: "thinking_end",
+				contentIndex: i,
+				content: block.thinking,
+				partial: { ...partial },
+			});
+		} else if (block.type === "text") {
+			partial.content = [...partial.content, { type: "text", text: "" }];
+			stream.push({ type: "text_start", contentIndex: i, partial: { ...partial } });
+
+			for (const chunk of chunkString(block.text)) {
+				(partial.content[i] as TextContent).text += chunk;
+				stream.push(makeEvent("text_delta", i, chunk, partial));
+			}
+
+			stream.push({
+				type: "text_end",
+				contentIndex: i,
+				content: block.text,
+				partial: { ...partial },
+			});
+		} else if (block.type === "toolCall") {
+			const argsJson = JSON.stringify(block.arguments);
+			partial.content = [...partial.content, { type: "toolCall", id: block.id, name: block.name, arguments: {} }];
+			stream.push({ type: "toolcall_start", contentIndex: i, partial: { ...partial } });
+
+			for (const chunk of chunkString(argsJson)) {
+				stream.push(makeEvent("toolcall_delta", i, chunk, partial));
+			}
+
+			// Final toolcall has the real parsed arguments
+			(partial.content[i] as ToolCall).arguments = block.arguments;
+			stream.push({
+				type: "toolcall_end",
+				contentIndex: i,
+				toolCall: block,
+				partial: { ...partial },
+			});
+		}
+	}
+
+	if (isError) {
+		stream.push({ type: "error", reason: message.stopReason as "error" | "aborted", error: message });
+	} else {
+		stream.push({ type: "done", reason: message.stopReason as "stop" | "length" | "toolUse", message });
+	}
+}
+
+function makeEvent(
+	type: "text_delta" | "thinking_delta" | "toolcall_delta",
+	contentIndex: number,
+	delta: string,
+	partial: AssistantMessage,
+): AssistantMessageEvent {
+	return { type, contentIndex, delta, partial: { ...partial } };
+}
+
+// ============================================================================
+// Stream function factory
+// ============================================================================
+
+export interface FauxStreamFnState {
+	/** Number of times the stream function has been called. */
+	callCount: number;
+	/** The context passed to each call, in order. */
+	contexts: Context[];
+}
+
+/**
+ * Create a faux stream function from a sequence of response descriptions.
+ *
+ * The function cycles through responses in order. If more calls are made than
+ * responses provided, it wraps around.
+ *
+ * Returns the stream function and a state object for inspection.
+ */
+export function createFauxStreamFn(responses: FauxResponseInput[]): {
+	streamFn: (model: Model<any>, context: Context, options?: SimpleStreamOptions) => AssistantMessageEventStream;
+	state: FauxStreamFnState;
+} {
+	if (responses.length === 0) {
+		throw new Error("createFauxStreamFn requires at least one response");
+	}
+
+	const state: FauxStreamFnState = { callCount: 0, contexts: [] };
+
+	const streamFn = (_model: Model<any>, context: Context, _options?: SimpleStreamOptions) => {
+		const index = state.callCount % responses.length;
+		state.callCount++;
+		state.contexts.push(context);
+
+		const resp = normalizeResponse(responses[index]);
+		const message = buildAssistantMessage(resp);
+		const stream = createAssistantMessageEventStream();
+
+		const emit = () => {
+			streamWithDeltas(stream, message);
+		};
+
+		if (resp.delayMs && resp.delayMs > 0) {
+			setTimeout(emit, resp.delayMs);
+		} else {
+			queueMicrotask(emit);
+		}
+
+		return stream;
+	};
+
+	return { streamFn, state };
+}
+
+// ============================================================================
+// Session harness
+// ============================================================================
+
+export interface HarnessOptions {
+	/** Response sequence for the faux provider. Default: single "ok" response. */
+	responses?: FauxResponseInput[];
+	/** Model to use. Default: fauxModel. */
+	model?: Model<any>;
+	/** Context window override (applied to the model). */
+	contextWindow?: number;
+	/** Settings overrides (retry, compaction, etc.). */
+	settings?: Partial<Settings>;
+	/** System prompt. Default: "You are a test assistant." */
+	systemPrompt?: string;
+	/** Custom tools to register on the agent. */
+	tools?: AgentTool[];
+	/** Base tools override (replaces built-in read/bash/edit/write). */
+	baseToolsOverride?: Record<string, AgentTool>;
+	/** Optional resource loader override. */
+	resourceLoader?: ResourceLoader;
+	/** Inline extensions to load into the session resource loader. */
+	extensionFactories?: Array<ExtensionFactory | CreateTestExtensionsResultInput>;
+}
+
+export interface Harness {
+	session: AgentSession;
+	agent: Agent;
+	sessionManager: SessionManager;
+	settingsManager: SettingsManager;
+	/** Faux stream function state (call count, captured contexts). */
+	faux: FauxStreamFnState;
+	/** All events emitted by the session, in order. */
+	events: AgentSessionEvent[];
+	/** Filter captured events by type. */
+	eventsOfType<T extends AgentSessionEvent["type"]>(type: T): Extract<AgentSessionEvent, { type: T }>[];
+	/** Temp directory (cleaned up by cleanup()). */
+	tempDir: string;
+	/** Dispose session and remove temp directory. */
+	cleanup: () => void;
+}
+
+function createTempDir(): string {
+	const tempDir = join(tmpdir(), `pi-harness-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+	mkdirSync(tempDir, { recursive: true });
+	return tempDir;
+}
+
+function createHarnessWithResourceLoader(
+	options: HarnessOptions,
+	resourceLoader: ResourceLoader,
+	tempDir: string,
+): Harness {
+	const baseModel = options.model ?? fauxModel;
+	const model: Model<any> = options.contextWindow ? { ...baseModel, contextWindow: options.contextWindow } : baseModel;
+
+	const { streamFn, state: fauxState } = createFauxStreamFn(options.responses ?? ["ok"]);
+
+	const agent = new Agent({
+		getApiKey: () => "faux-key",
+		initialState: {
+			model,
+			systemPrompt: options.systemPrompt ?? "You are a test assistant.",
+			tools: options.tools ?? [],
+		},
+		streamFn,
+	});
+
+	const sessionManager = SessionManager.inMemory();
+	const settingsManager = SettingsManager.create(tempDir, tempDir);
+
+	if (options.settings) {
+		settingsManager.applyOverrides(options.settings);
+	}
+
+	const authStorage = AuthStorage.create(join(tempDir, "auth.json"));
+	authStorage.setRuntimeApiKey(model.provider, "faux-key");
+	const modelRegistry = ModelRegistry.create(authStorage, tempDir);
+
+	const session = new AgentSession({
+		agent,
+		sessionManager,
+		settingsManager,
+		cwd: tempDir,
+		modelRegistry,
+		resourceLoader,
+		baseToolsOverride: options.baseToolsOverride,
+	});
+
+	const events: AgentSessionEvent[] = [];
+	session.subscribe((event) => {
+		events.push(event);
+	});
+
+	const cleanup = () => {
+		session.dispose();
+		if (existsSync(tempDir)) {
+			rmSync(tempDir, { recursive: true });
+		}
+	};
+
+	return {
+		session,
+		agent,
+		sessionManager,
+		settingsManager,
+		faux: fauxState,
+		events,
+		eventsOfType<T extends AgentSessionEvent["type"]>(type: T) {
+			return events.filter((e): e is Extract<AgentSessionEvent, { type: T }> => e.type === type);
+		},
+		tempDir,
+		cleanup,
+	};
+}
+
+export function createHarness(options: HarnessOptions = {}): Harness {
+	if (options.extensionFactories?.length) {
+		throw new Error("createHarness does not support extensionFactories. Use createHarnessWithExtensions().");
+	}
+
+	const tempDir = createTempDir();
+	return createHarnessWithResourceLoader(options, options.resourceLoader ?? createTestResourceLoader(), tempDir);
+}
+
+export async function createHarnessWithExtensions(options: HarnessOptions = {}): Promise<Harness> {
+	const tempDir = createTempDir();
+	const extensionsResult = await createTestExtensionsResult(options.extensionFactories ?? [], tempDir);
+	const resourceLoader = options.resourceLoader ?? createTestResourceLoader({ extensionsResult });
+	return createHarnessWithResourceLoader(options, resourceLoader, tempDir);
+}

package/pi.dev-src/pi-mono/coding-agent/test/test-theme-colors.ts

@@ -0,0 +1,246 @@
+import fs from "fs";
+import { initTheme, theme } from "../src/modes/interactive/theme/theme.js";
+
+// --- Color utilities ---
+
+function hexToRgb(hex: string): [number, number, number] {
+	const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+	return result ? [parseInt(result[1], 16), parseInt(result[2], 16), parseInt(result[3], 16)] : [0, 0, 0];
+}
+
+function rgbToHex(r: number, g: number, b: number): string {
+	return (
+		"#" +
+		[r, g, b]
+			.map((x) =>
+				Math.round(Math.max(0, Math.min(255, x)))
+					.toString(16)
+					.padStart(2, "0"),
+			)
+			.join("")
+	);
+}
+
+function rgbToHsl(r: number, g: number, b: number): [number, number, number] {
+	r /= 255;
+	g /= 255;
+	b /= 255;
+	const max = Math.max(r, g, b),
+		min = Math.min(r, g, b);
+	let h = 0,
+		s = 0;
+	const l = (max + min) / 2;
+	if (max !== min) {
+		const d = max - min;
+		s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+		switch (max) {
+			case r:
+				h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+				break;
+			case g:
+				h = ((b - r) / d + 2) / 6;
+				break;
+			case b:
+				h = ((r - g) / d + 4) / 6;
+				break;
+		}
+	}
+	return [h, s, l];
+}
+
+function hslToRgb(h: number, s: number, l: number): [number, number, number] {
+	let r: number, g: number, b: number;
+	if (s === 0) {
+		r = g = b = l;
+	} else {
+		const hue2rgb = (p: number, q: number, t: number) => {
+			if (t < 0) t += 1;
+			if (t > 1) t -= 1;
+			if (t < 1 / 6) return p + (q - p) * 6 * t;
+			if (t < 1 / 2) return q;
+			if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
+			return p;
+		};
+		const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+		const p = 2 * l - q;
+		r = hue2rgb(p, q, h + 1 / 3);
+		g = hue2rgb(p, q, h);
+		b = hue2rgb(p, q, h - 1 / 3);
+	}
+	return [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255)];
+}
+
+function getLuminance(r: number, g: number, b: number): number {
+	const lin = (c: number) => {
+		c = c / 255;
+		return c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+	};
+	return 0.2126 * lin(r) + 0.7152 * lin(g) + 0.0722 * lin(b);
+}
+
+function getContrast(rgb: [number, number, number], bgLum: number): number {
+	const fgLum = getLuminance(...rgb);
+	const lighter = Math.max(fgLum, bgLum);
+	const darker = Math.min(fgLum, bgLum);
+	return (lighter + 0.05) / (darker + 0.05);
+}
+
+function adjustColorToContrast(hex: string, targetContrast: number, againstWhite: boolean): string {
+	const rgb = hexToRgb(hex);
+	const [h, s] = rgbToHsl(...rgb);
+	const bgLum = againstWhite ? 1.0 : 0.0;
+
+	let lo = againstWhite ? 0 : 0.5;
+	let hi = againstWhite ? 0.5 : 1.0;
+
+	for (let i = 0; i < 50; i++) {
+		const mid = (lo + hi) / 2;
+		const testRgb = hslToRgb(h, s, mid);
+		const contrast = getContrast(testRgb, bgLum);
+
+		if (againstWhite) {
+			if (contrast < targetContrast) hi = mid;
+			else lo = mid;
+		} else {
+			if (contrast < targetContrast) lo = mid;
+			else hi = mid;
+		}
+	}
+
+	const finalL = againstWhite ? lo : hi;
+	return rgbToHex(...hslToRgb(h, s, finalL));
+}
+
+function fgAnsi(hex: string): string {
+	const rgb = hexToRgb(hex);
+	return `\x1b[38;2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+}
+
+const reset = "\x1b[0m";
+
+// --- Commands ---
+
+function cmdContrast(targetContrast: number): void {
+	const baseColors = {
+		teal: "#5f8787",
+		blue: "#5f87af",
+		green: "#87af87",
+		yellow: "#d7af5f",
+		red: "#af5f5f",
+	};
+
+	console.log(`\n=== Colors adjusted to ${targetContrast}:1 contrast ===\n`);
+
+	console.log("For LIGHT theme (vs white):");
+	for (const [name, hex] of Object.entries(baseColors)) {
+		const adjusted = adjustColorToContrast(hex, targetContrast, true);
+		const rgb = hexToRgb(adjusted);
+		const contrast = getContrast(rgb, 1.0);
+		console.log(`  ${name.padEnd(8)} ${fgAnsi(adjusted)}Sample${reset}  ${adjusted}  (${contrast.toFixed(2)}:1)`);
+	}
+
+	console.log("\nFor DARK theme (vs black):");
+	for (const [name, hex] of Object.entries(baseColors)) {
+		const adjusted = adjustColorToContrast(hex, targetContrast, false);
+		const rgb = hexToRgb(adjusted);
+		const contrast = getContrast(rgb, 0.0);
+		console.log(`  ${name.padEnd(8)} ${fgAnsi(adjusted)}Sample${reset}  ${adjusted}  (${contrast.toFixed(2)}:1)`);
+	}
+}
+
+function cmdTest(filePath: string): void {
+	if (!fs.existsSync(filePath)) {
+		console.error(`File not found: ${filePath}`);
+		process.exit(1);
+	}
+
+	const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+	const vars = data.vars || data;
+
+	console.log(`\n=== Testing ${filePath} ===\n`);
+
+	for (const [name, hex] of Object.entries(vars as Record<string, string>)) {
+		if (!hex.startsWith("#")) continue;
+		const rgb = hexToRgb(hex);
+		const vsWhite = getContrast(rgb, 1.0);
+		const vsBlack = getContrast(rgb, 0.0);
+		const passW = vsWhite >= 4.5 ? "AA" : vsWhite >= 3.0 ? "AA-lg" : "FAIL";
+		const passB = vsBlack >= 4.5 ? "AA" : vsBlack >= 3.0 ? "AA-lg" : "FAIL";
+		console.log(
+			`${name.padEnd(14)} ${fgAnsi(hex)}Sample text${reset}  ${hex}  white: ${vsWhite.toFixed(2)}:1 ${passW.padEnd(5)}  black: ${vsBlack.toFixed(2)}:1 ${passB}`,
+		);
+	}
+}
+
+function cmdTheme(themeName: string): void {
+	process.env.COLORTERM = "truecolor";
+	initTheme(themeName);
+
+	const parseAnsiRgb = (ansi: string): [number, number, number] | null => {
+		const match = ansi.match(/38;2;(\d+);(\d+);(\d+)/);
+		return match ? [parseInt(match[1], 10), parseInt(match[2], 10), parseInt(match[3], 10)] : null;
+	};
+
+	const getContrastVsWhite = (colorName: string): string => {
+		const ansi = theme.getFgAnsi(colorName as Parameters<typeof theme.getFgAnsi>[0]);
+		const rgb = parseAnsiRgb(ansi);
+		if (!rgb) return "(default)";
+		const ratio = getContrast(rgb, 1.0);
+		const pass = ratio >= 4.5 ? "AA" : ratio >= 3.0 ? "AA-lg" : "FAIL";
+		return `${ratio.toFixed(2)}:1 ${pass}`;
+	};
+
+	const getContrastVsBlack = (colorName: string): string => {
+		const ansi = theme.getFgAnsi(colorName as Parameters<typeof theme.getFgAnsi>[0]);
+		const rgb = parseAnsiRgb(ansi);
+		if (!rgb) return "(default)";
+		const ratio = getContrast(rgb, 0.0);
+		const pass = ratio >= 4.5 ? "AA" : ratio >= 3.0 ? "AA-lg" : "FAIL";
+		return `${ratio.toFixed(2)}:1 ${pass}`;
+	};
+
+	const logColor = (name: string): void => {
+		const sample = theme.fg(name as Parameters<typeof theme.fg>[0], "Sample text");
+		const cw = getContrastVsWhite(name);
+		const cb = getContrastVsBlack(name);
+		console.log(`${name.padEnd(20)} ${sample}  white: ${cw.padEnd(12)} black: ${cb}`);
+	};
+
+	console.log(`\n=== ${themeName} theme (WCAG AA = 4.5:1) ===`);
+
+	console.log("\n--- Core UI ---");
+	["accent", "border", "borderAccent", "borderMuted", "success", "error", "warning", "muted", "dim"].forEach(logColor);
+
+	console.log("\n--- Markdown ---");
+	["mdHeading", "mdLink", "mdCode", "mdCodeBlock", "mdCodeBlockBorder", "mdQuote", "mdListBullet"].forEach(logColor);
+
+	console.log("\n--- Diff ---");
+	["toolDiffAdded", "toolDiffRemoved", "toolDiffContext"].forEach(logColor);
+
+	console.log("\n--- Thinking ---");
+	["thinkingOff", "thinkingMinimal", "thinkingLow", "thinkingMedium", "thinkingHigh"].forEach(logColor);
+
+	console.log("\n--- Backgrounds ---");
+	console.log("userMessageBg:", theme.bg("userMessageBg", " Sample "));
+	console.log("toolPendingBg:", theme.bg("toolPendingBg", " Sample "));
+	console.log("toolSuccessBg:", theme.bg("toolSuccessBg", " Sample "));
+	console.log("toolErrorBg:", theme.bg("toolErrorBg", " Sample "));
+	console.log();
+}
+
+// --- Main ---
+
+const [cmd, arg] = process.argv.slice(2);
+
+if (cmd === "contrast") {
+	cmdContrast(parseFloat(arg) || 4.5);
+} else if (cmd === "test") {
+	cmdTest(arg);
+} else if (cmd === "light" || cmd === "dark") {
+	cmdTheme(cmd);
+} else {
+	console.log("Usage:");
+	console.log("  npx tsx test-theme-colors.ts light|dark     Test built-in theme");
+	console.log("  npx tsx test-theme-colors.ts contrast 4.5   Compute colors at ratio");
+	console.log("  npx tsx test-theme-colors.ts test file.json Test any JSON file");
+}