@kyubiware/commit-mint 0.6.6 → 0.7.2

package/dist/cli.mjs

@@ -3,7 +3,7 @@ import { cli, command } from "cleye";
 import Groq from "groq-sdk";
 import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import os from "node:os";
-import { extname, join } from "node:path";
+import { dirname, extname, join } from "node:path";
 import { bold, cyan, dim, green, red, yellow } from "kolorist";
 import { access, constants, mkdir, readFile, writeFile } from "node:fs/promises";
 import { execa } from "execa";
@@ -13,6 +13,7 @@ import { createHash } from "node:crypto";
 import * as p from "@clack/prompts";
 import { intro, isCancel, log, outro, spinner } from "@clack/prompts";
 import { spawn } from "node:child_process";
+import semver from "semver";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
@@ -28,7 +29,7 @@ var __exportAll = (all, no_symbols) => {
 //#region package.json
 var package_default = {
 	name: "@kyubiware/commit-mint",
-	version: "0.6.6",
+	version: "0.7.2",
 	description: "🌿 AI-powered git commit tool — auto-group changed files, generate messages, run pre-commit checks",
 	type: "module",
 	bin: { "cmint": "./dist/cli.mjs" },
@@ -74,11 +75,13 @@ var package_default = {
 		"ini": "^5.0.0",
 		"jiti": "^2.7.0",
 		"kolorist": "^1.8.0",
-		"picomatch": "^4.0.4"
+		"picomatch": "^4.0.4",
+		"semver": "^7.7.2"
 	},
 	devDependencies: {
 		"@biomejs/biome": "^2.0.0",
 		"@types/ini": "^4.1.1",
+		"@types/semver": "^7.7.1",
 		"@vitest/coverage-v8": "^3.2.4",
 		"tsdown": "^0.22.0",
 		"tsx": "^4.22.2",
@@ -1385,7 +1388,7 @@ const CACHE_DIR = join(os.homedir(), ".cache", "commit-mint");
 function repoHash(repoPath) {
 	return createHash("sha256").update(repoPath).digest("hex").slice(0, 12);
 }
-function cachePath(repoPath) {
+function cachePath$1(repoPath) {
 	return join(CACHE_DIR, `${repoHash(repoPath)}.json`);
 }
 async function saveCachedCommit(repoPath, message) {
@@ -1395,12 +1398,12 @@ async function saveCachedCommit(repoPath, message) {
 		timestamp: Date.now(),
 		repoPath
 	};
-	const path = cachePath(repoPath);
+	const path = cachePath$1(repoPath);
 	debug("saveCachedCommit: saving to %s", path);
 	await writeFile(path, JSON.stringify(data, null, 2), "utf8");
 }
 async function loadCachedCommit(repoPath) {
-	const path = cachePath(repoPath);
+	const path = cachePath$1(repoPath);
 	debug("loadCachedCommit: loading from %s", path);
 	try {
 		const raw = await readFile(path, "utf8");
@@ -1494,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");
@@ -1510,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)}`;
 }
@@ -1554,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;
@@ -2260,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 = "@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}`)} 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) {
@@ -2694,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) {
@@ -3120,7 +3436,7 @@ cli({
 	writeSessionHeader();
 	setDebug(argv.flags.debug);
 	if (argv.flags.agent) agentCommand(argv.flags);
-	else commitCommand(argv.flags);
+	else commitCommand(argv.flags, version);
 });
 //#endregion
 export {};