@kyubiware/commit-mint 0.1.0 → 0.2.0

package/dist/cli.mjs

@@ -5,8 +5,8 @@ import { intro, isCancel, log, outro, spinner } from "@clack/prompts";
 import { bold, cyan, dim, green, red, yellow } from "kolorist";
 import Groq from "groq-sdk";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
 import os from "node:os";
+import { join } from "node:path";
 import ini from "ini";
 import { execa } from "execa";
 import { createHash } from "node:crypto";
@@ -25,7 +25,7 @@ var __exportAll = (all, no_symbols) => {
 //#region package.json
 var package_default = {
 	name: "@kyubiware/commit-mint",
-	version: "0.1.0",
+	version: "0.2.0",
 	description: "A commit tool that actually handles hook failures",
 	type: "module",
 	bin: { "cmint": "./dist/cli.mjs" },
@@ -33,14 +33,20 @@ var package_default = {
 	scripts: {
 		"build": "tsdown src/cli.ts --format esm --dts --clean",
 		"dev": "tsx src/cli.ts",
+		"dev:debug": "tsx src/cli.ts --debug",
 		"lint": "biome check .",
 		"lint:fix": "biome check --fix .",
 		"typecheck": "tsc --noEmit",
 		"test": "vitest run",
 		"test:coverage": "vitest run --coverage",
 		"test:watch": "vitest --watch",
-		"prepublishOnly": "npm run build"
+		"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"
 	},
+	"simple-git-hooks": { "pre-commit": "npx lint-staged" },
 	keywords: [
 		"git",
 		"commit",
@@ -68,7 +74,10 @@ var package_default = {
 	},
 	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",
@@ -76,75 +85,174 @@ var package_default = {
 	}
 };
 //#endregion
+//#region src/utils/debug.ts
+let enabled = false;
+function setDebug(value) {
+	enabled = value;
+}
+function debug(...args) {
+	if (!enabled) return;
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+	console.error(dim(`[debug ${timestamp}]`), ...args);
+}
+//#endregion
 //#region src/services/ai.ts
+const MAX_DIFF_CHARS = 2e4;
 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);
+	if (match) return match[0].trim();
+	const first = reasoning.split(/[.!?]/).find((s) => s.trim().length >= 10);
+	return first ? first.trim() : null;
+}
+function stripContextLines(diff) {
+	return diff.split("\n").filter((line) => !line.startsWith(" ")).join("\n");
+}
 function compressDiff(diff) {
-	if (diff.length <= 4e4) return diff;
-	let result = diff.split("\n").map((line) => line.length > 256 ? `${line.slice(0, 256)}...` : line).join("\n");
-	if (result.length <= 4e4) return result;
-	const files = result.split(/(?=diff --git)/).filter(Boolean).map((fd) => ({
-		diff: fd,
-		parts: fd.split(/(?=\n@@)/)
-	}));
-	while (result.length > 4e4) {
-		files.sort((a, b) => b.parts.length - a.parts.length);
-		const longest = files[0];
-		if (!longest || longest.parts.length <= 1) break;
-		longest.parts.pop();
-		longest.diff = longest.parts.join("");
-		result = files.map((f) => f.diff).join("");
-	}
-	if (result.length <= 4e4) return result;
-	return `Summary of changes:\n${(result.match(/^diff --git a\/(.+) b\/(.+)$/gm) || []).map((f) => {
+	if (diff.length <= MAX_DIFF_CHARS) return diff;
+	let result = stripContextLines(diff);
+	if (result.length <= MAX_DIFF_CHARS) return result;
+	result = result.split(/(?=diff --git)/).filter(Boolean).map((fd) => {
+		return fd.split(/(?=\n@@)/).map((part, idx) => {
+			if (idx === 0) return part;
+			const lines = part.split("\n");
+			return [lines[0], ...lines.slice(1).filter((l) => l.startsWith("+") || l.startsWith("-")).slice(0, 10)].join("\n");
+		}).join("");
+	}).join("");
+	if (result.length <= MAX_DIFF_CHARS) return result;
+	return `Summary of changes:\n${(diff.match(/^diff --git a\/(.+) b\/(.+)$/gm) || []).map((f) => {
 		const match = f.match(/^diff --git a\/(.+) b\/(.+)$/);
 		return match && match[1] === match[2] ? `${match[1]} | changed` : "";
 	}).filter(Boolean).join("\n")}`;
 }
+function buildStatSummary(diff) {
+	const files = [];
+	let currentFile = "";
+	let adds = 0;
+	let dels = 0;
+	for (const line of diff.split("\n")) {
+		const match = line.match(/^diff --git a\/.+ b\/(.+)$/);
+		if (match) {
+			if (currentFile) files.push({
+				name: currentFile,
+				adds,
+				dels
+			});
+			currentFile = match[1];
+			adds = 0;
+			dels = 0;
+		} else if (line.startsWith("+") && !line.startsWith("+++")) adds++;
+		else if (line.startsWith("-") && !line.startsWith("---")) dels++;
+	}
+	if (currentFile) files.push({
+		name: currentFile,
+		adds,
+		dels
+	});
+	const totalAdds = files.reduce((s, f) => s + f.adds, 0);
+	const totalDels = files.reduce((s, f) => s + f.dels, 0);
+	const lines = files.map((f) => ` ${f.name}  | +${f.adds} -${f.dels}`);
+	lines.push(` ${files.length} files changed, ${totalAdds} insertions(+), ${totalDels} deletions(-)`);
+	return lines.join("\n");
+}
 function buildSystemPrompt(type) {
 	let prompt = "You are a commit message generator. Follow the Conventional Commits specification.\nValid types: build, chore, ci, docs, feat, fix, perf, refactor, revert, style, test.\nFormat: type(scope): description\nUse imperative mood, lowercase, no trailing period.\nOutput ONLY the commit message, no markdown fences, no explanation.";
 	if (type && type.trim().length > 0) prompt += `\nYou MUST use type: ${type}`;
 	return prompt;
 }
-function buildUserPrompt(diff, hint) {
-	return `${hint ? `Context: ${hint}\n\n` : ""}Generate a conventional commit for:\n\n${diff}`;
+function buildUserPrompt(diff, hint, statSummary) {
+	const parts = [];
+	if (hint) parts.push(`Context: ${hint}`);
+	if (statSummary) parts.push(`Change summary:\n${statSummary}`);
+	parts.push(`Generate a conventional commit for:\n\n${diff}`);
+	return parts.join("\n\n");
 }
 function isValidConventionalCommit(message) {
 	return CONVENTIONAL_COMMIT_REGEX.test(message);
 }
-function enforceMaxLength(message, maxLength) {
-	if (!maxLength || message.length <= maxLength) return message;
-	return `${message.slice(0, maxLength - 3)}...`;
+function extractContentText(content) {
+	if (content == null) return "";
+	if (typeof content === "string") return content.trim();
+	if (Array.isArray(content)) return content.filter((part) => part.type === "text" && typeof part.text === "string").map((part) => stripThinkTags(part.text)).join("").trim();
+	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({
 		apiKey: options.apiKey,
-		timeout: options.timeout ?? 6e4
+		timeout: timeoutMs
 	});
 	const compressedDiff = compressDiff(diff);
+	const statSummary = buildStatSummary(diff);
 	const systemPrompt = buildSystemPrompt(options.type);
-	const userPrompt = buildUserPrompt(compressedDiff, options.hint);
+	const userPrompt = buildUserPrompt(compressedDiff, options.hint, statSummary);
+	debug("Diff: %d chars → compressed to %d chars", diff.length, compressedDiff.length);
+	debug("Stat summary:\n%s", statSummary);
+	debug("User prompt length: %d chars", userPrompt.length);
 	async function callAI(strictSystemPrompt) {
-		return ((await client.chat.completions.create({
-			messages: [{
-				role: "system",
-				content: strictSystemPrompt ?? systemPrompt
-			}, {
-				role: "user",
-				content: userPrompt
-			}],
-			model: options.model ?? "openai/gpt-oss-20b",
-			temperature: .3,
-			max_tokens: 300
-		})).choices[0]?.message?.content)?.trim() ?? "";
+		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);
+		try {
+			const isReasoningModel = /^(o[1-9]|.*gpt-oss.*|.*gpt-5.*)/i.test(options.model ?? "");
+			const completion = await client.chat.completions.create({
+				messages: [{
+					role: "system",
+					content: strictSystemPrompt ?? systemPrompt
+				}, {
+					role: "user",
+					content: userPrompt
+				}],
+				model: options.model ?? "openai/gpt-oss-20b",
+				temperature: .3,
+				...isReasoningModel ? { max_completion_tokens: 1024 } : { max_tokens: 1024 },
+				reasoning_format: "parsed"
+			});
+			const elapsed = Date.now() - callStart;
+			const rawContent = completion.choices[0]?.message?.content;
+			const content = extractContentText(typeof rawContent === "string" ? stripThinkTags(rawContent) : rawContent);
+			debug("callAI response (%d ms): choices=%d, finishReason=%s, contentLen=%d, rawType=%s", elapsed, completion.choices.length, completion.choices[0]?.finish_reason ?? "(none)", content.length, typeof rawContent);
+			debug("callAI raw content: %s", content.slice(0, 300) || "(empty)");
+			if (!content) {
+				const reasoning = completion.choices[0]?.message?.reasoning;
+				debug("callAI: content empty, attempting reasoning fallback (reasoningLen=%d)", reasoning?.length ?? 0);
+				if (reasoning) {
+					const derived = deriveMessageFromReasoning(reasoning);
+					if (derived) {
+						debug("callAI: derived message from reasoning: %s", derived.slice(0, 100));
+						return stripThinkTags(derived);
+					}
+					debug("callAI: could not derive message from reasoning");
+				}
+				throw new Error("AI returned an empty commit message");
+			}
+			return content;
+		} catch (error) {
+			debug("callAI FAILED after %d ms: %s", Date.now() - callStart, error instanceof Error ? `${error.name}: ${error.message}` : String(error));
+			throw error;
+		}
 	}
 	try {
+		const totalStart = Date.now();
 		let message = await callAI();
+		debug("Validation: message=%s, isValid=%s", message.slice(0, 100), isValidConventionalCommit(message));
 		if (!isValidConventionalCommit(message)) {
+			debug("Initial message failed conventional commit validation, retrying with strict prompt (elapsed: %d ms)", Date.now() - totalStart);
 			const retryMessage = await callAI("You MUST output ONLY a valid conventional commit message. Format: type(scope): description. If you output anything else your response will be rejected.\nValid types: build, chore, ci, docs, feat, fix, perf, refactor, revert, style, test.");
-			if (isValidConventionalCommit(retryMessage)) message = retryMessage;
+			debug("Retry validation: message=%s, isValid=%s", retryMessage.slice(0, 100), isValidConventionalCommit(retryMessage));
+			if (isValidConventionalCommit(retryMessage)) {
+				debug("Retry produced valid conventional commit");
+				message = retryMessage;
+			} else debug("Retry also failed validation, using original message");
 		}
-		return enforceMaxLength(message, options.maxLength);
+		debug("Final message (%d ms total): %s", Date.now() - totalStart, message);
+		return message;
 	} catch (error) {
+		debug("AI error: %s", error instanceof Error ? error.message : String(error));
 		if (error instanceof Groq.AuthenticationError) throw new Error("Invalid GROQ_API_KEY. Run: cmint config set GROQ_API_KEY=<key>");
 		if (error instanceof Groq.RateLimitError) throw new Error("Rate limited by Groq. Please wait and try again.");
 		if (error instanceof Groq.APIConnectionTimeoutError) throw new Error("Request timed out. Check your network or try a smaller diff.");
@@ -163,14 +271,18 @@ const defaults = {
 	timeout: "10000"
 };
 async function readConfig() {
+	debug("readConfig: loading from %s", CONFIG_PATH);
 	try {
 		const raw = await readFile(CONFIG_PATH, "utf8");
 		const parsed = ini.parse(raw);
-		return {
+		const merged = {
 			...defaults,
 			...parsed
 		};
+		debug("readConfig: loaded keys: %s", Object.keys(merged).join(", "));
+		return merged;
 	} catch {
+		debug("readConfig: no config file, using defaults");
 		return { ...defaults };
 	}
 }
@@ -187,9 +299,16 @@ async function setConfigValue(key, value) {
 }
 async function getApiKey() {
 	const envKey = process.env.GROQ_API_KEY;
-	if (envKey) return envKey;
+	if (envKey) {
+		debug("getApiKey: found in env");
+		return envKey;
+	}
 	const config = await readConfig();
-	if (config.GROQ_API_KEY) return config.GROQ_API_KEY;
+	if (config.GROQ_API_KEY) {
+		debug("getApiKey: found in config");
+		return config.GROQ_API_KEY;
+	}
+	debug("getApiKey: not found");
 	throw new Error("Please set your Groq API key via `cmint config set GROQ_API_KEY=<your token>`");
 }
 //#endregion
@@ -199,57 +318,81 @@ var git_exports = /* @__PURE__ */ __exportAll({
 	assertGitRepo: () => assertGitRepo,
 	attemptCommit: () => attemptCommit,
 	attemptCommitNoVerify: () => attemptCommitNoVerify,
+	getChangedFiles: () => getChangedFiles,
+	getDefaultExcludes: () => getDefaultExcludes,
 	getHead: () => getHead,
 	getRepoRoot: () => getRepoRoot,
 	getStagedDiff: () => getStagedDiff,
 	getStatusShort: () => getStatusShort,
-	stageAll: () => stageAll
+	stageAll: () => stageAll,
+	stageFiles: () => stageFiles
 });
 var KnownError = class extends Error {};
 async function assertGitRepo() {
+	debug("assertGitRepo");
 	const { failed } = await execa("git", ["rev-parse", "--show-toplevel"], { reject: false });
 	if (failed) throw new KnownError("The current directory must be a Git repository!");
 }
 async function getRepoRoot() {
 	const { stdout } = await execa("git", ["rev-parse", "--show-toplevel"]);
+	debug("getRepoRoot:", stdout.trim());
 	return stdout.trim();
 }
+const DEFAULT_EXCLUDES = [
+	"package-lock.json",
+	"node_modules/**",
+	"dist/**",
+	"build/**",
+	".next/**",
+	"coverage/**",
+	"*.log",
+	"*.min.js",
+	"*.min.css",
+	"*.lock",
+	".DS_Store"
+];
+function getDefaultExcludes() {
+	return [...DEFAULT_EXCLUDES];
+}
 async function getStagedDiff(exclude) {
 	const excludeArgs = (exclude ?? []).map((e) => `:(exclude)${e}`);
-	const defaultExcludes = [
-		"package-lock.json",
-		"node_modules/**",
-		"dist/**",
-		"build/**",
-		".next/**",
-		"coverage/**",
-		"*.log",
-		"*.min.js",
-		"*.min.css",
-		"*.lock",
-		".DS_Store"
-	].map((e) => `:(exclude)${e}`);
+	const defaultExcludeArgs = DEFAULT_EXCLUDES.map((e) => `:(exclude)${e}`);
+	const { stdout: allFiles } = await execa("git", [
+		"diff",
+		"--cached",
+		"--name-only"
+	]);
+	if (!allFiles) {
+		debug("getStagedDiff: no staged files");
+		return null;
+	}
 	const { stdout: files } = await execa("git", [
 		"diff",
 		"--cached",
 		"--name-only",
-		...defaultExcludes,
+		...defaultExcludeArgs,
 		...excludeArgs
 	]);
-	if (!files) return null;
+	if (!files) {
+		const excludedFiles = allFiles.split("\n").filter(Boolean);
+		debug("getStagedDiff: all files excluded:", excludedFiles);
+		return { excludedFiles };
+	}
 	const { stdout: diff } = await execa("git", [
 		"diff",
 		"--cached",
 		"--diff-algorithm=minimal",
-		...defaultExcludes,
+		...defaultExcludeArgs,
 		...excludeArgs
 	]);
+	debug("getStagedDiff:", files.split("\n").filter(Boolean).length, "files,", diff.length, "chars");
 	return {
 		files: files.split("\n").filter(Boolean),
 		diff
 	};
 }
 async function stageAll() {
+	debug("stageAll: git add -A");
 	await execa("git", ["add", "-A"]);
 }
 async function getHead() {
@@ -260,25 +403,51 @@ async function getStatusShort() {
 	const { stdout } = await execa("git", ["status", "--short"]);
 	return stdout.trim();
 }
+async function getChangedFiles() {
+	const { stdout } = await execa("git", ["status", "--short"]);
+	if (!stdout.trim()) return [];
+	const files = stdout.split("\n").filter(Boolean).map((line) => ({
+		status: line.slice(0, 2).trim(),
+		path: line.slice(3)
+	}));
+	debug("getChangedFiles:", files.length, "files");
+	return files;
+}
+async function stageFiles(paths) {
+	debug("stageFiles:", paths);
+	await execa("git", ["add", ...paths]);
+}
 async function attemptCommit(message, extraArgs = []) {
+	debug("attemptCommit:", message, extraArgs.length ? extraArgs : "(no extra args)");
 	try {
-		await execa("git", [
+		const subprocess = execa("git", [
 			"commit",
 			"-m",
 			message,
 			...extraArgs
 		]);
-		return { ok: true };
+		const stderrChunks = [];
+		subprocess.stderr?.on("data", (chunk) => {
+			stderrChunks.push(chunk.toString());
+		});
+		await subprocess;
+		debug("attemptCommit: success");
+		return {
+			ok: true,
+			stderr: stderrChunks.join("")
+		};
 	} catch (error) {
 		const e = error;
+		debug("attemptCommit: failed —", e.message?.slice(0, 200));
 		return {
 			ok: false,
 			error: e.message,
-			stderr: e.stderr ?? ""
+			stderr: typeof e.stderr === "string" ? e.stderr : ""
 		};
 	}
 }
 async function attemptCommitNoVerify(message) {
+	debug("attemptCommitNoVerify:", message);
 	return attemptCommit(message, ["--no-verify"]);
 }
 //#endregion
@@ -289,25 +458,27 @@ async function attemptCommitNoVerify(message) {
 */
 function parseHookErrors(stderr) {
 	if (!stderr) return [];
+	debug("parseHookErrors: stderr length=%d", stderr.length);
 	const errors = [];
-	stderr.split("\n");
 	if (stderr.includes("lint-staged") || stderr.includes("[FAILED]")) errors.push(...parseLintStagedErrors(stderr));
 	if (stderr.includes("biome") || stderr.includes("Biome")) errors.push(...parseBiomeErrors(stderr));
 	if (stderr.includes("error TS") || stderr.includes("tsc")) errors.push(...parseTscErrors(stderr));
 	if (stderr.includes("vitest") || stderr.includes("jest") || stderr.includes("FAIL") || stderr.includes("test failed")) errors.push(...parseTestErrors(stderr));
 	if (stderr.includes("eslint") || stderr.includes("ESLint")) errors.push(...parseEslintErrors(stderr));
-	if (errors.length === 0) errors.push({
-		tool: "git hooks",
-		message: stderr.trim(),
-		raw: stderr
-	});
+	if (errors.length === 0) {
+		debug("parseHookErrors: no patterns matched, using raw fallback");
+		errors.push({
+			tool: "git hooks",
+			message: stderr.trim(),
+			raw: stderr
+		});
+	}
+	debug("parseHookErrors: found %d errors", errors.length);
 	return errors;
 }
 function parseLintStagedErrors(output) {
 	const errors = [];
-	const taskPattern = /\[FAILED\]\s+(.+?)\s+\[FAILED\]/g;
-	let match;
-	while ((match = taskPattern.exec(output)) !== null) {
+	for (const match of output.matchAll(/\[FAILED\]\s+(.+?)\s+\[FAILED\]/g)) {
 		const task = match[1].trim();
 		errors.push({
 			tool: "lint-staged",
@@ -319,9 +490,7 @@ function parseLintStagedErrors(output) {
 }
 function parseBiomeErrors(output) {
 	const errors = [];
-	const biomePattern = /^(.+?):(\d+):(\d+)\s+(.+)$/gm;
-	let match;
-	while ((match = biomePattern.exec(output)) !== null) errors.push({
+	for (const match of output.matchAll(/^(.+?):(\d+):(\d+)\s+(.+)$/gm)) errors.push({
 		tool: "biome",
 		message: `${match[1]}:${match[2]}:${match[3]} — ${match[4]}`,
 		raw: match[0]
@@ -335,9 +504,7 @@ function parseBiomeErrors(output) {
 }
 function parseTscErrors(output) {
 	const errors = [];
-	const tscPattern = /^(.+?)\((\d+),(\d+)\):\s+error\s+(TS\d+):\s+(.+)$/gm;
-	let match;
-	while ((match = tscPattern.exec(output)) !== null) errors.push({
+	for (const match of output.matchAll(/^(.+?)\((\d+),(\d+)\):\s+error\s+(TS\d+):\s+(.+)$/gm)) errors.push({
 		tool: "tsc",
 		message: `${match[1]}:${match[2]}:${match[3]} — ${match[4]}: ${match[5]}`,
 		raw: match[0]
@@ -361,71 +528,103 @@ function parseTestErrors(output) {
 }
 function parseEslintErrors(output) {
 	const errors = [];
-	const eslintPattern = /^\s*\d+:(\d+)\s+(error|warning)\s+(.+?)\s+(.+?)$/gm;
-	let match;
-	while ((match = eslintPattern.exec(output)) !== null) errors.push({
+	for (const match of output.matchAll(/^\s*\d+:(\d+)\s+(error|warning)\s+(.+?)\s+(.+?)$/gm)) errors.push({
 		tool: "eslint",
 		message: `${match[2]}: ${match[3]} (${match[4]})`,
 		raw: match[0]
 	});
 	return errors;
 }
-function formatErrorReport(errors) {
-	if (errors.length === 0) return "";
-	return errors.map((e) => `[${e.tool}]\n${e.message}`).join("\n\n");
+/**
+* Parse lint-staged/hook stderr output to discover which tools ran
+* and whether they succeeded. Used for clean post-commit summary.
+*/
+function parseToolChecks(stderr) {
+	if (!stderr) return [];
+	const checks = [];
+	for (const match of stderr.matchAll(/\[(COMPLETED|FAILED)\]\s+(.+)/g)) {
+		const status = match[1];
+		const command = match[2].trim();
+		if (isLintStagedMeta(command)) continue;
+		const tool = extractToolName(command);
+		if (!tool) continue;
+		checks.push({
+			tool,
+			ok: status === "COMPLETED"
+		});
+	}
+	const seen = /* @__PURE__ */ new Map();
+	for (const c of checks) seen.set(c.tool, c);
+	return [...seen.values()];
+}
+/** Heuristic: skip lint-staged internal metadata lines */
+function isLintStagedMeta(command) {
+	if (/[*{}[\]]/.test(command)) return true;
+	if (/\s[-–—]\s(\d+\s)?files?$/.test(command)) return true;
+	if (/\s[-–—]\sno\s files$/.test(command)) return true;
+	if (/^(Running tasks|Applying modifications|Cleaning up|Backing up|Backed up|Updating Git)/.test(command)) return true;
+	if (/\.{3}$/.test(command)) return true;
+	return false;
+}
+/** Extract a display-friendly tool name from a lint-staged command */
+function extractToolName(command) {
+	const tokens = command.split(/\s+/);
+	const first = tokens[0];
+	if ([
+		"npm",
+		"yarn",
+		"pnpm",
+		"bun"
+	].includes(first)) {
+		const script = tokens[tokens[1] === "run" ? 2 : 1];
+		if (!script) return null;
+		return {
+			typecheck: "tsc",
+			lint: "eslint",
+			format: "prettier"
+		}[script] ?? script;
+	}
+	if (first === "npx") return tokens[1] ?? null;
+	return first;
 }
 //#endregion
 //#region src/services/clipboard.ts
 async function copyToClipboard(content) {
-	for (const [cmd, ...args] of [
-		["wl-copy"],
-		[
-			"xclip",
-			"-selection",
-			"clipboard"
-		],
-		[
-			"xsel",
-			"--clipboard",
-			"--input"
-		],
-		["pbcopy"]
+	for (const [cmd, args] of [
+		["wl-copy", []],
+		["xclip", ["-selection", "clipboard"]],
+		["xsel", ["--clipboard", "--input"]],
+		["pbcopy", []]
 	]) try {
-		const { stdout } = await execa("which", [cmd], { reject: false });
-		if (!stdout) continue;
-		await execa(cmd, args.length > 0 ? args : [], { input: content });
+		await execa(cmd, args, { input: content });
 		return true;
-	} catch {
-		continue;
-	}
+	} catch {}
 	return false;
 }
 //#endregion
 //#region src/ui/menu.ts
-async function showRecoveryMenu(errors, onRetry, onSkipHooks, onRestage, message) {
-	p.note(errors.map((e) => `  ${red("•")} [${e.tool}] ${e.message}`).join("\n"), red(bold("Pre-commit hook failed")));
+async function showStagingMenu(files) {
+	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 "?": return dim("?");
+			default: return dim(status);
+		}
+	};
 	const choice = await p.select({
-		message: "What do you want to do?",
+		message: "Stage files for commit:",
 		options: [
 			{
-				label: "Copy error report to clipboard",
-				value: "clipboard",
-				hint: "Paste into another terminal for an AI agent"
+				label: "Stage all files",
+				value: "all",
+				hint: `${files.length} file${files.length !== 1 ? "s" : ""}`
 			},
 			{
-				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: "Select files...",
+				value: "select"
 			},
 			{
 				label: "Cancel",
@@ -433,44 +632,102 @@ async function showRecoveryMenu(errors, onRetry, onSkipHooks, onRestage, message
 			}
 		]
 	});
-	if (p.isCancel(choice)) {
-		p.outro(yellow("Cancelled. Message cached for --retry."));
-		process.exit(1);
-	}
-	switch (choice) {
-		case "clipboard":
-			if (await copyToClipboard(formatErrorReport(errors))) p.outro(green("Error report copied to clipboard."));
-			else p.outro(red("No clipboard tool found. Install xclip, wl-copy, or xsel."));
-			p.log.info(dim("Fix the errors, then run: cmint --retry"));
-			process.exit(0);
-			break;
-		case "skip":
-			p.log.info(yellow("Committing with --no-verify..."));
-			if (await onSkipHooks(message)) p.outro(green("Committed (hooks skipped)."));
-			else p.outro(red("Commit failed even with --no-verify."));
-			break;
-		case "restage":
-			p.log.info(cyan("Re-staging and retrying..."));
-			if (await onRestage()) p.outro(green("Committed successfully."));
-			else await showRecoveryMenu(errors, onRetry, onSkipHooks, onRestage, message);
-			break;
-		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."));
-				process.exit(1);
+	if (p.isCancel(choice) || choice === "cancel") return null;
+	if (choice === "all") return {
+		files: files.map((f) => f.path),
+		all: true
+	};
+	const selected = await p.multiselect({
+		message: "Select files to stage:",
+		options: files.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);
+	while (true) {
+		p.note(errors.map((e) => `  ${red("•")} [${e.tool}] ${e.message}`).join("\n"), red(bold("Pre-commit hook failed")));
+		const choice = await p.select({
+			message: "What do you want to do?",
+			options: [
+				{
+					label: "Copy error report to clipboard",
+					value: "clipboard",
+					hint: "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: "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."));
+			process.exit(1);
+			return;
+		}
+		debug("showRecoveryMenu: user chose %s", choice);
+		switch (choice) {
+			case "clipboard":
+				if (await copyToClipboard(rawStderr)) p.log.step(green("Errors copied"));
+				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)."));
+				else p.outro(red("Commit failed even with --no-verify."));
+				return;
+			case "restage":
+				p.log.info(cyan("Re-staging and retrying..."));
+				if (await onRestage()) {
+					p.outro(green("Committed successfully."));
+					return;
+				}
+				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."));
+					process.exit(1);
+					return;
+				}
+				if (await onRetry()) p.outro(green("Committed successfully."));
+				else p.outro(red("Commit failed again."));
+				return;
 			}
-			if (await onRetry()) p.outro(green("Committed successfully."));
-			else p.outro(red("Commit failed again."));
-			break;
+			case "cancel":
+				p.outro(dim("Message cached for --retry."));
+				process.exit(1);
+				return;
 		}
-		case "cancel":
-			p.outro(dim("Message cached for --retry."));
-			process.exit(1);
 	}
 }
 //#endregion
@@ -489,60 +746,141 @@ async function saveCachedCommit(repoPath, message) {
 		timestamp: Date.now(),
 		repoPath
 	};
-	await writeFile(cachePath(repoPath), JSON.stringify(data, null, 2), "utf8");
+	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(cachePath(repoPath), "utf8");
-		return JSON.parse(raw);
+		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/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 cached = await loadCachedCommit(await getRepoRoot());
+		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);
 		}
+		debug("Loaded cached message:", cached.message);
 		intro("commit-mint — retry");
 		const s = spinner();
 		s.start("Retrying commit...");
 		const result = await attemptCommit(cached.message);
 		s.stop("Attempted commit");
-		if (result.ok) outro(green("Committed successfully."));
-		else await showRecoveryMenu(parseHookErrors(result.stderr ?? ""), async () => (await attemptCommit(cached.message)).ok, async (msg) => (await attemptCommitNoVerify(msg)).ok, async () => {
-			await stageAll();
-			return (await attemptCommit(cached.message)).ok;
-		}, cached.message);
+		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"));
+			}
+			outro(green("Committed successfully."));
+		} else {
+			const errors = parseHookErrors(result.stderr ?? "");
+			debug("Hook errors on retry:", errors.length);
+			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 ?? "");
+		}
 		return;
 	}
 	intro("commit-mint");
-	if (!await getStatusShort()) {
+	const status = await getStatusShort();
+	debug("Git status:", status || "(empty)");
+	if (!status) {
 		outro(dim("Nothing to commit."));
 		return;
 	}
+	const changedFiles = await getChangedFiles();
+	debug("Changed files:", changedFiles.length);
 	const s = spinner();
-	s.start("Staging all changes...");
-	await stageAll();
-	s.stop("Changes staged");
-	const diff = await getStagedDiff();
-	if (!diff) {
+	try {
+		if (flags.all) {
+			s.start("Staging all changes...");
+			await stageAll();
+			s.stop("Changes staged");
+		} else if (changedFiles.length === 1) {
+			s.start(`Staging ${changedFiles[0].path}...`);
+			await stageFiles([changedFiles[0].path]);
+			s.stop("File staged");
+		} else {
+			const stagingResult = await showStagingMenu(changedFiles);
+			if (!stagingResult) {
+				outro(dim("Cancelled."));
+				return;
+			}
+			s.start(`Staging ${stagingResult.files.length} file${stagingResult.files.length !== 1 ? "s" : ""}...`);
+			if (stagingResult.all) await stageAll();
+			else await stageFiles(stagingResult.files);
+			s.stop("Files staged");
+		}
+	} catch (err) {
+		s.stop(red("Staging failed."));
+		const msg = err instanceof Error ? err.message : String(err);
+		debug("Staging error:", msg);
+		outro(red(`Failed to stage files: ${msg}`));
+		process.exit(1);
+	}
+	const diffResult = await getStagedDiff();
+	if (!diffResult) {
+		debug("No staged changes found after staging");
 		outro(red("No staged changes found."));
 		process.exit(1);
 	}
-	log.info(diff.files.map((f) => `     ${f}`).join("\n"));
+	if ("excludedFiles" in diffResult) {
+		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("Committing...");
+		const headBefore = await getHead();
+		const result = await attemptCommit(message);
+		const headAfter = await getHead();
+		if (result.ok || headBefore !== headAfter) {
+			s.stop("Committed successfully.");
+			outro(green("Done."));
+			return;
+		}
+		s.stop("Commit failed.");
+		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 ?? "");
+		return;
+	}
+	debug("Staged files:", diffResult.files);
+	debug("Diff length:", diffResult.diff.length, "chars");
+	log.info(diffResult.files.map((f) => `     ${f}`).join("\n"));
 	let message;
-	if (flags.message) message = flags.message;
-	else {
+	if (flags.message) {
+		debug("Using provided message:", flags.message);
+		message = flags.message;
+	} else {
 		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:",
@@ -554,12 +892,17 @@ async function commitCommand(flags) {
 				return;
 			}
 			await setConfigValue("GROQ_API_KEY", String(key).trim());
+			debug("API key saved to config");
 		}
 		s.start("Generating commit message...");
 		try {
-			message = await generateMessage(diff.diff, flags.hint);
+			const genStart = Date.now();
+			message = await generateMessage(diffResult.diff, flags.hint);
+			debug("generateMessage took %d ms", Date.now() - genStart);
+			debug("Generated message:", message);
 		} catch (err) {
 			s.stop(red("Failed to generate message."));
+			debug("Message generation failed:", err instanceof Error ? err.message : String(err));
 			outro(red(err instanceof Error ? err.message : String(err)));
 			return;
 		}
@@ -584,10 +927,12 @@ async function commitCommand(flags) {
 		]
 	});
 	if (isCancel(review) || review === "cancel") {
+		debug("User cancelled at review step");
 		outro(dim("Cancelled."));
 		return;
 	}
 	if (review === "edit") {
+		debug("User chose to edit message");
 		const edited = await text({
 			message: "Edit commit message:",
 			initialValue: message,
@@ -598,39 +943,63 @@ async function commitCommand(flags) {
 			return;
 		}
 		message = String(edited).trim();
+		debug("Edited message:", message);
 	}
 	const { getRepoRoot } = await Promise.resolve().then(() => git_exports);
-	await saveCachedCommit(await getRepoRoot(), message);
+	const repoRoot = await getRepoRoot();
+	await saveCachedCommit(repoRoot, message);
+	debug("Message cached for repo:", repoRoot);
 	s.start("Committing...");
 	const headBefore = await getHead();
+	debug("HEAD before commit:", headBefore);
 	const result = await attemptCommit(message);
 	const headAfter = await getHead();
+	debug("HEAD after commit:", headAfter);
+	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"));
+		}
 		outro(green("Done."));
 		return;
 	}
 	s.stop("Commit failed.");
-	await showRecoveryMenu(parseHookErrors(result.stderr ?? ""), async () => {
+	debug("Commit failed, showing recovery menu");
+	const errors = parseHookErrors(result.stderr ?? "");
+	debug("Parsed hook errors:", errors.length, "errors");
+	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);
+	}, message, result.stderr ?? "");
 }
 async function generateMessage(diff, hint) {
 	const config = await readConfig();
+	const apiKey = await getApiKey();
+	debug("Generating message with model:", config.model, "type:", config.type);
 	return generateCommitMessage(diff, {
-		apiKey: await getApiKey(),
+		apiKey,
 		model: config.model,
-		maxLength: config["max-length"] ? parseInt(config["max-length"], 10) : void 0,
 		type: config.type,
 		timeout: config.timeout ? parseInt(config.timeout, 10) : void 0,
 		hint
 	});
 }
+function buildExcludedFilesMessage(files) {
+	const excludes = getDefaultExcludes();
+	const isLockfile = (f) => excludes.some((pattern) => {
+		if (pattern.endsWith(".lock") || pattern.endsWith(".json")) return f === pattern || f.endsWith(pattern.replace("*.", "."));
+		return false;
+	});
+	if (files.every(isLockfile)) return "chore: update lockfile";
+	return "chore: update generated files";
+}
 //#endregion
 //#region src/commands/config.ts
 const configCommand = command({
@@ -686,10 +1055,17 @@ cli({
 			type: String,
 			description: "Add context hint for AI commit message generation",
 			alias: "H"
+		},
+		debug: {
+			type: Boolean,
+			description: "Enable debug output",
+			alias: "d",
+			default: false
 		}
 	},
 	commands: [configCommand]
 }, (argv) => {
+	setDebug(argv.flags.debug);
 	commitCommand(argv.flags);
 });
 //#endregion