preguito 0.1.0

package/dist/cli.mjs

@@ -0,0 +1,1234 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+
+//#region src/config/types.ts
+const PREDEFINED_TYPES = [
+	{
+		key: "f",
+		label: "feat"
+	},
+	{
+		key: "x",
+		label: "fix"
+	},
+	{
+		key: "c",
+		label: "chore"
+	},
+	{
+		key: "t",
+		label: "test"
+	},
+	{
+		key: "l",
+		label: "lint"
+	},
+	{
+		key: "r",
+		label: "refactor"
+	},
+	{
+		key: "o",
+		label: "docs"
+	},
+	{
+		key: "y",
+		label: "style"
+	},
+	{
+		key: "e",
+		label: "perf"
+	},
+	{
+		key: "b",
+		label: "build"
+	}
+];
+const PREDEFINED_ENVIRONMENTS = [
+	{
+		key: "p",
+		label: "prd"
+	},
+	{
+		key: "u",
+		label: "uat"
+	},
+	{
+		key: "h",
+		label: "homolog"
+	},
+	{
+		key: "d",
+		label: "dev"
+	},
+	{
+		key: "s",
+		label: "staging"
+	}
+];
+function generateTemplate(features, hasPrefix) {
+	const { cardId, type, environment } = features;
+	return [
+		cardId ? hasPrefix ? "[{{prefix}}-{{card_id}}]" : "[{{card_id}}]" : "",
+		type && environment ? "{{type}}({{environment}}):" : type ? "{{type}}:" : environment ? "({{environment}}):" : "",
+		"<message>"
+	].filter((p) => p !== "").join(" ");
+}
+const DEFAULT_CONFIG = {
+	template: "{{type}}: <message>",
+	features: {
+		cardId: false,
+		type: true,
+		environment: false
+	},
+	types: [
+		{
+			key: "f",
+			label: "feat"
+		},
+		{
+			key: "x",
+			label: "fix"
+		},
+		{
+			key: "c",
+			label: "chore"
+		},
+		{
+			key: "t",
+			label: "test"
+		},
+		{
+			key: "r",
+			label: "refactor"
+		},
+		{
+			key: "o",
+			label: "docs"
+		}
+	],
+	environments: [],
+	defaults: {}
+};
+const CONFIG_PATHS = [
+	".preguitorc",
+	".preguitorc.json",
+	".config/preguito/config.json"
+];
+
+//#endregion
+//#region src/utils/errors.ts
+var PrequitoError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "PrequitoError";
+	}
+};
+var TemplateMissingVariableError = class extends PrequitoError {
+	missingVariables;
+	constructor(missing) {
+		super(`Missing template variable(s): ${missing.join(", ")}. Provide shortcodes or check your config.`);
+		this.name = "TemplateMissingVariableError";
+		this.missingVariables = missing;
+	}
+};
+var TemplateMissingMessageError = class extends PrequitoError {
+	constructor(placeholderName) {
+		super(`Template requires a message (the <${placeholderName}> placeholder). Provide it as the last argument(s).`);
+		this.name = "TemplateMissingMessageError";
+	}
+};
+var GitOperationError = class extends PrequitoError {
+	exitCode;
+	stderr;
+	constructor(operation, exitCode, stderr) {
+		super(`Git ${operation} failed (exit ${exitCode}): ${stderr.trim()}`);
+		this.name = "GitOperationError";
+		this.exitCode = exitCode;
+		this.stderr = stderr;
+	}
+};
+
+//#endregion
+//#region src/template/engine.ts
+const VARIABLE_PATTERN = /\{\{(\w+)\}\}/g;
+const MESSAGE_PLACEHOLDER_PATTERN = /<(\w+)>/;
+function parseTemplate(template) {
+	const variables = [];
+	let match;
+	const pattern = new RegExp(VARIABLE_PATTERN.source, "g");
+	while ((match = pattern.exec(template)) !== null) if (!variables.includes(match[1])) variables.push(match[1]);
+	const messageMatch = MESSAGE_PLACEHOLDER_PATTERN.exec(template);
+	return {
+		variables,
+		messagePlaceholder: messageMatch ? messageMatch[1] : null
+	};
+}
+function renderTemplate(template, context, message) {
+	const parsed = parseTemplate(template);
+	const missing = parsed.variables.filter((v) => !(v in context));
+	if (missing.length > 0) throw new TemplateMissingVariableError(missing);
+	let result = template.replace(/\{\{(\w+)\}\}/g, (_, varName) => {
+		return context[varName];
+	});
+	if (parsed.messagePlaceholder) {
+		if (!message) throw new TemplateMissingMessageError(parsed.messagePlaceholder);
+		result = result.replace(/<\w+>/, message);
+	}
+	return result;
+}
+function mergeContext(defaults, overrides) {
+	return {
+		...defaults,
+		...overrides
+	};
+}
+
+//#endregion
+//#region src/config/loader.ts
+async function findConfigPath() {
+	const cwd = process.cwd();
+	const home = homedir();
+	for (const relPath of [".preguitorc", ".preguitorc.json"]) {
+		const fullPath = join(cwd, relPath);
+		if (existsSync(fullPath)) return fullPath;
+	}
+	for (const relPath of CONFIG_PATHS) {
+		const fullPath = join(home, relPath);
+		if (existsSync(fullPath)) return fullPath;
+	}
+	return null;
+}
+async function loadConfig() {
+	const configPath = await findConfigPath();
+	if (!configPath) return null;
+	const raw = await readFile(configPath, "utf-8");
+	return validateConfig(JSON.parse(raw));
+}
+async function loadConfigOrDefault() {
+	return await loadConfig() ?? DEFAULT_CONFIG;
+}
+function validateConfig(obj) {
+	if (typeof obj !== "object" || obj === null) throw new Error("Config must be a JSON object");
+	const config = obj;
+	if (typeof config.template !== "string" || config.template.trim() === "") throw new Error("Config must have a non-empty \"template\" string field");
+	const defaults = {};
+	if (config.defaults !== void 0) {
+		if (typeof config.defaults !== "object" || config.defaults === null) throw new Error("\"defaults\" must be an object");
+		for (const [key, value] of Object.entries(config.defaults)) {
+			if (typeof value !== "string") throw new Error(`Default value for "${key}" must be a string`);
+			defaults[key] = value;
+		}
+	}
+	let features;
+	if (config.features && typeof config.features === "object") {
+		const f = config.features;
+		features = {
+			cardId: Boolean(f.cardId),
+			type: Boolean(f.type),
+			environment: Boolean(f.environment)
+		};
+	} else features = inferFeaturesFromTemplate(config.template);
+	let types = [];
+	if (Array.isArray(config.types)) types = validateShortcodeArray(config.types, "types");
+	else if (features.type) types = [...PREDEFINED_TYPES];
+	let environments = [];
+	if (Array.isArray(config.environments)) environments = validateShortcodeArray(config.environments, "environments");
+	else if (features.environment) environments = [...PREDEFINED_ENVIRONMENTS];
+	return {
+		template: config.template,
+		features,
+		types,
+		environments,
+		defaults
+	};
+}
+function inferFeaturesFromTemplate(template) {
+	const parsed = parseTemplate(template);
+	return {
+		cardId: parsed.variables.includes("card_id"),
+		type: parsed.variables.includes("type"),
+		environment: parsed.variables.includes("environment")
+	};
+}
+function validateShortcodeArray(arr, fieldName) {
+	const result = [];
+	for (let i = 0; i < arr.length; i++) {
+		const item = arr[i];
+		if (typeof item !== "object" || item === null || typeof item.key !== "string" || typeof item.label !== "string") throw new Error(`${fieldName}[${i}] must be an object with "key" and "label" string fields`);
+		const entry = item;
+		if (entry.key.length !== 1) throw new Error(`${fieldName}[${i}].key must be a single character, got "${entry.key}"`);
+		result.push({
+			key: entry.key,
+			label: entry.label
+		});
+	}
+	return result;
+}
+async function writeConfig(config) {
+	const configDir = join(homedir(), ".config", "preguito");
+	const configPath = join(configDir, "config.json");
+	if (!existsSync(configDir)) await mkdir(configDir, { recursive: true });
+	await writeFile(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+	return configPath;
+}
+
+//#endregion
+//#region src/commands/commit-parser.ts
+function parsePositionalArgs(args, config) {
+	if (args.length === 0) throw new PrequitoError("No arguments provided. Usage: guito c [card_id] [shortcodes] <message...>");
+	const context = {};
+	let cursor = 0;
+	if (config.features.cardId) {
+		if (cursor >= args.length) throw new PrequitoError("Missing card ID. It must be the first argument.");
+		context.card_id = args[cursor];
+		cursor++;
+	}
+	if (config.features.type || config.features.environment) {
+		if (cursor >= args.length) throw new PrequitoError("Missing shortcodes argument. Provide type/environment shortcodes.");
+		const resolved = resolveShortcodes(args[cursor], config);
+		Object.assign(context, resolved);
+		cursor++;
+	}
+	const messageParts = args.slice(cursor);
+	if (messageParts.length === 0) throw new PrequitoError("Missing commit message.");
+	const message = messageParts.join(" ");
+	return {
+		context: mergeContext(config.defaults, context),
+		message
+	};
+}
+function resolveShortcodes(shortcodesStr, config) {
+	const result = {};
+	const typeMap = /* @__PURE__ */ new Map();
+	for (const t of config.types) typeMap.set(t.key, t.label);
+	const envMap = /* @__PURE__ */ new Map();
+	for (const e of config.environments) envMap.set(e.key, e.label);
+	let foundType = false;
+	let foundEnv = false;
+	for (const char of shortcodesStr) {
+		const isType = config.features.type && typeMap.has(char);
+		const isEnv = config.features.environment && envMap.has(char);
+		if (isType && isEnv) throw new PrequitoError(`Ambiguous shortcode "${char}" matches both type "${typeMap.get(char)}" and environment "${envMap.get(char)}". Fix your config to avoid conflicts.`);
+		if (isType) {
+			if (foundType) throw new PrequitoError(`Multiple type shortcodes found in "${shortcodesStr}". Only one type allowed.`);
+			result.type = typeMap.get(char);
+			foundType = true;
+		} else if (isEnv) {
+			if (foundEnv) throw new PrequitoError(`Multiple environment shortcodes found in "${shortcodesStr}". Only one environment allowed.`);
+			result.environment = envMap.get(char);
+			foundEnv = true;
+		} else throw new PrequitoError(`Unknown shortcode "${char}" in "${shortcodesStr}". Valid: ${[...config.types.map((t) => `${t.key}=${t.label}`), ...config.environments.map((e) => `${e.key}=${e.label}`)].join(", ")}`);
+	}
+	if (config.features.type && !foundType) throw new PrequitoError(`No type shortcode found in "${shortcodesStr}". Valid types: ${config.types.map((t) => `${t.key}=${t.label}`).join(", ")}`);
+	if (config.features.environment && !foundEnv) throw new PrequitoError(`No environment shortcode found in "${shortcodesStr}". Valid environments: ${config.environments.map((e) => `${e.key}=${e.label}`).join(", ")}`);
+	return result;
+}
+
+//#endregion
+//#region src/git/operations.ts
+const execFileAsync = promisify(execFile);
+async function git(args, env) {
+	try {
+		const result = await execFileAsync("git", args, {
+			maxBuffer: 10 * 1024 * 1024,
+			env: env ? {
+				...process.env,
+				...env
+			} : void 0
+		});
+		return {
+			stdout: result.stdout,
+			stderr: result.stderr
+		};
+	} catch (error) {
+		const err = error;
+		throw new GitOperationError(args[0], err.code ?? 1, err.stderr ?? err.message ?? "Unknown git error");
+	}
+}
+async function isGitRepo() {
+	try {
+		await git(["rev-parse", "--is-inside-work-tree"]);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function getCurrentBranch() {
+	return (await git(["branch", "--show-current"])).stdout.trim();
+}
+async function hasStagedChanges() {
+	try {
+		await git([
+			"diff",
+			"--cached",
+			"--quiet"
+		]);
+		return false;
+	} catch {
+		return true;
+	}
+}
+async function stageAll() {
+	await git(["add", "-A"]);
+}
+async function commit(message) {
+	return (await git([
+		"commit",
+		"-m",
+		message
+	])).stdout;
+}
+async function commitAmend() {
+	return (await git([
+		"commit",
+		"--amend",
+		"--no-edit"
+	])).stdout;
+}
+async function push() {
+	const result = await git(["push"]);
+	return result.stdout + result.stderr;
+}
+async function forcePush() {
+	const result = await git(["push", "--force"]);
+	return result.stdout + result.stderr;
+}
+async function forcePushLease() {
+	const result = await git(["push", "--force-with-lease"]);
+	return result.stdout + result.stderr;
+}
+async function checkout(branch) {
+	await git(["checkout", branch]);
+}
+async function pull() {
+	const result = await git(["pull"]);
+	return result.stdout + result.stderr;
+}
+async function rebase(branch) {
+	const result = await git(["rebase", branch]);
+	return result.stdout + result.stderr;
+}
+async function rebaseInteractiveEdit(hash) {
+	const sedCmd = `sed -i 's/^pick ${hash.slice(0, 7)}/edit ${hash.slice(0, 7)}/'`;
+	const result = await git([
+		"rebase",
+		"-i",
+		`${hash}^`
+	], { GIT_SEQUENCE_EDITOR: sedCmd });
+	return result.stdout + result.stderr;
+}
+async function status() {
+	return (await git(["status", "--short"])).stdout;
+}
+async function gitInteractive(args) {
+	return new Promise((resolve, reject) => {
+		spawn("git", args, { stdio: "inherit" }).on("close", (code) => {
+			if (code === 0) resolve();
+			else reject(new GitOperationError(args[0], code ?? 1, "Interactive git command failed"));
+		});
+	});
+}
+async function rebaseInteractive(count) {
+	await gitInteractive([
+		"rebase",
+		"-i",
+		`HEAD~${count}`
+	]);
+}
+async function pushUpstream$1(branch) {
+	const result = await git([
+		"push",
+		"--set-upstream",
+		"origin",
+		branch ?? await getCurrentBranch()
+	]);
+	return result.stdout + result.stderr;
+}
+async function commitFixup(hash) {
+	return (await git([
+		"commit",
+		"--fixup",
+		hash
+	])).stdout;
+}
+async function resetSoft(count = 1) {
+	return (await git([
+		"reset",
+		"--soft",
+		`HEAD~${count}`
+	])).stdout;
+}
+async function createBranch(branch) {
+	await git([
+		"checkout",
+		"-b",
+		branch
+	]);
+}
+async function stash() {
+	return (await git(["stash"])).stdout;
+}
+async function stashPop() {
+	return (await git(["stash", "pop"])).stdout;
+}
+async function logOneline(count = 10) {
+	return (await git([
+		"log",
+		"--oneline",
+		"-n",
+		String(count)
+	])).stdout;
+}
+async function logGrep(keyword, count) {
+	const args = [
+		"log",
+		"--oneline",
+		"--all",
+		`--grep=${keyword}`
+	];
+	if (count) args.push("-n", String(count));
+	return (await git(args)).stdout;
+}
+async function logTag(tag) {
+	return (await git([
+		"log",
+		"--oneline",
+		`${tag}..HEAD`
+	])).stdout;
+}
+async function logTagAll(tag) {
+	return (await git([
+		"log",
+		"--oneline",
+		tag
+	])).stdout;
+}
+
+//#endregion
+//#region src/commands/commit.ts
+function registerCommitCommand(program) {
+	program.command("c").alias("commit").description("Create a commit using your template").argument("[args...]", "Card ID, shortcodes, and message").option("-p, --push", "Push after committing").option("-f, --force", "Push with --force-with-lease after committing").option("-d, --dry-run", "Show the generated message without executing").option("-S, --no-stage", "Skip auto-staging (git add -A)").action(async (args, opts) => {
+		try {
+			await executeCommit(args, opts);
+		} catch (error) {
+			if (error instanceof PrequitoError) {
+				console.error(`\u2716 ${error.message}`);
+				process.exit(1);
+			}
+			throw error;
+		}
+	});
+}
+async function executeCommit(args, opts) {
+	if (!await isGitRepo()) {
+		console.error("✖ Not inside a git repository.");
+		process.exit(1);
+	}
+	const config = await loadConfigOrDefault();
+	const { context, message } = parsePositionalArgs(args, config);
+	const commitMessage = renderTemplate(config.template, context, message);
+	if (opts.dryRun) {
+		console.log(commitMessage);
+		return;
+	}
+	if (opts.stage !== false) await stageAll();
+	if (!await hasStagedChanges()) {
+		console.error("✖ No staged changes to commit.");
+		process.exit(1);
+	}
+	console.log(`\u2192 Committing: ${commitMessage}`);
+	await commit(commitMessage);
+	console.log("✔ Committed.");
+	if (opts.force) {
+		console.log("→ Pushing (--force-with-lease)...");
+		await forcePushLease();
+		console.log("✔ Pushed.");
+	} else if (opts.push) {
+		console.log("→ Pushing...");
+		await push();
+		console.log("✔ Pushed.");
+	}
+}
+
+//#endregion
+//#region src/commands/amend-push.ts
+function registerAmendPushCommands(program) {
+	program.command("ap").description("Amend last commit + git push --force").action(async () => {
+		try {
+			await amendAndPush(false);
+		} catch (error) {
+			if (error instanceof PrequitoError) {
+				console.error(`✖ ${error.message}`);
+				process.exit(1);
+			}
+			throw error;
+		}
+	});
+	program.command("apl").description("Amend last commit + git push --force-with-lease").action(async () => {
+		try {
+			await amendAndPush(true);
+		} catch (error) {
+			if (error instanceof PrequitoError) {
+				console.error(`✖ ${error.message}`);
+				process.exit(1);
+			}
+			throw error;
+		}
+	});
+}
+async function amendAndPush(useLease) {
+	if (!await isGitRepo()) {
+		console.error("✖ Not inside a git repository.");
+		process.exit(1);
+	}
+	console.log("→ Staging all changes...");
+	await stageAll();
+	console.log("→ Amending last commit...");
+	await commitAmend();
+	console.log("✔ Amended.");
+	if (useLease) {
+		console.log("→ Pushing (--force-with-lease)...");
+		await forcePushLease();
+	} else {
+		console.log("→ Pushing (--force)...");
+		await forcePush();
+	}
+	console.log("✔ Pushed.");
+}
+
+//#endregion
+//#region src/commands/rebase.ts
+function registerRebaseCommands(program) {
+	program.command("r <branch>").alias("rebase").description("Quick rebase: checkout <branch>, pull, come back, rebase on top").action(async (branch) => {
+		try {
+			await quickRebase(branch);
+		} catch (error) {
+			if (error instanceof PrequitoError) {
+				console.error(`✖ ${error.message}`);
+				process.exit(1);
+			}
+			throw error;
+		}
+	});
+	program.command("ri <count>").description("Interactive rebase: open editor for the last <count> commits").action(async (count) => {
+		try {
+			await interactiveRebase(count);
+		} catch (error) {
+			if (error instanceof PrequitoError) {
+				console.error(`✖ ${error.message}`);
+				process.exit(1);
+			}
+			throw error;
+		}
+	});
+	program.command("re <hash>").description("Edit rebase: start interactive rebase with commit marked as edit").action(async (hash) => {
+		try {
+			await editRebase(hash);
+		} catch (error) {
+			if (error instanceof PrequitoError) {
+				console.error(`✖ ${error.message}`);
+				process.exit(1);
+			}
+			throw error;
+		}
+	});
+}
+async function quickRebase(branch) {
+	if (!await isGitRepo()) {
+		console.error("✖ Not inside a git repository.");
+		process.exit(1);
+	}
+	const currentBranch = await getCurrentBranch();
+	console.log(`→ Current branch: ${currentBranch}`);
+	console.log(`→ Checking out ${branch}...`);
+	await checkout(branch);
+	console.log(`→ Pulling ${branch}...`);
+	await pull();
+	console.log(`→ Checking out ${currentBranch}...`);
+	await checkout(currentBranch);
+	console.log(`→ Rebasing ${currentBranch} onto ${branch}...`);
+	await rebase(branch);
+	console.log("✔ Rebase complete.");
+}
+async function interactiveRebase(count) {
+	if (!await isGitRepo()) {
+		console.error("✖ Not inside a git repository.");
+		process.exit(1);
+	}
+	const num = parseInt(count, 10);
+	if (isNaN(num) || num <= 0) {
+		console.error("✖ Count must be a positive integer.");
+		process.exit(1);
+	}
+	console.log(`→ Starting interactive rebase for the last ${num} commit(s)...`);
+	await rebaseInteractive(num);
+}
+async function editRebase(hash) {
+	if (!await isGitRepo()) {
+		console.error("✖ Not inside a git repository.");
+		process.exit(1);
+	}
+	console.log(`→ Starting edit rebase on commit ${hash}...`);
+	await rebaseInteractiveEdit(hash);
+	console.log("✔ Rebase paused at the target commit. Make your changes, then run:");
+	console.log("  git add . && git rebase --continue");
+}
+
+//#endregion
+//#region src/commands/usage-examples.ts
+function printUsageExamples(config) {
+	console.log("\n  📖 Examples:\n");
+	const { features, types, environments, defaults } = config;
+	const exType = types[0];
+	const exEnv = environments[0];
+	const exCardId = "1234";
+	const exMessage = "add login endpoint";
+	if (features.cardId && features.type && features.environment && exType && exEnv) {
+		const shortcodes = `${exType.key}${exEnv.key}`;
+		const context = mergeContext(defaults, {
+			card_id: exCardId,
+			type: exType.label,
+			environment: exEnv.label
+		});
+		const rendered = renderTemplate(config.template, context, exMessage);
+		console.log(`     $ guito c ${exCardId} ${shortcodes} "${exMessage}"`);
+		console.log(`     → ${rendered}`);
+		if (types.length > 1 && environments.length > 1) {
+			const t2 = types[1];
+			const e2 = environments[1];
+			const ctx2 = mergeContext(defaults, {
+				card_id: "5678",
+				type: t2.label,
+				environment: e2.label
+			});
+			const r2 = renderTemplate(config.template, ctx2, "fix timeout bug");
+			console.log(`\n     $ guito c 5678 ${t2.key}${e2.key} "fix timeout bug"`);
+			console.log(`     → ${r2}`);
+		}
+	} else if (features.cardId && features.type && exType) {
+		const context = mergeContext(defaults, {
+			card_id: exCardId,
+			type: exType.label
+		});
+		const rendered = renderTemplate(config.template, context, exMessage);
+		console.log(`     $ guito c ${exCardId} ${exType.key} "${exMessage}"`);
+		console.log(`     → ${rendered}`);
+	} else if (features.cardId && features.environment && exEnv) {
+		const context = mergeContext(defaults, {
+			card_id: exCardId,
+			environment: exEnv.label
+		});
+		const rendered = renderTemplate(config.template, context, exMessage);
+		console.log(`     $ guito c ${exCardId} ${exEnv.key} "${exMessage}"`);
+		console.log(`     → ${rendered}`);
+	} else if (features.type && features.environment && exType && exEnv) {
+		const context = {
+			type: exType.label,
+			environment: exEnv.label
+		};
+		const rendered = renderTemplate(config.template, context, exMessage);
+		console.log(`     $ guito c ${exType.key}${exEnv.key} "${exMessage}"`);
+		console.log(`     → ${rendered}`);
+	} else if (features.type && exType) {
+		const context = { type: exType.label };
+		const rendered = renderTemplate(config.template, context, exMessage);
+		console.log(`     $ guito c ${exType.key} "${exMessage}"`);
+		console.log(`     → ${rendered}`);
+	} else if (features.cardId) {
+		const context = mergeContext(defaults, { card_id: exCardId });
+		const rendered = renderTemplate(config.template, context, exMessage);
+		console.log(`     $ guito c ${exCardId} "${exMessage}"`);
+		console.log(`     → ${rendered}`);
+	} else {
+		console.log(`     $ guito c "${exMessage}"`);
+		console.log(`     → ${exMessage}`);
+	}
+	console.log("\n     Flags: -p (push)  -f (force push)  -d (dry-run)  -S (skip staging)");
+}
+
+//#endregion
+//#region src/commands/init.ts
+function registerInitCommand(program) {
+	program.command("i").alias("init").description("Interactive setup to create your preguito config").option("--default", "Use default config without prompts").action(async (opts) => {
+		if (opts.default) {
+			const path = await writeConfig(DEFAULT_CONFIG);
+			console.log(`✅ Config written to ${path}`);
+			return;
+		}
+		await interactiveInit();
+	});
+}
+async function interactiveInit() {
+	const rl = createInterface({
+		input: stdin,
+		output: stdout
+	});
+	try {
+		console.log("\n✨ Welcome to preguito setup!\n");
+		console.log("📋 Choose which features to enable:\n");
+		const features = {
+			cardId: await askYesNo(rl, "  🎫 Include card/ticket ID in commits?"),
+			type: await askYesNo(rl, "  🏷️  Include commit type (feat, fix, chore...)?"),
+			environment: await askYesNo(rl, "  🌍 Include environment (prd, uat, dev...)?")
+		};
+		const defaults = {};
+		if (features.cardId) {
+			const prefix = await rl.question("\n🔤 Project prefix/sigla (e.g. PROJ, leave empty to skip): ");
+			if (prefix.trim()) defaults.prefix = prefix.trim().toUpperCase();
+		}
+		const hasPrefix = "prefix" in defaults;
+		let types = [];
+		if (features.type) {
+			console.log("\n🏷️  Available commit types:\n");
+			for (const t of PREDEFINED_TYPES) console.log(`   ${t.key} → ${t.label}`);
+			types = selectEntries(PREDEFINED_TYPES, await rl.question("\n  Which types? (comma-separated labels, or 'all'): "));
+			if (types.length === 0) {
+				console.log("  ℹ️  No valid types selected, using all.");
+				types = [...PREDEFINED_TYPES];
+			}
+			console.log("\n✏️  Customize shortcode letters (Enter to keep default):\n");
+			types = await customizeKeys(rl, types);
+		}
+		let environments = [];
+		if (features.environment) {
+			console.log("\n🌍 Available environments:\n");
+			for (const e of PREDEFINED_ENVIRONMENTS) console.log(`   ${e.key} → ${e.label}`);
+			environments = selectEntries(PREDEFINED_ENVIRONMENTS, await rl.question("\n  Which environments? (comma-separated labels, or 'all'): "));
+			if (environments.length === 0) {
+				console.log("  ℹ️  No valid environments selected, using all.");
+				environments = [...PREDEFINED_ENVIRONMENTS];
+			}
+			console.log("\n✏️  Customize shortcode letters (Enter to keep default):\n");
+			environments = await customizeKeys(rl, environments);
+		}
+		if (features.type && features.environment) {
+			let conflicts = findKeyConflicts(types, environments);
+			while (conflicts.length > 0) {
+				console.log("\n⚠️  Letter conflicts detected:\n");
+				for (const c of conflicts) console.log(`   "${c.key}" is used for both type "${c.typeLabel}" and environment "${c.envLabel}"`);
+				console.log("\n  Reassign letters for the conflicting types:\n");
+				for (const c of conflicts) {
+					const newKey = (await rl.question(`   ${c.typeLabel} [${c.key}]: `)).trim().toLowerCase();
+					if (newKey && newKey.length === 1 && /^[a-z]$/.test(newKey)) {
+						const entry = types.find((t) => t.key === c.key && t.label === c.typeLabel);
+						if (entry) entry.key = newKey;
+					}
+				}
+				conflicts = findKeyConflicts(types, environments);
+			}
+		}
+		const template = generateTemplate(features, hasPrefix);
+		const config = {
+			template,
+			features,
+			types,
+			environments,
+			defaults
+		};
+		const path = await writeConfig(config);
+		console.log("\n─────────────────────────────────────");
+		console.log("✅ Setup complete!\n");
+		console.log(`  📄 Config saved to ${path}`);
+		console.log(`  📝 Template: ${template}`);
+		if (types.length > 0 || environments.length > 0) {
+			console.log("\n  🔑 Your shortcodes:");
+			if (types.length > 0) console.log(`     Types: ${types.map((t) => `${t.key}=${t.label}`).join(", ")}`);
+			if (environments.length > 0) console.log(`     Envs:  ${environments.map((e) => `${e.key}=${e.label}`).join(", ")}`);
+		}
+		printUsageExamples(config);
+		console.log("\n  💡 Run 'guito cfg' to view your config anytime.");
+		console.log("─────────────────────────────────────\n");
+	} finally {
+		rl.close();
+	}
+}
+async function askYesNo(rl, question) {
+	return (await rl.question(`${question} (y/n): `)).trim().toLowerCase().startsWith("y");
+}
+function selectEntries(predefined, input) {
+	const trimmed = input.trim().toLowerCase();
+	if (trimmed === "all" || trimmed === "") return [...predefined];
+	const requested = trimmed.split(",").map((s) => s.trim());
+	return predefined.filter((entry) => requested.includes(entry.label) || requested.includes(entry.key));
+}
+async function customizeKeys(rl, entries) {
+	const result = [];
+	const usedKeys = /* @__PURE__ */ new Set();
+	for (const entry of entries) {
+		let key = (await rl.question(`   ${entry.label} [${entry.key}]: `)).trim().toLowerCase();
+		if (!key) key = entry.key;
+		if (key.length !== 1 || !/^[a-z]$/.test(key)) {
+			console.log(`   ⚠️  Invalid key "${key}", keeping "${entry.key}".`);
+			key = entry.key;
+		}
+		if (usedKeys.has(key)) {
+			console.log(`   ⚠️  Key "${key}" already used, keeping "${entry.key}".`);
+			key = entry.key;
+		}
+		usedKeys.add(key);
+		result.push({
+			key,
+			label: entry.label
+		});
+	}
+	return result;
+}
+function findKeyConflicts(types, environments) {
+	const typeMap = new Map(types.map((t) => [t.key, t.label]));
+	const conflicts = [];
+	for (const env of environments) if (typeMap.has(env.key)) conflicts.push({
+		key: env.key,
+		typeLabel: typeMap.get(env.key),
+		envLabel: env.label
+	});
+	return conflicts;
+}
+
+//#endregion
+//#region src/commands/config.ts
+function registerConfigCommand(program) {
+	program.command("cfg").alias("config").description("Show current preguito configuration").option("--path", "Show only the config file path").option("--template", "Show only the template").action(async (opts) => {
+		const config = await loadConfig();
+		if (!config) {
+			console.log("No config found. Run \"guito i\" to create one.");
+			return;
+		}
+		if (opts.path) {
+			const path = await findConfigPath();
+			console.log(path);
+			return;
+		}
+		if (opts.template) {
+			console.log(config.template);
+			return;
+		}
+		const configPath = await findConfigPath();
+		console.log(`Config file: ${configPath}`);
+		console.log(`Template: ${config.template}`);
+		console.log("Features:");
+		console.log(`  Card ID: ${config.features.cardId ? "enabled" : "disabled"}`);
+		console.log(`  Commit type: ${config.features.type ? "enabled" : "disabled"}`);
+		console.log(`  Environment: ${config.features.environment ? "enabled" : "disabled"}`);
+		if (config.defaults.prefix) console.log(`Prefix: ${config.defaults.prefix}`);
+		if (config.types.length > 0) {
+			console.log("Types:");
+			for (const t of config.types) console.log(`  ${t.key} = ${t.label}`);
+		}
+		if (config.environments.length > 0) {
+			console.log("Environments:");
+			for (const e of config.environments) console.log(`  ${e.key} = ${e.label}`);
+		}
+		printUsageExamples(config);
+	});
+}
+
+//#endregion
+//#region src/commands/push.ts
+function registerPushCommands(program) {
+	program.command("pu").description("Push current branch and set upstream tracking").action(async () => {
+		try {
+			await pushUpstream();
+		} catch (error) {
+			if (error instanceof PrequitoError) {
+				console.error(`✖ ${error.message}`);
+				process.exit(1);
+			}
+			throw error;
+		}
+	});
+}
+async function pushUpstream() {
+	if (!await isGitRepo()) {
+		console.error("✖ Not inside a git repository.");
+		process.exit(1);
+	}
+	const branch = await getCurrentBranch();
+	console.log(`→ Pushing with --set-upstream origin ${branch}...`);
+	await pushUpstream$1(branch);
+	console.log("✔ Pushed.");
+}
+
+//#endregion
+//#region src/commands/fixup.ts
+function registerFixupCommand(program) {
+	program.command("cf <hash>").description("Create a fixup commit targeting a specific commit").option("-p, --push", "Push after creating the fixup commit").option("-f, --force", "Push with --force-with-lease after creating").action(async (hash, opts) => {
+		try {
+			await executeFixup(hash, opts);
+		} catch (error) {
+			if (error instanceof PrequitoError) {
+				console.error(`✖ ${error.message}`);
+				process.exit(1);
+			}
+			throw error;
+		}
+	});
+}
+async function executeFixup(hash, opts) {
+	if (!await isGitRepo()) {
+		console.error("✖ Not inside a git repository.");
+		process.exit(1);
+	}
+	console.log("→ Staging all changes...");
+	await stageAll();
+	if (!await hasStagedChanges()) {
+		console.error("✖ No staged changes to commit.");
+		process.exit(1);
+	}
+	console.log(`→ Creating fixup commit for ${hash}...`);
+	await commitFixup(hash);
+	console.log("✔ Fixup commit created.");
+	if (opts.force) {
+		console.log("→ Pushing (--force-with-lease)...");
+		await forcePushLease();
+		console.log("✔ Pushed.");
+	} else if (opts.push) {
+		console.log("→ Pushing...");
+		await push();
+		console.log("✔ Pushed.");
+	}
+}
+
+//#endregion
+//#region src/commands/undo.ts
+function registerUndoCommand(program) {
+	program.command("u [count]").alias("undo").description("Undo the last N commits (soft reset, changes stay staged)").action(async (count) => {
+		try {
+			await executeUndo(count);
+		} catch (error) {
+			if (error instanceof PrequitoError) {
+				console.error(`✖ ${error.message}`);
+				process.exit(1);
+			}
+			throw error;
+		}
+	});
+}
+async function executeUndo(count) {
+	if (!await isGitRepo()) {
+		console.error("✖ Not inside a git repository.");
+		process.exit(1);
+	}
+	const num = count ? parseInt(count, 10) : 1;
+	if (isNaN(num) || num <= 0) {
+		console.error("✖ Count must be a positive integer.");
+		process.exit(1);
+	}
+	console.log(`→ Undoing last ${num} commit(s)...`);
+	await resetSoft(num);
+	console.log(`✔ Undid last ${num} commit(s). Changes are staged.`);
+	const st = await status();
+	if (st) console.log(st);
+}
+
+//#endregion
+//#region src/commands/status.ts
+function registerStatusCommand(program) {
+	program.command("s").alias("status").description("Show short git status").action(async () => {
+		try {
+			await executeStatus();
+		} catch (error) {
+			if (error instanceof PrequitoError) {
+				console.error(`✖ ${error.message}`);
+				process.exit(1);
+			}
+			throw error;
+		}
+	});
+}
+async function executeStatus() {
+	if (!await isGitRepo()) {
+		console.error("✖ Not inside a git repository.");
+		process.exit(1);
+	}
+	const output = await status();
+	if (output) console.log(output.trimEnd());
+	else console.log("✨ Nothing to commit, working tree clean.");
+}
+
+//#endregion
+//#region src/commands/switch.ts
+function registerSwitchCommand(program) {
+	program.command("sw <branch>").alias("switch").description("Switch branches (use -n to create a new branch)").option("-n, --new", "Create a new branch").action(async (branch, opts) => {
+		try {
+			await executeSwitch(branch, opts);
+		} catch (error) {
+			if (error instanceof PrequitoError) {
+				console.error(`✖ ${error.message}`);
+				process.exit(1);
+			}
+			throw error;
+		}
+	});
+}
+async function executeSwitch(branch, opts) {
+	if (!await isGitRepo()) {
+		console.error("✖ Not inside a git repository.");
+		process.exit(1);
+	}
+	if (opts.new) {
+		console.log(`→ Creating and switching to ${branch}...`);
+		await createBranch(branch);
+	} else {
+		console.log(`→ Switching to ${branch}...`);
+		await checkout(branch);
+	}
+	console.log(`✔ On branch ${branch}.`);
+}
+
+//#endregion
+//#region src/commands/stash.ts
+function registerStashCommands(program) {
+	program.command("st").description("Stash all changes").action(async () => {
+		try {
+			await executeStash();
+		} catch (error) {
+			if (error instanceof PrequitoError) {
+				console.error(`✖ ${error.message}`);
+				process.exit(1);
+			}
+			throw error;
+		}
+	});
+	program.command("stp").description("Pop the latest stash").action(async () => {
+		try {
+			await executeStashPop();
+		} catch (error) {
+			if (error instanceof PrequitoError) {
+				console.error(`✖ ${error.message}`);
+				process.exit(1);
+			}
+			throw error;
+		}
+	});
+}
+async function executeStash() {
+	if (!await isGitRepo()) {
+		console.error("✖ Not inside a git repository.");
+		process.exit(1);
+	}
+	const output = await stash();
+	console.log(output.trimEnd());
+}
+async function executeStashPop() {
+	if (!await isGitRepo()) {
+		console.error("✖ Not inside a git repository.");
+		process.exit(1);
+	}
+	const output = await stashPop();
+	console.log(output.trimEnd());
+}
+
+//#endregion
+//#region src/commands/log.ts
+function registerLogCommand(program) {
+	program.command("l [count]").alias("log").description("Show compact git log (default: last 10 commits)").action(async (count) => {
+		try {
+			await executeLog(count);
+		} catch (error) {
+			if (error instanceof PrequitoError) {
+				console.error(`✖ ${error.message}`);
+				process.exit(1);
+			}
+			throw error;
+		}
+	});
+}
+async function executeLog(count) {
+	if (!await isGitRepo()) {
+		console.error("✖ Not inside a git repository.");
+		process.exit(1);
+	}
+	const num = count ? parseInt(count, 10) : 10;
+	if (isNaN(num) || num <= 0) {
+		console.error("✖ Count must be a positive integer.");
+		process.exit(1);
+	}
+	const output = await logOneline(num);
+	if (output) console.log(output.trimEnd());
+	else console.log("✨ No commits found.");
+}
+
+//#endregion
+//#region src/commands/find.ts
+function registerFindCommands(program) {
+	program.command("f <keyword>").alias("find").description("Search commits by message keyword").option("-n, --number <count>", "Limit number of results").action(async (keyword, opts) => {
+		try {
+			await executeFind(keyword, opts);
+		} catch (error) {
+			if (error instanceof PrequitoError) {
+				console.error(`✖ ${error.message}`);
+				process.exit(1);
+			}
+			throw error;
+		}
+	});
+	program.command("t <tag>").alias("tag").description("Show commits for a tag (default: tag..HEAD, --all: all commits reachable from tag)").option("-a, --all", "Show all commits reachable from the tag").action(async (tag, opts) => {
+		try {
+			await executeTag(tag, opts);
+		} catch (error) {
+			if (error instanceof PrequitoError) {
+				console.error(`✖ ${error.message}`);
+				process.exit(1);
+			}
+			throw error;
+		}
+	});
+}
+async function executeFind(keyword, opts) {
+	if (!await isGitRepo()) {
+		console.error("✖ Not inside a git repository.");
+		process.exit(1);
+	}
+	const count = opts.number ? parseInt(opts.number, 10) : void 0;
+	const output = await logGrep(keyword, count);
+	if (output) console.log(output.trimEnd());
+	else console.log(`✨ No commits found matching "${keyword}".`);
+}
+async function executeTag(tag, opts) {
+	if (!await isGitRepo()) {
+		console.error("✖ Not inside a git repository.");
+		process.exit(1);
+	}
+	if (opts.all) {
+		console.log(`Commits reachable from ${tag}:`);
+		const output = await logTagAll(tag);
+		if (output) console.log(output.trimEnd());
+		else console.log("✨ No commits found.");
+	} else {
+		console.log(`Commits since ${tag}:`);
+		const output = await logTag(tag);
+		if (output) console.log(output.trimEnd());
+		else console.log("✨ No commits since this tag.");
+	}
+}
+
+//#endregion
+//#region src/cli.ts
+const program = new Command();
+program.name("guito").description("preguito - a lazy git CLI with commit templates and shortcuts").version("0.1.0");
+registerCommitCommand(program);
+registerAmendPushCommands(program);
+registerRebaseCommands(program);
+registerInitCommand(program);
+registerConfigCommand(program);
+registerPushCommands(program);
+registerFixupCommand(program);
+registerUndoCommand(program);
+registerStatusCommand(program);
+registerSwitchCommand(program);
+registerStashCommands(program);
+registerLogCommand(program);
+registerFindCommands(program);
+program.parse();
+
+//#endregion
+export {  };