@kyubiware/commit-mint 0.7.2 → 0.7.4

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.2",
+	version: "0.7.4",
 	description: "🌿 AI-powered git commit tool — auto-group changed files, generate messages, run pre-commit checks",
 	type: "module",
 	bin: { "cmint": "./dist/cli.mjs" },
@@ -2311,7 +2311,6 @@ 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 = "@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");
@@ -2396,7 +2395,7 @@ async function fetchLatest(parentSignal) {
 }
 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}`)} to update`;
+	const message = `Update available: ${yellow(current)} → ${green(latest)}\nRun ${cyan("cmint update")} to update`;
 	log.warn(message);
 }
 /**
@@ -2404,11 +2403,16 @@ function displayNag(current, latest) {
 * {@link checkForUpdatesUpfront}. Accepts an optional AbortSignal that
 * propagates to the underlying fetch — used by the cancellable spinner.
 *
+* When an update is available, {@link onNag} is invoked (defaulting to
+* {@link displayNag}). The cancellable spinner path passes a capturing
+* callback so it can stop the spinner BEFORE the nag prints — otherwise
+* `log.warn` interleaves with the spinner line and leaves it on screen.
+*
 * 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) {
+async function runUpdateCheck(currentVersion, parentSignal, onNag = displayNag) {
 	debug("runUpdateCheck: currentVersion=%s", currentVersion);
 	if (shouldSkip(currentVersion)) {
 		debug("runUpdateCheck: skipped (NO_UPDATE_NOTIFIER / CI / NODE_ENV=test / non-TTY / invalid version)");
@@ -2419,7 +2423,7 @@ async function runUpdateCheck(currentVersion, parentSignal) {
 		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);
+				onNag(currentVersion, cached.latest);
 				return "cache-update";
 			}
 			debug("runUpdateCheck: current >= latest, no nag");
@@ -2437,7 +2441,7 @@ async function runUpdateCheck(currentVersion, parentSignal) {
 			checkedAt: Date.now()
 		});
 		if (semver.gt(latest, currentVersion)) {
-			displayNag(currentVersion, latest);
+			onNag(currentVersion, latest);
 			return "fetch-update";
 		}
 		debug("runUpdateCheck: current >= latest, no nag");
@@ -2560,9 +2564,15 @@ async function runCheckWithSpinner(currentVersion) {
 		reportFetchCurrent(await runUpdateCheck(currentVersion));
 		return;
 	}
+	const captured = { nag: null };
 	let status;
 	try {
-		status = await runUpdateCheck(currentVersion, controller.signal);
+		status = await runUpdateCheck(currentVersion, controller.signal, (current, latest) => {
+			captured.nag = {
+				current,
+				latest
+			};
+		});
 	} finally {
 		handler.cleanup();
 	}
@@ -2570,8 +2580,10 @@ async function runCheckWithSpinner(currentVersion) {
 		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 if (status === "fetch-update" || status === "cache-update") {
+		s.stop("");
+		if (captured.nag) displayNag(captured.nag.current, captured.nag.latest);
+	} else if (status === "fetch-failed-or-aborted") s.stop("Update check failed");
 	else s.stop("");
 }
 //#endregion
@@ -3372,6 +3384,149 @@ async function logsCommand(flags) {
 	for (const line of lines) console.log(line);
 }
 //#endregion
+//#region src/services/updater.ts
+const PACKAGE_NAME = "@kyubiware/commit-mint";
+/**
+* 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 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";
+	}
+}
+/**
+* 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`;
+	}
+}
+/**
+* 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 result = await execa("npm", [
+			"view",
+			packageName,
+			"version"
+		], { reject: false });
+		if (result.exitCode !== 0) {
+			debug("updater: npm view exited %d", result.exitCode);
+			return null;
+		}
+		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;
+	}
+}
+/**
+* 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 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 runUpdate(pm, packageName = PACKAGE_NAME) {
+	const command = buildUpdateCommand(pm, packageName);
+	debug("updater: running %s", command);
+	try {
+		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;
+		}
+	}
+	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
 const { version } = package_default;
 cli({
@@ -3419,19 +3574,34 @@ 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);