claudeup 6.3.0 → 6.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeup",
-  "version": "6.3.0",
+  "version": "6.4.0",
   "description": "TUI tool for managing Claude Code plugins, MCPs, and configuration",
   "type": "module",
   "main": "src/main.tsx",
@@ -64,8 +64,8 @@
     "typescript": "^5.6.3"
   },
   "optionalDependencies": {
-    "claudeup-darwin-arm64": "6.3.0",
-    "claudeup-darwin-x64": "6.3.0",
-    "claudeup-linux-x64": "6.3.0"
+    "claudeup-darwin-arm64": "6.4.0",
+    "claudeup-darwin-x64": "6.4.0",
+    "claudeup-linux-x64": "6.4.0"
   }
 }

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

@@ -19,6 +19,7 @@
  */
 
 import { afterEach, describe, expect, test } from "bun:test";
+import { width } from "../cli/ansi.js";
 import { LiveRegion, withPaused } from "../cli/live.js";
 
 /** A write stream that records instead of drawing. */
@@ -157,7 +158,12 @@ describe("animated mode", () => {
 		const { live, writes } = region({ columns: 20 });
 		live.start(() => ["x".repeat(40)]);
 		const painted = writes.at(-1) ?? "";
-		expect(painted.replace(/\n$/, "")).toHaveLength(19);
+		// DISPLAY width, not `.length`. `truncate` appends a reset when colour is
+		// on, and colour is on exactly when stdout is a real terminal — so a
+		// `.length` assertion passed piped and failed the moment anyone ran the
+		// suite in a terminal, over four zero-width bytes. The claim being made
+		// here is about columns, so measure columns.
+		expect(width(painted.replace(/\n$/, ""))).toBe(19);
 		live.stop();
 	});
 
