magus-cli 7.5.2 → 7.5.4

package/src/services/profile-startup.ts

@@ -26,6 +26,12 @@
  *
  *   ok           a profile is active; the manifest is in effect; ask nothing
  *   unmigrated   no manifest — the project is not using profiles at all
+ *   old-format   the project is on an older magus profile format; asked about
+ *                before it is updated, in the CLI and the TUI alike
+ *   nested       no manifest here, but this folder is inside a project that
+ *                has one — Claude Code started here would read this folder's
+ *                settings, not that project's, so nothing is offered: the way
+ *                on is running magus in that project, or `magus profile init`
  *   inactive     a manifest with profiles, none of them activated
  *   unknown      the active-profile marker names a profile the manifest does
  *                not define; the only way on is activating one that exists
@@ -50,18 +56,25 @@
  * detects.
  */
 
+import path from "node:path";
 import type { ProfileManifest } from "../types/index.js";
 // Type-only, so it is erased: this module stays free of the UI and of React,
 // which is what lets `magus hook` and the CLI import it. The shape of a
 // selectable option is presentation-neutral data, and both surfaces render the
 // same list from these builders rather than each composing its own.
 import type { SelectOption } from "../ui/state/types.js";
-import { MANIFEST_FILE, emptyManifest, readManifest } from "./manifest.js";
+import {
+	MANIFEST_FILE,
+	emptyManifest,
+	findEnclosingManifest,
+	readManifest,
+} from "./manifest.js";
 import type { ProfileChoice } from "./profile-activate.js";
 import { freeProfileId } from "./profile-adopt.js";
 import {
 	activeProfile,
 	displaceableArtifacts,
+	hasOlderLayout,
 	namedActiveProfile,
 } from "./profile-live.js";
 import { prepareProfileState } from "./profile-state.js";
@@ -71,6 +84,8 @@ import { SettingsParseError } from "./settings-file.js";
 export type ProfileStartupState =
 	| "ok"
 	| "unmigrated"
+	| "old-format"
+	| "nested"
 	| "inactive"
 	| "unknown"
 	| "unparseable";
