magus-cli 7.6.0 → 7.8.0

package/src/ui/screens/CliToolsScreen.tsx

@@ -4,7 +4,7 @@ import React, { useEffect, useCallback, useState, useRef } from "react";
 import { ScreenLayout } from "../components/layout/index.js";
 import { useScreenKeys } from "../input/KeyRouter.js";
 import { moveDirection } from "../keymap.js";
-import { useApp, useModal } from "../state/AppContext.js";
+import { useApp, useFailurePopup, useModal } from "../state/AppContext.js";
 import { useDimensions } from "../state/DimensionsContext.js";
 
 import { cliTools } from "../../data/cli-tools.js";
@@ -23,12 +23,18 @@ import {
 	specForCatalogTool,
 } from "../../services/tool-probe.js";
 import type { Command } from "../../utils/command-utils.js";
-import { formatCommand } from "../../utils/command-utils.js";
 import { createRequestGate } from "../../utils/request-gate.js";
 import {
+	type CliToolCommandFailure,
 	type CliToolRow,
 	buildToolRow,
+	cliToolConflictPartialReport,
+	cliToolConflictStuckReport,
 	cliToolEnterAction,
+	cliToolFailureReport,
+	cliToolNotDone,
+	cliToolsNotUpdatedReport,
+	commandFailureReason,
 	countToolRows,
 } from "../adapters/cliToolsAdapter.js";
 import { ScrollableList } from "../components/ScrollableList.js";
