claudeup 6.3.2 → 6.4.0

package/src/__tests__/models-screen-state.test.ts

@@ -0,0 +1,259 @@
+import { describe, expect, test } from "bun:test";
+import { join } from "node:path";
+import fs from "fs-extra";
+import { DEFAULT_PRESET, findPreset } from "../data/models-presets.js";
+import type { ModelsStatus } from "../services/models-core.js";
+import { appReducer, initialState } from "../ui/state/reducer.js";
+import type { AppAction, AppState, ModelsSnapshot } from "../ui/state/types.js";
+import { asyncValue } from "../ui/state/types.js";
+
+function run(actions: AppAction[], from: AppState = initialState): AppState {
+	return actions.reduce(appReducer, from);
+}
+
+function status(over: Partial<ModelsStatus> = {}): ModelsStatus {
+	return { state: "off", preset: null, drift: [], warnings: [], ...over };
+}
+
+function snapshot(over: Partial<ModelsSnapshot> = {}): ModelsSnapshot {
+	return {
+		status: status(),
+		config: null,
+		path: "/x/.claude/models.json",
+		...over,
+	};
+}
+
+/** Navigating away and back is what unmounts the screen. */
+const roundTrip: AppAction[] = [
+	{ type: "NAVIGATE", route: { screen: "plugins" } },
+	{ type: "NAVIGATE", route: { screen: "models" } },
+];
+
+describe("models screen initial state", () => {
+	test("starts idle, unfiltered, and with no message", () => {
+		expect(initialState.models.data.status).toBe("idle");
+		expect(initialState.models.searchQuery).toBe("");
+		expect(initialState.models.status).toBeNull();
+		expect(initialState.models.isApplying).toBe(false);
+	});
+
+	test("the models route is reachable and NAVIGATE keeps the screen's state", () => {
+		const state = run([
+			{ type: "MODELS_DATA_SUCCESS", snapshot: snapshot() },
+			...roundTrip,
+		]);
+		expect(state.currentRoute.screen).toBe("models");
+		expect(state.models.data.status).toBe("success");
+	});
+});
+
+describe("models search state", () => {
+	test("appending builds up the query one character at a time", () => {
+		// The regression this guards: computing `searchQuery + char` in the screen
+		// reads a value captured at render time, so keystrokes arriving faster
+		// than React re-renders all start from the same stale string.
+		const state = run([
+			{ type: "MODELS_SEARCH_APPEND", char: "o" },
+			{ type: "MODELS_SEARCH_APPEND", char: "p" },
+			{ type: "MODELS_SEARCH_APPEND", char: "u" },
+			{ type: "MODELS_SEARCH_APPEND", char: "s" },
+		]);
+		expect(state.models.searchQuery).toBe("opus");
+	});
+
+	test("appending resets the cursor so it cannot sit past the filtered list", () => {
+		const state = run([
+			{ type: "MODELS_SELECT", index: 4 },
+			{ type: "MODELS_SEARCH_APPEND", char: "h" },
+		]);
+		expect(state.models.selectedIndex).toBe(0);
+	});
+
+	test("backspace removes one character at a time", () => {
+		const typed = run([
+			{ type: "MODELS_SEARCH_APPEND", char: "a" },
+			{ type: "MODELS_SEARCH_APPEND", char: "b" },
+			{ type: "MODELS_SEARCH_APPEND", char: "c" },
+		]);
+		expect(
+			run([{ type: "MODELS_SEARCH_BACKSPACE" }], typed).models.searchQuery,
+		).toBe("ab");
+	});
+
+	test("backspace on an empty query is harmless", () => {
+		expect(run([{ type: "MODELS_SEARCH_BACKSPACE" }]).models.searchQuery).toBe(
+			"",
+		);
+	});
+
+	test("clearing the filter is one action, and it leaves the data alone", () => {
+		const filtered = run([
+			{ type: "MODELS_DATA_SUCCESS", snapshot: snapshot() },
+			{ type: "MODELS_SEARCH_APPEND", char: "z" },
+		]);
+		const cleared = run([{ type: "MODELS_SET_SEARCH", query: "" }], filtered);
+		expect(cleared.models.searchQuery).toBe("");
+		expect(cleared.models.data.status).toBe("success");
+	});
+});
+
+describe("models data state", () => {
+	test("a reload keeps the last snapshot on screen", () => {
+		// Reading the routing scans session transcripts to resolve the live model
+		// id behind each alias, so a reload is not instant. Without `previous` the
+		// list blanks to "Reading…" every time — including on every tab switch,
+		// because the router unmounts the screen and the effect refetches.
+		const loaded = run([
+			{ type: "MODELS_DATA_SUCCESS", snapshot: snapshot({ path: "/a" }) },
+			{ type: "MODELS_DATA_LOADING" },
+		]);
+		expect(loaded.models.data.status).toBe("loading");
+		expect(asyncValue(loaded.models.data)?.path).toBe("/a");
+	});
+
+	test("a FIRST load has nothing to carry, and says so", () => {
+		const loading = run([{ type: "MODELS_DATA_LOADING" }]);
+		expect(asyncValue(loading.models.data)).toBeUndefined();
+	});
+
+	test("success stores the whole snapshot, config included", () => {
+		const config = findPreset(DEFAULT_PRESET) ?? null;
+		const state = run([
+			{
+				type: "MODELS_DATA_SUCCESS",
+				snapshot: snapshot({
+					status: status({ state: "on", preset: DEFAULT_PRESET }),
+					config,
+				}),
+			},
+		]);
+		const value = asyncValue(state.models.data);
+		expect(value?.status.state).toBe("on");
+		expect(value?.config?.preset).toBe(DEFAULT_PRESET);
+	});
+
+	test("an error replaces the data rather than hiding behind stale rows", () => {
+		const state = run([
+			{ type: "MODELS_DATA_SUCCESS", snapshot: snapshot() },
+			{ type: "MODELS_DATA_ERROR", error: new Error("unreadable") },
+		]);
+		expect(state.models.data.status).toBe("error");
+		expect(asyncValue(state.models.data)).toBeUndefined();
+	});
+});
+
+describe("models status line", () => {
+	test("survives the screen unmounting, because it lives in app state", () => {
+		// `Router` swaps the component type on a tab change, so a message held in
+		// the screen's own useState is destroyed by 0 → 1 → 0 — and the message is
+		// the only record of what the last apply did.
+		const messaged = run([
+			{
+				type: "MODELS_STATUS_SET",
+				status: { text: "Routed opus-lead", tone: "success" },
+			},
+		]);
+		expect(run(roundTrip, messaged).models.status?.text).toBe(
+			"Routed opus-lead",
+		);
+	});
+
+	test("is replaced by the next message, not appended to", () => {
+		const state = run([
+			{ type: "MODELS_STATUS_SET", status: { text: "one", tone: "success" } },
+			{ type: "MODELS_STATUS_SET", status: { text: "two", tone: "error" } },
+		]);
+		expect(state.models.status).toEqual({ text: "two", tone: "error" });
+	});
+
+	test("clearing removes it", () => {
+		const state = run([
+			{ type: "MODELS_STATUS_SET", status: { text: "one", tone: "success" } },
+			{ type: "MODELS_STATUS_CLEAR" },
+		]);
+		expect(state.models.status).toBeNull();
+	});
+});
+
+describe("apply-in-flight state", () => {
+	test("survives the screen unmounting", () => {
+		// An apply rewrites the profile, re-materializes it and registers a hook.
+		// Held locally, the flag died on a tab switch and a returning user could
+		// launch a second write on top of the first.
+		const applying = run([{ type: "MODELS_APPLY_START" }]);
+		expect(applying.models.isApplying).toBe(true);
+		expect(run(roundTrip, applying).models.isApplying).toBe(true);
+	});
+
+	test("clears when the write finishes", () => {
+		expect(
+			run([{ type: "MODELS_APPLY_START" }, { type: "MODELS_APPLY_END" }]).models
+				.isApplying,
+		).toBe(false);
+	});
+});
+
+describe("selection state", () => {
+	test("select records the index verbatim", () => {
+		expect(
+			run([{ type: "MODELS_SELECT", index: 3 }]).models.selectedIndex,
+		).toBe(3);
+	});
+
+	test("models actions touch no other screen's state", () => {
+		// One shared reducer, so a mistyped spread is a real hazard: `...state`
+		// rather than `...state.models` would wipe every other screen.
+		const before = initialState;
+		const after = run([
+			{ type: "MODELS_SELECT", index: 2 },
+			{ type: "MODELS_APPLY_START" },
+			{ type: "MODELS_SEARCH_APPEND", char: "x" },
+		]);
+		expect(after.styles).toBe(before.styles);
+		expect(after.plugins).toBe(before.plugins);
+		expect(after.skills).toBe(before.skills);
+	});
+});
+
+// ─── Keybindings ──────────────────────────────────────────────────────────────
+
+const SCREEN = join(import.meta.dir, "..", "ui", "screens", "ModelsScreen.tsx");
+
+describe("ModelsScreen keybindings", () => {
+	test("a and Enter both apply, and c clears", async () => {
+		const src = await fs.readFile(SCREEN, "utf8");
+		expect(src).toContain('event.name === "a"');
+		expect(src).toContain('event.name === "c"');
+		expect(src).toContain('event.name === "r"');
+		expect(src).toContain('event.name === "/"');
+		// Enter is the same action as `a`. There is nothing to "open" here, so
+		// binding the most obvious key to nothing would be the wrong lesson.
+		const enter = src.indexOf('event.name === "return"');
+		expect(enter).toBeGreaterThan(-1);
+		expect(src.slice(enter, enter + 400)).toContain("handleApply()");
+	});
+
+	test("digits are treated as navigation, so a message survives a tab round trip", async () => {
+		// Every digit now navigates, 0 included. Clearing the status line on the
+		// way OUT of the tab loses the message the state was changed to preserve.
+		const src = await fs.readFile(SCREEN, "utf8");
+		expect(src).toContain("/^[0-9]$/.test(event.name");
+	});
+
+	test("no screen still treats 0 as a non-navigation key", async () => {
+		// The Styles screen shipped `/^[1-9]$/` before Models existed on key 0.
+		const styles = await fs.readFile(
+			join(import.meta.dir, "..", "ui", "screens", "StylesScreen.tsx"),
+			"utf8",
+		);
+		expect(styles).not.toContain("/^[1-9]$/");
+	});
+
+	test("screen state is held in the reducer, never in useState", async () => {
+		// The rule the two "survives unmounting" tests above enforce at runtime,
+		// pinned at the source so a new piece of state cannot quietly opt out.
+		const src = await fs.readFile(SCREEN, "utf8");
+		expect(src).not.toContain("useState");
+	});
+});

