@kyubiware/commit-mint 0.7.0 → 0.7.3

package/README.md

@@ -31,10 +31,23 @@ API key. The key is saved to `~/.commit-mint` (INI).
 cmint             # interactive: stage → checks → review → commit
 cmint -a          # auto-group, generate messages, commit everything
 cmint config      # edit provider, model, locale, etc.
+cmint update      # update cmint to the latest published version
 ```
 
 See [all flags](#all-flags) for the full list.
 
+## Self-update (`cmint update`)
+
+`cmint update` checks the npm registry for a newer version and, if one exists,
+runs the appropriate global install command for your package manager (detected
+from `npm_config_user_agent` — npm, pnpm, yarn, or bun; falls back to npm).
+
+- If you're already on the latest version, it exits silently.
+- Otherwise it prints `current → latest` and asks for confirmation before
+  running the install (live npm output is streamed to your terminal).
+- `cmint update -y` (or `--yes`) skips the confirmation prompt — useful in
+  scripts.
+
 ## Pre-flight checks (`.cmintrc`)
 
 `.cmintrc` is commit-mint's pre-commit check system. The config syntax is

package/dist/cli.mjs

@@ -29,7 +29,7 @@ var __exportAll = (all, no_symbols) => {
 //#region package.json
 var package_default = {
 	name: "@kyubiware/commit-mint",
-	version: "0.7.0",
+	version: "0.7.3",
 	description: "🌿 AI-powered git commit tool — auto-group changed files, generate messages, run pre-commit checks",
 	type: "module",
 	bin: { "cmint": "./dist/cli.mjs" },
@@ -1497,9 +1497,11 @@ function tryCopy(cmd, args, content) {
 //#region src/ui/check-failure-menu.ts
 const MAX_TSC_DIAGNOSTICS = 3;
 const MAX_ESLINT_DIAGNOSTICS = 3;
+const MAX_TEST_FAILURES = 3;
 const MAX_SUMMARY_LINE_LENGTH = 120;
 const TSC_DIAGNOSTIC = /^(.+?\.(?:ts|tsx|mts|cts|js|jsx|mjs|cjs))\((\d+),(\d+)\):\s+error\s+(TS\d+):\s+(.+)$/;
 const ESLINT_ERROR_LINE = /^\s*(\d+):(\d+)\s+(error|warning)\s+(.+)\s{2,}(\S+)\s*$/;
+const TEST_FILE_FAIL = /^\s*FAIL\s+(.+?\.(?:test|spec)\.[^\s>]+)\s*>\s*(.+)$/;
 function formatCheckFailureSummary(errors) {
 	if (errors.length === 0) return "No check error details were parsed. View full output for details.";
 	return errors.map((error) => formatCheckErrorSummary(error)).join("\n");
@@ -1513,6 +1515,10 @@ function formatCheckErrorSummary(error) {
 		const diagnostics = extractEslintDiagnostics(error.raw || error.message);
 		if (diagnostics.length > 0) return formatEslintSummary(diagnostics);
 	}
+	if (error.tool === "vitest" || error.tool === "jest") {
+		const failures = extractTestFailures(error.raw || error.message);
+		if (failures.length > 0) return formatTestFailureSummary(failures, error.tool);
+	}
 	const message = firstMeaningfulLine(error.message || error.raw);
 	return `  ${red("•")} [${error.tool}] ${truncate(message, MAX_SUMMARY_LINE_LENGTH)}`;
 }
@@ -1557,6 +1563,46 @@ function extractEslintDiagnostics(raw) {
 	}
 	return diagnostics;
 }
+function extractTestFailures(raw) {
+	const failures = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const line of raw.split("\n")) {
+		const match = TEST_FILE_FAIL.exec(line);
+		if (!match) continue;
+		const file = (match[1] ?? "").trim();
+		const name = (match[2] ?? "").trim();
+		if (!file || !name) continue;
+		const key = `${file}\u0000${name}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		failures.push({
+			file,
+			name
+		});
+	}
+	return failures;
+}
+function formatTestFailureSummary(failures, tool) {
+	const total = failures.length;
+	const visible = failures.slice(0, MAX_TEST_FAILURES);
+	const hidden = total - visible.length;
+	const fileCount = new Set(failures.map((f) => f.file)).size;
+	const testNoun = total === 1 ? "test" : "tests";
+	const fileNoun = fileCount === 1 ? "file" : "files";
+	const lines = [`  ${red("•")} [${tool}] ${total} failed ${testNoun} in ${fileCount} ${fileNoun}`];
+	const byFile = /* @__PURE__ */ new Map();
+	for (const failure of visible) {
+		const names = byFile.get(failure.file) ?? [];
+		names.push(failure.name);
+		byFile.set(failure.file, names);
+	}
+	for (const [file, names] of byFile) {
+		lines.push(`    ${truncate(file, MAX_SUMMARY_LINE_LENGTH)}`);
+		for (const name of names) lines.push(`      ${red("×")} ${truncate(name, MAX_SUMMARY_LINE_LENGTH)}`);
+	}
+	if (hidden > 0) lines.push(dim(`    +${hidden} more failed ${hidden === 1 ? "test" : "tests"}. View full output for details.`));
+	return lines.join("\n");
+}
 function formatEslintSummary(diagnostics) {
 	const visible = diagnostics.slice(0, MAX_ESLINT_DIAGNOSTICS);
 	const hidden = diagnostics.length - visible.length;
@@ -2263,6 +2309,272 @@ async function agentCommand(flags) {
 	});
 }
 //#endregion
