@kyubiware/commit-mint 0.8.4 → 0.9.0

package/README.md

@@ -107,17 +107,27 @@ each with its own message. The flow:
    — the remaining groups are not committed.
 
 `cmint` (no `-a`) shows a staging menu for any number of changed files
-(including one). The menu is also the only place the `a` hotkey toggles
-auto-accept mode, so it always runs:
+(including one). The menu is also the only place the `a` and `c` hotkeys
+toggle persistent modes, so it always runs:
 
 ```
-What do you want to stage?
-  Stage all files
-  Select files...
-  Auto-group into commits
-  Run checks
+Stage files for commit:
+  ⚡ Auto-accept: OFF (press `a` to toggle)
+  🛡 Pre-commit checks: ON (press `c` to toggle)
+
+  ● Stage all files
+  ○ Auto-group into commits
+  ○ Run checks
+  ...
 ```
 
+- **`a` — Auto-accept** — skip the message review step. Persisted in
+  `~/.commit-mint` as `auto-accept`.
+- **`c` — Pre-commit checks** — when OFF, skip the user-defined pre-commit
+  checks (the `.cmintrc` phase). Persisted in `~/.commit-mint` as
+  `run-checks` (default `true`/ON). Same effect as `cmint -N`, but persists
+  across runs. Only shown when a `.cmintrc` file exists.
+
 ## Self-update (`cmint update`)
 
 `cmint update` checks the npm registry for a newer version and, if one exists,
@@ -228,6 +238,8 @@ and **eslint**. Unrecognized output falls back to a single raw-stderr entry.
 | `type`           | —                    | Force commit type prefix                          |
 | `timeout`        | `10000`              | AI request timeout in ms                          |
 | `proxy`          | —                    | Proxy URL for API requests                        |
+| `auto-accept`    | `false`              | `a` hotkey: skip message review step              |
+| `run-checks`     | `true`               | `c` hotkey: run user-defined pre-commit checks    |
 | `--agent`       | `false`              | Headless JSON-output mode for AI agents           |
 
 API key lookup checks the env var first, then the INI file.

package/dist/cli.mjs