@@ -102,6 +117,11 @@ export interface ProfileStartupNeed {
 	activate: ActivatableProfile[];
 	/** For `unknown`: the profile the marker names. */
 	unknownProfile?: string;
+	/**
+	 * For `nested`: the enclosing project — its path relative to this folder
+	 * and its folder name, which is how the user knows it.
+	 */
+	enclosing?: { rel: string; name: string };
 	/**
 	 * The profile this project declares it wants, if the manifest names one that
 	 * exists. Used to preselect the row so Enter does the intended thing.
@@ -167,6 +187,24 @@ export async function detectProfileStartupNeed(
 	const ids = Object.keys(manifest.profiles);
 
 	if (ids.length === 0) {
+		// One decision for the CLI and the TUI alike. It lived in the CLI alone,
+		// so `magus update` in a subfolder explained and stopped while the TUI in
+		// the same folder offered to save a second, separate profile.
+		const enclosing = await findEnclosingManifest(projectPath);
+		if (enclosing !== null) {
+			return {
+				state: "nested",
+				adopt: null,
+				activate: [],
+				declaredDefault: null,
+				autoActivate: false,
+				manifest,
+				enclosing: {
+					rel: path.relative(projectPath, enclosing),
+					name: path.basename(enclosing),
+				},
+			};
+		}
 		return {
 			state: "unmigrated",
 			adopt: freeProfileId(manifest),
@@ -242,11 +280,45 @@ export async function detectProfileStartupNeed(
 	};
 }
 
+/**
+ * The `old-format` question, or null when the project is not on an older
+ * magus profile format. One source for the CLI's gate and the TUI's startup,
+ * so both ask the same thing — the TUI used to convert without asking while
+ * the CLI asked.
+ */
+export async function oldFormatNeed(
+	projectPath: string,
+): Promise<ProfileStartupNeed | null> {
+	if (!(await hasOlderLayout(projectPath))) return null;
+	let manifest: ProfileManifest;
+	try {
+		manifest = await readManifest(projectPath);
+	} catch (error) {
+		if (!(error instanceof SettingsParseError)) throw error;
+		return unparseableNeed(error);
+	}
+	return {
+		state: "old-format",
+		adopt: null,
+		activate: [],
+		declaredDefault: null,
+		autoActivate: false,
+		manifest,
+	};
+}
+
 /** 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. */
 	notices: string[];
+	/**
+	 * One line per thing the gate REFUSED — the lines the CLI stops on. Kept
+	 * apart from `notices` because a refusal can leave detection reading `ok`:
+	 * an old layout whose settings file does not parse is not converted, yet
+	 * still names its profile, so only this says the update did not happen.
+	 */
+	problems: string[];
 }
 
 /**
@@ -257,17 +329,66 @@ export interface ProfileStartup {
  */
 export async function prepareProfileStartup(
 	projectPath: string,
+	/**
+	 * Update an older profile format. Without it, a project on one is answered
+	 * with the `old-format` question and NOTHING is converted — the TUI asks
+	 * first, as the CLI does; the modal's "Update it now" calls back with this.
+	 */
+	opts: { convert?: boolean } = {},
 ): Promise<ProfileStartup> {
+	if (!opts.convert) {
+		const format = await oldFormatNeed(projectPath);
+		if (format !== null) return { need: format, notices: [], problems: [] };
+	}
 	const notices: string[] = [];
+	const problems: string[] = [];
 	try {
 		const prep = await prepareProfileState(projectPath);
-		notices.push(...prep.lines, ...prep.problems);
+		notices.push(...prep.lines);
+		problems.push(...prep.problems);
 	} catch (error) {
 		if (!(error instanceof SettingsParseError)) {
-			notices.push(error instanceof Error ? error.message : String(error));
+			problems.push(error instanceof Error ? error.message : String(error));
 		}
 	}
-	return { need: await detectProfileStartupNeed(projectPath), notices };
+	return {
+		need: await detectProfileStartupNeed(projectPath),
+		notices,
+		problems,
+	};
+}
+
+/** What the TUI shows once "Update it now" has run. */
+export type FormatUpdateOutcome =
+	| { kind: "ask"; need: ProfileStartupNeed }
+	| { kind: "updated"; title: string; message: string }
+	| { kind: "failed"; title: string; message: string };
+
+/**
+ * The verdict on an old-format update, from {@link prepareProfileStartup}'s
+ * result. A refusal is a failure even when detection reads `ok` — the CLI
+ * stops on the same lines, and the TUI used to show "Profile format updated"
+ * over a message saying magus had not updated it.
+ */
+export function formatUpdateOutcome(
+	result: ProfileStartup,
+): FormatUpdateOutcome {
+	if (result.problems.length > 0) {
+		return {
+			kind: "failed",
+			title: "Could not update the profile format",
+			message: [...result.problems, "", "Your profiles are kept."].join("\n"),
+		};
+	}
+	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.",
+	};
 }
 
 // ─── What to offer, as data both surfaces render ─────────────────────────────
