magus-cli 7.10.0 → 7.10.2

package/src/services/tool-probe.ts

@@ -52,13 +52,26 @@ import {
 	versionFromVersionedPath,
 } from "./cli-tool-version.js";
 import {
+	binPinCommand,
+	binUpgradeCommand,
 	claudeNativeUpgradeCommand,
 	npmPrefixInstallCommand,
 } from "./toolchain.js";
 
 // ── Types ────────────────────────────────────────────────────────────────────
 
-export type ToolState = "install" | "current" | "upgrade" | "unknown";
+/**
+ * `external` is a determined fact, not a failure to check: the tool is on
+ * PATH, and something other than the installer magus would use put it there
+ * (bun, an official installer, the OS). magus leaves it as is, so it is
+ * neither work nor "could not be checked".
+ */
+export type ToolState =
+	| "install"
+	| "current"
+	| "upgrade"
+	| "external"
+	| "unknown";
 
 export type ToolReason =
 	| "absent"
@@ -215,16 +228,51 @@ function withFailure(text: string, failure: string | undefined): string {
 	return failure ? `${text} (${failure})` : text;
 }
 
-/** The `not-managed` sentence. Names the file and its owner, never the version. */
+/** The installer as the user knows it. */
+export function installerWord(via: ManagedTool["via"]): string {
+	return via === "brew" ? "Homebrew" : via;
+}
+
+/** The directories the operating system itself installs programs into. */
+const SYSTEM_DIRS = ["/bin", "/sbin", "/usr/bin", "/usr/sbin", "/System"];
+
+function isSystemPath(resolved: string | null): boolean {
+	return (
+		resolved !== null && SYSTEM_DIRS.some((dir) => isInside(resolved, dir))
+	);
+}
+
+/**
+ * The `not-managed` sentence, in the user's terms: who did not install it,
+ * and what magus does about it. Never the path or the installer's directory:
+ * the user acts on neither.
+ */
 function notManagedNote(spec: ManagedTool, facts: ToolFacts): string {
+	const pin = pinOf(spec);
+	if (facts.managed === false && pin) {
+		return `installed outside ${installerWord(spec.via)}, so magus cannot move it to the pin ${pin}`;
+	}
+	// The KEPT chip already says magus leaves it as is; the note says only who
+	// installed it.
 	return facts.managed === false
-		? `on PATH at ${facts.resolvedPath ?? "?"}, which ${facts.owner ?? spec.via} does not own — upgrading through ${spec.via} would install a second copy`
+		? isSystemPath(facts.resolvedPath)
+			? "comes with the operating system"
+			: `installed outside ${installerWord(spec.via)}`
 		: withFailure(
-				`could not tell whether ${spec.via} owns ${facts.resolvedPath ?? spec.name}`,
+				`could not tell whether ${installerWord(spec.via)} installed it`,
 				facts.failure,
 			);
 }
 
