@rm-industries/create-forge 0.3.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 RM Industries
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,61 @@
+# `@rm-industries/create-forge`
+
+The publishable Forge project initializer. Once the generator milestone is
+complete, npm will resolve the primary command to this scoped package:
+
+```sh
+npm create @rm-industries/forge@next
+```
+
+The initializer accepts interactive answers, documented defaults through
+`--yes`, or a fully specified set of flags. Run `create-forge --help` for the
+complete input contract. Unless disabled with `--no-install` or `--no-git`, it
+runs `npm install` and initializes a `main`-branch Git repository after files are
+created. It never stages files, reads Git identity, or creates a commit.
+
+The selected template is copied with dotfiles and file modes intact. Forge
+customizes only reviewed metadata files and refuses parent-traversal paths,
+symbolic-link collisions, filesystem roots, and unconfirmed non-empty
+destinations. If copying or customization fails, files created by that
+invocation are removed and overwritten files are restored from temporary
+backups. The error includes recovery guidance if automatic rollback is
+incomplete.
+
+Installation and Git commands inherit the terminal so their progress and errors
+remain visible. A failed or interrupted command exits non-zero and leaves the
+generated project in place with instructions to inspect and retry it.
+
+After successful creation, Forge reports the created path, whether dependency
+and Git setup ran or was skipped, and only the commands still needed to start
+development. Output remains readable when color is disabled and contains no
+telemetry or promotional messages.
+
+## Package verification
+
+From the Forge repository root, build and inspect every workspace package:
+
+```sh
+npm run quality
+```
+
+To build this package, create its actual tarball, install it into an isolated OS
+temporary directory, and exercise the installed executable:
+
+```sh
+npm run verify:package --workspace @rm-industries/create-forge
+```
+
+The verification confirms `--help`, `--version`, and packaged template assets,
+then removes the temporary fixture.
+
+To exercise the packed CLI across the complete generator fixture matrix:
+
+```sh
+npm run test:generator:e2e
+```
+
+This generates default, fully specified, scoped-package-name, no-install, and
+conflict fixtures in an OS temporary directory. The default fixture installs,
+type-checks, and builds outside the Forge workspace. The conflict fixture also
+proves that a failed invocation leaves existing files unchanged. Every fixture
+is removed after the run.

package/dist/index.mjs

