claudeup 6.3.0 → 6.4.0

package/src/__tests__/models-adapter.test.ts

@@ -0,0 +1,317 @@
+import { describe, expect, test } from "bun:test";
+import {
+	BUILT_IN_PRESETS,
+	DEFAULT_PRESET,
+	findPreset,
+} from "../data/models-presets.js";
+import type { ModelsConfig, ModelsStatus } from "../services/models-core.js";
+import {
+	type ModelsBrowserItem,
+	buildModelsItems,
+	firstSelectableIndex,
+} from "../ui/adapters/modelsAdapter.js";
+
+/**
+ * The adapter is PURE — no fs, no React, no clock. Every test here builds its
+ * inputs by hand, which is the whole reason the list shape is testable at all:
+ * the screen it feeds cannot be rendered without a terminal.
+ */
+
+function status(over: Partial<ModelsStatus> = {}): ModelsStatus {
+	return {
+		state: "off",
+		preset: null,
+		drift: [],
+		warnings: [],
+		...over,
+	};
+}
+
+/** A hand-edited config: a preset name no built-in carries. */
+function customConfig(): ModelsConfig {
+	const base = findPreset(DEFAULT_PRESET);
+	if (!base) throw new Error("the default preset went missing");
+	return { ...base, preset: "custom" };
+}
+
+const presetRows = (items: ModelsBrowserItem[]) =>
+	items.filter((item) => item.kind === "preset");
+
+describe("buildModelsItems shape", () => {
+	test("a status header first, then one row per shipped preset", () => {
+		const items = buildModelsItems({
+			status: status(),
+			config: null,
+			query: "",
+		});
+
+		expect(items[0]?.kind).toBe("status");
+		expect(items).toHaveLength(BUILT_IN_PRESETS.length + 1);
+		expect(presetRows(items).map((item) => item.config.preset)).toEqual(
+			BUILT_IN_PRESETS.map((preset) => preset.preset),
+		);
+		// Exactly one header. A second would be a section, and this list has none.
+		expect(items.filter((item) => item.kind === "status")).toHaveLength(1);
+	});
+
+	/**
+	 * A row is NAMED for what you are choosing between, not for the id you type.
+	 * `fable-advisor` only says which model leads if you already know `advisor` is a
+	 * role in this vocabulary; "Opus with Fable help" says it outright.
+	 */
+	test("a row reads as a human name, not as the config's id", () => {
+		const items = buildModelsItems({
+			presets: BUILT_IN_PRESETS,
+			status: status({ state: "off" }),
+			config: null,
+			query: "",
+		});
+
+		const row = presetRows(items).find(
+			(item) => item.config.preset === "fable-advisor",
+		);
+		expect(row?.label).toBe("Opus with Fable help");
+		// The id survives beside it — it is what `models use` takes.
+		expect(row?.config.preset).toBe("fable-advisor");
+	});
+
+	test("search finds a preset by either name", () => {
+		for (const query of ["fable-advisor", "Opus with Fable"]) {
+			const items = buildModelsItems({
+				presets: BUILT_IN_PRESETS,
+				status: status({ state: "off" }),
+				config: null,
+				query,
+			});
+			expect(presetRows(items).map((item) => item.config.preset)).toContain(
+				"fable-advisor",
+			);
+		}
+	});
+
+	test("no status means no list — the screen has nothing to say yet", () => {
+		expect(buildModelsItems({ status: null, config: null, query: "" })).toEqual(
+			[],
+		);
+	});
+
+	test("the header carries the counts its badge draws, not the lines", () => {
+		const items = buildModelsItems({
+			status: status({
+				state: "stale",
+				preset: "fable-advisor",
+				drift: ["model: settings has x, config wants y", "effortLevel: …"],
+				warnings: ["CLAUDE_CODE_SUBAGENT_MODEL is set"],
+			}),
+			config: findPreset("fable-advisor") ?? null,
+			query: "",
+		});
+
+		const header = items[0];
+		if (header?.kind !== "status") throw new Error("expected a status header");
+		expect(header.state).toBe("stale");
+		expect(header.preset).toBe("fable-advisor");
+		expect(header.driftCount).toBe(2);
+		expect(header.warningCount).toBe(1);
+		// The lines themselves stay on the ModelsStatus the detail renderer gets.
+		// Copying them onto the item is how the two end up disagreeing.
+		expect(Object.keys(header)).not.toContain("drift");
+	});
+
+	test("ids are unique, so the list's React keys cannot collide", () => {
+		const items = buildModelsItems({
+			status: status(),
+			config: customConfig(),
+			query: "",
+		});
+		expect(new Set(items.map((item) => item.id)).size).toBe(items.length);
+	});
+});
+
+describe("marking the active preset", () => {
+	test("the config's preset name is the one marked", () => {
+		const items = buildModelsItems({
+			status: status({ state: "on", preset: "opus-lead" }),
+			config: findPreset("opus-lead") ?? null,
+			query: "",
+		});
+
+		const active = presetRows(items).filter((item) => item.active);
+		expect(active.map((item) => item.config.preset)).toEqual(["opus-lead"]);
+	});
+
+	test("no config means nothing is marked", () => {
+		const items = buildModelsItems({
+			status: status(),
+			config: null,
+			query: "",
+		});
+		expect(presetRows(items).some((item) => item.active)).toBe(false);
+	});
+
+	test("the shipped default is flagged, and it is exactly one preset", () => {
+		const items = buildModelsItems({
+			status: status(),
+			config: null,
+			query: "",
+		});
+		const defaults = presetRows(items).filter((item) => item.isDefault);
+		expect(defaults.map((item) => item.config.preset)).toEqual([
+			DEFAULT_PRESET,
+		]);
+	});
+
+	test("a hand-edited config gets a row of its own, marked active", () => {
+		// Without it the list shows four built-ins with none marked, which reads
+		// as "routing is off" for a project whose routing is emphatically on.
+		const config = customConfig();
+		const items = buildModelsItems({
+			status: status({ state: "on", preset: "custom" }),
+			config,
+			query: "",
+		});
+
+		const rows = presetRows(items);
+		expect(rows).toHaveLength(BUILT_IN_PRESETS.length + 1);
+		const mine = rows.at(-1);
+		expect(mine?.config.preset).toBe("custom");
+		expect(mine?.custom).toBe(true);
+		expect(mine?.active).toBe(true);
+		expect(mine?.isDefault).toBe(false);
+		// Its own config, so the detail pane shows what it actually routes.
+		expect(mine?.config).toBe(config);
+		// And it is the ONLY active row.
+		expect(rows.filter((item) => item.active)).toHaveLength(1);
+	});
+
+	test("a config naming a built-in adds no extra row", () => {
+		const items = buildModelsItems({
+			status: status({ state: "on", preset: "sonnet-economy" }),
+			config: findPreset("sonnet-economy") ?? null,
+			query: "",
+		});
+		expect(presetRows(items)).toHaveLength(BUILT_IN_PRESETS.length);
+		expect(presetRows(items).filter((item) => item.custom)).toEqual([]);
+	});
+});
+
+describe("filtering", () => {
+	test("matches on the preset name", () => {
+		const items = buildModelsItems({
+			status: status(),
+			config: null,
+			query: "economy",
+		});
+		expect(presetRows(items).map((item) => item.config.preset)).toEqual([
+			"sonnet-economy",
+		]);
+	});
+
+	test("matches on a model the preset names, not just its title", () => {
+		// "sonnet" is what someone hunting for it would type, and `fable-advisor` names it in
+		// neither its id nor its label — only in the tier it routes there.
+		const items = buildModelsItems({
+			status: status(),
+			config: null,
+			query: "sonnet",
+		});
+		const labels = presetRows(items).map((item) => item.config.preset);
+		expect(labels.length).toBeGreaterThan(0);
+		expect(labels).toContain("fable-advisor");
+	});
+
+	test("a model no preset uses finds nothing", () => {
+		// The negative control for the test above: without it, a matcher that returned
+		// every row would pass it.
+		const items = buildModelsItems({
+			status: status(),
+			config: null,
+			query: "haiku",
+		});
+		expect(presetRows(items)).toEqual([]);
+	});
+
+	test("is case- and whitespace-insensitive", () => {
+		const items = buildModelsItems({
+			status: status(),
+			config: null,
+			query: "  OPUS-Lead ",
+		});
+		expect(presetRows(items).map((item) => item.config.preset)).toEqual([
+			"opus-lead",
+		]);
+	});
+
+	test("a query that matches nothing drops the header too", () => {
+		// A lone header reads as a result. Returning nothing is what lets the
+		// screen show the empty state, which is the only thing that says how to
+		// clear the filter.
+		expect(
+			buildModelsItems({
+				status: status(),
+				config: null,
+				query: "zzzz",
+			}),
+		).toEqual([]);
+	});
+
+	test("a filtered-out custom config takes no row", () => {
+		const items = buildModelsItems({
+			status: status({ state: "on", preset: "custom" }),
+			config: customConfig(),
+			query: "economy",
+		});
+		expect(presetRows(items).map((item) => item.config.preset)).toEqual([
+			"sonnet-economy",
+		]);
+	});
+});
+
+describe("firstSelectableIndex", () => {
+	test("skips the status header", () => {
+		const items = buildModelsItems({
+			status: status(),
+			config: null,
+			query: "",
+		});
+		expect(items[0]?.kind).toBe("status");
+		expect(firstSelectableIndex(items)).toBe(1);
+	});
+
+	test("an empty list answers 0 rather than -1", () => {
+		// -1 would index past the array and render an undefined row.
+		expect(firstSelectableIndex([])).toBe(0);
+	});
+
+	test("the index it returns is always a preset when one exists", () => {
+		for (const query of ["", "economy", "opus", "fable"]) {
+			const items = buildModelsItems({ status: status(), config: null, query });
+			if (items.length === 0) continue;
+			expect(items[firstSelectableIndex(items)]?.kind).toBe("preset");
+		}
+	});
+});
+
+describe("purity", () => {
+	test("the adapter reaches no filesystem and no clock", async () => {
+		// It runs on every render and every keystroke of the filter. Anything it
+		// touched would be touched at that rate.
+		const src = await Bun.file(
+			new URL("../ui/adapters/modelsAdapter.ts", import.meta.url),
+		).text();
+		expect(src).not.toMatch(/from "node:fs/);
+		expect(src).not.toMatch(/\bfetch\s*\(/);
+		expect(src).not.toMatch(/Date\.now\(/);
+	});
+
+	test("building the list twice gives the same answer", () => {
+		const args = {
+			status: status({ state: "on", preset: "fable-advisor" }),
+			config: findPreset("fable-advisor") ?? null,
+			query: "",
+		};
+		expect(JSON.stringify(buildModelsItems(args))).toBe(
+			JSON.stringify(buildModelsItems(args)),
+		);
+	});
+});

package/src/__tests__/models-cli.test.ts

@@ -0,0 +1,173 @@
+/**
+ * `claudeup models` — exit codes and what it tells the user.
+ *
+ * The interesting one is the unknown preset: it must LIST the valid names and
+ * never near-match. `fable-lead` and `fable-advisor` differ by which model
+ * leads, so "did you mean" that silently picked the closer string would route
+ * every subagent differently from what was asked, and look like it worked.
+ */
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import fs from "fs-extra";
+import { runModelsCommand } from "../cli/models.js";
+import { presetNames } from "../data/models-presets.js";
+import { writeManifest } from "../services/manifest.js";
+
+let logs: string[];
+let errs: string[];
+let project: string;
+let configDir: string;
+let previousConfigDir: string | undefined;
+
+beforeEach(async () => {
+	logs = [];
+	errs = [];
+	console.log = mock((...a: unknown[]) => logs.push(a.join(" "))) as any;
+	console.error = mock((...a: unknown[]) => errs.push(a.join(" "))) as any;
+	project = await mkdtemp(join(tmpdir(), "modelscli-"));
+	configDir = await mkdtemp(join(tmpdir(), "modelscli-config-"));
+	previousConfigDir = process.env.CLAUDE_CONFIG_DIR;
+	process.env.CLAUDE_CONFIG_DIR = configDir;
+});
+
+afterEach(async () => {
+	mock.restore();
+	// biome-ignore lint/performance/noDelete: absence is the intent, not a shortcut
+	if (previousConfigDir === undefined) delete process.env.CLAUDE_CONFIG_DIR;
+	else process.env.CLAUDE_CONFIG_DIR = previousConfigDir;
+	await rm(project, { recursive: true, force: true });
+	await rm(configDir, { recursive: true, force: true });
+});
+
+/**
+ * Give the project a profile before applying a preset.
+ *
+ * Without one, `models use` reaches `ensureManifest`'s adoption branch, which asks
+ * "Create .claude/profiles.json?" — and that branch reads `process.stdin.isTTY`.
+ * A test that goes through it therefore passes headless (no TTY, so it refuses and
+ * returns) and HANGS in a real terminal, where stdin is a tty and the prompt waits
+ * for a human who is not there. Two tests did exactly that: green in CI, a 5 s
+ * timeout when the suite was run from a terminal.
+ *
+ * Adoption is `bootstrap`'s behaviour and is tested there. Every test here that
+ * applies a preset seeds the manifest first, so the outcome depends on the code
+ * under test rather than on how the runner was launched.
+ */
+async function seedProfile(name = "team"): Promise<void> {
+	await writeManifest({ version: 2, profiles: { [name]: { name } } }, project);
+	const dir = join(project, ".claude", "_profiles", name);
+	await fs.outputJson(join(dir, "settings.json"), {});
+	await fs.symlink(
+		join("_profiles", name, "settings.json"),
+		join(project, ".claude", "settings.json"),
+	);
+}
+
+describe("models use", () => {
+	test("an unknown preset exits 1 and lists every valid name", async () => {
+		const code = await runModelsCommand(["use", "fable-leed"], project);
+
+		expect(code).toBe(1);
+		const out = errs.join("\n");
+		expect(out).toContain('Unknown preset "fable-leed"');
+		for (const name of presetNames()) expect(out).toContain(name);
+		// Never near-matched into an apply.
+		expect(await fs.pathExists(join(project, ".claude", "models.json"))).toBe(
+			false,
+		);
+	});
+
+	test("`use` with no preset exits 1 and lists the names", async () => {
+		const code = await runModelsCommand(["use"], project);
+		expect(code).toBe(1);
+		expect(errs.join("\n")).toContain(presetNames()[0] as string);
+	});
+
+	test("applies a valid preset and points at the file to commit", async () => {
+		await seedProfile();
+
+		const code = await runModelsCommand(["use", "sonnet-economy"], project);
+
+		expect(code).toBe(0);
+		const out = logs.join("\n");
+		expect(out).toContain('Applied preset "sonnet-economy"');
+		expect(out).toContain('model = "sonnet"');
+		expect(out).toContain("Commit .claude/profiles.json");
+	});
+});
+
+describe("models list", () => {
+	test("shows every preset with its main and grades", async () => {
+		const code = await runModelsCommand(["list"], project);
+		expect(code).toBe(0);
+		const out = logs.join("\n");
+		for (const name of presetNames()) expect(out).toContain(name);
+		expect(out).toContain("smart");
+		expect(out).toContain("(default)");
+	});
+
+	test("marks the active preset", async () => {
+		await seedProfile();
+		await runModelsCommand(["use", "opus-lead"], project);
+		logs = [];
+		await runModelsCommand(["list"], project);
+		expect(logs.join("\n")).toContain("● Opus main  —  opus-lead");
+	});
+});
+
+describe("models status", () => {
+	test("reports off for a project with no routing, and exits 0", async () => {
+		const code = await runModelsCommand(["status"], project);
+		expect(code).toBe(0);
+		expect(logs.join("\n")).toContain("off");
+	});
+
+	test("a bare `models` is status", async () => {
+		const code = await runModelsCommand([], project);
+		expect(code).toBe(0);
+		expect(logs.join("\n")).toContain("Model tiers:");
+	});
+
+	// An invalid config routes nothing, so it is a failure, not a report.
+	test("exits 1 on an invalid config and prints each error", async () => {
+		await fs.outputJson(join(project, ".claude", "models.json"), {
+			version: 1,
+			preset: "hand-edited",
+			main: { model: "gpt-5" },
+		});
+
+		const code = await runModelsCommand(["status"], project);
+
+		expect(code).toBe(1);
+		const out = logs.join("\n");
+		expect(out).toContain("invalid");
+		expect(out).toContain("main.model");
+	});
+});
+
+describe("models off", () => {
+	test("removes the config and says routing stopped", async () => {
+		await seedProfile();
+		await runModelsCommand(["use", "sonnet-economy"], project);
+		logs = [];
+
+		const code = await runModelsCommand(["off"], project);
+
+		expect(code).toBe(0);
+		expect(await fs.pathExists(join(project, ".claude", "models.json"))).toBe(
+			false,
+		);
+		expect(logs.join("\n")).toContain("Model tiers off");
+	});
+});
+
+describe("unknown subcommand", () => {
+	test("exits 1 and prints usage", async () => {
+		const code = await runModelsCommand(["frobnicate"], project);
+		expect(code).toBe(1);
+		expect(errs.join("\n")).toContain('Unknown models command "frobnicate"');
+		expect(logs.join("\n")).toContain("Usage: claudeup models");
+	});
+});