@@ -202,7 +208,8 @@ describe("resize", () => {
 		// biome-ignore lint/suspicious/noControlCharactersInRegex: ESC is the thing being matched.
 		const CURSOR_UP = /\x1b\[\d+A/;
 		expect(writes.some((w) => CURSOR_UP.test(w))).toBe(false);
-		expect(writes.at(-1)?.replace(/\n$/, "")).toHaveLength(39);
+		// Display width, for the reason given on the clipping test above.
+		expect(width((writes.at(-1) ?? "").replace(/\n$/, ""))).toBe(39);
 		live.stop();
 	});
 

package/src/__tests__/footer-hints.test.ts

@@ -0,0 +1,40 @@
+/**
+ * `joinKeys` decides how a key group reads in the footer chip.
+ *
+ * Found on screen, not in review: the Models tab advertised apply as `Entera`, and the
+ * layout's own scroll hint had been rendering as `^U/^DPgUp/Dn` on EVERY screen in the app.
+ * Both are two key names concatenated with nothing between them, which reads as one key that
+ * does not exist.
+ */
+import { describe, expect, test } from "bun:test";
+import { joinKeys } from "../ui/components/layout/FooterHints.js";
+
+describe("joinKeys", () => {
+	test("single-character keys butt together, the way an arrow pair is written", () => {
+		expect(joinKeys(["↑", "↓"])).toBe("↑↓");
+		expect(joinKeys(["j", "k"])).toBe("jk");
+	});
+
+	test("one key is itself", () => {
+		expect(joinKeys(["U"])).toBe("U");
+		expect(joinKeys(["Enter"])).toBe("Enter");
+	});
+
+	test("named keys get a gap — the regression this exists for", () => {
+		expect(joinKeys(["Enter", "a"])).toBe("Enter a");
+		expect(joinKeys(["^U/^D", "PgUp/Dn"])).toBe("^U/^D PgUp/Dn");
+	});
+
+	test("a space, not a slash: several key names already contain one", () => {
+		expect(joinKeys(["^U/^D", "PgUp/Dn"])).not.toContain("//");
+	});
+
+	test("a multi-byte single character still counts as one", () => {
+		// "↑".length is 1 but an emoji's is 2 — count code points, not UTF-16 units.
+		expect(joinKeys(["⌘", "⇧"])).toBe("⌘⇧");
+	});
+
+	test("an empty group is empty rather than a stray separator", () => {
+		expect(joinKeys([])).toBe("");
+	});
+});

package/src/__tests__/gitignore-prerun.test.ts

@@ -3,6 +3,7 @@ import { spawnSync } from "node:child_process";
 import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { BUILTIN_DEFAULTS } from "../data/gitignore-defaults.js";
 import {
 	checkGitignore,
 	formatPrerunWarning,
@@ -40,21 +41,13 @@ describe("checkGitignore", () => {
 		git(projectDir, "init", "-q");
 		git(projectDir, "config", "user.email", "t@t");
 		git(projectDir, "config", "user.name", "t");
-		// Suppress all built-in ignore rules
+		// Suppress all built-in ignore rules. DERIVED from the constant, not a
+		// hand-copied list: a copy silently becomes a different assertion the
+		// moment a pattern is added, and then fails for a reason that has nothing
+		// to do with what this test is about.
 		await writeFile(
 			join(projectDir, ".gitignore"),
-			`${[
-				".claude/settings.local.json",
-				".claude/scheduled_tasks.lock",
-				".claude/cache/",
-				".claude/.statusline-worktree-*",
-				".claude/_profiles/",
-				"ai-docs/sessions/",
-				".mnemex/",
-				".claudemem/",
-				"gtd/sessions/",
-				".agents/",
-			].join("\n")}\n`,
+			`${BUILTIN_DEFAULTS.ignore.join("\n")}\n`,
 		);
 		// Tracked files don't have to exist for the absent-track-path case to be ignored
 		const r = await checkGitignore(projectDir);

package/src/__tests__/hook-import-policy.test.ts

@@ -0,0 +1,90 @@
+/**
+ * The hook path must never load the TUI.
+ *
+ * Claude Code runs `claudeup hook …` on every matching tool call, so anything
+ * the entry point imports is paid for on every tool call — and `@opentui/*`
+ * plus the `src/ui/` tree is the expensive half of this program. Two guards,
+ * because they fail differently:
+ *
+ *  - H-1 BUNDLES `src/cli/hook.ts` and inspects the output. A transitive import
+ *    added three modules deep still shows up here.
+ *  - H-2 reads `src/main.tsx` as text. Bundling cannot see this one: the TUI is
+ *    reachable from main.tsx by design, just only through a dynamic import that
+ *    the hook branch returns before. A *static* import would re-couple them
+ *    while every runtime test still passed, so the source is what is pinned —
+ *    the same technique dual-write-prevention.test.ts uses.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+
+const HOOK_ENTRY = path.join(import.meta.dir, "..", "cli", "hook.ts");
+const MAIN_TSX = path.join(import.meta.dir, "..", "main.tsx");
+
+/** Drop `//` line comments and `/* *\/` blocks so the guards match code only. */
+function stripComments(source: string): string {
+	return source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "");
+}
+
+describe("hook entry point", () => {
+	test("H-1: bundling src/cli/hook.ts pulls in neither @opentui nor src/ui", async () => {
+		const build = await Bun.build({
+			entrypoints: [HOOK_ENTRY],
+			target: "bun",
+		});
+
+		expect(build.logs).toEqual([]);
+		expect(build.success).toBe(true);
+		expect(build.outputs.length).toBeGreaterThan(0);
+
+		const bundle = (
+			await Promise.all(build.outputs.map((output) => output.text()))
+		).join("\n");
+
+		expect(bundle).not.toContain("@opentui");
+		expect(bundle).not.toContain("/ui/");
+	});
+});
+
+describe("main.tsx import policy", () => {
+	const source = stripComments(readFileSync(MAIN_TSX, "utf-8"));
+
+	/**
+	 * Every STATIC import/export specifier. `from "…"` only, which is exactly
+	 * what a dynamic `import("…")` does not have — so the dynamic loads main.tsx
+	 * relies on are invisible here, and that is the point.
+	 */
+	const staticSpecifiers = [
+		...source.matchAll(/\bfrom\s+["']([^"']+)["']/g),
+	].map((match) => match[1] as string);
+
+	test("H-2: no static import of @opentui/*", () => {
+		expect(staticSpecifiers.filter((s) => s.startsWith("@opentui"))).toEqual(
+			[],
+		);
+	});
+
+	test("H-2b: no static import of ./ui/*", () => {
+		expect(staticSpecifiers.filter((s) => s.startsWith("./ui/"))).toEqual([]);
+	});
+
+	test("H-2c: the guard sees the specifiers it is meant to see", () => {
+		// Negative control: a regex that matched nothing would pass H-2 and H-2b
+		// forever. main.tsx does still carry static imports — just harmless ones.
+		expect(staticSpecifiers.length).toBeGreaterThan(0);
+		expect(staticSpecifiers).toContain("./services/dotenv.js");
+	});
+
+	test("H-3: the hook branch is dispatched before the .env load", () => {
+		// Ordering, at source level, for the same reason theme-env.test.ts pins
+		// the snapshot: a hook must never open a project .env — it may be a
+		// symlink to a FIFO, and reading one blocks on every tool call.
+		const hookAt = source.indexOf('await import("./cli/hook.js")');
+		const dotenvAt = source.indexOf("loadProjectDotenv(");
+
+		expect(hookAt).toBeGreaterThan(-1);
+		expect(dotenvAt).toBeGreaterThan(-1);
+		expect(hookAt).toBeLessThan(dotenvAt);
+	});
+});

package/src/__tests__/hook-process.test.ts

@@ -0,0 +1,256 @@
+/**
+ * The hook as Claude Code actually runs it: a spawned process, a JSON payload on stdin, and
+ * whatever lands on stdout.
+ *
+ * `models-core.test.ts` covers the decision logic in-process. This file covers the things only
+ * a real spawn can show — that the binary starts, that it reads stdin, that it finds a config
+ * by walking up from the payload's cwd, and above all that EVERY failure mode is silent and
+ * exit 0. Claude Code spawns this on every Agent call in every session on the machine, so a
+ * hook that throws, hangs or exits non-zero would break delegation everywhere at once.
+ *
+ * The negative control is the point of the file: without a config, the same invocation must
+ * produce nothing at all. A test that only checks the happy path cannot tell a working hook
+ * from one that injects unconditionally.
+ */
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import {
+	mkdirSync,
+	mkdtempSync,
+	rmSync,
+	symlinkSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const MAIN = join(dirname(fileURLToPath(import.meta.url)), "..", "main.tsx");
+
+let dir: string;
+
+interface RunResult {
+	stdout: string;
+	stderr: string;
+	exitCode: number;
+	ms: number;
+}
+
+/** Spawn the hook exactly as a settings.json `command` entry would. */
+async function runHook(
+	payload: unknown,
+	opts: { cwd?: string; args?: string[] } = {},
+): Promise<RunResult> {
+	const started = Date.now();
+	const proc = Bun.spawn(
+		["bun", "--no-env-file", MAIN, "hook", ...(opts.args ?? ["agent-model"])],
+		{
+			cwd: opts.cwd ?? dir,
+			stdin: new TextEncoder().encode(
+				typeof payload === "string" ? payload : JSON.stringify(payload),
+			),
+			stdout: "pipe",
+			stderr: "pipe",
+		},
+	);
+	const [stdout, stderr, exitCode] = await Promise.all([
+		new Response(proc.stdout).text(),
+		new Response(proc.stderr).text(),
+		proc.exited,
+	]);
+	return { stdout, stderr, exitCode, ms: Date.now() - started };
+}
+
+const CONFIG = {
+	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",
+		Explore: "cheap",
+		"seo:editor": { model: "inherit" },
+	},
+	fallback: "normal",
+};
+
+function writeConfig(at: string, config: unknown = CONFIG): void {
+	mkdirSync(join(at, ".claude"), { recursive: true });
+	writeFileSync(
+		join(at, ".claude", "models.json"),
+		JSON.stringify(config, null, 2),
+	);
+}
+
+const agentPayload = (input: Record<string, unknown> = {}, cwd = dir) => ({
+	hook_event_name: "PreToolUse",
+	tool_name: "Agent",
+	cwd,
+	tool_input: { subagent_type: "dev:architect", prompt: "go", ...input },
+});
+
+beforeEach(() => {
+	dir = mkdtempSync(join(tmpdir(), "claudeup-hook-"));
+});
+afterEach(() => {
+	rmSync(dir, { recursive: true, force: true });
+});
+
+describe("claudeup hook agent-model", () => {
+	test("injects the routed model, and emits hookEventName", async () => {
+		writeConfig(dir);
+		const r = await runHook(agentPayload());
+		expect(r.exitCode).toBe(0);
+		expect(r.stderr).toBe("");
+		expect(JSON.parse(r.stdout)).toEqual({
+			hookSpecificOutput: {
+				hookEventName: "PreToolUse",
+				updatedInput: {
+					subagent_type: "dev:architect",
+					prompt: "go",
+					model: "fable",
+				},
+			},
+		});
+	});
+
+	test("NEGATIVE CONTROL: no config means no output at all", async () => {
+		// Without this the happy path above cannot distinguish routing from injecting always.
+		const r = await runHook(agentPayload());
+		expect(r.exitCode).toBe(0);
+		expect(r.stdout).toBe("");
+		expect(r.stderr).toBe("");
+	});
+
+	test("walks up to a config in a parent directory", async () => {
+		writeConfig(dir);
+		const nested = join(dir, "packages", "api", "src");
+		mkdirSync(nested, { recursive: true });
+		const r = await runHook(agentPayload({}, nested));
+		expect(JSON.parse(r.stdout).hookSpecificOutput.updatedInput.model).toBe(
+			"fable",
+		);
+	});
+
+	test("uses the payload's cwd, not the process's", async () => {
+		// A session's directory is not where this process was started, and the payload is the
+		// only thing that knows the difference.
+		const elsewhere = mkdtempSync(join(tmpdir(), "claudeup-hook-other-"));
+		try {
+			writeConfig(elsewhere);
+			const r = await runHook(agentPayload({}, elsewhere), { cwd: dir });
+			expect(JSON.parse(r.stdout).hookSpecificOutput.updatedInput.model).toBe(
+				"fable",
+			);
+		} finally {
+			rmSync(elsewhere, { recursive: true, force: true });
+		}
+	});
+
+	test("respects a model the caller already set", async () => {
+		writeConfig(dir);
+		const r = await runHook(agentPayload({ model: "haiku" }));
+		expect(r.stdout).toBe("");
+	});
+
+	test("`inherit` leaves the call alone", async () => {
+		writeConfig(dir);
+		const r = await runHook(agentPayload({ subagent_type: "seo:editor" }));
+		expect(r.stdout).toBe("");
+	});
+
+	test("an unknown agent takes the fallback grade", async () => {
+		writeConfig(dir);
+		const r = await runHook(agentPayload({ subagent_type: "brand-new:agent" }));
+		expect(JSON.parse(r.stdout).hookSpecificOutput.updatedInput.model).toBe(
+			"opus",
+		);
+	});
+
+	test("ignores a tool that is not Agent", async () => {
+		writeConfig(dir);
+		const r = await runHook({
+			tool_name: "Bash",
+			cwd: dir,
+			tool_input: { command: "ls" },
+		});
+		expect(r.stdout).toBe("");
+		expect(r.exitCode).toBe(0);
+	});
+
+	describe("fails open", () => {
+		test("garbage on stdin", async () => {
+			writeConfig(dir);
+			const r = await runHook("not json at all {{{");
+			expect(r.exitCode).toBe(0);
+			expect(r.stdout).toBe("");
+		});
+
+		test("empty stdin", async () => {
+			writeConfig(dir);
+			const r = await runHook("");
+			expect(r.exitCode).toBe(0);
+			expect(r.stdout).toBe("");
+		});
+
+		test("an unparseable config", async () => {
+			mkdirSync(join(dir, ".claude"), { recursive: true });
+			writeFileSync(join(dir, ".claude", "models.json"), "{ broken");
+			const r = await runHook(agentPayload());
+			expect(r.exitCode).toBe(0);
+			expect(r.stdout).toBe("");
+		});
+
+		test("an INVALID config routes nothing rather than injecting a bad model", async () => {
+			// Measured (AMR-1 bogus-model): a non-alias refuses the spawn outright, so injecting
+			// one would break every delegation for everyone who pulled the config.
+			writeConfig(dir, {
+				...CONFIG,
+				grades: { ...CONFIG.grades, smart: { model: "kimi-k2" } },
+			});
+			const r = await runHook(agentPayload());
+			expect(r.exitCode).toBe(0);
+			expect(r.stdout).toBe("");
+		});
+
+		test("a config from a future version", async () => {
+			writeConfig(dir, { ...CONFIG, version: 99 });
+			const r = await runHook(agentPayload());
+			expect(r.exitCode).toBe(0);
+			expect(r.stdout).toBe("");
+		});
+
+		test("an unrecognised hook name", async () => {
+			writeConfig(dir);
+			const r = await runHook(agentPayload(), { args: ["something-else"] });
+			expect(r.exitCode).toBe(0);
+			expect(r.stdout).toBe("");
+		});
+	});
+
+	test("a .env symlinked to a FIFO does not hang the hook", async () => {
+		// In this repo `.env` is often a symlink to a 1Password FIFO. Bun autoloads the cwd's
+		// .env before user code unless told not to, and reading a FIFO with no writer blocks
+		// forever — which would look exactly like Claude Code freezing on every Agent call.
+		writeConfig(dir);
+		const fifo = join(dir, "fifo-target");
+		Bun.spawnSync(["mkfifo", fifo]);
+		symlinkSync(fifo, join(dir, ".env"));
+		const r = await runHook(agentPayload());
+		expect(r.exitCode).toBe(0);
+		expect(JSON.parse(r.stdout).hookSpecificOutput.updatedInput.model).toBe(
+			"fable",
+		);
+	});
+
+	test("stays well inside a hook timeout", async () => {
+		writeConfig(dir);
+		const r = await runHook(agentPayload());
+		// Registered with timeout: 5s. From source (not the compiled binary) this measures
+		// ~0.02-0.3s; a regression that pulls the TUI back onto this path would blow past it.
+		expect(r.ms).toBeLessThan(3000);
+	});
+});