magus-cli 7.9.1 → 7.10.0

package/src/cli/update-view.ts

@@ -34,6 +34,10 @@ import {
 	type UpdatePlan,
 	isKeptDeprecated,
 } from "../services/update-plan.js";
+import type {
+	UnsetWorktree,
+	WorktreeSetupResult,
+} from "../services/worktree-profiles.js";
 import { type ReportBadgeKind, reportBadge } from "../ui/theme-mode.js";
 import { brand } from "../ui/theme.js";
 import { formatCommand } from "../utils/command-utils.js";
@@ -903,3 +907,72 @@ export function pendingHeadline(plan: UpdatePlan): string {
 		!plan.skills.some((s) => s.action === "install");
 	return onlyRemovals ? "Changes pending" : "Updates available";
 }
+
+// -- other worktrees -----------------------------------------------------------
+//
+// The other working trees of this repository that have no profile set up
+// (`findUnsetWorktrees`). `magus update` sets up the ones the project already
+// answered for, exactly as it does its own folder, and says so in one line.
+// No section and no question: there is nothing to decide. Read-only runs
+// (`magus doctor`, `--check`, `--dry-run`) get the same one line as a warning.
+
+/** `Worktree a` or `Worktrees a, b, c + 2 more`, so the row stays one line. */
+function worktreeLabel(names: readonly string[]): string {
+	const shown = names.slice(0, 3).join(", ");
+	const list = names.length > 3 ? `${shown} + ${names.length - 3} more` : shown;
+	return `${names.length === 1 ? "Worktree" : "Worktrees"} ${bold(list)}`;
+}
+
+/**
+ * The worktree rows: after a setup (`results`), one `✓` line for every
+ * worktree set up and a `✗` line for each failure; on a read-only run
+ * (`results` null), one `⚠` line for the ones `magus update` would set up.
+ * A worktree that needs a choice gets its own `⚠` line either way. Empty for
+ * an empty list: a repository with nothing to say prints nothing.
+ */
+export function worktreeLines(
+	worktrees: readonly UnsetWorktree[],
+	results: readonly WorktreeSetupResult[] | null,
+): string[] {
+	if (worktrees.length === 0) return [];
+	const lines = [""];
+	if (results === null) {
+		const auto = worktrees.filter((w) => w.autoActivate).map((w) => w.name);
+		if (auto.length > 0) {
+			const one = auto.length === 1;
+			lines.push(
+				warn(
+					`${worktreeLabel(auto)} ${one ? "is" : "are"} missing this project's plugins. magus update sets ${one ? "it" : "them"} up.`,
+				),
+			);
+		}
+	} else {
+		const done = results.filter((r) => r.ok).map((r) => r.name);
+		if (done.length > 0) {
+			lines.push(
+				ok(
+					`${worktreeLabel(done)} now ${done.length === 1 ? "has" : "have"} this project's plugins.`,
+				),
+			);
+		}
+		for (const r of results) {
+			if (!r.ok) {
+				lines.push(
+					fail(
+						`Worktree ${bold(r.name)} was not set up: ${r.reason.replace(/\.+$/, "")}.`,
+					),
+				);
+			}
+		}
+	}
+	for (const w of worktrees) {
+		if (!w.autoActivate) {
+			lines.push(
+				warn(
+					`Worktree ${bold(w.name)} is missing this project's plugins. Run magus update there to choose a profile.`,
+				),
+			);
+		}
+	}
+	return lines;
+}

package/src/cli/update.ts

@@ -84,6 +84,7 @@ import {
 	planSkillUpdates,
 	summarizePlan,
 } from "../services/update-plan.js";
+import type { ProfileManifest } from "../types/index.js";
 import { brand } from "../ui/theme.js";
 import { bold, dim, fg, width } from "./ansi.js";
 import { ensureManifest, requireActiveProfile } from "./bootstrap.js";
@@ -108,6 +109,7 @@ import {
 	unknownToolsNotice,
 	warn as warnLine,
 } from "./update-view.js";
