claudeup 6.2.1 → 6.3.2

package/src/__tests__/theme-resolve.test.ts

@@ -0,0 +1,380 @@
+import { describe, expect, test } from "bun:test";
+import type { ThemeMode } from "@opentui/core";
+import {
+	type ResolveThemeInput,
+	parseColorFgBg,
+	parseThemeWord,
+	resolveTheme,
+} from "../ui/theme-resolve.js";
+
+/**
+ * The resolver is a six-step, first-answer-wins list. These tests pin every
+ * step, every adjacent precedence pair, and the "no opinion" rule: a word that
+ * is not exactly `light` or `dark` says nothing and the next step runs.
+ *
+ * The probe is a hand-rolled recorder rather than `spyOn` — `spyOn` calls
+ * through to the original by default, and the property under test is whether
+ * the probe was reached at all.
+ */
+
+function probeReturning(value: ThemeMode | null) {
+	let calls = 0;
+	const probe = async () => {
+		calls += 1;
+		return value;
+	};
+	return { probe, calls: () => calls };
+}
+
+function input(overrides: Partial<ResolveThemeInput> = {}): ResolveThemeInput {
+	return {
+		env: {},
+		isInteractive: true,
+		probe: async () => null,
+		...overrides,
+	};
+}
+
+describe("each step answers on its own", () => {
+	test("T-step-1: the flag wins and the probe is never called", async () => {
+		const p = probeReturning("dark");
+
+		const r = await resolveTheme(input({ flag: "light", probe: p.probe }));
+
+		expect(r).toEqual({ mode: "light", source: "flag" });
+		expect(p.calls()).toBe(0);
+	});
+
+	test("T-step-2: CLAUDEUP_THEME answers without the probe", async () => {
+		const p = probeReturning("light");
+
+		const r = await resolveTheme(
+			input({ env: { CLAUDEUP_THEME: "dark" }, probe: p.probe }),
+		);
+
+		expect(r).toEqual({ mode: "dark", source: "variable" });
+		expect(p.calls()).toBe(0);
+	});
+
+	test("T-step-3: TERM_THEME answers and the probe is skipped entirely", async () => {
+		const p = probeReturning("dark");
+
+		const r = await resolveTheme(
+			input({ env: { TERM_THEME: "light" }, probe: p.probe }),
+		);
+
+		expect(r).toEqual({ mode: "light", source: "TERM_THEME" });
+		expect(p.calls()).toBe(0);
+	});
+
+	test("T-step-4: an interactive tty probes exactly once", async () => {
+		const p = probeReturning("light");
+
+		const r = await resolveTheme(input({ probe: p.probe }));
+
+		expect(r).toEqual({ mode: "light", source: "osc11" });
+		expect(p.calls()).toBe(1);
+	});
+
+	test("T-step-5: an unanswered probe falls to COLORFGBG", async () => {
+		const r = await resolveTheme(
+			input({ env: { COLORFGBG: "15;7" }, probe: async () => null }),
+		);
+
+		expect(r).toEqual({ mode: "light", source: "COLORFGBG" });
+	});
+
+	test("T-step-6: nothing answers → dark by decision, no throw", async () => {
+		const r = await resolveTheme(input());
+
+		expect(r).toEqual({ mode: "dark", source: "default" });
+	});
+});
+
+describe("precedence between adjacent steps", () => {
+	test("T-prec-flag>var: the flag beats CLAUDEUP_THEME", async () => {
+		const r = await resolveTheme(
+			input({ flag: "light", env: { CLAUDEUP_THEME: "dark" } }),
+		);
+
+		expect(r.mode).toBe("light");
+		expect(r.source).toBe("flag");
+	});
+
+	test("T-prec-var>TERM: CLAUDEUP_THEME beats TERM_THEME", async () => {
+		const r = await resolveTheme(
+			input({ env: { CLAUDEUP_THEME: "light", TERM_THEME: "dark" } }),
+		);
+
+		expect(r.mode).toBe("light");
+		expect(r.source).toBe("variable");
+	});
+
+	test("T-prec-TERM>probe: TERM_THEME beats a probe that would disagree", async () => {
+		const p = probeReturning("light");
+
+		const r = await resolveTheme(
+			input({ env: { TERM_THEME: "dark" }, probe: p.probe }),
+		);
+
+		expect(r.mode).toBe("dark");
+		expect(p.calls()).toBe(0);
+	});
+
+	test("T-prec-probe>CFB: the probe beats COLORFGBG", async () => {
+		const r = await resolveTheme(
+			input({ env: { COLORFGBG: "15;0" }, probe: async () => "light" }),
+		);
+
+		expect(r).toEqual({ mode: "light", source: "osc11" });
+	});
+
+	test("T-prec-CFB>default: a dark COLORFGBG is attributed to COLORFGBG, not default", async () => {
+		const r = await resolveTheme(input({ env: { COLORFGBG: "0;0" } }));
+
+		expect(r).toEqual({ mode: "dark", source: "COLORFGBG" });
+	});
+});
+
+describe("precedence across non-adjacent steps", () => {
+	test("T-prec-flag>all: the flag beats every later step, and none of them is consulted", async () => {
+		const p = probeReturning("light");
+
+		const r = await resolveTheme(
+			input({
+				flag: "dark",
+				env: {
+					CLAUDEUP_THEME: "light",
+					TERM_THEME: "light",
+					COLORFGBG: "0;15",
+				},
+				probe: p.probe,
+			}),
+		);
+
+		expect(r).toEqual({ mode: "dark", source: "flag" });
+		expect(p.calls()).toBe(0);
+	});
+
+	test("T-prec-var>probe: CLAUDEUP_THEME beats a probe that would disagree, and skips it", async () => {
+		const p = probeReturning("light");
+
+		const r = await resolveTheme(
+			input({
+				env: { CLAUDEUP_THEME: "dark", COLORFGBG: "0;15" },
+				probe: p.probe,
+			}),
+		);
+
+		expect(r).toEqual({ mode: "dark", source: "variable" });
+		expect(p.calls()).toBe(0);
+	});
+
+	test("T-prec-TERM>CFB: TERM_THEME beats COLORFGBG when there is no tty to probe", async () => {
+		const r = await resolveTheme(
+			input({
+				env: { TERM_THEME: "light", COLORFGBG: "15;0" },
+				isInteractive: false,
+			}),
+		);
+
+		expect(r).toEqual({ mode: "light", source: "TERM_THEME" });
+	});
+
+	test("T-step-4b: a probe that answers dark is attributed to osc11, not default", async () => {
+		const r = await resolveTheme(
+			input({ env: { COLORFGBG: "0;15" }, probe: async () => "dark" }),
+		);
+
+		expect(r).toEqual({ mode: "dark", source: "osc11" });
+	});
+});
+
+describe("no opinion falls through", () => {
+	test("T-noop-auto: TERM_THEME=auto reaches the probe", async () => {
+		const p = probeReturning("light");
+
+		const r = await resolveTheme(
+			input({ env: { TERM_THEME: "auto" }, probe: p.probe }),
+		);
+
+		expect(r).toEqual({ mode: "light", source: "osc11" });
+		expect(p.calls()).toBe(1);
+	});
+
+	test("T-noop-case: Light and DARK are not the exact words and are ignored", async () => {
+		const r = await resolveTheme(
+			input({
+				env: { TERM_THEME: "Light", CLAUDEUP_THEME: "DARK" },
+				isInteractive: false,
+			}),
+		);
+
+		expect(r).toEqual({ mode: "dark", source: "default" });
+	});
+
+	test("T-noop-empty: an empty TERM_THEME falls through", async () => {
+		const r = await resolveTheme(
+			input({ env: { TERM_THEME: "", COLORFGBG: "0;15" } }),
+		);
+
+		expect(r).toEqual({ mode: "light", source: "COLORFGBG" });
+	});
+
+	test("T-noop-auto-notty: TERM_THEME=auto never means dark — without a tty it reaches COLORFGBG", async () => {
+		const p = probeReturning("dark");
+
+		const r = await resolveTheme(
+			input({
+				env: { TERM_THEME: "auto", COLORFGBG: "0;15" },
+				isInteractive: false,
+				probe: p.probe,
+			}),
+		);
+
+		expect(r).toEqual({ mode: "light", source: "COLORFGBG" });
+		expect(p.calls()).toBe(0);
+	});
+
+	test("T-noop-auto-default: TERM_THEME=auto with nothing else is the DEFAULT dark, not a TERM_THEME answer", async () => {
+		const r = await resolveTheme(input({ env: { TERM_THEME: "auto" } }));
+
+		expect(r).toEqual({ mode: "dark", source: "default" });
+	});
+
+	test.each(["auto", "purple", "", "Dark"])(
+		"T-noop-var: CLAUDEUP_THEME=%p is no opinion and TERM_THEME answers instead",
+		async (word) => {
+			const p = probeReturning("dark");
+
+			const r = await resolveTheme(
+				input({
+					env: { CLAUDEUP_THEME: word, TERM_THEME: "light" },
+					probe: p.probe,
+				}),
+			);
+
+			expect(r).toEqual({ mode: "light", source: "TERM_THEME" });
+			expect(p.calls()).toBe(0);
+		},
+	);
+});
+
+describe("R8: resolving is silent", () => {
+	// The dark fallback is a decision, not a failure: no step, including step 6
+	// and a probe that fails, may print a "could not detect" line.
+	test("T-quiet: neither the default path nor a failing probe writes to the console", async () => {
+		const written: string[] = [];
+		const record = (...a: unknown[]) => {
+			written.push(a.join(" "));
+		};
+		const original = {
+			log: console.log,
+			warn: console.warn,
+			error: console.error,
+		};
+		console.log = record;
+		console.warn = record;
+		console.error = record;
+		try {
+			await resolveTheme(input());
+			await resolveTheme(
+				input({
+					probe: async () => {
+						throw new Error("no reply");
+					},
+				}),
+			);
+			await resolveTheme(
+				input({ env: { TERM_THEME: "auto" }, isInteractive: false }),
+			);
+		} finally {
+			console.log = original.log;
+			console.warn = original.warn;
+			console.error = original.error;
+		}
+
+		expect(written).toEqual([]);
+	});
+});
+
+describe("the probe is guarded", () => {
+	test("T-tty: a non-interactive process never probes", async () => {
+		const p = probeReturning("light");
+
+		const fromEnv = await resolveTheme(
+			input({
+				isInteractive: false,
+				env: { COLORFGBG: "0;15" },
+				probe: p.probe,
+			}),
+		);
+		const fromDefault = await resolveTheme(
+			input({ isInteractive: false, probe: p.probe }),
+		);
+
+		expect(fromEnv).toEqual({ mode: "light", source: "COLORFGBG" });
+		expect(fromDefault).toEqual({ mode: "dark", source: "default" });
+		expect(p.calls()).toBe(0);
+	});
+
+	test("T-probe-throws: a rejecting probe is treated as null", async () => {
+		const r = await resolveTheme(
+			input({
+				env: { COLORFGBG: "0;7" },
+				probe: async () => {
+					throw new Error("terminal hung up");
+				},
+			}),
+		);
+
+		expect(r).toEqual({ mode: "light", source: "COLORFGBG" });
+	});
+});
+
+describe("T-cfb-parse: parseColorFgBg reads the LAST field as the background", () => {
+	test.each<[string | undefined, ThemeMode | null]>([
+		["15;0", "dark"],
+		["0;15", "light"],
+		["0;7", "light"],
+		["12;3;7", "light"],
+		["0;default;15", "light"],
+		["default;default", null],
+		["7", null],
+		["15", null],
+		["x;16", null],
+		["0;255", null],
+		// Zero-padded fields are outside the statusline's literal `case` set, so
+		// they are no opinion here too — Number("07") would have said light.
+		["0;07", null],
+		["0;015", null],
+		["0;00", null],
+		["0;", null],
+		["", null],
+		[undefined, null],
+	])("%p → %p", (value, expected) => {
+		expect(parseColorFgBg(value)).toBe(expected);
+	});
+
+	test("every background 0-14 except 7 is dark", () => {
+		for (let bg = 0; bg <= 14; bg += 1) {
+			expect(parseColorFgBg(`0;${bg}`)).toBe(bg === 7 ? "light" : "dark");
+		}
+	});
+});
+
+describe("T-word-parse: parseThemeWord is exact, lowercase, untrimmed", () => {
+	test.each<[string | undefined, ThemeMode | null]>([
+		["light", "light"],
+		["dark", "dark"],
+		["auto", null],
+		["Light", null],
+		["DARK", null],
+		[" dark", null],
+		["dark ", null],
+		["", null],
+		[undefined, null],
+	])("%p → %p", (value, expected) => {
+		expect(parseThemeWord(value)).toBe(expected);
+	});
+});

