@kyubiware/commit-mint 0.7.5 → 0.8.0

package/README.md

@@ -36,17 +36,21 @@ cmint update      # update cmint to the latest published version
 
 See [all flags](#all-flags) for the full list.
 
-## Self-update (`cmint update`)
+## Providers
 
-`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).
+| Provider | Env var           | Default model        |
+| -------- | ----------------- | -------------------- |
+| Groq     | `GROQ_API_KEY`    | `openai/gpt-oss-20b` |
+| Cerebras | `CEREBRAS_API_KEY` | `gpt-oss-120b`     |
+| Mistral  | `MISTRAL_API_KEY` | `mistral-small`      |
 
-- 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.
+All three use OpenAI-compatible APIs and have a generous free tier. Groq uses the official SDK; Cerebras and
+Mistral use a built-in fetch client. Per-provider model overrides: set
+`model_groq`, `model_cerebras`, or `model_mistral` in `~/.commit-mint`.
+Resolution order is `model_<provider>` → `model` → provider default.
+
+`cmint config` walks you through provider, API key, model, locale, and
+timeout.
 
 ## Pre-flight checks (`.cmintrc`)
 
@@ -112,6 +116,18 @@ What do you want to stage?
   Run checks
 ```
 
+## 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.
+
 ## AI Agent Mode
 
 `cmint --agent` runs non-interactively with JSON output for AI coding agents.
@@ -194,22 +210,6 @@ they happen.
 Errors are parsed from **lint-staged**, **biome**, **tsc**, **vitest**/**jest**,
 and **eslint**. Unrecognized output falls back to a single raw-stderr entry.
 
-## Providers
-
-| Provider | Env var           | Default model        |
-| -------- | ----------------- | -------------------- |
-| Groq     | `GROQ_API_KEY`    | `openai/gpt-oss-20b` |
-| Cerebras | `CEREBRAS_API_KEY` | `gpt-oss-120b`     |
-| Mistral  | `MISTRAL_API_KEY` | `mistral-small`      |
-
-All three use OpenAI-compatible APIs. Groq uses the official SDK; Cerebras and
-Mistral use a built-in fetch client. Per-provider model overrides: set
-`model_groq`, `model_cerebras`, or `model_mistral` in `~/.commit-mint`.
-Resolution order is `model_<provider>` → `model` → provider default.
-
-`cmint config` walks you through provider, API key, model, locale, and
-timeout.
-
 ## Configuration
 
 `~/.commit-mint` (INI format). Run `cmint config` to edit.

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.8.0",
 	description: "🌿 AI-powered git commit tool — auto-group changed files, generate messages, run pre-commit checks",
 	type: "module",
 	bin: { "cmint": "./dist/cli.mjs" },
@@ -1026,7 +1026,11 @@ async function getStatusShort() {
 	return stdout.trim();
 }
 async function getChangedFiles() {
-	const { stdout } = await execa("git", ["status", "--short"]);
+	const { stdout } = await execa("git", [
+		"status",
+		"--short",
+		"--untracked-files=all"
+	]);
 	if (!stdout.trim()) return [];
 	const files = stdout.split("\n").filter(Boolean).map((line) => {
 		const indexStatus = line[0];
@@ -1167,6 +1171,168 @@ function parseGroupingResponse(content) {
 	throw new Error("AI response did not contain a JSON array");
 }
 //#endregion
+//#region src/services/grouping-reunite.ts
+/**
+* # Test/source reunification
+*
+* AI grouping prompts ask the model to keep a source file and its tests in the
+* same commit group, but the model frequently ignores that instruction (it
+* split `git.ts` from `git.test.ts` in the bug report that motivated this
+* module). The functions here provide a deterministic post-processing pass
+* that moves misplaced test files back into the group already containing
+* their source counterpart, regardless of what the model decided.
+*
+* Supported layouts (in priority order):
+* 1. Co-located: `src/foo.ts` ↔ `src/foo.test.ts`
+* 2. `__tests__/` mirror: `src/foo.ts` ↔ `src/__tests__/foo.test.ts`
+* 3. `tests/` or `test/` mirror: `src/foo.ts` ↔ `tests/foo.test.ts`
+*
+* Reunification runs inside `validateGroups()` (see `grouping.ts`) after
+* hallucinated-path filtering so only real files participate.
+*/
+/** Suffixes that mark a file as a test companion of a same-name source. */
+const TEST_SUFFIXES = [".test", ".spec"];
+/**
+* Extensions tried when looking for a source counterpart for a test file. The
+* test file's own extension is usually the right one, but we also try common
+* alternates (a `.test.tsx` may back a `.tsx` or a `.ts`).
+*/
+const SOURCE_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+	".mts",
+	".cts"
+];
+/** Matches a test file by extension regardless of which suffix it uses. */
+const TEST_FILE_PATTERN = /\.(?:test|spec)\.(?:ts|tsx|js|jsx|mjs|cjs|mts|cts)$/;
+/** Directory prefixes/segments that mirror source layout for non-co-located tests. */
+const TEST_DIR_PREFIXES = ["tests/", "test/"];
+/** Marker segment for co-located `__tests__/` directories. */
+const TESTS_DIR_SEGMENT = "/__tests__/";
+function stripTestSuffix(filename) {
+	for (const suffix of TEST_SUFFIXES) {
+		const marker = `${suffix}.`;
+		const idx = filename.lastIndexOf(marker);
+		if (idx > 0) return filename.slice(0, idx);
+	}
+	return null;
+}
+function withEachExtension(base) {
+	return SOURCE_EXTENSIONS.map((ext) => `${base}${ext}`);
+}
+/** Co-located: `dir/foo.test.ts` → `dir/foo.{ts,tsx,...}` */
+function colocatedCandidates(testPath) {
+	const base = stripTestSuffix(testPath);
+	return base === null ? [] : withEachExtension(base);
+}
+/** `__tests__` mirror: `src/__tests__/foo.test.ts` → `src/foo.{ts,tsx,...}` */
+function testsDirCandidates(testPath) {
+	const segmentIdx = testPath.indexOf(TESTS_DIR_SEGMENT);
+	if (segmentIdx < 0) return [];
+	const parentDir = testPath.slice(0, segmentIdx);
+	const base = stripTestSuffix(testPath.slice(segmentIdx + 11));
+	if (base === null) return [];
+	return withEachExtension(`${parentDir}/${base}`);
+}
+/** `tests/` or `test/` mirror: `tests/services/foo.test.ts` → `src/services/foo.{ts,tsx,...}` */
+function prefixedDirCandidates(testPath) {
+	for (const prefix of TEST_DIR_PREFIXES) {
+		if (!testPath.startsWith(prefix)) continue;
+		const base = stripTestSuffix(testPath.slice(prefix.length));
+		if (base === null) return [];
+		return withEachExtension(`src/${base}`);
+	}
+	return [];
+}
+/**
+* Compute candidate source paths for a test file in priority order: co-located
+* first, then `__tests__/` mirror, then `tests/`/`test/` mirror. Each mirror
+* emits one entry per `SOURCE_EXTENSIONS` candidate so the caller can match
+* against any of them.
+*/
+function candidateSourcePaths(testPath) {
+	return [
+		...colocatedCandidates(testPath),
+		...testsDirCandidates(testPath),
+		...prefixedDirCandidates(testPath)
+	];
+}
+/**
+* Resolve the unambiguous target group for a single test file, or `null` when
+* no source counterpart exists / matches more than one group (ambiguous). A
+* test whose candidates span multiple groups (e.g. `foo.ts` and `foo.tsx` in
+* different groups) is intentionally left alone rather than guessed.
+*/
+function findTargetGroup(testFile, currentGi, fileToGroup) {
+	const targetGroups = /* @__PURE__ */ new Set();
+	for (const candidate of candidateSourcePaths(testFile)) {
+		const targetGi = fileToGroup.get(candidate);
+		if (targetGi !== void 0 && targetGi !== currentGi) targetGroups.add(targetGi);
+	}
+	return targetGroups.size === 1 ? [...targetGroups][0] : null;
+}
+/**
+* Find the unambiguous target group for each misplaced test file.
+*
+* Returns a map of `testFile → targetGroupIndex`. A test is only moved when
+* its candidate source matches exactly one other group; ambiguous matches are
+* skipped (see {@link findTargetGroup}).
+*/
+function findMoves(groups, fileToGroup) {
+	const moves = /* @__PURE__ */ new Map();
+	for (let gi = 0; gi < groups.length; gi++) for (const file of groups[gi].files) {
+		if (moves.has(file) || !TEST_FILE_PATTERN.test(file)) continue;
+		const target = findTargetGroup(file, gi, fileToGroup);
+		if (target !== null) moves.set(file, target);
+	}
+	return moves;
+}
+/**
+* Apply queued moves to a fresh copy of the groups array. Tests are removed
+* from their original group and appended to the target group. Groups left
+* empty by moves are dropped.
+*/
+function applyMoves(groups, moves) {
+	const result = groups.map((g) => ({
+		...g,
+		files: [...g.files]
+	}));
+	const movedFiles = new Set(moves.keys());
+	const additionsByGroup = /* @__PURE__ */ new Map();
+	for (const [file, toGroup] of moves) {
+		const bucket = additionsByGroup.get(toGroup) ?? [];
+		bucket.push(file);
+		additionsByGroup.set(toGroup, bucket);
+	}
+	for (let gi = 0; gi < result.length; gi++) {
+		if (movedFiles.size > 0) result[gi].files = result[gi].files.filter((f) => !movedFiles.has(f));
+		const additions = additionsByGroup.get(gi);
+		if (!additions) continue;
+		const existing = new Set(result[gi].files);
+		for (const file of additions) if (!existing.has(file)) result[gi].files.push(file);
+	}
+	return result.filter((g) => g.files.length > 0);
+}
+/**
+* Move test files (`.test.*` / `.spec.*`) into the group that already contains
+* their source counterpart. Returns the same array reference if no moves were
+* needed; otherwise returns a fresh array of new group objects.
+*
+* See module doc for the matching algorithm.
+*/
+function reuniteTestsWithSources(groups) {
+	if (groups.length === 0) return groups;
+	const fileToGroup = /* @__PURE__ */ new Map();
+	for (let gi = 0; gi < groups.length; gi++) for (const file of groups[gi].files) fileToGroup.set(file, gi);
+	const moves = findMoves(groups, fileToGroup);
+	if (moves.size === 0) return groups;
+	return applyMoves(groups, moves);
+}
+//#endregion
 //#region src/services/grouping.ts
 function matchesExcludePattern(filePath, pattern) {
 	if (pattern === filePath) return true;
@@ -1227,7 +1393,8 @@ function buildGroupingSystemPrompt() {
 		"You are analyzing changed files in a git repository. Group them into logical commits based on what changed and why. Each group should be a coherent unit of work.",
 		"",
 		"Rules:",
-		"- Group by feature, fix, or concern (e.g., 'Frontend refactor', 'API changes', 'Test updates')",
+		"- ALWAYS keep a test file in the same group as the source file it tests. Examples: `foo.test.ts` stays with `foo.ts`; `__tests__/foo.test.ts` stays with `foo.ts` in the parent directory; `tests/foo.test.ts` stays with `src/foo.ts`. Never put source and its tests in separate groups.",
+		"- Group by feature, fix, or concern (e.g., 'Frontend refactor', 'API changes')",
 		"- Keep related files together (e.g., a component + its test, a model + its migration)",
 		"- Separate documentation changes (*.md files, docs/) from code changes — put docs in their own group",
 		"- Do not split a single logical change across multiple groups",
@@ -1255,12 +1422,13 @@ function buildRetryGroupingPrompt() {
 		"You MUST split the files into at least 2 groups based on what changed and why.",
 		"",
 		"Look for these natural split points:",
-		"- Source code vs tests",
 		"- Different features or modules (e.g., different directories)",
 		"- New files vs modified files vs deleted files",
 		"- Configuration changes vs code changes",
 		"- Documentation vs implementation",
 		"",
+		"Do NOT split a source file from its tests — keep `foo.ts` and `foo.test.ts` in the same group.",
+		"",
 		"If unsure, err on the side of MORE groups, not fewer.",
 		"",
 		"Output format: JSON array of objects with keys 'name', 'description', 'files'.",
@@ -1359,16 +1527,18 @@ function validateGroups(groups, allFiles) {
 			files: uniqueFiles
 		});
 	}
+	const reunited = reuniteTestsWithSources(validated);
+	if (reunited !== validated) debug("validateGroups: reunited %d groups after test/source merge", reunited.length);
 	const ungrouped = allFiles.filter((f) => !seen.has(f.path));
 	if (ungrouped.length > 0) {
 		debug("validateGroups: %d ungrouped files added to 'Other changes'", ungrouped.length);
-		validated.push({
+		reunited.push({
 			name: "Other changes",
 			description: "Miscellaneous changes that did not fit into other groups",
 			files: ungrouped.map((f) => f.path)
 		});
 	}
-	return validated;
+	return reunited;
 }
 const EXIT_CODES = {
 	SUCCESS: 0,
@@ -2354,7 +2524,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 +2613,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 +2697,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 +2740,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") {