@kirchdev/gitignore-sync 0.1.0

package/dist/bin/gitignore-sync.mjs

@@ -0,0 +1,1539 @@
+#!/usr/bin/env node
+import { defineCommand, runMain } from "citty";
+import { existsSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from "node:fs";
+import consola from "consola";
+import { colors } from "consola/utils";
+import { basename, dirname, isAbsolute, join, resolve } from "pathe";
+//#region src/gitignore/markers.ts
+/**
+* `# region` / `# endregion` rather than `# start` / `# end` for one concrete
+* reader: VSCode folds `#region`, so a 40-line managed block collapses to a
+* single line — and the nested form folds at both levels.
+*/
+var REGION_NAME = "gitignore-sync";
+/** `# region gitignore-sync` — the outer marker, matched leniently on spacing. */
+var OUTER_START = new RegExp(`^#\\s*region\\s+${REGION_NAME}\\s*$`);
+/** `# region node@v1` — a section marker. */
+var SECTION_START = /^#\s*region\s+([A-Za-z0-9][\w.-]*)@v(\d+)\s*$/;
+/** Any region opener, whichever level it belongs to. */
+var ANY_START = /^#\s*region\b/;
+var ANY_END = /^#\s*endregion\s*$/;
+var isOuterStart = (line) => OUTER_START.test(line);
+var isAnyStart = (line) => ANY_START.test(line);
+var isEnd = (line) => ANY_END.test(line);
+function matchSectionStart(line) {
+	const m = SECTION_START.exec(line);
+	if (!m?.[1] || !m[2]) return void 0;
+	return {
+		stack: m[1],
+		version: Number(m[2])
+	};
+}
+var outerStartLine = () => `# region ${REGION_NAME}`;
+var sectionStartLine = (stack, version) => `# region ${stack}@v${version}`;
+var endLine = () => "# endregion";
+/** `# stacks: core, node` — the declaration the whole tool reads. */
+var STACKS = /^#\s*stacks:\s*(.*)$/;
+function matchStacks(line) {
+	const m = STACKS.exec(line);
+	if (!m) return void 0;
+	return m[1] ? m[1].split(",").map((s) => s.trim()).filter(Boolean) : [];
+}
+var stacksLine = (stacks) => `# stacks: ${stacks.join(", ")}`;
+/** Cosmetic rule under the header; regenerated on every render. */
+var DIVIDER = `# ${"─".repeat(41)}`;
+//#endregion
+//#region src/gitignore/types.ts
+var GitignoreParseError = class extends Error {
+	line;
+	constructor(message, line) {
+		super(`${message} (line ${line})`);
+		this.name = "GitignoreParseError";
+		this.line = line;
+	}
+};
+//#endregion
+//#region src/gitignore/parse.ts
+var isBlank$1 = (line) => line.trim() === "";
+/**
+* Split text into lines, dropping the single trailing empty string a
+* newline-terminated file produces. Touches no filesystem: string in, Document
+* out.
+*/
+function toLines(text) {
+	const lines = text.split("\n");
+	if (lines.at(-1) === "") lines.pop();
+	return lines.map((l) => l.endsWith("\r") ? l.slice(0, -1) : l);
+}
+function trimBlankEdges(lines) {
+	let start = 0;
+	let end = lines.length;
+	while (start < end && isBlank$1(lines[start] ?? "")) start++;
+	while (end > start && isBlank$1(lines[end - 1] ?? "")) end--;
+	return lines.slice(start, end);
+}
+/**
+* Recognise the header, the sections and the free zone.
+*
+* A file with no managed region parses as pure free zone — that is what `init`
+* sees on its first run.
+*/
+function parse(text) {
+	const lines = toLines(text);
+	const outerStart = lines.findIndex(isOuterStart);
+	if (outerStart === -1) return {
+		header: [],
+		sections: [],
+		freeZone: trimBlankEdges(lines),
+		hasRegion: false
+	};
+	const header = [];
+	const sections = [];
+	/** Non-marker lines found at region level after the first section: strays. */
+	const strays = [];
+	let depth = 1;
+	let index = outerStart + 1;
+	let outerEnd = -1;
+	let open;
+	/** A line the region holds but no marker of ours claims. */
+	const keep = (line) => {
+		if (open) open.lines.push(line);
+		else if (sections.length === 0) header.push(line);
+		else if (!isBlank$1(line)) strays.push(line);
+	};
+	for (; index < lines.length; index++) {
+		const line = lines[index] ?? "";
+		if (isEnd(line)) {
+			const next = depth - 1;
+			if (next === 0) {
+				outerEnd = index;
+				break;
+			}
+			depth = next;
+			if (next === 1 && open) {
+				sections.push(open);
+				open = void 0;
+				continue;
+			}
+			keep(line);
+			continue;
+		}
+		if (isAnyStart(line)) {
+			const section = matchSectionStart(line);
+			depth++;
+			if (depth === 2 && section && !open) {
+				open = {
+					stack: section.stack,
+					version: section.version,
+					lines: []
+				};
+				continue;
+			}
+			keep(line);
+			continue;
+		}
+		keep(line);
+	}
+	if (outerEnd === -1) throw new GitignoreParseError(`unterminated '# region gitignore-sync' — no matching '# endregion'`, outerStart + 1);
+	const before = lines.slice(0, outerStart);
+	const after = lines.slice(outerEnd + 1);
+	for (const section of sections) section.lines = trimBlankEdges(section.lines);
+	return {
+		header: trimBlankEdges(header),
+		sections,
+		freeZone: [
+			...trimBlankEdges(before),
+			...trimBlankEdges(after),
+			...strays
+		],
+		hasRegion: true
+	};
+}
+/** The stacks the header declares — the input side of the document. */
+function readStacks(doc) {
+	for (const line of doc.header) {
+		const stacks = matchStacks(line);
+		if (stacks) return stacks;
+	}
+	return [];
+}
+/**
+* A copy of the document with a new `# stacks:` declaration. The header is the
+* only thing `add` and `remove` touch — the sections follow from it on the next
+* reconcile, which is the whole point of the header being input.
+*/
+function withStacks(doc, stacks) {
+	const line = stacksLine(stacks);
+	let replaced = false;
+	const header = doc.header.map((l) => {
+		if (replaced || matchStacks(l) === void 0) return l;
+		replaced = true;
+		return line;
+	});
+	return {
+		...doc,
+		header: replaced ? header : [line, ...header]
+	};
+}
+//#endregion
+//#region src/templates/index.ts
+/**
+* Curated blocks, versioned with the binary. Data, not code.
+*
+* Every version a stack has ever shipped is kept, ascending. Reconciling reads
+* the version the section marker names, so upgrading `node@v1` to `node@v2`
+* knows which of the block's lines it put there itself and which the user
+* added — without that history an upgrade would "rescue" its own dropped lines
+* into the free zone.
+*
+* **No line may appear in two stacks.** A repo declaring both would otherwise
+* render it twice, and the equivalence report would nag about a collision the
+* tool created itself. `tests/templates.test.ts` enforces this.
+*/
+var registry = {
+	core: [{
+		stack: "core",
+		version: 1,
+		lines: [".DS_Store", ".claude/settings.local.json"]
+	}],
+	git: [{
+		stack: "git",
+		version: 1,
+		lines: [
+			"*.orig",
+			"*.rej",
+			"*.BACKUP.*",
+			"*.BASE.*",
+			"*.LOCAL.*",
+			"*.REMOTE.*",
+			"*_BACKUP_*.txt",
+			"*_BASE_*.txt",
+			"*_LOCAL_*.txt",
+			"*_REMOTE_*.txt"
+		]
+	}],
+	node: [{
+		stack: "node",
+		version: 1,
+		lines: [
+			"node_modules",
+			"dist",
+			"coverage",
+			"logs",
+			"*.log",
+			"*.tsbuildinfo",
+			".eslintcache",
+			".npm",
+			"*.tgz"
+		]
+	}],
+	go: [{
+		stack: "go",
+		version: 1,
+		lines: [
+			"*.exe",
+			"*.test",
+			"*.out",
+			"*.prof"
+		]
+	}],
+	tofu: [{
+		stack: "tofu",
+		version: 1,
+		lines: [
+			".terraform/",
+			"*.tfstate",
+			"*.tfstate.*",
+			"*.tfvars",
+			"!*.tfvars.example",
+			"override.tf",
+			"override.tf.json",
+			".terraformrc",
+			"terraform.rc",
+			"crash.log",
+			"crash.*.log"
+		]
+	}],
+	php: [{
+		stack: "php",
+		version: 1,
+		lines: [
+			"/vendor",
+			"/.phpunit.cache",
+			"/.phpunit.result.cache"
+		]
+	}],
+	laravel: [{
+		stack: "laravel",
+		version: 1,
+		lines: [
+			"/public/build",
+			"/public/hot",
+			"/public/storage",
+			"/storage/*.key",
+			"/storage/pail",
+			"/bootstrap/ssr",
+			"_ide_helper.php",
+			"_ide_helper_models.php",
+			".phpstorm.meta.php"
+		]
+	}],
+	turborepo: [{
+		stack: "turborepo",
+		version: 1,
+		lines: [".turbo"]
+	}],
+	rust: [{
+		stack: "rust",
+		version: 1,
+		lines: ["/target", "**/*.rs.bk"]
+	}],
+	playwright: [{
+		stack: "playwright",
+		version: 1,
+		lines: [
+			"test-results/",
+			"playwright-report/",
+			"blob-report/",
+			".last-run.json"
+		]
+	}],
+	storybook: [{
+		stack: "storybook",
+		version: 1,
+		lines: ["storybook-static"]
+	}],
+	nuxt: [{
+		stack: "nuxt",
+		version: 1,
+		lines: [
+			".nuxt",
+			".output",
+			".nitro",
+			".data"
+		]
+	}],
+	tauri: [{
+		stack: "tauri",
+		version: 1,
+		lines: ["src-tauri/target", "src-tauri/gen/schemas"]
+	}],
+	dotenv: [{
+		stack: "dotenv",
+		version: 1,
+		lines: [
+			".env",
+			".env.*",
+			"!.env.example",
+			"!.env.*.example"
+		]
+	}],
+	vscode: [{
+		stack: "vscode",
+		version: 1,
+		lines: [
+			".vscode/*",
+			"!.vscode/extensions.json",
+			"!.vscode/settings.json",
+			"!.vscode/mcp.json"
+		]
+	}],
+	intellij: [{
+		stack: "intellij",
+		version: 1,
+		lines: [".idea/*"]
+	}],
+	macos: [{
+		stack: "macos",
+		version: 1,
+		lines: [
+			".AppleDouble",
+			".LSOverride",
+			"._*",
+			".Spotlight-V100",
+			".Trashes",
+			".DocumentRevisions-V100",
+			".fseventsd",
+			".TemporaryItems",
+			".VolumeIcon.icns",
+			".com.apple.timemachine.donotpresent",
+			".AppleDB",
+			".AppleDesktop",
+			"Network Trash Folder",
+			"Temporary Items",
+			".apdisk",
+			"*.icloud"
+		]
+	}],
+	windows: [{
+		stack: "windows",
+		version: 1,
+		lines: [
+			"Thumbs.db",
+			"Thumbs.db:encryptable",
+			"ehthumbs.db",
+			"ehthumbs_vista.db",
+			"[Dd]esktop.ini",
+			"$RECYCLE.BIN/",
+			"*.stackdump",
+			"*.cab",
+			"*.msi",
+			"*.msix",
+			"*.msm",
+			"*.msp",
+			"*.lnk"
+		]
+	}],
+	vim: [{
+		stack: "vim",
+		version: 1,
+		lines: [
+			"*.swp",
+			"*.swo",
+			"*.swn",
+			"Session.vim",
+			".netrwhist"
+		]
+	}],
+	linux: [{
+		stack: "linux",
+		version: 1,
+		lines: [
+			"*~",
+			".fuse_hidden*",
+			".directory",
+			".Trash-*",
+			".nfs*"
+		]
+	}]
+};
+/**
+* Registry insertion order, which is the order `init` writes into the header:
+* `core` first, then repository stacks, then the person-level ones. Stable, so
+* the `# stacks:` line does not churn between runs.
+*/
+var stackOrder = () => Object.keys(registry);
+var knownStacks = () => Object.keys(registry).sort();
+var isKnownStack = (stack) => stack in registry;
+/** The version a fresh render of this stack produces. */
+function currentTemplate(stack) {
+	return registry[stack]?.at(-1);
+}
+/** A specific past version, for working out what a section put there itself. */
+function templateAt(stack, version) {
+	return registry[stack]?.find((t) => t.version === version);
+}
+//#endregion
+//#region src/gitignore/reconcile.ts
+var isBlank = (line) => line.trim() === "";
+var isComment = (line) => line.trimStart().startsWith("#");
+/** Free-zone lines grouped the way a human reads them: blank lines separate. */
+function splitBlocks(lines) {
+	const blocks = [];
+	let current = [];
+	for (const line of lines) {
+		if (isBlank(line)) {
+			if (current.length > 0) blocks.push(current);
+			current = [];
+			continue;
+		}
+		current.push(line);
+	}
+	if (current.length > 0) blocks.push(current);
+	return blocks;
+}
+/**
+* A human-eye normalisation, used for **reporting only**. `/.idea` anchors to
+* the repo root and `.idea/` matches directories only, so collapsing them would
+* change what git ignores — hence never a merge, only a note.
+*/
+function equivalenceKey(line) {
+	let key = line.trim();
+	const negated = key.startsWith("!");
+	if (negated) key = key.slice(1);
+	key = key.replace(/^\/+/, "").replace(/\/\*{1,2}$/, "").replace(/\/+$/, "");
+	return negated ? `!${key}` : key;
+}
+/**
+* Bring a document in line with the templates its header declares.
+*
+* Pure: a Document in, a Document out. The rule that makes running this twice
+* safe lives here — a line inside a managed section that no template version
+* put there is moved to the free zone, never deleted.
+*/
+function reconcile(doc) {
+	const declared = readStacks(doc);
+	const unknownStacks = declared.filter((s) => !isKnownStack(s));
+	const rescued = [];
+	const staleSections = [];
+	for (const section of doc.sections) {
+		const shipped = templateAt(section.stack, section.version) ?? currentTemplate(section.stack);
+		if (shipped) {
+			const known = new Set(shipped.lines);
+			for (const line of section.lines) {
+				if (isBlank(line)) continue;
+				if (!known.has(line)) rescued.push(line);
+			}
+		}
+		const current = currentTemplate(section.stack);
+		if (current && current.version !== section.version) staleSections.push({
+			stack: section.stack,
+			from: section.version,
+			to: current.version
+		});
+	}
+	const sections = [];
+	for (const stack of declared) {
+		const template = currentTemplate(stack);
+		if (template) {
+			sections.push({
+				stack: template.stack,
+				version: template.version,
+				lines: [...template.lines]
+			});
+			continue;
+		}
+		const existing = doc.sections.find((s) => s.stack === stack);
+		if (existing) sections.push(existing);
+	}
+	const managed = new Set(sections.flatMap((s) => s.lines));
+	const duplicates = [];
+	const covered = [];
+	const orphanedComments = [];
+	const seen = /* @__PURE__ */ new Set();
+	const freeZone = [];
+	for (const block of splitBlocks([...doc.freeZone, ...rescued])) {
+		const kept = [];
+		let hadPattern = false;
+		let keptPattern = false;
+		for (const line of block) {
+			if (isComment(line)) {
+				kept.push(line);
+				continue;
+			}
+			hadPattern = true;
+			if (managed.has(line)) {
+				covered.push(line);
+				continue;
+			}
+			if (seen.has(line)) {
+				duplicates.push(line);
+				continue;
+			}
+			seen.add(line);
+			keptPattern = true;
+			kept.push(line);
+		}
+		if (hadPattern && !keptPattern) {
+			orphanedComments.push(...kept);
+			continue;
+		}
+		if (kept.length > 0) {
+			if (freeZone.length > 0) freeZone.push("");
+			freeZone.push(...kept);
+		}
+	}
+	const smothered = [];
+	const negations = [...managed].filter((line) => line.startsWith("!"));
+	for (const line of freeZone) {
+		if (isBlank(line) || isComment(line) || line.startsWith("!")) continue;
+		const dir = line.trim().replace(/^\/+/, "").replace(/\/+$/, "");
+		if (dir === "" || dir.includes("*")) continue;
+		const exceptions = negations.filter((n) => n.slice(1).replace(/^\/+/, "").startsWith(`${dir}/`));
+		if (exceptions.length > 0) smothered.push({
+			line,
+			exceptions
+		});
+	}
+	const byKey = /* @__PURE__ */ new Map();
+	for (const line of [...managed, ...freeZone]) {
+		if (isBlank(line) || isComment(line)) continue;
+		const key = equivalenceKey(line);
+		const spellings = byKey.get(key);
+		if (spellings) {
+			if (!spellings.includes(line)) spellings.push(line);
+		} else byKey.set(key, [line]);
+	}
+	const smotheredLines = new Set(smothered.map((s) => s.line));
+	const equivalences = [...byKey].map(([key, spellings]) => ({
+		key,
+		spellings: spellings.filter((s) => !smotheredLines.has(s))
+	})).filter(({ spellings }) => spellings.length > 1);
+	return {
+		document: {
+			header: doc.header,
+			sections,
+			freeZone,
+			hasRegion: doc.hasRegion
+		},
+		rescued,
+		duplicates,
+		covered,
+		orphanedComments,
+		smothered,
+		equivalences,
+		unknownStacks,
+		staleSections
+	};
+}
+//#endregion
+//#region src/io.ts
+var gitignorePath = (dir) => join(isAbsolute(dir) ? dir : resolve(dir), ".gitignore");
+/** A missing `.gitignore` reads as empty — that is `init`'s first-run case. */
+function readGitignore(dir) {
+	try {
+		return readFileSync(gitignorePath(dir), "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return "";
+		throw error;
+	}
+}
+function writeGitignore(dir, text) {
+	writeFileSync(gitignorePath(dir), text, "utf8");
+}
+//#endregion
+//#region src/commands/audit.ts
+var isPattern = (line) => {
+	const t = line.trim();
+	return t !== "" && !t.startsWith("#");
+};
+/**
+* Measure one file against every stack this binary ships.
+*
+* The point is not to rewrite anything — it is to answer "what would still be
+* left over if this repo declared everything?", because that remainder is what
+* decides whether a stack is missing or the lines are genuinely project rules.
+*/
+function auditFile(dir) {
+	const file = gitignorePath(dir);
+	const text = readGitignore(dir);
+	const before = text.split("\n").filter(isPattern).length;
+	const doc = parse(text);
+	const all = stackOrder();
+	const leftovers = reconcile({
+		...doc,
+		header: [stacksLine(all), DIVIDER],
+		hasRegion: true
+	}).document.freeZone.filter(isPattern).map((l) => l.trim());
+	return {
+		name: basename(dir),
+		file,
+		before,
+		after: leftovers.length,
+		leftovers
+	};
+}
+var auditCommand = defineCommand({
+	meta: {
+		name: "audit",
+		description: "Measure how much of one or more repos the shipped stacks already cover"
+	},
+	args: {
+		dirs: {
+			type: "positional",
+			description: "Repository directories (default: the current one)",
+			required: false,
+			default: "."
+		},
+		"min-files": {
+			type: "string",
+			description: "Only list leftovers carried by at least this many files",
+			default: "1"
+		},
+		json: {
+			type: "boolean",
+			description: "Emit a machine-readable JSON report",
+			default: false
+		}
+	},
+	run({ args }) {
+		const raw = args._ && args._.length > 0 ? args._ : [args.dirs];
+		const dirs = [...new Set(raw.filter((d) => typeof d === "string" && d !== ""))].filter((dir) => {
+			if (!existsSync(dir) || !statSync(dir).isDirectory()) {
+				consola.warn(`Not a directory, skipped: ${dir}`);
+				return false;
+			}
+			if (!existsSync(gitignorePath(dir))) {
+				consola.warn(`No .gitignore, skipped: ${dir}`);
+				return false;
+			}
+			return true;
+		});
+		if (dirs.length === 0) {
+			consola.error("Nothing to audit.");
+			process.exitCode = 1;
+			return;
+		}
+		const files = dirs.map(auditFile).sort((a, b) => b.before - a.before);
+		const before = files.reduce((n, f) => n + f.before, 0);
+		const after = files.reduce((n, f) => n + f.after, 0);
+		const carriers = /* @__PURE__ */ new Map();
+		for (const row of files) for (const line of row.leftovers) {
+			const seen = carriers.get(line);
+			if (seen) seen.push(row.name);
+			else carriers.set(line, [row.name]);
+		}
+		const minFiles = Math.max(1, Number(args["min-files"]) || 1);
+		const leftovers = [...carriers].map(([pattern, names]) => ({
+			pattern,
+			files: names
+		})).filter((l) => l.files.length >= minFiles).sort((a, b) => b.files.length - a.files.length || a.pattern.localeCompare(b.pattern));
+		const report = {
+			files,
+			totals: {
+				before,
+				after,
+				covered: before - after,
+				percent: before === 0 ? 100 : Math.round((before - after) / before * 1e3) / 10
+			},
+			leftovers
+		};
+		if (args.json) {
+			process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+			return;
+		}
+		const width = Math.max(...files.map((f) => f.name.length), 4);
+		consola.log(`  ${colors.dim("repo".padEnd(width))} ${colors.dim("before")}  ${colors.dim("left")}`);
+		for (const row of files) consola.log(`  ${row.name.padEnd(width)} ${String(row.before).padStart(6)}  ${String(row.after).padStart(4)}`);
+		consola.log(`\n  ${colors.bold(`${report.totals.before} patterns → ${report.totals.after} left`)} ${colors.dim(`(${report.totals.percent}% covered by the shipped stacks)`)}`);
+		if (leftovers.length > 0) {
+			consola.log(`\n  ${colors.dim(`leftovers carried by ${minFiles}+ file(s), most common first`)}`);
+			for (const { pattern, files: names } of leftovers) consola.log(`  ${String(names.length).padStart(3)}x  ${pattern}  ${colors.dim(names.slice(0, 4).join(", ") + (names.length > 4 ? ", …" : ""))}`);
+		}
+	}
+});
+//#endregion
+//#region src/gitignore/render.ts
+/**
+* Document back to text. The managed region comes first, the free zone below
+* it, exactly one blank line between every block — so a second render of a
+* rendered document is a no-op, which is what makes `check` a usable CI gate.
+*/
+function render(doc) {
+	const out = [];
+	if (doc.hasRegion || doc.header.length > 0 || doc.sections.length > 0) {
+		out.push(outerStartLine(), ...doc.header);
+		for (const section of doc.sections) out.push("", sectionStartLine(section.stack, section.version), ...section.lines, endLine());
+		out.push("", endLine());
+	}
+	if (doc.freeZone.length > 0) {
+		if (out.length > 0) out.push("");
+		out.push(...doc.freeZone);
+	}
+	return out.length > 0 ? `${out.join("\n")}\n` : "";
+}
+//#endregion
+//#region src/commands/report.ts
+/** Everything a run wants to say about a reconciliation, in one place. */
+function report(result) {
+	for (const stack of result.unknownStacks) consola.warn(`Header declares unknown stack ${colors.cyan(stack)} — no template ships for it, its block is left untouched.`);
+	for (const stale of result.staleSections) consola.info(`${colors.cyan(stale.stack)} block is at v${stale.from}, this binary ships v${stale.to}.`);
+	if (result.rescued.length > 0) {
+		consola.info(`Rescued ${result.rescued.length} hand-written line(s) from managed blocks into the free zone:`);
+		for (const line of result.rescued) consola.log(`    ${colors.green(line)}`);
+	}
+	if (result.covered.length > 0) {
+		consola.info(`Removed ${result.covered.length} free-zone line(s) a managed block already covers:`);
+		for (const line of result.covered) consola.log(`    ${colors.dim(line)}`);
+	}
+	if (result.orphanedComments.length > 0) {
+		consola.info(`Removed ${result.orphanedComments.length} heading(s) left pointing at nothing:`);
+		for (const line of result.orphanedComments) consola.log(`    ${colors.dim(line)}`);
+	}
+	if (result.duplicates.length > 0) {
+		consola.info(`Removed ${result.duplicates.length} exact duplicate(s):`);
+		for (const line of result.duplicates) consola.log(`    ${colors.dim(line)}`);
+	}
+	for (const s of result.smothered) consola.warn(`${colors.yellow(s.line)} ignores the whole directory, which disables ${s.exceptions.map((e) => colors.cyan(e)).join(", ")}. Remove it — the managed block already covers it.`);
+	for (const eq of result.equivalences) consola.warn(`${eq.spellings.map((s) => colors.yellow(s)).join(" / ")} mean different things to git — reported, not merged.`);
+}
+//#endregion
+//#region src/commands/check.ts
+var checkCommand = defineCommand({
+	meta: {
+		name: "check",
+		description: "Dry run for CI: report drift and duplicates, exit non-zero on deviation"
+	},
+	args: { dir: {
+		type: "positional",
+		description: "Repository directory (default: the current one)",
+		required: false,
+		default: "."
+	} },
+	run({ args }) {
+		const dir = args.dir;
+		const text = readGitignore(dir);
+		const doc = parse(text);
+		if (!doc.hasRegion) {
+			consola.error(`${gitignorePath(dir)} has no managed region — run ${colors.cyan("gitignore-sync init")} first.`);
+			process.exitCode = 1;
+			return;
+		}
+		const result = reconcile(doc);
+		report(result);
+		if (render(result.document) !== text) {
+			consola.error(`${gitignorePath(dir)} is out of sync — run ${colors.cyan("gitignore-sync sync")}.`);
+			process.exitCode = 1;
+			return;
+		}
+		consola.success(`${gitignorePath(dir)} is in sync.`);
+	}
+});
+//#endregion
+//#region src/detect.ts
+/**
+* How deep a pattern fingerprint looks. One level below the root, because a
+* Terraform repo keeps its stacks in `tofu/` or `terraform/` rather than
+* scattered across the root — and because going deeper starts finding other
+* people's examples.
+*/
+var PATTERN_DEPTH = 2;
+/**
+* Never descended into. `examples/` is here on purpose: a `.tf` file shown as
+* documentation is not a workspace that produces state, and treating it as one
+* makes every provider repo look like an infrastructure repo.
+*/
+var SKIP = /* @__PURE__ */ new Set([
+	".git",
+	"node_modules",
+	"vendor",
+	"dist",
+	"coverage",
+	"examples",
+	"testdata",
+	"fixtures"
+]);
+var fingerprints = {
+	core: {
+		source: "repo",
+		always: true
+	},
+	git: {
+		source: "repo",
+		files: [".git"]
+	},
+	node: {
+		source: "repo",
+		files: ["package.json"]
+	},
+	turborepo: {
+		source: "repo",
+		files: ["turbo.json"]
+	},
+	rust: {
+		source: "repo",
+		files: ["Cargo.toml"]
+	},
+	playwright: {
+		source: "repo",
+		patterns: [/^playwright\.config\.[cm]?[jt]s$/]
+	},
+	storybook: {
+		source: "repo",
+		files: [".storybook"]
+	},
+	php: {
+		source: "repo",
+		files: ["composer.json"]
+	},
+	laravel: {
+		source: "repo",
+		files: ["artisan"]
+	},
+	go: {
+		source: "repo",
+		files: ["go.mod"]
+	},
+	tofu: {
+		source: "repo",
+		patterns: [
+			/\.tf$/,
+			/\.tofu$/,
+			/^\.terraform\.lock\.hcl$/
+		]
+	},
+	nuxt: {
+		source: "repo",
+		patterns: [/^nuxt\.config\.[cm]?[jt]s$/]
+	},
+	tauri: {
+		source: "repo",
+		files: ["src-tauri"]
+	},
+	dotenv: {
+		source: "repo",
+		files: [".env.example", ".env"]
+	},
+	vscode: {
+		source: "machine",
+		files: [".vscode"]
+	},
+	intellij: {
+		source: "machine",
+		files: [".idea"]
+	},
+	vim: {
+		source: "machine",
+		editor: /\b(?:vi|vim|nvim)\b/
+	},
+	macos: {
+		source: "machine",
+		platform: "darwin"
+	},
+	windows: {
+		source: "machine",
+		platform: "win32"
+	},
+	linux: {
+		source: "machine",
+		platform: "linux"
+	}
+};
+function matchesPatterns(dir, patterns, depth) {
+	let entries;
+	try {
+		entries = readdirSync(dir, { withFileTypes: true });
+	} catch {
+		return false;
+	}
+	for (const entry of entries) {
+		if (entry.isDirectory()) continue;
+		if (patterns.some((pattern) => pattern.test(entry.name))) return true;
+	}
+	if (depth <= 1) return false;
+	for (const entry of entries) {
+		if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+		if (SKIP.has(entry.name)) continue;
+		if (matchesPatterns(join(dir, entry.name), patterns, depth - 1)) return true;
+	}
+	return false;
+}
+function matches(dir, print) {
+	if (print.always) return true;
+	if (print.files?.some((file) => existsSync(join(dir, file)))) return true;
+	if (print.platform && process.platform === print.platform) return true;
+	if (print.editor) {
+		const editor = process.env.VISUAL ?? process.env.EDITOR ?? "";
+		if (print.editor.test(editor)) return true;
+	}
+	if (print.patterns) return matchesPatterns(dir, print.patterns, PATTERN_DEPTH);
+	return false;
+}
+/**
+* The only filesystem contact in the tool. `parse`, `render` and `reconcile`
+* stay string-in/string-out so the hard part is testable with fixture pairs.
+*
+* Returns registry order, so the header reads the same on every run.
+*/
+function detect(dir) {
+	const found = [];
+	for (const stack of stackOrder()) {
+		const print = fingerprints[stack];
+		if (print && matches(dir, print)) found.push({
+			stack,
+			source: print.source
+		});
+	}
+	return found;
+}
+/** Just the names, for callers that do not care where a signal came from. */
+var stacksOf = (found) => found.map((d) => d.stack);
+/**
+* What may be written without asking. Only committed evidence: `init --yes`
+* and the no-TTY path run in CI, where the platform is the runner's and the
+* editor directory is nobody's.
+*/
+var committedOnly = (found) => found.filter((d) => d.source === "repo");
+//#endregion
+//#region src/commands/prompt.ts
+/**
+* The one multiselect both `init` and `edit` show, so the two read the same
+* however you got there. Returns `null` when the prompt was cancelled — the
+* caller writes nothing in that case.
+*/
+async function promptStacks(options) {
+	const offered = options.choices ?? stackOrder();
+	const source = new Map(options.found.map((d) => [d.stack, d.source]));
+	const choices = offered.map((stack) => {
+		const template = currentTemplate(stack);
+		const marks = [];
+		if (source.has(stack)) marks.push("detected");
+		if (options.declared.has(stack)) marks.push("declared");
+		return {
+			value: stack,
+			label: stack,
+			hint: `${template?.lines.length ?? 0} lines${marks.length > 0 ? ` · ${marks.join(", ")}` : ""}`
+		};
+	});
+	const answer = await consola.prompt(options.message, {
+		type: "multiselect",
+		options: choices,
+		initial: offered.filter((s) => options.initial.has(s)),
+		required: false,
+		cancel: "null"
+	});
+	if (answer === null || answer === void 0) return null;
+	const chosen = new Set(answer.map(String));
+	const picked = offered.filter((stack) => chosen.has(stack));
+	for (const stack of options.declared) if (!picked.includes(stack) && !stackOrder().includes(stack)) picked.push(stack);
+	return picked;
+}
+/** A prompt with no terminal to read from would hang or take its defaults. */
+var canPrompt = () => Boolean(process.stdin.isTTY);
+//#endregion
+//#region src/commands/edit.ts
+var editCommand = defineCommand({
+	meta: {
+		name: "edit",
+		description: "Tick stacks on and off in a prompt, then re-render"
+	},
+	args: {
+		dir: {
+			type: "positional",
+			description: "Repository directory (default: the current one)",
+			required: false,
+			default: "."
+		},
+		"dry-run": {
+			type: "boolean",
+			description: "Print the result instead of writing it",
+			default: false
+		}
+	},
+	async run({ args }) {
+		const dir = args.dir;
+		const text = readGitignore(dir);
+		const doc = parse(text);
+		if (!doc.hasRegion) {
+			consola.error(`${gitignorePath(dir)} has no managed region — run ${colors.cyan("gitignore-sync init")} first.`);
+			process.exitCode = 1;
+			return;
+		}
+		if (!canPrompt()) {
+			consola.error(`${colors.cyan("edit")} needs an interactive terminal. Use ${colors.cyan("add")} / ${colors.cyan("remove")} in a script or CI.`);
+			process.exitCode = 1;
+			return;
+		}
+		const declared = new Set(readStacks(doc));
+		const next = await promptStacks({
+			message: "Which stacks does this repo want?",
+			initial: declared,
+			found: detect(dir),
+			declared
+		});
+		if (next === null) {
+			consola.info("Cancelled — nothing written.");
+			return;
+		}
+		const result = reconcile(withStacks(doc, next));
+		const output = render(result.document);
+		consola.log(`  ${colors.dim(stacksLine(next))}`);
+		report(result);
+		if (args["dry-run"]) {
+			consola.log(output);
+			return;
+		}
+		if (output === text) {
+			consola.success(`${gitignorePath(dir)} is already in sync.`);
+			return;
+		}
+		writeGitignore(dir, output);
+		consola.success(`Wrote ${gitignorePath(dir)}`);
+	}
+});
+//#endregion
+//#region src/commands/info.ts
+/** The package.json `name` this build is identified by. */
+var PACKAGE_NAME = "@kirchdev/gitignore-sync";
+/** What a person types, and what the report is headed with. */
+var BIN_NAME = "gitignore-sync";
+/** Resolve the real executed file behind any shim or symlink. */
+function resolveBinary(entry) {
+	if (!entry) return {
+		invoked: null,
+		resolved: null
+	};
+	try {
+		return {
+			invoked: entry,
+			resolved: realpathSync(entry)
+		};
+	} catch {
+		return {
+			invoked: entry,
+			resolved: entry
+		};
+	}
+}
+/** Walk up from `start` to the nearest package.json, returning its dir + name. */
+function findPackageRoot(start) {
+	let dir = resolve(start);
+	for (;;) {
+		const pkgPath = join(dir, "package.json");
+		if (existsSync(pkgPath)) try {
+			const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+			return {
+				dir,
+				name: pkg.name
+			};
+		} catch {
+			return {
+				dir,
+				name: void 0
+			};
+		}
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+/**
+* Tell a linked dev build from an installed release: the resolved binary lives
+* inside a git work tree whose package.json carries this package's name. When
+* neither can be established, report `unknown` rather than guessing.
+*/
+function detectBuild(resolved) {
+	if (!resolved) return {
+		kind: "unknown",
+		packageRoot: null,
+		reason: "binary path could not be resolved"
+	};
+	const pkg = findPackageRoot(dirname(resolved));
+	if (!pkg) return {
+		kind: "unknown",
+		packageRoot: null,
+		reason: "no package.json found above the binary"
+	};
+	if (pkg.name !== PACKAGE_NAME) return {
+		kind: "unknown",
+		packageRoot: pkg.dir,
+		reason: `nearest package.json is "${pkg.name ?? "unnamed"}", not ${PACKAGE_NAME}`
+	};
+	const inGitTree = existsSync(join(pkg.dir, ".git"));
+	return {
+		kind: inGitTree ? "linked" : "release",
+		packageRoot: pkg.dir,
+		reason: inGitTree ? `runs from a git work tree named ${PACKAGE_NAME}` : `installed ${PACKAGE_NAME} package (no git work tree beside it)`
+	};
+}
+function inspectRepository(dir) {
+	const file = gitignorePath(dir);
+	const exists = existsSync(file);
+	if (!exists) return {
+		file,
+		exists,
+		hasRegion: false,
+		stacks: [],
+		status: "no file"
+	};
+	const text = readGitignore(dir);
+	try {
+		const doc = parse(text);
+		if (!doc.hasRegion) return {
+			file,
+			exists,
+			hasRegion: false,
+			stacks: [],
+			status: "no region"
+		};
+		const result = reconcile(doc);
+		return {
+			file,
+			exists,
+			hasRegion: true,
+			stacks: readStacks(doc),
+			status: render(result.document) === text ? "in sync" : "drifted"
+		};
+	} catch (error) {
+		return {
+			file,
+			exists,
+			hasRegion: false,
+			stacks: [],
+			status: error.message
+		};
+	}
+}
+var BUILD_LABELS = {
+	linked: "linked / dev build",
+	release: "installed release",
+	unknown: "unknown"
+};
+var row = (label, value) => `  ${colors.dim(label.padEnd(9))} ${value}\n`;
+function renderPretty(info) {
+	let out = `${colors.bold(BIN_NAME)} ${colors.cyan(`v${info.version}`)} ${colors.dim(`(${BUILD_LABELS[info.build.kind]})`)}\n`;
+	out += row("build", colors.dim(info.build.reason));
+	if (info.build.packageRoot) out += row("package", info.build.packageRoot);
+	out += row("binary", info.binary.resolved ?? colors.dim("unknown"));
+	if (info.binary.invoked && info.binary.invoked !== info.binary.resolved) out += row("", colors.dim(`via ${info.binary.invoked}`));
+	out += row("node", info.node);
+	out += `\n${colors.bold("templates")}\n`;
+	out += row("ships", `${info.templates.stacks} stacks, ${info.templates.patterns} patterns`);
+	out += `\n${colors.bold("repository")}\n`;
+	out += row("file", info.repository.file);
+	const status = info.repository.status === "in sync" ? colors.green(info.repository.status) : info.repository.status === "drifted" ? colors.yellow(info.repository.status) : colors.dim(info.repository.status);
+	out += row("status", status);
+	if (info.repository.stacks.length > 0) out += row("stacks", info.repository.stacks.map((s) => colors.cyan(s)).join(", "));
+	return out;
+}
+var infoCommand = defineCommand({
+	meta: {
+		name: "info",
+		description: "Describe this installation: version, how it was installed, and the repo it sees"
+	},
+	args: {
+		dir: {
+			type: "positional",
+			description: "Repository directory (default: the current one)",
+			required: false,
+			default: "."
+		},
+		json: {
+			type: "boolean",
+			description: "Emit a machine-readable JSON report",
+			default: false
+		}
+	},
+	run({ args }) {
+		const binary = resolveBinary(process.argv[1]);
+		const info = {
+			version: "0.1.0",
+			build: detectBuild(binary.resolved),
+			binary,
+			node: process.version,
+			templates: {
+				stacks: stackOrder().length,
+				patterns: stackOrder().reduce((n, s) => n + (currentTemplate(s)?.lines.length ?? 0), 0)
+			},
+			repository: inspectRepository(args.dir)
+		};
+		if (args.json) {
+			process.stdout.write(`${JSON.stringify(info, null, 2)}\n`);
+			return;
+		}
+		process.stdout.write(renderPretty(info));
+	}
+});
+//#endregion
+//#region src/commands/stacks.ts
+var args = {
+	stacks: {
+		type: "positional",
+		description: "One or more stack names",
+		required: true
+	},
+	dir: {
+		type: "string",
+		description: "Repository directory (default: the current one)",
+		default: "."
+	},
+	"dry-run": {
+		type: "boolean",
+		description: "Print the result instead of writing it",
+		default: false
+	}
+};
+/**
+* `add` and `remove` edit one line: the `# stacks:` declaration. Everything
+* below it is re-rendered from that line, so the two verbs stay a convenience
+* over an edit you could also make by hand — never a second source of truth.
+*/
+function edit(mode) {
+	return (context) => {
+		const a = context.args;
+		const dir = a.dir ?? ".";
+		const raw = a._ && a._.length > 0 ? a._ : [a.stacks];
+		const names = [...new Set(raw.filter((n) => typeof n === "string" && n !== ""))];
+		if (names.length === 0) {
+			consola.error("Name at least one stack.");
+			consola.info(`Available: ${knownStacks().join(", ")}`);
+			process.exitCode = 1;
+			return;
+		}
+		const doc = parse(readGitignore(dir));
+		if (!doc.hasRegion) {
+			consola.error(`${gitignorePath(dir)} has no managed region — run ${colors.cyan("gitignore-sync init")} first.`);
+			process.exitCode = 1;
+			return;
+		}
+		if (mode === "add") {
+			const unknown = names.filter((n) => !isKnownStack(n));
+			if (unknown.length > 0) {
+				consola.error(`Unknown stack: ${unknown.map((u) => colors.yellow(u)).join(", ")}`);
+				consola.info(`Available: ${knownStacks().join(", ")}`);
+				process.exitCode = 1;
+				return;
+			}
+		}
+		const before = readStacks(doc);
+		const set = new Set(before);
+		const changed = [];
+		for (const name of names) {
+			if (mode === "add") {
+				if (set.has(name)) continue;
+				set.add(name);
+			} else {
+				if (!set.has(name)) continue;
+				set.delete(name);
+			}
+			changed.push(name);
+		}
+		if (changed.length === 0) {
+			consola.info(mode === "add" ? "Already declared — nothing to add." : "Not declared — nothing to remove.");
+			return;
+		}
+		const order = stackOrder();
+		const next = [...set].sort((x, y) => {
+			const ix = order.indexOf(x);
+			const iy = order.indexOf(y);
+			if (ix === -1 && iy === -1) return x.localeCompare(y);
+			if (ix === -1) return 1;
+			if (iy === -1) return -1;
+			return ix - iy;
+		});
+		const result = reconcile(withStacks(doc, next));
+		const output = render(result.document);
+		consola.info(`${mode === "add" ? "Added" : "Removed"} ${changed.map((c) => colors.cyan(c)).join(", ")}`);
+		consola.log(`  ${colors.dim(`# stacks: ${next.join(", ")}`)}`);
+		report(result);
+		if (a["dry-run"]) {
+			consola.log(output);
+			return;
+		}
+		writeGitignore(dir, output);
+		consola.success(`Wrote ${gitignorePath(dir)}`);
+	};
+}
+var addCommand = defineCommand({
+	meta: {
+		name: "add",
+		description: "Add stacks to the header and re-render"
+	},
+	args,
+	run: edit("add")
+});
+var removeCommand = defineCommand({
+	meta: {
+		name: "remove",
+		alias: "rm",
+		description: "Remove stacks from the header and re-render"
+	},
+	args,
+	run: edit("remove")
+});
+//#endregion
+//#region src/commands/init.ts
+var initCommand = defineCommand({
+	meta: {
+		name: "init",
+		description: "Fingerprint the repo, confirm the stacks in a prompt and write the managed region"
+	},
+	args: {
+		dir: {
+			type: "positional",
+			description: "Repository directory (default: the current one)",
+			required: false,
+			default: "."
+		},
+		stacks: {
+			type: "string",
+			description: "Comma-separated stacks; skips the prompt"
+		},
+		yes: {
+			type: "boolean",
+			description: "Take what detection proposes without asking",
+			alias: "y",
+			default: false
+		},
+		"dry-run": {
+			type: "boolean",
+			description: "Print the result instead of writing it",
+			default: false
+		},
+		force: {
+			type: "boolean",
+			description: "Replace an existing header instead of refusing",
+			default: false
+		}
+	},
+	async run({ args }) {
+		const dir = args.dir;
+		const existing = parse(readGitignore(dir));
+		if (existing.hasRegion && !args.force) {
+			consola.error(`${gitignorePath(dir)} already carries a managed region. Use ${colors.cyan("gitignore-sync edit")} to change it, ${colors.cyan("sync")} to re-render, or pass --force to start over.`);
+			process.exitCode = 1;
+			return;
+		}
+		const found = detect(dir);
+		const detected = new Set(stacksOf(found));
+		let stacks;
+		if (args.stacks) stacks = args.stacks.split(",").map((s) => s.trim()).filter(Boolean);
+		else if (args.yes || !canPrompt()) {
+			stacks = stacksOf(committedOnly(found));
+			consola.info(`Detected ${stacks.map((s) => colors.cyan(s)).join(", ")}`);
+			const skipped = stacksOf(found).filter((s) => !stacks.includes(s));
+			if (skipped.length > 0) consola.log(`  ${colors.dim(`Skipped ${skipped.join(", ")} — editor and platform need a human to confirm them. Add with \`gitignore-sync add\`.`)}`);
+		} else {
+			consola.info(`Found ${detected.size} stack${detected.size === 1 ? "" : "s"}: ${[...detected].map((s) => colors.cyan(s)).join(", ")}`);
+			const takeProposal = await consola.prompt("Use them?", {
+				type: "confirm",
+				initial: true,
+				cancel: "null"
+			});
+			if (takeProposal === null || takeProposal === void 0) {
+				consola.info("Cancelled — nothing written.");
+				return;
+			}
+			if (takeProposal) {
+				const rest = stackOrder().filter((s) => !detected.has(s));
+				const extra = await promptStacks({
+					message: "Anything else?",
+					initial: /* @__PURE__ */ new Set(),
+					found,
+					declared: /* @__PURE__ */ new Set(),
+					choices: rest
+				});
+				if (extra === null) {
+					consola.info("Cancelled — nothing written.");
+					return;
+				}
+				stacks = stackOrder().filter((s) => detected.has(s) || extra.includes(s));
+			} else {
+				const picked = await promptStacks({
+					message: "Pick the stacks yourself:",
+					initial: /* @__PURE__ */ new Set(),
+					found,
+					declared: /* @__PURE__ */ new Set()
+				});
+				if (picked === null) {
+					consola.info("Cancelled — nothing written.");
+					return;
+				}
+				stacks = picked;
+			}
+		}
+		const result = reconcile({
+			...existing,
+			header: [stacksLine(stacks), DIVIDER],
+			hasRegion: true
+		});
+		const output = render(result.document);
+		consola.log(`  ${colors.dim(stacksLine(stacks))}`);
+		report(result);
+		if (args["dry-run"]) {
+			consola.log(output);
+			return;
+		}
+		writeGitignore(dir, output);
+		consola.success(`Wrote ${gitignorePath(dir)}`);
+	}
+});
+//#endregion
+//#region src/commands/list.ts
+var listCommand = defineCommand({
+	meta: {
+		name: "list",
+		alias: "ls",
+		description: "List the stacks this binary ships and which the repo declares"
+	},
+	args: { dir: {
+		type: "positional",
+		description: "Repository directory (default: the current one)",
+		required: false,
+		default: "."
+	} },
+	run({ args }) {
+		const declared = new Set(readStacks(parse(readGitignore(args.dir))));
+		for (const stack of knownStacks()) {
+			const template = currentTemplate(stack);
+			const mark = declared.has(stack) ? colors.green("●") : colors.dim("○");
+			consola.log(`  ${mark} ${colors.cyan(stack)}@v${template?.version ?? "?"}  ${colors.dim(`${template?.lines.length ?? 0} ${template?.lines.length === 1 ? "line" : "lines"}`)}`);
+		}
+		for (const stack of declared) if (!currentTemplate(stack)) consola.log(`  ${colors.yellow("?")} ${colors.cyan(stack)}  ${colors.dim("declared, no template")}`);
+	}
+});
+//#endregion
+//#region src/commands/sync.ts
+var syncCommand = defineCommand({
+	meta: {
+		name: "sync",
+		description: "Read the header, re-render the managed blocks from it. Detects nothing."
+	},
+	args: {
+		dir: {
+			type: "positional",
+			description: "Repository directory (default: the current one)",
+			required: false,
+			default: "."
+		},
+		detect: {
+			type: "boolean",
+			description: "Additionally propose header changes from the tree — never applies them",
+			default: false
+		},
+		"dry-run": {
+			type: "boolean",
+			description: "Print the result instead of writing it",
+			default: false
+		}
+	},
+	run({ args }) {
+		const dir = args.dir;
+		const text = readGitignore(dir);
+		const doc = parse(text);
+		if (!doc.hasRegion) {
+			consola.error(`${gitignorePath(dir)} has no managed region — run ${colors.cyan("gitignore-sync init")} first.`);
+			process.exitCode = 1;
+			return;
+		}
+		const result = reconcile(doc);
+		const output = render(result.document);
+		report(result);
+		if (args.detect) {
+			const declared = new Set(readStacks(doc));
+			const missing = stacksOf(detect(dir)).filter((s) => !declared.has(s));
+			if (missing.length === 0) consola.info("Detection proposes no header change.");
+			else consola.info(`Detection suggests adding ${missing.map((s) => colors.cyan(s)).join(", ")} to the ${colors.cyan("# stacks:")} line. Not applied.`);
+		}
+		if (args["dry-run"]) {
+			consola.log(output);
+			return;
+		}
+		if (output === text) {
+			consola.success(`${gitignorePath(dir)} is already in sync.`);
+			return;
+		}
+		writeGitignore(dir, output);
+		consola.success(`Wrote ${gitignorePath(dir)}`);
+	}
+});
+//#endregion
+//#region src/cli.ts
+var rootCommand = defineCommand({
+	meta: {
+		name: "gitignore-sync",
+		version: "0.1.0",
+		description: "Keep a repo's .gitignore maintained: curated blocks in a managed region, re-rendered on demand"
+	},
+	subCommands: {
+		init: initCommand,
+		edit: editCommand,
+		add: addCommand,
+		remove: removeCommand,
+		sync: syncCommand,
+		check: checkCommand,
+		list: listCommand,
+		audit: auditCommand,
+		info: infoCommand
+	}
+});
+//#endregion
+//#region src/bin/gitignore-sync.ts
+process.stdout.on("error", (error) => {
+	if (error.code === "EPIPE") process.exit(0);
+	throw error;
+});
+runMain(rootCommand);
+//#endregion
+
+//# sourceMappingURL=gitignore-sync.mjs.map