+/**
+ * Another installer's file is `external`, settled, only while nothing is
+ * asked of it. With a pin the profile declares a version magus cannot deliver
+ * without a second copy, so that is still a warning: `unknown`.
+ */
+function externalOr(pin: string | undefined): ToolState {
+	return pin ? "unknown" : "external";
+}
+
 /**
  * THE tool classifier. Pure. The first matching rule wins, and each branch
  * returns, so reading top to bottom is reading the precedence.
@@ -271,7 +319,7 @@ export function classifyTool(spec: ManagedTool, facts: ToolFacts): ToolStatus {
 	if (installed === null && facts.managed === false) {
 		return {
 			...base,
-			state: "unknown",
+			state: externalOr(pin),
 			reason: "not-managed",
 			target: null,
 			note: notManagedNote(spec, facts),
@@ -317,11 +365,12 @@ export function classifyTool(spec: ManagedTool, facts: ToolFacts): ToolStatus {
 		};
 	}
 
-	// 7. The veto: the upgrade would not replace the file PATH runs.
+	// 7. The veto: the upgrade would not replace the file PATH runs. Known to be
+	// another installer's file: `external`. Not known either way: `unknown`.
 	if (facts.managed !== true) {
 		return {
 			...base,
-			state: "unknown",
+			state: facts.managed === false ? externalOr(pin) : "unknown",
 			reason: "not-managed",
 			target: null,
 			note: notManagedNote(spec, facts),
@@ -1189,6 +1238,9 @@ async function probeBrew(
 	resolvedPath: string,
 ): Promise<void> {
 	const formula = spec.formula ?? spec.name;
+	// A tap formula ("user/tap/f") keeps its keg under the short name, so the
+	// full name never matched and a Homebrew mnemex read as installed outside it.
+	const keg = formula.slice(formula.lastIndexOf("/") + 1);
 	const prefix = await s.brewPrefix();
 	if ("failure" in prefix) {
 		f.managed = null;
@@ -1198,11 +1250,11 @@ async function probeBrew(
 	const cellar =
 		(await s.io.realpath(path.join(prefix.dir, "Cellar"))) ??
 		path.join(prefix.dir, "Cellar");
-	const ownerDir = path.join(cellar, formula);
+	const ownerDir = path.join(cellar, keg);
 	f.owner = `brew (Cellar ${ownerDir})`;
 	f.managed = isInside(resolvedPath, ownerDir);
 	if (!f.managed) return;
-	f.installed = brewKegVersion(resolvedPath, cellar, formula);
+	f.installed = brewKegVersion(resolvedPath, cellar, keg);
 	if (f.installed) addSource(f, "brew");
 
 	const r = await s.run("brew", ["outdated", "--json=v2", formula], BREW_ENV);
@@ -1352,6 +1404,129 @@ async function readNodePackage(
 	if (!pinned) await npmLatest(s, pkg, f);
 }
 
+/** Where `bun add -g` puts packages: `$BUN_INSTALL/install/global/node_modules`. */
+function bunGlobalRoot(io: ToolProbeIO): string {
+	return path.join(
+		io.env.BUN_INSTALL ?? path.join(io.homedir, ".bun"),
+		"install",
+		"global",
+		"node_modules",
+	);
+}
+
+/** The package a path names, from its segments under `node_modules`. */
+function packageFromSegments(rel: string): string | null {
+	const [first, second] = rel.split(path.sep);
+	if (!first || first.startsWith(".")) return null;
+	if (!first.startsWith("@")) return first;
+	return second ? `${first}/${second}` : null;
+}
+
+/**
+ * The bun or npm global package that holds `resolvedPath`, read from the path
+ * alone. Null when the file lies in neither tree (a Homebrew keg included:
+ * `npmGlobalPrefixOf` refuses one).
+ */
+async function nodeGlobalOwner(
+	s: ProbeSession,
+	resolvedPath: string,
+): Promise<{ via: "bun" | "npm"; pkg: string } | null> {
+	const bunRoot = await s.io.realpath(bunGlobalRoot(s.io));
+	if (bunRoot && isInside(resolvedPath, bunRoot)) {
+		const pkg = packageFromSegments(path.relative(bunRoot, resolvedPath));
+		return pkg ? { via: "bun", pkg } : null;
+	}
+	const marker = `${path.sep}${path.join("lib", "node_modules")}${path.sep}`;
+	const at = resolvedPath.lastIndexOf(marker);
+	if (at < 0) return null;
+	const pkg = packageFromSegments(resolvedPath.slice(at + marker.length));
+	return pkg && npmGlobalPrefixOf(resolvedPath, pkg) !== null
+		? { via: "npm", pkg }
+		: null;
+}
+
+/**
+ * The formula whose keg holds `resolvedPath` (`…/Cellar/<formula>/<version>/…`),
+ * read from the path alone. `probeBrew` then checks that this Cellar is brew's.
+ */
+function kegFormulaOf(resolvedPath: string): string | null {
+	const parts = resolvedPath.split(path.sep);
+	const at = parts.lastIndexOf("Cellar");
+	return at >= 0 && parts.length > at + 2 ? (parts[at + 1] ?? null) : null;
+}
+
+/**
+ * The spec as the installer that actually holds `resolvedPath` would state it,
+ * or null when that is the spec's own installer or none magus drives.
+ */
+async function actualOwnerSpec(
+	s: ProbeSession,
+	spec: ManagedTool,
+	resolvedPath: string,
+): Promise<ManagedTool | null> {
+	const base = {
+		name: spec.name,
+		...(spec.check ? { check: spec.check } : {}),
+		...(spec.version ? { version: spec.version } : {}),
+	};
+	const node = await nodeGlobalOwner(s, resolvedPath);
+	if (node) {
+		return node.via === spec.via
+			? null
+			: { ...base, via: node.via, package: node.pkg };
+	}
+	const formula = kegFormulaOf(resolvedPath);
+	// Homebrew takes no version, so it cannot honour a pin: such a tool stays
+	// "installed outside", which the classifier reports as unknown.
+	if (!formula || spec.via === "brew" || spec.version) return null;
+	return { ...base, via: "brew", formula };
+}
+
+/**
+ * The spec's installer does not own the file PATH runs, but bun's or npm's
+ * global tree or a Homebrew keg does: re-read the tool through THAT installer.
+ *
+ * A plugin's `requires` lists its install options in preference order for a
+ * FRESH install, and magus plans through the first. That order says how to
+ * install a missing tool, not which owner an installed one must have. A
+ * mnemex from `bun add -g` or from Homebrew has a version, a registry and an
+ * upgrade command like any other. Reading it as "installed outside" the
+ * first option's installer showed a settled, upgradeable tool as one magus
+ * could not touch.
+ *
+ * The catalogue's tools already follow how a tool IS installed
+ * (`specForCatalogTool`); this gives a plugin's requirements the same rule.
+ * The upgrade command is carried on the facts, so `magus update` and the TUI
+ * run the owner's command rather than the spec's.
+ */
+async function adoptActualOwner(
+	s: ProbeSession,
+	spec: ManagedTool,
+	f: ToolFacts,
+	resolvedPath: string,
+): Promise<void> {
+	const actual = await actualOwnerSpec(s, spec, resolvedPath);
+	if (!actual) return;
+	const read = blankFacts(spec.name);
+	if (actual.via === "brew") await probeBrew(s, actual, read, resolvedPath);
+	else await probeNodeGlobal(s, actual, read, resolvedPath);
+	if (read.managed !== true) return;
+	f.managed = true;
+	f.owner = read.owner;
+	f.installed = read.installed;
+	f.latest = read.latest;
+	f.behind = read.behind;
+	// What the spec's installer could not answer is moot once the owner is
+	// known: only the owner's own failure describes this tool.
+	f.failure = read.failure;
+	for (const source of read.sources) addSource(f, source);
+	f.upgradeCommand =
+		read.upgradeCommand ??
+		(spec.version
+			? (binPinCommand(actual) ?? undefined)
+			: binUpgradeCommand(actual));
+}
+
 async function probeNodeGlobal(
 	s: ProbeSession,
 	spec: ManagedTool,
@@ -1362,12 +1537,7 @@ async function probeNodeGlobal(
 	const pin = pinOf(spec);
 	const pinned = pin !== undefined;
 	if (spec.via === "bun") {
-		const root = path.join(
-			s.io.env.BUN_INSTALL ?? path.join(s.io.homedir, ".bun"),
-			"install",
-			"global",
-			"node_modules",
-		);
+		const root = bunGlobalRoot(s.io);
 		f.owner = `bun (global ${root})`;
 		const { inside, real } = await containedIn(
 			s,
@@ -1620,6 +1790,11 @@ async function probeInto(
 			break;
 	}
 
+	// Not the spec's installer's file, or it could not tell (npm with no `npm`
+	// to ask), but the path names bun's, npm's or Homebrew's tree: then that is
+	// the owner, and it can upgrade the file PATH runs.
+	if (f.managed !== true) await adoptActualOwner(s, spec, f, resolvedPath);
+
 	// The method's own record was silent. Before anything runs, read what the
 	// installed files already say about themselves.
 	if (f.installed === null) versionFromFiles(f, resolvedPath);

package/src/services/update-engine.ts

@@ -397,7 +397,7 @@ async function readRows(
  * The row Claude Code moved is left as it is: it belongs to this repository,
  * and bringing this repository's rows forward is what the repair does anyway.
  * Null when there was nothing to follow — this project's row moved (2.1.280),
- * or no row of this repository moved at all.
+ * or no row of this repository moved at all and none already holds `target`.
  */
 async function followMisdirectedUpdate(
 	deps: PluginApplyDeps,
@@ -422,14 +422,32 @@ async function followMisdirectedUpdate(
 		scope,
 		projectPath: scope === "user" ? undefined : projectPath,
 	});
-	if (moved.length === 0 || moved.some((row) => rowKey(row) === mine)) {
-		return null;
-	}
-	const version = moved
+	if (moved.some((row) => rowKey(row) === mine)) return null;
+	// The row Claude Code picked may ALREADY hold the target — an earlier run
+	// from another checkout put it there. Then the update writes nothing, so
+	// nothing moves, and this project's row stays behind on every run (seen on
+	// 2.1.296: "the installer exited 0 but mnemex@magus is still 1.1.0" while
+	// tools/claudeup held 1.1.1). A row of this repository at exactly the
+	// target is the same misdirection, already landed.
+	const landed =
+		moved.length > 0 || !target
+			? moved
+			: after.filter(
+					(row) =>
+						row.version === target &&
+						rowKey(row) !== mine &&
+						inThisRepository(row, projectPath),
+				);
+	if (landed.length === 0) return null;
+	const version = landed
 		.map((row) => row.version)
 		.reduce((a, b) => ((compareVersions(b, a) ?? 0) > 0 ? b : a));
 	if (!isRepairablyBehind(version, now)) return null;
-	const elsewhere = moved.map((row) => row.projectPath ?? `${row.scope} scope`);
+	// Already landed, every checkout at the target matches, but Claude Code
+	// wrote to one of them: report one folder, not all of them.
+	const elsewhere = (moved.length > 0 ? landed : landed.slice(0, 1)).map(
+		(row) => row.projectPath ?? `${row.scope} scope`,
+	);
 	if (target && version !== target) {
 		return {
 			elsewhere,

package/src/services/update-plan.ts

@@ -1235,8 +1235,10 @@ export function summarizePlan(plan: UpdatePlan): {
 	unknownPlugins: number;
 	unknownTools: number;
 	/**
-	 * No longer published by their marketplace, and kept on purpose: moved, or
-	 * still required. A determined fact, so not part of `unknown`.
+	 * Left as they are, on purpose. Plugins no longer published by their
+	 * marketplace and kept (moved, or still required), and tools another
+	 * installer put on PATH (`external`). Determined facts, so not part of
+	 * `unknown`.
 	 */
 	kept: number;
 } {
@@ -1244,8 +1246,11 @@ export function summarizePlan(plan: UpdatePlan): {
 		plan.plugins.filter((p) => p.action === a).length;
 	const bins = (a: BinUpdateAction) =>
 		plan.bins.filter((b) => b.action === a).length;
-	const kept = plan.plugins.filter(isKeptDeprecated).length;
-	const unknownPlugins = count("unknown") - kept;
+	const keptPlugins = plan.plugins.filter(isKeptDeprecated).length;
+	const unknownPlugins = count("unknown") - keptPlugins;
+	// A tool another installer put on PATH is left as it is: settled, like a
+	// kept plugin, and never "could not be checked".
+	const kept = keptPlugins + bins("external");
 	const unknownTools = bins("unknown");
 	return {
 		installed: count("install") + bins("install"),

package/src/ui/adapters/cliToolsAdapter.ts

@@ -29,6 +29,7 @@ import {
 	type ToolReason,
 	type ToolStatus,
 	classifyTool,
+	installerWord,
 } from "../../services/tool-probe.js";
 import { binCommandForState } from "../../services/toolchain.js";
 import type { Presence } from "../../shared/plugin/hooks/lib/requires-probe.js";
@@ -246,7 +247,9 @@ export function cliToolEnterAction(row: CliToolRow): CliToolEnterAction | null {
 			command,
 		};
 	}
-	if (status.state === "unknown") {
+	// Another installer's file, or one magus could not place: still offered,
+	// as an explicit choice, with the note beside it (see the renderer).
+	if (status.state === "unknown" || status.state === "external") {
 		return {
 			kind: "update-anyway",
 			label: "update anyway",
@@ -280,13 +283,14 @@ export interface CliToolStatusText {
  * line, the same string `magus update` prints.
  *
  * Every label is at most 19 cells, so the row suffix (" ? " + label) stays
- * within 24. Keyed by reason alone — plus the spec's installer, which is a
- * word, never a path.
+ * within 24. Keyed by reason alone.
  */
-function unknownLabel(reason: ToolReason, via: ManagedTool["via"]): string {
+function unknownLabel(reason: ToolReason): string {
 	switch (reason) {
+		// Only the undetermined case: a file known to be another installer's
+		// is `external`, not `unknown`.
 		case "not-managed":
-			return `not managed by ${via}`;
+			return "owner not known";
 		case "version-unreadable":
 			return "version unreadable";
 		case "latest-unavailable":
@@ -321,9 +325,14 @@ export function cliToolStatusText(row: CliToolRow): CliToolStatusText {
 	switch (status.state) {
 		case "unknown":
 			return {
-				suffix: ` ? ${unknownLabel(status.reason, row.spec.via)}`,
+				suffix: ` ? ${unknownLabel(status.reason)}`,
 				tone: "warning",
 			};
+		case "external":
+			return {
+				suffix: ` · outside ${installerWord(row.spec.via)}`,
+				tone: "muted",
+			};
 		case "upgrade":
 			return {
 				suffix: status.target

package/src/ui/renderers/cliToolRenderers.tsx

@@ -250,6 +250,10 @@ export function renderCliToolRow(
 	} else if (status?.state === "unknown") {
 		icon = "?";
 		iconColor = theme.colors.warning;
+	} else if (status?.state === "external") {
+		// Installed, and left alone on purpose: present, not a finding.
+		icon = "●";
+		iconColor = theme.colors.muted;
 	} else {
 		icon = "●";
 		iconColor = theme.colors.success;
@@ -353,6 +357,8 @@ export function renderCliToolDetail(
 						</text>
 					) : state === "upgrade" ? (
 						<text fg={theme.colors.warning}>{"● Update available"}</text>
+					) : state === "external" ? (
+						<text fg={theme.colors.muted}>{"● Installed, kept as is"}</text>
 					) : state === "unknown" ? (
 						// A version that was read but cannot be checked for updates is
 						// still a version: say "installed", and let Why say the rest.
@@ -365,12 +371,17 @@ export function renderCliToolDetail(
 						<text fg={theme.colors.success}>{"● Up to date"}</text>
 					)}
 				</box>
-				{state === "unknown" && status?.note ? (
+				{(state === "unknown" || state === "external") && status?.note ? (
 					<box flexDirection="row">
 						<text fg={theme.colors.muted} flexShrink={0}>
 							{"Why      "}
 						</text>
-						<text fg={theme.colors.warning} minWidth={0}>
+						<text
+							fg={
+								state === "external" ? theme.colors.muted : theme.colors.warning
+							}
+							minWidth={0}
+						>
 							{wrapValue(status.note, width)}
 						</text>
 					</box>