magus-cli 7.5.4 → 7.7.0

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" },
+		]);
 	});
 });

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/gitignore-service.ts

@@ -93,25 +93,6 @@ export async function applyStartupFixes(
 	return result;
 }
 
-/** What {@link applyStartupFixes} did, for the message the TUI shows. */
-export function describeStartupFix(result: StartupFixResult): string {
-	const lines: string[] = [];
-	if (result.untracked.length > 0) {
-		lines.push(
-			"Stopped tracking (the removal is staged — commit it):",
-			...result.untracked.map((p) => `  ${p}`),
-			'  git commit -m "Stop tracking generated Claude Code config"',
-		);
-	}
-	if (result.appended.length > 0) {
-		lines.push("Added to .gitignore:", ...result.appended.map((p) => `  ${p}`));
-	}
-	for (const f of result.failed) {
-		lines.push(`Could not untrack ${f.path}: ${f.reason}`);
-	}
-	return lines.length > 0 ? lines.join("\n") : "Nothing needed changing.";
-}
-
 export async function applyAllSafeFixes(
 	cwd: string,
 	violations: Violation[],

package/src/services/profile-absorb.ts

@@ -59,6 +59,7 @@ import { readManifest, writeManifest } from "./manifest.js";
 import { validateModelsConfig } from "./models-core.js";
 import {
 	type ActivateOptions,
+	type ActivationResult,
 	activateProfile,
 	activationNotes,
 	releasedCommittedSkillNote,
@@ -588,6 +589,12 @@ export interface ReconcileResult {
 	conflicts: string[];
 	/** Everything worth printing, in order. */
 	lines: string[];
+	/**
+	 * The re-render, when profiles.json changed and the live config was
+	 * generated again. `lines` already carries its CLI wording; this is for a
+	 * surface that words it differently (the TUI's notices).
+	 */
+	activation: ActivationResult | null;
 }
 
 function emptyResult(profile: string | null): ReconcileResult {
@@ -600,6 +607,7 @@ function emptyResult(profile: string | null): ReconcileResult {
 		unreadable: [],
 		conflicts: [],
 		lines: [],
+		activation: null,
 	};
 }
 
@@ -1529,6 +1537,7 @@ export async function reconcileActiveProfile(
 			// command that ran it reports that once, itself, and repeating it here
 			// printed the same warning three times in one `magus update`.
 			notes.push(...activationNotes(activation, { tracked: false }));
+			result.activation = activation;
 		} catch (error) {
 			result.problems.push(
 				error instanceof Error ? error.message : String(error),

package/src/services/profile-activate.ts

@@ -209,7 +209,8 @@ export function releasedCommittedSkillNote(folder: string): string {
 
 /**
  * Lines describing what activation did beyond the switch itself, phrased for
- * both the terminal and the TUI's outcome modal.
+ * the terminal. The TUI words its own, shorter set (`activationNotices` in
+ * ui/hooks/useProfileStartupModal.ts).
  *
  * `tracked: false` leaves the tracked-path notices out, for the CLI, which
  * prints them itself as a warning with the fix beneath it
@@ -516,5 +517,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

@@ -69,7 +69,11 @@ import {
 	findEnclosingManifest,
 	readManifest,
 } from "./manifest.js";
-import type { ProfileChoice } from "./profile-activate.js";
+import {
+	type ActivationResult,
+	type ProfileChoice,
+	activationNotes,
+} from "./profile-activate.js";
 import { freeProfileId } from "./profile-adopt.js";
 import {
 	activeProfile,
@@ -310,7 +314,10 @@ export async function oldFormatNeed(
 /** What the TUI shows at startup, beyond the question (if any). */
 export interface ProfileStartup {
 	need: ProfileStartupNeed;
-	/** One line per thing the gate did: absorbed edits, regeneration, repairs. */
+	/**
+	 * One line per thing the gate did: absorbed edits, regeneration, repairs.
+	 * Not what an activation reported — see `activations`.
+	 */
 	notices: string[];
 	/**
 	 * One line per thing the gate REFUSED — the lines the CLI stops on. Kept
@@ -319,6 +326,14 @@ export interface ProfileStartup {
 	 * still names its profile, so only this says the update did not happen.
 	 */
 	problems: string[];
+	/**
+	 * The activations the gate ran (a re-render, a format update). Handed over
+	 * as results rather than lines because the CLI's lines are the wrong words
+	 * for the TUI: they name plugin.json and backups, and they say "will not
+	 * load" in a line nothing marks as a warning. The TUI words them itself, in
+	 * user terms and with a tone (`activationWarnings` in the startup hook).
+	 */
+	activations: ActivationResult[];
 }
 
 /**
@@ -338,14 +353,24 @@ export async function prepareProfileStartup(
 ): Promise<ProfileStartup> {
 	if (!opts.convert) {
 		const format = await oldFormatNeed(projectPath);
-		if (format !== null) return { need: format, notices: [], problems: [] };
+		if (format !== null) {
+			return { need: format, notices: [], problems: [], activations: [] };
+		}
 	}
 	const notices: string[] = [];
 	const problems: string[] = [];
+	const activations: ActivationResult[] = [];
 	try {
 		const prep = await prepareProfileState(projectPath);
-		notices.push(...prep.lines);
+		// The gate's lines, less the ones its activations contributed: those
+		// reach the TUI as `activations`, and passing both would say the same
+		// thing twice — once in the CLI's words, as if it were a success.
+		const fromActivations = new Set(
+			prep.activations.flatMap((a) => activationNotes(a, { tracked: false })),
+		);
+		notices.push(...prep.lines.filter((line) => !fromActivations.has(line)));
 		problems.push(...prep.problems);
+		activations.push(...prep.activations);
 	} catch (error) {
 		if (!(error instanceof SettingsParseError)) {
 			problems.push(error instanceof Error ? error.message : String(error));
@@ -355,13 +380,17 @@ export async function prepareProfileStartup(
 		need: await detectProfileStartupNeed(projectPath),
 		notices,
 		problems,
+		activations,
 	};
 }
 
-/** What the TUI shows once "Update it now" has run. */
+/**
+ * What the TUI shows once "Update it now" has run: another question, a notice
+ * line, or an error modal.
+ */
 export type FormatUpdateOutcome =
 	| { kind: "ask"; need: ProfileStartupNeed }
-	| { kind: "updated"; title: string; message: string }
+	| { kind: "updated"; notice: string }
 	| { kind: "failed"; title: string; message: string };
 
 /**
@@ -381,14 +410,12 @@ export function formatUpdateOutcome(
 		};
 	}
 	if (!needsNothing(result.need)) return { kind: "ask", need: result.need };
-	return {
-		kind: "updated",
-		title: "Profile format updated",
-		message:
-			result.notices.length > 0
-				? result.notices.join("\n")
-				: "This project now uses the current profile format.",
-	};
+	// One line, not the gate's notices: those are the conversion's working log
+	// (edits carried over, the old format's backup), and the result the user
+	// cares about is only that the update is done. What the conversion's
+	// activation warns about is NOT dropped: the caller words it from
+	// `result.activations`, as it does for any activation.
+	return { kind: "updated", notice: "Profile format updated" };
 }
 
 // ─── What to offer, as data both surfaces render ─────────────────────────────
@@ -426,9 +453,10 @@ export const UPDATE_FORMAT_VALUE = "update-format";
  * Neither mentions the backup, deliberately. A sentence promising "nothing is
  * deleted — the old files are moved to a backup" raises a question the reader
  * did not have (which files? what was at risk?) and implies data loss, when what
- * changes is settings. Where the displaced files went belongs in the outcome
- * modal AFTER the switch, where it is something to act on rather than a worry to
- * plant beforehand.
+ * changes is settings. The TUI does not name the backup afterwards either: the
+ * backup is magus's own storage, and the user acts on nothing there. Only a
+ * failed activation lists what was moved, because then it is something to act
+ * on (see `describeFailure` in ui/hooks/useProfileStartupModal.ts).
  *
  * No file paths in these strings, deliberately. The TUI modal soft-wraps its
  * message at whatever width the terminal gives it, and OpenTUI treats `.` as a
@@ -555,7 +583,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 +627,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

@@ -299,6 +299,12 @@ export interface ProfileStatePrep {
 	problems: string[];
 	/** The files behind `problems` that could not be parsed. */
 	unreadable: SettingsParseError[];
+	/**
+	 * Every activation the gate ran, in order: a re-render after profiles.json
+	 * changed, an older layout converted. `lines` already carries them in the
+	 * CLI's words; the TUI words them itself from these.
+	 */
+	activations: ActivationResult[];
 }
 
 /**
@@ -319,11 +325,13 @@ export async function prepareProfileState(
 		lines: [],
 		problems: [],
 		unreadable: [],
+		activations: [],
 	};
 	const take = (r: ReconcileResult) => {
 		out.lines.push(...r.lines.filter((l) => !r.problems.includes(l)));
 		out.problems.push(...r.problems);
 		out.unreadable.push(...r.unreadable);
+		if (r.activation) out.activations.push(r.activation);
 	};
 
 	if (check.state === "active" && check.restored) {
@@ -358,6 +366,7 @@ export async function prepareProfileState(
 			}
 			// Tracked files are the command's to report, once (see profile-absorb).
 			out.lines.push(...activationNotes(result, { tracked: false }));
+			out.activations.push(result);
 		}
 		out.check = { state: "active", profile, restored: false };
 	}
@@ -556,7 +565,7 @@ export async function applyProfileChoice(
 	}
 	const result = await adoptCurrentProject(
 		projectPath,
-		undefined,
+		choice.name,
 		manifest,
 		choice.id,
 	);