package/src/__tests__/update-apply.test.ts

@@ -7,13 +7,13 @@
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
+import type { PluginScope } from "../services/claude-cli.js";
 import {
 	type PluginApplyDeps,
 	applyPlugins,
 	installPluginInScope,
 	updatePluginInScope,
 } from "../services/update-engine.js";
-import type { PluginScope } from "../services/claude-cli.js";
 import type { PluginUpdateItem } from "../services/update-plan.js";
 
 const PROJECT = "/tmp/project";
@@ -67,9 +67,7 @@ function item(over: Partial<PluginUpdateItem>): PluginUpdateItem {
 let logs: string[];
 beforeEach(() => {
 	logs = [];
-	// biome-ignore lint/suspicious/noExplicitAny: test double
 	console.log = ((...a: unknown[]) => logs.push(a.join(" "))) as any;
-	// biome-ignore lint/suspicious/noExplicitAny: test double
 	console.warn = ((...a: unknown[]) => logs.push(a.join(" "))) as any;
 });
 

package/src/__tests__/useGitignoreModal.test.ts

@@ -1,71 +1,79 @@
-import { describe, it, expect } from "bun:test";
+import { describe, expect, it } from "bun:test";
 import { buildGitignoreModal } from "../ui/hooks/useGitignoreModal";
 
 describe("buildGitignoreModal", () => {
-  it("builds a select modal with three options", () => {
-    let dismissed = false;
-    let fixed = false;
-    let opened = false;
-    const modal = buildGitignoreModal({
-      violationCount: 5,
-      safeCount: 3,
-      onFixSafe: () => { fixed = true; },
-      onOpenTab: () => { opened = true; },
-      onDismiss: () => { dismissed = true; },
-    });
-    expect(modal.type).toBe("select");
-    if (modal.type !== "select") throw new Error("type guard");
-    expect(modal.options.length).toBe(3);
-    expect(modal.options[0].value).toBe("fix-safe");
-    expect(modal.options[1].value).toBe("open-tab");
-    expect(modal.options[2].value).toBe("dismiss");
-    expect(modal.options[0].label).toContain("3");
+	it("builds a select modal with three options", () => {
+		let dismissed = false;
+		let fixed = false;
+		let opened = false;
+		const modal = buildGitignoreModal({
+			violationCount: 5,
+			safeCount: 3,
+			onFixSafe: () => {
+				fixed = true;
+			},
+			onOpenTab: () => {
+				opened = true;
+			},
+			onDismiss: () => {
+				dismissed = true;
+			},
+		});
+		expect(modal.type).toBe("select");
+		if (modal.type !== "select") throw new Error("type guard");
+		expect(modal.options.length).toBe(3);
+		expect(modal.options[0].value).toBe("fix-safe");
+		expect(modal.options[1].value).toBe("open-tab");
+		expect(modal.options[2].value).toBe("dismiss");
+		expect(modal.options[0].label).toContain("3");
 
-    modal.onSelect("fix-safe");
-    expect(fixed).toBe(true);
+		modal.onSelect("fix-safe");
+		expect(fixed).toBe(true);
 
-    modal.onSelect("open-tab");
-    expect(opened).toBe(true);
+		modal.onSelect("open-tab");
+		expect(opened).toBe(true);
 
-    modal.onSelect("dismiss");
-    expect(dismissed).toBe(true);
-  });
+		modal.onSelect("dismiss");
+		expect(dismissed).toBe(true);
+	});
 
-  it("shows no missing entries label when safeCount is 0", () => {
-    const modal = buildGitignoreModal({
-      violationCount: 2,
-      safeCount: 0,
-      onFixSafe: () => {},
-      onOpenTab: () => {},
-      onDismiss: () => {},
-    });
-    if (modal.type !== "select") throw new Error("type guard");
-    expect(modal.options[0].label).toContain("no missing .gitignore");
-  });
+	it("shows no missing entries label when safeCount is 0", () => {
+		const modal = buildGitignoreModal({
+			violationCount: 2,
+			safeCount: 0,
+			onFixSafe: () => {},
+			onOpenTab: () => {},
+			onDismiss: () => {},
+		});
+		if (modal.type !== "select") throw new Error("type guard");
+		expect(modal.options[0].label).toContain("no missing .gitignore");
+	});
 
-  it("includes violation count in the message", () => {
-    const modal = buildGitignoreModal({
-      violationCount: 7,
-      safeCount: 2,
-      onFixSafe: () => {},
-      onOpenTab: () => {},
-      onDismiss: () => {},
-    });
-    if (modal.type !== "select") throw new Error("type guard");
-    expect(modal.message).toContain("7");
-  });
+	it("includes violation count in the message", () => {
+		const modal = buildGitignoreModal({
+			violationCount: 7,
+			safeCount: 2,
+			onFixSafe: () => {},
+			onOpenTab: () => {},
+			onDismiss: () => {},
+		});
+		if (modal.type !== "select") throw new Error("type guard");
+		expect(modal.message).toContain("7");
+	});
 
-  it("calls onCancel as dismiss", () => {
-    let dismissed = false;
-    const modal = buildGitignoreModal({
-      violationCount: 1,
-      safeCount: 0,
-      onFixSafe: () => {},
-      onOpenTab: () => {},
-      onDismiss: () => { dismissed = true; },
-    });
-    if (modal.type !== "select") throw new Error("type guard");
-    modal.onCancel();
-    expect(dismissed).toBe(true);
-  });
+	it("calls onCancel as dismiss", () => {
+		let dismissed = false;
+		const modal = buildGitignoreModal({
+			violationCount: 1,
+			safeCount: 0,
+			onFixSafe: () => {},
+			onOpenTab: () => {},
+			onDismiss: () => {
+				dismissed = true;
+			},
+		});
+		if (modal.type !== "select") throw new Error("type guard");
+		modal.onCancel();
+		expect(dismissed).toBe(true);
+	});
 });