@kyubiware/commit-mint 0.9.2 → 0.9.4

package/README.md

@@ -274,7 +274,7 @@ returns either.
 | Form | Behavior |
 |---|---|
 | `string` | Matched files are appended as trailing arguments. Paths with spaces are quoted automatically. |
-| `string[]` | Commands run sequentially, each as a separate command. First failure stops the run. |
+| `string[]` | Commands run sequentially, each as a separate command. All commands run regardless of failures. |
 | `(files) => string \| string[]` | Function receives the matched files. Use when the command depends on the file list. |
 
 **String command:**
@@ -313,8 +313,8 @@ export default {
 
 - Checks run after `git add`, before the AI call.
 - Globs are processed in declaration order.
-- Commands run sequentially per glob. First failure stops the run (fail-fast)
-  and skips remaining globs.
+- Commands run sequentially per glob. All commands and all globs always run;
+  failures are collected and returned together.
 - 60s timeout per command. ENOENT (command not found) and timeouts are
   reported back to the menu as their own error.
 - Skipped entirely with `cmint -N` or the `c` hotkey toggle.

package/dist/bin.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { cli, command } from "cleye";
 import * as p$1 from "@clack/prompts";
-import { S_BAR, S_BAR_END, S_RADIO_ACTIVE, S_RADIO_INACTIVE, intro, isCancel, limitOptions, log, outro, spinner, symbol } from "@clack/prompts";
+import { S_BAR, S_BAR_END, S_CHECKBOX_ACTIVE, S_CHECKBOX_INACTIVE, S_CHECKBOX_SELECTED, S_RADIO_ACTIVE, S_RADIO_INACTIVE, intro, isCancel, limitOptions, log, outro, spinner, symbol } from "@clack/prompts";
 import { bold, cyan, dim, green, red, yellow } from "kolorist";
 import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import os from "node:os";
@@ -33,7 +33,7 @@ var __exportAll = (all, no_symbols) => {
 //#region package.json
 var package_default = {
 	name: "@kyubiware/commit-mint",
-	version: "0.9.2",
+	version: "0.9.4",
 	description: "🌿 AI-powered git commit tool — auto-group changed files, generate messages, run pre-commit checks",
 	type: "module",
 	bin: { "cmint": "./dist/bin.mjs" },
@@ -2287,30 +2287,29 @@ function resolveCommands(commands, matchedFiles) {
 /**
 * Run resolved commands for a single glob entry, appending results.
 * Function-originated commands run as-is; string commands get matched files appended.
-* Returns false if any command fails (for fail-fast signaling).
+* All commands run regardless of individual failures.
 */
-async function runCommandsForGlob(cmds, matchedFiles, timeout, results, repoRoot) {
+async function runCommandsForGlob(cmds, matchedFiles, timeout, results, repoRoot, observer) {
 	for (const { command, fromFunction } of cmds) {
 		const fullCommand = fromFunction ? command : buildCommand(command, matchedFiles);
+		const tool = extractToolName(fullCommand) ?? fullCommand.split(" ")[0];
 		debug("runCommandsForGlob: running '%s'", fullCommand);
+		observer?.onStart?.(tool, fullCommand, matchedFiles);
 		const result = await runCommand(fullCommand, timeout, repoRoot);
 		results.push({
 			...result,
 			files: matchedFiles
 		});
-		if (!result.ok) {
-			debug("runCommandsForGlob: check failed, stopping (fail-fast)");
-			return false;
-		}
+		observer?.onResult?.(result);
+		if (!result.ok) debug("runCommandsForGlob: check failed, continuing to next command");
 	}
-	return true;
 }
 /**
 * Run all user-defined checks from .cmintrc against staged files.
 * Returns a no-op result when no config exists.
-* Fail-fast: stops on first error.
+* All checks always run; failures are collected and returned together.
 */
-async function runAllChecks(repoRoot, stagedFiles, timeout) {
+async function runAllChecks(repoRoot, stagedFiles, timeout, observer) {
 	debug("runAllChecks: %d staged files, checking for config in %s", stagedFiles.length, repoRoot);
 	if (!await detectConfig(repoRoot)) {
 		debug("runAllChecks: no config found, skipping checks");
@@ -2329,10 +2328,7 @@ async function runAllChecks(repoRoot, stagedFiles, timeout) {
 			continue;
 		}
 		debug("runAllChecks: pattern '%s' matched %d files", glob, matchedFiles.length);
-		if (!await runCommandsForGlob(resolveCommands(commands, matchedFiles), matchedFiles, timeout, results, repoRoot)) return {
-			ok: false,
-			results
-		};
+		await runCommandsForGlob(resolveCommands(commands, matchedFiles), matchedFiles, timeout, results, repoRoot, observer);
 	}
 	const ok = results.every((r) => r.ok);
 	debug("runAllChecks: complete — ok=%s, %d results", ok, results.length);
@@ -2414,7 +2410,9 @@ function extractEslintDiagnostics(raw) {
 function extractTestFailures(raw) {
 	const failures = [];
 	const seen = /* @__PURE__ */ new Set();
-	for (const line of raw.split("\n")) {
+	const lines = raw.split("\n");
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
 		const match = TEST_FILE_FAIL.exec(line);
 		if (!match) continue;
 		const file = (match[1] ?? "").trim();
@@ -2423,13 +2421,35 @@ function extractTestFailures(raw) {
 		const key = `${file}\u0000${name}`;
 		if (seen.has(key)) continue;
 		seen.add(key);
+		const message = scanForwardForMessage(lines, i + 1, TEST_FILE_FAIL);
 		failures.push({
 			file,
-			name
+			name,
+			message
 		});
 	}
 	return failures;
 }
+/**
+* Scan forward from `startIndex` to find the first assertion error message line
+* after a FAIL header. Skips blank lines, separator dashes, stack frames,
+* subsequent FAIL lines, and vitest summary footers.
+*/
+function scanForwardForMessage(lines, startIndex, testFileFailRegex) {
+	for (let j = startIndex; j < lines.length; j++) {
+		const rawLine = lines[j];
+		const trimmed = rawLine.trim();
+		if (!trimmed) continue;
+		const stripped = trimmed.replace(/\s/g, "");
+		if (stripped.length > 5) {
+			if ((stripped.match(/[⎯\-═]/g) ?? []).length / stripped.length > .5) continue;
+		}
+		if (/^\s*[❯>]\s/.test(rawLine)) continue;
+		if (testFileFailRegex.test(trimmed)) break;
+		if (/^(Test Files|Tests)\s/.test(trimmed)) break;
+		return truncate(trimmed, MAX_SUMMARY_LINE_LENGTH);
+	}
+}
 function formatTestFailureSummary(failures, tool) {
 	const total = failures.length;
 	const visible = failures.slice(0, MAX_TEST_FAILURES);
@@ -2440,13 +2460,19 @@ function formatTestFailureSummary(failures, tool) {
 	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);
+		const entries = byFile.get(failure.file) ?? [];
+		entries.push({
+			name: failure.name,
+			message: failure.message
+		});
+		byFile.set(failure.file, entries);
 	}
-	for (const [file, names] of byFile) {
+	for (const [file, entries] of byFile) {
 		lines.push(`    ${truncate(file, MAX_SUMMARY_LINE_LENGTH)}`);
-		for (const name of names) lines.push(`      ${red("×")} ${truncate(name, MAX_SUMMARY_LINE_LENGTH)}`);
+		for (const entry of entries) {
+			lines.push(`      ${red("×")} ${truncate(entry.name, MAX_SUMMARY_LINE_LENGTH)}`);
+			if (entry.message) lines.push(`        ${dim("→")} ${entry.message}`);
+		}
 	}
 	if (hidden > 0) lines.push(dim(`    +${hidden} more failed ${hidden === 1 ? "test" : "tests"}. View full output for details.`));
 	return lines.join("\n");
@@ -2468,6 +2494,21 @@ function truncate(message, maxLength) {
 	if (collapsed.length <= maxLength) return collapsed;
 	return `${collapsed.slice(0, Math.max(0, maxLength - 1))}…`;
 }
+/**
+* Filter noisy lines from vitest/jest test output.
+* Strips stack trace frames (❯ prefix) and horizontal rule separators (⎯⎯⎯ lines),
+* while preserving FAIL lines, assertion messages, diff content, and the final summary.
+*/
+function filterTestOutput(output) {
+	return output.split("\n").filter((line) => {
+		if (/^\s*[❯>]\s/.test(line)) return false;
+		const stripped = line.replace(/\s/g, "");
+		if (stripped.length > 10) {
+			if ((stripped.match(/[⎯\-═]/g) ?? []).length / stripped.length > .5) return false;
+		}
+		return true;
+	}).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
 async function showCheckFailureMenu(errors, rawStderr, onRetry) {
 	debug("showCheckFailureMenu: %d errors", errors.length);
 	let clipboardCopied = false;
@@ -2507,13 +2548,13 @@ async function showCheckFailureMenu(errors, rawStderr, onRetry) {
 		debug("showCheckFailureMenu: user chose %s", choice);
 		switch (choice) {
 			case "copy":
-				if (await copyToClipboard(rawStderr)) {
+				if (await copyToClipboard(filterTestOutput(rawStderr))) {
 					clipboardCopied = true;
 					p$1.log.step(green("Copied to clipboard."));
 				} else p$1.log.warn(red("No clipboard tool found. Install xclip, wl-copy, or xsel."));
 				continue;
 			case "view":
-				p$1.note(rawStderr.trim() || "(no raw output)", "Full error output");
+				p$1.note(filterTestOutput(rawStderr) || "(no raw output)", "Full error output");
 				continue;
 			case "retry":
 				if (onRetry) return "retried";
@@ -2528,24 +2569,42 @@ async function showCheckFailureMenu(errors, rawStderr, onRetry) {
 	}
 }
 //#endregion
-//#region src/ui/check-summary.ts
+//#region src/ui/check-progress.ts
 /**
-* Stop a check spinner with a per-tool summary of the check results.
+* Creates a live check progress display.
 *
-* - On success: stops with "All checks passed" and prints a `✓ tool` line
-*   for each result.
-* - On failure: stops with "N checks failed" (pluralized). Raw error output
-*   is intentionally NOT printed here — callers handle failure display
-*   (menu, raw print, etc.).
+* - Each check gets its own line. While a check runs, a spinner animates
+*   in the status position. When it completes, the spinner becomes a ✓ or ✗.
+* - There is no separate "Running checks…" header — the spinner IS the
+*   check line.
+* - When all checks finish, a `log.info` summary line is emitted.
+*
+* Returns a `CheckObserver` (pass directly to `runAllChecks`) plus a `finish()`
+* method that prints the final summary.
 */
-function stopCheckSpinner(spinner, results) {
-	if (results.ok) {
-		spinner.stop("All checks passed");
-		if (results.results.length > 0) log.info(results.results.map((r) => `  ${green("✓")} ${r.tool}`).join("\n"));
-	} else {
-		const failed = results.results.filter((r) => !r.ok);
-		spinner.stop(`${failed.length} check${failed.length !== 1 ? "s" : ""} failed`);
-	}
+function createCheckProgressDisplay() {
+	const s = spinner();
+	const toolResults = [];
+	let started = false;
+	return {
+		onStart(_tool, _command, _matchedFiles) {
+			if (!started) {
+				s.start(_tool);
+				started = true;
+			} else s.message(_tool);
+		},
+		onResult(result) {
+			toolResults.push({
+				tool: result.tool,
+				ok: result.ok
+			});
+			s.message(`${result.ok ? "✓" : "✗"} ${result.tool}`);
+		},
+		finish(ok) {
+			s.stop(ok ? green("All checks passed") : red("Some checks failed"));
+			if (toolResults.length > 0) log.info(toolResults.map((r) => `  ${r.ok ? green("✓") : red("✗")} ${r.tool}`).join("\n"));
+		}
+	};
 }
 //#endregion
 //#region src/commands/check-phase.ts
@@ -2554,7 +2613,7 @@ function stopCheckSpinner(spinner, results) {
 *
 * Single entry point for the check-execution pipeline shared by `runPreCommitChecks`
 * (post-staging, normal commit flow) and `runAutoGroupFlow` (pre-staging, auto-group
-* flow). Encapsulates: detectConfig guard → spinner → runAllChecks → retry loop with
+* flow). Encapsulates: detectConfig guard → live progress display → runAllChecks → retry loop with
 * `showCheckFailureMenu`.
 *
 * Caller responsibilities:
@@ -2570,10 +2629,9 @@ function stopCheckSpinner(spinner, results) {
 async function runCheckPhaseInteractive(repoRoot, files, timeout, onRetry) {
 	if (!await detectConfig(repoRoot)) return "passed";
 	debug("Running user checks on %d files...", files.length);
-	const ck = spinner();
-	ck.start("Running checks...");
-	let checkResults = await runAllChecks(repoRoot, files, timeout);
-	stopCheckSpinner(ck, checkResults);
+	const display = createCheckProgressDisplay();
+	let checkResults = await runAllChecks(repoRoot, files, timeout, display);
+	display.finish(checkResults.ok);
 	debug("Check results: ok=%s, count=%d", checkResults.ok, checkResults.results.length);
 	while (!checkResults.ok) {
 		const rawOutput = checkResults.results.filter((r) => !r.ok).map((r) => `[${r.tool}]\n${r.stdout}\n${r.stderr}`.trim()).join("\n\n");
@@ -2584,9 +2642,9 @@ async function runCheckPhaseInteractive(repoRoot, files, timeout, onRetry) {
 		if (menuResult === "retried") {
 			debug("Re-running checks after retry...");
 			if (onRetry) await onRetry();
-			ck.start("Running checks...");
-			checkResults = await runAllChecks(repoRoot, files, timeout);
-			stopCheckSpinner(ck, checkResults);
+			const retryDisplay = createCheckProgressDisplay();
+			checkResults = await runAllChecks(repoRoot, files, timeout, retryDisplay);
+			retryDisplay.finish(checkResults.ok);
 			debug("Retry check results: ok=%s, count=%d", checkResults.ok, checkResults.results.length);
 			continue;
 		}
@@ -3570,6 +3628,52 @@ let m = class {
 		}
 	}
 };
+let nt = class extends m {
+	options;
+	cursor = 0;
+	get _value() {
+		return this.options[this.cursor].value;
+	}
+	get _enabledOptions() {
+		return this.options.filter((t) => t.disabled !== !0);
+	}
+	toggleAll() {
+		const t = this._enabledOptions, s = this.value !== void 0 && this.value.length === t.length;
+		this.value = s ? [] : t.map((e) => e.value);
+	}
+	toggleInvert() {
+		const t = this.value;
+		if (!t) return;
+		const s = this._enabledOptions.filter((e) => !t.includes(e.value));
+		this.value = s.map((e) => e.value);
+	}
+	toggleValue() {
+		this.value === void 0 && (this.value = []);
+		const t = this.value.includes(this._value);
+		this.value = t ? this.value.filter((s) => s !== this._value) : [...this.value, this._value];
+	}
+	constructor(t) {
+		super(t, !1), this.options = t.options, this.value = [...t.initialValues ?? []];
+		const s = Math.max(this.options.findIndex(({ value: e }) => e === t.cursorAt), 0);
+		this.cursor = this.options[s].disabled ? f(s, 1, this.options) : s, this.on("key", (e) => {
+			e === "a" && this.toggleAll(), e === "i" && this.toggleInvert();
+		}), this.on("cursor", (e) => {
+			switch (e) {
+				case "left":
+				case "up":
+					this.cursor = f(this.cursor, -1, this.options);
+					break;
+				case "down":
+				case "right":
+					this.cursor = f(this.cursor, 1, this.options);
+					break;
+				case "space":
+					this.toggleValue();
+					break;
+			}
+		});
+	}
+};
 var ut = class extends m {
 	options;
 	cursor = 0;
@@ -3598,6 +3702,86 @@ var ut = class extends m {
 	}
 };
 //#endregion
+//#region src/ui/file-multiselect.ts
+/**
+* Render a checkbox-style option line with 4 visual states:
+*   active-selected, selected, active, inactive
+*/
+function renderCheckboxOption(label, selected, active) {
+	if (selected && active) return `${green(S_CHECKBOX_SELECTED)} ${label}`;
+	if (selected) return `${dim(S_CHECKBOX_SELECTED)} ${dim(label)}`;
+	if (active) return `${green(S_CHECKBOX_ACTIVE)} ${label}`;
+	return `${dim(S_CHECKBOX_INACTIVE)} ${dim(label)}`;
+}
+/**
+* Build the render function for a MultiSelectPrompt with file-multiselect
+* styling and a hotkey hint line at the bottom.
+*/
+function buildMultiSelectRender(message, options, output) {
+	return function() {
+		const header = `${symbol(this.state)}  ${message}`;
+		const value = this.value ?? [];
+		const cursor = this.cursor;
+		switch (this.state) {
+			case "submit": {
+				const labels = value.map((v) => {
+					return options.find((o) => o.value === v)?.label ?? String(v);
+				}).join(dim(", "));
+				return `${header}\n${dim(S_BAR)}  ${dim(labels)}`;
+			}
+			case "cancel": {
+				const cancelled = styleText(["strikethrough", "dim"], "Cancelled");
+				return `${header}\n${dim(S_BAR_END)}  ${cancelled}`;
+			}
+			default: {
+				const lines = limitOptions({
+					cursor,
+					options,
+					style: (opt, active) => renderCheckboxOption(opt.label, value.includes(opt.value), active),
+					maxItems: 7,
+					output: output ?? process.stdout
+				}).map((line) => `${dim(S_BAR)}  ${line}`);
+				const hintLine = "↑/↓ navigate · space select · enter confirm · A select all · N select none";
+				return [
+					header,
+					...lines,
+					`${dim(S_BAR_END)}  ${dim(hintLine)}`
+				].join("\n");
+			}
+		}
+	};
+}
+/**
+* Multi-select prompt with extended hotkeys for file selection.
+*
+* Built-in (from `@clack/core`'s `MultiSelectPrompt`):
+*   `a` — toggle all (select all / deselect all)
+*   `i` — invert selection
+*
+* Extended hotkeys:
+*   `A` (shift+A) — select all unconditionally
+*   `N` — select none (deselect all)
+*/
+async function fileMultiSelect(message, options, opts) {
+	const required = opts?.required ?? true;
+	const prompt = new nt({
+		options,
+		required,
+		input: opts?.input,
+		output: opts?.output,
+		validate: (values) => {
+			if (required && (!values || values.length === 0)) return "Please select at least one option.";
+		},
+		render: buildMultiSelectRender(message, options, opts?.output)
+	});
+	prompt.on("key", (char, key) => {
+		if (!char) return;
+		if (char === "a" && key?.shift) prompt.value = options.map((o) => o.value);
+		if (char === "n") prompt.value = [];
+	});
+	return await prompt.prompt();
+}
+//#endregion
 //#region src/ui/toggle-select.ts
 const ON_LABEL = styleText("green", "ON");
 const OFF_LABEL = styleText("dim", "OFF");
@@ -3665,8 +3849,8 @@ function buildPromptRenderer(opts, state) {
 	const toggleList = opts.toggles;
 	return function() {
 		const sym = symbol(this.state);
-		const statusLines = toggleList.map((t) => renderToggleState(t, state[t.hotkey])).join("\n");
-		const header = `${sym}  ${opts.message}\n${dim(S_BAR)}  ${statusLines}`;
+		const statusLines = toggleList.map((t) => `${dim(S_BAR)}  ${renderToggleState(t, state[t.hotkey])}`).join("\n");
+		const header = `${sym}  ${opts.message}\n${statusLines}`;
 		switch (this.state) {
 			case "submit": {
 				const selected = optionList[this.cursor];
@@ -3795,14 +3979,10 @@ async function showStagingMenu(files, hasChecks) {
 		files: files.map((f) => f.path),
 		all: true
 	};
-	const selected = await p$1.multiselect({
-		message: "Select files to stage:",
-		options: sorted.map((f) => ({
-			label: `${statusLabel(f.status)}  ${f.path}`,
-			value: f.path
-		})),
-		required: true
-	});
+	const selected = await fileMultiSelect("Select files to stage:", sorted.map((f) => ({
+		label: `${statusLabel(f.status)}  ${f.path}`,
+		value: f.path
+	})), { required: true });
 	if (p$1.isCancel(selected)) return null;
 	return {
 		files: selected,
@@ -3835,10 +4015,9 @@ async function handleStaging(changedFiles, flags) {
 			await stageAll();
 			const allFiles = await getStagedFiles();
 			if (await detectConfig(repoRoot)) {
-				const ckSpinner = spinner();
-				ckSpinner.start("Running checks...");
-				const ckResult = await runAllChecks(repoRoot, allFiles, 6e4);
-				stopCheckSpinner(ckSpinner, ckResult);
+				const display = createCheckProgressDisplay();
+				const ckResult = await runAllChecks(repoRoot, allFiles, 6e4, display);
+				display.finish(ckResult.ok);
 				if (!ckResult.ok) for (const r of ckResult.results.filter((r) => !r.ok)) log.info(r.stderr?.trim() || r.stdout?.trim() || `Check failed: ${r.command}`);
 			}
 			currentFiles = await getChangedFiles();