@@ -39,6 +45,8 @@ import {
 import { theme } from "../theme.js";
 
 const execFileAsync = promisify(execFile);
+/** How long one installer command may run before it is stopped. */
+const COMMAND_TIMEOUT_MS = 60_000;
 
 // ─── Session cache ─────────────────────────────────────────────────────────────
 //
@@ -91,6 +99,7 @@ export function CliToolsScreen() {
 	const { state, dispatch } = useApp();
 	const { cliTools: cliToolsState } = state;
 	const modal = useModal();
+	const showFailures = useFailurePopup();
 	const dimensions = useDimensions();
 
 	const [rows, setRows] = useState<CliToolRow[]>(
@@ -208,23 +217,22 @@ export function CliToolsScreen() {
 	};
 
 	/**
-	 * Run one installer command and report success.
+	 * Run one installer command: null when it succeeded, else why it failed.
 	 *
 	 * `execFile`, so there is no shell to re-parse a package name — the same
 	 * reason `utils/run.ts` exists. It does NOT call that shared `runCommand`:
 	 * that one inherits stdio, and a TUI must never hand the terminal to a
-	 * child. Output is captured and discarded here; the modal is the progress
-	 * indicator.
+	 * child. Output is captured; the modal is the progress indicator, and on a
+	 * failure the installer's own words become the popup's reason.
 	 */
-	const runCommand = async (
-		command: Command,
-	): Promise<{ ok: boolean; error?: string }> => {
+	const runCommand = async (command: Command): Promise<string | null> => {
 		try {
-			await execFileAsync(command.cmd, [...command.args], { timeout: 60000 });
-			return { ok: true };
+			await execFileAsync(command.cmd, [...command.args], {
+				timeout: COMMAND_TIMEOUT_MS,
+			});
+			return null;
 		} catch (err) {
-			const msg = err instanceof Error ? err.message : String(err);
-			return { ok: false, error: msg };
+			return commandFailureReason(command, err, COMMAND_TIMEOUT_MS);
 		}
 	};
 
@@ -237,18 +245,19 @@ export function CliToolsScreen() {
 		const { command, progress: action } = enter;
 
 		modal.loading(`${action} ${tool.displayName}...`);
-		const result = await runCommand(command);
+		const reason = await runCommand(command);
 		modal.hideModal();
 
-		if (result.ok) {
+		if (reason === null) {
 			handleRefresh();
-		} else {
-			await modal.message(
-				"Error",
-				`Failed to ${action.toLowerCase()} ${tool.displayName}.\n\nTry running manually:\n${formatCommand(command)}`,
-				"error",
-			);
+			return;
 		}
+		await showFailures(
+			cliToolFailureReport(
+				`${tool.displayName} was not ${cliToolNotDone(enter.kind)}`,
+				[{ tool: tool.displayName, command, reason }],
+			),
+		);
 	};
 
 	/**
@@ -284,6 +293,11 @@ export function CliToolsScreen() {
 			methods
 				.map((m) => `The ${m} install stays: ${blockers.get(m)}.`)
 				.join("\n");
+		const blockerRows = (methods: readonly InstallMethod[]) =>
+			methods.map((method) => ({
+				method,
+				reason: blockers.get(method) ?? "magus cannot remove it",
+			}));
 
 		// One choice per install that can be KEPT — but only where keeping it
 		// removes something. "Keep npm" beside an unremovable native copy would
@@ -297,10 +311,8 @@ export function CliToolsScreen() {
 			}));
 
 		if (options.length === 0) {
-			await modal.message(
-				`${tool.displayName} conflict`,
-				`Installed via ${allMethods.join(" + ")}, and magus can remove none of them.\n\n${stuckList(allMethods)}\n\nRemove one by hand, then press r.`,
-				"error",
+			await showFailures(
+				cliToolConflictStuckReport(tool.displayName, blockerRows(allMethods)),
 			);
 			return;
 		}
@@ -318,35 +330,36 @@ export function CliToolsScreen() {
 		const leftBehind = stuck.filter((m) => m !== keep);
 		modal.loading(`Removing ${toRemove.join(", ")} install(s)...`);
 
-		const errors: string[] = [];
+		const failed: Array<{
+			method: InstallMethod;
+			command: Command;
+			reason: string;
+		}> = [];
+		const unremovable = blockerRows(leftBehind);
 		for (const method of toRemove) {
 			const cmd = cliToolUninstall(tool, method, install.brewFormula);
 			// Unreachable: `removable` was built from this same call. Reported
 			// rather than skipped, because a silent skip is the defect above.
 			if (!cmd) {
-				errors.push(`${method}: no uninstall command`);
+				unremovable.push({
+					method,
+					reason: "magus has no uninstall command for it",
+				});
 				continue;
 			}
-			const result = await runCommand(cmd);
-			if (!result.ok) errors.push(`${method}: ${formatCommand(cmd)}`);
+			const reason = await runCommand(cmd);
+			if (reason !== null) failed.push({ method, command: cmd, reason });
 		}
 
 		modal.hideModal();
 
-		const report = [
-			errors.length > 0
-				? `These removals failed. Run them by hand:\n${errors.join("\n")}`
-				: "",
-			leftBehind.length > 0
-				? `${stuckList(leftBehind)}\nRemove it by hand if you want it gone.`
-				: "",
-		].filter((part) => part !== "");
-
-		if (report.length > 0) {
-			await modal.message(
-				errors.length > 0 ? "Partly removed" : "One install stays",
-				report.join("\n\n"),
-				errors.length > 0 ? "error" : "info",
+		// A failed removal goes into the failure popup with the command to run,
+		// and so does an install left behind beside it. An install magus could
+		// never remove is not, on its own, a failure: nothing failed, and the row
+		// still shows the conflict until it is dealt with.
+		if (failed.length > 0 || unremovable.length > leftBehind.length) {
+			await showFailures(
+				cliToolConflictPartialReport(tool.displayName, failed, unremovable),
 			);
 		}
 
@@ -358,23 +371,24 @@ export function CliToolsScreen() {
 		// swept up in a bulk action — that is exactly the "cannot tell, so run
 		// it anyway" the CLI no longer does either.
 		const updatable = rows.filter((r) => r.status?.state === "upgrade");
-		if (updatable.length === 0) {
-			await modal.message(
-				"Up to Date",
-				"No tool is known to be behind.",
-				"info",
-			);
-			return;
-		}
+		if (updatable.length === 0) return;
 
 		modal.loading(`Updating ${updatable.length} tool(s)...`);
 
+		// Every failure is kept: the reload shows the tool still behind, and
+		// only this says why.
+		const failed: CliToolCommandFailure[] = [];
 		for (const row of updatable) {
-			await runCommand(row.updateCommand ?? row.installCommand);
+			const command = row.updateCommand ?? row.installCommand;
+			const reason = await runCommand(command);
+			if (reason !== null) {
+				failed.push({ tool: row.tool.displayName, command, reason });
+			}
 		}
 
 		modal.hideModal();
 		handleRefresh();
+		await showFailures(cliToolsNotUpdatedReport(failed));
 	};
 
 	const selectedRow = rows[cliToolsState.selectedIndex];

package/src/ui/screens/EnvVarsScreen.tsx

@@ -9,6 +9,7 @@ import {
 	type SettingsBrowserItem,
 	buildSettingsBrowserItems,
 } from "../adapters/settingsAdapter.js";
+import { stepFailureReport } from "../adapters/startupReports.js";
 import { ScrollableList } from "../components/ScrollableList.js";
 import { ScreenLayout } from "../components/layout/index.js";
 import { ErrorNotice } from "../components/primitives/index.js";
@@ -18,7 +19,7 @@ import {
 	renderSettingDetail,
 	renderSettingRow,
 } from "../renderers/settingsRenderers.js";
-import { useApp, useModal } from "../state/AppContext.js";
+import { useApp, useFailurePopup, useModal } from "../state/AppContext.js";
 import { useDimensions } from "../state/DimensionsContext.js";
 import { theme } from "../theme.js";
 
@@ -26,8 +27,19 @@ export function SettingsScreen() {
 	const { state, dispatch } = useApp();
 	const { settings } = state;
 	const modal = useModal();
+	const showFailures = useFailurePopup();
 	const dimensions = useDimensions();
 
+	/** A setting that did not save, at the scope it was being saved to. */
+	const reportNotSaved = (
+		name: string,
+		scope: "user" | "project",
+		error: unknown,
+	): Promise<void> =>
+		showFailures(
+			stepFailureReport(`${name} was not saved`, scope.toUpperCase(), error),
+		);
+
 	const fetchData = useCallback(async () => {
 		dispatch({ type: "SETTINGS_DATA_LOADING" });
 		try {
@@ -54,9 +66,12 @@ export function SettingsScreen() {
 		}
 	}, [dispatch, state.projectPath]);
 
+	// Load data on mount or when dataRefreshVersion changes — a profile
+	// activating changes what this screen shows.
+	// biome-ignore lint/correctness/useExhaustiveDependencies: dataRefreshVersion is the external refresh trigger; bumping it must re-run the fetch even though the body never reads it
 	useEffect(() => {
 		fetchData();
-	}, [fetchData]);
+	}, [fetchData, state.dataRefreshVersion]);
 
 	const listItems = useMemo((): SettingsBrowserItem[] => {
 		if (settings.values.status !== "success") return [];
@@ -81,7 +96,7 @@ export function SettingsScreen() {
 				await writeSettingValue(setting, newValue, scope, state.projectPath);
 				await fetchData();
 			} catch (error) {
-				await modal.message("Error", `Failed to update: ${error}`, "error");
+				await reportNotSaved(setting.name, scope, error);
 			}
 		} else if (setting.type === "select" && setting.options) {
 			const options = setting.options.map((o) => ({
@@ -107,7 +122,7 @@ export function SettingsScreen() {
 				await writeSettingValue(setting, val, scope, state.projectPath);
 				await fetchData();
 			} catch (error) {
-				await modal.message("Error", `Failed to update: ${error}`, "error");
+				await reportNotSaved(setting.name, scope, error);
 			}
 		} else {
 			// String type: if already set, clear it; if unset, show input modal
@@ -116,7 +131,7 @@ export function SettingsScreen() {
 					await writeSettingValue(setting, undefined, scope, state.projectPath);
 					await fetchData();
 				} catch (error) {
-					await modal.message("Error", `Failed to update: ${error}`, "error");
+					await reportNotSaved(setting.name, scope, error);
 				}
 			} else {
 				const newValue = await modal.input(
@@ -134,7 +149,7 @@ export function SettingsScreen() {
 					);
 					await fetchData();
 				} catch (error) {
-					await modal.message("Error", `Failed to update: ${error}`, "error");
+					await reportNotSaved(setting.name, scope, error);
 				}
 			}
 		}

package/src/ui/screens/GitignoreScreen.tsx

@@ -12,6 +12,11 @@ import {
 	loadGitignoreState,
 } from "../../services/gitignore-service.js";
 import type { ResolvedRule, Tier, Violation } from "../../types/gitignore.js";
+import {
+	gitignoreFixReport,
+	gitignoreTemplateReport,
+	stepFailureReport,
+} from "../adapters/startupReports.js";
 import { ScreenLayout } from "../components/layout/index.js";
 import { useScreenKeys } from "../input/KeyRouter.js";
 import { moveDirection } from "../keymap.js";
@@ -20,6 +25,7 @@ import {
 	renderRuleRow,
 } from "../renderers/gitignoreRenderers.js";
 import { useApp, useModal } from "../state/AppContext.js";
+import type { FailureReport } from "../state/types.js";
 import { theme } from "../theme.js";
 
 // Clean rows are grouped by the manifest that defined them. Order = display
@@ -57,9 +63,12 @@ export function GitignoreScreen() {
 		}
 	}, [cwd]);
 
+	// Load on mount or when dataRefreshVersion changes — a profile activating
+	// can turn committed files into generated ones this screen lists.
+	// biome-ignore lint/correctness/useExhaustiveDependencies: dataRefreshVersion is the external refresh trigger; bumping it must re-run the load even though the body never reads it
 	useEffect(() => {
 		void reload();
-	}, [reload]);
+	}, [reload, state.dataRefreshVersion]);
 
 	// Build the managed list: every desired gitignore rule, with all matching
 	// violations grouped under the rule that owns them.
@@ -135,112 +144,75 @@ export function GitignoreScreen() {
 	const handleFixAll = useCallback(async () => {
 		if (!data || toFixRows.length === 0) return;
 		try {
-			const messages: string[] = [];
-			const failures: string[] = [];
+			const failures: Array<{ path: string; message: string }> = [];
 			for (const { row } of toFixRows) {
 				for (const v of row.violations) {
 					const r = await applyDestructiveFix(cwd, v, row.rule.pattern);
-					(r.applied ? messages : failures).push(r.message);
+					if (!r.applied) failures.push({ path: v.path, message: r.message });
 				}
 			}
 			await reload();
-			if (failures.length > 0) {
-				await modal.message(
-					"Some fixes didn't apply",
-					[...failures, ...messages].join("\n"),
-					"error",
-				);
-			}
+			// Only what did not apply, each with why; the reloaded rows show the rest.
+			const report = gitignoreFixReport(failures);
+			if (report) await modal.failures(report);
 		} catch (err) {
-			await modal.message(
-				"Fix failed",
-				err instanceof Error ? err.message : String(err),
-				"error",
+			await modal.failures(
+				stepFailureReport("The fixes were not applied", ".gitignore", err),
 			);
 		}
 	}, [cwd, data, toFixRows, reload, modal]);
 
 	// Fix just the highlighted row.
 	const handleFixOne = useCallback(async () => {
-		if (!selectedRow) {
-			await modal.message(
-				"No row selected",
-				"Use ↑↓ to highlight a row that needs fixing, then press f.",
-				"info",
-			);
-			return;
-		}
-		if (selectedRow.violations.length === 0) {
-			await modal.message(
-				"Nothing to fix",
-				`${selectedRow.rule.pattern} already matches. f only applies to rows that need fixing.`,
-				"info",
-			);
-			return;
-		}
+		// Nothing highlighted, or a row that already matches: nothing to fix.
+		if (!selectedRow || selectedRow.violations.length === 0) return;
 
 		try {
-			const results: Array<{ applied: boolean; message: string }> = [];
+			const failures: Array<{ path: string; message: string }> = [];
 			for (const v of selectedRow.violations) {
-				results.push(
-					await applyDestructiveFix(cwd, v, selectedRow.rule.pattern),
-				);
+				const r = await applyDestructiveFix(cwd, v, selectedRow.rule.pattern);
+				if (!r.applied) failures.push({ path: v.path, message: r.message });
 			}
-			const failed = results.filter((r) => !r.applied);
 			await reload();
-			// Success is silent — the reload removes the fixed row. Only surface a
-			// modal when something didn't apply.
-			if (failed.length > 0) {
-				await modal.message(
-					"Some fixes didn't apply",
-					results.map((r) => r.message).join("\n"),
-					"error",
-				);
-			}
+			// Success is silent — the reload removes the fixed row. Only what did
+			// not apply goes into the failure popup.
+			const report = gitignoreFixReport(failures);
+			if (report) await modal.failures(report);
 		} catch (err) {
-			await modal.message(
-				"Fix failed",
-				err instanceof Error ? err.message : String(err),
-				"error",
+			await modal.failures(
+				stepFailureReport(
+					"The fix was not applied",
+					selectedRow.rule.pattern,
+					err,
+				),
 			);
 		}
 	}, [selectedRow, modal, cwd, reload]);
 
 	const handleApplyTemplate = useCallback(async () => {
 		const names = Object.keys(BUILTIN_TEMPLATES);
-		if (names.length === 0) {
-			await modal.message(
-				"No templates",
-				"No built-in templates available.",
-				"info",
-			);
-			return;
-		}
+		if (names.length === 0) return;
 		const selected = await modal.select(
 			"Apply template",
 			"Merge the template into the project manifest at .claude/gitignore.json.",
 			names.map((n) => ({ label: n, value: n })),
 		);
 		if (!selected) return;
+		let report: FailureReport | null = null;
 		try {
+			// What was merged shows in the list. What was skipped does not, so it
+			// is the one thing said — in the failure popup.
 			const r = await applyTemplate(cwd, selected);
-			const conflictNote =
-				r.conflicts.length > 0
-					? `\n\nSkipped due to conflicts: ${r.conflicts.join(", ")}`
-					: "";
-			await modal.message(
-				"Template applied",
-				`Wrote ${r.appliedTo}\n\nAdded ${r.added.ignore.length} ignore + ${r.added.track.length} track entries.${conflictNote}`,
-				"success",
-			);
+			report = gitignoreTemplateReport(selected, r.conflicts);
 		} catch (err) {
-			await modal.message(
-				"Template failed",
-				err instanceof Error ? err.message : String(err),
-				"error",
+			report = stepFailureReport(
+				`Template "${selected}" was not applied`,
+				".claude/gitignore.json",
+				err,
 			);
 		}
 		await reload();
+		if (report) await modal.failures(report);
 	}, [cwd, modal, reload]);
 
 	/**
@@ -248,7 +220,7 @@ export function GitignoreScreen() {
 	 *
 	 * Every await sits inside the try: this runs fire-and-forget from a key, and a
 	 * rejection nobody catches ends the app. A manifest that cannot be read or
-	 * created is said in a dialog on this screen instead.
+	 * created is said in the failure popup instead.
 	 */
 	const handleEditManifest = useCallback(async () => {
 		let projectManifest: string;
@@ -259,10 +231,12 @@ export function GitignoreScreen() {
 				current.resolved,
 			);
 		} catch (err) {
-			await modal.message(
-				"Cannot open the manifest",
-				err instanceof Error ? err.message : String(err),
-				"error",
+			await modal.failures(
+				stepFailureReport(
+					"The project's rules were not opened for editing",
+					".claude/gitignore.json",
+					err,
+				),
 			);
 			return;
 		}