magus-cli 7.6.0 → 7.7.0

package/src/__tests__/notices.test.tsx

@@ -0,0 +1,604 @@
+/**
+ * Spec "no confirmation screens in the magus TUI" — rules 1, 3, 4, 5: results become
+ * non-blocking notice lines instead of success modals.
+ *
+ * Written blind: from the spec and the exported signatures and types only
+ * (reducer actions NOTIFY / EXPIRE_NOTICES, `useNotify`, `NOTICE_DURATION_MS`, and the
+ * three pure wording functions). No implementation body was read.
+ *
+ * Coverage map (requirement → describe block):
+ *   REQ-3a notify adds a notice                         → "REQ-3 reducer"
+ *   REQ-3b same text replaces, never stacks             → "REQ-3 reducer"
+ *   REQ-3c at most MAX_NOTICES, newest kept             → "REQ-3 reducer"
+ *   REQ-3d expiry drops only expired notices            → "REQ-3 reducer"
+ *   REQ-3e warnings stay longer than successes          → "REQ-3 durations", "REQ-3 useNotify"
+ *   REQ-3f disappears by itself (no key)                → reducer expiry only (see below)
+ *   REQ-5a activation → `Using profile "<id>"`          → "REQ-5 activationNotices"
+ *   REQ-5b backup ("moved aside") lines dropped         → "REQ-5 activationNotices"
+ *   REQ-5c missing plugin → warning, short name, `magus install`, one line if several
+ *   REQ-4  wording: one line, no internals              → "REQ-4 wording"
+ *   REQ-1  gitignore fix / stale-load repair results are notices with a tone
+ *
+ * Not covered: rendering of NoticeBanner and "never takes keys" — the banner is not
+ * exported and is only reachable by rendering the whole App, which reads the machine's
+ * real plugin state. For the same reason the timer that dispatches EXPIRE_NOTICES is not
+ * exercised: the contract does not say which component owns it, and under AppProvider
+ * alone a success notice was still present after its duration.
+ *
+ * Rule 4 lets a notice name a file the user must act on. Untracking generated files
+ * leaves a staged removal the user has to commit, so the gitignore fix may name those
+ * files, and may word that line as a warning (rule 6: a result the user must act on).
+ */
+import { afterAll, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { testRender } from "@opentui/react/test-utils";
+import { act, useEffect } from "react";
+import type { StartupFixResult } from "../services/gitignore-service.js";
+import type { ActivationResult } from "../services/profile-activate.js";
+import { startupFixNotices } from "../ui/hooks/useGitignoreModal.js";
+import { activationNotices } from "../ui/hooks/useProfileStartupModal.js";
+import { staleLoadRepairNotices } from "../ui/hooks/useStaleLoadModal.js";
+import {
+	AppProvider,
+	NOTICE_DURATION_MS,
+	useApp,
+	useNotify,
+} from "../ui/state/AppContext.js";
+import { MAX_NOTICES, appReducer, initialState } from "../ui/state/reducer.js";
+import type {
+	AppState,
+	Notice,
+	NoticeLine,
+	NoticeTone,
+} from "../ui/state/types.js";
+
+// ---------------------------------------------------------------------------
+// Builders
+// ---------------------------------------------------------------------------
+
+let nextId = 1;
+function notice(
+	text: string,
+	tone: NoticeTone = "success",
+	expiresAt = 10_000,
+): Notice {
+	return { id: nextId++, text, tone, expiresAt };
+}
+
+function stateWith(notices: Notice[] = []): AppState {
+	return { ...initialState, notices };
+}
+
+function notify(state: AppState, n: Notice): AppState {
+	return appReducer(state, { type: "NOTIFY", notice: n });
+}
+
+function activation(
+	overrides: Partial<ActivationResult> = {},
+): ActivationResult {
+	return {
+		profileId: "magus-main",
+		displaced: [],
+		skills: { skills: {}, installed: [], removed: [], failed: [] },
+		conversion: {
+			converted: false,
+			managed: {},
+			restored: [],
+			conflicts: [],
+			keptAt: null,
+		},
+		tracked: [],
+		keptAt: null,
+		...overrides,
+	};
+}
+
+/** The spec's own example: a file moved aside into the backup folder. */
+const DISPLACED = [
+	{
+		link: ".claude/settings.json",
+		savedTo: ".claude/.magus-backups/2026-09-28T04-06-00-138Z/settings.json",
+	},
+];
+
+const FORBIDDEN = [
+	".magus-backups",
+	"plugin.json",
+	"settings.json",
+	"installed_plugins",
+	"registry",
+	"marker",
+];
+
+/** `allowed`: file names the user must act on, which rule 4 permits naming. */
+function expectUserTerms(
+	lines: readonly NoticeLine[],
+	allowed: readonly string[] = [],
+): void {
+	for (const line of lines) {
+		expect(line.text.length).toBeGreaterThan(0);
+		expect(line.text).not.toContain("\n");
+		expect(["success", "warning"]).toContain(line.tone);
+		for (const word of FORBIDDEN.filter((w) => !allowed.includes(w))) {
+			expect({ text: line.text, leaks: line.text.includes(word) }).toEqual({
+				text: line.text,
+				leaks: false,
+			});
+		}
+	}
+}
+
+// ---------------------------------------------------------------------------
+// REQ-3 reducer
+// ---------------------------------------------------------------------------
+
+describe("REQ-3 reducer: NOTIFY", () => {
+	test("REQ-3a adds the notice to an empty banner", () => {
+		const n = notice("Profile saved");
+
+		const next = notify(stateWith(), n);
+
+		expect(next.notices).toEqual([n]);
+	});
+
+	test("REQ-3a keeps earlier distinct notices, oldest first", () => {
+		const a = notice("first");
+		const b = notice("second", "warning");
+
+		const next = notify(notify(stateWith(), a), b);
+
+		expect(next.notices).toEqual([a, b]);
+	});
+
+	test("REQ-3b the same text replaces the earlier notice instead of stacking", () => {
+		const first = notice('Using profile "magus-main"', "success", 1_000);
+		const again = notice('Using profile "magus-main"', "success", 9_000);
+
+		const next = notify(notify(stateWith(), first), again);
+
+		expect(next.notices).toEqual([again]);
+	});
+
+	test("REQ-3b same text replaces while other notices stay", () => {
+		const other = notice("other");
+		const first = notice("repeat");
+		const again = notice("repeat", "warning", 20_000);
+
+		const next = notify(notify(notify(stateWith(), other), first), again);
+
+		expect(next.notices.filter((n) => n.text === "repeat")).toEqual([again]);
+		expect(next.notices.map((n) => n.text).sort()).toEqual(["other", "repeat"]);
+	});
+
+	test("REQ-3c MAX_NOTICES is 4", () => {
+		expect(MAX_NOTICES).toBe(4);
+	});
+
+	test("REQ-3c a fifth distinct notice drops the oldest one", () => {
+		const five = ["one", "two", "three", "four", "five"].map((t) => notice(t));
+
+		const next = five.reduce(notify, stateWith());
+
+		expect(next.notices).toEqual(five.slice(1));
+	});
+});
+
+describe("REQ-3 reducer: EXPIRE_NOTICES", () => {
+	test("REQ-3d removes only the notices whose time has passed", () => {
+		const expired = notice("old", "success", 1_000);
+		const live = notice("new", "warning", 5_000);
+
+		const next = appReducer(stateWith([expired, live]), {
+			type: "EXPIRE_NOTICES",
+			now: 3_000,
+		});
+
+		expect(next.notices).toEqual([live]);
+	});
+
+	test("REQ-3d removes every notice once all have expired", () => {
+		const next = appReducer(
+			stateWith([notice("a", "success", 1_000), notice("b", "warning", 2_000)]),
+			{ type: "EXPIRE_NOTICES", now: 50_000 },
+		);
+
+		expect(next.notices).toEqual([]);
+	});
+
+	test("REQ-3d returns the very same state object when nothing expired", () => {
+		const state = stateWith([notice("a", "success", 5_000)]);
+
+		const next = appReducer(state, { type: "EXPIRE_NOTICES", now: 1_000 });
+
+		expect(next).toBe(state);
+	});
+
+	test("REQ-3d returns the very same state object when there are no notices", () => {
+		const state = stateWith();
+
+		const next = appReducer(state, { type: "EXPIRE_NOTICES", now: 1_000 });
+
+		expect(next).toBe(state);
+	});
+});
+
+describe("REQ-3 durations", () => {
+	test("REQ-3e a warning stays visible longer than a success", () => {
+		expect(NOTICE_DURATION_MS.warning).toBeGreaterThan(
+			NOTICE_DURATION_MS.success,
+		);
+	});
+
+	test("REQ-3e a success disappears within a few seconds", () => {
+		expect(NOTICE_DURATION_MS.success).toBeGreaterThan(0);
+		expect(NOTICE_DURATION_MS.success).toBeLessThanOrEqual(10_000);
+	});
+
+	test("REQ-3e posted together, the success expires while the warning is still shown", () => {
+		const posted = 100_000;
+		const ok = notice("done", "success", posted + NOTICE_DURATION_MS.success);
+		const warn = notice(
+			"careful",
+			"warning",
+			posted + NOTICE_DURATION_MS.warning,
+		);
+
+		const next = appReducer(stateWith([ok, warn]), {
+			type: "EXPIRE_NOTICES",
+			now: posted + NOTICE_DURATION_MS.success + 1,
+		});
+
+		expect(next.notices).toEqual([warn]);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// REQ-3 useNotify, through the real provider
+// ---------------------------------------------------------------------------
+
+const scratch = mkdtempSync(path.join(tmpdir(), "magus-notices-"));
+afterAll(() => rmSync(scratch, { recursive: true, force: true }));
+
+interface Posted {
+	text: string;
+	tone?: NoticeTone;
+}
+
+/** Renders a provider whose child posts `posts` on mount; `seen()` reads the banner state. */
+async function withProvider(posts: Posted[]) {
+	let current: Notice[] = [];
+	let modal: unknown = "never rendered";
+	function Probe() {
+		const notifyFn = useNotify();
+		const { state } = useApp();
+		current = state.notices;
+		modal = state.modal;
+		useEffect(() => {
+			for (const p of posts) {
+				if (p.tone === undefined) notifyFn(p.text);
+				else notifyFn(p.text, p.tone);
+			}
+		}, [notifyFn, posts]);
+		return <text>probe</text>;
+	}
+	const before = Date.now();
+	const { renderOnce, renderer } = await testRender(
+		<AppProvider initialProjectPath={scratch}>
+			<Probe />
+		</AppProvider>,
+		{ width: 40, height: 5 },
+	);
+	await act(async () => {
+		await renderOnce();
+		await renderOnce();
+	});
+	const after = Date.now();
+	return {
+		before,
+		after,
+		seen: () => current,
+		modal: () => modal,
+		destroy: () => act(async () => renderer.destroy()),
+	};
+}
+
+describe("REQ-3 useNotify", () => {
+	test("REQ-3a notify without a tone posts a success that expires after the success duration", async () => {
+		const h = await withProvider([{ text: "Plugin updated" }]);
+
+		const seen = h.seen();
+		await h.destroy();
+
+		expect(seen.map((n) => ({ text: n.text, tone: n.tone }))).toEqual([
+			{ text: "Plugin updated", tone: "success" },
+		]);
+		expect(seen[0].expiresAt).toBeGreaterThanOrEqual(
+			h.before + NOTICE_DURATION_MS.success,
+		);
+		expect(seen[0].expiresAt).toBeLessThanOrEqual(
+			h.after + NOTICE_DURATION_MS.success,
+		);
+	});
+
+	test("REQ-3e a warning notice expires after the longer warning duration", async () => {
+		const h = await withProvider([
+			{ text: "typescript-lsp isn't downloaded yet", tone: "warning" },
+		]);
+
+		const seen = h.seen();
+		await h.destroy();
+
+		expect(seen).toHaveLength(1);
+		expect(seen[0].tone).toBe("warning");
+		expect(seen[0].expiresAt).toBeGreaterThanOrEqual(
+			h.before + NOTICE_DURATION_MS.warning,
+		);
+		expect(seen[0].expiresAt).toBeLessThanOrEqual(
+			h.after + NOTICE_DURATION_MS.warning,
+		);
+	});
+
+	test("REQ-3b notifying the same text twice shows it once", async () => {
+		const h = await withProvider([{ text: "Saved" }, { text: "Saved" }]);
+
+		const seen = h.seen();
+		await h.destroy();
+
+		expect(seen.map((n) => n.text)).toEqual(["Saved"]);
+	});
+
+	test("REQ-3 a notice never occupies the modal slot", async () => {
+		const h = await withProvider([{ text: "Done", tone: "warning" }]);
+
+		const seen = h.seen();
+		const modal = h.modal();
+		await h.destroy();
+
+		expect(seen).toHaveLength(1);
+		expect(modal).toBeNull();
+	});
+});
+
+// ---------------------------------------------------------------------------
+// REQ-5 activationNotices
+// ---------------------------------------------------------------------------
+
+describe("REQ-5 activationNotices", () => {
+	test('REQ-5a a clean activation of magus-main is one success line: Using profile "magus-main"', () => {
+		const lines = activationNotices(activation());
+
+		expect(lines).toHaveLength(1);
+		expect(lines[0].tone).toBe("success");
+		expect(lines[0].text).toContain('Using profile "magus-main"');
+	});
+
+	test("REQ-5a the success line names the activated profile, whatever it is", () => {
+		const lines = activationNotices(activation({ profileId: "frontend" }));
+
+		const success = lines.filter((l) => l.tone === "success");
+		expect(
+			success.some((l) => l.text.includes('Using profile "frontend"')),
+		).toBe(true);
+		expect(lines.some((l) => l.text.includes("magus-main"))).toBe(false);
+	});
+
+	test("REQ-5b files moved aside at activation add nothing to the notices", () => {
+		const clean = activationNotices(activation());
+
+		const withBackup = activationNotices(activation({ displaced: DISPLACED }));
+
+		expect(withBackup).toEqual(clean);
+		for (const line of withBackup) {
+			expect(line.text).not.toContain(".magus-backups");
+			expect(line.text.toLowerCase()).not.toContain("moved aside");
+		}
+	});
+
+	test("REQ-5c a plugin whose details are missing is a warning naming its short name and magus install", () => {
+		const lines = activationNotices(
+			activation({
+				dependencies: {
+					derived: [],
+					unreadable: ["typescript-lsp@claude-plugins-official"],
+					blocked: [],
+				},
+			}),
+		);
+
+		const warnings = lines.filter((l) => l.tone === "warning");
+		expect(warnings).toHaveLength(1);
+		expect(warnings[0].text).toContain("typescript-lsp");
+		expect(warnings[0].text).toContain("magus install");
+		expect(warnings[0].text).not.toContain("@claude-plugins-official");
+		expect(warnings[0].text).not.toContain("plugin.json");
+	});
+
+	test("REQ-5c a missing plugin still reports the profile as in use", () => {
+		const lines = activationNotices(
+			activation({
+				dependencies: {
+					derived: [],
+					unreadable: ["typescript-lsp@claude-plugins-official"],
+					blocked: [],
+				},
+			}),
+		);
+
+		expect(
+			lines.some(
+				(l) =>
+					l.tone === "success" && l.text.includes('Using profile "magus-main"'),
+			),
+		).toBe(true);
+	});
+
+	test("REQ-5c several missing plugins combine into one warning line naming each", () => {
+		const lines = activationNotices(
+			activation({
+				dependencies: {
+					derived: [],
+					unreadable: [
+						"typescript-lsp@claude-plugins-official",
+						"gopls-lsp@claude-plugins-official",
+						"code-search@magus",
+					],
+					blocked: [],
+				},
+			}),
+		);
+
+		const install = lines.filter((l) => l.text.includes("magus install"));
+		expect(install).toHaveLength(1);
+		expect(install[0].tone).toBe("warning");
+		for (const name of ["typescript-lsp", "gopls-lsp", "code-search"]) {
+			expect(install[0].text).toContain(name);
+		}
+		expect(install[0].text).not.toContain("@claude-plugins-official");
+		expect(install[0].text).not.toContain("@magus");
+	});
+});
+
+// ---------------------------------------------------------------------------
+// REQ-1 result notices for the gitignore fix and the stale-load repair
+// ---------------------------------------------------------------------------
+
+describe("REQ-1 startupFixNotices", () => {
+	test("REQ-1 adding missing ignore entries, with nothing to commit, yields success notices only", () => {
+		const lines = startupFixNotices({
+			untracked: [],
+			appended: [".claude/settings.json", ".mcp.json"],
+			failed: [],
+		});
+
+		expect(lines.length).toBeGreaterThan(0);
+		expect(lines.every((l) => l.tone === "success")).toBe(true);
+	});
+
+	test("REQ-1 untracking generated files yields at least one notice", () => {
+		const lines = startupFixNotices({
+			untracked: [".claude/settings.json", ".mcp.json"],
+			appended: [".claude/settings.json", ".mcp.json"],
+			failed: [],
+		});
+
+		expect(lines.length).toBeGreaterThan(0);
+	});
+
+	test("REQ-1 a fix with a file that could not be untracked yields a warning", () => {
+		const lines = startupFixNotices({
+			untracked: [".claude/settings.json"],
+			appended: [],
+			failed: [{ path: ".mcp.json", reason: "pathspec did not match" }],
+		});
+
+		expect(lines.some((l) => l.tone === "warning")).toBe(true);
+	});
+});
+
+describe("REQ-1 staleLoadRepairNotices", () => {
+	test("REQ-1 every repair succeeding yields success notices only", () => {
+		const lines = staleLoadRepairNotices([
+			{ pluginId: "code-search@magus", target: "2.3.0", ok: true },
+			{ pluginId: "dev@magus", target: "3.1.0", ok: true },
+		]);
+
+		expect(lines.length).toBeGreaterThan(0);
+		expect(lines.every((l) => l.tone === "success")).toBe(true);
+	});
+
+	test("REQ-1 a repair that failed yields a warning", () => {
+		const lines = staleLoadRepairNotices([
+			{ pluginId: "code-search@magus", target: "2.3.0", ok: true },
+			{
+				pluginId: "dev@magus",
+				target: "3.1.0",
+				ok: false,
+				error: "permission denied",
+			},
+		]);
+
+		expect(lines.some((l) => l.tone === "warning")).toBe(true);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// REQ-4 wording: one line, the user's terms, no internals
+// ---------------------------------------------------------------------------
+
+describe("REQ-4 wording", () => {
+	test("REQ-4 activationNotices never names backups, plugin.json, settings.json, the registry or the marker", () => {
+		const lines = activationNotices(
+			activation({
+				displaced: DISPLACED,
+				keptAt: ".claude/.magus-backups/2026-09-28T04-06-00-138Z/_profiles",
+				skills: {
+					skills: { "api-design": "abc123" },
+					installed: ["api-design"],
+					removed: ["old-skill"],
+					failed: [{ skill: "broken-skill", reason: "download failed" }],
+				},
+				conversion: {
+					converted: true,
+					managed: { "api-design": "abc123" },
+					restored: ["my-custom-skill"],
+					conflicts: [
+						{ folder: "dup-skill", kept: "dup-skill", other: "dup-skill-2" },
+					],
+					keptAt: ".claude/.magus-backups/2026-09-28T04-06-00-138Z/_profiles",
+				},
+				absorbed: ["Added the plugin dev@magus"],
+				dependencies: {
+					derived: ["claudish@magus"],
+					unreadable: ["typescript-lsp@claude-plugins-official"],
+					blocked: [
+						{ plugin: "multimodel@magus", dependency: "claudish@magus" },
+					],
+				},
+				committedSkills: ["team-skill"],
+				releasedCommitted: ["shared-skill"],
+			}),
+		);
+
+		expect(lines.length).toBeGreaterThan(0);
+		expectUserTerms(lines);
+	});
+
+	test("REQ-4 startupFixNotices for added ignore entries names no file and no internals", () => {
+		const lines = startupFixNotices({
+			untracked: [],
+			appended: [".claude/settings.json", ".claude/settings.local.json"],
+			failed: [],
+		});
+
+		expect(lines.length).toBeGreaterThan(0);
+		expectUserTerms(lines);
+	});
+
+	test("REQ-4 startupFixNotices never names backups, plugin.json, the registry or the marker, even when files must be committed", () => {
+		const lines = startupFixNotices({
+			untracked: [".claude/settings.json", ".claude/settings.local.json"],
+			appended: [".claude/settings.json"],
+			failed: [{ path: ".mcp.json", reason: "pathspec did not match" }],
+		});
+
+		expect(lines.length).toBeGreaterThan(0);
+		expectUserTerms(lines, ["settings.json"]);
+	});
+
+	test("REQ-4 staleLoadRepairNotices never names settings.json, plugin.json, backups, the registry or the marker", () => {
+		const lines = staleLoadRepairNotices([
+			{ pluginId: "code-search@magus", target: "2.3.0", ok: true },
+			{
+				pluginId: "dev@magus",
+				target: "3.1.0",
+				ok: false,
+				error: "permission denied",
+			},
+		]);
+
+		expect(lines.length).toBeGreaterThan(0);
+		expectUserTerms(lines);
+	});
+});

package/src/__tests__/update-apply.test.ts

@@ -789,11 +789,11 @@ describe("applyPlugins — read-back against beforeVersions", () => {
 			reasons.reporter,
 		);
 		expect(result.unchanged).toEqual(["dev@magus"]);
-		expect(reasons.lines(result.unchanged)).toBe(
+		expect(reasons.lines(result.unchanged)).toEqual([
 			"dev@magus: the installer exited 0 but dev@magus is still 1.0.0",
-		);
+		]);
 		// An item with no recorded cause still gets a line.
-		expect(reasons.lines(["other@magus"])).toBe("other@magus");
+		expect(reasons.lines(["other@magus"])).toEqual(["other@magus"]);
 	});
 });
 

package/src/__tests__/useStaleLoadModal.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from "bun:test";
 import {
 	buildStaleLoadModal,
-	staleLoadRepairSummary,
+	staleLoadRepairNotices,
 } from "../ui/hooks/useStaleLoadModal";
 
 /**
@@ -138,19 +138,24 @@ describe("buildStaleLoadModal", () => {
 	});
 });
 
-describe("staleLoadRepairSummary", () => {
-	it("says what loads NOW for each repaired plugin", () => {
+describe("staleLoadRepairNotices", () => {
+	it("says what loads NOW for the repaired plugins, in one line", () => {
 		expect(
-			staleLoadRepairSummary([
+			staleLoadRepairNotices([
 				{ pluginId: "madbench@magus", target: "0.5.0", ok: true },
 				{ pluginId: "dev@magus", target: "7.4.0", ok: true },
 			]),
-		).toBe("✓ madbench@magus now loads v0.5.0\n✓ dev@magus now loads v7.4.0");
+		).toEqual([
+			{
+				text: "Now loading madbench@magus v0.5.0, dev@magus v7.4.0",
+				tone: "success",
+			},
+		]);
 	});
 
 	it("reports a failed repair with its own reason, never as a success", () => {
 		expect(
-			staleLoadRepairSummary([
+			staleLoadRepairNotices([
 				{
 					pluginId: "madbench@magus",
 					target: "0.5.0",
@@ -158,20 +163,30 @@ describe("staleLoadRepairSummary", () => {
 					error: "the loader still resolves v0.3.0 here, not v0.5.0",
 				},
 			]),
-		).toBe(
-			"✗ madbench@magus — the loader still resolves v0.3.0 here, not v0.5.0",
-		);
+		).toEqual([
+			{
+				text: "madbench@magus not repaired: the loader still resolves v0.3.0 here, not v0.5.0",
+				tone: "warning",
+			},
+		]);
 	});
 
 	it("falls back to a plain reason rather than an empty line", () => {
 		expect(
-			staleLoadRepairSummary([
+			staleLoadRepairNotices([
 				{ pluginId: "a@magus", target: "1.0.0", ok: false },
 			]),
-		).toBe("✗ a@magus — repair did not take effect");
+		).toEqual([
+			{
+				text: "a@magus not repaired: repair did not take effect",
+				tone: "warning",
+			},
+		]);
 	});
 
 	it("says so when there was nothing to repair", () => {
-		expect(staleLoadRepairSummary([])).toBe("Nothing to repair.");
+		expect(staleLoadRepairNotices([])).toEqual([
+			{ text: "Nothing needed repairing", tone: "success" },
+		]);
 	});
 });