@@ -33,7 +33,7 @@ var __exportAll = (all, no_symbols) => {
 //#region package.json
 var package_default = {
 	name: "@kyubiware/commit-mint",
-	version: "0.8.4",
+	version: "0.9.0",
 	description: "🌿 AI-powered git commit tool — auto-group changed files, generate messages, run pre-commit checks",
 	type: "module",
 	bin: { "cmint": "./dist/cli.mjs" },
@@ -1662,6 +1662,42 @@ async function setAutoAccept(enabled) {
 	await writeConfig({ "auto-accept": value });
 }
 //#endregion
+//#region src/services/run-checks.ts
+/**
+* Parse a stored `run-checks` INI value into a boolean.
+*
+* Polarity is positive: `true` means "run user-defined pre-commit checks"
+* (the default behavior), `false` means "skip them".
+*
+* Accepts true variants ("true", "1", "yes" — case-insensitive) and boolean
+* values from ini.parse (which converts unquoted `true`/`false` to actual
+* booleans). Returns **true** for undefined / empty / unknown values so the
+* default behavior is to run checks — a fresh install with no INI key must
+* behave identically to `run-checks = true`.
+*/
+function parseRunChecksValue(value) {
+	if (typeof value === "boolean") return value;
+	if (typeof value !== "string" || !value) return true;
+	return ![
+		"false",
+		"0",
+		"no"
+	].includes(value.toLowerCase());
+}
+/** Read the persisted run-checks preference from `~/.commit-mint`. Defaults to true. */
+async function getRunChecks() {
+	const raw = (await readConfig())["run-checks"];
+	const enabled = parseRunChecksValue(raw);
+	debug("getRunChecks: raw=%s enabled=%s", raw, enabled);
+	return enabled;
+}
+/** Persist the run-checks preference to `~/.commit-mint`. */
+async function setRunChecks(enabled) {
+	const value = enabled ? "true" : "false";
+	debug("setRunChecks: %s", value);
+	await writeConfig({ "run-checks": value });
+}
+//#endregion
 //#region src/ui/grouping.ts
 async function showGroupingConfirmation(groups, excluded) {
 	debug("showGroupingConfirmation: %d groups, %d excluded", groups.length, excluded.length);
@@ -1728,7 +1764,9 @@ function showGroupedFiles(groups, changedFiles) {
 /** Milliseconds to wait after stdin closes for quick exit failures. */
 const GRACE_PERIOD_MS = 150;
 async function copyToClipboard(content) {
+	debug("clipboard: copying %d bytes", content.length);
 	for (const [cmd, args] of [
+		["wl-copy", ["--foreground"]],
 		["wl-copy", []],
 		["xclip", ["-selection", "clipboard"]],
 		["xsel", ["--clipboard", "--input"]],
@@ -2258,7 +2296,7 @@ async function runAutoGroupFlow(changedFiles, flags) {
 		else outro(dim("Nothing to commit."));
 		return "committed";
 	}
-	if (!flags.noCheck) {
+	if (!flags.noCheck && await getRunChecks()) {
 		const { getRepoRoot } = await Promise.resolve().then(() => git_exports);
 		if (await runCheckPhaseInteractive(await getRepoRoot(), await resolveToRepoRoot(included.filter((f) => f.status !== "D").map((f) => f.path)), 6e4) === "cancelled") return "cancelled";
 	}
@@ -3793,13 +3831,13 @@ var ut = class extends m {
 	}
 };
 //#endregion
-//#region src/ui/auto-accept-select.ts
+//#region src/ui/toggle-select.ts
 const ON_LABEL = styleText("green", "ON");
 const OFF_LABEL = styleText("dim", "OFF");
-const HOTKEY_HINT = dim("(press `a` to toggle)");
-function renderStatus(autoAccept) {
-	const label = autoAccept ? ON_LABEL : OFF_LABEL;
-	return `${dim("⚡ Auto-accept:")} ${label} ${HOTKEY_HINT}`;
+function renderToggleState(t, state) {
+	const label = state ? ON_LABEL : OFF_LABEL;
+	const hint = dim(`(press \`${t.hotkey}\` to toggle)`);
+	return `${dim(`${t.icon} ${t.label}:`)} ${label} ${hint}`;
 }
 /** Render a single select option line. */
 function renderOption(opt, active) {
@@ -3812,68 +3850,91 @@ function renderOption(opt, active) {
 	return `${dim(S_RADIO_INACTIVE)} ${dim(text)}`;
 }
 /**
-* Select prompt with an inline `a`-hotkey toggle for auto-accept mode.
+* Select prompt with inline hotkey toggles.
 *
-* Renders a normal select list plus a status line showing the current
-* auto-accept state. Pressing `a` flips the state in-place (the menu
-* re-renders) and fires `onToggle` so callers can persist the change.
+* Renders a normal select list plus one status line per toggle. Pressing a
+* toggle's hotkey flips its state in-place (the prompt re-renders) and fires
+* its `onToggle` callback so callers can persist the change.
 *
-* Returns `{ value, autoAccept }` on submit, or the clack cancel symbol
-* on cancel.
+* Returns `{ value, toggles }` on submit, or the clack cancel symbol on
+* cancel. `toggles` is a map of `ToggleOption.key -> final boolean state`.
 */
-async function selectWithAutoAccept(opts) {
-	let autoAccept = opts.initialAutoAccept;
+async function selectWithToggles(opts) {
+	const state = {};
+	for (const t of opts.toggles) state[t.hotkey] = t.initial;
 	const prompt = new ut({
 		options: opts.options,
 		input: opts.input,
 		output: opts.output,
-		render() {
-			const sym = symbol(this.state);
-			const statusLine = renderStatus(autoAccept);
-			const header = `${sym}  ${opts.message}\n${dim(S_BAR)}  ${statusLine}`;
-			switch (this.state) {
-				case "submit": {
-					const selected = this.options[this.cursor];
-					const text = selected.label ?? String(selected.value);
-					return `${header}\n${dim(S_BAR)}  ${dim(text)}`;
-				}
-				case "cancel": {
-					const selected = this.options[this.cursor];
-					const text = selected.label ?? String(selected.value);
-					return `${header}\n${dim(S_BAR)}  ${styleText(["strikethrough", "dim"], text)}\n${dim(S_BAR_END)}`;
-				}
-				default: return [
-					header,
-					...limitOptions({
-						cursor: this.cursor,
-						options: this.options,
-						style: (opt, active) => renderOption(opt, active),
-						maxItems: 7,
-						output: opts.output ?? process.stdout
-					}).map((line) => `${dim(S_BAR)}  ${line}`),
-					`${dim(S_BAR_END)}  ${dim("↑/↓ navigate • Enter confirm • `a` toggle auto-accept")}`
-				].join("\n");
-			}
-		}
+		render: buildPromptRenderer(opts, state)
 	});
 	prompt.on("key", async (char) => {
-		if (char === "a") {
-			autoAccept = !autoAccept;
-			debug("auto-accept toggled to %s", autoAccept);
-			try {
-				await opts.onToggle?.(autoAccept);
-			} catch (err) {
-				debug("onToggle threw (ignored): %s", err instanceof Error ? err.message : String(err));
-			}
+		const toggle = opts.toggles.find((t) => t.hotkey === char);
+		if (!toggle) return;
+		state[toggle.hotkey] = !state[toggle.hotkey];
+		debug("%s toggled to %s", toggle.label, state[toggle.hotkey]);
+		try {
+			await toggle.onToggle?.(state[toggle.hotkey]);
+		} catch (err) {
+			debug("onToggle threw (ignored): %s", err instanceof Error ? err.message : String(err));
 		}
 	});
 	const result = await prompt.prompt();
 	if (q(result)) return result;
 	return {
 		value: result,
-		autoAccept
+		toggles: buildTogglesMap(opts, state)
+	};
+}
+/**
+* Build a render callback for the SelectPrompt.
+*
+* Closed over `opts` (the toggle-select options) and `state` (the mutable
+* hotkey → boolean map) so the inline render function can access toggle
+* state without encoding it in `this`.
+*/
+function buildPromptRenderer(opts, state) {
+	const optionList = opts.options;
+	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}`;
+		switch (this.state) {
+			case "submit": {
+				const selected = optionList[this.cursor];
+				const text = selected.label ?? String(selected.value);
+				return `${header}\n${dim(S_BAR)}  ${dim(text)}`;
+			}
+			case "cancel": {
+				const selected = optionList[this.cursor];
+				const text = selected.label ?? String(selected.value);
+				return `${header}\n${dim(S_BAR)}  ${styleText(["strikethrough", "dim"], text)}\n${dim(S_BAR_END)}`;
+			}
+			default: {
+				const lines = limitOptions({
+					cursor: this.cursor,
+					options: optionList,
+					style: (opt, active) => renderOption(opt, active),
+					maxItems: 7,
+					output: opts.output ?? process.stdout
+				}).map((line) => `${dim(S_BAR)}  ${line}`);
+				const hotkeysHint = toggleList.map((t) => `\`${t.hotkey}\` toggle ${t.label.toLowerCase()}`).join(" • ");
+				return [
+					header,
+					...lines,
+					`${dim(S_BAR_END)}  ${dim(`↑/↓ navigate • Enter confirm • ${hotkeysHint}`)}`
+				].join("\n");
+			}
+		}
 	};
 }
+/** Collate the final toggle states keyed by `ToggleOption.key`. */
+function buildTogglesMap(opts, state) {
+	const togglesByKey = {};
+	for (const t of opts.toggles) togglesByKey[t.key] = state[t.hotkey];
+	return togglesByKey;
+}
 //#endregion
 //#region src/ui/staging-menu.ts
 async function showStagingMenu(files, hasChecks) {
@@ -3903,12 +3964,25 @@ async function showStagingMenu(files, hasChecks) {
 	p$1.note(lines.join("\n"), `${files.length} file${files.length !== 1 ? "s" : ""}`);
 	const initialAutoAccept = await getAutoAccept();
 	debug("showStagingMenu: initial auto-accept=%s", initialAutoAccept);
-	const selectResult = await selectWithAutoAccept({
+	const initialRunChecks = hasChecks ? await getRunChecks() : true;
+	debug("showStagingMenu: initial run-checks=%s", initialRunChecks);
+	const selectResult = await selectWithToggles({
 		message: "Stage files for commit:",
-		initialAutoAccept,
-		onToggle: async (next) => {
-			await setAutoAccept(next);
-		},
+		toggles: [{
+			key: "autoAccept",
+			hotkey: "a",
+			label: "Auto-accept",
+			icon: "⚡",
+			initial: initialAutoAccept,
+			onToggle: (next) => setAutoAccept(next)
+		}, ...hasChecks ? [{
+			key: "runChecks",
+			hotkey: "c",
+			label: "Pre-commit checks",
+			icon: "🛡",
+			initial: initialRunChecks,
+			onToggle: (next) => setRunChecks(next)
+		}] : []],
 		options: [
 			...files.length > 1 ? [{
 				label: "Auto-group into commits",
@@ -3945,7 +4019,7 @@ async function showStagingMenu(files, hasChecks) {
 		return null;
 	}
 	const choice = selectResult.value;
-	debug("showStagingMenu: choice=%s autoAccept=%s", choice, selectResult.autoAccept);
+	debug("showStagingMenu: choice=%s autoAccept=%s runChecks=%s", choice, selectResult.toggles.autoAccept, selectResult.toggles.runChecks);
 	if (p$1.isCancel(choice) || choice === "cancel") return null;
 	if (choice === "autogroup") return "autogroup";
 	if (choice === "checks") return "checks";
@@ -4073,7 +4147,10 @@ async function commitCommand(flags, version) {
 	debug("Changed files:", changedFiles.length);
 	const s = spinner();
 	try {
-		if (flags.auto) {
+		if (flags.single) {
+			debug("Single-commit mode: staging all files");
+			await stageAll();
+		} else if (flags.auto) {
 			if (flags.message) {
 				outro(red("--message flag is not compatible with auto-group mode."));
 				return;
@@ -4093,7 +4170,7 @@ async function commitCommand(flags, version) {
 		process.exit(1);
 	}
 	changedFiles = await getChangedFiles();
-	await runPreCommitChecks(changedFiles, flags.noCheck);
+	if (!flags.noCheck && await getRunChecks()) await runPreCommitChecks(changedFiles, false);
 	const diffResult = await getStagedDiff();
 	if (!diffResult) {
 		debug("No staged changes found after staging");
@@ -4157,7 +4234,7 @@ async function commitCommand(flags, version) {
 		}
 		s.stop("Message generated");
 	}
-	if (await getAutoAccept()) {
+	if (flags.single || await getAutoAccept()) {
 		debug("Auto-accept ON: skipping review step");
 		log.info(message);
 	} else {
@@ -4629,6 +4706,12 @@ cli({
 			type: Boolean,
 			description: "AI agent mode: non-interactive auto-group with JSON output",
 			default: false
+		},
+		single: {
+			type: Boolean,
+			description: "Stage all files as a single commit with AI message (non-interactive)",
+			alias: "s",
+			default: false
 		}
 	},
 	commands: [