magus-cli 7.5.3 → 7.6.0

package/src/__tests__/format-update-outcome.test.ts

@@ -0,0 +1,367 @@
+/**
+ * Spec 7.5.4 re-review — REQ-12: a refused format update is a failure in the TUI, as in
+ * the CLI.
+ *
+ * Written blind: from the spec and the exported signatures of `prepareProfileStartup`,
+ * `ProfileStartup`, `ProfileStartupNeed`, `formatUpdateOutcome` and `FormatUpdateOutcome`
+ * only. `formatUpdateOutcome` is what the TUI shows after "Update it now"; `problems` is
+ * what the gate refused — the lines the CLI stops on.
+ *
+ * REQ-12a–12d call the pure `formatUpdateOutcome` in-process on hand-built results.
+ *
+ * REQ-12e–12g run `prepareProfileStartup` on a real git repository holding the old
+ * layout, in a CHILD process that starts with HOME, CLAUDE_CONFIG_DIR and XDG_* already
+ * pointing at temp dirs (Bun's `os.homedir()` ignores a HOME changed at runtime), with
+ * stdin/stdout forced non-TTY and colours off. The child's PATH carries only `bun` and
+ * `git`, so nothing here can reach a real `claude` CLI or the real `~/.claude`. The child
+ * also computes `formatUpdateOutcome` on the result and writes everything as JSON.
+ */
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { existsSync } from "node:fs";
+import {
+	mkdir,
+	mkdtemp,
+	readFile,
+	realpath,
+	rm,
+	symlink,
+	writeFile,
+} from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import {
+	type ProfileStartup,
+	type ProfileStartupNeed,
+	type ProfileStartupState,
+	formatUpdateOutcome,
+} from "../services/profile-startup.js";
+
+const SRC = join(import.meta.dir, "..");
+const MODULES = {
+	ansi: join(SRC, "cli", "ansi.ts"),
+	startup: join(SRC, "services", "profile-startup.ts"),
+};
+
+const CHILD_TIMEOUT_MS = 45_000;
+const CHILD_TEST_TIMEOUT_MS = 60_000;
+
+// ---------------------------------------------------------------------------
+// Pure cases
+// ---------------------------------------------------------------------------
+
+function needIn(state: ProfileStartupState): ProfileStartupNeed {
+	return {
+		state,
+		adopt: null,
+		activate: [],
+		declaredDefault: null,
+		autoActivate: false,
+		manifest: { version: 2, profiles: {} },
+	};
+}
+
+describe("REQ-12 formatUpdateOutcome: what the TUI shows after Update it now", () => {
+	test('REQ-12a a problem makes the outcome "failed" with the fixed title and the problem in the message, even when the state reads ok', () => {
+		const result: ProfileStartup = {
+			need: needIn("ok"),
+			notices: [],
+			problems: ["boom"],
+		};
+
+		const outcome = formatUpdateOutcome(result);
+
+		expect(outcome).toEqual({
+			kind: "failed",
+			title: "Could not update the profile format",
+			message: expect.stringContaining("boom"),
+		});
+	});
+
+	test('REQ-12b no problems and a need still to answer gives "ask" carrying the same need object', () => {
+		const need = needIn("inactive");
+		const result: ProfileStartup = { need, notices: [], problems: [] };
+
+		const outcome = formatUpdateOutcome(result);
+
+		expect(outcome.kind).toBe("ask");
+		expect((outcome as { need?: unknown }).need).toBe(need);
+	});
+
+	test('REQ-12c no problems, state ok and a notice gives "updated" titled Profile format updated with the notice in the message', () => {
+		const result: ProfileStartup = {
+			need: needIn("ok"),
+			notices: ["absorbed 1 edit"],
+			problems: [],
+		};
+
+		const outcome = formatUpdateOutcome(result);
+
+		expect(outcome).toEqual({
+			kind: "updated",
+			title: "Profile format updated",
+			message: expect.stringContaining("absorbed 1 edit"),
+		});
+	});
+
+	test('REQ-12d no problems, state ok and no notices gives "updated" with the fixed current-format message', () => {
+		const result: ProfileStartup = {
+			need: needIn("ok"),
+			notices: [],
+			problems: [],
+		};
+
+		const outcome = formatUpdateOutcome(result);
+
+		expect(outcome).toEqual({
+			kind: "updated",
+			title: expect.any(String),
+			message: "This project now uses the current profile format.",
+		});
+	});
+});
+
+// ---------------------------------------------------------------------------
+// Real-tree cases
+// ---------------------------------------------------------------------------
+
+/** mode `prepare`: prepareProfileStartup with NO options. mode `convert`: `{ convert: true }`. */
+const STARTUP_CHILD = `
+import { writeFileSync } from "node:fs";
+
+const [mode, project, resultPath] = process.argv.slice(2);
+const ansi = await import(${JSON.stringify(MODULES.ansi)});
+const startup = await import(${JSON.stringify(MODULES.startup)});
+
+if (typeof ansi.setColorEnabled === "function") ansi.setColorEnabled(false);
+for (const stream of [process.stdin, process.stdout, process.stderr]) {
+	Object.defineProperty(stream, "isTTY", { value: false, configurable: true });
+}
+
+const out = {
+	state: null,
+	notices: null,
+	problems: null,
+	outcome: null,
+	error: null,
+};
+try {
+	const prepared =
+		mode === "convert"
+			? await startup.prepareProfileStartup(project, { convert: true })
+			: await startup.prepareProfileStartup(project);
+	out.state = prepared.need.state;
+	out.notices = prepared.notices;
+	out.problems = Array.isArray(prepared.problems) ? prepared.problems : null;
+	const outcome = startup.formatUpdateOutcome(prepared);
+	out.outcome =
+		outcome.kind === "ask"
+			? { kind: "ask", needState: outcome.need.state }
+			: { kind: outcome.kind, title: outcome.title, message: outcome.message };
+} catch (e) {
+	out.error = e instanceof Error ? (e.stack ?? e.message) : String(e);
+}
+writeFileSync(resultPath, JSON.stringify(out));
+process.exit(0);
+`;
+
+interface StartupRun {
+	state: ProfileStartupState | null;
+	notices: string[] | null;
+	/** Null when the result carried no `problems` array at all. */
+	problems: string[] | null;
+	outcome:
+		| { kind: "ask"; needState: ProfileStartupState }
+		| { kind: "updated" | "failed"; title: string; message: string }
+		| null;
+	error: string | null;
+}
+
+/** The target file the settings symlink names, when it does NOT parse (REQ-12e). */
+const UNPARSEABLE_TARGET = '{"enabledPlugins": {"dev@magus": true,},}\n';
+/** The same file when it parses (REQ-12f). */
+const PARSEABLE_TARGET = '{"enabledPlugins":{"dev@magus":true}}\n';
+const PROFILES_JSON =
+	'{"version":2,"profiles":{"team":{"name":"team","plugins":{"dev@magus":true}}}}\n';
+
+const scratch: string[] = [];
+let helperDir = "";
+let binDir = "";
+
+async function tempRoot(prefix: string): Promise<string> {
+	const dir = await realpath(await mkdtemp(join(tmpdir(), prefix)));
+	scratch.push(dir);
+	return dir;
+}
+
+beforeAll(async () => {
+	helperDir = await tempRoot("fuo-helpers-");
+	binDir = join(helperDir, "bin");
+	await mkdir(binDir);
+	await symlink(process.execPath, join(binDir, "bun"));
+	const git = Bun.which("git");
+	if (git) await symlink(git, join(binDir, "git"));
+	await writeFile(join(helperDir, "startup-child.ts"), STARTUP_CHILD);
+});
+
+afterAll(async () => {
+	for (const dir of scratch) await rm(dir, { recursive: true, force: true });
+});
+
+interface Project {
+	base: string;
+	project: string;
+	env: Record<string, string>;
+}
+
+/**
+ * A real git repository holding the old layout, everything committed:
+ * `.claude/profiles.json` defining `team`, `.claude/_profiles/team/settings.json` with
+ * `targetContent`, and `.claude/settings.json` a SYMLINK to the RELATIVE path
+ * `_profiles/team/settings.json`. HOME, CLAUDE_CONFIG_DIR (`<HOME>/.claude`) and XDG_*
+ * are temp dirs beside it.
+ */
+async function oldLayoutProject(targetContent: string): Promise<Project> {
+	const base = await tempRoot("fuo-");
+	const home = join(base, "home");
+	const xdg = join(base, "xdg");
+	await mkdir(join(home, ".claude"), { recursive: true });
+	for (const kind of ["config", "cache", "data", "state"]) {
+		await mkdir(join(xdg, kind), { recursive: true });
+	}
+	const env = {
+		PATH: `${binDir}:/usr/bin:/bin`,
+		HOME: home,
+		CLAUDE_CONFIG_DIR: join(home, ".claude"),
+		XDG_CONFIG_HOME: join(xdg, "config"),
+		XDG_CACHE_HOME: join(xdg, "cache"),
+		XDG_DATA_HOME: join(xdg, "data"),
+		XDG_STATE_HOME: join(xdg, "state"),
+		TMPDIR: tmpdir(),
+		NO_COLOR: "1",
+		TERM: "dumb",
+		GIT_CONFIG_NOSYSTEM: "1",
+		GIT_CONFIG_GLOBAL: "/dev/null",
+	};
+	const project = join(base, "proj");
+	await mkdir(project, { recursive: true });
+	const git = (...args: string[]): void => {
+		const r = Bun.spawnSync({
+			cmd: [
+				"git",
+				"-c",
+				"user.email=t@t",
+				"-c",
+				"user.name=t",
+				"-c",
+				"commit.gpgsign=false",
+				...args,
+			],
+			cwd: project,
+			env,
+		});
+		if (r.exitCode !== 0) {
+			throw new Error(`git ${args.join(" ")} failed: ${r.stderr.toString()}`);
+		}
+	};
+	git("init", "-q");
+	const target = join(project, ".claude", "_profiles", "team", "settings.json");
+	await mkdir(dirname(target), { recursive: true });
+	await writeFile(target, targetContent);
+	await symlink(
+		"_profiles/team/settings.json",
+		join(project, ".claude", "settings.json"),
+	);
+	await writeFile(join(project, ".claude", "profiles.json"), PROFILES_JSON);
+	git("add", "-A");
+	git("commit", "-q", "-m", "init");
+	return { base, project, env };
+}
+
+async function runStartup(
+	proj: Project,
+	mode: "prepare" | "convert",
+): Promise<StartupRun> {
+	const resultPath = join(proj.base, `result-${mode}.json`);
+	const proc = Bun.spawn({
+		cmd: [
+			process.execPath,
+			"--no-env-file",
+			join(helperDir, "startup-child.ts"),
+			mode,
+			proj.project,
+			resultPath,
+		],
+		cwd: proj.project,
+		env: proj.env,
+		stdin: "ignore",
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	const timer = setTimeout(() => proc.kill(), CHILD_TIMEOUT_MS);
+	const [stdout, stderr, code] = await Promise.all([
+		new Response(proc.stdout).text(),
+		new Response(proc.stderr).text(),
+		proc.exited,
+	]);
+	clearTimeout(timer);
+	let raw: string;
+	try {
+		raw = await readFile(resultPath, "utf8");
+	} catch {
+		throw new Error(
+			`startup child wrote no result (exit ${code}).\nstdout:\n${stdout}\nstderr:\n${stderr}`,
+		);
+	}
+	return JSON.parse(raw) as StartupRun;
+}
+
+describe("REQ-12 a refused format update is a failure in the TUI, as in the CLI", () => {
+	test(
+		'REQ-12e converting an old layout whose settings target does not parse returns a problem, a "failed" outcome, and leaves .claude/_profiles/ in place',
+		async () => {
+			const proj = await oldLayoutProject(UNPARSEABLE_TARGET);
+			const oldDir = join(proj.project, ".claude", "_profiles");
+			expect(existsSync(oldDir)).toBe(true);
+
+			const run = await runStartup(proj, "convert");
+
+			expect(run.error).toBeNull();
+			expect(run.problems).not.toBeNull();
+			expect(run.problems?.length ?? 0).toBeGreaterThan(0);
+			expect(run.outcome?.kind).toBe("failed");
+			expect(existsSync(oldDir)).toBe(true);
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+
+	test(
+		'REQ-12f negative control: converting an old layout whose settings target parses returns no problems and an outcome that is not "failed"',
+		async () => {
+			const proj = await oldLayoutProject(PARSEABLE_TARGET);
+
+			const run = await runStartup(proj, "convert");
+
+			expect(run.error).toBeNull();
+			expect(run.problems).toEqual([]);
+			expect(run.outcome).not.toBeNull();
+			expect(run.outcome?.kind).not.toBe("failed");
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+
+	test(
+		'REQ-12g without options, the unparseable old layout is asked about as "old-format", refuses nothing and converts nothing',
+		async () => {
+			const proj = await oldLayoutProject(UNPARSEABLE_TARGET);
+			const oldDir = join(proj.project, ".claude", "_profiles");
+
+			const run = await runStartup(proj, "prepare");
+
+			expect(run.error).toBeNull();
+			expect(run.state).toBe("old-format");
+			expect(run.problems).toEqual([]);
+			expect(existsSync(oldDir)).toBe(true);
+		},
+		CHILD_TEST_TIMEOUT_MS,
+	);
+});