magus-cli 7.5.4 → 7.7.0

package/src/ui/hooks/useGitignoreModal.ts

@@ -1,6 +1,7 @@
 import { useCallback } from "react";
-import { useApp, useNavigation } from "../state/AppContext.js";
-import type { ModalState } from "../state/types.js";
+import type { StartupFixResult } from "../../services/gitignore-service.js";
+import { useApp, useNavigation, useNotify } from "../state/AppContext.js";
+import type { ModalState, NoticeLine } from "../state/types.js";
 
 /**
  * Startup gitignore-violation modal: magus launches, detects a problem, and
@@ -79,17 +80,49 @@ export function buildGitignoreModal(args: BuildModalArgs): ModalState {
 	};
 }
 
+/**
+ * What the startup fix did, as notices. Untracking is a warning because it is
+ * not finished until the user commits the staged removal — the one thing here
+ * they must still do. The files are named only there, and in a failure, which
+ * the user has to deal with by hand.
+ */
+export function startupFixNotices(result: StartupFixResult): NoticeLine[] {
+	const lines: NoticeLine[] = [];
+	if (result.untracked.length > 0) {
+		lines.push({
+			text: `Stopped tracking ${result.untracked.join(", ")} — commit the staged removal`,
+			tone: "warning",
+		});
+	}
+	if (result.appended.length > 0) {
+		lines.push({
+			text: `Added ${entries(result.appended.length)}`,
+			tone: "success",
+		});
+	}
+	for (const f of result.failed) {
+		lines.push({
+			text: `Could not stop tracking ${f.path}: ${f.reason}`,
+			tone: "warning",
+		});
+	}
+	return lines.length > 0
+		? lines
+		: [{ text: "Gitignore already up to date", tone: "success" }];
+}
+
 export function useGitignoreModal() {
 	const { dispatch } = useApp();
 	const { navigateToScreen } = useNavigation();
+	const notify = useNotify();
 
 	const show = useCallback(
 		(args: {
 			violationCount: number;
 			safeCount: number;
 			generated?: readonly string[];
-			/** Returns what it did, shown before returning to the app. */
-			onFixSafe: () => Promise<string | undefined> | string | undefined;
+			/** Returns what it did, reported as notices once the fix settles. */
+			onFixSafe: () => Promise<readonly NoticeLine[]> | readonly NoticeLine[];
 		}) => {
 			if (args.violationCount === 0) return;
 			const dismiss = () => dispatch({ type: "HIDE_MODAL" });
@@ -98,20 +131,27 @@ export function useGitignoreModal() {
 				safeCount: args.safeCount,
 				generated: args.generated,
 				onFixSafe: () => {
-					dispatch({ type: "HIDE_MODAL" });
-					void Promise.resolve(args.onFixSafe())
+					// A loading modal, NOT HIDE_MODAL. The fix is async, and an empty
+					// modal slot is App's signal that the next startup question may be
+					// asked: hiding here let the profile question show during the await,
+					// be marked as asked, and then be replaced by the fix's result —
+					// lost for the whole session. The slot stays occupied until the
+					// fix settles.
+					dispatch({
+						type: "SHOW_MODAL",
+						modal: { type: "loading", message: "Fixing gitignore…" },
+					});
+					// Called inside `.then`, not passed to `Promise.resolve`: a fixer
+					// that throws synchronously must land in `.catch` below too, or
+					// the loading modal above stays up and swallows every key.
+					void Promise.resolve()
+						.then(() => args.onFixSafe())
 						.then((report) => {
-							if (!report) return;
-							dispatch({
-								type: "SHOW_MODAL",
-								modal: {
-									type: "message",
-									title: "Gitignore fixed",
-									message: report,
-									variant: "success",
-									onDismiss: dismiss,
-								},
-							});
+							// The loading modal must go — it swallows every key — and the
+							// result goes to the notice banner, which is outside the modal
+							// slot, so the next startup question can take the slot now.
+							dispatch({ type: "HIDE_MODAL" });
+							for (const line of report) notify(line.text, line.tone);
 						})
 						.catch((err) => {
 							dispatch({
@@ -134,7 +174,7 @@ export function useGitignoreModal() {
 			});
 			dispatch({ type: "SHOW_MODAL", modal });
 		},
-		[dispatch, navigateToScreen],
+		[dispatch, navigateToScreen, notify],
 	);
 
 	return { show };

package/src/ui/hooks/useProfileStartupModal.ts

@@ -15,12 +15,11 @@
  * leave, which is why it needs the app's own exit.
  */
 
-import { useCallback } from "react";
+import { useCallback, useRef } from "react";
 import { getManifestPath } from "../../services/manifest.js";
-import {
-	type ActivationResult,
-	type ProfileChoice,
-	activationNotes,
+import type {
+	ActivationResult,
+	ProfileChoice,
 } from "../../services/profile-activate.js";
 import type { DisplacedArtifact } from "../../services/profile-live.js";
 import {
@@ -32,12 +31,13 @@ import {
 	formatUpdateOutcome,
 	parseProfileChoice,
 	prepareProfileStartup,
+	profileIdForName,
 	unparseableNeed,
 } from "../../services/profile-startup.js";
 import { applyProfileChoice } from "../../services/profile-state.js";
 import { SettingsParseError } from "../../services/settings-file.js";
-import { useApp, useNavigation } from "../state/AppContext.js";
-import type { ModalState } from "../state/types.js";
+import { useApp, useNotify } from "../state/AppContext.js";
+import type { ModalState, NoticeLine } from "../state/types.js";
 
 export interface BuildProfileModalArgs {
 	need: ProfileStartupNeed;
@@ -84,38 +84,79 @@ export function buildProfileStartupModal(
 	};
 }
 
-/** What changed, phrased for a message modal rather than a terminal. */
-export function describeOutcome(
-	profileId: string,
-	displaced: DisplacedArtifact[],
-	projectPath: string,
-	/** True when this happened without asking, following the committed default. */
-	automatic = false,
-	/** Anything else activation reported (see `activationNotes`). */
-	notes: string[] = [],
-): string {
-	const lines = [
-		automatic
-			? `This project declares "${profileId}" as its profile, so magus activated it.`
-			: `"${profileId}" is now the active profile.`,
+/** `typescript-lsp@claude-plugins-official` → `typescript-lsp`. */
+function pluginName(pluginId: string): string {
+	const at = pluginId.lastIndexOf("@");
+	return at > 0 ? pluginId.slice(0, at) : pluginId;
+}
+
+/** "a", "a and b", "a, b and c". */
+function listed(names: readonly string[]): string {
+	if (names.length <= 1) return names.join("");
+	return `${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}`;
+}
+
+/**
+ * What an activation did, as notices — for the startup question and the
+ * Profiles tab alike: one line saying which profile is in use, then
+ * {@link activationWarnings}.
+ */
+export function activationNotices(result: ActivationResult): NoticeLine[] {
+	return [
+		{ text: `Using profile "${result.profileId}"`, tone: "success" },
+		...activationWarnings(result),
 	];
-	if (displaced.length > 0) {
-		lines.push(
-			"",
-			"These were moved aside to make room for the profile's files, and are kept:",
-			...displaced.map((d) => {
-				const from = d.link.startsWith(projectPath)
-					? d.link.slice(projectPath.length + 1)
-					: d.link;
-				const to = d.savedTo.startsWith(projectPath)
-					? d.savedTo.slice(projectPath.length + 1)
-					: d.savedTo;
-				return `  ${from} → ${to}`;
-			}),
-		);
+}
+
+/**
+ * What an activation left for the user to act on, one warning per thing, in
+ * user terms. Alone, without {@link activationNotices}' "Using profile" line,
+ * for an activation the user did not ask for — a re-render at startup, a
+ * profile format update — where which profile is in use is not news.
+ *
+ * Deliberately NOT {@link activationNotes}, which the CLI prints. Several of
+ * its lines are for a terminal log and would only be noise on this banner:
+ * where displaced files were backed up (the backup still happens; nobody needs
+ * to be told where), edits recorded into the profile being left (the switch
+ * confirmation already said so), skills handed back to the team. Tracked
+ * generated files are left out too: every activation signals
+ * PROFILE_ACTIVATED, and the app re-runs its gitignore check on it — the
+ * startup question and a Profiles-tab switch alike — which asks about exactly
+ * those files, with a way to fix them.
+ */
+export function activationWarnings(result: ActivationResult): NoticeLine[] {
+	const lines: NoticeLine[] = [];
+	const report = result.dependencies;
+	for (const { plugin, dependency } of report?.blocked ?? []) {
+		lines.push({
+			text: `${pluginName(plugin)} won't load: profile "${result.profileId}" turns off ${pluginName(dependency)}, which it needs`,
+			tone: "warning",
+		});
+	}
+	// The plugin's details are not on this machine yet, so what it depends on
+	// could not be enabled. One line for all of them: the fix is the same.
+	const missing = (report?.unreadable ?? []).map(pluginName);
+	if (missing.length > 0) {
+		lines.push({
+			text: `${listed(missing)} ${missing.length === 1 ? "isn't" : "aren't"} downloaded yet — run magus install`,
+			tone: "warning",
+		});
+	}
+	for (const f of result.skills.failed) {
+		lines.push({
+			text: `Skill "${f.skill}" could not be installed: ${f.reason}`,
+			tone: "warning",
+		});
 	}
-	if (notes.length > 0) lines.push("", ...notes);
-	return lines.join("\n");
+	// The one case that names a path: two copies of a skill, and which to keep
+	// is the user's call — they need to know where the other one is.
+	for (const c of result.conversion.conflicts) {
+		lines.push({
+			text: `Skill "${c.folder}" exists in two versions; kept ${c.kept}, the other is at ${c.other}`,
+			tone: "warning",
+		});
+	}
+	return lines;
 }
 
 /** Project-relative, so a path does not wrap over two lines. */
@@ -166,17 +207,71 @@ export function describeFailure(
 	].join("\n");
 }
 
-export function useProfileStartupModal(
-	onQuit: () => void,
-	/** Called once a choice has activated a profile — see App's gitignore re-check. */
-	onActivated?: () => void,
-) {
+export interface ProfileStartupModalCallbacks {
+	/** Leave magus: the modal's only non-action. */
+	onQuit: () => void;
+	/**
+	 * Called once a choice has activated a profile, or a format update has
+	 * rewritten it — the app dispatches PROFILE_ACTIVATED on it.
+	 */
+	onActivated?: () => void;
+	/**
+	 * The question is ANSWERED: a profile is active, or the user chose to quit.
+	 * Until this fires the caller must treat the question as outstanding and
+	 * call `show` again whenever the modal slot is empty — see `show`.
+	 */
+	onAnswered: () => void;
+}
+
+/**
+ * Where the profile question stands between `show` calls. `need` is the
+ * question on screen NOW, which is not always the one magus opened with: "Update
+ * it now" asks a new one, and a manifest that stopped parsing turns the question
+ * into the unparseable one. `working` is true while an activation or a format
+ * update is running — when it settles it empties the slot (success, reported as
+ * a notice) or puts its error modal there.
+ */
+interface ProfileFlow {
+	need: ProfileStartupNeed;
+	working: boolean;
+}
+
+export function useProfileStartupModal({
+	onQuit,
+	onActivated,
+	onAnswered,
+}: ProfileStartupModalCallbacks) {
 	const { state, dispatch } = useApp();
-	const { navigateToScreen } = useNavigation();
+	const notify = useNotify();
 	const projectPath = state.projectPath;
+	// A ref, not state: `show` is recreated on every render, and the flow must
+	// survive that — a re-show has to know what was last asked, and that work is
+	// in flight, without a render in between.
+	const flowRef = useRef<ProfileFlow | null>(null);
 
+	/**
+	 * Show the profile question, or put it back.
+	 *
+	 * The caller calls this again whenever the modal slot is empty and the
+	 * question is unanswered. The modal cannot be dismissed, so an empty slot
+	 * then means something else took the slot and closed it — a screen's
+	 * `confirm` resolving, say, before its loading modal lands. So a second call
+	 * re-asks the question that was on screen, and never re-runs an automatic
+	 * activation. While work is in flight it does nothing: that work puts its own
+	 * result up when it settles, and asking again meanwhile would let a second
+	 * choice race the first.
+	 */
 	const show = useCallback(
 		(need: ProfileStartupNeed) => {
+			const answered = (): void => {
+				flowRef.current = null;
+				onAnswered();
+			};
+			const quit = (): void => {
+				answered();
+				onQuit();
+			};
+
 			/**
 			 * Apply a choice, reporting the outcome either way. `current` is the
 			 * question it answers — after "Update it now" that is a NEW question,
@@ -184,16 +279,16 @@ export function useProfileStartupModal(
 			 */
 			const apply = (
 				choice: ProfileChoice,
-				automatic: boolean,
 				current: ProfileStartupNeed = need,
 			): void => {
+				flowRef.current = { need: current, working: true };
 				dispatch({
 					type: "SHOW_MODAL",
 					modal: {
 						type: "loading",
 						message:
 							choice.kind === "adopt"
-								? `Creating "${choice.id}"…`
+								? `Creating "${choice.name ?? choice.id}"…`
 								: `Activating ${choice.id}…`,
 					},
 				});
@@ -212,29 +307,19 @@ export function useProfileStartupModal(
 					onDisplace: (artifact) => moved.push(artifact),
 				})
 					.then((result: ActivationResult) => {
+						// Answered here, on success — NOT when the question was shown.
+						// Clearing it on show let a screen's modal replace it and the
+						// question never came back.
+						answered();
 						onActivated?.();
-						const { profileId, displaced } = result;
-						dispatch({
-							type: "SHOW_MODAL",
-							modal: {
-								type: "message",
-								title: "Profile active",
-								message: describeOutcome(
-									profileId,
-									displaced,
-									projectPath,
-									automatic,
-									activationNotes(result),
-								),
-								variant: "success",
-								onDismiss: () => {
-									dispatch({ type: "HIDE_MODAL" });
-									// The Profiles tab is where the result is visible, and
-									// where the user will want to look next.
-									navigateToScreen("profiles");
-								},
-							},
-						});
+						// No result modal and no jump to the Profiles tab: the user
+						// stays where they are, told in the notice banner. An automatic
+						// activation is reported the same way, so it is never
+						// invisible.
+						dispatch({ type: "HIDE_MODAL" });
+						for (const line of activationNotices(result)) {
+							notify(line.text, line.tone);
+						}
 					})
 					.catch((error: unknown) => {
 						// The manifest stopped parsing between launch and this answer —
@@ -246,6 +331,9 @@ export function useProfileStartupModal(
 							error.path === getManifestPath(projectPath)
 								? unparseableNeed(error)
 								: current;
+						// Still unanswered, and `next` is what a lost error modal
+						// returns to.
+						flowRef.current = { need: next, working: false };
 						dispatch({
 							type: "SHOW_MODAL",
 							modal: {
@@ -277,6 +365,7 @@ export function useProfileStartupModal(
 			 * say it is done.
 			 */
 			const updateFormat = (): void => {
+				flowRef.current = { need, working: true };
 				dispatch({
 					type: "SHOW_MODAL",
 					modal: { type: "loading", message: "Updating the profile format…" },
@@ -284,14 +373,30 @@ export function useProfileStartupModal(
 				void prepareProfileStartup(projectPath, { convert: true })
 					.then((result) => {
 						const outcome = formatUpdateOutcome(result);
+						// What the conversion's activation warns about — a plugin that
+						// will not load, one not downloaded yet, a skill that failed —
+						// in user terms. Posted whichever way it went, except a refusal,
+						// which converted nothing. Posting under the next question is
+						// safe: notices do not run down while a modal is open.
+						const warnings = (): void => {
+							for (const activation of result.activations) {
+								for (const line of activationWarnings(activation)) {
+									notify(line.text, line.tone);
+								}
+							}
+						};
 						if (outcome.kind === "ask") {
+							// Converted, but no profile is active yet: a new question,
+							// still unanswered.
 							onActivated?.();
 							ask(outcome.need);
+							warnings();
 							return;
 						}
 						if (outcome.kind === "failed") {
 							// Refused, so still the old format: back to the question,
 							// as the CLI stops on the same lines.
+							flowRef.current = { need, working: false };
 							dispatch({
 								type: "SHOW_MODAL",
 								modal: {
@@ -304,22 +409,15 @@ export function useProfileStartupModal(
 							});
 							return;
 						}
+						// Nothing left to ask: the converted profile is active.
+						answered();
 						onActivated?.();
-						dispatch({
-							type: "SHOW_MODAL",
-							modal: {
-								type: "message",
-								title: outcome.title,
-								message: outcome.message,
-								variant: "success",
-								onDismiss: () => {
-									dispatch({ type: "HIDE_MODAL" });
-									navigateToScreen("profiles");
-								},
-							},
-						});
+						dispatch({ type: "HIDE_MODAL" });
+						notify(outcome.notice);
+						warnings();
 					})
 					.catch((error: unknown) => {
+						flowRef.current = { need, working: false };
 						dispatch({
 							type: "SHOW_MODAL",
 							modal: {
@@ -333,29 +431,78 @@ export function useProfileStartupModal(
 					});
 			};
 
+			/**
+			 * "Save what you have" picked: ask what to call it, with the generated
+			 * id as the suggestion. An invalid name is explained above the field and
+			 * asked again with what was typed still in it; Escape creates nothing
+			 * and goes back to the profile question.
+			 */
+			const askName = (
+				suggestion: string,
+				current: ProfileStartupNeed,
+				typed: string = suggestion,
+				reason?: string,
+			): void => {
+				dispatch({
+					type: "SHOW_MODAL",
+					modal: {
+						type: "input",
+						title: "Save as a new profile",
+						label: reason ? `${reason}\n\nProfile name` : "Profile name",
+						defaultValue: typed,
+						onSubmit: (value: string) => {
+							const check = profileIdForName(
+								value.trim() === "" ? suggestion : value,
+								current.manifest,
+							);
+							if (!check.ok) {
+								askName(suggestion, current, value, check.reason);
+								return;
+							}
+							apply({ kind: "adopt", id: check.id, name: check.name }, current);
+						},
+						onCancel: () => ask(current),
+					},
+				});
+			};
+
 			function ask(current: ProfileStartupNeed = need): void {
+				flowRef.current = { need: current, working: false };
 				dispatch({
 					type: "SHOW_MODAL",
 					modal: buildProfileStartupModal({
 						need: current,
-						onChoose: (choice) => apply(choice, false, current),
+						onChoose: (choice) =>
+							choice.kind === "adopt"
+								? askName(choice.id, current)
+								: apply(choice, current),
 						onUpdateFormat: updateFormat,
-						onQuit,
+						onQuit: quit,
 					}),
 				});
 			}
 
+			const flow = flowRef.current;
+			// Work in flight owns the slot's next state; see the doc comment above.
+			if (flow?.working) return;
+			// Shown before and lost: put back the question that was on screen, not
+			// the one magus opened with, and never re-run an automatic activation.
+			if (flow) {
+				ask(flow.need);
+				return;
+			}
+
 			// The repo already answered and there is nothing of the user's to
 			// replace: asking here would ask someone to re-decide what their team
-			// decided, with nothing at stake. Reported in the outcome modal, so it
+			// decided, with nothing at stake. Reported in the notice banner, so it
 			// is never invisible.
 			if (need.autoActivate && need.declaredDefault !== null) {
-				apply({ kind: "activate", id: need.declaredDefault }, true);
+				apply({ kind: "activate", id: need.declaredDefault });
 				return;
 			}
 			ask();
 		},
-		[dispatch, navigateToScreen, projectPath, onQuit, onActivated],
+		[dispatch, notify, projectPath, onQuit, onActivated, onAnswered],
 	);
 
 	return { show };

package/src/ui/hooks/useStaleLoadModal.ts

@@ -1,6 +1,6 @@
 import { useCallback } from "react";
-import { useApp, useNavigation } from "../state/AppContext.js";
-import type { ModalState } from "../state/types.js";
+import { useApp, useNavigation, useNotify } from "../state/AppContext.js";
+import type { ModalState, NoticeLine } from "../state/types.js";
 
 /**
  * Startup broken-plugin modal: magus launches, finds that Claude Code will load
@@ -71,12 +71,13 @@ export function buildStaleLoadModal(args: BuildStaleLoadModalArgs): ModalState {
 export function useStaleLoadModal() {
 	const { dispatch } = useApp();
 	const { navigateToScreen } = useNavigation();
+	const notify = useNotify();
 
 	const show = useCallback(
 		(args: {
 			brokenCount: number;
 			/** Runs the repair. Resolves to what to tell the user afterwards. */
-			onFix: () => Promise<string> | string;
+			onFix: () => Promise<readonly NoticeLine[]> | readonly NoticeLine[];
 		}) => {
 			if (args.brokenCount === 0) return;
 			const dismiss = () => dispatch({ type: "HIDE_MODAL" });
@@ -91,18 +92,17 @@ export function useStaleLoadModal() {
 					// the loader after writing and can legitimately answer "still not
 					// loading the target"; swallowing that would leave the user believing
 					// a broken plugin was fixed.
-					void Promise.resolve(args.onFix())
+					//
+					// Called inside `.then` so a synchronous throw reaches `.catch`
+					// too; otherwise the loading modal stays up and swallows every key.
+					void Promise.resolve()
+						.then(() => args.onFix())
 						.then((summary) => {
-							dispatch({
-								type: "SHOW_MODAL",
-								modal: {
-									type: "message",
-									title: "Plugin repair",
-									message: summary,
-									variant: "info",
-									onDismiss: dismiss,
-								},
-							});
+							// Hidden, not replaced: the loading modal swallows every key,
+							// and the result belongs in the notice banner, outside the
+							// modal slot the next startup question is waiting for.
+							dispatch({ type: "HIDE_MODAL" });
+							for (const line of summary) notify(line.text, line.tone);
 						})
 						.catch((err) => {
 							dispatch({
@@ -125,33 +125,47 @@ export function useStaleLoadModal() {
 			});
 			dispatch({ type: "SHOW_MODAL", modal });
 		},
-		[dispatch, navigateToScreen],
+		[dispatch, navigateToScreen, notify],
 	);
 
 	return { show };
 }
 
 /**
- * One line per repair attempt, for the modal that follows the fix.
+ * What the repair did, as notices: one line for every plugin that now loads
+ * the version installed, and a warning for each that still does not.
  *
- * Exported and pure so the wording is tested rather than inspected by eye. Each
- * line says what the loader resolves NOW, because that — not the row count — is
- * the thing the user came here to change.
+ * Exported and pure so the wording is tested rather than inspected by eye. The
+ * lines say what loads NOW, because that — not the row count — is the thing
+ * the user came here to change. A failure is never folded into the success
+ * line: `ok` is the loader re-asked after the write, and a repair that did not
+ * take must read as one.
  */
-export function staleLoadRepairSummary(
+export function staleLoadRepairNotices(
 	results: ReadonlyArray<{
 		pluginId: string;
 		target: string;
 		ok: boolean;
 		error?: string;
 	}>,
-): string {
-	if (results.length === 0) return "Nothing to repair.";
-	return results
-		.map((r) =>
-			r.ok
-				? `✓ ${r.pluginId} now loads v${r.target}`
-				: `✗ ${r.pluginId} — ${r.error ?? "repair did not take effect"}`,
-		)
-		.join("\n");
+): NoticeLine[] {
+	if (results.length === 0) {
+		return [{ text: "Nothing needed repairing", tone: "success" }];
+	}
+	const lines: NoticeLine[] = [];
+	const fixed = results.filter((r) => r.ok);
+	if (fixed.length > 0) {
+		lines.push({
+			text: `Now loading ${fixed.map((r) => `${r.pluginId} v${r.target}`).join(", ")}`,
+			tone: "success",
+		});
+	}
+	for (const r of results) {
+		if (r.ok) continue;
+		lines.push({
+			text: `${r.pluginId} not repaired: ${r.error ?? "repair did not take effect"}`,
+			tone: "warning",
+		});
+	}
+	return lines;
 }