@kyubiware/commit-mint 0.7.6 → 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.6",
+	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,