+//#region src/services/update-check.ts
+const REGISTRY_URL = "https://registry.npmjs.org/-/package/@kyubiware/commit-mint/dist-tags";
+const PACKAGE_NAME$1 = "@kyubiware/commit-mint";
+const TTL_MS = 1440 * 60 * 1e3;
+const FETCH_TIMEOUT_MS = 5e3;
+let cachePath = join(os.homedir(), ".cache", "commit-mint", "update-check.json");
+let fetchImpl = globalThis.fetch;
+/**
+* Returns true when the notifier must not run: env opt-out, CI, test env,
+* non-TTY stderr, or an invalid/missing current version.
+*/
+function shouldSkip(currentVersion) {
+	const noUpdate = process.env.NO_UPDATE_NOTIFIER;
+	if (noUpdate !== void 0 && noUpdate !== "") return true;
+	const ci = process.env.CI;
+	if (ci !== void 0 && ci !== "" && ci !== "0") return true;
+	if (process.env.NODE_ENV === "test") return true;
+	if (process.stderr.isTTY !== true) return true;
+	if (currentVersion === void 0) return true;
+	if (currentVersion === "") return true;
+	if (semver.valid(currentVersion) === null) return true;
+	return false;
+}
+function loadCache() {
+	try {
+		const raw = readFileSync(cachePath, "utf8");
+		const parsed = JSON.parse(raw);
+		if (parsed !== null && typeof parsed === "object" && typeof parsed.latest === "string" && typeof parsed.checkedAt === "number") {
+			const entry = parsed;
+			const ageH = ((Date.now() - entry.checkedAt) / 36e5).toFixed(2);
+			debug("loadCache: hit — latest=%s, age=%sh", entry.latest, ageH);
+			return Promise.resolve(entry);
+		}
+		debug("loadCache: miss — malformed entry");
+		return Promise.resolve(null);
+	} catch {
+		debug("loadCache: miss — %s does not exist", cachePath);
+		return Promise.resolve(null);
+	}
+}
+function saveCache(entry) {
+	try {
+		mkdirSync(dirname(cachePath), { recursive: true });
+		writeFileSync(cachePath, JSON.stringify(entry), "utf8");
+		debug("saveCache: wrote latest=%s to %s", entry.latest, cachePath);
+	} catch (err) {
+		debug("saveCache: failed — %s", err instanceof Error ? err.message : String(err));
+	}
+	return Promise.resolve();
+}
+/**
+* Fetch latest version from the registry. Aborts on FETCH_TIMEOUT_MS or when
+* `parentSignal` aborts (user keypress). Returns null on any failure so the
+* caller can degrade silently.
+*/
+async function fetchLatest(parentSignal) {
+	debug("fetchLatest: GET %s (timeout=%dms)", REGISTRY_URL, FETCH_TIMEOUT_MS);
+	try {
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+		const onParentAbort = () => controller.abort();
+		if (parentSignal) if (parentSignal.aborted) controller.abort();
+		else parentSignal.addEventListener("abort", onParentAbort, { once: true });
+		try {
+			const response = await fetchImpl(REGISTRY_URL, { signal: controller.signal });
+			if (!response.ok) {
+				debug("fetchLatest: HTTP %d — returning null", response.status);
+				return null;
+			}
+			const data = await response.json();
+			if (typeof data.latest !== "string") {
+				debug("fetchLatest: response missing 'latest' field — returning null");
+				return null;
+			}
+			debug("fetchLatest: ok — latest=%s", data.latest);
+			return data.latest;
+		} finally {
+			clearTimeout(timer);
+			if (parentSignal) parentSignal.removeEventListener("abort", onParentAbort);
+		}
+	} catch (err) {
+		debug("fetchLatest: error — %s", err instanceof Error ? err.message : String(err));
+		return null;
+	}
+}
+function displayNag(current, latest) {
+	debug("displayNag: %s → %s", current, latest);
+	const message = `Update available: ${yellow(current)} → ${green(latest)}\nRun ${cyan(`npm update -g ${PACKAGE_NAME$1}`)} to update`;
+	log.warn(message);
+}
+/**
+* Run the full update check. Exported for tests; the public surface is
+* {@link checkForUpdatesUpfront}. Accepts an optional AbortSignal that
+* propagates to the underlying fetch — used by the cancellable spinner.
+*
+* Returns an {@link UpdateCheckStatus} so the caller can distinguish a
+* real fetch that found the user current (eligible for "You are on the
+* latest version" feedback) from a silent cache hit.
+*/
+async function runUpdateCheck(currentVersion, parentSignal) {
+	debug("runUpdateCheck: currentVersion=%s", currentVersion);
+	if (shouldSkip(currentVersion)) {
+		debug("runUpdateCheck: skipped (NO_UPDATE_NOTIFIER / CI / NODE_ENV=test / non-TTY / invalid version)");
+		return "skipped";
+	}
+	try {
+		const cached = await loadCache();
+		if (cached && Date.now() - cached.checkedAt < TTL_MS) {
+			debug("runUpdateCheck: cache fresh (<%dh), skipping fetch", TTL_MS / 36e5);
+			if (semver.gt(cached.latest, currentVersion)) {
+				displayNag(currentVersion, cached.latest);
+				return "cache-update";
+			}
+			debug("runUpdateCheck: current >= latest, no nag");
+			return "cache-current";
+		}
+		if (cached) debug("runUpdateCheck: cache stale, refetching");
+		else debug("runUpdateCheck: no cache, fetching");
+		const latest = await fetchLatest(parentSignal);
+		if (latest === null) {
+			debug("runUpdateCheck: fetch returned null, not saving cache");
+			return "fetch-failed-or-aborted";
+		}
+		await saveCache({
+			latest,
+			checkedAt: Date.now()
+		});
+		if (semver.gt(latest, currentVersion)) {
+			displayNag(currentVersion, latest);
+			return "fetch-update";
+		}
+		debug("runUpdateCheck: current >= latest, no nag");
+		return "fetch-current";
+	} catch (err) {
+		debug("runUpdateCheck: unexpected error — %s", err instanceof Error ? err.message : String(err));
+		return "error";
+	}
+}
+/**
+* Run the update check at startup. Silent when:
+*   - skip conditions match (CI, NO_UPDATE_NOTIFIER, NODE_ENV=test, non-TTY
+*     stderr, invalid version)
+*   - cache is fresh (< 24h old) — only displays nag if update available.
+*     A cache-hit-current result produces NO output (no "latest version"
+*     message), because no actual check was performed.
+*   - stdin is non-interactive (piped) — runs silently without spinner, but
+*     still shows "You are on the latest version" after a successful fetch
+*
+* On a stale/missing cache with interactive stdin, shows a spinner that the
+* user can dismiss by pressing any key. Ctrl+C restores the terminal and
+* exits with conventional code 130.
+*/
+async function checkForUpdatesUpfront(currentVersion) {
+	debug("checkForUpdatesUpfront: currentVersion=%s", currentVersion);
+	if (shouldSkip(currentVersion)) {
+		debug("checkForUpdatesUpfront: skipped (NO_UPDATE_NOTIFIER / CI / NODE_ENV=test / non-TTY / invalid version)");
+		return;
+	}
+	const cached = await loadCache();
+	if (cached && Date.now() - cached.checkedAt < TTL_MS) {
+		debug("checkForUpdatesUpfront: cache fresh (<%dh), skipping fetch", TTL_MS / 36e5);
+		if (semver.gt(cached.latest, currentVersion)) displayNag(currentVersion, cached.latest);
+		else debug("checkForUpdatesUpfront: current >= latest, no nag");
+		return;
+	}
+	if (cached) debug("checkForUpdatesUpfront: cache stale, refetching");
+	else debug("checkForUpdatesUpfront: no cache, fetching");
+	const stdin = process.stdin;
+	if (stdin.isTTY !== true || typeof stdin.setRawMode !== "function") {
+		debug("checkForUpdatesUpfront: stdin not interactive, running silent check");
+		reportFetchCurrent(await runUpdateCheck(currentVersion));
+		return;
+	}
+	await runCheckWithSpinner(currentVersion);
+}
+/**
+* Surface "You are on the latest version" feedback only when the check
+* actually performed a fetch and the user is current. Silent on cache hits,
+* skips, failures, and aborts.
+*/
+function reportFetchCurrent(status) {
+	if (status === "fetch-current") log.info(green("You are on the latest version"));
+}
+/**
+* Attach a "press any key to skip" listener to stdin. Returns a cleanup
+* function that restores raw mode + pauses stdin; safe to call multiple times.
+* Returns `failed: true` if raw mode could not be enabled (caller should fall
+* back to a silent check).
+*
+* On any keypress: aborts `controller`. On Ctrl+C (byte 0x03): runs cleanup,
+* stops the spinner with `spinnerMsg`, and exits with conventional code 130.
+*/
+function attachStdinSkip(controller, spinner, spinnerMsg) {
+	const stdin = process.stdin;
+	let cleanedUp = false;
+	const cleanup = () => {
+		if (cleanedUp) return;
+		cleanedUp = true;
+		stdin.off("data", onData);
+		try {
+			stdin.setRawMode(false);
+		} catch (err) {
+			debug("attachStdinSkip: setRawMode(false) failed — %s", err instanceof Error ? err.message : String(err));
+		}
+		try {
+			stdin.pause();
+		} catch {}
+	};
+	function onData(buffer) {
+		const byte = buffer[0];
+		debug("attachStdinSkip: stdin byte=0x%s", byte.toString(16).padStart(2, "0"));
+		if (byte === 3) {
+			debug("attachStdinSkip: Ctrl+C (0x03), exiting");
+			cleanup();
+			spinner.stop(spinnerMsg);
+			process.exit(130);
+		}
+		debug("attachStdinSkip: user pressed key, aborting check");
+		controller.abort();
+	}
+	try {
+		stdin.setRawMode(true);
+		stdin.resume();
+		stdin.on("data", onData);
+		return {
+			cleanup,
+			failed: false
+		};
+	} catch (err) {
+		debug("attachStdinSkip: setRawMode failed — %s", err instanceof Error ? err.message : String(err));
+		return {
+			cleanup: () => {},
+			failed: true
+		};
+	}
+}
+/**
+* Show a cancellable spinner while the check runs. Puts stdin in raw mode to
+* capture individual keypresses via {@link attachStdinSkip}.
+*/
+async function runCheckWithSpinner(currentVersion) {
+	debug("runCheckWithSpinner: showing cancellable spinner");
+	const s = spinner();
+	s.start("Checking for updates (press any key to skip)");
+	const controller = new AbortController();
+	const handler = attachStdinSkip(controller, s, "Cancelled");
+	if (handler.failed) {
+		s.stop("");
+		reportFetchCurrent(await runUpdateCheck(currentVersion));
+		return;
+	}
+	let status;
+	try {
+		status = await runUpdateCheck(currentVersion, controller.signal);
+	} finally {
+		handler.cleanup();
+	}
+	if (controller.signal.aborted) {
+		debug("runCheckWithSpinner: spinner dismissed by user");
+		s.stop("Skipped");
+	} else if (status === "fetch-current") s.stop(green("You are on the latest version"));
+	else if (status === "fetch-update") s.stop("");
+	else if (status === "fetch-failed-or-aborted") s.stop("Update check failed");
+	else s.stop("");
+}
+//#endregion
 //#region src/commands/commit-utils.ts
 /** Shared recovery menu factory — avoids repeating the same callback set */
 function makeRecoveryCallbacks(message) {
@@ -2697,13 +3009,14 @@ async function restageFormatterModifications(stagedFileList) {
 }
 //#endregion
 //#region src/commands/commit.ts
-async function commitCommand(flags) {
+async function commitCommand(flags, version) {
 	debug("commitCommand called", { flags });
 	await assertGitRepo();
 	if (flags.retry) return handleRetry();
 	const repoRoot = await getRepoRoot();
 	await runPreflightSetupPrompt(repoRoot);
 	intro("🌿 commit-mint");
+	await checkForUpdatesUpfront(version);
 	const status = await getStatusShort();
 	debug("Git status:", status || "(empty)");
 	if (!status) {
@@ -3059,93 +3372,147 @@ async function logsCommand(flags) {
 	for (const line of lines) console.log(line);
 }
 //#endregion
-//#region src/services/update-check.ts
-const REGISTRY_URL = "https://registry.npmjs.org/@kyubiware/commit-mint/latest";
+//#region src/services/updater.ts
 const PACKAGE_NAME = "@kyubiware/commit-mint";
-const TTL_MS = 1440 * 60 * 1e3;
-const FETCH_TIMEOUT_MS = 5e3;
-let cachePath = join(os.homedir(), ".cache", "commit-mint", "update-check.json");
-let fetchImpl = globalThis.fetch;
 /**
-* Returns true when the notifier must not run: env opt-out, CI, test env,
-* non-TTY stderr, or an invalid/missing current version.
+* Detect the active package manager from the `npm_config_user_agent` env var.
+* Format: "<pm>/<version> <...>" — e.g. "npm/10.2.0 node/v20.10.0".
+* Empty/undefined input and unrecognized prefixes fall back to "npm".
 */
-function shouldSkip(currentVersion) {
-	const noUpdate = process.env.NO_UPDATE_NOTIFIER;
-	if (noUpdate !== void 0 && noUpdate !== "") return true;
-	const ci = process.env.CI;
-	if (ci !== void 0 && ci !== "" && ci !== "0") return true;
-	if (process.env.NODE_ENV === "test") return true;
-	if (process.stderr.isTTY !== true) return true;
-	if (currentVersion === void 0) return true;
-	if (currentVersion === "") return true;
-	if (semver.valid(currentVersion) === null) return true;
-	return false;
-}
-function loadCache() {
-	try {
-		const raw = readFileSync(cachePath, "utf8");
-		const parsed = JSON.parse(raw);
-		if (parsed !== null && typeof parsed === "object" && typeof parsed.latest === "string" && typeof parsed.checkedAt === "number") return Promise.resolve(parsed);
-		return Promise.resolve(null);
-	} catch {
-		return Promise.resolve(null);
+function detectPackageManager(userAgent) {
+	if (!userAgent) {
+		debug("updater: empty userAgent, defaulting to npm");
+		return "npm";
+	}
+	const prefix = userAgent.split("/")[0];
+	switch (prefix) {
+		case "pnpm": return "pnpm";
+		case "yarn": return "yarn";
+		case "bun": return "bun";
+		case "npm": return "npm";
+		default:
+			debug("updater: unknown userAgent prefix '%s', defaulting to npm", prefix);
+			return "npm";
 	}
 }
-function saveCache(entry) {
-	try {
-		mkdirSync(dirname(cachePath), { recursive: true });
-		writeFileSync(cachePath, JSON.stringify(entry), "utf8");
-	} catch {}
-	return Promise.resolve();
+/**
+* Build the global install shell command for the given package manager.
+* Returned as a single string suitable for `execa(cmd, [], { shell: true })`.
+*/
+function buildUpdateCommand(pm, packageName = PACKAGE_NAME) {
+	switch (pm) {
+		case "npm": return `npm install -g ${packageName}@latest`;
+		case "pnpm": return `pnpm add -g ${packageName}@latest`;
+		case "yarn": return `yarn global add ${packageName}@latest`;
+		case "bun": return `bun add -g ${packageName}@latest`;
+	}
 }
-async function fetchLatest() {
+/**
+* Fetch the latest version from the npm registry via `npm view <pkg> version`.
+* Returns the trimmed version string on success, or null on any failure
+* (non-zero exit, empty stdout, thrown error). Never throws.
+*/
+async function fetchLatestVersion(packageName = PACKAGE_NAME) {
+	debug("updater: fetching latest version for %s", packageName);
 	try {
-		const controller = new AbortController();
-		const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
-		try {
-			const response = await fetchImpl(REGISTRY_URL, { signal: controller.signal });
-			if (!response.ok) return null;
-			const data = await response.json();
-			if (typeof data.latest !== "string") return null;
-			return data.latest;
-		} finally {
-			clearTimeout(timer);
+		const result = await execa("npm", [
+			"view",
+			packageName,
+			"version"
+		], { reject: false });
+		if (result.exitCode !== 0) {
+			debug("updater: npm view exited %d", result.exitCode);
+			return null;
 		}
-	} catch {
+		const trimmed = result.stdout.trim();
+		if (!trimmed) {
+			debug("updater: npm view returned empty stdout");
+			return null;
+		}
+		debug("updater: latest=%s", trimmed);
+		return trimmed;
+	} catch (err) {
+		debug("updater: fetchLatestVersion error — %s", err instanceof Error ? err.message : String(err));
 		return null;
 	}
 }
-function displayNag(current, latest) {
-	const message = `Update available: ${yellow(current)} → ${green(latest)}\nRun ${cyan(`npm update -g ${PACKAGE_NAME}`)} to update`;
-	log.warn(message);
+/**
+* True iff `latest` is strictly greater than `current` per semver. Returns
+* false on invalid semver input rather than throwing.
+*/
+function isUpdateAvailable(current, latest) {
+	try {
+		return semver.gt(latest, current);
+	} catch (err) {
+		debug("updater: isUpdateAvailable error — %s", err instanceof Error ? err.message : String(err));
+		return false;
+	}
 }
 /**
-* Run the full update check. Exported for tests; the public surface is
-* {@link checkForUpdates}, which schedules this on `beforeExit`.
+* Run the global install command for the given package manager. Streams
+* the installer's live output to the user's terminal via `stdio: "inherit"`.
+* Returns true iff the install exits with code 0.
 */
-async function runUpdateCheck(currentVersion) {
-	if (shouldSkip(currentVersion)) return;
+async function runUpdate(pm, packageName = PACKAGE_NAME) {
+	const command = buildUpdateCommand(pm, packageName);
+	debug("updater: running %s", command);
 	try {
-		const cached = await loadCache();
-		if (cached && Date.now() - cached.checkedAt < TTL_MS) {
-			if (semver.gt(cached.latest, currentVersion)) displayNag(currentVersion, cached.latest);
+		return (await execa(command, [], {
+			shell: true,
+			reject: false,
+			stdio: "inherit"
+		})).exitCode === 0;
+	} catch (err) {
+		debug("updater: runUpdate error — %s", err instanceof Error ? err.message : String(err));
+		return false;
+	}
+}
+//#endregion
+//#region src/commands/update.ts
+/**
+* Self-update flow for the installed `cmint` package. Detects the active
+* package manager from `npm_config_user_agent`, asks the npm registry for the
+* latest published version, and — if newer — runs the equivalent global
+* install command after a confirmation prompt (skippable with `--yes`).
+*
+* Never throws. Registry failures and install failures are reported through
+* `p.outro(...)` and `process.exit(1)`; cancellation and "already current"
+* resolve normally so the CLI exits cleanly.
+*/
+async function updateCommand(currentVersion, flags) {
+	p.intro("cmint update");
+	const pm = detectPackageManager(process.env.npm_config_user_agent);
+	p.log.info(`Package manager: ${pm}`);
+	p.log.message("Checking latest version...");
+	const latest = await fetchLatestVersion();
+	if (latest === null) {
+		p.outro(red("Could not reach the npm registry. Check your connection and try again."));
+		process.exit(1);
+		return;
+	}
+	if (!isUpdateAvailable(currentVersion, latest)) {
+		p.outro(`Already up-to-date: v${currentVersion}`);
+		return;
+	}
+	p.log.step(`${dim(currentVersion)} → ${green(latest)}`);
+	const cmd = buildUpdateCommand(pm);
+	if (flags?.yes !== true) {
+		const confirmed = await p.confirm({
+			message: `Run \`${cmd}\`?`,
+			initialValue: true
+		});
+		if (p.isCancel(confirmed) || !confirmed) {
+			p.outro("Update cancelled.");
 			return;
 		}
-		const latest = await fetchLatest();
-		if (latest === null) return;
-		await saveCache({
-			latest,
-			checkedAt: Date.now()
-		});
-		if (semver.gt(latest, currentVersion)) displayNag(currentVersion, latest);
-	} catch {}
-}
-/** Register the update check to run on `process.beforeExit`. */
-function checkForUpdates(currentVersion) {
-	process.on("beforeExit", () => {
-		runUpdateCheck(currentVersion);
-	});
+	}
+	p.log.message(`Running ${cyan(cmd)}...`);
+	if (await runUpdate(pm)) {
+		p.outro(green(`Updated to v${latest}`));
+		return;
+	}
+	p.outro(red("Update failed. See output above."));
+	process.exit(1);
 }
 //#endregion
 //#region src/cli.ts
@@ -3195,27 +3562,39 @@ cli({
 			default: false
 		}
 	},
-	commands: [command({
-		name: "logs",
-		description: "Show debug logs from the last cmint run",
-		flags: { lines: {
-			type: Number,
-			description: "Number of lines to show from the end",
-			alias: "n"
-		} }
-	}, async (argv) => {
-		await logsCommand(argv.flags);
-	}), command({ name: "config" }, async () => {
-		await configCommand();
-	})]
+	commands: [
+		command({
+			name: "logs",
+			description: "Show debug logs from the last cmint run",
+			flags: { lines: {
+				type: Number,
+				description: "Number of lines to show from the end",
+				alias: "n"
+			} }
+		}, async (argv) => {
+			await logsCommand(argv.flags);
+		}),
+		command({ name: "config" }, async () => {
+			await configCommand();
+		}),
+		command({
+			name: "update",
+			description: "Update cmint to the latest published version",
+			flags: { yes: {
+				type: Boolean,
+				description: "Skip confirmation prompt",
+				alias: "y",
+				default: false
+			} }
+		}, async (argv) => {
+			await updateCommand(version, argv.flags);
+		})
+	]
 }, (argv) => {
 	writeSessionHeader();
 	setDebug(argv.flags.debug);
 	if (argv.flags.agent) agentCommand(argv.flags);
-	else {
-		checkForUpdates(version);
-		commitCommand(argv.flags);
-	}
+	else commitCommand(argv.flags, version);
 });
 //#endregion
 export {};