@@ -276,6 +397,8 @@ export async function prepareProfileStartup(
 export const ADOPT_VALUE = "adopt";
 export const QUIT_VALUE = "quit";
 export const ACTIVATE_PREFIX = "activate:";
+/** The `old-format` question's "Update it now" row. Not a profile choice. */
+export const UPDATE_FORMAT_VALUE = "update-format";
 
 /**
  * Title and message for the state we are in.
@@ -349,6 +472,35 @@ export function describeNeed(need: ProfileStartupNeed): {
 		};
 	}
 
+	if (need.state === "old-format") {
+		return {
+			title: "This project uses an old magus profile format",
+			message:
+				"magus has to update it before it can manage this project.\n\nYour profiles, plugins and custom skills are kept.",
+		};
+	}
+
+	if (need.state === "nested") {
+		// The one other place a path appears, and for the same reason as
+		// `unparseable`: the folder IS the message. It sits on a line of its own,
+		// short, so the modal never wraps it at a `.`. The reason is stated as
+		// Claude Code's behaviour, which it is — magus follows it.
+		const at = need.enclosing;
+		return {
+			title: "Inside another Claude Code project",
+			message: [
+				"This folder is inside a Claude Code project that already has profiles:",
+				"",
+				`  ${at?.rel ?? ".."}  (${at?.name ?? "?"})`,
+				"",
+				"Claude Code treats each folder you start it in as a separate project, with its own plugins and settings, and magus follows it.",
+				"",
+				"To manage plugins for the whole project, run magus there.",
+				"To give this folder a setup of its own, run magus profile init here.",
+			].join("\n"),
+		};
+	}
+
 	if (need.state === "unknown") {
 		return {
 			title: "Active profile no longer exists",
@@ -390,6 +542,10 @@ export function describeNeed(need: ProfileStartupNeed): {
 export function buildProfileOptions(need: ProfileStartupNeed): SelectOption[] {
 	const options: SelectOption[] = [];
 
+	if (need.state === "old-format") {
+		options.push({ label: "Update it now", value: UPDATE_FORMAT_VALUE });
+	}
+
 	if (need.adopt !== null) {
 		options.push({
 			// Says what it PRESERVES, not what it creates. "Create <id> from this

package/src/services/profile-state.ts

@@ -41,10 +41,6 @@ import {
 	type ProfileChoice,
 	activateProfile,
 	activationNotes,
-	activeWritableSkillFolders,
-	assertNoTrackedWriteTargets,
-	writableSkillFolders,
-	writeRefusal,
 } from "./profile-activate.js";
 import { adoptCurrentProject } from "./profile-adopt.js";
 import {
@@ -73,7 +69,6 @@ import {
 	skillFolder,
 } from "./profile-skills.js";
 import type { SettingsParseError } from "./settings-file.js";
-import type { LiveFileRefusal } from "./tracked-live-files.js";
 
 export type ActiveProfileCheck =
 	| { state: "no-profiles" }
@@ -266,7 +261,7 @@ export function describeUnknownProfile(
 export function describeUnmarked(
 	check: Extract<ActiveProfileCheck, { state: "unmarked" }>,
 ): string {
-	return `No profile is active in this project, and its live config matches no single profile. Run ${switchHint(check.available, check.suggested)}.`;
+	return `No profile is active in this project, and its plugins match none of the profiles. Run ${switchHint(check.available, check.suggested)}.`;
 }
 
 /**
@@ -304,11 +299,6 @@ export interface ProfileStatePrep {
 	problems: string[];
 	/** The files behind `problems` that could not be parsed. */
 	unreadable: SettingsParseError[];
-	/**
-	 * Set when a file magus would write is tracked by git, or git could not
-	 * say: nothing ran, and `problems` holds its message.
-	 */
-	refusal?: LiveFileRefusal;
 }
 
 /**
@@ -322,27 +312,6 @@ export async function prepareProfileState(
 	projectPath: string,
 	opts: Pick<ActivateOptions, "installSkill"> = {},
 ): Promise<ProfileStatePrep> {
-	// A project with profiles whose live files — or the active profile's
-	// magus-installed skill folders — git tracks: every path below would write
-	// one of them (or the marker, or the manifest on the way), so nothing runs,
-	// not even the marker a unique match would restore.
-	const manifest = await readManifest(projectPath);
-	if (Object.keys(manifest.profiles).length > 0) {
-		const refusal = await writeRefusal(
-			projectPath,
-			await activeWritableSkillFolders(projectPath, manifest),
-		);
-		if (refusal) {
-			return {
-				check: await checkActiveProfile(projectPath, { restore: false }),
-				reconcile: null,
-				lines: [],
-				problems: [refusal.message],
-				unreadable: [],
-				refusal,
-			};
-		}
-	}
 	const check = await checkActiveProfile(projectPath);
 	const out: ProfileStatePrep = {
 		check,
@@ -359,7 +328,7 @@ export async function prepareProfileState(
 
 	if (check.state === "active" && check.restored) {
 		out.lines.push(
-			`No active-profile marker, but the live config matches profile "${check.profile}" exactly — restored it`,
+			`Using profile "${check.profile}" — this project's plugins match it`,
 		);
 	}
 
@@ -384,10 +353,11 @@ export async function prepareProfileState(
 			);
 			if (check.state === "old-layout") {
 				out.lines.push(
-					`Converted profile "${profile}" from the older layout to real files`,
+					`Updated profile "${profile}" to the current profile format`,
 				);
 			}
-			out.lines.push(...activationNotes(result));
+			// Tracked files are the command's to report, once (see profile-absorb).
+			out.lines.push(...activationNotes(result, { tracked: false }));
 		}
 		out.check = { state: "active", profile, restored: false };
 	}
@@ -417,11 +387,11 @@ export async function inspectProfileState(
 
 	if (check.state === "old-layout") {
 		pending.push(
-			`Profile "${check.profile}" is on an older magus layout (links into .claude/_profiles/). The next magus command, or \`magus doctor --fix\`, adds any changes Claude Code made under it to profiles.json, converts it to real files, and keeps .claude/_profiles/ in .claude/.magus-backups/.`,
+			`Profile "${check.profile}" uses an old magus profile format. The next magus command, or \`magus doctor --fix\`, updates it — keeping any changes Claude Code made, and a backup of the old format.`,
 		);
 	} else if (check.state === "unmarked" && check.match !== null) {
 		pending.push(
-			`No active-profile marker, but the live config matches profile "${check.match}" exactly — the next magus command, or \`magus doctor --fix\`, restores it.`,
+			`This project's plugins match profile "${check.match}" — the next magus command, or \`magus doctor --fix\`, switches to it.`,
 		);
 	} else if (
 		check.state === "active" &&
@@ -524,22 +494,6 @@ export async function switchToProfile(
 		);
 		return result;
 	}
-	// Before the absorbs below write profiles.json: nothing at all is written
-	// when a live file this switch would write is tracked by git.
-	const marker = await readActiveMarker(projectPath);
-	const refusal = await writeRefusal(projectPath, [
-		...(await writableSkillFolders(
-			projectPath,
-			target.skills ?? [],
-			marker?.skills,
-		)),
-		...(await activeWritableSkillFolders(projectPath, before)),
-	]);
-	if (refusal) {
-		result.problems.push(refusal.message);
-		return result;
-	}
-
 	if (!take(await absorbBeforeConversion(projectPath, name))) return result;
 	const installSkill = { installSkill: opts.installSkill };
 	if (!take(await reconcileActiveProfile(projectPath, installSkill))) {
@@ -580,20 +534,6 @@ export async function applyProfileChoice(
 	projectPath: string,
 	opts: ActivateOptions = {},
 ): Promise<ActivationResult> {
-	// Nothing is written — not the adopted manifest, not an absorbed edit —
-	// when a live file this choice would write is tracked by git.
-	const skills =
-		choice.kind === "activate"
-			? (manifest.profiles[choice.id]?.skills ?? [])
-			: [];
-	await assertNoTrackedWriteTargets(
-		projectPath,
-		await writableSkillFolders(
-			projectPath,
-			skills,
-			(await readActiveMarker(projectPath))?.skills,
-		),
-	);
 	if (choice.kind === "activate") {
 		const absorbed: string[] = [];
 		let changed = false;
@@ -635,7 +575,6 @@ export async function prepareProfileWrite(
 	projectPath: string,
 ): Promise<ProfileStatePrep> {
 	const prep = await prepareProfileState(projectPath);
-	if (prep.refusal) throw prep.refusal;
 	refuseOnProblems(prep);
 	return prep;
 }

package/src/services/tracked-live-files.ts

@@ -1,76 +1,75 @@
 /**
- * magus never writes a generated file that git tracks.
+ * Generated files that git tracks: reported, never refused.
  *
- * In a project with profiles, `.claude/settings.json`, `.mcp.json` and
- * `.claude/models.json` are generated per developer from `.claude/profiles.json`.
- * A committed copy is the team's hand-kept file: writing it leaves git
- * tracking a file that now differs per developer, so every write shows as a
- * modified tracked file and one developer's plugin set gets committed for
- * everyone. `.gitignore` cannot fix that — it does not untrack a file already
- * committed. So every writer refuses, having written nothing, and says how to
- * stop tracking it; the user decides.
+ * In a project with profiles, `.claude/settings.json`, `.mcp.json`,
+ * `.claude/models.json` and the magus-installed skill folders are generated
+ * per developer from `.claude/profiles.json`, and are expected to be
+ * gitignored. A repository that committed one before adopting profiles keeps
+ * tracking it — `.gitignore` does not untrack a committed file.
  *
- * Activation checks every path it would write up front (`profile-activate.ts`).
- * This module holds the refusal itself, and the check for the writers outside
- * activation: the TUI's direct settings edits, `.mcp.json` edits, and the
- * Claude CLI's project-scope installs, which write `.claude/settings.json`.
+ * magus writes those files anyway: every command that writes them proceeds
+ * exactly as for an untracked file. What changes is what it says. The CLI
+ * prints one warning per tracked file with the fix (`git rm --cached <path>`,
+ * then commit) and never runs git itself; `magus doctor` reports it as a note;
+ * the TUI asks on every open and, when told to, untracks them in place
+ * (`gitignore-check.ts`, `profileGitignoreManifest`).
  */
 
 import path from "node:path";
