magus-cli 7.5.4 → 7.6.0

package/src/cli/bootstrap.ts

@@ -35,6 +35,7 @@ import {
 	needsNothing,
 	oldFormatNeed,
 	parseProfileChoice,
+	profileIdForName,
 } from "../services/profile-startup.js";
 import {
 	applyProfileChoice,
@@ -47,7 +48,7 @@ import { SettingsParseError } from "../services/settings-file.js";
 import type { ProfileManifest } from "../types/index.js";
 import { brand } from "../ui/theme.js";
 import { badge, bold, dim } from "./ansi.js";
-import { askYesNo } from "./prompt.js";
+import { askYesNo, isPromptAborted, promptValue } from "./prompt.js";
 import { selectOption } from "./select.js";
 import {
 	type ScopeName,
@@ -447,6 +448,31 @@ export async function ensureManifest(
 	return result.manifest;
 }
 
+/**
+ * The name for a profile saved from what the project has, or null when the
+ * user gave none (Ctrl+C, or input ended). Empty accepts `suggestion`. An
+ * invalid name is explained and asked again — never swapped for another id.
+ */
+async function askProfileName(
+	suggestion: string,
+	manifest: ProfileManifest,
+): Promise<{ id: string; name: string } | null> {
+	for (;;) {
+		let typed: string;
+		try {
+			typed = await promptValue(
+				question("Name for the new profile", `[${suggestion}]`),
+			);
+		} catch (error) {
+			if (isPromptAborted(error)) return null;
+			throw error;
+		}
+		const check = profileIdForName(typed === "" ? suggestion : typed, manifest);
+		if (check.ok) return { id: check.id, name: check.name };
+		console.log(warnLine(check.reason));
+	}
+}
+
 /**
  * Require an active profile, or stop the command.
  *
@@ -545,7 +571,13 @@ export async function requireActiveProfile(
 	// "Quit magus", Esc and Ctrl+C all land here, and there is no third
 	// outcome: the command stops rather than proceed without a profile.
 	const value = picked === null ? undefined : options[picked]?.value;
-	const choice = value === undefined ? null : parseProfileChoice(value, need);
+	let choice = value === undefined ? null : parseProfileChoice(value, need);
+	// Saving asks for the name, and an unanswered name is an unanswered
+	// question like any other: nothing is created and the command stops.
+	if (choice?.kind === "adopt") {
+		const named = await askProfileName(choice.id, need.manifest);
+		choice = named === null ? null : { kind: "adopt", ...named };
+	}
 	if (!choice) {
 		console.error(failLine("No profile chosen — stopping."));
 		return null;

package/src/cli/prompt.ts

@@ -39,15 +39,25 @@ export function isPromptAborted(error: unknown): boolean {
 	);
 }
 
-/** One readline question, with Ctrl+C normalised. */
+/** One readline question, with Ctrl+C and end of input normalised. */
 async function ask(question: string): Promise<string> {
 	const rl = createInterface({ input: process.stdin, output: process.stdout });
+	// End of input (Ctrl+D, or a pipe that ran dry) closes the interface and
+	// never settles `question()` — MEASURED under Bun, it waits forever. Input
+	// that ends before an answer is a cancellation, the same as Ctrl+C.
+	let settled = false;
+	const closed = new Promise<never>((_, reject) => {
+		rl.once("close", () => {
+			if (!settled) reject(new PromptAborted());
+		});
+	});
 	try {
-		return (await rl.question(question)).trim();
+		return (await Promise.race([rl.question(question), closed])).trim();
 	} catch (error) {
 		if (isPromptAborted(error)) throw new PromptAborted();
 		throw error;
 	} finally {
+		settled = true;
 		rl.close();
 	}
 }

package/src/cli/update-view.ts

@@ -214,11 +214,13 @@ export function scopeBadge(scope: ScopeName): string {
 }
 
 /**
- * The prompt for a yes/no question, in the glyph column: `?  <question>  [Y/n] `.
- * Printed by readline, so the answer is typed on the same line.
+ * The prompt for a question, in the glyph column: `?  <question>  [Y/n] `.
+ * Printed by readline, so the answer is typed on the same line. `hint` is what
+ * an empty answer means — yes by default, or the suggested value for a
+ * free-text question.
  */
-export function question(text: string): string {
-	return `${PAD}${fg(brand.accent, "?")}  ${bold(text)}  ${dim("[Y/n]")} `;
+export function question(text: string, hint = "[Y/n]"): string {
+	return `${PAD}${fg(brand.accent, "?")}  ${bold(text)}  ${dim(hint)} `;
 }
 
 /**

package/src/services/profile-activate.ts

@@ -516,5 +516,6 @@ export async function recordRefetchedSkills(
 
 /** The two ways a project can be put onto a profile. */
 export type ProfileChoice =
-	| { kind: "adopt"; id: string }
+	/** `name` is what the user typed; without it the adopted default name is used. */
+	| { kind: "adopt"; id: string; name?: string }
 	| { kind: "activate"; id: string };

package/src/services/profile-adopt.ts

@@ -36,12 +36,19 @@ export const ADOPTED_PROFILE_ID = "default";
  * Lives here rather than at a call site because both surfaces adopt now — the
  * CLI prompt and the TUI's startup offer — and two copies of "which id is
  * free?" is two chances to overwrite somebody's profile.
+ *
+ * Own keys, the same test `profileIdForName` applies to the name the user
+ * submits. A truthiness test called a hand-written `"default": null` free, so
+ * the suggestion offered in the name field was the one name it then refused,
+ * and Enter looped on it.
  */
 export function freeProfileId(manifest: ProfileManifest): string {
-	if (!manifest.profiles[ADOPTED_PROFILE_ID]) return ADOPTED_PROFILE_ID;
+	if (!Object.hasOwn(manifest.profiles, ADOPTED_PROFILE_ID)) {
+		return ADOPTED_PROFILE_ID;
+	}
 	for (let n = 2; ; n++) {
 		const id = `${ADOPTED_PROFILE_ID}-${n}`;
-		if (!manifest.profiles[id]) return id;
+		if (!Object.hasOwn(manifest.profiles, id)) return id;
 	}
 }
 

package/src/services/profile-startup.ts

@@ -555,7 +555,11 @@ export function buildProfileOptions(need: ProfileStartupNeed): SelectOption[] {
 			// Kept short on purpose: this is the longest label in the list, and the
 			// meta column is measured against the longest one. "…and use it" made it
 			// 41 cells and pushed every plugin count onto a line of its own.
-			label: `Save what you have as "${need.adopt}"`,
+			//
+			// No id in it. The generated one read as a copy of an existing profile
+			// ("default-2" as "overwrite Default"); the name is asked for once this
+			// row is picked, with that id only as the suggestion.
+			label: "Save what you have as a new profile",
 			value: ADOPT_VALUE,
 		});
 	}
@@ -595,6 +599,47 @@ export function defaultOptionIndex(need: ProfileStartupNeed): number {
 	return at === -1 ? 0 : at;
 }
 
+/** A typed profile name, judged: the id it becomes, or why it cannot. */
+export type ProfileNameCheck =
+	| { ok: true; id: string; name: string }
+	| { ok: false; reason: string };
+
+/**
+ * Validate a profile name typed by the user and derive its id. Pure.
+ *
+ * The one rule both surfaces ask with, so the CLI and the TUI cannot accept
+ * different names. A clash is refused, never resolved: quietly saving as
+ * `<id>-2` is the very thing that made users read the old generated label as
+ * "overwrite Default".
+ */
+export function profileIdForName(
+	input: string,
+	manifest: ProfileManifest,
+): ProfileNameCheck {
+	const name = input.trim();
+	if (name === "") {
+		return { ok: false, reason: "Enter a name for the profile." };
+	}
+	const id = name
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, "-")
+		.replace(/^-+|-+$/g, "");
+	if (id === "") {
+		return { ok: false, reason: "Use at least one letter or digit." };
+	}
+	// Own keys only: a name like "constructor" is free, not a clash with the
+	// object prototype.
+	if (Object.hasOwn(manifest.profiles, id)) {
+		// Named as the user knows it; a hand-written entry may carry no name.
+		const known = manifest.profiles[id]?.name || id;
+		return {
+			ok: false,
+			reason: `A profile called "${known}" already exists. Choose another name.`,
+		};
+	}
+	return { ok: true, id, name };
+}
+
 /**
  * Turn a chosen option value into the action it means.
  *

package/src/services/profile-state.ts

@@ -556,7 +556,7 @@ export async function applyProfileChoice(
 	}
 	const result = await adoptCurrentProject(
 		projectPath,
-		undefined,
+		choice.name,
 		manifest,
 		choice.id,
 	);

package/src/ui/App.tsx

@@ -287,9 +287,15 @@ function AppContent({ onExit }: AppContentProps) {
 				// non-fatal: the Git State tab still shows the same rows
 			});
 	}, []);
+	// Stable, so `profileModal.show` is not rebuilt for it on every render.
+	const profileAnswered = React.useCallback(() => setProfileNeed(null), []);
 	// The profile modal cannot be dismissed, so it needs the app's own exit: its
 	// only non-action is to leave.
-	const profileModal = useProfileStartupModal(onExit, checkGitignoreNow);
+	const profileModal = useProfileStartupModal({
+		onQuit: onExit,
+		onActivated: checkGitignoreNow,
+		onAnswered: profileAnswered,
+	});
 
 	// Check for updates on startup, then re-check periodically (force-bypassing
 	// the session cache) so the banner reflects a release that lands while
@@ -324,51 +330,91 @@ function AppContent({ onExit }: AppContentProps) {
 		return () => clearTimeout(timer);
 	}, [recoveryReport]);
 
-	// Show gitignore modal — wait for the modal slot to be free so we don't
-	// stomp on another modal that may have just been shown.
-	useEffect(() => {
-		if (!gitignoreData) return;
-		if (state.modal) return;
-		gitignoreModal.show({
-			violationCount: gitignoreData.violationCount,
-			safeCount: gitignoreData.safeCount,
-			generated: gitignoreData.generated,
-			// In place, then back to the app: tracked generated files are
-			// untracked, missing entries added; other items stay for the tab.
-			onFixSafe: async () =>
-				describeStartupFix(await applyStartupFixes(state.projectPath)),
-		});
-		setGitignoreData(null);
-	}, [gitignoreData, gitignoreModal, state.modal, state.projectPath]);
-
-	// Show the broken-plugin modal — same "wait for the modal slot" rule as the
-	// gitignore one above, so two startup findings queue instead of one stomping
-	// the other.
+	// The startup questions — gitignore, then broken plugins, then profile — are
+	// asked ONE at a time, from ONE effect, and only while the modal slot is free.
+	//
+	// They used to be three effects, each checking `state.modal` from the same
+	// render. Two needs arriving in one commit both saw an empty slot, both
+	// showed, and the later SHOW_MODAL replaced the earlier question after its
+	// need had already been cleared — so it never came back. The profile question
+	// was lost exactly that way, and the user updated plugins believing a profile
+	// was active. So: show at most one per run and return; the next question
+	// follows once that one's last modal is dismissed and the slot is empty
+	// again.
+	//
+	// The hooks keep the slot occupied for their whole flow (a loading modal
+	// while their fix runs, never HIDE_MODAL mid-flow), because an empty slot is
+	// what lets the next question in. That does not stop a SCREEN from emptying
+	// it: `useModal().confirm` hides its modal when answered and the screen shows
+	// its loading modal a microtask later. A key pressed before the profile check
+	// resolved lands the profile question in exactly that gap, and the screen's
+	// loading modal then replaces it.
+	//
+	// So the two kinds of question are cleared at different points.
+	//
+	// - The profile need is cleared when it is ANSWERED (`profileAnswered`, from
+	//   the hook: a profile activated, or quit), never when shown. The modal
+	//   cannot be dismissed, so an empty slot while the need is still set means
+	//   it was lost, and this effect puts it back. The hook keeps what was last
+	//   asked and whether work is in flight, so a re-show re-asks the question
+	//   that was on screen and never starts a second activation.
+	// - The gitignore and broken-plugin needs are still cleared on show. Both
+	//   can be dismissed, so an empty slot does not mean they were lost —
+	//   re-showing would re-ask a question the user just declined. Losing one
+	//   costs nothing lasting: the Git State and Plugins tabs show the same rows,
+	//   and gitignore is asked again after a profile activates.
 	useEffect(() => {
-		if (brokenPluginCount === null) return;
 		if (state.modal) return;
-		staleLoadModal.show({
-			brokenCount: brokenPluginCount,
-			// Re-surveys before repairing, like the gitignore fixer: the registry may
-			// have moved between the startup scan and the user pressing Enter, and
-			// repairing from the stale count would act on rows that are no longer
-			// there. `repairAllStaleLoads` is the same `repairStaleLoad` the Plugins
-			// screen's `a` key drives through the apply engine.
-			//
-			// The pins are re-read with it, from the same helper the survey used: a
-			// repair that capped at a different ceiling than the offer was counted
-			// against would move rows the dialog never mentioned.
-			onFix: async () =>
-				staleLoadRepairSummary(
-					await repairAllStaleLoads(
-						state.projectPath,
-						undefined,
-						await activePluginPins(state.projectPath),
+		if (gitignoreData) {
+			gitignoreModal.show({
+				violationCount: gitignoreData.violationCount,
+				safeCount: gitignoreData.safeCount,
+				generated: gitignoreData.generated,
+				// In place, then back to the app: tracked generated files are
+				// untracked, missing entries added; other items stay for the tab.
+				onFixSafe: async () =>
+					describeStartupFix(await applyStartupFixes(state.projectPath)),
+			});
+			setGitignoreData(null);
+			return;
+		}
+		if (brokenPluginCount !== null) {
+			staleLoadModal.show({
+				brokenCount: brokenPluginCount,
+				// Re-surveys before repairing, like the gitignore fixer: the registry
+				// may have moved between the startup scan and the user pressing Enter,
+				// and repairing from the stale count would act on rows that are no
+				// longer there. `repairAllStaleLoads` is the same `repairStaleLoad` the
+				// Plugins screen's `a` key drives through the apply engine.
+				//
+				// The pins are re-read with it, from the same helper the survey used: a
+				// repair that capped at a different ceiling than the offer was counted
+				// against would move rows the dialog never mentioned.
+				onFix: async () =>
+					staleLoadRepairSummary(
+						await repairAllStaleLoads(
+							state.projectPath,
+							undefined,
+							await activePluginPins(state.projectPath),
+						),
 					),
-				),
-		});
-		setBrokenPluginCount(null);
-	}, [brokenPluginCount, staleLoadModal, state.modal, state.projectPath]);
+			});
+			setBrokenPluginCount(null);
+			return;
+		}
+		// Not cleared here — see above. Re-called on every empty slot until the
+		// hook reports it answered.
+		if (profileNeed) profileModal.show(profileNeed);
+	}, [
+		state.modal,
+		state.projectPath,
+		gitignoreData,
+		gitignoreModal,
+		brokenPluginCount,
+		staleLoadModal,
+		profileNeed,
+		profileModal,
+	]);
 
 	// Does this project load an older plugin than it installed? Detection only;
 	// nothing is written until the user chooses Fix.
@@ -393,17 +439,6 @@ function AppContent({ onExit }: AppContentProps) {
 		})();
 	}, []);
 
-	// Show the profile modal on the same terms as the gitignore one: only once
-	// the modal slot is free, so two startup checks that both found something do
-	// not stomp on each other. Gitignore is asked first simply because its
-	// effect is declared first; whichever the user dismisses, the other follows.
-	useEffect(() => {
-		if (!profileNeed) return;
-		if (state.modal) return;
-		profileModal.show(profileNeed);
-		setProfileNeed(null);
-	}, [profileNeed, profileModal, state.modal]);
-
 	// The gitignore question on every open. Its own effect, NOT part of the
 	// marketplace block below, which returns early on `--no-refresh`: that flag
 	// is about network calls and must not silence this question.

package/src/ui/components/modals/ModalContainer.tsx

@@ -34,6 +34,9 @@ const isPlain = (key: KeyPress) => !key.ctrl && !key.meta;
  *            question that must be answered).
  * - input:   Esc cancels; everything else goes to the focused <input>, which
  *            OpenTUI delivers after this layer and which submits on Enter.
+ *            Only an <input> that was ALREADY focused when the key arrived:
+ *            the Enter that opens an input modal from a select never reaches
+ *            it (KeyRouter's `dispatchThenGuardFocus`).
  * - message: any key dismisses.
  * - loading: keys are swallowed until the work finishes.
  * - help:    ↑↓ / PgUp / PgDn / Ctrl+U / Ctrl+D scroll; Esc or `?` close.

package/src/ui/hooks/useGitignoreModal.ts

@@ -98,10 +98,28 @@ 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 "Gitignore fixed" —
+					// lost for the whole session. The slot stays occupied until the
+					// result below is dismissed.
+					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;
+							// Nothing to report still has to clear the loading modal: it
+							// swallows every key, so leaving it would hang the app.
+							if (!report) {
+								dispatch({ type: "HIDE_MODAL" });
+								return;
+							}
 							dispatch({
 								type: "SHOW_MODAL",
 								modal: {