+import { setUpOtherWorktrees } from "./worktrees.js";
 
 interface UpdateFlags {
 	/** Report drift and exit 1 if anything is behind. The CI gate. */
@@ -250,6 +252,25 @@ export async function runUpdateCommand(
 	// what it promised. A refused `--check` exits 1, because that is a gate.
 	if (!current) return flags.dryRun ? 0 : 1;
 
+	const code = await updateProfile(flags, projectPath, current, startedAt);
+
+	// This project is on a profile; now the other worktrees of the repository,
+	// set up the same way without asking. After the update, so their line is
+	// not lost above the plan. Read-only under `--check` and `--dry-run`, and
+	// never a change to the exit code: those are other projects.
+	await setUpOtherWorktrees(projectPath, {
+		mayWrite: !flags.check && !flags.dryRun,
+	});
+	return code;
+}
+
+/** The update itself, once the project's own profile gate has passed. */
+async function updateProfile(
+	flags: UpdateFlags,
+	projectPath: string,
+	current: ProfileManifest,
+	startedAt: number,
+): Promise<number> {
 	const profileIds = Object.keys(current.profiles);
 	if (flags.profile && !current.profiles[flags.profile]) {
 		console.error(

package/src/cli/worktrees.ts

@@ -0,0 +1,32 @@
+/**
+ * The other worktrees of this repository at the end of `magus update`: the ones
+ * with no profile set up. Each one whose project already declares a profile,
+ * with nothing of the user's to replace, is set up without asking, exactly as
+ * `magus update` sets up its own folder. Then one line says so.
+ *
+ * Detection and apply are `services/worktree-profiles.ts`, shared with
+ * `magus doctor` and the TUI; the words are `update-view.ts`.
+ */
+
+import {
+	findUnsetWorktrees,
+	setUpWorktrees,
+} from "../services/worktree-profiles.js";
+import { worktreeLines } from "./update-view.js";
+
+/**
+ * Set up what can be set up when `mayWrite`, and print the rows. Under
+ * `--check` and `--dry-run` it only reports. Never changes the command's exit
+ * code: these are other projects, and a failure in one is reported on its row.
+ */
+export async function setUpOtherWorktrees(
+	projectPath: string,
+	opts: { mayWrite: boolean },
+): Promise<void> {
+	const worktrees = await findUnsetWorktrees(projectPath);
+	if (worktrees.length === 0) return;
+	const results = opts.mayWrite
+		? await setUpWorktrees(worktrees.filter((w) => w.autoActivate))
+		: null;
+	for (const line of worktreeLines(worktrees, results)) console.log(line);
+}

package/src/services/git-worktree.ts

@@ -190,6 +190,47 @@ export async function inheritablePaths(projectPath: string): Promise<string[]> {
 	return paths;
 }
 
+/** One working tree of a repository, as `git worktree list` reports it. */
+export interface WorkingTree {
+	/** Absolute path, as git recorded it. */
+	path: string;
+	/** git says its folder is gone (`prunable`); the record outlives it. */
+	prunable: boolean;
+}
+
+/**
+ * Every working tree of `projectPath`'s repository — the main one first, then
+ * each linked worktree — and the one `projectPath` itself sits in.
+ *
+ * Null when git cannot say: not a repository, git missing or not answering.
+ * A bare repository's own record has no working tree and is left out. Reads
+ * only; never caches, because a worktree added while magus runs is exactly
+ * what a caller of this wants to see.
+ */
+export async function listWorkingTrees(
+	projectPath: string,
+): Promise<{ self: string; trees: WorkingTree[] } | null> {
+	const dir = path.resolve(projectPath);
+	const [top, list] = await Promise.all([
+		git(dir, ["rev-parse", "--show-toplevel"]),
+		git(dir, ["worktree", "list", "--porcelain"]),
+	]);
+	if (top.code !== 0 || !top.out || list.code !== 0) return null;
+	const trees: WorkingTree[] = [];
+	for (const record of list.out.split(/\n\s*\n/)) {
+		const lines = record.split("\n").map((l) => l.trim());
+		const line = lines.find((l) => l.startsWith("worktree "));
+		if (!line || lines.includes("bare")) continue;
+		trees.push({
+			path: path.resolve(line.slice("worktree ".length)),
+			prunable: lines.some(
+				(l) => l === "prunable" || l.startsWith("prunable "),
+			),
+		});
+	}
+	return { self: path.resolve(top.out), trees };
+}
+
 async function resolveInheritable(
 	dir: string,
 ): Promise<{ paths: string[]; answered: boolean }> {

package/src/services/plugin-mcp-config.ts

@@ -217,7 +217,9 @@ export async function getPluginSourcePath(
 				const plugin = manifest.plugins.find(
 					(p: { name: string }) => p.name === pluginName,
 				);
-				return plugin?.source;
+				// An object source (git-subdir, github, url) is fetched from its own
+				// repo, not read from the marketplace clone, so there is no local path.
+				return typeof plugin?.source === "string" ? plugin.source : undefined;
 			}
 		}
 	} catch {

package/src/services/worktree-profiles.ts

@@ -0,0 +1,181 @@
+/**
+ * The other working trees of this repository that carry a magus manifest but
+ * have no profile in effect — and setting them up.
+ *
+ * A profiled project's generated files are git-ignored, so git never gives
+ * them to a new worktree. Claude Code treats the folder it starts in as the
+ * project and reads only that folder's settings, so a session started in such
+ * a worktree loads only the plugins turned on at USER scope. magus run in that
+ * worktree would fix it (`autoActivate`), but nothing tells the user to.
+ *
+ * So magus, run anywhere in the repository, looks at the other working trees
+ * too. Detection and apply are kept apart, and every surface — `magus update`,
+ * `magus doctor` and the TUI — uses these two functions; none of them decides
+ * anything of its own beyond how to show the result.
+ *
+ * Detection writes nothing, anywhere: it is `detectProfileStartupNeed` per
+ * working tree, which is detection only. Apply is the activation the normal
+ * gate runs for a fresh clone, against THAT worktree's own manifest — nothing
+ * is ever copied between worktrees.
+ */
+
+import { realpath, stat } from "node:fs/promises";
+import path from "node:path";
+import { listWorkingTrees } from "./git-worktree.js";
+import { getManifestPath, readManifest } from "./manifest.js";
+import {
+	type ProfileStartupState,
+	detectProfileStartupNeed,
+} from "./profile-startup.js";
+import { applyProfileChoice } from "./profile-state.js";
+import { SettingsParseError } from "./settings-file.js";
+
+export interface UnsetWorktree {
+	/** Absolute path of that working tree. */
+	path: string;
+	/** Its folder name, how the user knows it. */
+	name: string;
+	/** From `detectProfileStartupNeed(path)`; never "ok". */
+	state: ProfileStartupState;
+	declaredDefault: string | null;
+	/** The repo declares a profile and nothing would be replaced. */
+	autoActivate: boolean;
+}
+
+export type WorktreeSetupResult =
+	| { path: string; name: string; ok: true; profileId: string }
+	| { path: string; name: string; ok: false; reason: string };
+
+/** The canonical spelling of a path, so `/tmp` and `/private/tmp` compare equal. */
+async function canonical(p: string): Promise<string> {
+	try {
+		return await realpath(p);
+	} catch {
+		return path.resolve(p);
+	}
+}
+
+async function isDirectory(p: string): Promise<boolean> {
+	try {
+		return (await stat(p)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+
+async function isFile(p: string): Promise<boolean> {
+	try {
+		return (await stat(p)).isFile();
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Read-only. The other working trees of `projectPath`'s repository that need
+ * setup, sorted by name.
+ *
+ * Left out: `projectPath`'s own working tree (the normal gate handles it), a
+ * working tree whose folder is gone, one with no manifest (not a magus
+ * project on that branch), and one already on a profile. Not a repository, or
+ * git failing, is `[]`.
+ */
+export async function findUnsetWorktrees(
+	projectPath: string,
+): Promise<UnsetWorktree[]> {
+	let listing: Awaited<ReturnType<typeof listWorkingTrees>>;
+	try {
+		listing = await listWorkingTrees(projectPath);
+	} catch {
+		return [];
+	}
+	if (listing === null) return [];
+	const self = await canonical(listing.self);
+
+	const found = await Promise.all(
+		listing.trees.map(async (tree): Promise<UnsetWorktree | null> => {
+			if (tree.prunable || !(await isDirectory(tree.path))) return null;
+			const at = await canonical(tree.path);
+			if (at === self) return null;
+			if (!(await isFile(getManifestPath(at)))) return null;
+			try {
+				const need = await detectProfileStartupNeed(at);
+				if (need.state === "ok") return null;
+				return {
+					path: at,
+					name: path.basename(at),
+					state: need.state,
+					declaredDefault: need.declaredDefault,
+					autoActivate: need.autoActivate && need.declaredDefault !== null,
+				};
+			} catch {
+				// One working tree magus cannot read says nothing about the others.
+				return null;
+			}
+		}),
+	);
+
+	const seen = new Set<string>();
+	return found
+		.filter((w): w is UnsetWorktree => {
+			if (w === null || seen.has(w.path)) return false;
+			seen.add(w.path);
+			return true;
+		})
+		.sort((a, b) =>
+			a.name === b.name
+				? a.path.localeCompare(b.path)
+				: a.name.localeCompare(b.name),
+		);
+}
+
+/** Why an activation failed, in one line that never ends on an absolute path. */
+function failureReason(error: unknown, worktree: string): string {
+	if (error instanceof SettingsParseError) {
+		return `${path.relative(worktree, error.path)} ${error.problem}`;
+	}
+	const message = error instanceof Error ? error.message : String(error);
+	return message.split("\n")[0] ?? message;
+}
+
+/**
+ * Activate the declared profile in each worktree whose `autoActivate` is true,
+ * one after another. Entries that need a choice are skipped and not returned;
+ * one failure does not stop the others.
+ */
+export async function setUpWorktrees(
+	worktrees: UnsetWorktree[],
+): Promise<WorktreeSetupResult[]> {
+	const results: WorktreeSetupResult[] = [];
+	for (const wt of worktrees) {
+		if (!wt.autoActivate || wt.declaredDefault === null) continue;
+		try {
+			// That worktree's own manifest, read now: its branch may declare
+			// something other than this one's.
+			const manifest = await readManifest(wt.path);
+			const result = await applyProfileChoice(
+				{ kind: "activate", id: wt.declaredDefault },
+				manifest,
+				wt.path,
+				// Nothing to announce: `autoActivate` means nothing of the user's
+				// was there to move aside, and printing here would land inside
+				// whichever surface called this.
+				{ onDisplace: () => {} },
+			);
+			results.push({
+				path: wt.path,
+				name: wt.name,
+				ok: true,
+				profileId: result.profileId,
+			});
+		} catch (error) {
+			results.push({
+				path: wt.path,
+				name: wt.name,
+				ok: false,
+				reason: failureReason(error, wt.path),
+			});
+		}
+	}
+	return results;
+}

package/src/ui/App.tsx

@@ -21,10 +21,15 @@ import {
 	checkForUpdates,
 	getCurrentVersion,
 } from "../services/version-check.js";
+import {
+	findUnsetWorktrees,
+	setUpWorktrees,
+} from "../services/worktree-profiles.js";
 import {
 	gitignoreStartupReport,
 	profileStartupReport,
 	staleRepairReport,
+	worktreeSetupReport,
 } from "./adapters/startupReports.js";
 import { ScreenErrorBoundary } from "./components/ScreenErrorBoundary.js";
 import { TABS } from "./components/TabBar.js";
@@ -296,8 +301,15 @@ function AppContent({ onExit }: AppContentProps) {
 		null,
 	);
 	const staleLoadModal = useStaleLoadModal();
+	// This project's own profile question is settled: it needed nothing, or it
+	// was answered. Only then are the other worktrees set up — before it, they
+	// would be set up from a project that is not set up itself.
+	const [profileSettled, setProfileSettled] = useState(false);
 	// Stable, so `profileModal.show` is not rebuilt for it on every render.
-	const profileAnswered = React.useCallback(() => setProfileNeed(null), []);
+	const profileAnswered = React.useCallback(() => {
+		setProfileNeed(null);
+		setProfileSettled(true);
+	}, []);
 	// Activating a profile changes which plugins are on, so the open screen must
 	// reload. The result modal that used to follow sent the user to the Profiles
 	// tab, which remounted it; without that modal the user stays where they are,
@@ -550,12 +562,31 @@ function AppContent({ onExit }: AppContentProps) {
 				);
 				queueReports(profileStartupReport(problems, activations ?? []));
 				if (!needsNothing(need)) setProfileNeed(need);
+				else setProfileSettled(true);
 			} catch {
 				// non-fatal: the Profiles tab still works by hand
 			}
 		})();
 	}, [queueReports]);
 
+	// The other worktrees of this repository with no profile set up, once this
+	// project's own question is settled. Each one whose project already declares
+	// a profile, with nothing of the user's to replace, is set up without
+	// asking — the same rule this project's own profile follows above. Success
+	// shows nothing; failures go to the one failure popup. A worktree that needs
+	// a choice is left to `magus update` run in it. Its own effect, for the
+	// same reason as the profile check above.
+	const worktreesLooked = useRef(false);
+	useEffect(() => {
+		if (!profileSettled || worktreesLooked.current) return;
+		worktreesLooked.current = true;
+		findUnsetWorktrees(process.cwd())
+			.then((found) => setUpWorktrees(found.filter((w) => w.autoActivate)))
+			.then((results) => queueReports(worktreeSetupReport(results)))
+			// non-fatal: `magus update` reports the same worktrees
+			.catch(() => {});
+	}, [profileSettled, queueReports]);
+
 	// Auto-refresh marketplaces on startup
 	useEffect(() => {
 		const noRefresh = process.argv.includes("--no-refresh");

package/src/ui/adapters/startupReports.ts

@@ -1,8 +1,8 @@
 /**
  * The failure popup's words for everything outside the Plugins screen's apply
  * paths: the profile gate at startup, a profile activation, the startup
- * repairs (stale plugin loads, marketplace refreshes, gitignore fixes) and the
- * Git State screen. Each is a pure builder over what the service returned, on
+ * repairs (stale plugin loads, marketplace refreshes, gitignore fixes), the
+ * setup of other worktrees and the Git State screen. Each is a pure builder over what the service returned, on
  * top of {@link failureReport}, so they read like every other failure.
  *
  * Each returns null when nothing failed: success says nothing, because the
@@ -13,6 +13,7 @@ import type { StaleLoadRepairResult } from "../../services/claude-settings.js";
 import type { ActivationResult } from "../../services/profile-activate.js";
 import { SettingsParseError } from "../../services/settings-file.js";
 import { pluginName } from "../../services/update-engine.js";
+import type { WorktreeSetupResult } from "../../services/worktree-profiles.js";
 import { userFacingPath, withUserFacingPath } from "../../utils/user-path.js";
 import type { FailureReport, FailureRow } from "../state/types.js";
 import {
@@ -212,6 +213,25 @@ export function stepFailureReport(
 	};
 }
 
+/**
+ * Worktrees the startup setup could not put on their declared profile, each
+ * by folder name with its reason. Null when every one was set up.
+ */
+export function worktreeSetupReport(
+	results: readonly WorktreeSetupResult[],
+): FailureReport | null {
+	const failed = results.filter(
+		(r): r is Extract<WorktreeSetupResult, { ok: false }> => !r.ok,
+	);
+	return failureReport(
+		`${counted(failed.length, "worktree")} ${failed.length === 1 ? "was" : "were"} not set up`,
+		failed.map((r) => ({
+			subject: r.name,
+			reason: exceptionReason(r.reason).reason,
+		})),
+	);
+}
+
 /**
  * M9: generated files the startup gitignore fix could not untrack, each with
  * git's own reason.