magus-cli 7.5.1 → 7.5.3

package/package.json

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

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

@@ -1,19 +1,16 @@
 import { afterEach, beforeEach, describe, expect, it } from "bun:test";
 import { spawnSync } from "node:child_process";
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { 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,
-	formatGitignoreWarning,
-} from "../services/gitignore-check";
+import { startupGitignoreNeed } from "../services/gitignore-check";
 
 function git(cwd: string, ...args: string[]): void {
 	spawnSync("git", ["-c", "core.excludesFile=/dev/null", ...args], { cwd });
 }
 
-describe("checkGitignore", () => {
+describe("startupGitignoreNeed", () => {
 	let projectDir: string;
 
 	beforeEach(async () => {
@@ -24,20 +21,21 @@ describe("checkGitignore", () => {
 		await rm(projectDir, { recursive: true, force: true });
 	});
 
-	it("returns 0 violations for non-git directory", async () => {
-		const r = await checkGitignore(projectDir);
-		expect(r.violationCount).toBe(0);
+	it("asks nothing in a non-git directory", async () => {
+		expect(await startupGitignoreNeed(projectDir)).toBeNull();
 	});
 
 	it("flags missing built-in patterns inside a fresh git repo", async () => {
 		git(projectDir, "init", "-q");
-		const r = await checkGitignore(projectDir);
+		const need = await startupGitignoreNeed(projectDir);
 		// BUILTIN_DEFAULTS includes ".mnemex/" etc. — none are tracked, none in
 		// .gitignore, so each one becomes "missing-from-gitignore".
-		expect(r.violationCount).toBeGreaterThan(0);
+		expect(need?.violationCount).toBeGreaterThan(0);
+		expect(need?.safeCount).toBeGreaterThan(0);
+		expect(need?.generated).toEqual([]);
 	});
 
-	it("returns 0 when .gitignore covers all built-in patterns and tracked files match track rules", async () => {
+	it("asks nothing when .gitignore covers all built-in patterns and tracked files match track rules", async () => {
 		git(projectDir, "init", "-q");
 		git(projectDir, "config", "user.email", "t@t");
 		git(projectDir, "config", "user.name", "t");
@@ -50,22 +48,6 @@ describe("checkGitignore", () => {
 			`${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);
-		expect(r.violationCount).toBe(0);
-	});
-});
-
-describe("formatGitignoreWarning", () => {
-	it("returns null when no violations", () => {
-		expect(
-			formatGitignoreWarning({ violationCount: 0, warnings: [] }),
-		).toBeNull();
-	});
-
-	it("returns a warning string when violations exist", () => {
-		const w = formatGitignoreWarning({ violationCount: 3, warnings: [] });
-		expect(w).not.toBeNull();
-		expect(w).toContain("3 git state");
-		expect(w).toContain("Git State tab");
+		expect(await startupGitignoreNeed(projectDir)).toBeNull();
 	});
 });

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

@@ -0,0 +1,248 @@
+/**
+ * B7 — in a project with profiles, a generated file git tracks is a question
+ * asked on every TUI open, fixed in place when the user says so.
+ *
+ * The files magus generates from `.claude/profiles.json` are expected to be
+ * gitignored. The gitignore manager's `profile` tier says so, so a committed
+ * copy is reported as "tracked but should be ignored" — and the startup fix
+ * untracks exactly those files, leaving every other violation for the tab.
+ */
+
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import { spawnSync } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import fs from "fs-extra";
+import { startupGitignoreNeed } from "../services/gitignore-check.js";
+import {
+	applyStartupFixes,
+	describeStartupFix,
+	loadGitignoreState,
+} from "../services/gitignore-service.js";
+import { writeManifest } from "../services/manifest.js";
+import { activateProfile } from "../services/profile-activate.js";
+import {
+	folderHash,
+	readActiveMarker,
+	writeActiveMarker,
+} from "../services/profile-live.js";
+import {
+	applyProfileChoice,
+	prepareProfileState,
+} from "../services/profile-state.js";
+import type { ProfileManifest } from "../types/index.js";
+import { buildGitignoreModal } from "../ui/hooks/useGitignoreModal.js";
+
+const MANIFEST: ProfileManifest = {
+	version: 2,
+	profiles: { team: { name: "Team", plugins: { "dev@magus": "latest" } } },
+};
+
+let project: string;
+let log: ReturnType<typeof spyOn>;
+
+function git(...args: string[]) {
+	return spawnSync(
+		"git",
+		[
+			"-c",
+			"user.email=test@example.com",
+			"-c",
+			"user.name=test",
+			"-c",
+			"commit.gpgsign=false",
+			"-c",
+			"core.excludesFile=/dev/null",
+			...args,
+		],
+		{ cwd: project, encoding: "utf8" },
+	);
+}
+
+/** A repo that commits `.claude/settings.json` (and, optionally, profiles.json). */
+async function commitSettings(withProfiles: boolean): Promise<void> {
+	expect(git("init", "-q").status).toBe(0);
+	await fs.outputJson(join(project, ".claude", "settings.json"), {
+		enabledPlugins: { "dev@magus": true },
+	});
+	if (withProfiles) await writeManifest(MANIFEST, project);
+	expect(git("add", "-A").status).toBe(0);
+	expect(git("commit", "-q", "-m", "init").status).toBe(0);
+}
+
+beforeEach(async () => {
+	project = await fs.realpath(await mkdtemp(join(tmpdir(), "gitig-prof-")));
+	log = spyOn(console, "log").mockImplementation(() => {});
+});
+afterEach(async () => {
+	log.mockRestore();
+	await rm(project, { recursive: true, force: true });
+});
+
+describe("the startup question names tracked generated files", () => {
+	test("B7: in a project with profiles, a committed settings.json is tracked-but-should-ignore", async () => {
+		await commitSettings(true);
+
+		const need = await startupGitignoreNeed(project);
+
+		expect(need?.generated).toEqual([".claude/settings.json"]);
+		const { violations } = await loadGitignoreState(project);
+		expect(violations).toContainEqual({
+			kind: "tracked-but-should-ignore",
+			path: ".claude/settings.json",
+			source: "profile",
+			severity: "destructive",
+		});
+	});
+
+	test("B7: without profiles, a committed settings.json is the team's file — nothing generated to ask about", async () => {
+		await commitSettings(false);
+		expect((await startupGitignoreNeed(project))?.generated ?? []).toEqual([]);
+	});
+
+	test("B7: nothing is remembered — dismissing leaves the question for the next open", async () => {
+		await commitSettings(true);
+		// Two opens, the first dismissed (dismiss changes nothing).
+		const first = await startupGitignoreNeed(project);
+		const second = await startupGitignoreNeed(project);
+		expect(first?.generated).toEqual([".claude/settings.json"]);
+		expect(second).toEqual(first);
+	});
+
+	test("B7: after a first adoption in the same session, the re-check asks about the file adoption made generated", async () => {
+		await commitSettings(false);
+		expect((await startupGitignoreNeed(project))?.generated ?? []).toEqual([]);
+
+		// The profile modal's "Save what you have".
+		await applyProfileChoice(
+			{ kind: "adopt", id: "default" },
+			{ version: 2, profiles: {} },
+			project,
+			{ onDisplace: () => {} },
+		);
+
+		expect((await startupGitignoreNeed(project))?.generated).toEqual([
+			".claude/settings.json",
+		]);
+	});
+});
+
+describe("the startup fix untracks generated files in place", () => {
+	test("B7: only generated files are untracked; other violations stay; the removal is staged", async () => {
+		await commitSettings(true);
+		// Another violation magus does not own: a committed personal settings file.
+		await fs.outputJson(join(project, ".claude", "settings.local.json"), {});
+		expect(git("add", "-f", ".claude/settings.local.json").status).toBe(0);
+		expect(git("commit", "-q", "-m", "local").status).toBe(0);
+
+		const result = await applyStartupFixes(project);
+
+		expect(result.untracked).toEqual([".claude/settings.json"]);
+		expect(result.failed).toEqual([]);
+		const status = git("status", "--porcelain").stdout;
+		expect(status).toContain("D  .claude/settings.json");
+		expect(status).not.toContain("settings.local.json");
+		expect(git("ls-files", ".claude/settings.local.json").stdout.trim()).toBe(
+			".claude/settings.local.json",
+		);
+		// The file itself is kept, and now ignored.
+		expect(await fs.pathExists(join(project, ".claude", "settings.json"))).toBe(
+			true,
+		);
+		expect(await fs.readFile(join(project, ".gitignore"), "utf8")).toContain(
+			".claude/settings.json",
+		);
+		expect(describeStartupFix(result)).toContain(
+			"Stopped tracking (the removal is staged — commit it):",
+		);
+		// Asked again on the next open: nothing generated is tracked any more.
+		expect((await startupGitignoreNeed(project))?.generated ?? []).toEqual([]);
+	});
+
+	test("B7: the modal offers the in-place fix and names the files", async () => {
+		const modal = buildGitignoreModal({
+			violationCount: 3,
+			safeCount: 2,
+			generated: [".claude/settings.json"],
+			onFixSafe: () => {},
+			onOpenTab: () => {},
+			onDismiss: () => {},
+		});
+		if (modal.type !== "select") throw new Error("type guard");
+		expect(modal.options.map((o) => o.value)).toEqual([
+			"fix-safe",
+			"open-tab",
+			"dismiss",
+		]);
+		expect(modal.options[0]?.label).toBe(
+			"Stop tracking 1 generated file and add 2 missing .gitignore entries",
+		);
+		expect(modal.message).toContain("  .claude/settings.json");
+		expect(modal.message).toContain("expected to be gitignored");
+	});
+});
+
+describe("review: what the profile tier must never claim", () => {
+	test("B7 review M: a committed skill an old marker records as magus's is never flagged, never untracked, and handed back", async () => {
+		expect(git("init", "-q").status).toBe(0);
+		await fs.outputFile(
+			join(project, ".claude", "skills", "review", "SKILL.md"),
+			"---\nname: review\n---\nteam skill\n",
+		);
+		expect(git("add", "-A").status).toBe(0);
+		expect(git("commit", "-q", "-m", "team skill").status).toBe(0);
+		await writeManifest(MANIFEST, project);
+		await activateProfile(MANIFEST, "team", project, { onDisplace: () => {} });
+		// What 7.5.0's conversion wrote: the committed folder recorded as installed.
+		const marker = await readActiveMarker(project);
+		if (!marker) throw new Error("no marker");
+		await writeActiveMarker(
+			{
+				...marker,
+				skills: {
+					review: (await folderHash(
+						join(project, ".claude", "skills", "review"),
+					)) as string,
+				},
+			},
+			project,
+		);
+
+		expect(
+			(await startupGitignoreNeed(project))?.generated ?? [],
+		).not.toContain(".claude/skills/review/SKILL.md");
+		const fixed = await applyStartupFixes(project);
+		expect(fixed.untracked).not.toContain(".claude/skills/review/SKILL.md");
+		expect(git("diff", "--cached", "--name-only").stdout).toBe("");
+
+		// The next marker write drops it, and says so once.
+		const prep = await prepareProfileState(project);
+		expect(prep.lines).toContain(
+			"Skill review is committed by the team — magus no longer manages it",
+		);
+		expect((await readActiveMarker(project))?.skills).toEqual({});
+		expect(
+			await fs.pathExists(
+				join(project, ".claude", "skills", "review", "SKILL.md"),
+			),
+		).toBe(true);
+		expect((await prepareProfileState(project)).lines.join("\n")).not.toContain(
+			"committed by the team",
+		);
+	});
+
+	test("B7 review L2: a left-over marker in a repo that dropped profiles.json is not profiled", async () => {
+		expect(git("init", "-q").status).toBe(0);
+		await writeManifest(MANIFEST, project);
+		await activateProfile(MANIFEST, "team", project, { onDisplace: () => {} });
+		await fs.remove(join(project, ".claude", "profiles.json"));
+		expect(git("add", "-f", ".claude/settings.json").status).toBe(0);
+		expect(
+			git("commit", "-q", "-m", "team commits settings again").status,
+		).toBe(0);
+
+		expect((await startupGitignoreNeed(project))?.generated ?? []).toEqual([]);
+		expect((await applyStartupFixes(project)).untracked).toEqual([]);
+	});
+});

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

@@ -14,6 +14,10 @@ import fs from "fs-extra";
 import { runModelsCommand } from "../cli/models.js";
 import { presetNames } from "../data/models-presets.js";
 import { writeManifest } from "../services/manifest.js";
+import {
+	clearMateCatalogCache,
+	loadMateCatalog,
+} from "../services/mate-catalog.js";
 import { activateProfile } from "../services/profile-activate.js";
 
 let logs: string[];
@@ -31,10 +35,17 @@ beforeEach(async () => {
 	configDir = await mkdtemp(join(tmpdir(), "modelscli-config-"));
 	previousConfigDir = process.env.CLAUDE_CONFIG_DIR;
 	process.env.CLAUDE_CONFIG_DIR = configDir;
+	// `models list` with a mate asks the catalogue, whose default fetcher spawns the real
+	// `claudish --models` — about 2s on a machine that has it, with an 8s budget, so the first
+	// test to reach it timed out under load and passed on CI, which has no claudish. An empty
+	// catalogue is the no-claudish case, and every assertion here holds against it.
+	clearMateCatalogCache();
+	await loadMateCatalog(async () => null);
 });
 
 afterEach(async () => {
 	mock.restore();
+	clearMateCatalogCache();
 	// biome-ignore lint/performance/noDelete: absence is the intent, not a shortcut
 	if (previousConfigDir === undefined) delete process.env.CLAUDE_CONFIG_DIR;
 	else process.env.CLAUDE_CONFIG_DIR = previousConfigDir;

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

@@ -17,6 +17,7 @@ import {
 	activationNotes,
 	recordRefetchedSkills,
 	trackFetchedSkills,
+	trackedGeneratedWarnings,
 	updatableSkills,
 } from "../services/profile-activate.js";
 import {
@@ -459,42 +460,36 @@ describe("older layout: committed custom skills the seeding displaced come back"
 		expect(again.problems).toEqual([]);
 	});
 
-	test("review 3b: a magus-installed folder someone committed is refused before the reconcile writes anything", async () => {
+	test("B7 review: a magus-installed folder someone committed is handed back to the team — kept, never warned about", async () => {
 		await start();
 		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);
-		// A teammate drops alpha from the profile: the next reconcile would
-		// remove the folder, after recording the change in the marker.
+		expect(await trackedGeneratedWarnings(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();
 		(pulled.profiles.team as { skills: ProfileSkillRef[] }).skills = [];
 		await writeManifest(pulled, project);
-		const marker = await fs.readFile(
-			join(project, ".claude", "profiles", "active.json"),
-			"utf8",
-		);
-		const manifestBytes = await fs.readFile(
-			join(project, ".claude", "profiles.json"),
-			"utf8",
-		);
 
 		const prep = await prepareProfileState(project, {
 			installSkill: fakeInstall,
 		});
 
-		expect(prep.problems[0]).toContain(
-			"git rm --cached -r .claude/skills/alpha",
+		expect(prep.problems).toEqual([]);
+		expect(prep.lines).toContain(
+			"Skill alpha is committed by the team — magus no longer manages it",
 		);
 		expect(await fs.pathExists(skill("alpha"))).toBe(true);
+		expect((await readActiveMarker(project))?.skills).toEqual({});
 		expect(
-			await fs.readFile(
-				join(project, ".claude", "profiles", "active.json"),
-				"utf8",
-			),
-		).toBe(marker);
-		expect(
-			await fs.readFile(join(project, ".claude", "profiles.json"), "utf8"),
-		).toBe(manifestBytes);
+			git(project, "status", "--porcelain", "--", ".claude/skills").stdout,
+		).toBe("");
+		// Said once: the marker no longer records it.
+		const again = await prepareProfileState(project, {
+			installSkill: fakeInstall,
+		});
+		expect(again.lines.join("\n")).not.toContain("committed by the team");
 	});
 
 	test("an existing folder is never overwritten; a differing copy is reported with both paths", async () => {