@kyubiware/commit-mint 0.4.2 → 0.5.1

package/dist/cli.mjs

@@ -1,16 +1,18 @@
 #!/usr/bin/env node
 import { cli, command } from "cleye";
 import * as p from "@clack/prompts";
-import { intro, isCancel, log, note, outro, select, spinner } from "@clack/prompts";
+import { intro, isCancel, log, outro, spinner } from "@clack/prompts";
 import { bold, cyan, dim, green, red, yellow } from "kolorist";
 import { access, constants, mkdir, readFile, writeFile } from "node:fs/promises";
 import os from "node:os";
-import { join } from "node:path";
+import { extname, join } from "node:path";
 import ini from "ini";
-import { execa } from "execa";
-import { spawn } from "node:child_process";
 import Groq from "groq-sdk";
+import { execa } from "execa";
 import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import picomatch from "picomatch";
+import { spawn } from "node:child_process";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
@@ -26,8 +28,8 @@ var __exportAll = (all, no_symbols) => {
 //#region package.json
 var package_default = {
 	name: "@kyubiware/commit-mint",
-	version: "0.4.2",
-	description: "A commit tool that actually handles hook failures",
+	version: "0.5.1",
+	description: "🌿 A commit tool that actually handles hook failures",
 	type: "module",
 	bin: { "cmint": "./dist/cli.mjs" },
 	files: ["dist"],
@@ -45,16 +47,13 @@ var package_default = {
 		"release:patch": "bash scripts/release.sh patch",
 		"release:minor": "bash scripts/release.sh minor",
 		"release:major": "bash scripts/release.sh major",
-		"prepublishOnly": "npm run build",
-		"prepare": "simple-git-hooks"
+		"prepublishOnly": "npm run build"
 	},
-	"simple-git-hooks": { "pre-commit": "npx lint-staged" },
 	keywords: [
 		"git",
 		"commit",
 		"hooks",
 		"pre-commit",
-		"lint-staged",
 		"ai",
 		"groq",
 		"conventional-commits",
@@ -72,14 +71,14 @@ var package_default = {
 		"execa": "^9.6.0",
 		"groq-sdk": "^0.32.0",
 		"ini": "^5.0.0",
-		"kolorist": "^1.8.0"
+		"jiti": "^2.7.0",
+		"kolorist": "^1.8.0",
+		"picomatch": "^4.0.4"
 	},
 	devDependencies: {
 		"@biomejs/biome": "^2.0.0",
 		"@types/ini": "^4.1.1",
 		"@vitest/coverage-v8": "^3.2.4",
-		"lint-staged": "^17.0.5",
-		"simple-git-hooks": "^2.13.1",
 		"tsdown": "^0.22.0",
 		"tsx": "^4.22.2",
 		"typescript": "^5.9.2",
@@ -98,9 +97,52 @@ function debug(...args) {
 	console.error(dim(`[debug ${timestamp}]`), ...args);
 }
 //#endregion
+//#region src/services/provider.ts
+const PROVIDER_CONFIGS = {
+	groq: {
+		baseURL: "https://api.groq.com",
+		defaultModel: "openai/gpt-oss-20b"
+	},
+	cerebras: {
+		baseURL: "https://api.cerebras.ai",
+		defaultModel: "gpt-oss-120b"
+	},
+	mistral: {
+		baseURL: "https://api.mistral.ai",
+		defaultModel: "mistral-small"
+	}
+};
+const ALLOWED_PROVIDERS = Object.keys(PROVIDER_CONFIGS);
+const PROVIDER_ENV_KEYS = {
+	groq: "GROQ_API_KEY",
+	cerebras: "CEREBRAS_API_KEY",
+	mistral: "MISTRAL_API_KEY"
+};
+function formatProviderName(provider) {
+	return provider.charAt(0).toUpperCase() + provider.slice(1);
+}
+function isValidProvider(name) {
+	return ALLOWED_PROVIDERS.includes(name);
+}
+function createProvider(options) {
+	if (!isValidProvider(options.provider)) throw new Error(`Invalid provider "${options.provider}". Allowed values: ${ALLOWED_PROVIDERS.join(", ")}`);
+	const providerConfig = PROVIDER_CONFIGS[options.provider];
+	const model = options.modelOverride ?? providerConfig.defaultModel;
+	const baseURL = options.baseURLOverride ?? providerConfig.baseURL;
+	return {
+		client: new Groq({
+			apiKey: options.apiKey,
+			baseURL,
+			timeout: options.timeout
+		}),
+		model
+	};
+}
+//#endregion
 //#region src/services/config.ts
 const CONFIG_PATH = join(os.homedir(), ".commit-mint");
 const defaults = {
+	provider: "groq",
 	model: "openai/gpt-oss-20b",
 	locale: "en",
 	"max-length": "100",
@@ -128,25 +170,29 @@ async function writeConfig(updates) {
 	Object.assign(existing, updates);
 	await writeFile(CONFIG_PATH, ini.stringify(existing), "utf8");
 }
-async function getConfigValue(key) {
-	return (await readConfig())[key];
-}
 async function setConfigValue(key, value) {
 	await writeConfig({ [key]: value });
 }
-async function getApiKey() {
-	const envKey = process.env.GROQ_API_KEY;
-	if (envKey) {
-		debug("getApiKey: found in env");
-		return envKey;
+async function getProviderApiKey(provider) {
+	const envVar = PROVIDER_ENV_KEYS[provider];
+	if (envVar) {
+		const envValue = process.env[envVar];
+		if (envValue) {
+			debug("getProviderApiKey(%s): found in env", provider);
+			return envValue;
+		}
 	}
 	const config = await readConfig();
-	if (config.GROQ_API_KEY) {
-		debug("getApiKey: found in config");
-		return config.GROQ_API_KEY;
+	const configKey = PROVIDER_ENV_KEYS[provider];
+	if (configKey && config[configKey]) {
+		debug("getProviderApiKey(%s): found in config", provider);
+		return config[configKey];
 	}
-	debug("getApiKey: not found");
-	throw new Error("Please set your Groq API key via `cmint config set GROQ_API_KEY=<your token>`");
+	debug("getProviderApiKey(%s): not found", provider);
+	throw new Error(`Please set your ${formatProviderName(provider)} API key via \`cmint config set ${envVar}=<your token>\``);
+}
+function getModelForProvider(config, provider, defaultModel) {
+	return config[`model_${provider}`] ?? config.model ?? defaultModel;
 }
 //#endregion
 //#region src/services/hooks.ts
@@ -521,195 +567,20 @@ async function attemptCommitNoVerify(message, onProgress) {
 	return attemptCommit(message, ["--no-verify"], onProgress);
 }
 //#endregion
-//#region src/services/lint-staged.ts
-const CONFIG_FILES = [
-	".lintstagedrc",
-	".lintstagedrc.json",
-	".lintstagedrc.yaml",
-	".lintstagedrc.yml",
-	".lintstagedrc.mjs",
-	".lintstagedrc.cjs",
-	"lint-staged.config.mjs",
-	"lint-staged.config.cjs",
-	"lint-staged.config.js"
-];
-async function hasLintStagedConfig(repoRoot) {
-	debug("hasLintStagedConfig: checking in %s", repoRoot);
-	for (const file of CONFIG_FILES) {
-		const path = join(repoRoot, file);
-		try {
-			await access(path, constants.F_OK);
-			debug("hasLintStagedConfig: found %s", file);
-			return true;
-		} catch {}
-	}
-	const packageJsonPath = join(repoRoot, "package.json");
-	try {
-		const raw = await readFile(packageJsonPath, "utf8");
-		if ("lint-staged" in JSON.parse(raw)) {
-			debug("hasLintStagedConfig: found lint-staged in package.json");
-			return true;
-		}
-	} catch {}
-	debug("hasLintStagedConfig: no config found");
-	return false;
-}
-async function runLintStaged() {
-	debug("runLintStaged: starting npx lint-staged");
-	const { failed, stdout, stderr } = await execa("npx", ["lint-staged"], { reject: false });
-	debug("runLintStaged: finished, failed=%s", failed);
-	return {
-		ok: !failed,
-		stdout,
-		stderr
-	};
-}
-//#endregion
-//#region src/services/clipboard.ts
-async function copyToClipboard(content) {
-	for (const [cmd, args] of [
-		["wl-copy", []],
-		["xclip", ["-selection", "clipboard"]],
-		["xsel", ["--clipboard", "--input"]],
-		["pbcopy", []]
-	]) try {
-		if (await new Promise((resolve) => {
-			const child = spawn(cmd, args, { stdio: [
-				"pipe",
-				"ignore",
-				"ignore"
-			] });
-			let settled = false;
-			const done = (result) => {
-				if (settled) return;
-				settled = true;
-				resolve(result);
-			};
-			child.on("error", () => done(false));
-			child.on("exit", (code) => {
-				if (code !== 0) done(false);
-			});
-			child.stdin.write(content, (err) => {
-				if (err) {
-					done(false);
-					return;
-				}
-				child.stdin.end(() => {
-					child.unref();
-					done(true);
-				});
-			});
-		})) return true;
-	} catch {}
-	return false;
-}
-//#endregion
-//#region src/ui/menu.ts
-async function showStagingMenu(files, hasLintStaged) {
-	debug("showStagingMenu: %d files", files.length);
-	const statusLabel = (status) => {
-		switch (status) {
-			case "M": return yellow("M");
-			case "A": return green("A");
-			case "D": return red("D");
-			case "?":
-			case "??": return cyan("?");
-			default: return dim(status);
-		}
-	};
-	const sorted = [...files].sort((a, b) => {
-		if (a.staged !== b.staged) return a.staged ? -1 : 1;
-		return a.path.localeCompare(b.path);
-	});
-	const stagedFiles = sorted.filter((f) => f.staged);
-	const unstagedFiles = sorted.filter((f) => !f.staged);
-	const lines = [];
-	if (stagedFiles.length > 0) lines.push(green(bold("Staged:")), ...stagedFiles.map((f) => `  ${statusLabel(f.status)}  ${f.path}`));
-	if (unstagedFiles.length > 0) {
-		if (lines.length > 0) lines.push("");
-		lines.push(yellow(bold("Changed:")), ...unstagedFiles.map((f) => `  ${statusLabel(f.status)}  ${f.path}`));
-	}
-	p.note(lines.join("\n"), `${files.length} file${files.length !== 1 ? "s" : ""}`);
-	const choice = await p.select({
-		message: "Stage files for commit:",
-		options: [
-			{
-				label: "Auto-group into commits",
-				value: "autogroup",
-				hint: "LLM groups files into logical commits"
-			},
-			{
-				label: "Stage all files",
-				value: "all",
-				hint: `${files.length} file${files.length !== 1 ? "s" : ""}`
-			},
-			...hasLintStaged ? [{
-				label: "Run lint-staged checks",
-				value: "lint-staged",
-				hint: "Pre-flight checks on all changed files"
-			}] : [],
-			{
-				label: "Select files...",
-				value: "select"
-			},
-			{
-				label: "Cancel",
-				value: "cancel"
-			}
-		]
-	});
-	if (p.isCancel(choice) || choice === "cancel") return null;
-	if (choice === "autogroup") return "autogroup";
-	if (choice === "lint-staged") return "lint-staged";
-	if (choice === "all") return {
-		files: files.map((f) => f.path),
-		all: true
-	};
-	const selected = await p.multiselect({
-		message: "Select files to stage:",
-		options: sorted.map((f) => ({
-			label: `${statusLabel(f.status)}  ${f.path}`,
-			value: f.path
-		})),
-		required: true
-	});
-	if (p.isCancel(selected)) return null;
-	return {
-		files: selected,
-		all: false
-	};
-}
-async function showRecoveryMenu(errors, onRetry, onSkipHooks, onRestage, message, rawStderr) {
-	debug("showRecoveryMenu: %d errors", errors.length);
-	let clipboardCopied = false;
-	let showNote = true;
+//#region src/ui/review-message.ts
+async function reviewCommitMessage(message) {
+	const { select, text } = await import("@clack/prompts");
 	while (true) {
-		if (showNote) {
-			p.note(errors.map((e) => `  ${red("•")} [${e.tool}] ${e.message}`).join("\n"), red(bold("Pre-commit hook failed")));
-			showNote = false;
-		}
-		const choice = await p.select({
-			message: "What do you want to do?",
+		const review = await select({
+			message: `Review commit message:\n\n   ${bold(message)}\n`,
 			options: [
 				{
-					label: clipboardCopied ? `${green("✓")} Copy error report to clipboard` : "Copy error report to clipboard",
-					value: "clipboard",
-					hint: clipboardCopied ? "Copied!" : "Paste into another terminal for an AI agent"
-				},
-				{
-					label: "Skip hooks and commit (--no-verify)",
-					value: "skip",
-					hint: "Commit anyway, fix later"
-				},
-				{
-					label: "Re-stage files and retry",
-					value: "restage",
-					hint: "Pick up fixes from another terminal"
+					label: "Use as-is",
+					value: "use"
 				},
 				{
-					label: "Edit commit message",
-					value: "edit",
-					hint: "Modify the message before retrying"
+					label: "Edit",
+					value: "edit"
 				},
 				{
 					label: "Cancel",
@@ -717,73 +588,74 @@ async function showRecoveryMenu(errors, onRetry, onSkipHooks, onRestage, message
 				}
 			]
 		});
-		if (p.isCancel(choice)) {
-			debug("showRecoveryMenu: user cancelled");
-			p.outro(yellow("Cancelled. Message cached for --retry."));
-			return "cancelled";
+		if (isCancel(review) || review === "cancel") {
+			debug("User cancelled at review step");
+			return null;
 		}
-		debug("showRecoveryMenu: user chose %s", choice);
-		switch (choice) {
-			case "clipboard":
-				if (await copyToClipboard(rawStderr)) {
-					clipboardCopied = true;
-					p.log.step(green("Copied to clipboard."));
-				} else p.log.warn(red("No clipboard tool found. Install xclip, wl-copy, or xsel."));
-				continue;
-			case "skip":
-				p.log.info(yellow("Committing with --no-verify..."));
-				if (await onSkipHooks(message)) {
-					p.outro(green("Committed (hooks skipped)."));
-					return "committed";
-				} else {
-					p.outro(red("Commit failed even with --no-verify."));
-					return "failed";
-				}
-			case "restage":
-				p.log.info(cyan("Re-staging and retrying..."));
-				if (await onRestage()) {
-					p.outro(green("Committed successfully."));
-					return "committed";
-				}
-				showNote = true;
-				continue;
-			case "edit": {
-				const edited = await p.text({
-					message: "Edit commit message:",
-					initialValue: message,
-					validate: (v) => v?.trim() ? void 0 : "Message cannot be empty"
-				});
-				if (p.isCancel(edited)) {
-					p.outro(yellow("Cancelled. Message cached for --retry."));
-					return "cancelled";
-				}
-				if (await onRetry()) {
-					p.outro(green("Committed successfully."));
-					return "committed";
-				} else {
-					p.outro(red("Commit failed again."));
-					return "failed";
-				}
-			}
-			case "cancel":
-				p.outro(dim("Message cached for --retry."));
-				return "cancelled";
+		if (review === "use") {
+			debug("User accepted message");
+			return message;
+		}
+		if (review === "edit") {
+			debug("User chose to edit message");
+			const edited = await text({
+				message: "Edit commit message:",
+				initialValue: message,
+				validate: (v) => v?.trim() ? void 0 : "Message cannot be empty"
+			});
+			if (isCancel(edited)) continue;
+			message = String(edited).trim();
+			debug("Edited message:", message);
 		}
 	}
 }
 //#endregion
-//#region src/services/ai.ts
-const MAX_DIFF_CHARS = 2e4;
-function mapGroqError$1(error) {
-	if (error instanceof Groq.AuthenticationError) return /* @__PURE__ */ new Error("Invalid GROQ_API_KEY. Run: cmint config set GROQ_API_KEY=<key>");
-	if (error instanceof Groq.RateLimitError) return /* @__PURE__ */ new Error("Rate limited by Groq. Please wait and try again.");
-	if (error instanceof Groq.APIConnectionTimeoutError) return /* @__PURE__ */ new Error("Request timed out. Check your network or try a smaller diff.");
-	if (error instanceof Groq.APIError) return /* @__PURE__ */ new Error(`Groq API error: ${error.message}`);
-	return /* @__PURE__ */ new Error(`Unexpected error: ${error instanceof Error ? error.message : String(error)}`);
-}
-const CONVENTIONAL_COMMIT_REGEX = /^(build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test)(\(.+\))?!?: .+$/;
-function stripThinkTags(text) {
-	return text.replace(/<think[\s\S]*?<\/think>/gi, "").trim();
+//#region src/utils/cache.ts
+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) {
+	return join(CACHE_DIR, `${repoHash(repoPath)}.json`);
+}
+async function saveCachedCommit(repoPath, message) {
+	await mkdir(CACHE_DIR, { recursive: true });
+	const data = {
+		message,
+		timestamp: Date.now(),
+		repoPath
+	};
+	const path = cachePath(repoPath);
+	debug("saveCachedCommit: saving to %s", path);
+	await writeFile(path, JSON.stringify(data, null, 2), "utf8");
+}
+async function loadCachedCommit(repoPath) {
+	const path = cachePath(repoPath);
+	debug("loadCachedCommit: loading from %s", path);
+	try {
+		const raw = await readFile(path, "utf8");
+		const data = JSON.parse(raw);
+		debug("loadCachedCommit: found message from %s", new Date(data.timestamp).toISOString());
+		return data;
+	} catch {
+		debug("loadCachedCommit: no cached commit found");
+		return null;
+	}
+}
+//#endregion
+//#region src/services/ai.ts
+const MAX_DIFF_CHARS = 2e4;
+function mapGroqError(error, providerLabel) {
+	const label = providerLabel ?? "Groq";
+	if (error instanceof Groq.AuthenticationError) return /* @__PURE__ */ new Error(`Invalid API key for ${label}. Run: cmint config set ${label.toUpperCase()}_API_KEY=<key>`);
+	if (error instanceof Groq.RateLimitError) return /* @__PURE__ */ new Error(`Rate limited by ${label}. Please wait and try again.`);
+	if (error instanceof Groq.APIConnectionTimeoutError) return /* @__PURE__ */ new Error("Request timed out. Check your network or try a smaller diff.");
+	if (error instanceof Groq.APIError) return /* @__PURE__ */ new Error(`${label} API error: ${error.message}`);
+	return /* @__PURE__ */ new Error(`Unexpected error: ${error instanceof Error ? error.message : String(error)}`);
+}
+const CONVENTIONAL_COMMIT_REGEX = /^(build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test)(\(.+\))?!?: .+$/;
+function stripThinkTags(text) {
+	return text.replace(/<think[\s\S]*?<\/think>/gi, "").trim();
 }
 function deriveMessageFromReasoning(reasoning) {
 	const match = reasoning.match(/(build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test)(\(.+\))?!?: .+/i);
@@ -863,13 +735,16 @@ function extractContentText(content) {
 	return "";
 }
 async function generateCommitMessage(diff, options) {
-	debug("generateCommitMessage: model=%s, type=%s, hint=%s", options.model ?? "default", options.type ?? "none", options.hint ?? "none");
 	const timeoutMs = options.timeout ?? 6e4;
 	debug("Timeout: %d ms", timeoutMs);
-	const client = new Groq({
+	const { client, model } = createProvider({
+		provider: options.provider ?? "groq",
 		apiKey: options.apiKey,
-		timeout: timeoutMs
+		modelOverride: options.model,
+		timeout: timeoutMs,
+		baseURLOverride: options.proxy
 	});
+	debug("generateCommitMessage: model=%s, type=%s, hint=%s", model, options.type ?? "none", options.hint ?? "none");
 	const compressedDiff = compressDiff(diff);
 	const statSummary = buildStatSummary(diff);
 	const systemPrompt = buildSystemPrompt(options.type);
@@ -879,9 +754,9 @@ async function generateCommitMessage(diff, options) {
 	debug("User prompt length: %d chars", userPrompt.length);
 	async function callAI(strictSystemPrompt) {
 		const callStart = Date.now();
-		debug("callAI: %s — model=%s, promptLen=%d, systemLen=%d", !!strictSystemPrompt ? "RETRY (strict)" : "INITIAL", options.model ?? "openai/gpt-oss-20b", userPrompt.length, (strictSystemPrompt ?? systemPrompt).length);
+		debug("callAI: %s — model=%s, promptLen=%d, systemLen=%d", !!strictSystemPrompt ? "RETRY (strict)" : "INITIAL", model, userPrompt.length, (strictSystemPrompt ?? systemPrompt).length);
 		try {
-			const isReasoningModel = /^(o[1-9]|.*gpt-oss.*|.*gpt-5.*)/i.test(options.model ?? "");
+			const isReasoningModel = /^(o[1-9]|.*gpt-oss.*|.*gpt-5.*)/i.test(model);
 			const completion = await client.chat.completions.create({
 				messages: [{
 					role: "system",
@@ -890,7 +765,7 @@ async function generateCommitMessage(diff, options) {
 					role: "user",
 					content: userPrompt
 				}],
-				model: options.model ?? "openai/gpt-oss-20b",
+				model,
 				temperature: .3,
 				...isReasoningModel ? { max_completion_tokens: 1024 } : { max_tokens: 1024 },
 				reasoning_format: "parsed"
@@ -936,332 +811,205 @@ async function generateCommitMessage(diff, options) {
 		return message;
 	} catch (error) {
 		debug("AI error: %s", error instanceof Error ? error.message : String(error));
-		throw mapGroqError$1(error);
-	}
-}
-//#endregion
-//#region src/services/review-ai.ts
-function buildReviewSystemPrompt() {
-	return [
-		"You are an expert code reviewer. Review the following staged git diff.",
-		"",
-		"Focus on finding:",
-		"1. **Bugs** — logic errors, off-by-one, race conditions, null pointer risks",
-		"2. **Security issues** — injection, exposure of secrets, missing validation, CSRF, XSS",
-		"3. **Performance problems** — unnecessary work, large allocations in hot paths",
-		"4. **Code quality** — readability, maintainability, error handling gaps",
-		"5. **Edge cases** — missing boundary checks, empty states, error states",
-		"",
-		"For each issue found, use this format:",
-		"- SEVERITY: [critical|major|minor|suggestion]",
-		"- LOCATION: <file-path>:<line-number>",
-		"- ISSUE: <description>",
-		"- FIX: <suggested resolution>",
-		"",
-		"Separate issues with a blank line.",
-		"",
-		"If you find NO issues at all, respond with exactly: NO_ISSUES_FOUND",
-		"",
-		"Be thorough but practical. Only flag real problems — not style preferences or nitpicks."
-	].join("\n");
-}
-function buildReviewPrompt(diff, files, statSummary) {
-	const parts = [];
-	parts.push(`Review the following staged changes (${files.length} files):`);
-	parts.push("");
-	parts.push(statSummary);
-	parts.push("");
-	parts.push("```diff");
-	parts.push(diff);
-	parts.push("```");
-	return parts.join("\n");
-}
-async function generateCodeReview(diff, files, options) {
-	debug("generateCodeReview: model=%s, files=%d", options.model ?? "default", files.length);
-	const timeoutMs = options.timeout ?? 6e4;
-	const client = new Groq({
-		apiKey: options.apiKey,
-		timeout: timeoutMs
-	});
-	const compressedDiff = compressDiff(diff);
-	const statSummary = buildStatSummary(diff);
-	const systemPrompt = buildReviewSystemPrompt();
-	const userPrompt = buildReviewPrompt(compressedDiff, files, statSummary);
-	debug("Code review: %d chars → %d chars, system=%d chars, user=%d chars", diff.length, compressedDiff.length, systemPrompt.length, userPrompt.length);
-	try {
-		const completion = await client.chat.completions.create({
-			messages: [{
-				role: "system",
-				content: systemPrompt
-			}, {
-				role: "user",
-				content: userPrompt
-			}],
-			model: options.model ?? "openai/gpt-oss-20b",
-			temperature: .3,
-			max_tokens: 4096
-		});
-		const rawContent = completion.choices[0]?.message?.content;
-		const content = extractContentText(rawContent);
-		debug("generateCodeReview response: choices=%d, finishReason=%s, contentLen=%d", completion.choices.length, completion.choices[0]?.finish_reason ?? "(none)", content.length);
-		if (!content) {
-			const reasoning = completion.choices[0]?.message?.reasoning;
-			if (reasoning) {
-				const derived = deriveMessageFromReasoning(reasoning);
-				if (derived) {
-					debug("generateCodeReview: derived from reasoning");
-					return derived;
-				}
-			}
-			return "NO_ISSUES_FOUND";
-		}
-		return content;
-	} catch (error) {
-		debug("generateCodeReview error: %s", error instanceof Error ? error.message : String(error));
-		throw mapGroqError$1(error);
+		throw mapGroqError(error, options.provider ? formatProviderName(options.provider) : void 0);
 	}
 }
 //#endregion
-//#region src/commands/review.ts
-async function reviewCommand() {
-	debug("reviewCommand called");
-	await assertGitRepo();
-	const s = spinner();
-	s.start("Staging all changes...");
-	await stageAll();
-	s.stop("Changes staged");
-	const diffResult = await getStagedDiff();
-	if (!diffResult) {
-		outro(dim("No changes to review."));
-		return;
-	}
-	if ("excludedFiles" in diffResult) {
-		outro(dim("Staged files are all excluded from review."));
-		return;
-	}
-	intro("commit-mint — code review");
-	log.info(diffResult.files.map((f) => `     ${f}`).join("\n"));
-	const report = await isOpenCodeAvailable() ? await reviewWithOpenCode(diffResult.diff, diffResult.files) : await reviewWithGroq(diffResult.diff, diffResult.files);
-	if (report !== "NO_ISSUES_FOUND" && report.trim().length > 0) {
-		note(report, red(bold("Review findings")));
-		await offerClipboardCopy(report);
-	} else outro(green("No issues found. Looks good!"));
-}
-async function offerClipboardCopy(report) {
-	const shouldCopy = await select({
-		message: "Copy review report to clipboard?",
-		options: [{
-			label: "Yes, copy to clipboard",
-			value: "yes"
-		}, {
-			label: "No",
-			value: "no"
-		}]
-	});
-	if (isCancel(shouldCopy) || shouldCopy === "no") {
-		outro(dim("Done."));
-		return;
-	}
-	if (await copyToClipboard(report)) outro(green("Report copied to clipboard. You can paste it anywhere for fixes."));
-	else outro(red("Failed to copy to clipboard. Install xclip, wl-copy, or xsel."));
+//#region src/services/checks.ts
+/** Config file names, checked in priority order (matches lint-staged naming conventions) */
+const CONFIG_FILES = [
+	".cmintrc",
+	".cmintrc.json",
+	".cmintrc.mjs",
+	".cmintrc.mts",
+	".cmintrc.js",
+	".cmintrc.ts",
+	".cmintrc.cjs",
+	".cmintrc.cts",
+	"cmint.config.mjs",
+	"cmint.config.mts",
+	"cmint.config.js",
+	"cmint.config.ts",
+	"cmint.config.cjs",
+	"cmint.config.cts"
+];
+/**
+* Detect whether the repo has a cmint config file.
+* Returns the config file path, or null if none found.
+*/
+async function detectConfig(repoRoot) {
+	debug("detectConfig: checking for config in %s", repoRoot);
+	for (const name of CONFIG_FILES) try {
+		await access(join(repoRoot, name), constants.R_OK);
+		debug("detectConfig: found %s", name);
+		return join(repoRoot, name);
+	} catch {}
+	debug("detectConfig: no config file found");
+	return null;
 }
-async function isOpenCodeAvailable() {
-	try {
-		const { exitCode } = await import("execa").then((m) => m.execa("which", ["opencode"], { reject: false }));
-		return exitCode === 0;
-	} catch {
-		return false;
-	}
+/**
+* Load and validate the cmint config from a repo root.
+* Throws if the loaded value is missing or not a non-null object.
+*/
+async function loadConfig(repoRoot) {
+	const configPath = await detectConfig(repoRoot);
+	if (!configPath) throw new Error("No cmint config file found");
+	debug("loadConfig: loading %s", configPath);
+	const ext = extname(configPath);
+	const isJSON = ext === ".json";
+	const needsJiti = ext === ".ts" || ext === ".mts" || ext === ".cts" || ext === ".cjs";
+	let config;
+	if (isJSON) {
+		const raw = readFileSync(configPath, "utf-8");
+		config = JSON.parse(raw);
+	} else if (needsJiti) {
+		const { createJiti } = await import("jiti");
+		const mod = await createJiti(import.meta.url, {}).import(configPath);
+		config = mod.default ?? mod;
+	} else config = (await import(configPath)).default;
+	if (!config || typeof config !== "object" || Array.isArray(config)) throw new Error("cmint config must export a non-null object with glob→command mappings");
+	debug("loadConfig: loaded %d glob patterns", Object.keys(config).length);
+	return config;
 }
-async function reviewWithGroq(diff, files) {
-	const s = spinner();
-	s.start("Reviewing with Groq...");
+/**
+* Run a shell command and capture its output.
+* Returns a CheckResult with ok=true on success (exit 0), ok=false on failure.
+* Handles ENOENT (command not found) and timeout errors gracefully.
+*/
+async function runCommand(command, timeout, repoRoot) {
+	debug("runCommand: %s (timeout: %dms)", command, timeout);
+	const tool = extractToolName(command) ?? command.split(" ")[0];
 	try {
-		const config = await readConfig();
-		const report = await generateCodeReview(diff, files, {
-			apiKey: await getApiKey(),
-			model: config.model,
-			timeout: config.timeout ? Number.parseInt(config.timeout, 10) : void 0
+		const result = await execa(command, {
+			shell: true,
+			reject: false,
+			timeout,
+			all: true,
+			preferLocal: true,
+			...repoRoot ? { localDir: repoRoot } : {}
 		});
-		s.stop("Review complete");
-		return report;
+		const ok = !result.failed;
+		debug("runCommand: %s — ok=%s", tool, ok);
+		return {
+			ok,
+			tool,
+			command,
+			stdout: result.stdout ?? "",
+			stderr: result.stderr ?? "",
+			files: []
+		};
 	} catch (err) {
-		s.stop(red("Review failed."));
-		debug("reviewWithGroq error:", err instanceof Error ? err.message : String(err));
-		throw err;
+		const msg = err instanceof Error ? err.message : String(err);
+		const isTimedOut = msg.toLowerCase().includes("timed out");
+		const isNotFound = msg.toLowerCase().includes("enoent") || msg.toLowerCase().includes("not found");
+		debug("runCommand: %s — error: %s", tool, msg);
+		return {
+			ok: false,
+			tool,
+			command,
+			stdout: "",
+			stderr: isTimedOut ? `Check timed out after ${timeout}ms` : isNotFound ? `Command not found: ${tool}` : msg,
+			files: []
+		};
 	}
 }
-async function reviewWithOpenCode(diff, files) {
-	const s = spinner();
-	s.start("Running OpenCode review...");
-	try {
-		const repoRoot = await getRepoRoot();
-		const prompt = [
-			"Review the staged changes in this git repository.",
-			"Analyze the code diff for bugs, security issues, performance problems,",
-			"code quality issues, and missing edge cases.",
-			"",
-			`Files changed (${files.length}):`,
-			...files.map((f) => `  - ${f}`),
-			"",
-			"```diff",
-			diff.slice(0, 15e3),
-			"```",
-			"",
-			"Provide a structured report with severity, location, issue, and fix suggestion for each finding.",
-			"If no issues found, respond with: NO_ISSUES_FOUND"
-		].join("\n");
-		const { stdout } = await import("execa").then((m) => m.execa("opencode", [
-			"run",
-			prompt,
-			"--dir",
-			repoRoot
-		], {
-			timeout: 12e4,
-			reject: false
-		}));
-		s.stop("Review complete");
-		return stdout || "OpenCode review completed but no output captured.";
-	} catch (err) {
-		s.stop(red("OpenCode review failed."));
-		debug("reviewWithOpenCode error:", err instanceof Error ? err.message : String(err));
-		throw new Error(`OpenCode review failed: ${err instanceof Error ? err.message : String(err)}`);
-	}
+/**
+* Filter a list of file paths by a picomatch glob pattern.
+* When the pattern contains no `/`, files are matched at any depth (matchBase).
+* Dotfiles are included (dot: true).
+*/
+function matchFiles(pattern, files) {
+	if (!pattern) return [];
+	const matchBase = !pattern.includes("/");
+	const isMatch = picomatch(pattern, {
+		dot: true,
+		posixSlashes: true,
+		strictBrackets: true
+	});
+	return files.filter((f) => {
+		const parts = f.split("/");
+		return isMatch(matchBase ? parts[parts.length - 1] : f);
+	});
 }
-//#endregion
-//#region src/ui/review-message.ts
-async function runCodeReview() {
-	const diffResult = await getStagedDiff();
-	if (!diffResult || "excludedFiles" in diffResult) {
-		outro(dim("No staged changes to review."));
-		return;
-	}
-	const opencodeAvailable = await isOpenCodeAvailable();
-	const s = spinner();
-	s.start(opencodeAvailable ? "Running OpenCode review..." : "Running Groq review...");
-	try {
-		const report = opencodeAvailable ? await reviewWithOpenCode(diffResult.diff, diffResult.files) : await reviewWithGroq(diffResult.diff, diffResult.files);
-		s.stop("Review complete");
-		await showReviewResults(report);
-	} catch (err) {
-		s.stop(red("Review failed."));
-		debug("Code review error:", err instanceof Error ? err.message : String(err));
-		outro(red(err instanceof Error ? err.message : String(err)));
-	}
+/**
+* Build a shell command string from a base command and a list of file paths.
+* File paths containing spaces are wrapped in double quotes.
+* If no files are provided, the base command is returned as-is.
+*/
+function buildCommand(command, files) {
+	if (files.length === 0) return command;
+	return `${command} ${files.map((f) => f.includes(" ") ? `"${f}"` : f).join(" ")}`;
 }
-async function showReviewResults(report) {
-	const { note: clackNote, select: clackSelect } = await import("@clack/prompts");
-	if (!(report !== "NO_ISSUES_FOUND" && report.trim().length > 0)) {
-		log.info(green("No issues found."));
-		return;
+/**
+* Resolve config commands for a glob entry into an array of command strings.
+* Function commands receive matched filenames; string commands are used as-is.
+*/
+function resolveCommands(commands, matchedFiles) {
+	if (typeof commands === "function") {
+		const resolved = commands(matchedFiles);
+		return Array.isArray(resolved) ? resolved : [resolved];
 	}
-	clackNote(report, red(bold("Review findings")));
-	const shouldCopy = await clackSelect({
-		message: "Copy review report to clipboard?",
-		options: [{
-			label: "Yes, copy to clipboard",
-			value: "yes"
-		}, {
-			label: "No",
-			value: "no"
-		}]
-	});
-	if (isCancel(shouldCopy) || shouldCopy !== "yes") return;
-	if (await copyToClipboard(report)) log.info(green("Report copied to clipboard."));
-	else log.warn(red("Failed to copy to clipboard."));
+	return Array.isArray(commands) ? commands : [commands];
 }
-async function reviewCommitMessage(message) {
-	const { select, text } = await import("@clack/prompts");
-	while (true) {
-		const review = await select({
-			message: `Review commit message:\n\n   ${bold(message)}\n`,
-			options: [
-				{
-					label: "Use as-is",
-					value: "use"
-				},
-				{
-					label: "Edit",
-					value: "edit"
-				},
-				{
-					label: "Review with OpenCode",
-					value: "review"
-				},
-				{
-					label: "Cancel",
-					value: "cancel"
-				}
-			]
+/**
+* Run resolved commands for a single glob entry, appending results.
+* Returns false if any command fails (for fail-fast signaling).
+*/
+async function runCommandsForGlob(cmds, isFunction, matchedFiles, timeout, results, repoRoot) {
+	for (const cmd of cmds) {
+		const fullCommand = isFunction ? cmd : buildCommand(cmd, matchedFiles);
+		debug("runCommandsForGlob: running '%s'", fullCommand);
+		const result = await runCommand(fullCommand, timeout, repoRoot);
+		results.push({
+			...result,
+			files: matchedFiles
 		});
-		if (isCancel(review) || review === "cancel") {
-			debug("User cancelled at review step");
-			return null;
-		}
-		if (review === "use") {
-			debug("User accepted message");
-			return message;
+		if (!result.ok) {
+			debug("runCommandsForGlob: check failed, stopping (fail-fast)");
+			return false;
 		}
-		if (review === "edit") {
-			debug("User chose to edit message");
-			const edited = await text({
-				message: "Edit commit message:",
-				initialValue: message,
-				validate: (v) => v?.trim() ? void 0 : "Message cannot be empty"
-			});
-			if (isCancel(edited)) continue;
-			message = String(edited).trim();
-			debug("Edited message:", message);
+	}
+	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.
+*/
+async function runAllChecks(repoRoot, stagedFiles, timeout) {
+	debug("runAllChecks: %d staged files, checking for config in %s", stagedFiles.length, repoRoot);
+	if (!await detectConfig(repoRoot)) {
+		debug("runAllChecks: no config found, skipping checks");
+		return {
+			ok: true,
+			results: []
+		};
+	}
+	const config = await loadConfig(repoRoot);
+	debug("runAllChecks: loaded config with %d patterns", Object.keys(config).length);
+	const results = [];
+	for (const [glob, commands] of Object.entries(config)) {
+		const matchedFiles = matchFiles(glob, stagedFiles);
+		const isFunction = typeof commands === "function";
+		if (matchedFiles.length === 0) {
+			debug("runAllChecks: no files matched pattern '%s'", glob);
 			continue;
 		}
-		if (review === "review") {
-			debug("User chose to review code");
-			await runCodeReview();
-		}
+		debug("runAllChecks: pattern '%s' matched %d files", glob, matchedFiles.length);
+		if (!await runCommandsForGlob(resolveCommands(commands, matchedFiles), isFunction, matchedFiles, timeout, results, repoRoot)) return {
+			ok: false,
+			results
+		};
 	}
-}
-//#endregion
-//#region src/utils/cache.ts
-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) {
-	return join(CACHE_DIR, `${repoHash(repoPath)}.json`);
-}
-async function saveCachedCommit(repoPath, message) {
-	await mkdir(CACHE_DIR, { recursive: true });
-	const data = {
-		message,
-		timestamp: Date.now(),
-		repoPath
+	const ok = results.every((r) => r.ok);
+	debug("runAllChecks: complete — ok=%s, %d results", ok, results.length);
+	return {
+		ok,
+		results
 	};
-	const path = cachePath(repoPath);
-	debug("saveCachedCommit: saving to %s", path);
-	await writeFile(path, JSON.stringify(data, null, 2), "utf8");
-}
-async function loadCachedCommit(repoPath) {
-	const path = cachePath(repoPath);
-	debug("loadCachedCommit: loading from %s", path);
-	try {
-		const raw = await readFile(path, "utf8");
-		const data = JSON.parse(raw);
-		debug("loadCachedCommit: found message from %s", new Date(data.timestamp).toISOString());
-		return data;
-	} catch {
-		debug("loadCachedCommit: no cached commit found");
-		return null;
-	}
 }
 //#endregion
 //#region src/services/grouping.ts
-function mapGroqError(error) {
-	if (error instanceof Groq.AuthenticationError) return /* @__PURE__ */ new Error("Invalid GROQ_API_KEY. Run: cmint config set GROQ_API_KEY=<key>");
-	if (error instanceof Groq.RateLimitError) return /* @__PURE__ */ new Error("Rate limited by Groq. Please wait and try again.");
-	if (error instanceof Groq.APIConnectionTimeoutError) return /* @__PURE__ */ new Error("Request timed out. Check your network and try again.");
-	if (error instanceof Groq.APIError) return /* @__PURE__ */ new Error(`Groq API error: ${error.message}`);
-	return /* @__PURE__ */ new Error(`Unexpected error: ${error instanceof Error ? error.message : String(error)}`);
-}
 function matchesExcludePattern(filePath, pattern) {
 	if (pattern === filePath) return true;
 	if (pattern.endsWith("/**")) {
@@ -1278,7 +1026,9 @@ function matchesExcludePattern(filePath, pattern) {
 const LOCKFILE_COMPANIONS = {
 	"package-lock.json": "package.json",
 	"pnpm-lock.yaml": "package.json",
-	"yarn.lock": "package.json"
+	"yarn.lock": "package.json",
+	"bun.lock": "package.json",
+	"bun.lockb": "package.json"
 };
 function filterExcludedFiles(files) {
 	const patterns = getDefaultExcludes();
@@ -1352,7 +1102,7 @@ function parseGroupingResponse(content) {
 	});
 	return rawGroups;
 }
-async function generateGroups(files, apiKey, model, timeout) {
+async function generateGroups(files, apiKey, model, timeout, provider, proxy) {
 	debug("generateGroups: %d files, model=%s", files.length, model ?? "default");
 	const { included, excluded } = filterExcludedFiles(files);
 	if (included.length === 0) {
@@ -1367,9 +1117,12 @@ async function generateGroups(files, apiKey, model, timeout) {
 	const userPrompt = buildGroupingUserPrompt(summary);
 	debug("File summary:\n%s", summary);
 	debug("User prompt length: %d chars", userPrompt.length);
-	const client = new Groq({
+	const { client, model: resolvedModel } = createProvider({
+		provider: provider ?? "groq",
 		apiKey,
-		timeout: timeout ?? 6e4
+		modelOverride: model,
+		timeout: timeout ?? 6e4,
+		baseURLOverride: proxy
 	});
 	try {
 		const completion = await client.chat.completions.create({
@@ -1380,7 +1133,7 @@ async function generateGroups(files, apiKey, model, timeout) {
 				role: "user",
 				content: userPrompt
 			}],
-			model: model ?? "openai/gpt-oss-20b",
+			model: resolvedModel,
 			temperature: .3,
 			max_tokens: 2048
 		});
@@ -1399,7 +1152,7 @@ async function generateGroups(files, apiKey, model, timeout) {
 		};
 	} catch (error) {
 		debug("generateGroups error: %s", error instanceof Error ? error.message : String(error));
-		throw mapGroqError(error);
+		throw mapGroqError(error, provider ? formatProviderName(provider) : void 0);
 	}
 }
 function validateGroups(groups, allFiles) {
@@ -1465,36 +1218,372 @@ async function showGroupingConfirmation(groups, excluded) {
 function showGroupProgress(current, total, groupName) {
 	p.log.info(`Commit group ${current} of ${total}: ${cyan(`"${groupName}"`)}`);
 }
-//#endregion
-//#region src/commands/auto-group.ts
-async function runAutoGroupFlow(changedFiles, flags) {
-	const { included, excluded } = filterExcludedFiles(changedFiles);
-	try {
-		await getApiKey();
-		debug("API key found");
-	} catch {
-		debug("No API key found, prompting user");
-		const { text: promptText } = await import("@clack/prompts");
-		const key = await promptText({
-			message: "Enter your Groq API key:",
-			placeholder: "gsk_...",
-			validate: (v) => v?.trim() ? void 0 : "API key is required"
-		});
-		if (isCancel(key)) {
-			outro(dim("Cancelled."));
-			return "cancelled";
+const statusLabel = (status) => {
+	switch (status) {
+		case "M": return yellow("M");
+		case "A": return green("A");
+		case "D": return red("D");
+		case "?":
+		case "??": return cyan("?");
+		default: return dim(status);
+	}
+};
+/** Display combined view: files with status indicators grouped by commit group */
+function showGroupedFiles(groups, changedFiles) {
+	const statusMap = new Map(changedFiles.map((f) => [f.path, f.status]));
+	const lines = [];
+	for (let i = 0; i < groups.length; i++) {
+		const group = groups[i];
+		lines.push(`${bold(group.name)} ${dim("—")} ${group.files.length} file${group.files.length !== 1 ? "s" : ""}`);
+		for (const file of group.files) {
+			const status = statusMap.get(file) ?? "M";
+			lines.push(`  ${statusLabel(status)}  ${file}`);
 		}
-		await setConfigValue("GROQ_API_KEY", String(key).trim());
-		debug("API key saved to config");
+		if (i < groups.length - 1) lines.push("");
 	}
-	const s = spinner();
-	s.start("Analyzing files...");
-	const config = await readConfig();
-	const validatedGroups = validateGroups((await generateGroups(included, await getApiKey(), config.model, config.timeout ? parseInt(config.timeout, 10) : void 0)).groups, included);
-	s.stop("Files analyzed");
-	if (flags.auto) debug("Auto mode: skipping grouping confirmation");
-	else if (!await showGroupingConfirmation(validatedGroups, excluded)) {
-		outro(dim("Cancelled."));
+	p.note(lines.join("\n"), "Commit groups");
+}
+//#endregion
+//#region src/services/clipboard.ts
+async function copyToClipboard(content) {
+	for (const [cmd, args] of [
+		["wl-copy", []],
+		["xclip", ["-selection", "clipboard"]],
+		["xsel", ["--clipboard", "--input"]],
+		["pbcopy", []]
+	]) try {
+		if (await new Promise((resolve) => {
+			const child = spawn(cmd, args, { stdio: [
+				"pipe",
+				"ignore",
+				"ignore"
+			] });
+			let settled = false;
+			const done = (result) => {
+				if (settled) return;
+				settled = true;
+				resolve(result);
+			};
+			child.on("error", () => done(false));
+			child.on("exit", (code) => {
+				if (code !== 0) done(false);
+			});
+			child.stdin.write(content, (err) => {
+				if (err) {
+					done(false);
+					return;
+				}
+				child.stdin.end(() => {
+					child.unref();
+					done(true);
+				});
+			});
+		})) return true;
+	} catch {}
+	return false;
+}
+//#endregion
+//#region src/ui/menu.ts
+async function showStagingMenu(files, hasChecks) {
+	debug("showStagingMenu: %d files", files.length);
+	const statusLabel = (status) => {
+		switch (status) {
+			case "M": return yellow("M");
+			case "A": return green("A");
+			case "D": return red("D");
+			case "?":
+			case "??": return cyan("?");
+			default: return dim(status);
+		}
+	};
+	const sorted = [...files].sort((a, b) => {
+		if (a.staged !== b.staged) return a.staged ? -1 : 1;
+		return a.path.localeCompare(b.path);
+	});
+	const stagedFiles = sorted.filter((f) => f.staged);
+	const unstagedFiles = sorted.filter((f) => !f.staged);
+	const lines = [];
+	if (stagedFiles.length > 0) lines.push(green(bold("Staged:")), ...stagedFiles.map((f) => `  ${statusLabel(f.status)}  ${f.path}`));
+	if (unstagedFiles.length > 0) {
+		if (lines.length > 0) lines.push("");
+		lines.push(yellow(bold("Changed:")), ...unstagedFiles.map((f) => `  ${statusLabel(f.status)}  ${f.path}`));
+	}
+	p.note(lines.join("\n"), `${files.length} file${files.length !== 1 ? "s" : ""}`);
+	const choice = await p.select({
+		message: "Stage files for commit:",
+		options: [
+			{
+				label: "Auto-group into commits",
+				value: "autogroup",
+				hint: "LLM groups files into logical commits"
+			},
+			...stagedFiles.length > 0 ? [{
+				label: "Commit staged files only",
+				value: "staged",
+				hint: `${stagedFiles.length} file${stagedFiles.length !== 1 ? "s" : ""} already staged`
+			}] : [],
+			{
+				label: "Stage all files",
+				value: "all",
+				hint: `${files.length} file${files.length !== 1 ? "s" : ""}`
+			},
+			...hasChecks ? [{
+				label: "Run checks",
+				value: "checks",
+				hint: "Pre-flight checks from cmint config"
+			}] : [],
+			{
+				label: "Select files...",
+				value: "select"
+			},
+			{
+				label: "Cancel",
+				value: "cancel"
+			}
+		]
+	});
+	if (p.isCancel(choice) || choice === "cancel") return null;
+	if (choice === "autogroup") return "autogroup";
+	if (choice === "checks") return "checks";
+	if (choice === "staged") return "staged";
+	if (choice === "all") return {
+		files: files.map((f) => f.path),
+		all: true
+	};
+	const selected = await p.multiselect({
+		message: "Select files to stage:",
+		options: sorted.map((f) => ({
+			label: `${statusLabel(f.status)}  ${f.path}`,
+			value: f.path
+		})),
+		required: true
+	});
+	if (p.isCancel(selected)) return null;
+	return {
+		files: selected,
+		all: false
+	};
+}
+async function showRecoveryMenu(errors, onRetry, onSkipHooks, onRestage, message, rawStderr) {
+	debug("showRecoveryMenu: %d errors", errors.length);
+	let clipboardCopied = false;
+	let showNote = true;
+	while (true) {
+		if (showNote) {
+			p.note(errors.map((e) => `  ${red("•")} [${e.tool}] ${e.message}`).join("\n"), red(bold("Pre-commit hook failed")));
+			showNote = false;
+		}
+		const choice = await p.select({
+			message: "What do you want to do?",
+			options: [
+				{
+					label: clipboardCopied ? `${green("✓")} Copy error report to clipboard` : "Copy error report to clipboard",
+					value: "clipboard",
+					hint: clipboardCopied ? "Copied!" : "Paste into another terminal for an AI agent"
+				},
+				{
+					label: "View full error output",
+					value: "view",
+					hint: "Show the raw stderr from hooks"
+				},
+				{
+					label: "Skip hooks and commit (--no-verify)",
+					value: "skip",
+					hint: "Commit anyway, fix later"
+				},
+				{
+					label: "Re-stage files and retry",
+					value: "restage",
+					hint: "Pick up fixes from another terminal"
+				},
+				{
+					label: "Edit commit message",
+					value: "edit",
+					hint: "Modify the message before retrying"
+				},
+				{
+					label: "Cancel",
+					value: "cancel"
+				}
+			]
+		});
+		if (p.isCancel(choice)) {
+			debug("showRecoveryMenu: user cancelled");
+			p.outro(yellow("Cancelled. Message cached for --retry."));
+			return "cancelled";
+		}
+		debug("showRecoveryMenu: user chose %s", choice);
+		switch (choice) {
+			case "clipboard":
+				if (await copyToClipboard(rawStderr)) {
+					clipboardCopied = true;
+					p.log.step(green("Copied to clipboard."));
+				} else p.log.warn(red("No clipboard tool found. Install xclip, wl-copy, or xsel."));
+				continue;
+			case "view":
+				p.note(rawStderr.trim() || "(no raw output)", "Full error output");
+				showNote = true;
+				continue;
+			case "skip":
+				p.log.info(yellow("Committing with --no-verify..."));
+				if (await onSkipHooks(message)) {
+					p.outro(green("Committed (hooks skipped)."));
+					return "committed";
+				} else {
+					p.outro(red("Commit failed even with --no-verify."));
+					return "failed";
+				}
+			case "restage":
+				p.log.info(cyan("Re-staging and retrying..."));
+				if (await onRestage()) {
+					p.outro(green("Committed successfully."));
+					return "committed";
+				}
+				showNote = true;
+				continue;
+			case "edit": {
+				const edited = await p.text({
+					message: "Edit commit message:",
+					initialValue: message,
+					validate: (v) => v?.trim() ? void 0 : "Message cannot be empty"
+				});
+				if (p.isCancel(edited)) {
+					p.outro(yellow("Cancelled. Message cached for --retry."));
+					return "cancelled";
+				}
+				if (await onRetry()) {
+					p.outro(green("Committed successfully."));
+					return "committed";
+				} else {
+					p.outro(red("Commit failed again."));
+					return "failed";
+				}
+			}
+			case "cancel":
+				p.outro(dim("Message cached for --retry."));
+				return "cancelled";
+		}
+	}
+}
+async function showCheckFailureMenu(errors, rawStderr) {
+	debug("showCheckFailureMenu: %d errors", errors.length);
+	let clipboardCopied = false;
+	p.note(errors.map((e) => `  ${red("•")} [${e.tool}] ${e.message}`).join("\n"), red("Pre-commit check failed"));
+	while (true) {
+		const choice = await p.select({
+			message: "What do you want to do?",
+			options: [
+				{
+					label: clipboardCopied ? `${green("✓")} Copy error report to clipboard` : "Copy error report to clipboard",
+					value: "copy"
+				},
+				{
+					label: "View full error output",
+					value: "view",
+					hint: "Show the raw stderr from checks"
+				},
+				{
+					label: "Skip checks and commit",
+					value: "skip"
+				},
+				{
+					label: "Cancel",
+					value: "cancel"
+				}
+			]
+		});
+		if (p.isCancel(choice)) {
+			debug("showCheckFailureMenu: user cancelled");
+			return "cancelled";
+		}
+		debug("showCheckFailureMenu: user chose %s", choice);
+		switch (choice) {
+			case "copy":
+				if (await copyToClipboard(rawStderr)) {
+					clipboardCopied = true;
+					p.log.step(green("Copied to clipboard."));
+				} else p.log.warn(red("No clipboard tool found. Install xclip, wl-copy, or xsel."));
+				continue;
+			case "view":
+				p.note(rawStderr.trim() || "(no raw output)", "Full error output");
+				continue;
+			case "skip":
+				p.log.info("Skipping checks and proceeding with commit...");
+				return "skipped";
+			case "cancel":
+				p.outro(dim("Cancelled."));
+				return "cancelled";
+		}
+	}
+}
+//#endregion
+//#region src/commands/auto-group.ts
+async function runAutoGroupFlow(changedFiles, flags) {
+	const { included, excluded } = filterExcludedFiles(changedFiles);
+	if (excluded.length > 0) {
+		debug("Committing %d excluded files upfront:", excluded.length, excluded);
+		const message = buildExcludedFilesMessage(excluded);
+		await resetStaging();
+		await stageFiles(excluded);
+		const headBefore = await getHead();
+		const commitResult = await attemptCommit(message);
+		const headAfter = await getHead();
+		if (commitResult.ok || headBefore !== headAfter) debug("Excluded files committed:", message);
+		else debug("Excluded files commit failed, continuing without them");
+	}
+	if (included.length === 0) {
+		debug("No included files to group, done");
+		outro(green("Done."));
+		return "committed";
+	}
+	if (!flags.noCheck) {
+		const { getRepoRoot } = await Promise.resolve().then(() => git_exports);
+		const repoRoot = await getRepoRoot();
+		const allFiles = included.filter((f) => f.status !== "D").map((f) => f.path);
+		debug("Running user checks on %d files...", allFiles.length);
+		const ck = spinner();
+		ck.start("Running checks...");
+		const checkResults = await runAllChecks(repoRoot, allFiles, 6e4);
+		debug("Check results: ok=%s, count=%d", checkResults.ok, checkResults.results.length);
+		if (!checkResults.ok) {
+			ck.stop(`${checkResults.results.filter((r) => !r.ok).length} check(s) failed`);
+			const rawStderr = checkResults.results.filter((r) => !r.ok).map((r) => `[${r.tool}] ${r.stderr}`).join("\n");
+			if (await showCheckFailureMenu(parseHookErrors(rawStderr), rawStderr) === "cancelled") return "cancelled";
+		} else {
+			ck.stop("All checks passed");
+			if (checkResults.results.length > 0) log.info(checkResults.results.map((r) => `  ${green("✓")} ${r.tool}`).join("\n"));
+		}
+	}
+	const config = await readConfig();
+	const resolvedProvider = config.provider ?? "groq";
+	const provider = isValidProvider(resolvedProvider) ? resolvedProvider : "groq";
+	try {
+		await getProviderApiKey(provider);
+		debug("API key found");
+	} catch {
+		debug("No API key found, prompting user");
+		const { text: promptText } = await import("@clack/prompts");
+		const key = await promptText({
+			message: `Enter your ${formatProviderName(provider)} API key:`,
+			placeholder: provider === "groq" ? "gsk_..." : "...",
+			validate: (v) => v?.trim() ? void 0 : "API key is required"
+		});
+		if (isCancel(key)) {
+			outro(dim("Cancelled."));
+			return "cancelled";
+		}
+		const configKey = PROVIDER_ENV_KEYS[provider];
+		await setConfigValue(configKey, String(key).trim());
+		debug("API key saved to config");
+	}
+	const s = spinner();
+	s.start("Analyzing files...");
+	const validatedGroups = validateGroups((await generateGroups(included, await getProviderApiKey(provider), getModelForProvider(config, provider, PROVIDER_CONFIGS[provider].defaultModel), config.timeout ? parseInt(config.timeout, 10) : void 0, provider, config.proxy)).groups, included);
+	s.stop("Files analyzed");
+	showGroupedFiles(validatedGroups, included);
+	if (flags.auto) debug("Auto mode: skipping grouping confirmation");
+	else if (!await showGroupingConfirmation(validatedGroups, excluded)) {
+		outro(dim("Cancelled."));
 		return "cancelled";
 	}
 	for (let i = 0; i < validatedGroups.length; i++) {
@@ -1558,14 +1647,19 @@ async function runAutoGroupFlow(changedFiles, flags) {
 }
 async function generateMessage(diff, hint) {
 	const config = await readConfig();
-	const apiKey = await getApiKey();
-	debug("Generating message with model:", config.model, "type:", config.type);
+	const resolvedProvider = config.provider ?? "groq";
+	const provider = isValidProvider(resolvedProvider) ? resolvedProvider : "groq";
+	const apiKey = await getProviderApiKey(provider);
+	const model = getModelForProvider(config, provider, PROVIDER_CONFIGS[provider].defaultModel);
+	debug("Generating message with provider:", provider, "model:", model, "type:", config.type);
 	return generateCommitMessage(diff, {
 		apiKey,
-		model: config.model,
+		model,
 		type: config.type,
 		timeout: config.timeout ? parseInt(config.timeout, 10) : void 0,
-		hint
+		hint,
+		provider,
+		proxy: config.proxy
 	});
 }
 function buildExcludedFilesMessage(files) {
@@ -1578,46 +1672,143 @@ function buildExcludedFilesMessage(files) {
 	return "chore: update generated files";
 }
 //#endregion
-//#region src/commands/commit.ts
-async function commitCommand(flags) {
-	debug("commitCommand called", { flags });
-	await assertGitRepo();
-	if (flags.retry) {
-		debug("Entering retry mode");
-		const { getRepoRoot } = await Promise.resolve().then(() => git_exports);
-		const repoRoot = await getRepoRoot();
-		debug("Repo root:", repoRoot);
-		const cached = await loadCachedCommit(repoRoot);
-		if (!cached) {
-			debug("No cached commit found");
-			outro(red("No cached commit message found. Run cmint without --retry first."));
-			process.exit(1);
+//#region src/commands/commit-utils.ts
+/** Shared recovery menu factory — avoids repeating the same callback set */
+function makeRecoveryCallbacks(message) {
+	return {
+		retry: async () => (await attemptCommit(message)).ok,
+		skipHooks: async (msg) => (await attemptCommitNoVerify(msg)).ok,
+		restage: async () => {
+			await stageAll();
+			return (await attemptCommit(message)).ok;
+		},
+		message
+	};
+}
+/**
+* Attempt commit with automatic recovery flow.
+* Handles the attempt → HEAD check → success (tool checks display)
+* / failure (recovery menu) pattern.
+* Caller is responsible for starting the spinner and showing the final outro.
+*/
+async function commitWithRecovery(message, s, headBefore) {
+	const result = await attemptCommit(message, [], createProgressHandler(s));
+	const headAfter = await getHead();
+	if (result.ok || headBefore !== headAfter) {
+		s.stop("Committed successfully.");
+		const checks = parseToolChecks(result.stderr ?? "");
+		if (checks.length > 0) {
+			const lines = checks.map((c) => `  ${c.ok ? green("✓") : red("✗")} ${c.tool}`);
+			log.info(lines.join("\n"));
 		}
-		debug("Loaded cached message:", cached.message);
-		intro("commit-mint — retry");
-		const s = spinner();
-		s.start("Running pre-commit hooks...");
-		const result = await attemptCommit(cached.message, [], createProgressHandler(s));
-		s.stop("Attempted commit");
-		debug("Retry commit result:", result);
-		if (result.ok) {
-			const checks = parseToolChecks(result.stderr ?? "");
-			if (checks.length > 0) {
-				const lines = checks.map((c) => `  ${c.ok ? green("✓") : red("✗")} ${c.tool}`);
-				log.info(lines.join("\n"));
+		return "committed";
+	}
+	s.stop("Commit failed.");
+	const errors = parseHookErrors(result.stderr ?? "");
+	const cb = makeRecoveryCallbacks(message);
+	if (await showRecoveryMenu(errors, cb.retry, cb.skipHooks, cb.restage, cb.message, result.stderr ?? "") === "cancelled") return "cancelled";
+	return "committed";
+}
+//#endregion
+//#region src/commands/retry.ts
+/** Handle --retry mode: load cached message and re-attempt commit */
+async function handleRetry() {
+	debug("Entering retry mode");
+	const cached = await loadCachedCommit(await getRepoRoot());
+	if (!cached) {
+		outro(red("No cached commit message found. Run cmint without --retry first."));
+		process.exit(1);
+	}
+	intro("🌿 commit-mint — retry");
+	const s = spinner();
+	const headBefore = await getHead();
+	s.start("Running pre-commit hooks...");
+	if (await commitWithRecovery(cached.message, s, headBefore) === "committed") outro(green("Committed successfully."));
+	else process.exit(1);
+}
+//#endregion
+//#region src/commands/staging.ts
+/** Interactive staging loop for multiple changed files */
+async function handleStaging(changedFiles, flags) {
+	const repoRoot = await getRepoRoot();
+	const checksAvailable = await detectConfig(repoRoot) !== null;
+	debug("checks available:", checksAvailable);
+	let stagingResult = null;
+	let filesToStage = [];
+	let stageAllFlag = false;
+	let skipStaging = false;
+	let currentFiles = changedFiles;
+	while (true) {
+		stagingResult = await showStagingMenu(currentFiles, checksAvailable);
+		if (stagingResult === "autogroup") {
+			if (flags.message) {
+				outro(red("--message flag is not compatible with auto-group mode."));
+				return null;
 			}
-			outro(green("Committed successfully."));
-		} else {
-			const errors = parseHookErrors(result.stderr ?? "");
-			debug("Hook errors on retry:", errors.length);
-			if (await showRecoveryMenu(errors, async () => (await attemptCommit(cached.message)).ok, async (msg) => (await attemptCommitNoVerify(msg)).ok, async () => {
-				await stageAll();
-				return (await attemptCommit(cached.message)).ok;
-			}, cached.message, result.stderr ?? "") === "cancelled") process.exit(1);
-			return;
+			if (await runAutoGroupFlow(currentFiles, flags) !== "committed") process.exit(1);
+			return null;
+		}
+		if (stagingResult === "checks") {
+			await stageAll();
+			const ckSpinner = spinner();
+			ckSpinner.start("Running checks...");
+			const ckResult = await runAllChecks(repoRoot, currentFiles.filter((f) => f.status !== "D").map((f) => f.path), 6e4);
+			if (ckResult.ok) {
+				ckSpinner.stop("All checks passed");
+				for (const r of ckResult.results) if (r.stdout.trim()) log.info(dim(r.stdout.trim()));
+			} else {
+				const failed = ckResult.results.filter((r) => !r.ok);
+				ckSpinner.stop(`${failed.length} check${failed.length !== 1 ? "s" : ""} failed`);
+				for (const r of failed) log.info(r.stderr?.trim() || r.stdout?.trim() || `Check failed: ${r.command}`);
+			}
+			currentFiles = await getChangedFiles();
+			continue;
+		}
+		if (stagingResult === "staged") {
+			skipStaging = true;
+			break;
+		}
+		if (!stagingResult) {
+			outro(dim("Cancelled."));
+			return null;
 		}
+		filesToStage = stagingResult.files;
+		stageAllFlag = stagingResult.all;
+		break;
 	}
-	intro("commit-mint");
+	if (!skipStaging) {
+		const s = spinner();
+		s.start(`Staging ${filesToStage.length} file${filesToStage.length !== 1 ? "s" : ""}...`);
+		if (stageAllFlag) await stageAll();
+		else await stageFiles(filesToStage);
+		s.stop("Files staged");
+	}
+	return {
+		changedFiles: currentFiles,
+		skipStaging
+	};
+}
+/** Run user-defined pre-commit checks from cmint config */
+async function runPreCommitChecks(changedFiles, noCheck) {
+	if (noCheck) return;
+	const checkRoot = await getRepoRoot();
+	const stagedFileList = changedFiles.filter((f) => f.staged && f.status !== "D").map((f) => f.path);
+	if (stagedFileList.length === 0) return;
+	debug("Running user checks on %d staged files...", stagedFileList.length);
+	const checkResults = await runAllChecks(checkRoot, stagedFileList, 6e4);
+	debug("Check results: ok=%s, count=%d", checkResults.ok, checkResults.results.length);
+	if (!checkResults.ok) {
+		const rawStderr = checkResults.results.filter((r) => !r.ok).map((r) => `[${r.tool}] ${r.stderr}`).join("\n");
+		if (await showCheckFailureMenu(parseHookErrors(rawStderr), rawStderr) === "cancelled") process.exit(1);
+	}
+}
+//#endregion
+//#region src/commands/commit.ts
+async function commitCommand(flags) {
+	debug("commitCommand called", { flags });
+	await assertGitRepo();
+	if (flags.retry) return handleRetry();
+	intro("🌿 commit-mint");
 	const status = await getStatusShort();
 	debug("Git status:", status || "(empty)");
 	if (!status) {
@@ -1640,49 +1831,9 @@ async function commitCommand(flags) {
 			await stageFiles([changedFiles[0].path]);
 			s.stop("File staged");
 		} else {
-			const { getRepoRoot } = await Promise.resolve().then(() => git_exports);
-			const lintStagedAvailable = await hasLintStagedConfig(await getRepoRoot());
-			debug("lint-staged available:", lintStagedAvailable);
-			let stagingResult = null;
-			let filesToStage = [];
-			let stageAllFlag = false;
-			while (true) {
-				stagingResult = await showStagingMenu(changedFiles, lintStagedAvailable);
-				if (stagingResult === "autogroup") {
-					if (flags.message) {
-						outro(red("--message flag is not compatible with auto-group mode."));
-						return;
-					}
-					if (await runAutoGroupFlow(changedFiles, flags) !== "committed") process.exit(1);
-					return;
-				}
-				if (stagingResult === "lint-staged") {
-					await stageAll();
-					const lsSpinner = spinner();
-					lsSpinner.start("Running lint-staged checks...");
-					const lsResult = await runLintStaged();
-					if (lsResult.ok) {
-						lsSpinner.stop("All lint-staged checks passed");
-						if (lsResult.stdout.trim()) log.info(dim(lsResult.stdout.trim()));
-					} else {
-						lsSpinner.stop("Lint-staged checks failed");
-						log.info(lsResult.stderr?.trim() || lsResult.stdout?.trim() || "Unknown error");
-					}
-					changedFiles = await getChangedFiles();
-					continue;
-				}
-				if (!stagingResult) {
-					outro(dim("Cancelled."));
-					return;
-				}
-				filesToStage = stagingResult.files;
-				stageAllFlag = stagingResult.all;
-				break;
-			}
-			s.start(`Staging ${filesToStage.length} file${filesToStage.length !== 1 ? "s" : ""}...`);
-			if (stageAllFlag) await stageAll();
-			else await stageFiles(filesToStage);
-			s.stop("Files staged");
+			const result = await handleStaging(changedFiles, flags);
+			if (!result) return;
+			changedFiles = result.changedFiles;
 		}
 	} catch (err) {
 		s.stop(red("Staging failed."));
@@ -1691,6 +1842,8 @@ async function commitCommand(flags) {
 		outro(red(`Failed to stage files: ${msg}`));
 		process.exit(1);
 	}
+	changedFiles = await getChangedFiles();
+	await runPreCommitChecks(changedFiles, flags.noCheck);
 	const diffResult = await getStagedDiff();
 	if (!diffResult) {
 		debug("No staged changes found after staging");
@@ -1701,22 +1854,14 @@ async function commitCommand(flags) {
 		debug("All staged files are excluded:", diffResult.excludedFiles);
 		const message = buildExcludedFilesMessage(diffResult.excludedFiles);
 		log.info(diffResult.excludedFiles.map((f) => `     ${f}`).join("\n"));
-		const { getRepoRoot } = await Promise.resolve().then(() => git_exports);
 		await saveCachedCommit(await getRepoRoot(), message);
 		s.start("Running pre-commit hooks...");
-		const headBefore = await getHead();
-		const result = await attemptCommit(message, [], createProgressHandler(s));
-		const headAfter = await getHead();
-		if (result.ok || headBefore !== headAfter) {
-			s.stop("Committed successfully.");
+		const result = await commitWithRecovery(message, s, await getHead());
+		if (result === "committed") {
 			outro(green("Done."));
 			return;
 		}
-		s.stop("Commit failed.");
-		if (await showRecoveryMenu(parseHookErrors(result.stderr ?? ""), async () => (await attemptCommit(message)).ok, async (msg) => (await attemptCommitNoVerify(msg)).ok, async () => {
-			await stageAll();
-			return (await attemptCommit(message)).ok;
-		}, message, result.stderr ?? "") === "cancelled") process.exit(1);
+		if (result === "cancelled") process.exit(1);
 		return;
 	}
 	debug("Staged files:", diffResult.files);
@@ -1727,22 +1872,25 @@ async function commitCommand(flags) {
 		debug("Using provided message:", flags.message);
 		message = flags.message;
 	} else {
+		const config = await readConfig();
+		const provider = isValidProvider(config.provider ?? "groq") ? config.provider : "groq";
 		try {
-			await getApiKey();
+			await getProviderApiKey(provider);
 			debug("API key found");
 		} catch {
 			debug("No API key found, prompting user");
 			const { text: promptText } = await import("@clack/prompts");
+			const configKey = PROVIDER_ENV_KEYS[provider];
 			const key = await promptText({
-				message: "Enter your Groq API key:",
-				placeholder: "gsk_...",
+				message: `Enter your ${formatProviderName(provider)} API key:`,
+				placeholder: provider === "groq" ? "gsk_..." : "...",
 				validate: (v) => v?.trim() ? void 0 : "API key is required"
 			});
 			if (isCancel(key)) {
 				outro(dim("Cancelled."));
 				return;
 			}
-			await setConfigValue("GROQ_API_KEY", String(key).trim());
+			await setConfigValue(configKey, String(key).trim());
 			debug("API key saved to config");
 		}
 		s.start("Generating commit message...");
@@ -1765,66 +1913,197 @@ async function commitCommand(flags) {
 		return;
 	}
 	message = reviewed;
-	const { getRepoRoot } = await Promise.resolve().then(() => git_exports);
 	const repoRoot = await getRepoRoot();
 	await saveCachedCommit(repoRoot, message);
 	debug("Message cached for repo:", repoRoot);
 	s.start("Running pre-commit hooks...");
 	const headBefore = await getHead();
 	debug("HEAD before commit:", headBefore);
-	const result = await attemptCommit(message, [], createProgressHandler(s));
-	const headAfter = await getHead();
-	debug("HEAD after commit:", headAfter);
+	const result = await commitWithRecovery(message, s, headBefore);
 	debug("Commit result:", result);
-	if (result.ok || headBefore !== headAfter) {
-		s.stop("Committed successfully.");
-		const checks = parseToolChecks(result.stderr ?? "");
-		if (checks.length > 0) {
-			const lines = checks.map((c) => `  ${c.ok ? green("✓") : red("✗")} ${c.tool}`);
-			log.info(lines.join("\n"));
-		}
+	if (result === "committed") {
 		outro(green("Done."));
 		return;
 	}
-	s.stop("Commit failed.");
-	debug("Commit failed, showing recovery menu");
-	const errors = parseHookErrors(result.stderr ?? "");
-	debug("Parsed hook errors:", errors.length, "errors");
-	if (await showRecoveryMenu(errors, async () => {
-		return (await attemptCommit(message)).ok;
-	}, async (msg) => {
-		return (await attemptCommitNoVerify(msg)).ok;
-	}, async () => {
-		await stageAll();
-		return (await attemptCommit(message)).ok;
-	}, message, result.stderr ?? "") === "cancelled") process.exit(1);
+	if (result === "cancelled") process.exit(1);
 }
 //#endregion
 //#region src/commands/config.ts
-const configCommand = command({
-	name: "config",
-	parameters: ["<mode>", "<key=value...>"]
-}, async (argv) => {
-	const { mode, keyValue } = argv._;
-	if (mode === "get") {
-		for (const kv of keyValue) {
-			const key = kv.split("=")[0];
-			const value = await getConfigValue(key);
-			console.log(`${key}=${value ?? ""}`);
-		}
-		return;
+function maskKey(key) {
+	if (!key) return dim("not set");
+	if (key.length <= 8) return "****";
+	return `${key.slice(0, 4)}${"*".repeat(Math.min(key.length - 8, 20))}${key.slice(-4)}`;
+}
+function buildConfigDisplay(config) {
+	const provider = isValidProvider(config.provider ?? "groq") ? config.provider : "groq";
+	const apiKey = config[PROVIDER_ENV_KEYS[provider]];
+	return [
+		`Provider:     ${bold(formatProviderName(provider))}`,
+		`API Key:      ${maskKey(apiKey)}`,
+		`Model:        ${config.model ?? "(none)"}`,
+		`Locale:       ${config.locale ?? "en"}`,
+		`Max Length:   ${config["max-length"] ?? "100"}`,
+		`Commit Type:  ${config.type || dim("(none)")}`,
+		`Timeout:      ${config.timeout ?? "10000"}ms`,
+		`Proxy:        ${config.proxy || dim("(none)")}`
+	].join("\n");
+}
+function getProvider(config) {
+	return isValidProvider(config.provider ?? "groq") ? config.provider : "groq";
+}
+async function promptProvider() {
+	return p.select({
+		message: "Select LLM provider:",
+		options: [
+			{
+				label: "Groq",
+				value: "groq",
+				hint: PROVIDER_CONFIGS.groq.defaultModel
+			},
+			{
+				label: "Cerebras",
+				value: "cerebras",
+				hint: PROVIDER_CONFIGS.cerebras.defaultModel
+			},
+			{
+				label: "Mistral",
+				value: "mistral",
+				hint: PROVIDER_CONFIGS.mistral.defaultModel
+			}
+		]
+	});
+}
+async function promptApiKey(provider) {
+	const keyName = PROVIDER_ENV_KEYS[provider];
+	const result = await p.text({
+		message: `${formatProviderName(provider)} API key:`,
+		placeholder: "Paste your API key",
+		validate: (v) => !v?.trim() ? "API key cannot be empty" : void 0
+	});
+	if (p.isCancel(result)) return result;
+	await writeConfig({ [keyName]: result.toString().trim() });
+	debug("config: %s set", keyName);
+	return result;
+}
+async function promptTextSetting(label, configKey, currentValue, validate) {
+	const result = await p.text({
+		message: label,
+		placeholder: currentValue ?? "",
+		initialValue: currentValue ?? "",
+		validate
+	});
+	if (p.isCancel(result)) return result;
+	await writeConfig({ [configKey]: result.toString().trim() });
+	debug("config: %s set to %s", configKey, result);
+	return result;
+}
+const requireNumber = (v) => {
+	if (!v?.trim()) return "Value cannot be empty";
+	return Number.isNaN(Number(v)) ? "Must be a number" : void 0;
+};
+function getSettingHandlers(config) {
+	const provider = getProvider(config);
+	return {
+		provider: async () => {
+			const result = await promptProvider();
+			if (p.isCancel(result)) return result;
+			await writeConfig({ provider: result });
+			debug("config: provider set to %s", result);
+		},
+		apikey: async () => promptApiKey(provider),
+		model: async () => promptTextSetting("Model ID:", "model", config.model),
+		locale: async () => promptTextSetting("Locale (e.g. en, ja, ko):", "locale", config.locale),
+		maxlen: async () => promptTextSetting("Max commit message length:", "max-length", config["max-length"], requireNumber),
+		type: async () => promptTextSetting("Commit type prefix (e.g. conventional):", "type", config.type),
+		timeout: async () => promptTextSetting("Timeout (ms):", "timeout", config.timeout, requireNumber),
+		proxy: async () => promptTextSetting("Proxy URL:", "proxy", config.proxy)
+	};
+}
+async function handleEditSetting(setting, config) {
+	const handler = getSettingHandlers(config)[setting];
+	if (!handler) return false;
+	const result = await handler();
+	return !p.isCancel(result);
+}
+async function editSettingsLoop(initialConfig) {
+	let config = initialConfig;
+	while (true) {
+		config = await readConfig();
+		const provider = getProvider(config);
+		const setting = await p.select({
+			message: "Select a setting to edit:",
+			options: [
+				{
+					label: `LLM Provider  ${dim(`(${formatProviderName(provider)})`)}`,
+					value: "provider"
+				},
+				{
+					label: `API Key  ${dim(`(for ${formatProviderName(provider)})`)}`,
+					value: "apikey"
+				},
+				{
+					label: `Model  ${dim(`(${config.model ?? "(none)"})`)}`,
+					value: "model"
+				},
+				{
+					label: `Locale  ${dim(`(${config.locale ?? "en"})`)}`,
+					value: "locale"
+				},
+				{
+					label: `Max commit length  ${dim(`(${config["max-length"] ?? "100"})`)}`,
+					value: "maxlen"
+				},
+				{
+					label: `Commit type prefix  ${dim(`(${config.type || "(none)"})`)}`,
+					value: "type"
+				},
+				{
+					label: `Timeout (ms)  ${dim(`(${config.timeout ?? "10000"})`)}`,
+					value: "timeout"
+				},
+				{
+					label: `Proxy URL  ${dim(`(${config.proxy || "(none)"})`)}`,
+					value: "proxy"
+				},
+				{
+					label: "Done editing",
+					value: "done"
+				}
+			]
+		});
+		if (p.isCancel(setting) || setting === "done") break;
+		if (await handleEditSetting(setting, config)) p.log.success(green("Updated."));
 	}
-	if (mode === "set") {
-		for (const kv of keyValue) {
-			const [key, ...rest] = kv.split("=");
-			await setConfigValue(key, rest.join("="));
+}
+async function configCommand() {
+	debug("configCommand: starting");
+	p.intro(bold("🌿 commit-mint config"));
+	while (true) {
+		const config = await readConfig();
+		p.note(buildConfigDisplay(config), "commit-mint config");
+		const action = await p.select({
+			message: "What would you like to do?",
+			options: [{
+				label: "Edit settings",
+				value: "edit"
+			}, {
+				label: "Done",
+				value: "done"
+			}]
+		});
+		if (p.isCancel(action)) {
+			debug("configCommand: cancelled at main menu");
+			p.outro(dim("Cancelled."));
+			return;
 		}
-		console.log("Config updated.");
-		return;
+		if (action === "done") {
+			debug("configCommand: done");
+			p.outro("Config saved.");
+			return;
+		}
+		await editSettingsLoop(config);
 	}
-	console.error(`Unknown config mode: ${mode}. Use "get" or "set".`);
-	process.exit(1);
-});
+}
 //#endregion
 //#region src/cli.ts
 const { version } = package_default;
@@ -1855,24 +2134,25 @@ cli({
 			description: "Add context hint for AI commit message generation",
 			alias: "H"
 		},
-		review: {
-			type: Boolean,
-			description: "Review staged changes with a coding model",
-			alias: "R",
-			default: false
-		},
 		debug: {
 			type: Boolean,
 			description: "Enable debug output",
 			alias: "d",
 			default: false
+		},
+		noCheck: {
+			type: Boolean,
+			description: "Skip user-defined pre-commit checks",
+			alias: "N",
+			default: false
 		}
 	},
-	commands: [configCommand]
+	commands: [command({ name: "config" }, async () => {
+		await configCommand();
+	})]
 }, (argv) => {
 	setDebug(argv.flags.debug);
-	if (argv.flags.review) reviewCommand();
-	else commitCommand(argv.flags);
+	commitCommand(argv.flags);
 });
 //#endregion
 export {};