magus-cli 7.6.0 → 7.8.0

package/src/ui/App.tsx

@@ -1,4 +1,4 @@
-import React, { useEffect, useState } from "react";
+import React, { useEffect, useRef, useState } from "react";
 import { activePluginPins } from "../services/active-closure.js";
 import { isClaudeAvailable } from "../services/claude-cli.js";
 import {
@@ -11,10 +11,7 @@ import {
 	type StartupGitignoreNeed,
 	startupGitignoreNeed,
 } from "../services/gitignore-check.js";
-import {
-	applyStartupFixes,
-	describeStartupFix,
-} from "../services/gitignore-service.js";
+import { applyStartupFixes } from "../services/gitignore-service.js";
 import { repairAllMarketplaces } from "../services/local-marketplace.js";
 import { autoAddMissingMarketplaces } from "../services/marketplace-sync.js";
 import {
@@ -27,16 +24,20 @@ import {
 	checkForUpdates,
 	getCurrentVersion,
 } from "../services/version-check.js";
+import {
+	gitignoreStartupReport,
+	marketplaceRefreshReport,
+	profileStartupReport,
+	staleRepairReport,
+} from "./adapters/startupReports.js";
 import { ScreenErrorBoundary } from "./components/ScreenErrorBoundary.js";
 import { TABS } from "./components/TabBar.js";
 import { ProgressBar } from "./components/layout/ProgressBar.js";
 import { ModalContainer } from "./components/modals/index.js";
+import { nextStartupStep } from "./hooks/startupQueue.js";
 import { useGitignoreModal } from "./hooks/useGitignoreModal.js";
 import { useProfileStartupModal } from "./hooks/useProfileStartupModal.js";
-import {
-	staleLoadRepairSummary,
-	useStaleLoadModal,
-} from "./hooks/useStaleLoadModal.js";
+import { useStaleLoadModal } from "./hooks/useStaleLoadModal.js";
 import { KeyRouter, useKeyLayer } from "./input/KeyRouter.js";
 import { type GlobalHandlers, runGlobalBindings } from "./keymap.js";
 import {
@@ -62,7 +63,7 @@ import {
 	DimensionsProvider,
 	useDimensions,
 } from "./state/DimensionsContext.js";
-import type { Screen } from "./state/types.js";
+import type { FailureReport, Screen } from "./state/types.js";
 import { theme } from "./theme.js";
 
 export const VERSION = getCurrentVersion();
@@ -207,17 +208,9 @@ function ProgressIndicator({
 interface AppContentInnerProps {
 	updateInfo: VersionCheckResult | null;
 	onExit: () => void;
-	recoveryReport: string | null;
-	/** What the startup profile gate did: absorbed edits, regeneration, repairs. */
-	profileNotices: string[];
 }
 
-function AppContentInner({
-	updateInfo,
-	onExit,
-	recoveryReport,
-	profileNotices,
-}: AppContentInnerProps) {
+function AppContentInner({ updateInfo, onExit }: AppContentInnerProps) {
 	const { state } = useApp();
 	const { progress } = state;
 	const dimensions = useDimensions();
@@ -225,16 +218,6 @@ function AppContentInner({
 	return (
 		<box flexDirection="column" height={dimensions.terminalHeight}>
 			{updateInfo?.updateAvailable && <UpdateBanner result={updateInfo} />}
-			{recoveryReport && (
-				<box paddingLeft={1} paddingRight={1}>
-					<text fg={theme.colors.success}>✓ Fixed: {recoveryReport}</text>
-				</box>
-			)}
-			{profileNotices.map((line) => (
-				<box key={line} paddingLeft={1} paddingRight={1}>
-					<text fg={theme.colors.success}>• {line}</text>
-				</box>
-			))}
 			{progress && <ProgressIndicator {...progress} />}
 			<box
 				flexDirection="column"
@@ -250,6 +233,27 @@ function AppContentInner({
 	);
 }
 
+/** A gitignore check's answer, waiting for the modal slot. */
+interface QueuedGitignore {
+	need: StartupGitignoreNeed;
+	/** The `gitignoreCheckRequest` it answers. */
+	request: number;
+}
+
+/**
+ * The gitignore check's bookkeeping. A ref, not state: a landing check reads
+ * the latest request and what was last shown at that moment, not as of the
+ * render that started it.
+ */
+interface GitignoreCheck {
+	/** A check is running. There is never more than one. */
+	inFlight: boolean;
+	/** The newest `gitignoreCheckRequest` seen. */
+	latest: number;
+	/** The request whose answer was last shown as a question; -1 for none. */
+	shown: number;
+}
+
 /**
  * AppContent Component
  * Wraps app with DimensionsProvider and manages state for debug/updates
@@ -262,38 +266,55 @@ function AppContent({ onExit }: AppContentProps) {
 	const { state, dispatch } = useApp();
 	const { progress } = state;
 	const [updateInfo, setUpdateInfo] = useState<VersionCheckResult | null>(null);
-	const [recoveryReport, setRecoveryReport] = useState<string | null>(null);
-	const [profileNotices, setProfileNotices] = useState<string[]>([]);
-	const [gitignoreData, setGitignoreData] =
-		useState<StartupGitignoreNeed | null>(null);
+	const [gitignoreData, setGitignoreData] = useState<QueuedGitignore | null>(
+		null,
+	);
+	// The last request whose check has landed. Behind the latest request, a
+	// check is pending, and `gitignoreData` — if any — is an answer to an
+	// earlier question about a project that has since changed.
+	const [gitignoreSettled, setGitignoreSettled] = useState(-1);
+	const gitignorePending = gitignoreSettled < state.gitignoreCheckRequest;
+	const gitignoreCheck = useRef<GitignoreCheck>({
+		inFlight: false,
+		latest: 0,
+		shown: -1,
+	});
 	const [profileNeed, setProfileNeed] = useState<ProfileStartupNeed | null>(
 		null,
 	);
+	// What startup work could not do — the profile gate's refusals and its
+	// activations, a marketplace refresh — waiting for the modal slot, oldest
+	// first. Each is the one failure popup; the TUI says nothing else.
+	const [startupReports, setStartupReports] = useState<FailureReport[]>([]);
+	const queueReports = React.useCallback(
+		(...reports: Array<FailureReport | null>) => {
+			const present = reports.filter((r): r is FailureReport => r !== null);
+			if (present.length > 0) {
+				setStartupReports((queued) => [...queued, ...present]);
+			}
+		},
+		[],
+	);
 	const gitignoreModal = useGitignoreModal();
 	const [brokenPluginCount, setBrokenPluginCount] = useState<number | null>(
 		null,
 	);
 	const staleLoadModal = useStaleLoadModal();
-	// The gitignore question, asked fresh: on every open, and again once the
-	// profile modal has activated a profile — a first adoption is what turns a
-	// committed settings.json into a generated file git should not track.
-	// Nothing remembers an earlier answer.
-	const checkGitignoreNow = React.useCallback(() => {
-		startupGitignoreNeed(process.cwd())
-			.then((need) => {
-				if (need) setGitignoreData(need);
-			})
-			.catch(() => {
-				// non-fatal: the Git State tab still shows the same rows
-			});
-	}, []);
 	// Stable, so `profileModal.show` is not rebuilt for it on every render.
 	const profileAnswered = React.useCallback(() => setProfileNeed(null), []);
+	// 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,
+	// and the screen under them would keep showing the pre-activation state.
+	// The same action re-runs the gitignore check — see the effect below.
+	const profileActivated = React.useCallback(() => {
+		dispatch({ type: "PROFILE_ACTIVATED" });
+	}, [dispatch]);
 	// The profile modal cannot be dismissed, so it needs the app's own exit: its
 	// only non-action is to leave.
 	const profileModal = useProfileStartupModal({
 		onQuit: onExit,
-		onActivated: checkGitignoreNow,
+		onActivated: profileActivated,
 		onAnswered: profileAnswered,
 	});
 
@@ -315,21 +336,6 @@ function AppContent({ onExit }: AppContentProps) {
 		return () => clearInterval(id);
 	}, []);
 
-	// Auto-dismiss the profile gate's notices after 10 seconds — long enough to
-	// read a line per absorbed change.
-	useEffect(() => {
-		if (profileNotices.length === 0) return;
-		const timer = setTimeout(() => setProfileNotices([]), 10000);
-		return () => clearTimeout(timer);
-	}, [profileNotices]);
-
-	// Auto-dismiss recovery banner after 5 seconds
-	useEffect(() => {
-		if (!recoveryReport) return;
-		const timer = setTimeout(() => setRecoveryReport(null), 5000);
-		return () => clearTimeout(timer);
-	}, [recoveryReport]);
-
 	// The startup questions — gitignore, then broken plugins, then profile — are
 	// asked ONE at a time, from ONE effect, and only while the modal slot is free.
 	//
@@ -339,12 +345,13 @@ function AppContent({ onExit }: AppContentProps) {
 	// need had already been cleared — so it never came back. The profile question
 	// was lost exactly that way, and the user updated plugins believing a profile
 	// was active. So: show at most one per run and return; the next question
-	// follows once that one's last modal is dismissed and the slot is empty
-	// again.
+	// follows once that one's flow has ended and the slot is empty again.
 	//
 	// The hooks keep the slot occupied for their whole flow (a loading modal
 	// while their fix runs, never HIDE_MODAL mid-flow), because an empty slot is
-	// what lets the next question in. That does not stop a SCREEN from emptying
+	// what lets the next question in. A flow that succeeds ends by hiding its
+	// loading modal and reports nothing: the screen it leaves shows the result.
+	// That does not stop a SCREEN from emptying
 	// it: `useModal().confirm` hides its modal when answered and the screen shows
 	// its loading modal a microtask later. A key pressed before the profile check
 	// resolved lands the profile question in exactly that gap, and the screen's
@@ -363,24 +370,60 @@ function AppContent({ onExit }: AppContentProps) {
 	//   re-showing would re-ask a question the user just declined. Losing one
 	//   costs nothing lasting: the Git State and Plugins tabs show the same rows,
 	//   and gitignore is asked again after a profile activates.
+	//
+	// The gitignore question also waits while a check is pending. An activation
+	// both empties the slot and asks for a fresh check, so the slot is free
+	// while an answer from BEFORE the activation may still be queued: showing
+	// it and then the fresh one asked the same question twice. The fresh result
+	// replaces the queued one instead (see the check effect below).
 	useEffect(() => {
-		if (state.modal) return;
-		if (gitignoreData) {
+		// The order lives in `nextStartupStep`, where it is tested: failure
+		// reports first — something that already happened, and the question
+		// after it may be answered differently once it is known — so the profile
+		// gate's refusals land before the profile question, which they do not
+		// replace; then gitignore, broken plugins, and the profile last.
+		const step = nextStartupStep({
+			modalOpen: !!state.modal,
+			reports: startupReports,
+			gitignoreReady: !!gitignoreData && !gitignorePending,
+			brokenCount: brokenPluginCount,
+			profileNeed,
+		});
+		if (!step) return;
+		if (step.kind === "report") {
+			setStartupReports(step.rest);
+			dispatch({
+				type: "SHOW_MODAL",
+				modal: {
+					type: "failures",
+					report: step.report,
+					onDismiss: () => dispatch({ type: "HIDE_MODAL" }),
+				},
+			});
+			return;
+		}
+		if (step.kind === "gitignore" && gitignoreData) {
+			// Anything older than what is now on screen is dropped on arrival.
+			gitignoreCheck.current.shown = gitignoreData.request;
+			const need = gitignoreData.need;
 			gitignoreModal.show({
-				violationCount: gitignoreData.violationCount,
-				safeCount: gitignoreData.safeCount,
-				generated: gitignoreData.generated,
+				violationCount: need.violationCount,
+				safeCount: need.safeCount,
+				generated: need.generated,
 				// In place, then back to the app: tracked generated files are
 				// untracked, missing entries added; other items stay for the tab.
+				// A file git would not untrack is named with git's reason.
 				onFixSafe: async () =>
-					describeStartupFix(await applyStartupFixes(state.projectPath)),
+					gitignoreStartupReport(
+						(await applyStartupFixes(state.projectPath)).failed,
+					),
 			});
 			setGitignoreData(null);
 			return;
 		}
-		if (brokenPluginCount !== null) {
+		if (step.kind === "stale-load") {
 			staleLoadModal.show({
-				brokenCount: brokenPluginCount,
+				brokenCount: step.brokenCount,
 				// Re-surveys before repairing, like the gitignore fixer: the registry
 				// may have moved between the startup scan and the user pressing Enter,
 				// and repairing from the stale count would act on rows that are no
@@ -390,8 +433,10 @@ function AppContent({ onExit }: AppContentProps) {
 				// The pins are re-read with it, from the same helper the survey used: a
 				// repair that capped at a different ceiling than the offer was counted
 				// against would move rows the dialog never mentioned.
+				//
+				// A repair that did not take is named, with its reason.
 				onFix: async () =>
-					staleLoadRepairSummary(
+					staleRepairReport(
 						await repairAllStaleLoads(
 							state.projectPath,
 							undefined,
@@ -404,11 +449,14 @@ function AppContent({ onExit }: AppContentProps) {
 		}
 		// Not cleared here — see above. Re-called on every empty slot until the
 		// hook reports it answered.
-		if (profileNeed) profileModal.show(profileNeed);
+		if (step.kind === "profile") profileModal.show(step.need);
 	}, [
 		state.modal,
 		state.projectPath,
+		dispatch,
+		startupReports,
 		gitignoreData,
+		gitignorePending,
 		gitignoreModal,
 		brokenPluginCount,
 		staleLoadModal,
@@ -439,12 +487,46 @@ function AppContent({ onExit }: AppContentProps) {
 		})();
 	}, []);
 
-	// The gitignore question on every open. Its own effect, NOT part of the
-	// marketplace block below, which returns early on `--no-refresh`: that flag
-	// is about network calls and must not silence this question.
+	// The gitignore question, asked fresh: on every open (request 0), and again
+	// on each PROFILE_ACTIVATED — a first adoption is what turns a committed
+	// settings.json into a generated file git should not track, and a
+	// Profiles-tab switch can do the same. Nothing remembers an earlier answer.
+	//
+	// At most ONE check runs at a time. A request that arrives while one runs
+	// is not started beside it: the running check, on landing, sees that it is
+	// no longer the latest, throws its answer away — it describes the project
+	// before whatever prompted the request — and runs again. Only the latest
+	// request's answer is kept, and it REPLACES anything still queued, including
+	// with nothing when the project no longer needs the question.
+	//
+	// Its own effect, NOT part of the marketplace block below, which returns
+	// early on `--no-refresh`: that flag is about network calls and must not
+	// silence this question.
 	useEffect(() => {
-		checkGitignoreNow();
-	}, [checkGitignoreNow]);
+		const check = gitignoreCheck.current;
+		check.latest = state.gitignoreCheckRequest;
+		if (check.inFlight) return;
+		const run = (request: number): void => {
+			check.inFlight = true;
+			startupGitignoreNeed(process.cwd())
+				// non-fatal: the Git State tab still shows the same rows
+				.catch(() => null)
+				.then((need) => {
+					if (request !== check.latest) {
+						run(check.latest);
+						return;
+					}
+					check.inFlight = false;
+					setGitignoreSettled(request);
+					// Defence in depth: an answer to a request no newer than the
+					// question last shown predates the user's reply to it.
+					setGitignoreData(
+						need && request > check.shown ? { need, request } : null,
+					);
+				});
+		};
+		run(check.latest);
+	}, [state.gitignoreCheckRequest]);
 
 	// Is this project actually running a profile? Detection only — nothing is
 	// written until the user picks something in the modal. The Profiles tab could
@@ -462,19 +544,21 @@ function AppContent({ onExit }: AppContentProps) {
 				// edits into the active profile, regenerate from a changed
 				// profiles.json, restore a lost marker — then the question, if one
 				// is left to ask.
-				const { need, notices, problems } = await prepareProfileStartup(
+				// A refusal never blocks the TUI at startup: the user is still asked
+				// whatever is left, and the screens show the state as it is. What
+				// the gate refused, and what its re-render could not do, go into ONE
+				// failure popup first — one step, one popup — queued in the same
+				// tick as the question, so it is shown before it.
+				const { need, problems, activations } = await prepareProfileStartup(
 					process.cwd(),
 				);
-				// A refusal never blocks the TUI at startup: it is shown beside what
-				// the gate did, and the user is still asked whatever is left.
-				const shown = [...notices, ...problems];
-				if (shown.length > 0) setProfileNotices(shown);
+				queueReports(profileStartupReport(problems, activations ?? []));
 				if (!needsNothing(need)) setProfileNeed(need);
 			} catch {
 				// non-fatal: the Profiles tab still works by hand
 			}
 		})();
-	}, []);
+	}, [queueReports]);
 
 	// Auto-refresh marketplaces on startup
 	useEffect(() => {
@@ -496,41 +580,29 @@ function AppContent({ onExit }: AppContentProps) {
 		(async () => {
 			try {
 				if (!(await isClaudeAvailable())) return;
-				const added = await autoAddMissingMarketplaces(process.cwd());
-				if (added.length > 0) {
-					setRecoveryReport(`added marketplace(s): ${added.join(", ")}`);
-				}
+				await autoAddMissingMarketplaces(process.cwd());
 			} catch {
 				// non-fatal: user can still install marketplaces manually
 			}
 		})();
 
-		// Recover stale marketplace registry entries (e.g. "directory" -> "github")
+		// Recover stale marketplace registry entries (e.g. "directory" -> "github"),
+		// then refresh the clones whose source that fixed. A refresh that fails
+		// leaves that marketplace's plugins read from an old copy, so it is named
+		// in the failure popup with why.
 		recoverMarketplaceSettings()
 			.then(async (recovery) => {
-				const parts: string[] = [];
-				if (recovery.reregistered.length > 0) {
-					// Update the marketplace clone now that the source is fixed
-					const { updateMarketplace } = await import(
-						"../services/claude-cli.js"
-					);
-					for (const mp of recovery.reregistered) {
-						try {
-							await updateMarketplace(mp);
-							parts.push(`${mp} refreshed`);
-						} catch {
-							parts.push(`${mp} (update failed)`);
-						}
-					}
-				}
-				if (recovery.removed.length > 0) {
-					parts.push(`removed: ${recovery.removed.join(", ")}`);
-				}
-				if (parts.length > 0) {
-					setRecoveryReport(parts.join(" | "));
+				if (recovery.reregistered.length === 0) return;
+				const { updateMarketplace } = await import("../services/claude-cli.js");
+				const failed: Array<{ marketplace: string; error: unknown }> = [];
+				for (const mp of recovery.reregistered) {
+					await updateMarketplace(mp).catch((error: unknown) => {
+						failed.push({ marketplace: mp, error });
+					});
 				}
+				queueReports(marketplaceRefreshReport(failed));
 			})
-			.catch(() => {}); // non-fatal
+			.catch(() => {}); // the recovery itself: non-fatal
 
 		repairAllMarketplaces()
 			.then(async () => {
@@ -540,23 +612,14 @@ function AppContent({ onExit }: AppContentProps) {
 			.catch(() => {
 				dispatch({ type: "HIDE_PROGRESS" });
 			});
-	}, [dispatch]);
-
-	// Count transient banners for dimension calculation
-	const transientBannerCount = recoveryReport ? 1 : 0;
+	}, [dispatch, queueReports]);
 
 	return (
 		<DimensionsProvider
 			showProgress={!!progress}
 			showUpdateBanner={!!updateInfo?.updateAvailable}
-			transientBannerCount={transientBannerCount}
 		>
-			<AppContentInner
-				updateInfo={updateInfo}
-				onExit={onExit}
-				recoveryReport={recoveryReport}
-				profileNotices={profileNotices}
-			/>
+			<AppContentInner updateInfo={updateInfo} onExit={onExit} />
 		</DimensionsProvider>
 	);
 }