+import type { GitignoreManifest } from "../types/gitignore.js";
 import { GitQueryError, trackedByGit } from "./git-worktree.js";
 import { getManifestPath, readProfilesFile } from "./manifest.js";
-
-/** magus refused to write a live file, and changed nothing. */
-export class LiveFileRefusal extends Error {}
-
-/** A live file magus would write is tracked by git. */
-export class TrackedLiveFileError extends LiveFileRefusal {
-	constructor(readonly paths: readonly string[]) {
-		const one = paths.length === 1;
-		super(
-			[
-				`magus will not write ${one ? "a file" : "files"} git tracks in this project — ${
-					one ? "it is" : "they are"
-				} generated from .claude/profiles.json and ${one ? "differs" : "differ"} per developer:`,
-				...paths.map((p) => `  ${p}`),
-				`Stop tracking ${one ? "it" : "them"}, commit, then run the command again:`,
-				...paths.map((p) => `  ${untrackCommand(p)}`),
-				'  git commit -m "Stop tracking generated Claude Code config"',
-				"Nothing was changed.",
-			].join("\n"),
-		);
-		this.name = "TrackedLiveFileError";
-	}
-}
+import {
+	LIVE_FILE_KEYS,
+	livePath,
+	readActiveMarker,
+	skillsRoot,
+} from "./profile-live.js";
 
 /**
  * The project is a git work tree, but git could not say what it tracks — it
  * timed out, is missing, or refused the repository (`detected dubious
- * ownership`). Answering "nothing is tracked" would let magus write a tracked
- * file, so it refuses instead and passes on git's own words.
+ * ownership`). Reported with git's own words wherever the check is made; it
+ * never stops a write.
  */
