magus-cli 7.5.2 → 7.5.4

package/src/cli/bootstrap.ts

@@ -18,7 +18,7 @@ import {
 	type ActivationResult,
 	activateProfile,
 	activationNotes,
-	assertNoTrackedWriteTargets,
+	activationTrackedNotices,
 	reportDisplaced,
 } from "../services/profile-activate.js";
 import {
@@ -26,11 +26,14 @@ import {
 	adoptCurrentProject,
 } from "../services/profile-adopt.js";
 import {
+	type ProfileStartupNeed,
+	UPDATE_FORMAT_VALUE,
 	buildProfileOptions,
 	defaultOptionIndex,
 	describeNeed,
 	detectProfileStartupNeed,
 	needsNothing,
+	oldFormatNeed,
 	parseProfileChoice,
 } from "../services/profile-startup.js";
 import {
@@ -42,10 +45,23 @@ import {
 } from "../services/profile-state.js";
 import { SettingsParseError } from "../services/settings-file.js";
 import type { ProfileManifest } from "../types/index.js";
-import { dim } from "./ansi.js";
-import { confirm } from "./prompt.js";
-import { selectDialog } from "./tui-prompt.js";
-import { fail as failLine, note as noteLine } from "./update-view.js";
+import { brand } from "../ui/theme.js";
+import { badge, bold, dim } from "./ansi.js";
+import { askYesNo } from "./prompt.js";
+import { selectOption } from "./select.js";
+import {
+	type ScopeName,
+	fail as failLine,
+	field,
+	info as infoLine,
+	listItem,
+	noteBlock,
+	note as noteLine,
+	ok as okLine,
+	question,
+	scopeBadge,
+	warn as warnLine,
+} from "./update-view.js";
 
 /**
  * Report a file that exists and cannot be used — it does not parse, or parses
@@ -77,6 +93,13 @@ export function reportUnparseable(error: SettingsParseError): void {
 async function writeAndActivate(
 	result: AdoptResult,
 	projectPath: string,
+	/**
+	 * Report a generated file git tracks. Only when adopting IS the command
+	 * (`profile init`): `install` and `update` report it themselves right
+	 * after — install's switch, update's own check — so adoption inside them
+	 * said it twice in one run.
+	 */
+	reportTracked: boolean,
 ): Promise<void> {
 	// Relative to the project throughout. These are all project paths, and an
 	// absolute one wraps over two terminal lines — several wrapped lines in a row
@@ -84,11 +107,13 @@ async function writeAndActivate(
 	// their hand-written files went.
 	const rel = (p: string) => path.relative(projectPath, p);
 
-	// Before the manifest is written: adopting activates, and activating a
-	// project whose settings.json git tracks would take that file over.
-	await assertNoTrackedWriteTargets(projectPath);
 	await writeManifest(result.manifest, projectPath);
-	console.log(`✓ Wrote ${rel(getManifestPath(projectPath))}`);
+	console.log(okLine(`Saved profile ${bold(result.profileId)}`));
+	console.log(
+		noteLine(
+			`Commit ${rel(getManifestPath(projectPath))} so your team gets the same plugins.`,
+		),
+	);
 
 	// Each move is printed as it happens, not from the returned list afterwards.
 	// Activation writes three files in sequence, so a throw on the third would
@@ -100,14 +125,28 @@ async function writeAndActivate(
 		projectPath,
 		{ onDisplace: reportDisplaced(projectPath) },
 	);
-	console.log(`✓ Active profile: ${result.profileId}`);
-	printActivationNotes(activation);
+	console.log(okLine(`Using profile ${bold(result.profileId)}`));
+	printActivationNotes(activation, { tracked: reportTracked });
 	console.log();
 }
 
-/** Print what activation did beyond the switch itself, one line each. */
-export function printActivationNotes(result: ActivationResult): void {
-	for (const line of activationNotes(result)) console.log(noteLine(line));
+/**
+ * Print what activation did beyond the switch itself: notes one line each, and
+ * — unless `tracked` is false — a tracked generated file as a warning with its
+ * fix beneath.
+ */
+export function printActivationNotes(
+	result: ActivationResult,
+	opts: { tracked?: boolean } = {},
+): void {
+	for (const line of activationNotes(result, { tracked: false })) {
+		console.log(noteLine(line));
+	}
+	if (opts.tracked === false) return;
+	for (const n of activationTrackedNotices(result)) {
+		console.log(warnLine(n.problem));
+		for (const line of n.fix) console.log(noteLine(line));
+	}
 }
 
 export interface ProfileGateOptions {
@@ -117,6 +156,39 @@ export interface ProfileGateOptions {
 	 * exists — `profile switch`, `install`.
 	 */
 	allowUnknown?: boolean;
+	/** `--yes`: update an old profile format without asking. */
+	yes?: boolean;
+}
+
+/**
+ * An old magus profile format: the shared `old-format` state, stated with the
+ * TUI's own title and message and — with a person at the terminal and no
+ * `--yes` — asked with the TUI's own rows. Returns false when the user
+ * declines; the command then stops, since magus cannot manage a project in a
+ * format it no longer writes. With nobody to ask it updates, as before: CI and
+ * `--yes` must not hang on a question.
+ */
+async function confirmFormatUpdate(
+	projectPath: string,
+	opts: ProfileGateOptions,
+): Promise<boolean> {
+	const need = await oldFormatNeed(projectPath);
+	if (need === null || need.state !== "old-format") return true;
+	const { title, message } = describeNeed(need);
+	console.log("");
+	console.log(warnLine(bold(title)));
+	for (const line of noteBlock(message, process.stdout.columns)) {
+		console.log(line);
+	}
+	console.log("");
+	if (opts.yes || !process.stdin.isTTY || !process.stdout.isTTY) return true;
+	const options = buildProfileOptions(need);
+	const picked = await selectOption("Update the profile format?", options, 0);
+	if (picked !== null && options[picked]?.value === UPDATE_FORMAT_VALUE) {
+		return true;
+	}
+	console.log(infoLine("Nothing changed."));
+	return false;
 }
 
 /**
@@ -133,6 +205,7 @@ export async function profileGate(
 	projectPath: string,
 	opts: ProfileGateOptions = {},
 ): Promise<boolean> {
+	if (!(await confirmFormatUpdate(projectPath, opts))) return false;
 	let prep: Awaited<ReturnType<typeof prepareProfileState>>;
 	try {
 		prep = await prepareProfileState(projectPath);
@@ -158,64 +231,128 @@ export async function profileGate(
 	return true;
 }
 
-/** Print what adoption would capture, so the user can judge it before writing. */
+/** The plugin as a user reads it: its name, and its marketplace only when that is not magus's own. */
+function pluginLabel(id: string): string {
+	const at = id.lastIndexOf("@");
+	if (at <= 0) return id;
+	const market = id.slice(at + 1);
+	return market === "magus"
+		? id.slice(0, at)
+		: `${id.slice(0, at)} ${dim(market)}`;
+}
+
+/** Longest list shown before it is cut to "+ N more". */
+const LIST_MAX = 12;
+
+/** Print up to LIST_MAX entries under a field, then how many were left out. */
+function printList(entries: string[]): void {
+	for (const entry of entries.slice(0, LIST_MAX)) console.log(listItem(entry));
+	if (entries.length > LIST_MAX) {
+		console.log(listItem(dim(`+ ${entries.length - LIST_MAX} more`)));
+	}
+}
+
+/**
+ * Print the state and what adoption would capture, so the user can judge it
+ * before the question below.
+ *
+ * In the user's terms only: the state ("no profiles yet"), the plugins as a
+ * list with the SCOPE they come from, and anything that affects the team.
+ * Never where magus stores things — the owner, on the version that printed
+ * "from this folder's .claude/settings.json" and a relative path: users
+ * operate in scopes (user, project, local), not in files, and a mechanism
+ * they never chose is noise.
+ */
 function printAdoptionPlan(result: AdoptResult): void {
+	console.log("");
+	console.log(warnLine(bold("No profiles in this project yet")));
 	console.log(
-		"\nThis project has no .claude/profiles.json — magus can create one from its current setup.\n",
+		noteLine(
+			"magus keeps a project's plugins in a profile: a named set your team gets",
+		),
 	);
-	console.log(`  profile      ${result.profileId} (${result.entry.name})`);
 	console.log(
-		`  plugins      ${result.counts.plugins} enabled, adopted as "latest"`,
+		noteLine(
+			"by committing it. Save what this project uses now as the first one.",
+		),
 	);
-	if (result.source === "user") {
-		// Never let this be invisible: the generated file is meant to be committed,
-		// and these came from ~/.claude/settings.json — this machine's personal
-		// global set, not anything this repo chose.
-		console.log(
-			"               ⚠ read from ~/.claude/settings.json (user scope) — this project",
-		);
-		console.log(
-			"                 enables none of its own. Review before committing.",
-		);
-	}
-	if (result.counts.mcpServers > 0) {
-		console.log(`  mcp servers  ${result.counts.mcpServers} from .mcp.json`);
+	console.log("");
+
+	console.log(
+		field(
+			"profile",
+			`${bold(result.profileId)}  ${badge("NEW", brand.success)}`,
+		),
+	);
+	const scope: ScopeName = result.source === "user" ? "user" : "project";
+	console.log(
+		field(
+			"plugins",
+			`${bold(String(result.counts.plugins))}  ${scopeBadge(scope)}`,
+		),
+	);
+	printList(Object.keys(result.entry.plugins ?? {}).map(pluginLabel));
+	const servers = Object.keys(result.entry.mcpServers ?? {});
+	if (servers.length > 0) {
+		console.log(field("mcp servers", bold(String(servers.length))));
+		printList(servers);
 	}
-	if (result.counts.settingsKeys > 0) {
+	console.log("");
+
+	const warned =
+		result.source === "user" ||
+		result.skipped.length > 0 ||
+		result.machinePaths.length > 0;
+	if (result.source === "user") {
+		// Never let this be invisible: the profile is meant to be committed, and
+		// these are one person's global set, not anything this project chose.
+		console.log(warnLine("This project has no plugins of its own"));
 		console.log(
-			`  settings     ${result.counts.settingsKeys} keys carried over`,
+			noteLine(
+				"These are your USER plugins, on in every project. Check them before committing.",
+			),
 		);
 	}
 	for (const id of result.skipped) {
 		console.log(
-			`  ⚠ skipped ${id} — no marketplace in its id, not reproducible`,
+			warnLine(`${id} can't be shared — it isn't from a marketplace`),
 		);
 	}
 	for (const hit of result.machinePaths) {
-		console.log(`  ⚠ machine path  ${hit}`);
-	}
-	if (result.machinePaths.length > 0) {
 		console.log(
-			"    Those name a directory on THIS machine and will not resolve on another.",
+			warnLine(`A setting points to a folder on this computer: ${hit}`),
 		);
 	}
-	console.log(
-		"\nCommit the file to share this setup with the team; edit it to pin versions.",
-	);
-	// Said before the question, not after it: adopting also SWITCHES the project
-	// onto the profile, which replaces two files that are in the working tree
-	// right now. The prompt below is the only place to decline.
-	console.log(
-		"The project then runs this profile: .claude/settings.json and .mcp.json are",
-	);
-	console.log(
-		"generated from it, and your current copies are kept where the run reports.",
-	);
+	if (result.machinePaths.length > 0) {
+		console.log(noteLine("Your teammates won't have it."));
+	}
+	if (warned) console.log("");
+}
+
+/**
+ * A state that stops the command, stated the way the TUI states it: the same
+ * title and message from `describeNeed`, dim — nothing is wrong, and there is
+ * nothing to choose from the CLI.
+ */
+function printNeedNote(need: ProfileStartupNeed): void {
+	const { title, message } = describeNeed(need);
+	console.log("");
+	console.log(noteLine(bold(title)));
+	for (const line of noteBlock(message, process.stdout.columns)) {
+		console.log(line);
+	}
+	console.log("");
 }
 
 export interface EnsureManifestOptions {
 	/** Read-only mode: never write, just report that adoption is needed. */
 	check?: boolean;
+	/**
+	 * Report a tracked generated file after activating. False for a caller that
+	 * already reported it this run (`update` checks before it asks), so it is
+	 * said once.
+	 */
+	reportTracked?: boolean;
 	/**
 	 * Adopt without prompting. Set only by `magus profile init`, where
 	 * creating the manifest IS the command the user asked for.
@@ -245,14 +382,30 @@ export async function ensureManifest(
 	}
 	if (Object.keys(manifest.profiles).length > 0) return manifest;
 
+	// Inside a project that has profiles: the shared startup state says so, and
+	// the command stops — the TUI shows the same state as its startup question.
+	// Only `profile init` (`allowAdopt`), run on purpose, gives a subfolder a
+	// setup of its own.
+	if (!opts.allowAdopt) {
+		const need = await detectProfileStartupNeed(projectPath);
+		if (need.state === "nested") {
+			printNeedNote(need);
+			return null;
+		}
+	}
+
 	const result = await adoptCurrentProject(projectPath);
 
 	if (result.counts.plugins === 0) {
 		console.error(
-			`No .claude/profiles.json in ${projectPath}, and no enabled plugins to adopt one from.`,
+			failLine(
+				`No profile in ${path.basename(projectPath)}, and no plugins to save as one`,
+			),
 		);
 		console.error(
-			"Open magus and select the plugins this project needs, then re-run.",
+			noteLine(
+				"Open magus, pick the plugins this folder needs, then run this again.",
+			),
 		);
 		return null;
 	}
@@ -261,8 +414,9 @@ export async function ensureManifest(
 
 	if (opts.check) {
 		console.error(
-			"\n--check is read-only and will not create the manifest. Run `magus install` once to adopt.",
+			failLine("--check is read-only, so it does not create the profile"),
 		);
+		console.error(noteLine("Run `magus install` once to create it."));
 		return null;
 	}
 
@@ -276,15 +430,20 @@ export async function ensureManifest(
 		// fall through to the write
 	} else if (!process.stdin.isTTY) {
 		console.error(
-			"\nRefusing to create .claude/profiles.json without a human: run `magus profile init` to create it deliberately.",
+			failLine("No profile in this folder, and nobody here to ask"),
+		);
+		console.error(
+			noteLine("Run `magus profile init` to create one deliberately."),
 		);
 		return null;
-	} else if (!(await confirm("\nCreate it and switch to it?"))) {
-		console.log("Aborted — nothing written.");
+	} else if (
+		!(await askYesNo(question(`Save as profile "${result.profileId}"?`)))
+	) {
+		console.log(infoLine("Nothing written."));
 		return null;
 	}
 
-	await writeAndActivate(result, projectPath);
+	await writeAndActivate(result, projectPath, opts.allowAdopt === true);
 	return result.manifest;
 }
 
@@ -335,7 +494,7 @@ export async function requireActiveProfile(
 		console.log(
 			`✓ Active profile: ${result.profileId} ${dim("(declared by this project)")}`,
 		);
-		printActivationNotes(result);
+		printActivationNotes(result, { tracked: opts.reportTracked !== false });
 		console.log("");
 		return readManifest(projectPath);
 	}
@@ -351,7 +510,9 @@ export async function requireActiveProfile(
 	}
 
 	// CI has nobody to ask. Exiting beats hanging on an answer that cannot come.
-	if (!process.stdin.isTTY) {
+	// Both ends: with stdout piped the list cannot draw, and "No profile chosen"
+	// would claim an answer nobody was asked for.
+	if (!process.stdin.isTTY || !process.stdout.isTTY) {
 		console.error(failLine(title));
 		console.error(
 			noteLine(
@@ -366,27 +527,35 @@ export async function requireActiveProfile(
 		return null;
 	}
 
+	// The choices the TUI's startup modal offers, built by the same functions,
+	// as an arrow-key list in the report style — the CLI mounts no TUI.
+	const options = buildProfileOptions(need);
+	const def = defaultOptionIndex(need);
 	console.log("");
-	const chosen = await selectDialog({
-		title,
-		message: describeNeed(need).message,
-		options: buildProfileOptions(need),
-		defaultIndex: defaultOptionIndex(need),
-	});
+	console.log(warnLine(bold(title)));
+	for (const line of noteBlock(
+		describeNeed(need).message,
+		process.stdout.columns,
+	)) {
+		console.log(line);
+	}
+	console.log("");
+	const picked = await selectOption("Choose a profile", options, def);
 
-	// Esc, Ctrl+C and the "Quit magus" row all land here, and there is no third
+	// "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 choice = chosen === null ? null : parseProfileChoice(chosen, need);
+	const value = picked === null ? undefined : options[picked]?.value;
+	const choice = value === undefined ? null : parseProfileChoice(value, need);
 	if (!choice) {
-		console.error(failLine("No active profile — stopping."));
+		console.error(failLine("No profile chosen — stopping."));
 		return null;
 	}
 
 	const result = await applyProfileChoice(choice, need.manifest, projectPath, {
 		onDisplace: reportDisplaced(projectPath),
 	});
-	console.log(`✓ Active profile: ${result.profileId}`);
-	printActivationNotes(result);
+	console.log(okLine(`Using profile ${bold(result.profileId)}`));
+	printActivationNotes(result, { tracked: opts.reportTracked !== false });
 	console.log("");
 
 	// Re-read rather than return `need.manifest`: adopting wrote a new profile

package/src/cli/doctor.ts

@@ -46,7 +46,7 @@ import {
 	type RepoRootCache,
 	pickLoadedEntry,
 } from "../services/plugin-resolution.js";
-import { trackedGeneratedFiles } from "../services/profile-activate.js";
+import { trackedGeneratedNotices } from "../services/profile-activate.js";
 import {
 	LIVE_FILE_KEYS,
 	liveKind,
@@ -67,10 +67,6 @@ import {
 	switchHint,
 } from "../services/profile-state.js";
 import { resolveAllProfiles } from "../services/resolver.js";
-import {
-	GitCheckError,
-	untrackCommand,
-} from "../services/tracked-live-files.js";
 import type {
 	ClaudeSettings,
 	InstalledPluginsRegistry,
@@ -556,21 +552,12 @@ export async function reportProfileState(
 		}
 	}
 
-	// A .gitignore entry does not untrack a file committed before it. Report
-	// only: magus never runs git rm.
-	let tracked: string[] = [];
-	try {
-		tracked = await trackedGeneratedFiles(projectPath);
-	} catch (error) {
-		if (!(error instanceof GitCheckError)) throw error;
-		console.log(`✗ ${error.message}`);
-		unfixable++;
-	}
-	for (const rel of tracked) {
-		console.log(
-			`✗ ${rel} is generated from profiles.json but tracked by git. Fix: \`${untrackCommand(rel)}\`, then commit.`,
-		);
-		unfixable++;
+	// A .gitignore entry does not untrack a file committed before it. A note
+	// with the fix, not a failure: magus writes the file all the same, and
+	// never runs git rm itself.
+	for (const n of await trackedGeneratedNotices(projectPath)) {
+		console.log(`• ${n.problem}`);
+		for (const line of n.fix) console.log(`  ${line}`);
 	}
 	return { fixable, unfixable };
 }