magus-cli 7.4.0 → 7.5.0

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

@@ -0,0 +1,425 @@
+/**
+ * `.claude/skills/` is a real directory: magus-installed folders for the
+ * active profile's skills, and custom folders magus never touches.
+ */
+
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import { spawnSync } from "node:child_process";
+import { lstat, mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import fs from "fs-extra";
+import { switchProfile } from "../cli/profile.js";
+import { readManifest, writeManifest } from "../services/manifest.js";
+import { reconcileActiveProfile } from "../services/profile-absorb.js";
+import {
+	activateProfile,
+	activationNotes,
+	recordRefetchedSkills,
+	trackFetchedSkills,
+	updatableSkills,
+} from "../services/profile-activate.js";
+import {
+	backupRoot,
+	folderHash,
+	readActiveMarker,
+	skillsRoot,
+} from "../services/profile-live.js";
+import {
+	SkillClashError,
+	type SkillInstaller,
+} from "../services/profile-skills.js";
+import { prepareProfileState } from "../services/profile-state.js";
+import type { ProfileManifest, ProfileSkillRef } from "../types/index.js";
+
+const ALPHA: ProfileSkillRef = {
+	name: "alpha",
+	repo: "acme/skills",
+	path: "skills/alpha",
+};
+const BETA: ProfileSkillRef = {
+	name: "beta",
+	repo: "acme/skills",
+	path: "skills/beta",
+};
+
+function manifest(): ProfileManifest {
+	return {
+		version: 2,
+		profiles: {
+			team: {
+				name: "Team",
+				plugins: { "dev@magus": "latest" },
+				skills: [ALPHA],
+			},
+			other: {
+				name: "Other",
+				plugins: { "terminal@magus": "latest" },
+				skills: [BETA],
+			},
+		},
+	};
+}
+
+/** Installs a skill offline: one SKILL.md naming where it came from. */
+const fakeInstall: SkillInstaller = async (ref, projectPath) => {
+	await fs.outputFile(
+		join(skillsRoot(projectPath), ref.name, "SKILL.md"),
+		`# ${ref.name} from ${ref.repo}\n`,
+	);
+};
+
+let project: string;
+let log: ReturnType<typeof spyOn>;
+let err: ReturnType<typeof spyOn>;
+
+const skill = (folder: string) => join(skillsRoot(project), folder);
+const gitignoreLines = async () =>
+	(await fs.readFile(join(project, ".gitignore"), "utf8"))
+		.split("\n")
+		.map((l) => l.trim());
+
+async function start(m = manifest(), profile = "team") {
+	await writeManifest(m, project);
+	return activateProfile(m, profile, project, {
+		onDisplace: () => {},
+		installSkill: fakeInstall,
+	});
+}
+
+beforeEach(async () => {
+	project = await mkdtemp(join(tmpdir(), "skills-"));
+	log = spyOn(console, "log").mockImplementation(() => {});
+	err = spyOn(console, "error").mockImplementation(() => {});
+});
+afterEach(async () => {
+	log.mockRestore();
+	err.mockRestore();
+	await rm(project, { recursive: true, force: true });
+});
+
+describe("magus-installed skills", () => {
+	test("are installed into real folders, hashed in the marker, ignored one by one", async () => {
+		await fs.outputFile(join(skill("mine"), "SKILL.md"), "# custom\n");
+
+		await start();
+
+		expect((await lstat(skillsRoot(project))).isDirectory()).toBe(true);
+		expect((await lstat(skillsRoot(project))).isSymbolicLink()).toBe(false);
+		expect(await fs.readFile(join(skill("alpha"), "SKILL.md"), "utf8")).toBe(
+			"# alpha from acme/skills\n",
+		);
+		const marker = await readActiveMarker(project);
+		expect(marker?.skills).toEqual({
+			alpha: (await folderHash(skill("alpha"))) as string,
+		});
+		const lines = await gitignoreLines();
+		expect(lines).toContain(".claude/skills/alpha/");
+		expect(lines).not.toContain(".claude/skills/mine/");
+		expect(lines).not.toContain(".claude/skills");
+	});
+
+	test("switching removes the old profile's skills, installs the new, leaves custom alone", async () => {
+		await fs.outputFile(join(skill("mine"), "SKILL.md"), "# custom\n");
+		await start();
+
+		expect(
+			await switchProfile("other", project, { installSkill: fakeInstall }),
+		).toBe(0);
+
+		expect(await fs.pathExists(skill("alpha"))).toBe(false);
+		expect(await fs.pathExists(skill("beta"))).toBe(true);
+		expect(await fs.readFile(join(skill("mine"), "SKILL.md"), "utf8")).toBe(
+			"# custom\n",
+		);
+		expect(
+			Object.keys((await readActiveMarker(project))?.skills ?? {}),
+		).toEqual(["beta"]);
+		const lines = await gitignoreLines();
+		expect(lines).toContain(".claude/skills/beta/");
+		expect(lines).not.toContain(".claude/skills/alpha/");
+		expect(await fs.pathExists(backupRoot(project))).toBe(false);
+	});
+
+	test("a user's own ignore line for a skill folder survives magus installing and removing it", async () => {
+		await fs.writeFile(
+			join(project, ".gitignore"),
+			"# local\n.claude/skills/alpha/\n",
+		);
+		await start();
+		expect(
+			await switchProfile("other", project, { installSkill: fakeInstall }),
+		).toBe(0);
+
+		const lines = await gitignoreLines();
+		// Theirs, outside magus's block: still there, exactly once.
+		expect(lines.filter((l) => l === ".claude/skills/alpha/")).toHaveLength(1);
+		expect(lines.slice(0, 2)).toEqual(["# local", ".claude/skills/alpha/"]);
+		expect(lines).toContain(".claude/skills/beta/");
+	});
+
+	test("a failed install leaves no folder behind and is reported", async () => {
+		await writeManifest(manifest(), project);
+		const result = await activateProfile(manifest(), "team", project, {
+			onDisplace: () => {},
+			installSkill: async (ref, p) => {
+				await fs.outputFile(join(skillsRoot(p), ref.name, "partial"), "x");
+				throw new Error("network down");
+			},
+		});
+
+		expect(await fs.pathExists(skill("alpha"))).toBe(false);
+		expect(activationNotes(result)).toContain(
+			'Skill "alpha" could not be installed: network down',
+		);
+		expect((await readActiveMarker(project))?.skills).toEqual({});
+	});
+});
+
+describe("magus update re-fetching a skill", () => {
+	test("records the new contents, so the skill does not read as edited", async () => {
+		await start();
+		// What `magus update` does: re-fetch the skill in place.
+		await fs.outputFile(join(skill("alpha"), "SKILL.md"), "# alpha v2\n");
+
+		await recordRefetchedSkills(project, ["alpha"]);
+
+		const result = await reconcileActiveProfile(project, {
+			installSkill: fakeInstall,
+		});
+		expect(result.lines).toEqual([]);
+		expect((await readActiveMarker(project))?.skills.alpha).toBe(
+			(await folderHash(skill("alpha"))) as string,
+		);
+	});
+
+	test("only the skills the update actually fetched get new hashes", async () => {
+		const m = manifest();
+		(m.profiles.team as { skills?: ProfileSkillRef[] }).skills = [ALPHA, BETA];
+		await start(m);
+		// During the update: alpha is re-fetched; beta's fetch fails, and
+		// meanwhile someone edits beta by hand.
+		const reporter = trackFetchedSkills([ALPHA, BETA], {
+			begin: () => {},
+			finish: () => {},
+			detach: (work) => work(),
+		});
+		reporter.report.finish(true, "dev@magus", "installed", 1); // a plugin, not a skill
+		await fs.outputFile(join(skill("alpha"), "SKILL.md"), "# alpha v2\n");
+		reporter.report.finish(true, "alpha", "acme/skills", 1);
+		await fs.appendFile(join(skill("beta"), "SKILL.md"), "hand edit\n");
+		reporter.report.finish(false, "beta", "network down", 1);
+		expect(reporter.fetched()).toEqual(["alpha"]);
+
+		await recordRefetchedSkills(project, reporter.fetched());
+		const result = await reconcileActiveProfile(project, {
+			installSkill: fakeInstall,
+		});
+
+		// alpha's new contents are magus's; beta's edit is still an edit.
+		expect(result.lines).toEqual([
+			'Skill "beta" was edited — it is now a custom skill in .claude/skills/beta; commit it',
+		]);
+		expect((await readActiveMarker(project))?.skills.alpha).toBe(
+			(await folderHash(skill("alpha"))) as string,
+		);
+		expect((await readActiveMarker(project))?.skills.beta).toBeUndefined();
+	});
+
+	test("updatableSkills never targets a custom folder or another profile", async () => {
+		await start();
+		await fs.outputFile(join(skill("beta"), "SKILL.md"), "# custom beta\n");
+		const m = manifest();
+		const teamSkills = m.profiles.team?.skills ?? [];
+		expect(
+			await updatableSkills(project, "team", [...teamSkills, BETA]),
+		).toEqual([ALPHA]);
+		expect(await updatableSkills(project, "other", [BETA])).toEqual([]);
+	});
+});
+
+describe("a profile skill whose folder is a custom skill", () => {
+	test("activation is refused, naming both, and nothing changes", async () => {
+		await fs.outputFile(join(skill("alpha"), "SKILL.md"), "# my own alpha\n");
+		await writeManifest(manifest(), project);
+
+		await expect(
+			activateProfile(manifest(), "team", project, {
+				onDisplace: () => {},
+				installSkill: fakeInstall,
+			}),
+		).rejects.toBeInstanceOf(SkillClashError);
+
+		expect(await fs.readFile(join(skill("alpha"), "SKILL.md"), "utf8")).toBe(
+			"# my own alpha\n",
+		);
+		expect(await fs.pathExists(join(project, ".claude", "settings.json"))).toBe(
+			false,
+		);
+		expect(await readActiveMarker(project)).toBeNull();
+	});
+
+	test("a switch is refused and the current profile stays live", async () => {
+		await start();
+		await fs.outputFile(join(skill("beta"), "SKILL.md"), "# my own beta\n");
+		const before = await fs.readFile(
+			join(project, ".claude", "settings.json"),
+			"utf8",
+		);
+
+		expect(
+			await switchProfile("other", project, { installSkill: fakeInstall }),
+		).toBe(1);
+
+		const said = err.mock.calls.map((c) => String(c[0])).join("\n");
+		expect(said).toContain('profile skill "beta"');
+		expect(said).toContain("custom skill .claude/skills/beta/");
+		expect((await readActiveMarker(project))?.profile).toBe("team");
+		expect(
+			await fs.readFile(join(project, ".claude", "settings.json"), "utf8"),
+		).toBe(before);
+		expect(await fs.pathExists(skill("alpha"))).toBe(true);
+	});
+});
+
+describe("an edited magus-installed skill becomes a custom skill", () => {
+	test("dropped from the marker, the profile and the ignore file; kept on disk", async () => {
+		await start();
+		await fs.appendFile(join(skill("alpha"), "SKILL.md"), "my local change\n");
+
+		const result = await reconcileActiveProfile(project, {
+			installSkill: fakeInstall,
+		});
+
+		expect(result.lines).toContain(
+			'Skill "alpha" was edited — it is now a custom skill in .claude/skills/alpha; commit it',
+		);
+		expect((await readManifest(project)).profiles.team?.skills).toBeUndefined();
+		expect((await readActiveMarker(project))?.skills).toEqual({});
+		expect(await gitignoreLines()).not.toContain(".claude/skills/alpha/");
+		expect(
+			await fs.readFile(join(skill("alpha"), "SKILL.md"), "utf8"),
+		).toContain("my local change");
+		expect(await fs.pathExists(backupRoot(project))).toBe(false);
+
+		// And a later switch leaves it alone.
+		expect(
+			await switchProfile("other", project, { installSkill: fakeInstall }),
+		).toBe(0);
+		expect(await fs.pathExists(skill("alpha"))).toBe(true);
+	});
+});
+
+function git(cwd: string, ...args: string[]) {
+	return spawnSync(
+		"git",
+		[
+			"-c",
+			"user.email=test@example.com",
+			"-c",
+			"user.name=test",
+			"-c",
+			"commit.gpgsign=false",
+			...args,
+		],
+		{ cwd, encoding: "utf8" },
+	);
+}
+
+describe("older layout: committed custom skills the seeding displaced come back", () => {
+	test("git status is clean for the committed skill after conversion", async () => {
+		expect(git(project, "init", "-q").status).toBe(0);
+		const committed = "---\nname: claudish-usage\n---\n# the team's skill\n";
+		await fs.outputFile(join(skill("claudish-usage"), "SKILL.md"), committed);
+		expect(git(project, "add", ".claude/skills").status).toBe(0);
+		expect(git(project, "commit", "-q", "-m", "skills").status).toBe(0);
+
+		// What the older release did: seed the project's skills into the profile
+		// dir, move the real .claude/skills into a backup, and link it instead.
+		const old = join(project, ".claude", "_profiles", "team");
+		await fs.copy(skillsRoot(project), join(old, "skills"));
+		await fs.outputFile(join(old, "skills", "alpha", "SKILL.md"), "# alpha\n");
+		await fs.move(
+			skillsRoot(project),
+			join(backupRoot(project), "2026-09-01T00-00-00-000Z", "skills"),
+		);
+		await fs.symlink("_profiles/team/skills", skillsRoot(project));
+		await fs.outputJson(join(old, "settings.json"), { enabledPlugins: {} });
+		await fs.symlink(
+			"_profiles/team/settings.json",
+			join(project, ".claude", "settings.json"),
+		);
+		await writeManifest(manifest(), project);
+		// The symptom: git sees the committed skill as gone.
+		expect(git(project, "status", "--porcelain").stdout).toContain(
+			".claude/skills",
+		);
+
+		const prep = await prepareProfileState(project, {
+			installSkill: fakeInstall,
+		});
+
+		expect(prep.lines).toContain(
+			'Converted profile "team" from the older layout to real files',
+		);
+		expect(
+			git(
+				project,
+				"status",
+				"--porcelain",
+				"--",
+				".claude/skills/claudish-usage",
+			).stdout,
+		).toBe("");
+		expect(
+			await fs.readFile(join(skill("claudish-usage"), "SKILL.md"), "utf8"),
+		).toBe(committed);
+		// The profile's own skill carried over as magus-installed, not re-fetched.
+		expect(
+			Object.keys((await readActiveMarker(project))?.skills ?? {}),
+		).toEqual(["alpha"]);
+		expect(await fs.readFile(join(skill("alpha"), "SKILL.md"), "utf8")).toBe(
+			"# alpha\n",
+		);
+		expect(await fs.pathExists(join(project, ".claude", "_profiles"))).toBe(
+			false,
+		);
+		// The backup it was restored from is untouched.
+		expect(
+			await fs.pathExists(
+				join(
+					backupRoot(project),
+					"2026-09-01T00-00-00-000Z",
+					"skills",
+					"claudish-usage",
+					"SKILL.md",
+				),
+			),
+		).toBe(true);
+	});
+
+	test("an existing folder is never overwritten; a differing copy is reported with both paths", async () => {
+		await fs.outputFile(join(skill("shared"), "SKILL.md"), "# mine\n");
+		const old = join(project, ".claude", "_profiles", "other", "skills");
+		await fs.outputFile(join(old, "shared", "SKILL.md"), "# older copy\n");
+		await writeManifest(manifest(), project);
+
+		const result = await activateProfile(manifest(), "team", project, {
+			onDisplace: () => {},
+			installSkill: fakeInstall,
+		});
+
+		expect(await fs.readFile(join(skill("shared"), "SKILL.md"), "utf8")).toBe(
+			"# mine\n",
+		);
+		expect(result.conversion.conflicts).toHaveLength(1);
+		const conflict = result.conversion.conflicts[0];
+		expect(conflict?.kept).toBe(skill("shared"));
+		expect(
+			await fs.readFile(join(conflict?.other ?? "", "SKILL.md"), "utf8"),
+		).toBe("# older copy\n");
+		expect(activationNotes(result).join("\n")).toContain(
+			'Skill "shared" exists in two versions',
+		);
+	});
+});

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

@@ -20,8 +20,9 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import fs from "fs-extra";
 import { validateManifest } from "../services/manifest.js";
-import { materializeAndActivate } from "../services/profile-activate.js";
+import { activateProfile } from "../services/profile-activate.js";
 import { adoptCurrentProject } from "../services/profile-adopt.js";
+import { writeActiveMarker } from "../services/profile-live.js";
 import {
 	ACTIVATE_PREFIX,
 	ADOPT_VALUE,
@@ -32,6 +33,7 @@ import {
 	detectProfileStartupNeed,
 	needsNothing,
 	parseProfileChoice,
+	prepareProfileStartup,
 } from "../services/profile-startup.js";
 import { listProfiles } from "../services/profiles.js";
 import type { ProfileManifest } from "../types/index.js";
@@ -93,7 +95,7 @@ describe("detectProfileStartupNeed", () => {
 	test("a profile is active — asks nothing, whatever is enabled", async () => {
 		await fs.outputJson(join(project, ".claude", "profiles.json"), LEAN);
 		await enable(project, ["terminal@magus"]);
-		await materializeAndActivate(LEAN, "lean", project, () => {});
+		await activateProfile(LEAN, "lean", project, { onDisplace: () => {} });
 
 		expect(
 			needsNothing(await detectProfileStartupNeed(project)).valueOf(),
@@ -101,19 +103,16 @@ describe("detectProfileStartupNeed", () => {
 	});
 
 	test("an active profile whose generated settings were edited still asks nothing", async () => {
-		// THE point of dropping the comparison. `settings.json` is a symlink into
-		// `_profiles/lean/`, which is generated FROM the manifest — so judging the
-		// manifest against it reads the manifest's own output. The old code offered
-		// to create a third profile describing the corrupted file; the right answer
-		// is to re-materialize, and the wrong answer is what made magus behave as
-		// though the profileless world were still live.
+		// THE point of dropping the comparison. `settings.json` is rendered FROM
+		// the manifest, so judging the manifest against it reads the manifest's
+		// own output. An edit to it is a change to the active profile, absorbed
+		// before anything reads it — never a reason to offer a third profile.
 		await fs.outputJson(join(project, ".claude", "profiles.json"), LEAN);
 		await enable(project, ["terminal@magus"]);
-		await materializeAndActivate(LEAN, "lean", project, () => {});
-		await fs.outputJson(
-			join(project, ".claude", "_profiles", "lean", "settings.json"),
-			{ enabledPlugins: { "terminal@magus": true, "brand-new@magus": true } },
-		);
+		await activateProfile(LEAN, "lean", project, { onDisplace: () => {} });
+		await fs.outputJson(join(project, ".claude", "settings.json"), {
+			enabledPlugins: { "terminal@magus": true, "brand-new@magus": true },
+		});
 
 		const need = await detectProfileStartupNeed(project);
 
@@ -121,6 +120,37 @@ describe("detectProfileStartupNeed", () => {
 		expect(need.adopt).toBeNull();
 	});
 
+	test("a marker naming a profile the manifest lacks offers only activation", async () => {
+		await fs.outputJson(join(project, ".claude", "profiles.json"), LEAN);
+		await writeActiveMarker(
+			{ version: 1, profile: "gone", files: {}, skills: {} },
+			project,
+		);
+
+		const need = await detectProfileStartupNeed(project);
+
+		expect(need.state).toBe("unknown");
+		expect(need.unknownProfile).toBe("gone");
+		// Saving "what you have" would capture a profile that no longer exists.
+		expect(need.adopt).toBeNull();
+		expect(need.activate.map((p) => p.id).sort()).toEqual(["full", "lean"]);
+		expect(describeNeed(need).message).toContain('"gone"');
+	});
+
+	test("the TUI startup runs the gate first and reports what it absorbed", async () => {
+		await fs.outputJson(join(project, ".claude", "profiles.json"), LEAN);
+		await activateProfile(LEAN, "lean", project, { onDisplace: () => {} });
+		const live = join(project, ".claude", "settings.json");
+		const settings = await fs.readJson(live);
+		settings.enabledPlugins["code-search@magus"] = true;
+		await fs.writeFile(live, JSON.stringify(settings));
+
+		const { need, notices } = await prepareProfileStartup(project);
+
+		expect(need.state).toBe("ok");
+		expect(notices).toEqual(['Added code-search@magus to profile "lean"']);
+	});
+
 	test("what is enabled never changes the answer", async () => {
 		// Nothing reads enabledPlugins, so two wildly different settings files on
 		// the same manifest must produce identical needs.
@@ -143,7 +173,7 @@ describe("detectProfileStartupNeed", () => {
 		const before = await listProfiles(project);
 		expect(before.every((p) => p.active !== true)).toBe(true);
 
-		await materializeAndActivate(LEAN, "lean", project, () => {});
+		await activateProfile(LEAN, "lean", project, { onDisplace: () => {} });
 		const after = await listProfiles(project);
 
 		expect(after.find((p) => p.id === "lean")?.active).toBe(true);