@adbayb/stack 0.0.0-next-5dd260c → 0.0.0-next.d8e717b

package/dist/index.js

@@ -1,820 +1,860 @@
-import { helpers, termost } from 'termost';
-import { createRequire } from 'node:module';
-import { resolve, join } from 'node:path';
-import { existsSync, readdirSync, cpSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
-import { rm, mkdir, symlink, writeFile, chmod } from 'node:fs/promises';
-import { fdir } from 'fdir';
+import { helpers, termost } from "termost";
+import { createRequire } from "node:module";
+import { basename, join, resolve } from "node:path";
+import { existsSync, readdirSync } from "node:fs";
+import { chmod, cp, mkdir, readFile, readdir, rename, rm, symlink, writeFile } from "node:fs/promises";
 
-const require$1 = createRequire(import.meta.url);
-function assert(expectedCondition, createError) {
-    if (!expectedCondition) {
-        throw createError();
-    }
-}
+//#region src/helpers.ts
+const require = createRequire(import.meta.url);
+const assert = (expectedCondition, createError) => {
+	if (!expectedCondition) throw createError();
+};
 /**
- * Helper to format log messages with a welcoming bot.
- * @param input - Message factory.
- * @param input.title - Title input.
- * @param input.description - Description input.
- * @param input.body - Body input.
- * @param input.type - Message type.
- * @example
- * botMessage(
- *	{
- * 		title: "Oops, an error occurred",
- * 		description:
- * 			"Keep calm and carry on with some coffee ☕️",
- * 		body: String(previousTaskError),
- * 		type: "error",
- * 	},
- * );
- */ const botMessage = (input)=>{
-    const { type } = input;
-    const log = type === "error" ? console.error : console.log;
-    const colorByType = {
-        error: "red",
-        information: "blue",
-        success: "green"
-    };
-    log(helpers.format(`
+* Helper to format log messages with a welcoming bot.
+*
+* @example
+* 	botMessage({
+* 		title: "Oops, an error occurred",
+* 		description: "Keep calm and carry on with some coffee ☕️",
+* 		body: String(previousTaskError),
+* 		type: "error",
+* 	});
+*
+* @param input - Message factory.
+* @param input.title - Title input.
+* @param input.description - Description input.
+* @param input.body - Body input.
+* @param input.type - Message type.
+*/
+const botMessage = (input) => {
+	const { type } = input;
+	const log = console[type === "error" ? "error" : "log"];
+	log(helpers.format(`
 ╭─────╮
 │ ◠   ◠  ${input.title}
 │   ${type === "error" ? "◠" : "◡"} │  ${input.description}
 ╰─────╯
 ${input.body ? `
 ${input.body}
-` : ""}`, {
-        color: colorByType[type]
-    }));
+` : ""}`, { color: {
+		error: "red",
+		information: "blue",
+		success: "green"
+	}[type] }));
 };
 /**
- * Resolve a relative path to an absolute one resolved from the generated project root directory.
- * @param path - The relative path.
- * @returns The resolved absolute path.
- * @example
- * resolveFromProjectDirectory(".gitignore");
- */ const resolveFromProjectDirectory = (path)=>{
-    return resolve(process.cwd(), path);
+* Resolve a relative path to an absolute one resolved from the generated project root directory.
+*
+* @example
+* 	resolveFromWorkingDirectory(".gitignore");
+*
+* @param path - The relative path.
+* @returns The resolved absolute path.
+*/
+const resolveFromWorkingDirectory = (...path) => {
+	return resolve(process.cwd(), ...path);
 };
 /**
- * Resolve a relative path to an absolute one resolved from the `stack` node module directory.
- * @param path - The relative path.
- * @returns The resolved absolute path.
- * @example
- * resolveFromStackDirectory("./templates");
- */ const resolveFromStackDirectory = (path)=>{
-    return resolve(import.meta.dirname, "../", path);
-};
-const createError = (bin, error)=>{
-    const errorMessage = `\`${bin}\` command failed.\n${String(error)}`;
-    if (error instanceof Error) {
-        error.message = errorMessage;
-        return error;
-    }
-    return new Error(errorMessage);
-};
-const checkPackageManager = async ()=>{
-    try {
-        await helpers.exec("npx only-allow pnpm");
-    } catch  {
-        throw createError("pnpm", "The project must use `pnpm` as a node package manager tool. Follow this installation guide https://pnpm.io/installation");
-    }
-};
-const getNpmVersion = async ()=>{
-    try {
-        return await helpers.exec("pnpm -v");
-    } catch  {
-        throw createError("pnpm", "The project must use `pnpm` as a node package manager tool. Follow this installation guide https://pnpm.io/installation");
-    }
-};
-const getStackCommand = (command, isNodeRuntime = true)=>{
-    /**
-	 * `isNodeRuntime` allows executing node bin executables in a non node environment such as in git hooks context
-	 * Npx is used to make executable resolution independent from the build tool (npx is the built-in Node tool)
-	 * `--no` flag to prevent installation prompt and throw an error if the binary is not installed.
-	 */ return [
-        ...isNodeRuntime ? [] : [
-            "npx --no"
-        ],
-        `stack ${command}`
-    ].join(" ");
-};
-const hasDependency = (packageName)=>{
-    return Boolean(require$1.resolve(packageName));
-};
-const setPackageManager = async ()=>{
-    /**
-	 * Corepack is downloaded remotely to get always up-to-date npm registry fingerprints since they're hardcoded.
-	 * @see {@link https://github.com/nodejs/corepack/issues/613}
-	 */ return helpers.exec("npx corepack enable");
-};
-const request = {
-    async get (url, responseType) {
-        const response = await fetch(url);
-        if (!response.ok) {
-            throw createError("fetch", `Failed to fetch resources from ${url} (${JSON.stringify({
-                status: response.status,
-                statusText: response.statusText
-            })})`);
-        }
-        return responseType === "text" ? response.text() : response.json();
-    }
-};
-const eslint = (options)=>async (files = [])=>{
-        let eslintFiles = [];
-        if (files.length === 0) {
-            eslintFiles.push(".");
-        } else {
-            eslintFiles = files.filter((file)=>{
-                return ESLINT_EXTENSIONS.some((extension)=>file.endsWith(extension));
-            });
-            if (eslintFiles.length === 0) return;
-        }
-        const arguments_ = [
-            ...eslintFiles,
-            "--cache",
-            `--cache-location ${resolveFromProjectDirectory("node_modules/.cache/.eslintcache")}`,
-            "--no-error-on-unmatched-pattern"
-        ];
-        if (options.isFixMode) {
-            arguments_.push("--fix");
-        }
-        try {
-            return await helpers.exec(`eslint ${arguments_.join(" ")}`);
-        } catch (error) {
-            throw createError("eslint", error);
-        }
-    };
-const turbo = async (command, options = {})=>{
-    try {
-        const { excludeExamples = false, hasLiveOutput = true, ...restOptions } = options;
-        return await helpers.exec(`turbo run ${command} ${excludeExamples ? "--filter !@examples/*" : ""}`, {
-            ...restOptions,
-            hasLiveOutput
-        });
-    } catch (error) {
-        throw createError("turbo", error);
-    }
-};
-const logCheckableFiles = (files)=>{
-    if (files.length === 0) {
-        helpers.message("The whole project will be checked.", {
-            label: false,
-            lineBreak: {
-                end: true,
-                start: false
-            }
-        });
-        return;
-    }
-    helpers.message(files.join("\n   "), {
-        label: "Following files will be checked:",
-        lineBreak: {
-            end: true,
-            start: false
-        }
-    });
-};
-const changeset = async (command)=>{
-    try {
-        return await helpers.exec(command, {
-            hasLiveOutput: true
-        });
-    } catch (error) {
-        throw createError("changeset", error);
-    }
-};
-const ESLINT_EXTENSIONS = [
-    "js",
-    "jsx",
-    "cjs",
-    "mjs",
-    "ts",
-    "tsx",
-    "cts",
-    "mts",
-    "md",
-    "mdx"
-];
+* Resolve a relative path to an absolute one resolved from the `stack` node module directory.
+*
+* @example
+* 	resolveFromPackageDirectory("./templates");
+*
+* @param path - The relative path.
+* @returns The resolved absolute path.
+*/
+const resolveFromPackageDirectory = (...path) => {
+	return resolve(import.meta.dirname, "../", ...path);
+};
+const createError = (bin, error) => {
+	const errorMessage = `\`${bin}\` command failed.\n${String(error)}`;
+	if (error instanceof Error) {
+		error.message = errorMessage;
+		return error;
+	}
+	return new Error(errorMessage);
+};
+const getPnpmVersion = async () => {
+	try {
+		return await helpers.exec("pnpm -v");
+	} catch {
+		throw createError("pnpm", "The project must use `pnpm` as a node package manager tool. Follow this installation guide https://pnpm.io/installation");
+	}
+};
+const getStackCommand = (command) => {
+	return `pnpm stack ${command}`;
+};
+const setPackageManager = async () => {
+	/**
+	* Corepack is downloaded remotely to get always up-to-date npm registry fingerprints since
+	* they're hardcoded.
+	*
+	* @see {@link https://github.com/nodejs/corepack/issues/613}
+	*/
+	await helpers.exec("pnx corepack enable");
+};
+const request = { async get(url, responseType) {
+	const response = await fetch(url);
+	if (!response.ok) throw createError("fetch", `Failed to fetch resources from ${url} (${JSON.stringify({
+		status: response.status,
+		statusText: response.statusText
+	})})`);
+	return responseType === "text" ? response.text() : response.json();
+} };
+const oxlint = (options) => {
+	return async (files = []) => {
+		const args = [
+			...files,
+			"--disable-nested-config",
+			"--no-error-on-unmatched-pattern"
+		];
+		if (options.isFixMode) args.push("--fix-dangerously");
+		try {
+			return await helpers.exec(`oxlint ${args.join(" ")}`);
+		} catch (error) {
+			throw createError("oxlint", error instanceof Error ? error : new Error(String(error)));
+		}
+	};
+};
+const oxfmt = (options) => {
+	return async (files = []) => {
+		const args = [
+			...files,
+			"--disable-nested-config",
+			"--no-error-on-unmatched-pattern",
+			options.isFixMode ? "--write" : "--check"
+		];
+		try {
+			return await helpers.exec(`oxfmt ${args.join(" ")}`);
+		} catch (error) {
+			throw createError("oxfmt", error instanceof Error ? error : new Error(String(error)));
+		}
+	};
+};
+const turbo = async (command, options = {}) => {
+	try {
+		const { excludeExamples = false, hasLiveOutput = true, ...restOptions } = options;
+		return await helpers.exec(`turbo run ${command} ${excludeExamples ? "--filter !@examples/*" : ""}`, {
+			...restOptions,
+			hasLiveOutput
+		});
+	} catch (error) {
+		throw createError("turbo", error instanceof Error ? error : new Error(String(error)));
+	}
+};
+const logCheckableFiles = (files) => {
+	if (files.length === 0) {
+		helpers.message("The whole project will be checked.", {
+			label: false,
+			lineBreak: {
+				end: true,
+				start: false
+			}
+		});
+		return;
+	}
+	helpers.message(files.join("\n   "), {
+		label: "Following files will be checked:",
+		lineBreak: {
+			end: true,
+			start: false
+		}
+	});
+};
+const changeset = async (command) => {
+	try {
+		return await helpers.exec(command, { hasLiveOutput: true });
+	} catch (error) {
+		throw createError("changeset", error instanceof Error ? error : new Error(String(error)));
+	}
+};
 
-const createBuildCommand = (program)=>{
-    program.command({
-        description: "Build the project in production mode",
-        name: "build"
-    }).task({
-        async handler () {
-            await turbo("build");
-        }
-    });
+//#endregion
+//#region src/commands/build.ts
+const createBuildCommand = (program) => {
+	program.command({
+		name: "build",
+		description: "Build the project in production mode"
+	}).task({ async handler() {
+		await turbo("build");
+	} });
 };
 
-const checkCode = eslint({
-    isFixMode: false
-});
+//#endregion
+//#region src/commands/check/checkCode.ts
+const checkCode = oxlint({ isFixMode: false });
 
-const checkCommit = async ()=>{
-    try {
-        return await helpers.exec('commitlint --extends "@commitlint/config-conventional" --edit');
-    } catch (error) {
-        throw createError("commitlint", error);
-    }
+//#endregion
+//#region src/commands/check/checkCommit.ts
+const checkCommit = async () => {
+	try {
+		return await helpers.exec("commitlint --extends \"@commitlint/config-conventional\" --edit");
+	} catch (error) {
+		throw createError("commitlint", error instanceof Error ? error : new Error(String(error)));
+	}
 };
 
-const checkDependency = async ()=>{
-    const stdout = await helpers.exec("pnpm recursive ls --json");
-    const checkDependencyVersionMismatch = createPackagesVersionMismatchChecker();
-    const packages = JSON.parse(stdout).map((package_)=>{
-        const packagePath = join(package_.path, "package.json");
-        assert(package_.name, ()=>createPackageError(`\`${packagePath}\` must have a name field.`));
-        const packageContent = require$1(packagePath);
-        const peerDependencies = packageContent.peerDependencies ?? {};
-        const devDependencies = packageContent.devDependencies ?? {};
-        const dependencies = packageContent.dependencies ?? {};
-        return {
-            dependencies,
-            devDependencies,
-            name: package_.name,
-            peerDependencies
-        };
-    });
-    for (const package_ of packages){
-        // Check version mismatches to guarantee a single copy for a given package in the monorepo (use case: prevent singleton-like issues with React contexts)
-        checkDependencyVersionMismatch(package_);
-        // Check version range accordingly to our dependency guidelines (ie. dev dependencies must be pinned and dependencies must have caret)
-        checkDependencyVersionRange(package_);
-    }
-};
-const checkDependencyVersionRange = ({ dependencies, devDependencies, name, peerDependencies })=>{
-    for (const dependencyName of Object.keys(devDependencies)){
-        const version = devDependencies[dependencyName];
-        assertVersion(version, {
-            consumedBy: name,
-            name: dependencyName
-        });
-        if (version !== "workspace:*" && !isExcluded(version) && !/^\d/.test(version)) throw createPackageError(`As a dev dependency, \`${dependencyName}\` version must be fixed (or set as "workspace:*" for local packages) to reduce accidental breaking change risks due to an implicit semver upgrade.`, {
-            consumedBy: name,
-            name: dependencyName
-        });
-    }
-    for (const dependencyName of Object.keys(dependencies)){
-        const version = dependencies[dependencyName];
-        assertVersion(version, {
-            consumedBy: name,
-            name: dependencyName
-        });
-        if (version !== "workspace:^" && !hasCaret(version) && !isExcluded(version)) throw createPackageError(`As a dependency, \`${dependencyName}\` version must be prefixed with a caret (or set as "workspace:^" for local packages) to optimize the size (whether of installation or bundle output) on the consumer side.`, {
-            consumedBy: name,
-            name: dependencyName
-        });
-    }
-    for (const dependencyName of Object.keys(peerDependencies)){
-        const version = peerDependencies[dependencyName];
-        assertVersion(version, {
-            consumedBy: name,
-            name: dependencyName
-        });
-        if (!hasCaret(version) && !isExcluded(version)) /*
-			 * Why disallowing workspace protocol as a version resolver?
-			 * To reduce the update frequency needs consumer-side and guarantee on our side the minimum compatible version,
-			 * the best practice should be to keeping an explicit number version which represents the lowest compatible version from an API perspective.
-			 */ throw createPackageError(`As a peer dependency, \`${dependencyName}\` version must be explicit (i.e. the "workspace:^" protocol a version resolver is not allowed) and prefixed with a caret to optimize the size (whether of installation or bundle output) on the consumer side.`, {
-            consumedBy: name,
-            name: dependencyName
-        });
-    }
-};
-const createPackagesVersionMismatchChecker = ()=>{
-    const monorepoDependencies = new Map();
-    const monorepoDevelopmentDependencies = new Map();
-    const lint = (package_, type)=>{
-        const packageName = package_.name;
-        const isDevelopment = type === "development";
-        const store = isDevelopment ? monorepoDevelopmentDependencies : monorepoDependencies;
-        const dependencies = isDevelopment ? package_.devDependencies : package_.dependencies;
-        for (const dependencyName of Object.keys(dependencies)){
-            const depVersion = dependencies[dependencyName];
-            if (!depVersion) continue;
-            const storedVersion = store.get(dependencyName);
-            if (!storedVersion) {
-                store.set(dependencyName, depVersion);
-                continue;
-            }
-            const isSameMonorepoVersion = depVersion === storedVersion;
-            if (!isSameMonorepoVersion) {
-                throw createPackageError(`Mismatched versions: received version \`${depVersion}\` while others use \`${storedVersion}\`. To prevent issues with singleton-like code (React contexts, …), please make sure to update all packages to use the same \`${dependencyName}\` version (either \`${storedVersion}\` or \`${depVersion}\`).`, {
-                    consumedBy: packageName,
-                    name: dependencyName
-                });
-            }
-        }
-    };
-    return (package_)=>{
-        lint(package_, "development");
-        lint(package_, "production");
-    };
-};
-const createPackageError = (message, context)=>{
-    return createError("stack check", context ? `\`${context.name}\` consumed by \`${context.consumedBy}\` doesn't conform to package guidelines.\n${message}` : message);
-};
-function assertVersion(version, { consumedBy, name }) {
-    assert(version, ()=>createPackageError(`\`${name}\` must have a valid version specified (current version equals to \`${String(version)}\`).`, {
-            consumedBy,
-            name
-        }));
-}
-const isExcluded = (version)=>{
-    const isPreReleaseVersion = /\d+\.\d+\.\d+-(alpha|beta|experimental|next|rc).*/.exec(version);
-    const isNpmProtocol = version.startsWith("npm:");
-    return isNpmProtocol || isPreReleaseVersion;
-};
-const hasCaret = (version)=>version.startsWith("^");
-
-const checkType = async ()=>{
-    try {
-        return await helpers.exec("pnpm --parallel exec tsc --noEmit");
-    } catch (error) {
-        throw createError("tsc", error);
-    }
+//#endregion
+//#region src/commands/check/checkDependency.ts
+const checkDependency = async () => {
+	const stdout = await helpers.exec("pnpm recursive ls --json");
+	const checkDependencyVersionMismatch = createPackagesVersionMismatchChecker();
+	const packages = JSON.parse(stdout).map((pkg) => {
+		const packagePath = join(pkg.path, "package.json");
+		assert(pkg.name, () => {
+			return createPackageError(`\`${packagePath}\` must have a name field.`);
+		});
+		const packageContent = require(packagePath);
+		const peerDependencies = packageContent.peerDependencies ?? {};
+		const devDependencies = packageContent.devDependencies ?? {};
+		const dependencies = packageContent.dependencies ?? {};
+		return {
+			name: pkg.name,
+			dependencies,
+			devDependencies,
+			peerDependencies
+		};
+	});
+	for (const pkg of packages) {
+		checkDependencyVersionMismatch(pkg);
+		checkDependencyVersionRange(pkg);
+	}
+};
+const STARTING_WITH_DIGIT_REGEXP = /^\d/u;
+const checkDependencyVersionRange = ({ name, dependencies, devDependencies, peerDependencies }) => {
+	for (const [dependencyName, version] of Object.entries(devDependencies)) {
+		assertVersion(version, {
+			name: dependencyName,
+			consumedBy: name
+		});
+		if (version !== "workspace:*" && !isExcluded(version) && !STARTING_WITH_DIGIT_REGEXP.test(version)) throw createPackageError(`As a dev dependency, \`${dependencyName}\` version must be fixed (or set as "workspace:*" for local packages) to reduce accidental breaking change risks due to an implicit semver upgrade.`, {
+			name: dependencyName,
+			consumedBy: name
+		});
+	}
+	for (const [dependencyName, version] of Object.entries(dependencies)) {
+		assertVersion(version, {
+			name: dependencyName,
+			consumedBy: name
+		});
+		if (version !== "workspace:^" && !hasCaret(version) && !isExcluded(version)) throw createPackageError(`As a dependency, \`${dependencyName}\` version must be prefixed with a caret (or set as "workspace:^" for local packages) to optimize the size (whether of installation or bundle output) on the consumer side.`, {
+			name: dependencyName,
+			consumedBy: name
+		});
+	}
+	for (const [dependencyName, version] of Object.entries(peerDependencies)) {
+		assertVersion(version, {
+			name: dependencyName,
+			consumedBy: name
+		});
+		if (!hasCaret(version) && !isExcluded(version)) throw createPackageError(`As a peer dependency, \`${dependencyName}\` version must be explicit (i.e. the "workspace:^" protocol a version resolver is not allowed) and prefixed with a caret to optimize the size (whether of installation or bundle output) on the consumer side.`, {
+			name: dependencyName,
+			consumedBy: name
+		});
+	}
+};
+const createPackagesVersionMismatchChecker = () => {
+	const monorepoDependencies = /* @__PURE__ */ new Map();
+	const monorepoDevelopmentDependencies = /* @__PURE__ */ new Map();
+	const lint = (pkg, type) => {
+		const packageName = pkg.name;
+		const isDevelopment = type === "development";
+		const store = isDevelopment ? monorepoDevelopmentDependencies : monorepoDependencies;
+		const dependencies = pkg[isDevelopment ? "devDependencies" : "dependencies"];
+		for (const [dependencyName, dependencyVersion] of Object.entries(dependencies)) {
+			if (!dependencyVersion) continue;
+			const storedVersion = store.get(dependencyName);
+			if (!storedVersion) {
+				store.set(dependencyName, dependencyVersion);
+				continue;
+			}
+			if (!(dependencyVersion === storedVersion)) throw createPackageError(`Mismatched versions: received version \`${dependencyVersion}\` while others use \`${storedVersion}\`. To prevent issues with singleton-like code (React contexts, …), please make sure to update all packages to use the same \`${dependencyName}\` version (either \`${storedVersion}\` or \`${dependencyVersion}\`).`, {
+				name: dependencyName,
+				consumedBy: packageName
+			});
+		}
+	};
+	return (pkg) => {
+		lint(pkg, "development");
+		lint(pkg, "production");
+	};
+};
+const createPackageError = (message, context) => {
+	return createError("stack check", context ? `\`${context.name}\` consumed by \`${context.consumedBy}\` doesn't conform to package guidelines.\n${message}` : message);
+};
+const assertVersion = (version, { name, consumedBy }) => {
+	assert(version, () => {
+		return createPackageError(`\`${name}\` must have a valid version specified (current version equals to \`${String(version)}\`).`, {
+			name,
+			consumedBy
+		});
+	});
+};
+const PRERELEASE_VERSION_REGEXP = /\d+\.\d+\.\d+-(alpha|beta|experimental|next|rc).*/u;
+const isExcluded = (version) => {
+	const isPreReleaseVersion = PRERELEASE_VERSION_REGEXP.exec(version);
+	return version.startsWith("npm:") || isPreReleaseVersion;
+};
+const hasCaret = (version) => {
+	return version.startsWith("^");
 };
 
+//#endregion
+//#region src/commands/check/checkFormatting.ts
+const checkFormatting = oxfmt({ isFixMode: false });
+
+//#endregion
+//#region src/commands/check/check.ts
 const ONLY_VALUES = [
-    "commit",
-    "code",
-    "dependency",
-    "type"
+	"commit",
+	"code",
+	"dependency",
+	"formatting"
 ];
-const createCheckCommand = (program)=>{
-    program.command({
-        description: "Check code health (static analysis)",
-        name: "check"
-    }).option({
-        defaultValue: undefined,
-        description: `Filter the compliance check to run (accepted value: ${ONLY_VALUES.join(", ")})`,
-        key: "filter",
-        name: "filter"
-    }).task({
-        handler (_, argv) {
-            logCheckableFiles(argv.operands);
-        },
-        skip: ifFilterDefinedAndNotEqualTo("code")
-    }).task({
-        async handler () {
-            await turbo("build", {
-                excludeExamples: true,
-                hasLiveOutput: false
-            });
-        },
-        label: label$4("Prepare the project"),
-        skip ({ filter }) {
-            return filter === "commit"; // No need to build if only commit is checked
-        }
-    }).task({
-        async handler () {
-            await checkDependency();
-        },
-        label: label$4("Check dependency compliance"),
-        skip: ifFilterDefinedAndNotEqualTo("dependency")
-    }).task({
-        async handler (_, argv) {
-            const filenames = argv.operands;
-            await checkCode(filenames);
-        },
-        label: label$4("Check code compliance"),
-        skip: ifFilterDefinedAndNotEqualTo("code")
-    }).task({
-        async handler () {
-            await checkType();
-        },
-        label: label$4("Check type compliance"),
-        skip (context, argv) {
-            return ifFilterDefinedAndNotEqualTo("type")(context) || !hasDependency("typescript") || /**
-					 * For now, skip type-checking if some files are passed down.
-					 * @see https://github.com/microsoft/TypeScript/issues/27379
-					 */ argv.operands.length > 0;
-        }
-    }).task({
-        async handler () {
-            await checkCommit();
-        },
-        label: label$4("Check commit compliance"),
-        skip (context) {
-            return context.filter !== "commit";
-        }
-    });
-};
-const label$4 = (message)=>`${message} 🧐`;
-const ifFilterDefinedAndNotEqualTo = (filter)=>(context)=>{
-        return context.filter !== undefined && context.filter !== filter;
-    };
+const createCheckCommand = (program) => {
+	program.command({
+		name: "check",
+		description: "Check code health (static analysis)"
+	}).option({
+		key: "filter",
+		name: "filter",
+		description: `Filter the compliance check to run (accepted value: ${ONLY_VALUES.join(", ")})`,
+		defaultValue: void 0
+	}).task({
+		handler(_, argv) {
+			logCheckableFiles(argv.operands);
+		},
+		skip: ifFilterDefinedAndNotEqualTo("code")
+	}).task({
+		label: label$4("Prepare the project"),
+		async handler() {
+			await turbo("build", {
+				excludeExamples: true,
+				hasLiveOutput: false
+			});
+		},
+		skip({ filter }) {
+			return filter === "commit";
+		}
+	}).task({
+		label: label$4("Check dependency compliance"),
+		async handler() {
+			await checkDependency();
+		},
+		skip: ifFilterDefinedAndNotEqualTo("dependency")
+	}).task({
+		label: label$4("Check formatting compliance"),
+		async handler(_, argv) {
+			const filenames = argv.operands;
+			await checkFormatting(filenames);
+		},
+		skip: ifFilterDefinedAndNotEqualTo("formatting")
+	}).task({
+		label: label$4("Check code compliance"),
+		async handler(_, argv) {
+			const filenames = argv.operands;
+			await checkCode(filenames);
+		},
+		skip: ifFilterDefinedAndNotEqualTo("code")
+	}).task({
+		label: label$4("Check commit compliance"),
+		async handler() {
+			await checkCommit();
+		},
+		skip(context) {
+			return context.filter !== "commit";
+		}
+	});
+};
+const label$4 = (message) => {
+	return `${message} 🧐`;
+};
+const ifFilterDefinedAndNotEqualTo = (filter) => {
+	return (context) => {
+		return context.filter !== void 0 && context.filter !== filter;
+	};
+};
 
-const createCleanCommand = (program)=>{
-    program.command({
-        description: "Clean the project",
-        name: "clean"
-    }).task({
-        async handler () {
-            const cachePath = "node_modules/.cache";
-            const files = await retrieveIgnoredFiles();
-            if (isDirectoryExistAndNotEmpty(resolveFromProjectDirectory(cachePath))) {
-                files.push(cachePath);
-            }
-            return files;
-        },
-        key: "files",
-        label: label$3("Retrieve removable files")
-    }).task({
-        async handler ({ files }) {
-            if (files.length === 0) return;
-            await cleanFiles(files);
-        },
-        label ({ files }) {
-            return files.length > 0 ? label$3("Clean assets") : "Already clean ✨";
-        }
-    }).task({
-        handler ({ files }) {
-            helpers.message(files.join("\n   "), {
-                label: "Removed assets",
-                lineBreak: {
-                    end: false,
-                    start: true
-                },
-                type: "information"
-            });
-        },
-        skip ({ files }) {
-            return files.length === 0;
-        }
-    });
-};
-const label$3 = (message)=>`${message} 🧹`;
-const cleanFiles = async (files)=>{
-    return Promise.all(files.map(async (file)=>rm(file, {
-            force: true,
-            recursive: true
-        })));
-};
-const isDirectoryExistAndNotEmpty = (path)=>{
-    return existsSync(path) && readdirSync(path).length > 0;
-};
-const retrieveIgnoredFiles = async ()=>{
-    const rawFiles = await helpers.exec("git clean -fdXn");
-    return rawFiles.split(/\n|\r\n/).filter((cleanOutput)=>!PRESERVE_FILES.some((excludedFile)=>cleanOutput.includes(excludedFile))).map((cleanOutput)=>cleanOutput.split(" ").at(-1));
-};
-const PRESERVE_FILES = [
-    "node_modules"
-];
+//#endregion
+//#region src/commands/clean.ts
+const createCleanCommand = (program) => {
+	program.command({
+		name: "clean",
+		description: "Clean the project"
+	}).task({
+		key: "files",
+		label: label$3("Retrieve removable files"),
+		async handler() {
+			const cachePath = "node_modules/.cache";
+			const files = await retrieveIgnoredFiles();
+			if (isDirectoryExistAndNotEmpty(resolveFromWorkingDirectory(cachePath))) files.push(cachePath);
+			return files;
+		}
+	}).task({
+		label({ files }) {
+			return files.length > 0 ? label$3("Clean assets") : "Already clean ✨";
+		},
+		async handler({ files }) {
+			if (files.length === 0) return;
+			await cleanFiles(files);
+		}
+	}).task({
+		handler({ files }) {
+			helpers.message(files.join("\n   "), {
+				label: "Removed assets",
+				lineBreak: {
+					end: false,
+					start: true
+				},
+				type: "information"
+			});
+		},
+		skip({ files }) {
+			return files.length === 0;
+		}
+	});
+};
+const label$3 = (message) => {
+	return `${message} 🧹`;
+};
+const cleanFiles = async (files) => {
+	await Promise.all(files.map(async (file) => {
+		await rm(file, {
+			force: true,
+			recursive: true
+		});
+	}));
+};
+const isDirectoryExistAndNotEmpty = (path) => {
+	return existsSync(path) && readdirSync(path).length > 0;
+};
+const LINEBREAK_REGEXP = /\n|\r\n/u;
+const retrieveIgnoredFiles = async () => {
+	return (await helpers.exec("git clean -fdXn")).split(LINEBREAK_REGEXP).filter((cleanOutput) => {
+		return PRESERVE_FILES.every((excludedFile) => {
+			return !cleanOutput.includes(excludedFile);
+		});
+	}).map((cleanOutput) => {
+		return cleanOutput.split(" ").at(-1) ?? "";
+	}).filter(Boolean);
+};
+const PRESERVE_FILES = ["node_modules"];
 
-var version = "0.0.0-next-5dd260c";
+//#endregion
+//#region package.json
+var version = "0.0.0-next.d8e717b";
 
-const createCreateCommand = (program)=>{
-    program.command({
-        description: "Scaffold a new project",
-        name: "create"
-    }).task({
-        handler () {
-            botMessage({
-                description: "I can guarantee you a project creation in under 1 minute 🚀",
-                title: `I'm Stack v${version}, your bot assistant`,
-                type: "information"
-            });
-        }
-    }).task({
-        async handler () {
-            // Check pnpm availability by verifying its version
-            await getNpmVersion();
-        },
-        label: label$2("Check pre-requisites")
-    }).input({
-        key: "inputName",
-        label: "What's your project name?",
-        type: "text"
-    }).input({
-        key: "inputDescription",
-        label: "How would you describe it?",
-        type: "text"
-    }).input({
-        defaultValue: "git@github.com:adbayb/xxx.git",
-        key: "inputUrl",
-        label: "Where will it be stored? (Git remote URL)",
-        type: "text"
-    }).input({
-        defaultValue: "single-project",
-        key: "inputTemplate",
-        label: "Which template you would like to apply?",
-        options: [
-            "single-project",
-            "multi-projects"
-        ],
-        type: "select"
-    }).task({
-        async handler ({ inputDescription, inputName, inputUrl }) {
-            if (!inputName) {
-                throw createError("stack create", "The project name is not optional. Make sure to provide a valid value (non-empty string).");
-            }
-            const { repoName, repoOwner } = (inputUrl.startsWith("git") ? /^git@.*:(?<repoOwner>.*)\/(?<repoName>.*)\.git$/ : /^https?:\/\/.*\/(?<repoOwner>.*)\/(?<repoName>.*)\.git$/).exec(inputUrl)?.groups ?? {};
-            if (!repoOwner || !repoName) {
-                throw createError("git", "The owner and repository name can not be extracted. Please make sure to follow either `/^git@.*:(?<repoOwner>.*)/(?<repoName>.*).git$/` or `/^https?://.*/(?<repoOwner>.*)/(?<repoName>.*).git$/` pattern.");
-            }
-            const nodeVersion = await request.get("https://resolve-node.vercel.app/lts", "text");
-            const { version: npmVersion } = await request.get("https://registry.npmjs.org/pnpm/latest", "json");
-            return {
-                licenseYear: new Date().getFullYear().toString(),
-                nodeVersion: nodeVersion.replace("v", ""),
-                npmVersion: String(npmVersion),
-                projectDescription: inputDescription.charAt(0).toUpperCase() + inputDescription.slice(1),
-                projectName: inputName.toLowerCase(),
-                projectUrl: inputUrl,
-                repoId: `${repoOwner}/${repoName}`
-            };
-        },
-        key: "data",
-        label: label$2("Check and format input")
-    }).task({
-        async handler ({ data }) {
-            const projectPath = resolve(process.cwd(), data.projectName);
-            await mkdir(projectPath);
-            process.chdir(projectPath);
-        },
-        label ({ data }) {
-            return label$2(`Create \`${data.projectName}\` folder`);
-        }
-    }).task({
-        async handler ({ data }) {
-            await helpers.exec("git init");
-            await helpers.exec(`git remote add origin ${data.projectUrl}`);
-        },
-        label: label$2("Initialize `git`")
-    }).task({
-        handler ({ data, inputTemplate }) {
-            applyTemplate(inputTemplate, data);
-        },
-        label: label$2("Apply template")
-    }).task({
-        async handler ({ data: { projectName }, inputTemplate }) {
-            await symlink(join(inputTemplate === "single-project" ? projectName : join("libraries", projectName), "README.md"), "./README.md");
-        },
-        label: label$2("Create a symlink to `README.md` file")
-    }).task({
-        async handler () {
-            await setPackageManager();
-        },
-        label: label$2("Set up the package manager")
-    }).task({
-        async handler ({ data }) {
-            const localDevelopmentDependencies = [
-                "quickbundle",
-                "vitest"
-            ];
-            const globalDevelopmentDependencies = [
-                "@adbayb/stack"
-            ];
-            try {
-                await helpers.exec(`pnpm add ${globalDevelopmentDependencies.join(" ")} --save-dev --ignore-workspace-root-check`);
-                await helpers.exec(`pnpm add ${localDevelopmentDependencies.join(" ")} --save-dev --filter ${data.projectName}`);
-                await helpers.exec("pnpm install");
-            } catch (error) {
-                throw createError("pnpm", error);
-            }
-        },
-        label: label$2("Install dependencies")
-    }).task({
-        async handler () {
-            await helpers.exec("stack install");
-        },
-        label: label$2("Run `stack install`")
-    }).task({
-        async handler () {
-            await helpers.exec("git add -A");
-            await helpers.exec('git commit -m "chore: initial commit"');
-        },
-        label: label$2("Commit")
-    }).task({
-        handler ({ data }) {
-            botMessage({
-                description: `Run \`cd ./${data.projectName}\` and Enjoy 🚀`,
-                title: "The project was successfully created",
-                type: "success"
-            });
-        }
-    });
-};
-const label$2 = (message)=>`${message} 🔨`;
-/**
- * A simple template engine to evaluate dynamic expressions and apply side effets (such as hydrating a content with values from an input object) on impacted template files.
- * @param template - The selected template.
- * @param dataModel - Data model mapping the template expression key with its corresponding value.
- * @example
- * applyTemplate(
- * 	{ toReplace: "value" },
- * );
- */ const applyTemplate = (template, dataModel)=>{
-    const templateExtension = ".tmpl";
-    const templateRootPath = resolveFromStackDirectory(join("./templates", template));
-    const projectRootPath = resolveFromProjectDirectory("./");
-    const templateExpressionRegExp = /{{(.*?)}}/g;
-    const evaluate = (content)=>{
-        return content.replaceAll(templateExpressionRegExp, (_, key)=>dataModel[key] || "");
-    };
-    /** Copy the template before mutations. */ cpSync(templateRootPath, projectRootPath, {
-        force: true,
-        recursive: true
-    });
-    /** Template file mutations. */ new fdir().withBasePath().glob(`**/*${templateExtension}`).crawl(projectRootPath).sync().forEach((templateFilePath)=>{
-        const projectFilePath = templateFilePath.slice(0, templateFilePath.lastIndexOf(templateExtension));
-        const content = evaluate(readFileSync(templateFilePath, "utf8"));
-        renameSync(templateFilePath, projectFilePath);
-        writeFileSync(projectFilePath, content, "utf8");
-    });
-    /** Template folder mutations. */ new fdir().withBasePath().onlyDirs().filter((path)=>{
-        return templateExpressionRegExp.test(path);
-    }).crawl(projectRootPath).sync()// Re-order from longest to lowest path length to apply first renaming operations on deepest file structure
-    .toSorted((a, b)=>b.length - a.length).forEach((templateFolderPath)=>{
-        const newPath = templateFolderPath.replaceAll(templateExpressionRegExp, (_, dataModelKey)=>{
-            return dataModel[dataModelKey];
-        });
-        renameSync(templateFolderPath, newPath);
-    });
+//#endregion
+//#region src/commands/create.ts
+const REPOSITORY_REGEXP = /^(?:git@.*:|https?:\/\/.*\/)(?<repoOwner>[^/]+)\/(?<repoName>[^/]+)\.git$/u;
+const createCreateCommand = (program) => {
+	program.command({
+		name: "create",
+		description: "Scaffold a new project"
+	}).task({ handler() {
+		botMessage({
+			title: `I'm Stack v${version} 👋`,
+			description: "I can guarantee you a project creation in under 1 minute 🚀",
+			type: "information"
+		});
+	} }).task({
+		label: label$2("Check pre-requisites"),
+		async handler() {
+			await getPnpmVersion();
+		}
+	}).input({
+		key: "inputName",
+		label: "What's your project name?",
+		type: "text"
+	}).input({
+		key: "inputDescription",
+		label: "How would you describe it?",
+		type: "text"
+	}).input({
+		key: "inputUrl",
+		label: "Where will it be stored? (Git remote URL)",
+		defaultValue: "git@github.com:adbayb/xxx.git",
+		type: "text"
+	}).input({
+		key: "inputTemplate",
+		label: "Which template you would like to apply?",
+		defaultValue: "single-project",
+		options: ["single-project", "multi-projects"],
+		type: "select"
+	}).task({
+		key: "data",
+		label: label$2("Check and format input"),
+		async handler({ inputDescription, inputName, inputTemplate, inputUrl }) {
+			if (!inputName) throw createError("stack create", "The project name is not optional. Make sure to provide a valid value (non-empty string).");
+			const { repoName, repoOwner } = REPOSITORY_REGEXP.exec(inputUrl)?.groups ?? {};
+			if (!repoOwner || !repoName) throw createError("git", "The owner and repository name can not be extracted. Please make sure to follow either `/^git@.*:(?<repoOwner>.*)/(?<repoName>.*).git$/` or `/^https?://.*/(?<repoOwner>.*)/(?<repoName>.*).git$/` pattern.");
+			const nodeVersion = await request.get("https://resolve-node.vercel.app/lts", "text");
+			const { version: pnpmVersion } = await request.get("https://registry.npmjs.org/pnpm/latest", "json");
+			const projectName = slugify(inputName);
+			return {
+				licenseYear: (/* @__PURE__ */ new Date()).getFullYear().toString(),
+				nodeVersion: `^${Number(nodeVersion.replace("v", "").split(".")[0])}.0.0`,
+				pnpmVersion: String(pnpmVersion),
+				projectDescription: toCapitalLetter(inputDescription),
+				projectName,
+				projectUrl: inputUrl,
+				repoId: `${repoOwner}/${repoName}`,
+				templatePath: resolveFromPackageDirectory("templates", inputTemplate),
+				workingPath: resolveFromWorkingDirectory(projectName)
+			};
+		}
+	}).input({
+		key: "canRemoveExistingDirectoryInput",
+		label({ data: { projectName } }) {
+			return label$2(`\`${projectName}\` directory already exists, do you want to remove it?`);
+		},
+		defaultValue: true,
+		skip({ data: { workingPath } }) {
+			return !existsSync(workingPath);
+		},
+		type: "confirm",
+		validate({ canRemoveExistingDirectoryInput, data: { projectName } }) {
+			if (canRemoveExistingDirectoryInput) return;
+			return createError("mkdir", `Remove or rename the \`${projectName}\` existing directory to apply the template from a clean state.`);
+		}
+	}).task({
+		key: "templateEngine",
+		label({ data: { projectName }, inputTemplate }) {
+			return label$2(`Copy \`${inputTemplate}\` template to \`${projectName}\` directory`);
+		},
+		async handler({ canRemoveExistingDirectoryInput, data: { licenseYear, nodeVersion, pnpmVersion, projectDescription, projectName, projectUrl, repoId, templatePath, workingPath }, inputTemplate }) {
+			if (canRemoveExistingDirectoryInput) await rm(workingPath, {
+				force: true,
+				recursive: true
+			});
+			return createTemplateEngine(workingPath, {
+				projectName,
+				templateModel: {
+					licenseYear,
+					nodeVersion,
+					pnpmVersion,
+					projectDescription,
+					projectName,
+					projectUrl,
+					repoId
+				},
+				templateName: inputTemplate,
+				templatePath
+			});
+		}
+	}).task({
+		label() {
+			return label$2("Process template");
+		},
+		async handler({ templateEngine }) {
+			await templateEngine.processContents();
+			await templateEngine.processPaths();
+		}
+	}).task({
+		label: label$2("Initialize `git`"),
+		async handler({ data: { projectUrl } }) {
+			await helpers.exec("git init");
+			await helpers.exec(`git remote add origin ${projectUrl}`);
+		}
+	}).task({
+		label: label$2("Set up the package manager"),
+		async handler() {
+			await setPackageManager();
+		}
+	}).task({
+		label: label$2("Install dependencies"),
+		async handler({ data: { projectName } }) {
+			const localDevelopmentDependencies = ["quickbundle", "vitest"];
+			const globalDevelopmentDependencies = ["@adbayb/stack"];
+			try {
+				await helpers.exec(`pnpm add ${globalDevelopmentDependencies.join(" ")} --save-dev --ignore-workspace-root-check`);
+				await helpers.exec(`pnpm add ${localDevelopmentDependencies.join(" ")} --save-dev --filter ${projectName}`);
+				await helpers.exec("pnpm install");
+			} catch (error) {
+				throw createError("pnpm", error instanceof Error ? error : new Error(String(error)));
+			}
+		}
+	}).task({
+		label: label$2("Run `stack install`"),
+		async handler() {
+			await helpers.exec("stack install");
+		}
+	}).task({
+		label: label$2("Commit"),
+		async handler() {
+			await helpers.exec("git add -A");
+			await helpers.exec("git commit -m \"chore: initial commit\"");
+		}
+	}).task({ handler({ data: { projectName } }) {
+		botMessage({
+			title: "The project was successfully created",
+			description: `Run \`cd ./${projectName}\` and Enjoy 🚀`,
+			type: "success"
+		});
+	} });
+};
+const label$2 = (message) => {
+	return `${message} 🔨`;
+};
+const slugify = (input) => {
+	return input.toLowerCase().replaceAll(/[^a-z0-9\s-]/gu, "").trim().replaceAll(/\s+/gu, "-").replaceAll(/-+/gu, "-");
+};
+const toCapitalLetter = (input) => {
+	return input.charAt(0).toUpperCase() + input.slice(1);
+};
+const createTemplateEngine = async (workingPath, { projectName, templateModel, templateName, templatePath }) => {
+	if (!existsSync(workingPath)) await mkdir(workingPath);
+	await cp(templatePath, workingPath, {
+		force: true,
+		recursive: true
+	});
+	const gitignoreFile = join(workingPath, ".gitignore.tmpl");
+	if (existsSync(gitignoreFile)) await rename(gitignoreFile, join(workingPath, ".gitignore"));
+	const templateEntries = await getTemplateEntries(workingPath);
+	process.chdir(workingPath);
+	return {
+		async processContents() {
+			await Promise.all(templateEntries.filter(({ type }) => {
+				return type === "content";
+			}).map(async (entry) => {
+				await writeFile(entry.path, setTemplateVariables(entry, templateModel));
+			}));
+		},
+		async processPaths() {
+			const sortedDirectoryEntries = templateEntries.filter(({ content, type }) => {
+				if (type === "path.directory" || type === "path.file") return hasTemplateVariable(basename(content));
+				return false;
+			}).toSorted(({ path: pathA }, { path: pathB }) => {
+				return pathB.length - pathA.length;
+			});
+			for (const entry of sortedDirectoryEntries) {
+				const newPath = setTemplateVariables(entry, templateModel);
+				await rename(entry.path, newPath);
+			}
+			await symlink(join(templateName === "single-project" ? projectName : join("libraries", projectName), "README.md"), "./README.md");
+		}
+	};
+};
+const getTemplateEntries = async (path) => {
+	const entries = await readdir(path, {
+		recursive: true,
+		withFileTypes: true
+	});
+	return (await Promise.all(entries.map(async (entry) => {
+		const isDirectory = entry.isDirectory();
+		if (!isDirectory && !entry.isFile()) return [];
+		const entryPath = resolve(entry.parentPath, entry.name);
+		return (isDirectory ? [{
+			content: entryPath,
+			type: "path.directory"
+		}] : [{
+			content: entryPath,
+			type: "path.file"
+		}, {
+			content: await readFile(entryPath, "utf8"),
+			type: "content"
+		}]).map(({ content, type }) => {
+			if (!hasTemplateVariable(content)) return;
+			return {
+				content,
+				path: entryPath,
+				type
+			};
+		}).filter((input) => {
+			return Boolean(input);
+		});
+	}))).flat();
+};
+const setTemplateVariables = (entry, model) => {
+	return entry.content.replaceAll(TEMPLATE_VARIABLE_MATCHER, (match, dataModelKey) => {
+		return model[dataModelKey] ?? match;
+	});
+};
+const TEMPLATE_VARIABLE_MATCHER = /\{\{(.*?)\}\}/giu;
+const hasTemplateVariable = (input) => {
+	/**
+	* TemplateVariableMatcher.test() is not used since the `RegExp` is stateful when the global is
+	* used leading to some unstable results (relying on latest `lastIndex` set (lastIndex specifies
+	* the index at which to start the next match)). String.search is stateless.
+	*
+	* @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/test MDN documentation}.
+	*/
+	return input.search(TEMPLATE_VARIABLE_MATCHER) >= 0;
 };
 
-const PRETTIER_IGNORE_FILES = [
-    "pnpm-lock.yaml"
-];
-const fixFormatting = async (files)=>{
-    let prettierFiles = [];
-    if (files.length === 0) {
-        prettierFiles.push(`"**/!(${PRETTIER_IGNORE_FILES.join("|")})"`);
-    } else {
-        prettierFiles = files.filter((file)=>{
-            return !PRETTIER_IGNORE_FILES.some((filename)=>file.endsWith(filename));
-        });
-        if (prettierFiles.length === 0) return;
-    }
-    const arguments_ = [
-        ...prettierFiles
-    ];
-    if (existsSync(resolveFromProjectDirectory(".gitignore"))) {
-        arguments_.push("--ignore-path .gitignore");
-    }
-    arguments_.push("--write", "--ignore-unknown", "--no-error-on-unmatched-pattern");
-    try {
-        return await helpers.exec(`prettier ${arguments_.join(" ")}`);
-    } catch (error) {
-        throw createError("prettier", error);
-    }
-};
+//#endregion
+//#region src/commands/fix/fixCode.ts
+const fixCode = oxlint({ isFixMode: true });
 
-const fixLinter = eslint({
-    isFixMode: true
-});
+//#endregion
+//#region src/commands/fix/fixFormatting.ts
+const fixFormatting = oxfmt({ isFixMode: true });
 
-const createFixCommand = (program)=>{
-    program.command({
-        description: "Fix auto-fixable issues",
-        name: "fix"
-    }).task({
-        handler (_, argv) {
-            logCheckableFiles(argv.operands);
-        }
-    }).task({
-        async handler () {
-            await turbo("build", {
-                excludeExamples: true,
-                hasLiveOutput: false
-            });
-        },
-        label: label$1("Prepare the project")
-    }).task({
-        async handler (_, argv) {
-            await fixLinter(argv.operands);
-        },
-        label: label$1("Fix linter issues")
-    }).task({
-        async handler (_, argv) {
-            await fixFormatting(argv.operands);
-        },
-        label: label$1("Fix formatting issues")
-    });
-};
-const label$1 = (message)=>`${message} 🚑`;
+//#endregion
+//#region src/commands/fix/fix.ts
+const createFixCommand = (program) => {
+	program.command({
+		name: "fix",
+		description: "Fix auto-fixable issues"
+	}).task({ handler(_, argv) {
+		logCheckableFiles(argv.operands);
+	} }).task({
+		label: label$1("Prepare the project"),
+		async handler() {
+			await turbo("build", {
+				excludeExamples: true,
+				hasLiveOutput: false
+			});
+		}
+	}).task({
+		label: label$1("Fix formatting issues"),
+		async handler(_, argv) {
+			await fixFormatting(argv.operands);
+		}
+	}).task({
+		label: label$1("Fix code issues"),
+		async handler(_, argv) {
+			await fixCode(argv.operands);
+		}
+	});
+};
+const label$1 = (message) => {
+	return `${message} 🚑`;
+};
 
-const createInstallCommand = (program)=>{
-    program.command({
-        description: "Install required setup",
-        name: "install"
-    }).task({
-        async handler () {
-            const lineBreakMatcher = String.raw`\n|\r\n`;
-            const modifiedFilesCommand = `node -e 'console.log(require("child_process").execSync("git status --porcelain", {encoding: "utf8"}).split(/${lineBreakMatcher}/).filter(Boolean).map(item => item.split(" ").at(-1)).join(" "))'`;
-            await installGitHook("pre-commit", `${getStackCommand(`fix $(${modifiedFilesCommand})`, false)} && git add -A`);
-        },
-        label: label("Install `git.pre-commit` hook")
-    }).task({
-        async handler () {
-            await installGitHook("commit-msg", getStackCommand("check --filter commit", false));
-        },
-        label: label("Install `git.commit-msg` hook")
-    }).task({
-        async handler () {
-            await checkPackageManager();
-        },
-        label: label("Check the package manager")
-    });
-};
-const label = (message)=>`${message} 📲`;
-const installGitHook = async (hook, content)=>{
-    const filename = resolveFromProjectDirectory(`.git/hooks/${hook}`);
-    await writeFile(filename, content);
-    return chmod(filename, "0755");
+//#endregion
+//#region src/commands/install.ts
+const createInstallCommand = (program) => {
+	program.command({
+		name: "install",
+		description: "Install required setup"
+	}).task({
+		label: label("Install `git.pre-commit` hook"),
+		async handler() {
+			const lineBreakMatcher = String.raw`\n|\r\n`;
+			const stackCommand = getStackCommand(`fix $(node -e 'console.log(require("child_process").execSync("git status --porcelain", {encoding: "utf8"}).split(/${lineBreakMatcher}/).filter(Boolean).map(item => item.split(" ").at(-1)).join(" "))')`);
+			await installGitHook("pre-commit", `${stackCommand} && git add -A`);
+		}
+	}).task({
+		label: label("Install `git.commit-msg` hook"),
+		async handler() {
+			await installGitHook("commit-msg", getStackCommand("check --filter commit"));
+		}
+	});
+};
+const label = (message) => {
+	return `${message} 📲`;
+};
+const installGitHook = async (hook, content) => {
+	const filename = resolveFromWorkingDirectory(`.git/hooks/${hook}`);
+	await writeFile(filename, content);
+	return chmod(filename, "0755");
 };
 
-const createReleaseCommand = (program)=>{
-    program.command({
-        description: "Log, version, and publish package(s)",
-        name: "release"
-    }).option({
-        description: "Add a new changelog entry",
-        key: "log",
-        name: "log"
-    }).option({
-        description: "Bump the package(s) version",
-        key: "tag",
-        name: "tag"
-    }).option({
-        description: "Publish package(s) to the registry",
-        key: "publish",
-        name: "publish"
-    }).task({
-        async handler () {
-            helpers.message("New changelog entry\n");
-            await changeset("changeset");
-        },
-        skip: ifNotEqualTo("log")
-    }).task({
-        async handler () {
-            helpers.message("Bumping the package(s) version\n");
-            await changeset("changeset version && pnpm install --no-frozen-lockfile");
-        },
-        skip: ifNotEqualTo("tag")
-    }).task({
-        async handler () {
-            helpers.message("Publishing package(s) to the registry\n");
-            await changeset("stack build && pnpm changeset publish");
-        },
-        skip: ifNotEqualTo("publish")
-    });
-};
-const ifNotEqualTo = (validOption)=>(context)=>{
-        return !context[validOption];
-    };
+//#endregion
+//#region src/commands/release.ts
+const createReleaseCommand = (program) => {
+	program.command({
+		name: "release",
+		description: "Log, version, and publish package(s)"
+	}).option({
+		key: "log",
+		name: "log",
+		description: "Add a new changelog entry"
+	}).option({
+		key: "emptyLog",
+		name: "empty-log",
+		description: "Add an empty changelog entry"
+	}).option({
+		key: "tag",
+		name: "tag",
+		description: "Bump the package(s) version"
+	}).option({
+		key: "publish",
+		name: "publish",
+		description: "Publish package(s) to the registry"
+	}).task({
+		async handler() {
+			helpers.message("New changelog entry\n");
+			await changeset("changeset");
+		},
+		skip: ifNotEqualTo("log")
+	}).task({
+		async handler() {
+			helpers.message("New empty changelog entry\n");
+			await changeset("changeset --empty");
+		},
+		skip: ifNotEqualTo("emptyLog")
+	}).task({
+		async handler() {
+			helpers.message("Bumping the package(s) version\n");
+			await changeset("changeset version");
+		},
+		skip: ifNotEqualTo("tag")
+	}).task({
+		async handler() {
+			helpers.message("Publishing package(s) to the registry\n");
+			await changeset("stack build && changeset publish");
+		},
+		skip: ifNotEqualTo("publish")
+	});
+};
+const ifNotEqualTo = (validOption) => {
+	return (context) => {
+		return !context[validOption];
+	};
+};
 
-const createStartCommand = (program)=>{
-    program.command({
-        description: "Start the project in production mode",
-        name: "start"
-    }).task({
-        async handler () {
-            await turbo("start");
-        }
-    });
+//#endregion
+//#region src/commands/start.ts
+const createStartCommand = (program) => {
+	program.command({
+		name: "start",
+		description: "Start the project in production mode"
+	}).task({ async handler() {
+		await turbo("start");
+	} });
 };
 
-const createTestCommand = (program)=>{
-    program.command({
-        description: "Test the code execution",
-        name: "test"
-    }).task({
-        async handler () {
-            await turbo("test");
-        }
-    });
+//#endregion
+//#region src/commands/test.ts
+const createTestCommand = (program) => {
+	program.command({
+		name: "test",
+		description: "Test the code execution"
+	}).task({ async handler() {
+		await turbo("test");
+	} });
 };
 
-const createWatchCommand = (program)=>{
-    program.command({
-        description: "Build and start the project in development mode",
-        name: "watch"
-    }).task({
-        async handler () {
-            await turbo("watch");
-        }
-    });
+//#endregion
+//#region src/commands/watch.ts
+const createWatchCommand = (program) => {
+	program.command({
+		name: "watch",
+		description: "Build and start the project in development mode"
+	}).task({ async handler() {
+		await turbo("watch");
+	} });
 };
 
-const createProgram = (...commandFactories)=>{
-    const program = termost({
-        description: "Toolbox to easily scaffold and maintain a project",
-        name: "stack",
-        onException () {
-            botMessage({
-                description: "Keep calm and carry on with some coffee ☕️",
-                title: "Oops, an error occurred",
-                type: "error"
-            });
-        },
-        version: version
-    });
-    for (const commandBuilder of commandFactories){
-        commandBuilder(program);
-    }
+//#endregion
+//#region src/index.ts
+const createProgram = (...commandFactories) => {
+	const program = termost({
+		name: "stack",
+		description: "Toolbox to easily scaffold and maintain a project",
+		onException() {
+			botMessage({
+				title: "Oops, an error occurred",
+				description: "Keep calm and carry on with some coffee ☕️",
+				type: "error"
+			});
+		},
+		version
+	});
+	for (const commandBuilder of commandFactories) commandBuilder(program);
 };
 createProgram(createCreateCommand, createInstallCommand, createCleanCommand, createCheckCommand, createFixCommand, createStartCommand, createBuildCommand, createWatchCommand, createTestCommand, createReleaseCommand);
+
+//#endregion