magus-cli 7.5.3 → 7.6.0

package/src/__tests__/profile-name-on-save.test.ts

@@ -0,0 +1,443 @@
+/**
+ * "Save what you have" asks for a name — written blind from the spec's public
+ * contract, never from the implementation.
+ *
+ * Requirements (from the spec):
+ *  REQ-1  The save row's label carries no generated id; it is exactly
+ *         `Save what you have as a new profile`.
+ *  REQ-3  ONE pure function validates the typed name; an invalid name is a
+ *         one-line reason, never silently changed to another id.
+ *  REQ-4  The new profile is written under the derived id with `name` = the
+ *         trimmed text (via applyProfileChoice's adopt `name`).
+ *  REQ-6  Applies to both states that offer the save row: inactive, unmigrated.
+ *  C-1    profileIdForName: empty/whitespace → "Enter a name for the profile."
+ *  C-2    id = lowercase, every run outside [a-z0-9] → one "-", edges trimmed.
+ *  C-3    empty id → "Use at least one letter or digit."
+ *  C-4    id already a key → 'A profile called "<name or id>" already exists.
+ *         Choose another name.'
+ *  C-5    otherwise { ok: true, id, name } with name trimmed.
+ *  C-6    applyProfileChoice adopt without `name` keeps current behaviour.
+ *
+ * REQ-2 and REQ-5 (the prompt itself, its suggestion default, and cancelling
+ * it) live in the CLI/TUI surfaces, which the contract does not expose; they
+ * are listed as known gaps in the run report.
+ */
+
+import { afterEach, beforeEach, describe, expect, spyOn, 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 { readManifest, writeManifest } from "../services/manifest.js";
+import type { ProfileChoice } from "../services/profile-activate.js";
+import {
+	ADOPT_VALUE,
+	buildProfileOptions,
+	detectProfileStartupNeed,
+	parseProfileChoice,
+	profileIdForName,
+} from "../services/profile-startup.js";
+import { applyProfileChoice } from "../services/profile-state.js";
+import type { ProfileManifest } from "../types/index.js";
+
+const SAVE_LABEL = "Save what you have as a new profile";
+
+const MANIFEST: ProfileManifest = {
+	version: 2,
+	profiles: {
+		lean: { name: "Lean", plugins: { "terminal@magus": "latest" } },
+		full: {
+			name: "Full Stack",
+			plugins: { "terminal@magus": "latest", "dev@magus": "latest" },
+		},
+	},
+};
+
+/** A manifest with a profile that carries no display name. */
+const NAMELESS = {
+	version: 2,
+	profiles: {
+		default: { plugins: { "terminal@magus": "latest" } },
+	},
+} as unknown as ProfileManifest;
+
+const EMPTY: ProfileManifest = { version: 2, profiles: {} };
+
+describe("profileIdForName — empty input (C-1)", () => {
+	test("C-1: an empty string asks for a name", () => {
+		expect(profileIdForName("", MANIFEST)).toEqual({
+			ok: false,
+			reason: "Enter a name for the profile.",
+		});
+	});
+
+	test("C-1: whitespace only (spaces, tab, newline) asks for a name, not for a letter", () => {
+		// Rule order: trimming to empty is caught BEFORE the slug rule.
+		for (const input of [" ", "     ", "\t", "\n", " \t \n "]) {
+			expect(profileIdForName(input, MANIFEST)).toEqual({
+				ok: false,
+				reason: "Enter a name for the profile.",
+			});
+		}
+	});
+
+	test("C-1: empty input is rejected even against an empty manifest", () => {
+		expect(profileIdForName("", EMPTY)).toEqual({
+			ok: false,
+			reason: "Enter a name for the profile.",
+		});
+	});
+});
+
+describe("profileIdForName — no usable characters (C-3)", () => {
+	test("C-3: symbols only is rejected with the letter-or-digit reason", () => {
+		for (const input of ["!!!", "---", "@#$%", "  _-_  ", "...", "()[]{}"]) {
+			expect(profileIdForName(input, MANIFEST)).toEqual({
+				ok: false,
+				reason: "Use at least one letter or digit.",
+			});
+		}
+	});
+
+	test("C-3: letters outside [a-z0-9] leave no id and are rejected", () => {
+		// Non-ASCII letters are outside [a-z0-9] after lowercasing.
+		expect(profileIdForName("ÄÖÜ", EMPTY)).toEqual({
+			ok: false,
+			reason: "Use at least one letter or digit.",
+		});
+	});
+});
+
+describe("profileIdForName — id derivation (C-2, C-5)", () => {
+	const cases: Array<[string, string, string]> = [
+		// [input, expected id, expected name]
+		["backend", "backend", "backend"],
+		["Backend", "backend", "Backend"],
+		["My Team", "my-team", "My Team"],
+		["MiXeD CaSe", "mixed-case", "MiXeD CaSe"],
+		["UPPER123", "upper123", "UPPER123"],
+		["v2", "v2", "v2"],
+		["2026", "2026", "2026"],
+		["a.b.c", "a-b-c", "a.b.c"],
+		["Front--End!!v2", "front-end-v2", "Front--End!!v2"],
+		["one   two", "one-two", "one   two"],
+		["snake_case_name", "snake-case-name", "snake_case_name"],
+		["--Hello__World--", "hello-world", "--Hello__World--"],
+		["!!Release!!", "release", "!!Release!!"],
+		["Café Team", "caf-team", "Café Team"],
+		["x", "x", "x"],
+	];
+
+	for (const [input, id, name] of cases) {
+		test(`C-2/C-5: "${input}" becomes id "${id}"`, () => {
+			expect(profileIdForName(input, MANIFEST)).toEqual({ ok: true, id, name });
+		});
+	}
+
+	test("C-5: the returned name is trimmed at both ends, inner spacing kept", () => {
+		expect(profileIdForName("   My   Team  \t", MANIFEST)).toEqual({
+			ok: true,
+			id: "my-team",
+			name: "My   Team",
+		});
+	});
+
+	test("C-2: the id never starts or ends with a dash", () => {
+		const result = profileIdForName("  -*- Night Build -*-  ", EMPTY);
+		expect(result).toEqual({
+			ok: true,
+			id: "night-build",
+			name: "-*- Night Build -*-",
+		});
+	});
+
+	test("C-2: a derived id contains only [a-z0-9] and single dashes", () => {
+		const result = profileIdForName("Q3 / Mobile & Web — Beta!!", EMPTY);
+		expect(result.ok).toBe(true);
+		if (!result.ok) return;
+		expect(result.id).toBe("q3-mobile-web-beta");
+		expect(result.id).toMatch(/^[a-z0-9]+(-[a-z0-9]+)*$/);
+	});
+});
+
+describe("profileIdForName — collisions (C-4, REQ-3)", () => {
+	test("C-4: a name deriving an existing id is refused, naming that profile's display name", () => {
+		expect(profileIdForName("lean", MANIFEST)).toEqual({
+			ok: false,
+			reason: 'A profile called "Lean" already exists. Choose another name.',
+		});
+	});
+
+	test("C-4: the collision is judged on the derived id, whatever the case or padding", () => {
+		for (const input of ["LEAN", "  Lean  ", "lean!", "--lean--"]) {
+			expect(profileIdForName(input, MANIFEST)).toEqual({
+				ok: false,
+				reason: 'A profile called "Lean" already exists. Choose another name.',
+			});
+		}
+	});
+
+	test("C-4: the reason quotes the EXISTING profile's name, not what the user typed", () => {
+		expect(profileIdForName("FULL", MANIFEST)).toEqual({
+			ok: false,
+			reason:
+				'A profile called "Full Stack" already exists. Choose another name.',
+		});
+	});
+
+	test("C-4: a profile with no name is quoted by its id", () => {
+		expect(profileIdForName("Default", NAMELESS)).toEqual({
+			ok: false,
+			reason: 'A profile called "default" already exists. Choose another name.',
+		});
+	});
+
+	test("REQ-3: a colliding name is never silently moved to another id", () => {
+		// The old flow proposed `default-2`; a typed name that collides must be
+		// refused, not renumbered.
+		const result = profileIdForName("default", NAMELESS);
+		expect(result.ok).toBe(false);
+		expect(result).not.toHaveProperty("id");
+	});
+
+	test("C-4: matching an existing DISPLAY name under a different id is not a collision", () => {
+		// "Full Stack" is the name of id `full`; its derived id is `full-stack`,
+		// which is not a key — the rule compares ids only.
+		expect(profileIdForName("Full Stack", MANIFEST)).toEqual({
+			ok: true,
+			id: "full-stack",
+			name: "Full Stack",
+		});
+	});
+
+	test("C-4: a name whose id merely starts with an existing id is fine", () => {
+		expect(profileIdForName("Lean 2", MANIFEST)).toEqual({
+			ok: true,
+			id: "lean-2",
+			name: "Lean 2",
+		});
+	});
+});
+
+describe("profileIdForName — purity (REQ-3)", () => {
+	test("REQ-3: it does not modify the manifest and answers the same twice", () => {
+		const before = structuredClone(MANIFEST);
+		const first = profileIdForName("New One", MANIFEST);
+		const second = profileIdForName("New One", MANIFEST);
+		expect(first).toEqual(second);
+		expect(MANIFEST).toEqual(before);
+		// A valid name is not registered anywhere by being checked.
+		expect(Object.keys(MANIFEST.profiles)).toEqual(["lean", "full"]);
+	});
+});
+
+describe("the save row (REQ-1, REQ-6)", () => {
+	const unmigrated = {
+		state: "unmigrated" as const,
+		adopt: "default",
+		activate: [],
+		manifest: EMPTY,
+	};
+	const inactive = {
+		state: "inactive" as const,
+		adopt: "default-2",
+		activate: [
+			{ id: "lean", name: "Lean", pluginCount: 1 },
+			{ id: "full", name: "Full Stack", pluginCount: 2 },
+		],
+		manifest: MANIFEST,
+	};
+
+	for (const need of [unmigrated, inactive]) {
+		test(`REQ-1/REQ-6: in the ${need.state} state the save row reads exactly "${SAVE_LABEL}"`, () => {
+			const save = buildProfileOptions(need).find(
+				(o) => o.value === ADOPT_VALUE,
+			);
+			expect(save).toBeDefined();
+			expect(save?.label).toBe(SAVE_LABEL);
+		});
+
+		test(`REQ-1: in the ${need.state} state the save row does not show the generated id`, () => {
+			const save = buildProfileOptions(need).find(
+				(o) => o.value === ADOPT_VALUE,
+			);
+			expect(save?.label).not.toContain(need.adopt);
+			expect(save?.label).not.toContain('"');
+		});
+	}
+});
+
+describe("applyProfileChoice writes the user's name (REQ-4, REQ-6, C-6)", () => {
+	let project: string;
+	let wasTTY: boolean | undefined;
+	let log: ReturnType<typeof spyOn>;
+	let err: ReturnType<typeof spyOn>;
+
+	const enable = (ids: string[]) =>
+		fs.outputJson(join(project, ".claude", "settings.json"), {
+			enabledPlugins: Object.fromEntries(ids.map((id) => [id, true])),
+		});
+
+	beforeEach(async () => {
+		project = await mkdtemp(join(tmpdir(), "name-on-save-"));
+		wasTTY = process.stdin.isTTY;
+		Object.defineProperty(process.stdin, "isTTY", {
+			value: false,
+			configurable: true,
+		});
+		log = spyOn(console, "log").mockImplementation(() => {});
+		err = spyOn(console, "error").mockImplementation(() => {});
+	});
+	afterEach(async () => {
+		log.mockRestore();
+		err.mockRestore();
+		Object.defineProperty(process.stdin, "isTTY", {
+			value: wasTTY,
+			configurable: true,
+		});
+		await rm(project, { recursive: true, force: true });
+	});
+
+	test("REQ-4: adopt with a name writes that name under the given id", async () => {
+		await writeManifest(MANIFEST, project);
+		await enable(["code-search@magus"]);
+
+		const choice: ProfileChoice = {
+			kind: "adopt",
+			id: "my-team",
+			name: "My Team",
+		};
+		const result = await applyProfileChoice(choice, MANIFEST, project, {
+			onDisplace: () => {},
+		});
+
+		expect(result.profileId).toBe("my-team");
+		const written = await readManifest(project);
+		expect(written.profiles["my-team"]).toBeDefined();
+		expect(written.profiles["my-team"]?.name).toBe("My Team");
+	});
+
+	test("REQ-4: adopting under a new name leaves every existing profile untouched", async () => {
+		await writeManifest(MANIFEST, project);
+		await enable(["code-search@magus"]);
+
+		await applyProfileChoice(
+			{ kind: "adopt", id: "my-team", name: "My Team" },
+			MANIFEST,
+			project,
+			{ onDisplace: () => {} },
+		);
+
+		const written = await readManifest(project);
+		expect(written.profiles.lean).toEqual(MANIFEST.profiles.lean);
+		expect(written.profiles.full).toEqual(MANIFEST.profiles.full);
+		expect(Object.keys(written.profiles).sort()).toEqual([
+			"full",
+			"lean",
+			"my-team",
+		]);
+	});
+
+	test("REQ-4/REQ-6: inactive state — detect, choose save, name it, apply", async () => {
+		await writeManifest(MANIFEST, project);
+		await enable(["code-search@magus"]);
+
+		const need = await detectProfileStartupNeed(project);
+		expect(need.state).toBe("inactive");
+		const picked = parseProfileChoice(ADOPT_VALUE, need);
+		expect(picked).toEqual({ kind: "adopt", id: need.adopt as string });
+
+		const check = profileIdForName("  Release Candidate  ", need.manifest);
+		expect(check).toEqual({
+			ok: true,
+			id: "release-candidate",
+			name: "Release Candidate",
+		});
+		if (!check.ok || !picked) throw new Error("unreachable");
+
+		const result = await applyProfileChoice(
+			{ ...picked, id: check.id, name: check.name } as ProfileChoice,
+			need.manifest,
+			project,
+			{ onDisplace: () => {} },
+		);
+
+		expect(result.profileId).toBe("release-candidate");
+		const written = await readManifest(project);
+		expect(written.profiles["release-candidate"]?.name).toBe(
+			"Release Candidate",
+		);
+		// No auto-numbered profile was created alongside it.
+		expect(written.profiles[need.adopt as string]).toBeUndefined();
+		expect(written.profiles.lean).toEqual(MANIFEST.profiles.lean);
+		expect(written.profiles.full).toEqual(MANIFEST.profiles.full);
+	});
+
+	test("REQ-4/REQ-6: unmigrated state — the first profile gets the typed name", async () => {
+		// No profiles.json at all.
+		await enable(["dev@magus"]);
+
+		const need = await detectProfileStartupNeed(project);
+		expect(need.state).toBe("unmigrated");
+
+		const check = profileIdForName("Personal Setup", need.manifest);
+		expect(check).toEqual({
+			ok: true,
+			id: "personal-setup",
+			name: "Personal Setup",
+		});
+		if (!check.ok) throw new Error("unreachable");
+
+		const result = await applyProfileChoice(
+			{ kind: "adopt", id: check.id, name: check.name },
+			need.manifest,
+			project,
+			{ onDisplace: () => {} },
+		);
+
+		expect(result.profileId).toBe("personal-setup");
+		const written = await readManifest(project);
+		expect(Object.keys(written.profiles)).toEqual(["personal-setup"]);
+		expect(written.profiles["personal-setup"]?.name).toBe("Personal Setup");
+	});
+
+	test("REQ-4: accepting the suggestion writes the suggested id as the name", async () => {
+		await writeManifest(MANIFEST, project);
+		await enable(["code-search@magus"]);
+
+		const need = await detectProfileStartupNeed(project);
+		const suggestion = need.adopt as string;
+		const check = profileIdForName(suggestion, need.manifest);
+		expect(check).toEqual({ ok: true, id: suggestion, name: suggestion });
+		if (!check.ok) throw new Error("unreachable");
+
+		await applyProfileChoice(
+			{ kind: "adopt", id: check.id, name: check.name },
+			need.manifest,
+			project,
+			{ onDisplace: () => {} },
+		);
+
+		expect((await readManifest(project)).profiles[suggestion]?.name).toBe(
+			suggestion,
+		);
+	});
+
+	test("C-6: adopt without a name still creates the profile under its id", async () => {
+		await writeManifest(MANIFEST, project);
+		await enable(["code-search@magus"]);
+
+		const result = await applyProfileChoice(
+			{ kind: "adopt", id: "default" },
+			MANIFEST,
+			project,
+			{ onDisplace: () => {} },
+		);
+
+		expect(result.profileId).toBe("default");
+		const written = await readManifest(project);
+		expect(written.profiles.default).toBeDefined();
+		expect(written.profiles.lean).toEqual(MANIFEST.profiles.lean);
+		expect(written.profiles.full).toEqual(MANIFEST.profiles.full);
+	});
+});

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

@@ -17,7 +17,7 @@ import {
 	activationNotes,
 	recordRefetchedSkills,
 	trackFetchedSkills,
-	trackedGeneratedWarnings,
+	trackedGeneratedNotices,
 	updatableSkills,
 } from "../services/profile-activate.js";
 import {
@@ -361,7 +361,7 @@ describe("older layout: committed custom skills the seeding displaced come back"
 		});
 
 		expect(prep.lines).toContain(
-			'Converted profile "team" from the older layout to real files',
+			'Updated profile "team" to the current profile format',
 		);
 		expect(
 			git(
@@ -465,7 +465,7 @@ describe("older layout: committed custom skills the seeding displaced come back"
 		expect(git(project, "init", "-q").status).toBe(0);
 		expect(git(project, "add", "-f", ".claude/skills/alpha").status).toBe(0);
 		expect(git(project, "commit", "-q", "-m", "oops").status).toBe(0);
-		expect(await trackedGeneratedWarnings(project)).toEqual([]);
+		expect(await trackedGeneratedNotices(project)).toEqual([]);
 		// A teammate drops alpha from the profile. Were it still magus's, the
 		// reconcile would delete the team's committed folder.
 		const pulled = manifest();