claudeup 6.3.2 → 6.5.0

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 });

package/src/__tests__/tabbar-layout.test.ts

@@ -4,13 +4,18 @@ import { TABS, barWidth, layoutTabs } from "../ui/components/TabBar.js";
 const FULL = TABS.map((t) => `${t.key}:${t.label}`);
 const FULL_WIDTH = barWidth(FULL);
 
+/** The widest the compacted bar ever gets — whichever active label is longest. */
+const WIDEST_COMPACT = Math.max(
+	...TABS.map((tab) => barWidth(layoutTabs(TABS, tab.screen, 0))),
+);
+
 describe("tab bar layout", () => {
 	test("shows every label when the bar fits", () => {
 		expect(layoutTabs(TABS, "plugins", FULL_WIDTH)).toEqual(FULL);
 	});
 
 	test("drops inactive labels when the bar does not fit", () => {
-		// A 94-column pane leaves ~90 usable, and nine full tabs need ~99 — the
+		// A 94-column pane leaves ~90 usable, and ten full tabs need ~110 — the
 		// width at which OpenTUI clipped each cell into a meaningless stub.
 		const texts = layoutTabs(TABS, "styles", 90);
 		expect(texts).toContain("9:Styles");
@@ -24,6 +29,26 @@ describe("tab bar layout", () => {
 		expect(barWidth(layoutTabs(TABS, "styles", 90))).toBeLessThanOrEqual(90);
 	});
 
+	test("the full bar no longer fits a standard window, so compacting is the norm", () => {
+		// The tenth tab pushed the full bar past 100 columns. That is not a
+		// regression — it is why the compact form has to stay readable, and why
+		// the test below measures it rather than assuming.
+		expect(FULL_WIDTH).toBeGreaterThan(100);
+		expect(layoutTabs(TABS, "models", 100)).not.toEqual(FULL);
+	});
+
+	test("the compact bar fits an 80-column terminal, on every tab", () => {
+		// The real question a tenth tab raises. ScreenLayout pads the bar by 1
+		// each side inside a container padded by 1, so an 80-column terminal
+		// leaves 76 — and the widest compact bar is well under it.
+		expect(WIDEST_COMPACT).toBeLessThanOrEqual(76);
+		for (const tab of TABS) {
+			expect(barWidth(layoutTabs(TABS, tab.screen, 76))).toBeLessThanOrEqual(
+				76,
+			);
+		}
+	});
+
 	test("keeps the label of whichever tab is active", () => {
 		for (const tab of TABS) {
 			const texts = layoutTabs(TABS, tab.screen, 40);
@@ -46,7 +71,9 @@ describe("tab bar layout", () => {
 
 	test("every tab key is a digit the global handler binds", () => {
 		// The compact bar shows only the number, so the number must be the key
-		// that actually navigates.
+		// that actually navigates. Models is keyed "0" and sits last, because the
+		// number row reads 1…9 then 0 — the order here and the order under the
+		// fingers have to agree.
 		expect(TABS.map((t) => t.key)).toEqual([
 			"1",
 			"2",
@@ -57,6 +84,17 @@ describe("tab bar layout", () => {
 			"7",
 			"8",
 			"9",
+			"0",
 		]);
+		expect(TABS.at(-1)).toEqual({
+			key: "0",
+			label: "Models",
+			screen: "models",
+		});
+	});
+
+	test("no two tabs share a key or a screen", () => {
+		expect(new Set(TABS.map((t) => t.key)).size).toBe(TABS.length);
+		expect(new Set(TABS.map((t) => t.screen)).size).toBe(TABS.length);
 	});
 });

package/src/__tests__/theme-adaptive-colors.test.ts

@@ -96,7 +96,18 @@ describe("contrast maths", () => {
 
 // ─── The palette ──────────────────────────────────────────────────────────────
 
-const ACCENTS = Object.entries(brand).filter(([name]) => name !== "ink");
+/**
+ * Inks we paint on a fill WE own, so they are measured against that fill and
+ * not against the terminal. They cannot satisfy the both-backgrounds rule and
+ * are not supposed to: `selectionDim` is a light grey chosen for the selection
+ * purple, which on a cream terminal would be invisible — and is never drawn
+ * there.
+ */
+const OWN_FILL_INKS = new Set(["ink", "selectionDim"]);
+
+const ACCENTS = Object.entries(brand).filter(
+	([name]) => !OWN_FILL_INKS.has(name),
+);
 
 describe("accents are legible on light AND dark terminals", () => {
 	test("the palette is non-empty (guards the loops below)", () => {
@@ -131,6 +142,42 @@ describe("accents are legible on light AND dark terminals", () => {
 		expect(failures).toEqual([]);
 	});
 
+	test("a SELECTED row has two legible inks, and the page palette is not among them", () => {
+		// Found on a screenshot: `(default)` was drawn in `theme.colors.muted` on
+		// the selection purple and simply was not there. Every page-level tone
+		// fails the same way — they are chosen against the terminal's background,
+		// and the selection fill is neither of the two references.
+		const bg = theme.selection.bg;
+		expect(contrastRatio(theme.selection.fg, bg)).toBeGreaterThanOrEqual(
+			INK_CONTRAST,
+		);
+		expect(contrastRatio(theme.selection.dim, bg)).toBeGreaterThanOrEqual(
+			UI_CONTRAST,
+		);
+
+		// And it must READ as secondary next to the primary ink, or the
+		// distinction it exists to make is not visible.
+		expect(
+			contrastRatio(theme.selection.dim, theme.selection.fg),
+		).toBeGreaterThan(1.2);
+		expect(contrastRatio(theme.selection.dim, bg)).toBeLessThan(
+			contrastRatio(theme.selection.fg, bg),
+		);
+	});
+
+	test("the meta tones are exactly why a selected row cannot use them", () => {
+		// The negative half of the rule above, kept measurable: if a future
+		// palette change made one of these legible on the selection, the
+		// selection-aware branch in MetaText would still be right, but this test
+		// would tell us the reasoning had changed.
+		const unreadable = Object.entries(theme.meta).filter(
+			([, hex]) => contrastRatio(hex, theme.selection.bg) < UI_CONTRAST,
+		);
+		expect(unreadable.map(([name]) => name).sort()).toEqual(
+			Object.keys(theme.meta).sort(),
+		);
+	});
+
 	test("the three scope colours are perceptually far apart", () => {
 		// They render as single-character squares, where a subtle shift is not
 		// readable at all. Deferring to ANSI put project and local on slots 2 and 3,

package/src/__tests__/version-snapshot.test.ts

@@ -159,13 +159,13 @@ describe("per-project baselines", () => {
 
 	test("saving one project preserves the others", async () => {
 		await withSandbox(async () => {
-			await saveSeenVersions("/proj/a", { "gtd@magus": "2.0.0" });
-			await saveSeenVersions("/proj/b", { "gtd@magus": "2.0.1" });
+			await saveSeenVersions("/proj/a", { "designer@magus": "2.0.0" });
+			await saveSeenVersions("/proj/b", { "designer@magus": "2.0.1" });
 			expect(await loadSeenVersions("/proj/a")).toEqual({
-				"gtd@magus": "2.0.0",
+				"designer@magus": "2.0.0",
 			});
 			expect(await loadSeenVersions("/proj/b")).toEqual({
-				"gtd@magus": "2.0.1",
+				"designer@magus": "2.0.1",
 			});
 		});
 	});

package/src/cli/doctor.ts

@@ -6,15 +6,26 @@
  *      This is the check that would have caught a dead `tmux-mcp`.
  *   2. Profile symlink integrity — the active profile's links resolve.
  *   3. Convention compliance — .gitignore + CLAUDE.md blocks (ported engine).
+ *   4. Model routing — config validity, hook registration, and drift.
  */
 
 import path from "node:path";
 import fs from "fs-extra";
 import { checkBinaries, missingBinaries } from "../services/doctor-bins.js";
 import { checkProject, fixDoctorIssues } from "../services/doctor.js";
+import {
+	isAgentModelHookRegistered,
+	registerAgentModelHook,
+} from "../services/hook-registration.js";
 import { readManifest } from "../services/manifest.js";
+import {
+	readModelsConfig,
+	readModelsStatus,
+	reapplyModels,
+} from "../services/models-manager.js";
 import { resolveAllProfiles } from "../services/resolver.js";
 import { activeProfile, profileDir } from "../services/symlink-manager.js";
+import { resolveExecutable } from "../utils/command-utils.js";
 
 export async function runDoctorCommand(args: string[]): Promise<number> {
 	const fix = args.includes("--fix");
@@ -98,10 +109,89 @@ export async function runDoctorCommand(args: string[]): Promise<number> {
 		}
 	}
 
+	// 4. Model routing.
+	problems += await checkModels(projectPath, fix);
+
 	if (problems === 0) console.log("\n✓ No problems found.");
 	return problems > 0 && !fix ? 1 : 0;
 }
 
+/**
+ * Model routing health. Silent when the project has no routing at all — an
+ * absent `models.json` is the normal state, not a finding.
+ *
+ * Ordered by what blocks what: an invalid config routes nothing and cannot be
+ * fixed from here (the values are a human's decision); an unregistered hook
+ * routes nothing no matter how good the config is; drift only matters once
+ * both of those are sound.
+ */
+async function checkModels(projectPath: string, fix: boolean): Promise<number> {
+	const { config, errors, path: file } = await readModelsConfig(projectPath);
+	if (config === null && errors.length === 0) return 0;
+
+	console.log("\nModel routing:");
+	let problems = 0;
+
+	if (errors.length > 0) {
+		console.log(`  ✗ ${file} is invalid — nothing is routed:`);
+		for (const e of errors) {
+			console.log(`      ${e.path || "(root)"}: ${e.message}`);
+		}
+		console.log(
+			"    Not auto-fixable: these are choices, not damage. Edit the file (or",
+		);
+		console.log("    re-run `claudeup models use <preset>`) and check again.");
+		// An invalid config is worth exactly one problem, not one per message —
+		// the count drives the exit code, not the severity.
+		return 1;
+	}
+
+	// The hook is what applies the routing. Without it the config is inert.
+	if (await isAgentModelHookRegistered()) {
+		console.log("  ✓ agent-model hook registered at user scope.");
+	} else if (fix) {
+		await registerAgentModelHook();
+		console.log("  ✓ agent-model hook registered at user scope (fixed).");
+	} else {
+		console.log(
+			"  ✗ agent-model hook is not registered — the config is there, but nothing runs it.",
+		);
+		console.log("    Fix: claudeup doctor --fix");
+		problems++;
+	}
+
+	// The hook runs as a bare `claudeup`, deliberately (an absolute path dies on
+	// the next upgrade) — so PATH has to carry it. Warn only: PATH inside a
+	// Claude Code session is not necessarily PATH here.
+	if (!(await resolveExecutable("claudeup"))) {
+		console.log(
+			"  • `claudeup` is not on PATH in this shell. The hook invokes it by name,",
+		);
+		console.log(
+			"    so it must resolve in the shell Claude Code spawns hooks from.",
+		);
+	}
+
+	const status = await readModelsStatus(projectPath);
+	if (status.state === "stale") {
+		console.log("  ✗ settings have drifted from the config:");
+		for (const line of status.drift) console.log(`      ${line}`);
+		if (fix) {
+			await reapplyModels(projectPath);
+			console.log("    Re-applied the config (fixed).");
+		} else {
+			console.log("    Fix: claudeup doctor --fix");
+			problems++;
+		}
+	} else if (status.state === "on") {
+		console.log(`  ✓ preset "${status.preset}" applied, no drift.`);
+	}
+
+	for (const warning of status.warnings) console.log(`  ⚠ ${warning}`);
+
+	return problems;
+}
+
 /** Which of the active profile's expected symlinks are missing or dangling. */
 async function danglingLinks(
 	name: string,

package/src/cli/hook.ts

@@ -0,0 +1,129 @@
+/**
+ * `claudeup hook agent-model` — the PreToolUse hook Claude Code runs on every Agent call.
+ *
+ * This is the hottest path claudeup has: Claude Code spawns it once per subagent dispatch, in
+ * every session on the machine, and waits for it. Two consequences shape the whole file.
+ *
+ * IT MUST BE FAST. `main.tsx` routes here before it loads the project's `.env` and before it
+ * imports the router or the TUI, so nothing in this module may import `src/ui/` or anything
+ * that pulls in `@opentui`. `src/__tests__/hook-import-policy.test.ts` fails the build if that
+ * ever regresses. Measured: 0.02s on this path against 0.16s once the router is loaded.
+ *
+ * IT MUST FAIL OPEN. Every error path exits 0 with empty stdout, which Claude Code reads as
+ * "no opinion". A hook that throws, blocks, or exits non-zero takes the user's subagents with
+ * it, and the failure would surface as delegation mysteriously not working — in every project,
+ * not just the one with the bad config. Silence is always the safe answer, so it is the
+ * default and the fallback.
+ *
+ * It never writes a file, never exits 2, and never reads a `.env`.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, parse } from "node:path";
+import {
+	type ModelsConfig,
+	evaluateAgentHook,
+	validateModelsConfig,
+} from "../services/models-core.js";
+
+/** How far up the tree to look for a config before giving up. */
+const MAX_WALK_UP = 32;
+
+/**
+ * Find the nearest `.claude/models.json` at or above `startDir`.
+ *
+ * The walk matters: a session's cwd is frequently a subdirectory of the project, and this repo
+ * in particular runs most work inside git worktrees. Anchoring on the hook payload's `cwd`
+ * rather than `process.cwd()` is deliberate — Claude Code tells us where the session is, and
+ * that is not necessarily where this process was started.
+ */
+export function findModelsConfig(startDir: string): string | null {
+	let dir = startDir;
+	const root = parse(dir).root;
+	for (let i = 0; i < MAX_WALK_UP; i += 1) {
+		const candidate = join(dir, ".claude", "models.json");
+		if (existsSync(candidate)) return candidate;
+		if (dir === root) return null;
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+	return null;
+}
+
+/**
+ * Read and validate a config. Returns null for every unusable state — missing, unreadable,
+ * unparseable, or invalid — because the hook's answer to all four is the same: do nothing.
+ *
+ * An invalid config is NOT an error here even though it is one everywhere else. `models use`
+ * refuses to write one, `claudeup install` refuses to apply one, and `doctor` reports one; by
+ * the time a session is running, the only useful behaviour left is to get out of the way.
+ */
+export function loadConfig(path: string): ModelsConfig | null {
+	let raw: unknown;
+	try {
+		raw = JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		return null;
+	}
+	if (validateModelsConfig(raw).length > 0) return null;
+	return raw as ModelsConfig;
+}
+
+async function readStdin(): Promise<string> {
+	// A hook always receives its payload on stdin. Guard the TTY case anyway so that a human
+	// typing the subcommand by hand gets an immediate no-op instead of a hang.
+	if (process.stdin.isTTY) return "";
+	const chunks: Uint8Array[] = [];
+	for await (const chunk of Bun.stdin.stream()) chunks.push(chunk);
+	return Buffer.concat(chunks).toString("utf8");
+}
+
+export async function runHookCommand(args: string[]): Promise<number> {
+	// `hook` with no recognised name is a no-op rather than a usage error: this process is
+	// wired into someone's session, and printing to stdout would be interpreted as a decision.
+	if (args[0] !== "agent-model") {
+		await readStdin();
+		return 0;
+	}
+
+	try {
+		const raw = await readStdin();
+		if (raw.trim().length === 0) return 0;
+
+		let payload: Record<string, unknown>;
+		try {
+			payload = JSON.parse(raw) as Record<string, unknown>;
+		} catch {
+			return 0;
+		}
+
+		// `cwd` is the session's directory, which is not this process's cwd.
+		const cwd =
+			typeof payload.cwd === "string" && payload.cwd.length > 0
+				? payload.cwd
+				: process.cwd();
+		const configPath = findModelsConfig(cwd);
+		const config = configPath === null ? null : loadConfig(configPath);
+
+		const decision = evaluateAgentHook(
+			{
+				tool_name:
+					typeof payload.tool_name === "string" ? payload.tool_name : undefined,
+				tool_input:
+					typeof payload.tool_input === "object" && payload.tool_input !== null
+						? (payload.tool_input as Record<string, unknown>)
+						: undefined,
+				cwd,
+			},
+			config,
+		);
+
+		if (decision.kind === "update")
+			process.stdout.write(JSON.stringify(decision.output));
+		return 0;
+	} catch {
+		// Belt and braces. Nothing above should throw, and if it ever does the session must
+		// not notice.
+		return 0;
+	}
+}