-export class GitCheckError extends LiveFileRefusal {
+export class GitCheckError extends Error {
 	constructor(readonly detail: string) {
 		super(
-			[
-				"magus could not check which files git tracks in this project, so it wrote nothing. git said:",
-				...detail
-					.trim()
-					.split("\n")
-					.map((line) => `  ${line}`),
-				"Fix that, then run the command again. Nothing was changed.",
-			].join("\n"),
+			`magus could not check which files git tracks in this project. git said: ${detail.trim()}`,
 		);
 		this.name = "GitCheckError";
 	}
 }
 
-/** How to untrack one generated path — `-r` for a skill folder. */
+/** How to untrack one generated path. */
 export function untrackCommand(rel: string): string {
-	const isDir =
-		rel.split(path.sep).length > 2 &&
-		rel.startsWith(path.join(".claude", "skills") + path.sep);
-	return isDir ? `git rm --cached -r ${rel}` : `git rm --cached ${rel}`;
+	return `git rm --cached ${rel}`;
+}
+
+/** A tracked generated path, as reported: the problem, then the fix beneath. */
+export interface TrackedNotice {
+	problem: string;
+	/** Lines under the problem. Empty when git itself could not be asked. */
+	fix: string[];
+}
+
+/**
+ * The notice for one tracked generated path.
+ *
+ * Short lines, not one long one. The single line this replaced ran the
+ * problem, the cause and the command together and wrapped mid-command at 80
+ * columns; the owner read it as confusing. Now: what is wrong, what the user
+ * will see because of it, and the command alone on its line to be copied —
+ * each under 80 columns with the report's indent.
+ */
+export function trackedNotice(rel: string): TrackedNotice {
+	return {
+		problem: `git tracks ${rel}, but magus rewrites it`,
+		fix: [
+			"It will keep showing as changed. Untrack it — the file stays on disk:",
+			`${untrackCommand(rel)}, then commit`,
+		],
+	};
 }
 
 /**
@@ -92,34 +91,70 @@ export async function trackedPaths(
 }
 
 /**
- * Does magus generate this project's live files — does its profiles.json
- * define a profile? A profiles.json that cannot be read counts as yes: the
- * check that follows only ever stops a write.
+ * Of `folders` under `.claude/skills/`, the ones git tracks — the team's own
+ * copies. A skill folder git tracks is the team's, never magus's: magus does
+ * not install over it, manage it, flag it or untrack it. Empty when git cannot
+ * say, so a failed git call never turns a team skill into one magus removes —
+ * it only leaves a folder magus recorded as its own until git answers.
  */
-async function hasProfiles(projectPath: string): Promise<boolean> {
+export async function trackedSkillFolders(
+	projectPath: string,
+	folders: readonly string[],
+): Promise<Set<string>> {
+	if (folders.length === 0) return new Set();
+	const root = path.relative(projectPath, skillsRoot(projectPath));
+	let tracked: Set<string>;
 	try {
-		const file = await readProfilesFile(getManifestPath(projectPath));
-		return Object.keys(file.profiles).length > 0;
-	} catch {
-		return true;
+		tracked = await trackedPaths(
+			projectPath,
+			[],
+			folders.map((folder) => path.join(root, folder)),
+		);
+	} catch (error) {
+		if (error instanceof GitCheckError) return new Set();
+		throw error;
 	}
+	return new Set(folders.filter((f) => tracked.has(path.join(root, f))));
 }
 
 /**
- * Throw {@link TrackedLiveFileError} — before anything is written — when
- * `projectPath` has profiles and git tracks any of `files` (absolute, or
- * relative to the project). A project without profiles owns its files by
- * hand, and writing them is not magus's to refuse.
+ * The gitignore rules the profile model implies, for the gitignore manager's
+ * `profile` tier — or null in a project without profiles.
+ *
+ * In a project with profiles — profiles.json defines at least one — the three
+ * live files and the magus-installed skill folders are generated per
+ * developer, so they must be ignored. The built-in defaults say to TRACK
+ * `.claude/settings.json` and `.mcp.json`, which is right for a project that
+ * writes them by hand; this tier overrides that for a profiled one, so a
+ * committed copy is reported as "tracked but should be ignored". A left-over
+ * marker in a repo that dropped profiles.json does not make it profiled.
+ *
+ * A skill folder git tracks is left out even when the marker records it:
+ * markers written by 7.5.0's conversion recorded committed skills as
+ * magus-installed, and the team's copy must never be flagged or untracked.
  */
-export async function refuseTrackedLiveFiles(
+export async function profileGitignoreManifest(
 	projectPath: string,
-	files: readonly string[],
-): Promise<void> {
-	if (!(await hasProfiles(projectPath))) return;
-	const rel = files.map((f) =>
-		path.isAbsolute(f) ? path.relative(projectPath, f) : f,
-	);
-	const tracked = await trackedPaths(projectPath, rel);
-	const hit = rel.filter((r) => tracked.has(r));
-	if (hit.length > 0) throw new TrackedLiveFileError(hit);
+): Promise<GitignoreManifest | null> {
+	try {
+		const file = await readProfilesFile(getManifestPath(projectPath));
+		if (Object.keys(file.profiles).length === 0) return null;
+	} catch {
+		return null; // An unreadable profiles.json is reported by every profile command.
+	}
+	const marker = await readActiveMarker(projectPath);
+	const managed = Object.keys(marker?.skills ?? {});
+	const committed = await trackedSkillFolders(projectPath, managed);
+	const posix = (abs: string) =>
+		path.relative(projectPath, abs).split(path.sep).join("/");
+	const skills = posix(skillsRoot(projectPath));
+	return {
+		ignore: [
+			...LIVE_FILE_KEYS.map((key) => posix(livePath(key, projectPath))),
+			...managed
+				.filter((folder) => !committed.has(folder))
+				.map((folder) => `${skills}/${folder}/`),
+		],
+		track: [],
+	};
 }