package/src/__tests__/profile-materializer.test.ts

@@ -3,6 +3,7 @@ import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import fs from "fs-extra";
+import type { ModelsConfig } from "../services/models-core.js";
 import {
 	buildProfileMcp,
 	buildProfileSettings,
@@ -11,6 +12,19 @@ import {
 import { profileDir } from "../services/symlink-manager.js";
 import type { ResolvedClosure } from "../types/index.js";
 
+const ROUTING: ModelsConfig = {
+	version: 1,
+	preset: "test",
+	main: { model: "opus", effort: "medium" },
+	grades: {
+		smart: { model: "fable", effort: "xhigh" },
+		normal: { model: "opus", effort: "medium" },
+		cheap: { model: "sonnet", effort: "low" },
+	},
+	agents: { "dev:architect": "smart" },
+	fallback: "normal",
+};
+
 function closure(overrides: Partial<ResolvedClosure> = {}): ResolvedClosure {
 	return {
 		marketplaces: {},
@@ -162,6 +176,38 @@ describe("materializeProfile", () => {
 		expect(await fs.readdir(join(dir, "skills"))).toEqual([]);
 	});
 
+	test("writes models.json when the closure carries routing", async () => {
+		const dir = await materializeProfile(
+			"p",
+			closure({ models: ROUTING }),
+			project,
+		);
+		expect(await fs.readJson(join(dir, "models.json"))).toEqual(ROUTING);
+	});
+
+	// The one artifact materialization DELETES. Every other file here is
+	// unconditional, so overwriting is enough; routing is optional, and a
+	// profile that dropped it would otherwise keep routing from a file nothing
+	// writes any more — `claudeup models off` could not turn routing off,
+	// because the hook walks up to the nearest models.json and finds this one.
+	test("deletes a stale models.json when the closure has no routing", async () => {
+		const dir = await materializeProfile(
+			"p",
+			closure({ models: ROUTING }),
+			project,
+		);
+		expect(await fs.pathExists(join(dir, "models.json"))).toBe(true);
+
+		await materializeProfile("p", closure(), project);
+
+		expect(await fs.pathExists(join(dir, "models.json"))).toBe(false);
+	});
+
+	test("a profile that never had routing gets no models.json", async () => {
+		const dir = await materializeProfile("p", closure(), project);
+		expect(await fs.pathExists(join(dir, "models.json"))).toBe(false);
+	});
+
 	test("two profiles from one union each disable the other's plugins", async () => {
 		const union = ["designer@magus", "terminal@magus"];
 		const fe = await materializeProfile(

package/src/__tests__/resolver.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test";
+import { PREDEFINED_PROFILES } from "../data/predefined-profiles.js";
 import {
 	dedupeBins,
 	resolveAllProfiles,
@@ -105,6 +106,41 @@ describe("resolveExtends", () => {
 		expect(resolveExtends(entry)).toBe(entry);
 	});
 
+	// `models` inherits like `settings` — later wins — but by WHOLE object: a
+	// ModelsConfig is validated as a unit (every grade present, one effort per
+	// model), so a key-by-key merge could produce a config neither side wrote
+	// and neither side validated.
+	test("the entry's own models win over an inherited one, whole-object", () => {
+		const base = {
+			version: 1,
+			preset: "inherited",
+			main: { model: "sonnet" },
+			grades: {
+				smart: { model: "opus" },
+				normal: { model: "sonnet" },
+				cheap: { model: "haiku" },
+			},
+			agents: {},
+			fallback: "normal",
+		} as ProfileManifestEntry["models"];
+		const own = { ...(base as object), preset: "mine" } as typeof base;
+
+		const withBase = PREDEFINED_PROFILES.find((p) => p.id === "must-have");
+		if (!withBase) throw new Error("must-have preset went missing");
+		withBase.models = base;
+		try {
+			expect(
+				resolveExtends({ name: "X", extends: "must-have" }).models?.preset,
+			).toBe("inherited");
+			expect(
+				resolveExtends({ name: "X", extends: "must-have", models: own }).models
+					?.preset,
+			).toBe("mine");
+		} finally {
+			withBase.models = undefined;
+		}
+	});
+
 	test("unknown extends id is ignored (returns entry unchanged)", () => {
 		const entry: ProfileManifestEntry = { name: "X", extends: "nope" };
 		expect(resolveExtends(entry)).toBe(entry);

package/src/__tests__/settings-file.test.ts

@@ -0,0 +1,179 @@
+/**
+ * `services/settings-file.ts` — the one place claudeup edits a settings.json.
+ *
+ * Every test here pins a failure mode that has cost, or would cost, a user
+ * their configuration:
+ *
+ *  - an unparseable file must be REFUSED, and left byte-for-byte alone;
+ *  - a symlinked settings.json must be written THROUGH the link, because that
+ *    is the shape an active profile leaves behind (`.claude/settings.json` →
+ *    `.claude/_profiles/<name>/settings.json`). Remove-then-create would
+ *    replace the link with a plain file and detach the project from its
+ *    profile, which nothing downstream would notice.
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+import {
+	lstatSync,
+	mkdtempSync,
+	readFileSync,
+	rmSync,
+	symlinkSync,
+	writeFileSync,
+} from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+	readSettingsFile,
+	updateSettingsFile,
+} from "../services/settings-file.js";
+
+const dirs: string[] = [];
+
+afterEach(() => {
+	for (const dir of dirs.splice(0))
+		rmSync(dir, { recursive: true, force: true });
+});
+
+function tempDir(): string {
+	const dir = mkdtempSync(path.join(os.tmpdir(), "claudeup-settings-file-"));
+	dirs.push(dir);
+	return dir;
+}
+
+describe("readSettingsFile", () => {
+	test("S-1: a missing file reads as an empty object", async () => {
+		const missing = path.join(tempDir(), "nested", "settings.json");
+		expect(await readSettingsFile(missing)).toEqual({});
+	});
+
+	test("S-1b: an empty file reads as an empty object", async () => {
+		const file = path.join(tempDir(), "settings.json");
+		writeFileSync(file, "   \n");
+		expect(await readSettingsFile(file)).toEqual({});
+	});
+
+	test("S-2: an unparseable file throws, naming the path and the refusal", async () => {
+		const file = path.join(tempDir(), "settings.json");
+		writeFileSync(file, "{ not json");
+
+		await expect(readSettingsFile(file)).rejects.toThrow(/not valid JSON/);
+		await expect(readSettingsFile(file)).rejects.toThrow(
+			/refusing to overwrite/,
+		);
+		await expect(readSettingsFile(file)).rejects.toThrow(file);
+	});
+});
+
+describe("updateSettingsFile", () => {
+	test("S-3: a missing file starts from {} and is created", async () => {
+		const file = path.join(tempDir(), "nested", "settings.json");
+
+		await updateSettingsFile(file, (settings) => {
+			settings.outputStyle = "composed";
+		});
+
+		expect(JSON.parse(readFileSync(file, "utf8"))).toEqual({
+			outputStyle: "composed",
+		});
+	});
+
+	test("S-4: a valid file round-trips and unrelated keys survive", async () => {
+		const file = path.join(tempDir(), "settings.json");
+		writeFileSync(
+			file,
+			`${JSON.stringify(
+				{
+					enabledPlugins: { "dev@magus": true },
+					someOtherKey: 42,
+					outputStyle: "old",
+				},
+				null,
+				2,
+			)}\n`,
+		);
+
+		await updateSettingsFile(file, (settings) => {
+			settings.outputStyle = "new";
+		});
+
+		expect(JSON.parse(readFileSync(file, "utf8"))).toEqual({
+			enabledPlugins: { "dev@magus": true },
+			someOtherKey: 42,
+			outputStyle: "new",
+		});
+	});
+
+	test("S-4b: the mutator may return a replacement object instead of mutating", async () => {
+		const file = path.join(tempDir(), "settings.json");
+		writeFileSync(file, `${JSON.stringify({ a: 1 }, null, 2)}\n`);
+
+		await updateSettingsFile(file, (settings) => ({ ...settings, b: 2 }));
+
+		expect(JSON.parse(readFileSync(file, "utf8"))).toEqual({ a: 1, b: 2 });
+	});
+
+	test("S-4c: deleting a key removes it rather than serializing undefined", async () => {
+		const file = path.join(tempDir(), "settings.json");
+		writeFileSync(file, `${JSON.stringify({ a: 1, outputStyle: "x" })}\n`);
+
+		await updateSettingsFile(file, (settings) => {
+			// biome-ignore lint/performance/noDelete: removal is the intent
+			delete settings.outputStyle;
+		});
+
+		const raw = readFileSync(file, "utf8");
+		expect(raw).not.toContain("outputStyle");
+		expect(JSON.parse(raw)).toEqual({ a: 1 });
+	});
+
+	test("S-4d: the write is 2-space JSON with a trailing newline", async () => {
+		const file = path.join(tempDir(), "settings.json");
+
+		await updateSettingsFile(file, () => ({ a: { b: 1 } }));
+
+		expect(readFileSync(file, "utf8")).toBe(
+			'{\n  "a": {\n    "b": 1\n  }\n}\n',
+		);
+	});
+
+	test("S-5: an unparseable file throws and the bytes on disk are UNCHANGED", async () => {
+		const file = path.join(tempDir(), "settings.json");
+		const original = '{ "half": tru\n// a human mid-edit\n';
+		writeFileSync(file, original);
+		let mutatorRan = false;
+
+		await expect(
+			updateSettingsFile(file, (settings) => {
+				mutatorRan = true;
+				settings.outputStyle = "composed";
+			}),
+		).rejects.toThrow(/not valid JSON, refusing to overwrite it/);
+
+		expect(mutatorRan).toBe(false);
+		expect(readFileSync(file, "utf8")).toBe(original);
+	});
+
+	test("S-6: a symlinked settings.json is written THROUGH the link — the profile case", async () => {
+		const dir = tempDir();
+		const target = path.join(dir, "profile-settings.json");
+		const link = path.join(dir, "settings.json");
+		writeFileSync(
+			target,
+			`${JSON.stringify({ enabledPlugins: { "dev@magus": true } }, null, 2)}\n`,
+		);
+		symlinkSync(target, link);
+
+		await updateSettingsFile(link, (settings) => {
+			settings.outputStyle = "composed";
+		});
+
+		// The profile's real file received the write …
+		expect(JSON.parse(readFileSync(target, "utf8"))).toEqual({
+			enabledPlugins: { "dev@magus": true },
+			outputStyle: "composed",
+		});
+		// … and the link is still a link, not a plain file that replaced it.
+		expect(lstatSync(link).isSymbolicLink()).toBe(true);
+	});
+});

package/src/__tests__/symlink-manager.test.ts

@@ -13,7 +13,12 @@ import {
 async function materialize(
 	project: string,
 	name: string,
-	files: { settings?: object; mcp?: object; skills?: boolean },
+	files: {
+		settings?: object;
+		mcp?: object;
+		skills?: boolean;
+		models?: object;
+	},
 ) {
 	const dir = profileDir(name, project);
 	await fs.ensureDir(dir);
@@ -21,6 +26,7 @@ async function materialize(
 		await fs.writeJson(join(dir, "settings.json"), files.settings);
 	if (files.mcp) await fs.writeJson(join(dir, "mcp.json"), files.mcp);
 	if (files.skills) await fs.ensureDir(join(dir, "skills"));
+	if (files.models) await fs.writeJson(join(dir, "models.json"), files.models);
 }
 
 describe("symlink-manager", () => {
@@ -108,6 +114,64 @@ describe("symlink-manager", () => {
 		);
 	});
 
+	test("links models.json when the profile has routing", async () => {
+		await materialize(project, "frontend", {
+			settings: { a: 1 },
+			models: { version: 1, preset: "fable-advisor" },
+		});
+		await activateProfile("frontend", project);
+
+		const link = join(project, ".claude", "models.json");
+		expect((await lstat(link)).isSymbolicLink()).toBe(true);
+		expect((await fs.readJson(link)).preset).toBe("fable-advisor");
+	});
+
+	// A dangling .claude/models.json is a repo-wide hazard: `.claude/` is
+	// committed, so it would ship to every teammate and point at a directory
+	// that only exists on the machine that made it.
+	test("a profile without routing gets no models link at all", async () => {
+		await materialize(project, "frontend", { settings: { a: 1 } });
+		await activateProfile("frontend", project);
+
+		const link = join(project, ".claude", "models.json");
+		expect(await fs.pathExists(link)).toBe(false);
+		await expect(lstat(link)).rejects.toThrow();
+	});
+
+	test("switching to a profile without routing removes the previous link", async () => {
+		await materialize(project, "routed", {
+			settings: { which: "routed" },
+			models: { version: 1, preset: "fable-advisor" },
+		});
+		await materialize(project, "plain", { settings: { which: "plain" } });
+
+		await activateProfile("routed", project);
+		expect(
+			(await lstat(join(project, ".claude", "models.json"))).isSymbolicLink(),
+		).toBe(true);
+
+		await activateProfile("plain", project);
+		await expect(
+			lstat(join(project, ".claude", "models.json")),
+		).rejects.toThrow();
+	});
+
+	// Removal is scoped to links INTO _profiles/. A real models.json a project
+	// wrote by hand is not claudeup's to delete.
+	test("a real models.json file is never clobbered by activation", async () => {
+		await materialize(project, "plain", { settings: { a: 1 } });
+		await fs.outputJson(join(project, ".claude", "models.json"), {
+			version: 1,
+			preset: "hand-written",
+		});
+
+		await activateProfile("plain", project);
+
+		expect(
+			(await fs.readJson(join(project, ".claude", "models.json"))).preset,
+		).toBe("hand-written");
+	});
+
 	test("activeProfile returns null when settings.json is a real file", async () => {
 		await fs.ensureDir(join(project, ".claude"));
 		await fs.writeJson(join(project, ".claude", "settings.json"), { a: 1 });