magus-cli 7.5.4 → 7.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magus-cli",
-  "version": "7.5.4",
+  "version": "7.7.0",
   "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.4",
-    "magus-cli-darwin-x64": "7.5.4",
-    "magus-cli-linux-x64": "7.5.4"
+    "magus-cli-darwin-arm64": "7.7.0",
+    "magus-cli-darwin-x64": "7.7.0",
+    "magus-cli-linux-x64": "7.7.0"
   }
 }

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

@@ -87,7 +87,7 @@ describe("REQ-12 formatUpdateOutcome: what the TUI shows after Update it now", (
 		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', () => {
+	test('REQ-12c no problems, state ok and a notice gives "updated" with one notice line, not the gate\'s working log', () => {
 		const result: ProfileStartup = {
 			need: needIn("ok"),
 			notices: ["absorbed 1 edit"],
@@ -98,12 +98,11 @@ describe("REQ-12 formatUpdateOutcome: what the TUI shows after Update it now", (
 
 		expect(outcome).toEqual({
 			kind: "updated",
-			title: "Profile format updated",
-			message: expect.stringContaining("absorbed 1 edit"),
+			notice: "Profile format updated",
 		});
 	});
 
-	test('REQ-12d no problems, state ok and no notices gives "updated" with the fixed current-format message', () => {
+	test('REQ-12d no problems, state ok and no notices gives the same "updated" notice', () => {
 		const result: ProfileStartup = {
 			need: needIn("ok"),
 			notices: [],
@@ -114,8 +113,7 @@ describe("REQ-12 formatUpdateOutcome: what the TUI shows after Update it now", (
 
 		expect(outcome).toEqual({
 			kind: "updated",
-			title: expect.any(String),
-			message: "This project now uses the current profile format.",
+			notice: "Profile format updated",
 		});
 	});
 });
@@ -156,7 +154,9 @@ try {
 	out.outcome =
 		outcome.kind === "ask"
 			? { kind: "ask", needState: outcome.need.state }
-			: { kind: outcome.kind, title: outcome.title, message: outcome.message };
+			: outcome.kind === "updated"
+				? { kind: "updated", notice: outcome.notice }
+				: { kind: outcome.kind, title: outcome.title, message: outcome.message };
 } catch (e) {
 	out.error = e instanceof Error ? (e.stack ?? e.message) : String(e);
 }
@@ -171,7 +171,8 @@ interface StartupRun {
 	problems: string[] | null;
 	outcome:
 		| { kind: "ask"; needState: ProfileStartupState }
-		| { kind: "updated" | "failed"; title: string; message: string }
+		| { kind: "updated"; notice: string }
+		| { kind: "failed"; title: string; message: string }
 		| null;
 	error: string | null;
 }

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

@@ -17,7 +17,6 @@ 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";
@@ -32,7 +31,10 @@ import {
 	prepareProfileState,
 } from "../services/profile-state.js";
 import type { ProfileManifest } from "../types/index.js";
-import { buildGitignoreModal } from "../ui/hooks/useGitignoreModal.js";
+import {
+	buildGitignoreModal,
+	startupFixNotices,
+} from "../ui/hooks/useGitignoreModal.js";
 
 const MANIFEST: ProfileManifest = {
 	version: 2,
@@ -153,9 +155,11 @@ describe("the startup fix untracks generated files in place", () => {
 		expect(await fs.readFile(join(project, ".gitignore"), "utf8")).toContain(
 			".claude/settings.json",
 		);
-		expect(describeStartupFix(result)).toContain(
-			"Stopped tracking (the removal is staged — commit it):",
-		);
+		// Untracking is unfinished until the user commits, so it is a warning.
+		expect(startupFixNotices(result)).toContainEqual({
+			text: "Stopped tracking .claude/settings.json — commit the staged removal",
+			tone: "warning",
+		});
 		// Asked again on the next open: nothing generated is tracked any more.
 		expect((await startupGitignoreNeed(project))?.generated ?? []).toEqual([]);
 	});

package/src/__tests__/key-focus-guard.test.tsx

@@ -0,0 +1,260 @@
+/**
+ * Key focus rule: "A key goes only to the input that had focus when the key was
+ * pressed."
+ *
+ * Written blind — from the spec and the exported signatures of KeyRouter,
+ * AppProvider/useModal, DimensionsProvider and ModalContainer only. The real
+ * providers and the real ModalContainer are mounted; keys are sent through the
+ * test renderer's mock keyboard, and the outcome is read from what the user
+ * sees (the frame) and what the caller receives (onSubmit).
+ *
+ * REQ-A1  a select modal's onSelect opens an input modal in the same Enter:
+ *         that Enter shows the input and does NOT submit it.
+ * REQ-A2  the next Enter submits the input's default value ("default-2").
+ * REQ-A3  keys typed after the input opened do reach it.
+ * REQ-A4  an input modal that was already open receives typed text: "abc" +
+ *         Enter submits "abc".
+ * REQ-A5  a screen-level key that opens an input modal is not typed into it:
+ *         the default value is unchanged after the key.
+ */
+import { afterEach, describe, expect, mock, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { testRender } from "@opentui/react/test-utils";
+import { act } from "react";
+import { ModalContainer } from "../ui/components/modals/ModalContainer.js";
+import { KeyRouter, useKeyLayer } from "../ui/input/KeyRouter.js";
+import { AppProvider, useModal } from "../ui/state/AppContext.js";
+import { DimensionsProvider } from "../ui/state/DimensionsContext.js";
+import type { ModalState } from "../ui/state/types.js";
+
+type ModalApi = ReturnType<typeof useModal>;
+
+const SELECT_TITLE = "Pick a setup";
+const INPUT_TITLE = "Name the new profile";
+const INPUT_LABEL = "Profile name";
+
+let cleanup: Array<() => Promise<void> | void> = [];
+
+afterEach(async () => {
+	for (const fn of cleanup.reverse()) await fn();
+	cleanup = [];
+});
+
+interface Mounted {
+	modal: () => ModalApi;
+	frame: () => Promise<string>;
+	/** Run input actions, then let React and the renderer settle. */
+	send: (fn: () => void | Promise<void>) => Promise<void>;
+	mockInput: Awaited<ReturnType<typeof testRender>>["mockInput"];
+}
+
+/** A screen that opens an input modal on its own key `e`. */
+function ScreenWithKey({
+	onKey,
+}: {
+	onKey: () => void;
+}) {
+	useKeyLayer("screen", true, (key) => {
+		if (key.name === "e" && !key.ctrl && !key.meta) {
+			onKey();
+			return true;
+		}
+		return false;
+	});
+	return <text>screen body</text>;
+}
+
+async function mount(
+	opts: { screenKey?: (modal: ModalApi) => void } = {},
+): Promise<Mounted> {
+	// A throwaway project path: nothing here reads or writes a real project.
+	const project = mkdtempSync(join(tmpdir(), "key-focus-guard-"));
+	cleanup.push(() => rmSync(project, { recursive: true, force: true }));
+
+	let api: ModalApi | null = null;
+	function Harness() {
+		const modal = useModal();
+		api = modal;
+		return (
+			<box flexDirection="column" width="100%" height="100%">
+				{opts.screenKey ? (
+					<ScreenWithKey onKey={() => opts.screenKey?.(modal)} />
+				) : (
+					<text>screen body</text>
+				)}
+				<ModalContainer />
+			</box>
+		);
+	}
+
+	const { renderer, mockInput, renderOnce, captureCharFrame } =
+		await testRender(
+			<AppProvider initialProjectPath={project}>
+				<DimensionsProvider>
+					<KeyRouter>
+						<Harness />
+					</KeyRouter>
+				</DimensionsProvider>
+			</AppProvider>,
+			{ width: 100, height: 30 },
+		);
+	cleanup.push(async () => {
+		await act(async () => renderer.destroy());
+	});
+
+	const settle = async () => {
+		for (let i = 0; i < 3; i++) {
+			await new Promise((r) => setTimeout(r, 10));
+			await renderOnce();
+		}
+	};
+	await act(settle);
+
+	return {
+		mockInput,
+		modal: () => {
+			if (!api) throw new Error("useModal was never reached");
+			return api;
+		},
+		frame: async () => {
+			await act(settle);
+			return captureCharFrame();
+		},
+		send: async (fn) => {
+			await act(async () => {
+				await fn();
+				await settle();
+			});
+		},
+	};
+}
+
+function inputModal(
+	defaultValue: string | undefined,
+	onSubmit: (value: string) => void,
+): ModalState {
+	return {
+		type: "input",
+		title: INPUT_TITLE,
+		label: INPUT_LABEL,
+		...(defaultValue !== undefined ? { defaultValue } : {}),
+		onSubmit,
+		onCancel: () => {},
+	};
+}
+
+/** Open a select whose onSelect opens the input modal, in the same handler. */
+async function openSelectThatOpensInput(
+	m: Mounted,
+	onSelect: (value: string) => void,
+	onSubmit: (value: string) => void,
+): Promise<void> {
+	await m.send(() => {
+		m.modal().showModal({
+			type: "select",
+			title: SELECT_TITLE,
+			message: "Which setup should this project start from?",
+			options: [
+				{ label: "Default setup", value: "default" },
+				{ label: "Empty setup", value: "empty" },
+			],
+			defaultIndex: 0,
+			onSelect: (value) => {
+				onSelect(value);
+				m.modal().showModal(inputModal("default-2", onSubmit));
+			},
+			onCancel: () => {},
+		});
+	});
+	const frame = await m.frame();
+	// Precondition: the select is on screen, the input is not.
+	expect(frame).toContain(SELECT_TITLE);
+	expect(frame).not.toContain(INPUT_TITLE);
+}
+
+describe("key focus: a key goes only to the input that had focus when it was pressed", () => {
+	test("REQ-A1 one Enter on a select whose onSelect opens an input shows the input and does not submit it", async () => {
+		const m = await mount();
+		const onSelect = mock((_v: string) => {});
+		const onSubmit = mock((_v: string) => {});
+		await openSelectThatOpensInput(m, onSelect, onSubmit);
+
+		await m.send(() => m.mockInput.pressEnter());
+
+		expect(onSelect).toHaveBeenCalledTimes(1);
+		expect(onSelect).toHaveBeenCalledWith("default");
+		const frame = await m.frame();
+		expect(frame).toContain(INPUT_TITLE);
+		expect(frame).toContain("default-2");
+		expect(onSubmit).not.toHaveBeenCalled();
+	});
+
+	test('REQ-A2 a second Enter submits the input\'s default value "default-2"', async () => {
+		const m = await mount();
+		const onSubmit = mock((_v: string) => {});
+		await openSelectThatOpensInput(m, () => {}, onSubmit);
+
+		await m.send(() => m.mockInput.pressEnter());
+		expect(onSubmit).not.toHaveBeenCalled();
+
+		await m.send(() => m.mockInput.pressEnter());
+		expect(onSubmit).toHaveBeenCalledTimes(1);
+		expect(onSubmit).toHaveBeenCalledWith("default-2");
+	});
+
+	test('REQ-A3 keys typed after the input opened reach it: "x" then Enter submits "default-2x"', async () => {
+		const m = await mount();
+		const onSubmit = mock((_v: string) => {});
+		await openSelectThatOpensInput(m, () => {}, onSubmit);
+
+		await m.send(() => m.mockInput.pressEnter());
+		await m.send(() => m.mockInput.typeText("x"));
+		expect(await m.frame()).toContain("default-2x");
+
+		await m.send(() => m.mockInput.pressEnter());
+		expect(onSubmit).toHaveBeenCalledTimes(1);
+		expect(onSubmit).toHaveBeenCalledWith("default-2x");
+	});
+
+	test('REQ-A4 an input modal that was already open receives typing: "abc" then Enter submits "abc"', async () => {
+		const m = await mount();
+		const onSubmit = mock((_v: string) => {});
+		await m.send(() => m.modal().showModal(inputModal(undefined, onSubmit)));
+		expect(await m.frame()).toContain(INPUT_TITLE);
+
+		await m.send(() => m.mockInput.typeText("abc"));
+		expect(await m.frame()).toContain("abc");
+		expect(onSubmit).not.toHaveBeenCalled();
+
+		await m.send(() => m.mockInput.pressEnter());
+		expect(onSubmit).toHaveBeenCalledTimes(1);
+		expect(onSubmit).toHaveBeenCalledWith("abc");
+	});
+
+	test('REQ-A5 a screen key that opens an input modal is not typed into it: default "cfg" stays "cfg"', async () => {
+		const onSubmit = mock((_v: string) => {});
+		const opened = mock(() => {});
+		const m = await mount({
+			screenKey: (modal) => {
+				opened();
+				modal.showModal(inputModal("cfg", onSubmit));
+			},
+		});
+		expect(await m.frame()).not.toContain(INPUT_TITLE);
+
+		await m.send(() => m.mockInput.pressKey("e"));
+
+		expect(opened).toHaveBeenCalledTimes(1);
+		const frame = await m.frame();
+		expect(frame).toContain(INPUT_TITLE);
+		expect(frame).toContain("cfg");
+		expect(frame).not.toContain("cfge");
+		expect(onSubmit).not.toHaveBeenCalled();
+
+		await m.send(() => m.mockInput.pressEnter());
+		expect(onSubmit).toHaveBeenCalledTimes(1);
+		expect(onSubmit).toHaveBeenCalledWith("cfg");
+	});
+});