@kyubiware/commit-mint 0.7.4 → 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.4",
+	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" },
@@ -1866,25 +1866,65 @@ async function showRecoveryMenu(errors, onRetry, onSkipHooks, onRestage, message
 }
 //#endregion
 //#region src/ui/review-message.ts
-async function reviewCommitMessage(message) {
-	const { select, text } = await import("@clack/prompts");
+async function handleEdit(message) {
+	const { text } = await import("@clack/prompts");
+	const edited = await text({
+		message: "Edit commit message:",
+		initialValue: message,
+		validate: (v) => v?.trim() ? void 0 : "Message cannot be empty"
+	});
+	if (isCancel(edited)) {
+		debug("User cancelled edit, returning to review menu");
+		return null;
+	}
+	const newMessage = String(edited).trim();
+	debug("Edited message:", newMessage);
+	return newMessage;
+}
+async function handleRegenerate(regenerate) {
+	const { log, text } = await import("@clack/prompts");
+	const hint = await text({
+		message: "Describe what this commit is about to guide regeneration:",
+		validate: (v) => v?.trim() ? void 0 : "Hint cannot be empty"
+	});
+	if (isCancel(hint)) {
+		debug("User cancelled hint entry, returning to review menu");
+		return null;
+	}
+	const hintValue = String(hint).trim();
+	debug("Regenerating with hint:", hintValue);
+	try {
+		const newMessage = await regenerate(hintValue);
+		debug("Regenerated message:", newMessage);
+		return newMessage;
+	} catch (err) {
+		const errMsg = err instanceof Error ? err.message : String(err);
+		debug("Regeneration failed:", errMsg);
+		log.warn(red(`Regeneration failed: ${errMsg}`));
+		return null;
+	}
+}
+async function reviewCommitMessage(message, options) {
+	const { select } = await import("@clack/prompts");
 	while (true) {
+		const reviewOptions = [{
+			label: "Use as-is",
+			value: "use"
+		}, {
+			label: "Edit",
+			value: "edit"
+		}];
+		if (options?.regenerate) reviewOptions.push({
+			label: "Regenerate with hint",
+			value: "regenerate"
+		});
+		reviewOptions.push({
+			label: "Cancel",
+			value: "cancel"
+		});
 		const review = await select({
 			message: `Review commit message:\n\n   ${bold(message)}\n`,
-			options: [
-				{
-					label: "Use as-is",
-					value: "use"
-				},
-				{
-					label: "Edit",
-					value: "edit"
-				},
-				{
-					label: "Cancel",
-					value: "cancel"
-				}
-			]
+			options: reviewOptions
 		});
 		if (isCancel(review) || review === "cancel") {
 			debug("User cancelled at review step");
@@ -1894,17 +1934,8 @@ async function reviewCommitMessage(message) {
 			debug("User accepted message");
 			return message;
 		}
-		if (review === "edit") {
-			debug("User chose to edit message");
-			const edited = await text({
-				message: "Edit commit message:",
-				initialValue: message,
-				validate: (v) => v?.trim() ? void 0 : "Message cannot be empty"
-			});
-			if (isCancel(edited)) continue;
-			message = String(edited).trim();
-			debug("Edited message:", message);
-		}
+		if (review === "edit") message = await handleEdit(message) ?? message;
+		if (review === "regenerate" && options?.regenerate) message = await handleRegenerate(options.regenerate) ?? message;
 	}
 }
 //#endregion
@@ -2019,7 +2050,19 @@ async function runAutoGroupFlow(changedFiles, flags) {
 		log.info(dim(message));
 		if (flags.auto) debug("Auto mode: accepting generated message");
 		else {
-			const reviewed = await reviewCommitMessage(message);
+			const reviewed = await reviewCommitMessage(message, { regenerate: async (hint) => {
+				const combinedHint = flags.hint ? `${flags.hint}\n${hint}` : hint;
+				debug("Regenerating with combined hint:", combinedHint);
+				s.start("Regenerating commit message...");
+				try {
+					const newMessage = await generateMessage(diffResult.diff, combinedHint);
+					s.stop("Message regenerated");
+					return newMessage;
+				} catch (err) {
+					s.stop(red("Regeneration failed"));
+					throw err;
+				}
+			} });
 			if (reviewed === null) {
 				outro(dim("Cancelled."));
 				return "cancelled";
@@ -2311,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;
@@ -2399,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.
@@ -2419,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");
@@ -2472,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") {
@@ -3009,11 +3105,13 @@ async function runPreCommitChecks(changedFiles, noCheck) {
 }
 /**
 * Re-stage staged files whose working-tree content diverged from the index after checks ran.
-* Signal: a file with both index and working-tree modifications has git status "MM".
+* Signals (git status --short, 2-char XY code):
+*   "MM" — tracked file staged-modified, then reformatted on disk
+*   "AM" — newly-added file staged, then reformatted on disk
 */
 async function restageFormatterModifications(stagedFileList) {
 	const checkedSet = new Set(stagedFileList);
-	const modifiedByChecks = (await getChangedFiles()).filter((f) => checkedSet.has(f.path) && f.staged && f.status === "MM").map((f) => f.path);
+	const modifiedByChecks = (await getChangedFiles()).filter((f) => checkedSet.has(f.path) && f.staged && (f.status === "MM" || f.status === "AM")).map((f) => f.path);
 	if (modifiedByChecks.length === 0) return;
 	debug("Re-staging %d file(s) modified by checks", modifiedByChecks.length);
 	await stageFiles(modifiedByChecks);
@@ -3127,7 +3225,19 @@ async function commitCommand(flags, version) {
 		}
 		s.stop("Message generated");
 	}
-	const reviewed = await reviewCommitMessage(message);
+	const reviewed = await reviewCommitMessage(message, { regenerate: async (hint) => {
+		const combinedHint = flags.hint ? `${flags.hint}\n${hint}` : hint;
+		debug("Regenerating with combined hint:", combinedHint);
+		s.start("Regenerating commit message...");
+		try {
+			const newMessage = await generateMessage(diffResult.diff, combinedHint);
+			s.stop("Message regenerated");
+			return newMessage;
+		} catch (err) {
+			s.stop(red("Regeneration failed"));
+			throw err;
+		}
+	} });
 	if (reviewed === null) {
 		outro(dim("Cancelled."));
 		return;