@@ -0,0 +1,511 @@
+#!/usr/bin/env node
+import { chmod, copyFile, lstat, mkdir, mkdtemp, readFile, readdir, rm, rmdir, stat, writeFile } from "node:fs/promises";
+import { confirm, isCancel, text } from "@clack/prompts";
+import { Command, CommanderError, Option } from "commander";
+import { basename, dirname, isAbsolute, join, parse, relative, resolve } from "node:path";
+import validateNpmPackageName from "validate-npm-package-name";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+//#region src/prompts.ts
+const clackPrompts = {
+	text: (options) => text({
+		message: options.message,
+		...options.initialValue === void 0 ? {} : { initialValue: options.initialValue },
+		...options.placeholder === void 0 ? {} : { placeholder: options.placeholder },
+		...options.validate === void 0 ? {} : { validate: options.validate }
+	}),
+	confirm,
+	isCancel
+};
+const derivePackageName = (destination) => {
+	return basename(resolve(destination)) || "forge-site";
+};
+const humanizePackageName = (packageName) => {
+	return (packageName.split("/").at(-1) ?? packageName).split(/[-_\s]+/u).filter(Boolean).map((word) => `${word.charAt(0).toUpperCase()}${word.slice(1)}`).join(" ");
+};
+//#endregion
+//#region src/validation.ts
+var InputError = class extends Error {};
+const invalid = (option, value, reason) => {
+	throw new InputError(`Invalid ${option} value ${JSON.stringify(value)}: ${reason}`);
+};
+const validateDestination = (value) => {
+	const destination = value.trim();
+	if (!destination) invalid("destination", value, "provide a non-empty path");
+	if (destination.includes("\0")) invalid("destination", value, "paths cannot contain null bytes");
+	return destination;
+};
+const validatePackageName = (value) => {
+	const packageName = value.trim();
+	const result = validateNpmPackageName(packageName);
+	if (!result.validForNewPackages) {
+		const reason = [...result.errors ?? [], ...result.warnings ?? []].join("; ");
+		invalid("--name", value, reason || "provide a valid npm package name");
+	}
+	return packageName;
+};
+const validatePlainText = (option, value, required = false) => {
+	const text = value.trim();
+	if (required && !text) invalid(option, value, "provide non-empty text");
+	if (/\p{Cc}/u.test(text)) invalid(option, value, "control characters are not allowed");
+	return text;
+};
+const validateUrl = (value) => {
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		return invalid("--url", value, "provide an absolute HTTP(S) URL");
+	}
+	if (!["http:", "https:"].includes(url.protocol)) invalid("--url", value, "provide an absolute HTTP(S) URL");
+	return url.toString();
+};
+const validateRepository = (value) => {
+	const repository = value.trim();
+	if (!repository) return repository;
+	if (!/^[\w.-]+\/[\w.-]+$/u.test(repository)) invalid("--repository", value, "use the GitHub owner/repository format or leave it empty");
+	return repository;
+};
+//#endregion
+//#region src/resolve-options.ts
+var CancellationError = class extends Error {};
+const textValidation = (validator) => (value) => {
+	try {
+		validator(value ?? "");
+		return;
+	} catch (error) {
+		return error instanceof Error ? error.message : "Invalid value";
+	}
+};
+const promptText = async (prompts, options) => {
+	const value = await prompts.text(options);
+	if (prompts.isCancel(value)) throw new CancellationError("Project creation cancelled.");
+	return String(value);
+};
+const promptConfirm = async (prompts, message) => {
+	const value = await prompts.confirm({
+		message,
+		initialValue: true
+	});
+	if (prompts.isCancel(value)) throw new CancellationError("Project creation cancelled.");
+	return Boolean(value);
+};
+const hasEveryExplicitValue = (options) => options.destination !== void 0 && options.packageName !== void 0 && options.siteName !== void 0 && options.description !== void 0 && options.author !== void 0 && options.url !== void 0 && options.repository !== void 0 && options.install !== void 0 && options.git !== void 0;
+const resolveOptions = async (provided, { interactive, prompts }) => {
+	const useDefaults = provided.yes;
+	if (!interactive && !useDefaults && !hasEveryExplicitValue(provided)) throw new InputError("Non-interactive use requires --yes or explicit values for every generator option. Run create-forge --help for details.");
+	const destination = validateDestination(provided.destination ?? (useDefaults ? "." : await promptText(prompts, {
+		message: "Where should we create your project?",
+		placeholder: ".",
+		initialValue: ".",
+		validate: textValidation(validateDestination)
+	})));
+	const derivedPackageName = derivePackageName(destination);
+	const packageName = validatePackageName(provided.packageName ?? (useDefaults ? derivedPackageName : await promptText(prompts, {
+		message: "What should the npm package be named?",
+		initialValue: derivedPackageName,
+		validate: textValidation(validatePackageName)
+	})));
+	const defaultSiteName = humanizePackageName(packageName);
+	return {
+		destination,
+		packageName,
+		siteName: validatePlainText("--site-name", provided.siteName ?? (useDefaults ? defaultSiteName : await promptText(prompts, {
+			message: "What should the site be called?",
+			initialValue: defaultSiteName,
+			validate: textValidation((value) => validatePlainText("--site-name", value, true))
+		})), true),
+		description: validatePlainText("--description", provided.description ?? (useDefaults ? "A content-driven website built with Forge" : await promptText(prompts, {
+			message: "How would you describe the site?",
+			initialValue: "A content-driven website built with Forge",
+			validate: textValidation((value) => validatePlainText("--description", value))
+		}))),
+		author: validatePlainText("--author", provided.author ?? (useDefaults ? "" : await promptText(prompts, {
+			message: "Who is the site author?",
+			placeholder: "Optional",
+			validate: textValidation((value) => validatePlainText("--author", value))
+		}))),
+		url: validateUrl(provided.url ?? (useDefaults ? "https://example.com" : await promptText(prompts, {
+			message: "What is the canonical site URL?",
+			initialValue: "https://example.com",
+			validate: textValidation(validateUrl)
+		}))),
+		repository: validateRepository(provided.repository ?? (useDefaults ? "" : await promptText(prompts, {
+			message: "What is the GitHub repository?",
+			placeholder: "owner/repository (optional)",
+			validate: textValidation(validateRepository)
+		}))),
+		install: provided.install ?? (useDefaults ? true : await promptConfirm(prompts, "Install dependencies?")),
+		git: provided.git ?? (useDefaults ? true : await promptConfirm(prompts, "Initialize a Git repository?"))
+	};
+};
+//#endregion
+//#region src/cli.ts
+const hasBoth = (args, positive, negative) => args.includes(positive) && args.includes(negative);
+const parseArguments = (args, version) => {
+	let output = "";
+	const program = new Command().name("create-forge").description("Create a content-driven Forge website").argument("[destination]", "directory where the project will be created").option("--name <name>", "npm package name (defaults to the directory basename)").option("--site-name <name>", "site name").option("--description <text>", "site description").option("--author <name>", "site author").option("--url <url>", "absolute canonical HTTP(S) URL").option("--repository <owner/repository>", "GitHub repository or an empty value").addOption(new Option("--install", "install dependencies")).addOption(new Option("--no-install", "do not install dependencies")).addOption(new Option("--git", "initialize a Git repository")).addOption(new Option("--no-git", "do not initialize a Git repository")).option("-y, --yes", "use documented defaults without prompting", false).version(version, "-v, --version", "show the installed package version").helpOption("-h, --help", "show this help message").showHelpAfterError().allowExcessArguments(false).exitOverride().configureOutput({
+		writeOut: (value) => {
+			output += value;
+		},
+		writeErr: (value) => {
+			output += value;
+		}
+	});
+	try {
+		program.parse(args, { from: "user" });
+	} catch (error) {
+		if (error instanceof CommanderError) return {
+			output,
+			exitCode: error.exitCode
+		};
+		throw error;
+	}
+	if (hasBoth(args, "--install", "--no-install")) return {
+		output: "error: --install cannot be used with --no-install\n",
+		exitCode: 1
+	};
+	if (hasBoth(args, "--git", "--no-git")) return {
+		output: "error: --git cannot be used with --no-git\n",
+		exitCode: 1
+	};
+	const raw = program.opts();
+	return { provided: {
+		destination: program.args[0],
+		packageName: raw.name,
+		siteName: raw.siteName,
+		description: raw.description,
+		author: raw.author,
+		url: raw.url,
+		repository: raw.repository,
+		install: raw.install,
+		git: raw.git,
+		yes: raw.yes
+	} };
+};
+const runCli = async (args, version, context = {}) => {
+	const parsed = parseArguments(args, version);
+	if (!("provided" in parsed)) return parsed;
+	try {
+		return {
+			output: "",
+			exitCode: 0,
+			options: await resolveOptions(parsed.provided, {
+				interactive: context.interactive ?? Boolean(process.stdin.isTTY && process.stdout.isTTY),
+				prompts: context.prompts ?? clackPrompts
+			})
+		};
+	} catch (error) {
+		if (error instanceof CancellationError) return {
+			output: `${error.message}\n`,
+			exitCode: 1
+		};
+		if (error instanceof Error) return {
+			output: `error: ${error.message}\n`,
+			exitCode: 1
+		};
+		throw error;
+	}
+};
+//#endregion
+//#region src/template-tokens.ts
+const prefix = "__RM_INDUSTRIES_FORGE_TEMPLATE_V1_";
+const templateTokens = Object.freeze({
+	packageName: `${prefix}PACKAGE_NAME__`,
+	siteName: `${prefix}SITE_NAME__`,
+	description: `${prefix}DESCRIPTION__`,
+	author: `${prefix}AUTHOR__`,
+	url: `${prefix}URL__`,
+	repository: `${prefix}REPOSITORY__`
+});
+const templateTokenPrefix = prefix;
+//#endregion
+//#region src/materialize.ts
+var MaterializationError = class extends Error {};
+const pathExists = async (path) => {
+	try {
+		await lstat(path);
+		return true;
+	} catch (error) {
+		if (error.code === "ENOENT") return false;
+		throw error;
+	}
+};
+const getPathStat = async (path) => {
+	try {
+		return await lstat(path);
+	} catch (error) {
+		if (error.code === "ENOENT") return void 0;
+		throw error;
+	}
+};
+const assertNotAborted = (signal) => {
+	if (signal?.aborted) throw new Error("Project creation was interrupted.");
+};
+const resolveTemplateDirectory = (directory) => directory instanceof URL ? fileURLToPath(directory) : resolve(directory);
+const resolveDestination = (destination, cwd) => {
+	if (destination.split(/[\\/]/u).includes("..")) throw new MaterializationError(`Unsafe destination ${JSON.stringify(destination)}: parent traversal is not allowed.`);
+	const resolved = isAbsolute(destination) ? resolve(destination) : resolve(cwd, destination);
+	if (resolved === parse(resolved).root) throw new MaterializationError(`Unsafe destination ${JSON.stringify(destination)}: a filesystem root is not allowed.`);
+	return resolved;
+};
+const listTemplateFiles = async (root, directory = root) => {
+	const entries = await readdir(directory, { withFileTypes: true });
+	const files = [];
+	for (const entry of entries) {
+		const source = join(directory, entry.name);
+		if (entry.isDirectory()) {
+			files.push(...await listTemplateFiles(root, source));
+			continue;
+		}
+		if (!entry.isFile()) throw new MaterializationError(`Template entry ${source} is not a regular file.`);
+		files.push({
+			source,
+			relativePath: relative(root, source),
+			mode: (await stat(source)).mode
+		});
+	}
+	return files.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
+};
+const isDirectoryEmpty = async (directory) => (await readdir(directory)).length === 0;
+const ensureDirectory = async (directory, created) => {
+	const existing = await getPathStat(directory);
+	if (existing) {
+		if (existing.isSymbolicLink() || !existing.isDirectory()) throw new Error(`Unsafe destination entry ${directory}: expected a regular directory.`);
+		return;
+	}
+	const parent = dirname(directory);
+	if (parent !== directory) await ensureDirectory(parent, created);
+	await mkdir(directory);
+	created.add(directory);
+};
+const replaceToken = (source, token, value, field) => {
+	const quotedToken = `'${token}'`;
+	if (!source.includes(quotedToken)) throw new Error(`Packaged template is missing the ${field} token.`);
+	return source.replaceAll(quotedToken, JSON.stringify(value));
+};
+const customizeTemplate = async (destination, options) => {
+	const packagePath = join(destination, "package.json");
+	const packageLockPath = join(destination, "package-lock.json");
+	const packageMetadata = JSON.parse(await readFile(packagePath, "utf8"));
+	const packageLock = JSON.parse(await readFile(packageLockPath, "utf8"));
+	if (packageMetadata.name !== templateTokens.packageName || packageLock.name !== templateTokens.packageName || packageLock.packages?.[""]?.name !== templateTokens.packageName) throw new Error("Packaged template contains unexpected package metadata tokens.");
+	packageMetadata.name = options.packageName;
+	packageMetadata.version = "0.0.0";
+	packageMetadata.private = true;
+	packageLock.name = options.packageName;
+	if (!packageLock.packages?.[""]) throw new Error("Packaged template lockfile is missing its root package metadata.");
+	packageLock.packages[""].name = options.packageName;
+	packageLock.packages[""].version = "0.0.0";
+	await writeFile(packagePath, `${JSON.stringify(packageMetadata, void 0, 2)}\n`);
+	await writeFile(packageLockPath, `${JSON.stringify(packageLock, void 0, 2)}\n`);
+	const siteConfigPath = join(destination, "src", "config", "site.ts");
+	let siteConfig = await readFile(siteConfigPath, "utf8");
+	siteConfig = replaceToken(siteConfig, templateTokens.siteName, options.siteName, "site name");
+	siteConfig = replaceToken(siteConfig, templateTokens.description, options.description, "description");
+	siteConfig = replaceToken(siteConfig, templateTokens.author, options.author, "author");
+	siteConfig = replaceToken(siteConfig, templateTokens.url, options.url, "URL");
+	siteConfig = replaceToken(siteConfig, templateTokens.repository, options.repository, "repository");
+	if (siteConfig.includes("__RM_INDUSTRIES_FORGE_TEMPLATE_V1_")) throw new Error("Packaged template contains unresolved tokens.");
+	await writeFile(siteConfigPath, siteConfig);
+};
+const materializeProject = async (options, context) => {
+	const cwd = context.cwd ?? process.cwd();
+	const destination = resolveDestination(options.destination, cwd);
+	const templateDirectory = resolveTemplateDirectory(context.templateDirectory);
+	const destinationExisted = await pathExists(destination);
+	if (destinationExisted) {
+		const destinationStat = await lstat(destination);
+		if (destinationStat.isSymbolicLink() || !destinationStat.isDirectory()) throw new MaterializationError(`Unsafe destination ${destination}: expected a regular directory.`);
+	}
+	if (destinationExisted && !await isDirectoryEmpty(destination)) {
+		if (!await context.confirmOverwrite?.(destination)) throw new MaterializationError(`Destination ${destination} is not empty. No files were changed.`);
+	}
+	const files = await listTemplateFiles(templateDirectory);
+	const backupDirectory = await mkdtemp(join(tmpdir(), "create-forge-backup-"));
+	const createdFiles = /* @__PURE__ */ new Set();
+	const createdDirectories = /* @__PURE__ */ new Set();
+	const backups = /* @__PURE__ */ new Map();
+	try {
+		assertNotAborted(context.signal);
+		await ensureDirectory(destination, createdDirectories);
+		for (const file of files) {
+			assertNotAborted(context.signal);
+			const target = join(destination, file.relativePath);
+			const targetRelative = relative(destination, target);
+			if (targetRelative.startsWith("..") || isAbsolute(targetRelative)) throw new Error(`Unsafe template path ${file.relativePath}.`);
+			await ensureDirectory(dirname(target), createdDirectories);
+			const targetStat = await getPathStat(target);
+			if (targetStat) {
+				if (targetStat.isSymbolicLink() || !targetStat.isFile()) throw new Error(`Unsafe destination entry ${target}: expected a regular file.`);
+				const backup = join(backupDirectory, file.relativePath);
+				await mkdir(dirname(backup), { recursive: true });
+				await copyFile(target, backup);
+				backups.set(target, backup);
+			} else createdFiles.add(target);
+			await copyFile(file.source, target);
+			await chmod(target, file.mode);
+			context.onFileCopied?.(target);
+		}
+		assertNotAborted(context.signal);
+		await customizeTemplate(destination, options);
+		const tokenBytes = Buffer.from(templateTokenPrefix);
+		for (const file of files) {
+			assertNotAborted(context.signal);
+			if ((await readFile(join(destination, file.relativePath))).includes(tokenBytes)) throw new Error(`Generated file ${file.relativePath} contains an unresolved template token.`);
+		}
+		return {
+			destination,
+			filesCopied: files.length
+		};
+	} catch (error) {
+		const cleanupErrors = [];
+		for (const [target, backup] of backups) try {
+			await copyFile(backup, target);
+		} catch (cleanupError) {
+			cleanupErrors.push(cleanupError);
+		}
+		for (const file of createdFiles) try {
+			await rm(file, { force: true });
+		} catch (cleanupError) {
+			cleanupErrors.push(cleanupError);
+		}
+		for (const directory of [...createdDirectories].sort((left, right) => right.length - left.length)) try {
+			await rmdir(directory);
+		} catch (cleanupError) {
+			if (!["ENOENT", "ENOTEMPTY"].includes(cleanupError.code ?? "")) cleanupErrors.push(cleanupError);
+		}
+		throw new MaterializationError(`${error instanceof Error ? error.message : String(error)} ${cleanupErrors.length ? `Recovery: review ${destination}; some changes could not be rolled back automatically.` : `Recovery: changes from this invocation were rolled back; resolve the error and retry.`}`, { cause: error });
+	} finally {
+		await rm(backupDirectory, {
+			recursive: true,
+			force: true
+		});
+	}
+};
+//#endregion
+//#region src/process.ts
+var ProcessStepError = class extends Error {
+	exitCode;
+	constructor(message, exitCode = 1, options) {
+		super(message, options);
+		this.exitCode = exitCode;
+	}
+};
+const signalExitCode = (signal) => {
+	if (signal === "SIGINT") return 130;
+	if (signal === "SIGTERM") return 143;
+	return 1;
+};
+const executeCommand = ({ executable, arguments: args, cwd, signal, environment }) => new Promise((resolve, reject) => {
+	const child = spawn(executable, args, {
+		cwd,
+		stdio: "inherit",
+		...signal ? { signal } : {},
+		...environment ? { env: environment } : {}
+	});
+	child.once("error", (error) => {
+		const interrupted = signal?.aborted;
+		reject(new ProcessStepError(interrupted ? `${executable} was interrupted. The generated project remains at ${cwd}.` : `Could not start ${executable}: ${error.message}. The generated project remains at ${cwd}.`, interrupted ? 130 : 1, { cause: error }));
+	});
+	child.once("close", (code, processSignal) => {
+		if (code === 0) {
+			resolve();
+			return;
+		}
+		reject(new ProcessStepError(`${executable} failed with ${processSignal ? `signal ${processSignal}` : `exit code ${code ?? "unknown"}`}. The generated project remains at ${cwd}; review the output above and retry the command there.`, processSignal ? signalExitCode(processSignal) : code ?? 1));
+	});
+});
+const runProjectSetup = async (options, context) => {
+	const execute = context.execute ?? executeCommand;
+	const command = (executable, args) => execute({
+		executable,
+		arguments: args,
+		cwd: context.destination,
+		...context.signal ? { signal: context.signal } : {},
+		...context.environment ? { environment: context.environment } : {}
+	});
+	if (options.install) await command("npm", ["install"]);
+	if (options.git) await command("git", ["init", "--initial-branch=main"]);
+};
+//#endregion
+//#region src/reporter.ts
+const ansi = {
+	bold: (value) => `\u001B[1m${value}\u001B[22m`,
+	green: (value) => `\u001B[32m${value}\u001B[39m`
+};
+const commandPath = (path) => {
+	if (/^[\w./@-]+$/u.test(path)) return path;
+	return `"${path.replaceAll("\"", "\\\"")}"`;
+};
+const displayDestination = (destination, cwd) => {
+	const path = relative(cwd, destination);
+	if (!path) return ".";
+	return isAbsolute(path) ? destination : path;
+};
+const supportsColor = (environment = process.env, terminal = Boolean(process.stdout.isTTY)) => terminal && environment.NO_COLOR === void 0;
+const formatCompletion = (options, context) => {
+	const cwd = context.cwd ?? process.cwd();
+	const decorate = context.color ?? supportsColor() ? ansi : {
+		bold: (value) => value,
+		green: (value) => value
+	};
+	const destination = displayDestination(context.destination, cwd);
+	const commands = [
+		...destination === "." ? [] : [`cd ${commandPath(destination)}`],
+		...options.install ? [] : ["npm install"],
+		"npm run dev"
+	];
+	return `${decorate.green("✓")} Created ${options.siteName} in ${destination}\n\n${decorate.bold("Setup")}\n  Dependencies: ${options.install ? "installed" : "skipped"}\n  Git repository: ${options.git ? "initialized" : "skipped"}\n\n${decorate.bold("Next steps")}\n${commands.map((command) => `  ${command}`).join("\n")}\n`;
+};
+//#endregion
+//#region src/index.ts
+const packageJson = new URL("../package.json", import.meta.url);
+const metadata = JSON.parse(await readFile(packageJson, "utf8"));
+const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+const result = await runCli(process.argv.slice(2), metadata.version, { interactive });
+if (result.options) {
+	const controller = new AbortController();
+	let interruptedExitCode;
+	const interrupt = () => {
+		interruptedExitCode = 130;
+		controller.abort();
+	};
+	const terminate = () => {
+		interruptedExitCode = 143;
+		controller.abort();
+	};
+	process.once("SIGINT", interrupt);
+	process.once("SIGTERM", terminate);
+	try {
+		const materialized = await materializeProject(result.options, {
+			templateDirectory: new URL("./template/", import.meta.url),
+			signal: controller.signal,
+			...interactive ? { confirmOverwrite: async (destination) => {
+				const answer = await confirm({
+					message: `${destination} is not empty. Continue and overwrite conflicting template files?`,
+					initialValue: false
+				});
+				return !isCancel(answer) && answer;
+			} } : {}
+		});
+		await runProjectSetup(result.options, {
+			destination: materialized.destination,
+			signal: controller.signal
+		});
+		result.output = formatCompletion(result.options, { destination: materialized.destination });
+	} catch (error) {
+		result.output = `error: ${error instanceof Error ? error.message : String(error)}\n`;
+		result.exitCode = interruptedExitCode ?? (error instanceof ProcessStepError ? error.exitCode : 1);
+	} finally {
+		process.off("SIGINT", interrupt);
+		process.off("SIGTERM", terminate);
+	}
+}
+process.stdout.write(result.output);
+process.exitCode = result.exitCode;
+//#endregion
+export {};
+
+//# sourceMappingURL=index.mjs.map