gatecheck 0.0.1-beta.5

package/dist/bin.mjs

@@ -0,0 +1,722 @@
+#!/usr/bin/env node
+import { Command, Option } from "commander";
+import { readFile } from "node:fs/promises";
+import { matchesGlob, relative, resolve } from "node:path";
+import * as v from "valibot";
+import { parse } from "yaml";
+import { execFile, spawn } from "node:child_process";
+
+//#region package.json
+var version = "0.0.1-beta.5";
+var description = "Quality gate for git changes — run checks and AI reviews against changed files";
+
+//#endregion
+//#region src/config.ts
+const RegexStringSchema = v.pipe(v.string(), v.check((value) => {
+	try {
+		new RegExp(value);
+		return true;
+	} catch {
+		return false;
+	}
+}, "Invalid regular expression"));
+const ChangedFilesSchema = v.object({
+	separator: v.optional(v.string()),
+	path: v.optional(v.picklist(["relative", "absolute"]))
+});
+const CheckEntrySchema = v.object({
+	name: v.string(),
+	match: RegexStringSchema,
+	exclude: v.optional(v.string()),
+	group: v.string(),
+	command: v.string(),
+	changedFiles: v.optional(ChangedFilesSchema)
+});
+const ReviewEntrySchema = v.object({
+	name: v.string(),
+	match: RegexStringSchema,
+	exclude: v.optional(v.string()),
+	vars: v.optional(v.record(v.string(), v.string())),
+	command: v.string(),
+	fallbacks: v.optional(v.array(v.string()))
+});
+const DefaultsSchema = v.object({
+	changed: v.optional(v.string()),
+	target: v.optional(v.string())
+});
+const GatecheckConfigSchema = v.object({
+	defaults: v.optional(DefaultsSchema),
+	checks: v.optional(v.array(CheckEntrySchema)),
+	reviews: v.optional(v.array(ReviewEntrySchema))
+});
+const CONFIG_FILENAME = "gatecheck.yaml";
+const resolveConfigPath = (cwd) => resolve(cwd, CONFIG_FILENAME);
+var ConfigNotFoundError = class extends Error {
+	constructor(configPath) {
+		super(`Config file not found: ${configPath}\nRun \`gatecheck setup\` to create one.`);
+		this.name = "ConfigNotFoundError";
+	}
+};
+const loadConfig = async (cwd) => {
+	const configPath = resolveConfigPath(cwd);
+	let raw;
+	try {
+		raw = await readFile(configPath, "utf-8");
+	} catch (err) {
+		if (err instanceof Error && "code" in err && err.code === "ENOENT") throw new ConfigNotFoundError(configPath);
+		throw err;
+	}
+	const parsed = parse(raw);
+	return v.parse(GatecheckConfigSchema, parsed);
+};
+
+//#endregion
+//#region src/git.ts
+const exec = (cmd, args, cwd) => new Promise((res, rej) => {
+	execFile(cmd, [...args], { cwd }, (error, stdout) => {
+		if (error) {
+			rej(error);
+			return;
+		}
+		res(stdout);
+	});
+});
+const gitCommandForSource = (source) => {
+	switch (source.type) {
+		case "untracked": return [
+			"ls-files",
+			"--others",
+			"--exclude-standard"
+		];
+		case "unstaged": return [
+			"diff",
+			"--name-only",
+			"--diff-filter=d"
+		];
+		case "staged": return [
+			"diff",
+			"--cached",
+			"--name-only",
+			"--diff-filter=d"
+		];
+		case "branch": return [
+			"diff",
+			"--name-only",
+			"--diff-filter=d",
+			`${source.name}...HEAD`
+		];
+		case "sha": return [
+			"diff",
+			"--name-only",
+			"--diff-filter=d",
+			`${source.sha}...HEAD`
+		];
+		default: {
+			const _exhaustive = source;
+			throw new Error(`Unknown source type: ${JSON.stringify(_exhaustive)}`);
+		}
+	}
+};
+const parseFileList = (output) => output.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+const describeSource = (source) => {
+	switch (source.type) {
+		case "untracked": return "untracked files";
+		case "unstaged": return "unstaged changes";
+		case "staged": return "staged changes";
+		case "branch": return `branch '${source.name}'`;
+		case "sha": return `sha '${source.sha}'`;
+		default: {
+			const _exhaustive = source;
+			throw new Error(`Unknown source type: ${JSON.stringify(_exhaustive)}`);
+		}
+	}
+};
+const getDiffSummary = async (sources, cwd) => {
+	return (await Promise.all(sources.map(async (source) => {
+		const args = gitCommandForSource(source).filter((a) => a !== "--name-only");
+		try {
+			return await exec("git", args, cwd);
+		} catch (error) {
+			const detail = error instanceof Error ? error.message : String(error);
+			throw new Error(`Failed to get diff for ${describeSource(source)}: ${detail}`);
+		}
+	}))).filter((r) => r.trim().length > 0).join("\n");
+};
+const getChangedFiles = async (sources, cwd) => {
+	const results = await Promise.all(sources.map(async (source) => {
+		const args = gitCommandForSource(source);
+		try {
+			return parseFileList(await exec("git", args, cwd));
+		} catch (error) {
+			const detail = error instanceof Error ? error.message : String(error);
+			throw new Error(`Failed to get changed files for ${describeSource(source)}: ${detail}`);
+		}
+	}));
+	const seen = /* @__PURE__ */ new Set();
+	const files = [];
+	for (const list of results) for (const file of list) {
+		const abs = resolve(cwd, file);
+		if (!seen.has(abs)) {
+			seen.add(abs);
+			files.push(abs);
+		}
+	}
+	return files;
+};
+
+//#endregion
+//#region src/logger.ts
+const log = (message) => {
+	process.stdout.write(`${message}\n`);
+};
+const logError = (message) => {
+	process.stderr.write(`${message}\n`);
+};
+
+//#endregion
+//#region src/matcher.ts
+const matchFiles = (files, match, cwd, exclude) => {
+	const matchRegex = new RegExp(match);
+	const results = [];
+	for (const file of files) {
+		const rel = relative(cwd, file);
+		if (exclude !== void 0 && matchesGlob(rel, exclude)) continue;
+		const m = matchRegex.exec(rel);
+		if (!m) continue;
+		const groups = {};
+		if (m.groups) {
+			for (const [key, value] of Object.entries(m.groups)) if (value !== void 0) groups[key] = value;
+		}
+		results.push({
+			file,
+			groups
+		});
+	}
+	return results;
+};
+const groupMatchResults = (results) => {
+	const map = /* @__PURE__ */ new Map();
+	for (const result of results) {
+		const keyParts = Object.values(result.groups);
+		const key = keyParts.length > 0 ? keyParts.join("/") : "";
+		const existing = map.get(key);
+		if (existing) existing.files.push(result.file);
+		else map.set(key, {
+			groups: result.groups,
+			files: [result.file]
+		});
+	}
+	return map;
+};
+
+//#endregion
+//#region src/template.ts
+const TEMPLATE_PATTERN = /\{\{\s*(\w+)\.(\w+)\s*\}\}/g;
+const lookupValue = (scope, key, context) => {
+	switch (scope) {
+		case "env": return context.env[key];
+		case "match": return context.match[key];
+		case "ctx": return context.ctx[key];
+		case "vars": return context.vars[key];
+		default: return;
+	}
+};
+const resolveTemplate = (template, context) => template.replaceAll(TEMPLATE_PATTERN, (original, scope, key) => {
+	return lookupValue(scope, key, context) ?? original;
+});
+const resolveVars = (vars, baseContext) => {
+	const resolved = {};
+	const contextForVars = {
+		...baseContext,
+		vars: {}
+	};
+	for (const [key, value] of Object.entries(vars)) resolved[key] = resolveTemplate(value, contextForVars);
+	return resolved;
+};
+const resolve$1 = (template, context) => resolveTemplate(template, context);
+const resolveCommand = (template, context) => template.replaceAll(TEMPLATE_PATTERN, (original, scope, key) => {
+	const value = lookupValue(scope, key, context);
+	if (value === void 0) return original;
+	return scope === "vars" ? shellEscape(value) : value;
+});
+const getEnv = () => process.env;
+const shellEscape = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+const buildContext = (overrides) => ({
+	env: getEnv(),
+	match: overrides.match ?? {},
+	ctx: overrides.ctx ?? {},
+	vars: overrides.vars ?? {}
+});
+
+//#endregion
+//#region src/runner.ts
+const runCommand = (command, cwd) => new Promise((res) => {
+	const child = spawn("sh", ["-c", command], {
+		cwd,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	});
+	const stdoutChunks = [];
+	const stderrChunks = [];
+	child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
+	child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+	child.on("close", (code) => {
+		res({
+			exitCode: code ?? 1,
+			stdout: Buffer.concat(stdoutChunks).toString(),
+			stderr: Buffer.concat(stderrChunks).toString()
+		});
+	});
+});
+const formatFileList = (files, cwd, changedFiles) => {
+	const sep = changedFiles?.separator ?? " ";
+	return (changedFiles?.path === "absolute" ? files : files.map((f) => relative(cwd, f))).map((p) => shellEscape(p)).join(sep);
+};
+const formatFileListPlain = (files, cwd) => files.map((f) => relative(cwd, f)).join(" ");
+const hasNamedGroups = (pattern) => /\(\?<[^>]+>/.test(pattern);
+const runSingleCheckEntry = async (entry, changedFiles, cwd) => {
+	const matched = matchFiles(changedFiles, entry.match, cwd, entry.exclude);
+	if (matched.length === 0) return [{
+		status: "skip",
+		name: entry.name
+	}];
+	if (hasNamedGroups(entry.match)) {
+		const grouped = groupMatchResults(matched);
+		return await Promise.all([...grouped.entries()].map(async ([groupKey, group]) => {
+			const checkName = groupKey ? `${entry.name}[${groupKey}]` : entry.name;
+			const ctx = { CHANGED_FILES: formatFileList(group.files, cwd, entry.changedFiles) };
+			const context = buildContext({
+				match: group.groups,
+				ctx
+			});
+			const command = resolve$1(entry.command, context);
+			const { exitCode, stdout, stderr } = await runCommand(command, cwd);
+			if (exitCode === 0) return {
+				status: "passed",
+				name: checkName,
+				command
+			};
+			return {
+				status: "failed",
+				name: checkName,
+				command,
+				exitCode,
+				stdout,
+				stderr
+			};
+		}));
+	}
+	const ctx = { CHANGED_FILES: formatFileList(matched.map((m) => m.file), cwd, entry.changedFiles) };
+	const context = buildContext({ ctx });
+	const command = resolve$1(entry.command, context);
+	const { exitCode, stdout, stderr } = await runCommand(command, cwd);
+	if (exitCode === 0) return [{
+		status: "passed",
+		name: entry.name,
+		command
+	}];
+	return [{
+		status: "failed",
+		name: entry.name,
+		command,
+		exitCode,
+		stdout,
+		stderr
+	}];
+};
+const runChecks = async (entries, changedFiles, cwd) => {
+	return (await Promise.allSettled(entries.map((entry) => runSingleCheckEntry(entry, changedFiles, cwd)))).flatMap((result, i) => {
+		if (result.status === "fulfilled") return result.value;
+		const entry = entries[i];
+		if (!entry) throw new Error(`Unexpected missing entry at index ${i}`);
+		return [{
+			status: "failed",
+			name: entry.name,
+			command: entry.command,
+			exitCode: 1,
+			stdout: "",
+			stderr: result.reason instanceof Error ? result.reason.message : String(result.reason)
+		}];
+	});
+};
+const runReviewWithFallbacks = async (commands, cwd, name) => {
+	for (const command of commands) {
+		const { exitCode, stdout, stderr } = await runCommand(command, cwd);
+		if (exitCode === 0) return {
+			status: "completed",
+			name,
+			command,
+			stdout
+		};
+		if (command === commands[commands.length - 1]) return {
+			status: "failed",
+			name,
+			command,
+			exitCode,
+			stdout,
+			stderr
+		};
+	}
+	return {
+		status: "failed",
+		name,
+		command: commands[commands.length - 1] ?? "",
+		exitCode: 1,
+		stdout: "",
+		stderr: "No commands to execute"
+	};
+};
+const runSingleReviewEntry = async (entry, changedFiles, cwd, diffSummary) => {
+	const matched = matchFiles(changedFiles, entry.match, cwd, entry.exclude);
+	if (matched.length === 0) return [{
+		status: "skip",
+		name: entry.name
+	}];
+	const allFiles = matched.map((m) => m.file);
+	const matchGroups = matched[0]?.groups ?? {};
+	const ctx = {
+		DIFF_SUMMARY: diffSummary,
+		CHANGED_FILES: formatFileListPlain(allFiles, cwd)
+	};
+	const baseContext = buildContext({
+		match: matchGroups,
+		ctx
+	});
+	const resolvedVars = entry.vars ? resolveVars(entry.vars, baseContext) : {};
+	const fullContext = buildContext({
+		match: matchGroups,
+		ctx,
+		vars: resolvedVars
+	});
+	return [await runReviewWithFallbacks([entry.command, ...entry.fallbacks ?? []].map((cmd) => resolveCommand(cmd, fullContext)), cwd, entry.name)];
+};
+const runReviews = async (entries, changedFiles, cwd, diffSummary) => {
+	return (await Promise.allSettled(entries.map((entry) => runSingleReviewEntry(entry, changedFiles, cwd, diffSummary)))).flatMap((result, i) => {
+		if (result.status === "fulfilled") return result.value;
+		const entry = entries[i];
+		if (!entry) throw new Error(`Unexpected missing entry at index ${i}`);
+		return [{
+			status: "failed",
+			name: entry.name,
+			command: entry.command,
+			exitCode: 1,
+			stdout: "",
+			stderr: result.reason instanceof Error ? result.reason.message : String(result.reason)
+		}];
+	});
+};
+const dryRunChecks = (entries, changedFiles, cwd) => {
+	for (const entry of entries) {
+		const matched = matchFiles(changedFiles, entry.match, cwd, entry.exclude);
+		if (matched.length === 0) {
+			log(`  [skip] ${entry.name} (no matching files)`);
+			continue;
+		}
+		if (hasNamedGroups(entry.match)) {
+			const grouped = groupMatchResults(matched);
+			for (const [groupKey, group] of grouped) {
+				const checkName = groupKey ? `${entry.name}[${groupKey}]` : entry.name;
+				const ctx = { CHANGED_FILES: formatFileList(group.files, cwd) };
+				const context = buildContext({
+					match: group.groups,
+					ctx
+				});
+				const command = resolve$1(entry.command, context);
+				log(`  [run]  ${checkName}`);
+				log(`         $ ${command}`);
+			}
+		} else {
+			const ctx = { CHANGED_FILES: formatFileList(matched.map((m) => m.file), cwd) };
+			const context = buildContext({ ctx });
+			const command = resolve$1(entry.command, context);
+			log(`  [run]  ${entry.name}`);
+			log(`         $ ${command}`);
+		}
+	}
+};
+const dryRunReviews = (entries, changedFiles, cwd, diffSummary) => {
+	for (const entry of entries) {
+		const matched = matchFiles(changedFiles, entry.match, cwd, entry.exclude);
+		if (matched.length === 0) {
+			log(`${entry.name}: (no matching files)\n`);
+			continue;
+		}
+		const allFiles = matched.map((m) => m.file);
+		const matchGroups = matched[0]?.groups ?? {};
+		const ctx = {
+			DIFF_SUMMARY: diffSummary,
+			CHANGED_FILES: formatFileListPlain(allFiles, cwd)
+		};
+		const baseContext = buildContext({
+			match: matchGroups,
+			ctx
+		});
+		const resolvedVars = entry.vars ? resolveVars(entry.vars, baseContext) : {};
+		const fullContext = buildContext({
+			match: matchGroups,
+			ctx,
+			vars: resolvedVars
+		});
+		log(`${entry.name}:`);
+		log("");
+		log("  ctx:");
+		for (const [key, value] of Object.entries(ctx)) {
+			const lines = value.split("\n");
+			if (lines.length <= 5) log(`    ${key}: ${value}`);
+			else log(`    ${key}: (${lines.length} lines)`);
+		}
+		log("");
+		if (entry.vars !== void 0) {
+			log("  vars:");
+			for (const [key, value] of Object.entries(resolvedVars)) log(`    ${key}: ${value}`);
+			log("");
+		}
+		const commands = [entry.command, ...entry.fallbacks ?? []].map((cmd) => resolveCommand(cmd, fullContext));
+		for (const cmd of commands) log(`  $ ${cmd}`);
+		log("");
+	}
+};
+const reportCheckResults = (results) => {
+	const skipped = results.filter((r) => r.status === "skip");
+	const passed = results.filter((r) => r.status === "passed");
+	const failed = results.filter((r) => r.status === "failed");
+	if (failed.length > 0) for (const r of failed) {
+		logError(`\n── ${r.name} ──`);
+		if (r.stdout) logError(r.stdout.trimEnd());
+		if (r.stderr) logError(r.stderr.trimEnd());
+	}
+	log("");
+	for (const r of skipped) log(`  - ${r.name} [skipped]`);
+	for (const r of passed) log(`  ✓ ${r.name} [passed]`);
+	for (const r of failed) log(`  ✗ ${r.name} [failed]`);
+	if (failed.length > 0) {
+		log(`\n${passed.length} passed, ${failed.length} failed, ${skipped.length} skipped`);
+		return false;
+	}
+	log(`\n${passed.length} passed, ${skipped.length} skipped`);
+	return true;
+};
+const reportCheckResultsJson = (results) => {
+	const passed = results.filter((r) => r.status === "passed");
+	const failed = results.filter((r) => r.status === "failed");
+	const skipped = results.filter((r) => r.status === "skip");
+	const checks = results.map((r) => {
+		switch (r.status) {
+			case "skip": return {
+				name: r.name,
+				status: r.status
+			};
+			case "passed": return {
+				name: r.name,
+				status: r.status,
+				command: r.command
+			};
+			case "failed": return {
+				name: r.name,
+				status: r.status,
+				command: r.command,
+				exitCode: r.exitCode,
+				stdout: r.stdout,
+				stderr: r.stderr
+			};
+			default: {
+				const _exhaustive = r;
+				throw new Error(`Unexpected status: ${JSON.stringify(_exhaustive)}`);
+			}
+		}
+	});
+	return {
+		status: failed.length > 0 ? "failed" : "passed",
+		summary: {
+			passed: passed.length,
+			failed: failed.length,
+			skipped: skipped.length
+		},
+		checks
+	};
+};
+const reportCheckResultsHooks = (results) => {
+	const failed = results.filter((r) => r.status === "failed");
+	if (failed.length === 0) return null;
+	const failureDetails = failed.map((r) => {
+		const lines = [`── ${r.name} ($ ${r.command}) ──`];
+		if (r.stdout) lines.push(r.stdout.trimEnd());
+		if (r.stderr) lines.push(r.stderr.trimEnd());
+		return lines.join("\n");
+	}).join("\n\n");
+	const passed = results.filter((r) => r.status === "passed").length;
+	const skipped = results.filter((r) => r.status === "skip").length;
+	return {
+		decision: "block",
+		reason: [
+			"gatecheck blocked: checks failed. Fix the errors below and try again.",
+			"",
+			failureDetails,
+			"",
+			`${passed} passed, ${failed.length} failed, ${skipped} skipped`
+		].join("\n")
+	};
+};
+const reportReviewResults = (results) => {
+	const skipped = results.filter((r) => r.status === "skip");
+	const completed = results.filter((r) => r.status === "completed");
+	const failed = results.filter((r) => r.status === "failed");
+	for (const r of completed) {
+		log(`\n── ${r.name} ──`);
+		if (r.stdout) log(r.stdout.trimEnd());
+	}
+	if (failed.length > 0) for (const r of failed) {
+		logError(`\n── ${r.name} (failed) ──`);
+		if (r.stdout) logError(r.stdout.trimEnd());
+		if (r.stderr) logError(r.stderr.trimEnd());
+	}
+	log("");
+	for (const r of skipped) log(`  - ${r.name} [skipped]`);
+	for (const r of completed) log(`  ✓ ${r.name} [completed]`);
+	for (const r of failed) log(`  ✗ ${r.name} [failed]`);
+	if (failed.length > 0) {
+		log(`\n${completed.length} completed, ${failed.length} failed, ${skipped.length} skipped`);
+		return false;
+	}
+	log(`\n${completed.length} completed, ${skipped.length} skipped`);
+	return true;
+};
+
+//#endregion
+//#region src/bin.ts
+const parseChangedSource = (raw) => {
+	if (raw === "untracked") return { type: "untracked" };
+	if (raw === "unstaged") return { type: "unstaged" };
+	if (raw === "staged") return { type: "staged" };
+	if (raw.startsWith("branch:")) {
+		const name = raw.slice(7);
+		if (name === "") throw new Error("branch: requires a branch name (e.g. branch:main)");
+		return {
+			type: "branch",
+			name
+		};
+	}
+	if (raw.startsWith("sha:")) {
+		const sha = raw.slice(4);
+		if (sha === "") throw new Error("sha: requires a commit SHA (e.g. sha:abc1234)");
+		return {
+			type: "sha",
+			sha
+		};
+	}
+	throw new Error(`Unknown changed source: ${raw}`);
+};
+const parseChangedSources = (raw) => raw.split(",").map((s) => parseChangedSource(s.trim()));
+const DEFAULT_SOURCES = [{ type: "unstaged" }, { type: "staged" }];
+const filterByTarget = (entries, target) => {
+	if (target === void 0 || target === "all") return entries;
+	const groups = target.split(",").map((s) => s.trim());
+	const knownGroups = new Set(entries.map((e) => e.group));
+	const unknown = groups.filter((g) => !knownGroups.has(g));
+	if (unknown.length > 0) logError(`Warning: unknown target group(s): ${unknown.join(", ")}`);
+	return entries.filter((e) => groups.includes(e.group));
+};
+const parseFormat = (raw) => {
+	if (raw === "json") return "json";
+	if (raw === "claude-code-hooks") return "claude-code-hooks";
+	if (raw === "copilot-cli-hooks") return "copilot-cli-hooks";
+	return "text";
+};
+const check = async (opts) => {
+	const cwd = process.cwd();
+	const fmt = parseFormat(opts.format);
+	const config = await loadConfig(cwd);
+	if (opts.dryRun === true && fmt !== "text") throw new Error("--dry-run can only be used with --format text");
+	const entries = filterByTarget(config.checks ?? [], opts.target ?? config.defaults?.target);
+	if (entries.length === 0) {
+		if (fmt === "text") log("No checks configured.");
+		if (fmt === "json") log(JSON.stringify(reportCheckResultsJson([])));
+		if (fmt === "claude-code-hooks" || fmt === "copilot-cli-hooks") {}
+		return;
+	}
+	const changedFiles = await getChangedFiles(opts.changed !== void 0 ? parseChangedSources(opts.changed) : config.defaults?.changed !== void 0 ? parseChangedSources(config.defaults.changed) : DEFAULT_SOURCES, cwd);
+	if (changedFiles.length === 0) {
+		if (fmt === "text") log("No changed files found.");
+		if (fmt === "json") log(JSON.stringify(reportCheckResultsJson([])));
+		return;
+	}
+	if (fmt === "text") log(`Found ${changedFiles.length} changed file(s).`);
+	if (opts.dryRun === true) {
+		log("");
+		dryRunChecks(entries, changedFiles, cwd);
+		return;
+	}
+	if (fmt === "text") log(`Running ${entries.length} check(s)...`);
+	const results = await runChecks(entries, changedFiles, cwd);
+	switch (fmt) {
+		case "text":
+			if (!reportCheckResults(results)) process.exitCode = 1;
+			break;
+		case "json": {
+			const output = reportCheckResultsJson(results);
+			log(JSON.stringify(output, null, 2));
+			if (output.status === "failed") process.exitCode = 1;
+			break;
+		}
+		case "claude-code-hooks":
+		case "copilot-cli-hooks": {
+			const output = reportCheckResultsHooks(results);
+			if (output !== null) {
+				log(JSON.stringify(output));
+				process.exitCode = 1;
+			}
+			break;
+		}
+		default: {
+			const _exhaustive = fmt;
+			throw new Error(`Unknown format: ${String(_exhaustive)}`);
+		}
+	}
+};
+const review = async (opts) => {
+	const cwd = process.cwd();
+	const config = await loadConfig(cwd);
+	const entries = config.reviews ?? [];
+	if (entries.length === 0) {
+		log("No reviews configured.");
+		return;
+	}
+	const changedSources = opts.changed !== void 0 ? parseChangedSources(opts.changed) : config.defaults?.changed !== void 0 ? parseChangedSources(config.defaults.changed) : DEFAULT_SOURCES;
+	const changedFiles = await getChangedFiles(changedSources, cwd);
+	if (changedFiles.length === 0) {
+		log("No changed files found.");
+		return;
+	}
+	log(`Found ${changedFiles.length} changed file(s).`);
+	const diffSummary = await getDiffSummary(changedSources, cwd);
+	if (opts.dryRun === true) {
+		log("");
+		dryRunReviews(entries, changedFiles, cwd, diffSummary);
+		return;
+	}
+	log(`Running ${entries.length} review(s)...`);
+	if (!reportReviewResults(await runReviews(entries, changedFiles, cwd, diffSummary))) process.exitCode = 1;
+};
+const program = new Command().name("gatecheck").description(description).version(version);
+program.command("check").description("Run deterministic checks (lint, typecheck, test) against changed files").option("-c, --changed <sources>", "Changed sources (comma-separated: untracked,unstaged,staged,branch:<name>,sha:<sha>)").option("-t, --target <groups>", "Target groups (comma-separated or \"all\")").option("-d, --dry-run", "Show which checks would run without executing them").addOption(new Option("-f, --format <format>", "Output format").choices([
+	"text",
+	"json",
+	"claude-code-hooks",
+	"copilot-cli-hooks"
+])).action(check);
+program.command("review").description("Run AI-powered reviews against changed files").option("-c, --changed <sources>", "Changed sources (comma-separated: untracked,unstaged,staged,branch:<name>,sha:<sha>)").option("-d, --dry-run", "Show review configuration and matched files without executing").action(review);
+program.command("setup").description("Create or update gatecheck.yaml").option("--non-interactive", "Skip prompts and use defaults with auto-detected presets").action(async (opts) => {
+	const { runSetup } = await import("./setup-BGSEp6JC.mjs");
+	await runSetup(process.cwd(), { nonInteractive: opts.nonInteractive });
+});
+program.parseAsync().catch((error) => {
+	if (error instanceof ConfigNotFoundError) logError(error.message);
+	else logError(error instanceof Error ? error.message : String(error));
+	process.exitCode = 1;
+});
+
+//#endregion
+export { loadConfig as n, resolveConfigPath as r, log as t };