@adbayb/stack 2.39.0 → 2.40.0-next-f8ad939

package/dist/index.js

@@ -1,9 +1,8 @@
 import { helpers, termost } from "termost";
 import { createRequire } from "node:module";
-import { join, resolve } from "node:path";
-import { cpSync, existsSync, readFileSync, readdirSync, renameSync, writeFileSync } from "node:fs";
-import { chmod, mkdir, rm, symlink, writeFile } from "node:fs/promises";
-import { fdir } from "fdir";
+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";
 
 //#region src/helpers.ts
 const require = createRequire(import.meta.url);
@@ -12,21 +11,20 @@ function assert(expectedCondition, createError) {
 }
 /**
 * 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.
-* @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;
@@ -46,23 +44,27 @@ ${input.body}
 };
 /**
 * 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.
-* @example
-* resolveFromProjectDirectory(".gitignore");
 */
-const resolveFromProjectDirectory = (path) => {
-	return resolve(process.cwd(), path);
+const resolveFromWorkingDirectory = (...path) => {
+	return resolve(process.cwd(), ...path);
 };
 /**
 * 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.
-* @example
-* resolveFromStackDirectory("./templates");
 */
-const resolveFromStackDirectory = (path) => {
-	return resolve(import.meta.dirname, "../", path);
+const resolveFromPackageDirectory = (...path) => {
+	return resolve(import.meta.dirname, "../", ...path);
 };
 const createError = (bin, error) => {
 	const errorMessage = `\`${bin}\` command failed.\n${String(error)}`;
@@ -72,7 +74,7 @@ const createError = (bin, error) => {
 	}
 	return new Error(errorMessage);
 };
-const getNpmVersion = async () => {
+const getPnpmVersion = async () => {
 	try {
 		return await helpers.exec("pnpm -v");
 	} catch {
@@ -82,44 +84,49 @@ const getNpmVersion = async () => {
 const getStackCommand = (command) => {
 	return `pnpm stack ${command}`;
 };
-const hasDependency = (packageName) => {
-	return Boolean(require.resolve(packageName));
-};
 const setPackageManager = async () => {
 	/**
-	* Corepack is downloaded remotely to get always up-to-date npm registry fingerprints since they're hardcoded.
+	* 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");
+	return helpers.exec("pnx corepack enable");
 };
-const request = { async get(url, responseType) {
+async function getRequest(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 response[responseType === "text" ? "text" : "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")}`,
+	if (responseType === "text") return response.text();
+	return response.json();
+}
+const request = { get: getRequest };
+const oxlint = (options) => async (files = []) => {
+	const args = [
+		...files,
+		"--disable-nested-config",
 		"--no-error-on-unmatched-pattern"
 	];
-	if (options.isFixMode) arguments_.push("--fix");
+	if (options.isFixMode) args.push("--fix");
+	try {
+		return await helpers.exec(`oxlint ${args.join(" ")}`);
+	} catch (error) {
+		throw createError("oxlint", error instanceof Error ? error : new Error(String(error)));
+	}
+};
+const oxfmt = (options) => async (files = []) => {
+	const args = [
+		...files,
+		"--disable-nested-config",
+		"--no-error-on-unmatched-pattern",
+		options.isFixMode ? "--write" : "--check"
+	];
 	try {
-		return await helpers.exec(`eslint ${arguments_.join(" ")}`);
+		return await helpers.exec(`oxfmt ${args.join(" ")}`);
 	} catch (error) {
-		throw createError("eslint", error);
+		throw createError("oxfmt", error instanceof Error ? error : new Error(String(error)));
 	}
 };
 const turbo = async (command, options = {}) => {
@@ -130,7 +137,7 @@ const turbo = async (command, options = {}) => {
 			hasLiveOutput
 		});
 	} catch (error) {
-		throw createError("turbo", error);
+		throw createError("turbo", error instanceof Error ? error : new Error(String(error)));
 	}
 };
 const logCheckableFiles = (files) => {
@@ -156,21 +163,9 @@ const changeset = async (command) => {
 	try {
 		return await helpers.exec(command, { hasLiveOutput: true });
 	} catch (error) {
-		throw createError("changeset", error);
+		throw createError("changeset", error instanceof Error ? error : new Error(String(error)));
 	}
 };
-const ESLINT_EXTENSIONS = [
-	"js",
-	"jsx",
-	"cjs",
-	"mjs",
-	"ts",
-	"tsx",
-	"cts",
-	"mts",
-	"md",
-	"mdx"
-];
 
 //#endregion
 //#region src/commands/build.ts
@@ -185,7 +180,7 @@ const createBuildCommand = (program) => {
 
 //#endregion
 //#region src/commands/check/checkCode.ts
-const checkCode = eslint({ isFixMode: false });
+const checkCode = oxlint({ isFixMode: false });
 
 //#endregion
 //#region src/commands/check/checkCommit.ts
@@ -193,7 +188,7 @@ const checkCommit = async () => {
 	try {
 		return await helpers.exec("commitlint --extends \"@commitlint/config-conventional\" --edit");
 	} catch (error) {
-		throw createError("commitlint", error);
+		throw createError("commitlint", error instanceof Error ? error : new Error(String(error)));
 	}
 };
 
@@ -202,22 +197,22 @@ const checkCommit = async () => {
 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 packages = JSON.parse(stdout).map((pkg) => {
+		const packagePath = join(pkg.path, "package.json");
+		assert(pkg.name, () => createPackageError(`\`${packagePath}\` must have a name field.`));
 		const packageContent = require(packagePath);
 		const peerDependencies = packageContent.peerDependencies ?? {};
 		const devDependencies = packageContent.devDependencies ?? {};
 		return {
 			dependencies: packageContent.dependencies ?? {},
 			devDependencies,
-			name: package_.name,
+			name: pkg.name,
 			peerDependencies
 		};
 	});
-	for (const package_ of packages) {
-		checkDependencyVersionMismatch(package_);
-		checkDependencyVersionRange(package_);
+	for (const pkg of packages) {
+		checkDependencyVersionMismatch(pkg);
+		checkDependencyVersionRange(pkg);
 	}
 };
 const checkDependencyVersionRange = ({ dependencies, devDependencies, name, peerDependencies }) => {
@@ -255,11 +250,11 @@ const checkDependencyVersionRange = ({ dependencies, devDependencies, name, peer
 const createPackagesVersionMismatchChecker = () => {
 	const monorepoDependencies = /* @__PURE__ */ new Map();
 	const monorepoDevelopmentDependencies = /* @__PURE__ */ new Map();
-	const lint = (package_, type) => {
-		const packageName = package_.name;
+	const lint = (pkg, type) => {
+		const packageName = pkg.name;
 		const isDevelopment = type === "development";
 		const store = isDevelopment ? monorepoDevelopmentDependencies : monorepoDependencies;
-		const dependencies = package_[isDevelopment ? "devDependencies" : "dependencies"];
+		const dependencies = pkg[isDevelopment ? "devDependencies" : "dependencies"];
 		for (const [dependencyName, dependencyVersion] of Object.entries(dependencies)) {
 			if (!dependencyVersion) continue;
 			const storedVersion = store.get(dependencyName);
@@ -273,9 +268,9 @@ const createPackagesVersionMismatchChecker = () => {
 			});
 		}
 	};
-	return (package_) => {
-		lint(package_, "development");
-		lint(package_, "production");
+	return (pkg) => {
+		lint(pkg, "development");
+		lint(pkg, "production");
 	};
 };
 const createPackageError = (message, context) => {
@@ -294,14 +289,8 @@ const isExcluded = (version) => {
 const hasCaret = (version) => version.startsWith("^");
 
 //#endregion
-//#region src/commands/check/checkType.ts
-const checkType = async () => {
-	try {
-		return await helpers.exec("pnpm --parallel exec tsc --noEmit");
-	} catch (error) {
-		throw createError("tsc", error);
-	}
-};
+//#region src/commands/check/checkFormatting.ts
+const checkFormatting = oxfmt({ isFixMode: false });
 
 //#endregion
 //#region src/commands/check/check.ts
@@ -309,7 +298,7 @@ const ONLY_VALUES = [
 	"commit",
 	"code",
 	"dependency",
-	"type"
+	"formatting"
 ];
 const createCheckCommand = (program) => {
 	program.command({
@@ -342,6 +331,13 @@ const createCheckCommand = (program) => {
 		},
 		label: label$4("Check dependency compliance"),
 		skip: ifFilterDefinedAndNotEqualTo("dependency")
+	}).task({
+		async handler(_, argv) {
+			const filenames = argv.operands;
+			await checkFormatting(filenames);
+		},
+		label: label$4("Check formatting compliance"),
+		skip: ifFilterDefinedAndNotEqualTo("formatting")
 	}).task({
 		async handler(_, argv) {
 			const filenames = argv.operands;
@@ -349,14 +345,6 @@ const createCheckCommand = (program) => {
 		},
 		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") || argv.operands.length > 0;
-		}
 	}).task({
 		async handler() {
 			await checkCommit();
@@ -382,7 +370,7 @@ const createCleanCommand = (program) => {
 		async handler() {
 			const cachePath = "node_modules/.cache";
 			const files = await retrieveIgnoredFiles();
-			if (isDirectoryExistAndNotEmpty(resolveFromProjectDirectory(cachePath))) files.push(cachePath);
+			if (isDirectoryExistAndNotEmpty(resolveFromWorkingDirectory(cachePath))) files.push(cachePath);
 			return files;
 		},
 		key: "files",
@@ -422,13 +410,13 @@ const isDirectoryExistAndNotEmpty = (path) => {
 	return existsSync(path) && readdirSync(path).length > 0;
 };
 const retrieveIgnoredFiles = async () => {
-	return (await helpers.exec("git clean -fdXn")).split(/\n|\r\n/).filter((cleanOutput) => PRESERVE_FILES.every((excludedFile) => !cleanOutput.includes(excludedFile))).map((cleanOutput) => cleanOutput.split(" ").at(-1));
+	return (await helpers.exec("git clean -fdXn")).split(/\n|\r\n/).filter((cleanOutput) => PRESERVE_FILES.every((excludedFile) => !cleanOutput.includes(excludedFile))).map((cleanOutput) => cleanOutput.split(" ").at(-1) ?? "").filter(Boolean);
 };
 const PRESERVE_FILES = ["node_modules"];
 
 //#endregion
 //#region package.json
-var version = "2.39.0";
+var version = "2.40.0-next-f8ad939";
 
 //#endregion
 //#region src/commands/create.ts
@@ -439,12 +427,12 @@ const createCreateCommand = (program) => {
 	}).task({ handler() {
 		botMessage({
 			description: "I can guarantee you a project creation in under 1 minute 🚀",
-			title: `I'm Stack v${version}, your bot assistant`,
+			title: `I'm Stack v${version} 👋`,
 			type: "information"
 		});
 	} }).task({
 		async handler() {
-			await getNpmVersion();
+			await getPnpmVersion();
 		},
 		label: label$2("Check pre-requisites")
 	}).input({
@@ -467,64 +455,95 @@ const createCreateCommand = (program) => {
 		options: ["single-project", "multi-projects"],
 		type: "select"
 	}).task({
-		async handler({ inputDescription, inputName, inputUrl }) {
+		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 } = (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");
+			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: nodeVersion.replace("v", ""),
-				npmVersion: String(npmVersion),
-				projectDescription: inputDescription.charAt(0).toUpperCase() + inputDescription.slice(1),
-				projectName: inputName.toLowerCase(),
+				pnpmVersion: String(pnpmVersion),
+				projectDescription: toCapitalLetter(inputDescription),
+				projectName,
 				projectUrl: inputUrl,
-				repoId: `${repoOwner}/${repoName}`
+				repoId: `${repoOwner}/${repoName}`,
+				templatePath: resolveFromPackageDirectory("templates", inputTemplate),
+				workingPath: resolveFromWorkingDirectory(projectName)
 			};
 		},
 		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);
+	}).input({
+		defaultValue: true,
+		key: "canRemoveExistingDirectoryInput",
+		label({ data: { projectName } }) {
+			return label$2(`\`${projectName}\` directory already exists, do you want to remove it?`);
 		},
-		label({ data }) {
-			return label$2(`Create \`${data.projectName}\` folder`);
+		skip({ data: { workingPath } }) {
+			return !existsSync(workingPath);
+		},
+		type: "confirm",
+		validate({ canRemoveExistingDirectoryInput, data: { projectName } }) {
+			if (canRemoveExistingDirectoryInput) return void 0;
+			return createError("mkdir", `Remove or rename the \`${projectName}\` existing directory to apply the template from a clean state.`);
 		}
 	}).task({
-		async handler({ data }) {
-			await helpers.exec("git init");
-			await helpers.exec(`git remote add origin ${data.projectUrl}`);
+		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
+			});
 		},
-		label: label$2("Initialize `git`")
+		key: "templateEngine",
+		label({ data: { projectName }, inputTemplate }) {
+			return label$2(`Copy \`${inputTemplate}\` template to \`${projectName}\` directory`);
+		}
 	}).task({
-		handler({ data, inputTemplate }) {
-			applyTemplate(inputTemplate, data);
+		async handler({ templateEngine }) {
+			await templateEngine.processContents();
+			await templateEngine.processPaths();
 		},
-		label: label$2("Apply template")
+		label() {
+			return label$2("Process template");
+		}
 	}).task({
-		async handler({ data: { projectName }, inputTemplate }) {
-			await symlink(join(inputTemplate === "single-project" ? projectName : join("libraries", projectName), "README.md"), "./README.md");
+		async handler({ data: { projectUrl } }) {
+			await helpers.exec("git init");
+			await helpers.exec(`git remote add origin ${projectUrl}`);
 		},
-		label: label$2("Create a symlink to `README.md` file")
+		label: label$2("Initialize `git`")
 	}).task({
 		async handler() {
 			await setPackageManager();
 		},
 		label: label$2("Set up the package manager")
 	}).task({
-		async handler({ data }) {
+		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 ${data.projectName}`);
+				await helpers.exec(`pnpm add ${localDevelopmentDependencies.join(" ")} --save-dev --filter ${projectName}`);
 				await helpers.exec("pnpm install");
 			} catch (error) {
-				throw createError("pnpm", error);
+				throw createError("pnpm", error instanceof Error ? error : new Error(String(error)));
 			}
 		},
 		label: label$2("Install dependencies")
@@ -539,79 +558,104 @@ const createCreateCommand = (program) => {
 			await helpers.exec("git commit -m \"chore: initial commit\"");
 		},
 		label: label$2("Commit")
-	}).task({ handler({ data }) {
+	}).task({ handler({ data: { projectName } }) {
 		botMessage({
-			description: `Run \`cd ./${data.projectName}\` and Enjoy 🚀`,
+			description: `Run \`cd ./${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, {
+const slugify = (input) => {
+	return input.toLowerCase().replaceAll(/[^a-z0-9\s-]/g, "").trim().replaceAll(/\s+/g, "-").replaceAll(/-+/g, "-");
+};
+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
 	});
-	/** 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");
+	const gitignoreFile = join(workingPath, ".gitignore.tmpl");
+	if (existsSync(gitignoreFile)) await rename(gitignoreFile, join(workingPath, ".gitignore"));
+	const eslintConfigFile = join(workingPath, "eslint.config.js.tmpl");
+	if (existsSync(eslintConfigFile)) await rename(eslintConfigFile, join(workingPath, "eslint.config.js"));
+	const templateEntries = await getTemplateEntries(workingPath);
+	process.chdir(workingPath);
+	return {
+		async processContents() {
+			await Promise.all(templateEntries.filter(({ type }) => type === "content").map(async (entry) => {
+				return 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 }) => 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
 	});
-	/** Template folder mutations. */
-	new fdir().withBasePath().onlyDirs().filter((path) => {
-		return templateExpressionRegExp.test(path);
-	}).crawl(projectRootPath).sync().toSorted((a, b) => b.length - a.length).forEach((templateFolderPath) => {
-		renameSync(templateFolderPath, templateFolderPath.replaceAll(templateExpressionRegExp, (_, dataModelKey) => {
-			return dataModel[dataModelKey];
-		}));
+	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 void 0;
+			return {
+				content,
+				path: entryPath,
+				type
+			};
+		}).filter((input) => Boolean(input));
+	}))).flat();
+};
+const setTemplateVariables = (entry, model) => {
+	return entry.content.replaceAll(TEMPLATE_VARIABLE_MATCHER, (match, dataModelKey) => {
+		return model[dataModelKey] ?? match;
 	});
 };
+const TEMPLATE_VARIABLE_MATCHER = /* @__PURE__ */ new RegExp(/{{(.*?)}}/g, "gi");
+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;
+};
 
 //#endregion
-//#region src/commands/fix/fixFormatting.ts
-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.every((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);
-	}
-};
+//#region src/commands/fix/fixCode.ts
+const fixCode = oxlint({ isFixMode: true });
 
 //#endregion
-//#region src/commands/fix/fixLinter.ts
-const fixLinter = eslint({ isFixMode: true });
+//#region src/commands/fix/fixFormatting.ts
+const fixFormatting = oxfmt({ isFixMode: true });
 
 //#endregion
 //#region src/commands/fix/fix.ts
@@ -631,14 +675,14 @@ const createFixCommand = (program) => {
 		label: label$1("Prepare the project")
 	}).task({
 		async handler(_, argv) {
-			await fixLinter(argv.operands);
+			await fixFormatting(argv.operands);
 		},
-		label: label$1("Fix linter issues")
+		label: label$1("Fix formatting issues")
 	}).task({
 		async handler(_, argv) {
-			await fixFormatting(argv.operands);
+			await fixCode(argv.operands);
 		},
-		label: label$1("Fix formatting issues")
+		label: label$1("Fix code issues")
 	});
 };
 const label$1 = (message) => `${message} 🚑`;
@@ -663,7 +707,7 @@ const createInstallCommand = (program) => {
 };
 const label = (message) => `${message} 📲`;
 const installGitHook = async (hook, content) => {
-	const filename = resolveFromProjectDirectory(`.git/hooks/${hook}`);
+	const filename = resolveFromWorkingDirectory(`.git/hooks/${hook}`);
 	await writeFile(filename, content);
 	return chmod(filename, "0755");
 };