@kyubiware/commit-mint 0.7.5 → 0.7.6

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.5",
+	version: "0.7.6",
 	description: "🌿 AI-powered git commit tool — auto-group changed files, generate messages, run pre-commit checks",
 	type: "module",
 	bin: { "cmint": "./dist/cli.mjs" },
@@ -2354,7 +2354,8 @@ 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 TTL_MS = 1440 * 60 * 1e3;
+const FRESH_MS = 3600 * 1e3;
+const STALE_MS = 1440 * 60 * 1e3;
 const FETCH_TIMEOUT_MS = 5e3;
 let cachePath = join(os.homedir(), ".cache", "commit-mint", "update-check.json");
 let fetchImpl = globalThis.fetch;
@@ -2442,6 +2443,70 @@ function displayNag(current, latest) {
 	log.warn(message);
 }
 /**
+* Fire-and-forget cache refresh used by the stale-while-revalidate (SWR) band
+* (cache age in [FRESH_MS, STALE_MS)). Runs the registry fetch and writes a
+* fresh cache entry without awaiting — the caller returns immediately with
+* the cached `latest` so the nag decision is fast.
+*
+* Wrapped in try/catch and `void`-ed so the floating promise NEVER rejects
+* (vitest fails the suite on unhandled rejections). On any failure (network,
+* HTTP non-ok, malformed JSON, fs write error) the cache file is left
+* unchanged and the failure is logged via {@link debug} only.
+*
+* No abort signal is wired here — the cancellable spinner only runs on the
+* STALE blocking-fetch path, and FRESH/SWR callers explicitly want this to
+* complete in the background regardless of user keystrokes.
+*/
+function refreshCacheInBackground() {
+	debug("refreshCacheInBackground: starting fire-and-forget refresh");
+	(async () => {
+		try {
+			const latest = await fetchLatest();
+			if (latest === null) {
+				debug("refreshCacheInBackground: fetch returned null, leaving cache unchanged");
+				return;
+			}
+			await saveCache({
+				latest,
+				checkedAt: Date.now()
+			});
+			debug("refreshCacheInBackground: refreshed cache to latest=%s", latest);
+		} catch (err) {
+			debug("refreshCacheInBackground: failed — %s", err instanceof Error ? err.message : String(err));
+		}
+	})();
+}
+/**
+* Resolve the cache-hit branch (FRESH / SWR / stale-or-missing). Returns
+* `null` when the caller must fall through to the blocking-fetch path; returns
+* a {@link UpdateCheckStatus} when the cache hit is terminal.
+*
+* Side effect: kicks off a fire-and-forget {@link refreshCacheInBackground}
+* when age is in the SWR band [FRESH_MS, STALE_MS).
+*/
+function resolveCacheHit(cached, currentVersion, onNag) {
+	if (cached === null) {
+		debug("runUpdateCheck: no cache, fetching");
+		return null;
+	}
+	const age = Date.now() - cached.checkedAt;
+	if (age >= STALE_MS) {
+		debug("runUpdateCheck: cache stale (>=%dh), refetching", STALE_MS / 36e5);
+		return null;
+	}
+	if (age < FRESH_MS) debug("runUpdateCheck: cache fresh (<%dh), serving from cache", FRESH_MS / 36e5);
+	else {
+		debug("runUpdateCheck: cache in SWR band (<%dh), serving + background refresh", STALE_MS / 36e5);
+		refreshCacheInBackground();
+	}
+	if (semver.gt(cached.latest, currentVersion)) {
+		onNag(currentVersion, cached.latest);
+		return "cache-update";
+	}
+	debug("runUpdateCheck: current >= latest, no nag");
+	return "cache-current";
+}
+/**
 * 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.
@@ -2462,18 +2527,8 @@ async function runUpdateCheck(currentVersion, parentSignal, onNag = displayNag)
 		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)) {
-				onNag(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 cacheStatus = resolveCacheHit(await loadCache(), currentVersion, onNag);
+		if (cacheStatus !== null) return cacheStatus;
 		const latest = await fetchLatest(parentSignal);
 		if (latest === null) {
 			debug("runUpdateCheck: fetch returned null, not saving cache");
@@ -2515,13 +2570,11 @@ async function checkForUpdatesUpfront(currentVersion) {
 		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");
+	if (cached && Date.now() - cached.checkedAt < STALE_MS) {
+		await runUpdateCheck(currentVersion);
 		return;
 	}
-	if (cached) debug("checkForUpdatesUpfront: cache stale, refetching");
+	if (cached) debug("checkForUpdatesUpfront: cache stale (>=%dh), refetching", STALE_MS / 36e5);
 	else debug("checkForUpdatesUpfront: no cache, fetching");
 	const stdin = process.stdin;
 	if (stdin.isTTY !== true || typeof stdin.setRawMode !== "function") {