@adbayb/stack 1.16.0 → 2.0.0

package/dist/index.js

@@ -0,0 +1,761 @@
+import { helpers, termost } from 'termost';
+import process from 'node:process';
+import { resolve, join } from 'node:path';
+import { createRequire } from 'node:module';
+import { writeFile, chmod, mkdir, symlink } from 'node:fs/promises';
+import { existsSync, cpSync, readFileSync, renameSync, writeFileSync, readdirSync } from 'node:fs';
+import { fdir } from 'fdir';
+
+var version = "2.0.0";
+
+const VERSION = version;
+
+const require = createRequire(import.meta.url);
+function 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 options - Formatting option.
+ * @example
+ * botMessage(
+ *	{
+ * 		title: "Oops, an error occurred",
+ * 		description:
+ * 			"Keep calm and carry on with some coffee ☕️",
+ * 		body: String(previousTaskError),
+ * 	},
+ * 	{
+ * 		type: "error",
+ * 	},
+ * );
+ */ const botMessage = (input, options)=>{
+    helpers.message(`
+╭─────╮
+│ ◠   ◠  ${input.title}
+│   ${options?.type === "error" ? "◠" : "◡"} │  ${input.description}
+╰─────╯
+${!input.body ? "" : `
+${input.body}
+`}`, options);
+};
+/**
+ * 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 `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 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.resolve(packageName));
+};
+const setPkgManager = async ()=>{
+    return helpers.exec("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((ext)=>file.endsWith(ext));
+            });
+            if (eslintFiles.length === 0) return Promise.resolve();
+        }
+        const args = [
+            ...eslintFiles
+        ];
+        args.push("--cache");
+        args.push(`--cache-location ${resolveFromProjectDirectory("node_modules/.cache/.eslintcache")}`);
+        // @note: prevent errors when no matched file is found
+        args.push("--no-error-on-unmatched-pattern");
+        if (options.isFixMode) {
+            args.push("--fix");
+        }
+        try {
+            return await helpers.exec(`eslint ${args.join(" ")}`);
+        } catch (error) {
+            throw createError("eslint", error);
+        }
+    };
+const turbo = async (command, options = {
+    hasLiveOutput: true
+})=>{
+    try {
+        return await helpers.exec(`turbo run ${command}`, options);
+    } catch (error) {
+        throw createError("turbo", error);
+    }
+};
+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"
+];
+
+const createWatchCommand = (program)=>{
+    program.command({
+        name: "watch",
+        description: "Build and start the project in development mode"
+    }).task({
+        async handler () {
+            await turbo("watch");
+        }
+    });
+};
+
+const createTestCommand = (program)=>{
+    program.command({
+        name: "test",
+        description: "Test the code execution"
+    }).task({
+        async handler () {
+            await turbo("test");
+        }
+    });
+};
+
+const createStartCommand = (program)=>{
+    program.command({
+        name: "start",
+        description: "Start the project in production mode"
+    }).task({
+        async handler () {
+            await turbo("start");
+        }
+    });
+};
+
+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: "tag",
+        name: "tag",
+        description: "Bump the package(s) version"
+    }).option({
+        key: "publish",
+        name: "publish",
+        description: "Publish package(s) to the registry"
+    }).task({
+        async handler () {
+            // TODO: label instead?
+            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];
+    };
+
+const createInstallCommand = (program)=>{
+    program.command({
+        name: "install",
+        description: "Setup initial requirements"
+    }).task({
+        label: label$4("Install `git.pre-commit` hook"),
+        async handler () {
+            await installGitHook("pre-commit", `${getStackCommand("fix $(git status --porcelain | awk 'BEGIN{ ORS=\" \" } { print $2 }')", false)} && git add -A`);
+        }
+    }).task({
+        label: label$4("Install `git.commit-msg` hook"),
+        async handler () {
+            await installGitHook("commit-msg", getStackCommand("check --only commit", false));
+        }
+    });
+};
+const label$4 = (message)=>`${message} 📲`;
+const installGitHook = async (hook, content)=>{
+    const filename = resolveFromProjectDirectory(`.git/hooks/${hook}`);
+    await writeFile(filename, content);
+    return chmod(filename, "0755");
+};
+
+const fixLinter = eslint({
+    isFixMode: true
+});
+
+const PRETTIER_IGNORE_FILES = [
+    "CHANGELOG.md",
+    "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)) && // The root `README.md` file is ignored to prevent error due to its symbolic link nature when specified explicitly as a file
+            file !== "README.md";
+        });
+        if (prettierFiles.length === 0) return Promise.resolve();
+    }
+    const args = [
+        ...prettierFiles
+    ];
+    if (existsSync(resolveFromProjectDirectory(".gitignore"))) {
+        args.push("--ignore-path .gitignore");
+    }
+    args.push("--write");
+    args.push("--ignore-unknown");
+    args.push("--no-error-on-unmatched-pattern");
+    try {
+        return await helpers.exec(`prettier ${args.join(" ")}`);
+    } catch (error) {
+        throw createError("prettier", error);
+    }
+};
+
+const createFixCommand = (program)=>{
+    program.command({
+        name: "fix",
+        description: "Fix auto-fixable issues"
+    }).task({
+        label: label$3("Prepare the project"),
+        async handler () {
+            await turbo("build", {
+                hasLiveOutput: false
+            });
+        }
+    }).task({
+        label: label$3("Fix linter issues"),
+        async handler (_, argv) {
+            await fixLinter(argv.operands);
+        }
+    }).task({
+        label: label$3("Fix formatting issues"),
+        async handler (_, argv) {
+            await fixFormatting(argv.operands);
+        }
+    });
+};
+const label$3 = (message)=>`${message} 🚑`;
+
+const createCreateCommand = (program)=>{
+    program.command({
+        name: "create",
+        description: "Scaffold a new project"
+    }).task({
+        handler () {
+            botMessage({
+                title: `I'm Stack v${VERSION}, your bot assistant`,
+                description: "I can guarantee you a project creation in under 1 minute 🚀"
+            }, {
+                type: "information"
+            });
+        }
+    }).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({
+        label: label$2("Check pre-requisites"),
+        async handler () {
+            // Check pnpm availability by verifying its version
+            await getNpmVersion();
+        }
+    }).task({
+        key: "data",
+        label: label$2("Evaluate contextual data"),
+        async handler ({ inputDescription, inputName, inputUrl }) {
+            const nodeVersion = (await request.get("https://resolve-node.vercel.app/lts", "text")).replace("v", "");
+            const npmVersion = (await request.get("https://registry.npmjs.org/pnpm/latest", "json")).version;
+            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.");
+            }
+            return {
+                licenseYear: new Date().getFullYear().toString(),
+                nodeVersion,
+                npmVersion,
+                projectDescription: inputDescription.charAt(0).toUpperCase() + inputDescription.slice(1),
+                projectName: inputName.toLowerCase(),
+                projectUrl: inputUrl,
+                repoId: `${repoOwner}/${repoName}`
+            };
+        }
+    }).task({
+        label ({ data }) {
+            return label$2(`Create \`${data.projectName}\` folder`);
+        },
+        async handler ({ data }) {
+            const projectPath = resolve(process.cwd(), data.projectName);
+            await mkdir(projectPath);
+            process.chdir(projectPath);
+        }
+    }).task({
+        label: label$2("Initialize `git`"),
+        async handler ({ data }) {
+            await helpers.exec("git init");
+            await helpers.exec(`git remote add origin ${data.projectUrl}`);
+        }
+    }).task({
+        label: label$2("Apply template"),
+        handler ({ data, inputTemplate }) {
+            applyTemplate(inputTemplate, data);
+        }
+    }).task({
+        label: label$2("Install dependencies"),
+        async handler ({ data }) {
+            const localDevDependencies = [
+                "quickbundle",
+                "vitest"
+            ];
+            const globalDevDependencies = [
+                "@adbayb/stack"
+            ];
+            try {
+                await helpers.exec(`pnpm add ${globalDevDependencies.join(" ")} --save-dev --ignore-workspace-root-check`);
+                await helpers.exec(`pnpm add ${localDevDependencies.join(" ")} --save-dev --filter ${data.projectName}`);
+            } catch (error) {
+                throw createError("pnpm", error);
+            }
+        }
+    }).task({
+        key: "error",
+        label: label$2("Clean up"),
+        async handler ({ data }) {
+            try {
+                // Symlink the package `README.md` file to the root project directory
+                await symlink(`./${data.projectName}/README.md`, "./README.md");
+                // Set the Node package manager runtime by following the `packageManager` field instruction
+                await setPkgManager();
+                // Run install command to add git hooks
+                await helpers.exec("stack install");
+                // Commit (and run check/fix command via git hooks)
+                await helpers.exec("git add -A");
+                await helpers.exec('git commit -m "chore: initial commit"');
+                return;
+            } catch (error) {
+                return error;
+            }
+        }
+    }).task({
+        handler ({ data, error }) {
+            if (error) {
+                botMessage({
+                    title: "Oops, an error occurred",
+                    description: "Keep calm and carry on with some coffee ☕️",
+                    body: String(error)
+                }, {
+                    type: "error"
+                });
+                return;
+            }
+            botMessage({
+                title: "The project was successfully created",
+                description: `Run \`cd ./${data.projectName}\` and Enjoy 🚀`
+            }, {
+                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.replace(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, "utf-8"));
+        renameSync(templateFilePath, projectFilePath);
+        writeFileSync(projectFilePath, content, "utf-8");
+    });
+    /** Template folder mutations. */ new fdir().withBasePath().onlyDirs().filter((path)=>{
+        return Boolean(templateExpressionRegExp.exec(path));
+    }).crawl(projectRootPath).sync()// Re-order from longest to lowest path length to apply first renaming operations on deepest file structure
+    .sort((a, b)=>b.length - a.length).forEach((templateFolderPath)=>{
+        const newPath = templateFolderPath.replace(templateExpressionRegExp, (_, dataModelKey)=>{
+            return dataModel[dataModelKey];
+        });
+        renameSync(templateFolderPath, newPath);
+    });
+};
+
+const createCleanCommand = (program)=>{
+    program.command({
+        name: "clean",
+        description: "Clean the project"
+    }).task({
+        key: "files",
+        label: label$1("Retrieve removable files"),
+        async handler () {
+            const cachePath = "node_modules/.cache";
+            const files = await retrieveIgnoredFiles();
+            if (isDirectoryExistAndNotEmpty(resolveFromProjectDirectory(cachePath))) {
+                files.push(cachePath);
+            }
+            return files;
+        }
+    }).task({
+        label ({ files }) {
+            return files.length > 0 ? label$1("Clean assets") : "Already clean ✨";
+        },
+        async handler ({ files }) {
+            if (files.length === 0) return;
+            await cleanFiles(files);
+        }
+    }).task({
+        handler ({ files }) {
+            helpers.message(`Removed assets: ${files.join(", ")}\n`, {
+                type: "information"
+            });
+        },
+        skip ({ files }) {
+            return files.length === 0;
+        }
+    });
+};
+const label$1 = (message)=>`${message} 🧹`;
+const cleanFiles = async (files)=>{
+    return helpers.exec(`rm -rf ${files.join(" ")}`);
+};
+const isDirectoryExistAndNotEmpty = (path)=>{
+    return existsSync(path) && readdirSync(path).length > 0;
+};
+const retrieveIgnoredFiles = async ()=>{
+    const rawFiles = await helpers.exec(`git clean -fdXn | grep -v '${PRESERVE_FILES.join("\\|")}' | cut -c 14-`);
+    return rawFiles.split(/\n/).filter(Boolean);
+};
+const PRESERVE_FILES = [
+    "node_modules",
+    ".turbo"
+];
+
+const checkTypes = async ()=>{
+    try {
+        return await helpers.exec("pnpm --parallel exec tsc --noEmit");
+    } catch (error) {
+        throw createError("tsc", error);
+    }
+};
+
+const checkPackages = async ()=>{
+    const stdout = await helpers.exec("pnpm recursive ls --json");
+    const checkPackagesVersionMismatch = createPackagesVersionMismatchChecker();
+    const packages = JSON.parse(stdout).map((pkg)=>{
+        const pkgPath = join(pkg.path, "package.json");
+        assert(pkg.name, ()=>createPackageError(`\`${pkgPath}\` must have a name field.`));
+        const pkgContent = require(pkgPath);
+        const peerDependencies = pkgContent.peerDependencies ?? {};
+        const devDependencies = pkgContent.devDependencies ?? {};
+        const dependencies = pkgContent.dependencies ?? {};
+        return {
+            name: pkg.name,
+            dependencies,
+            devDependencies,
+            peerDependencies
+        };
+    });
+    for (const pkg 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)
+        checkPackagesVersionMismatch(pkg);
+        // Check version range accordingly to our dependency guidelines (ie. dev dependencies must be pinned and dependencies must have caret)
+        checkPackagesVersionRange(pkg);
+    }
+};
+const checkPackagesVersionRange = ({ name, dependencies, devDependencies, peerDependencies })=>{
+    for (const dependencyName of Object.keys(devDependencies)){
+        const version = devDependencies[dependencyName];
+        assertVersion(version, {
+            name: dependencyName,
+            consumedBy: name
+        });
+        if (version !== "workspace:*" && !/^\d/.exec(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
+        });
+    }
+    const isPreReleaseVersion = (version)=>/\d+\.\d+\.\d+-(alpha|beta|experimental|next|rc).*/.exec(version);
+    const hasNoCaret = (version)=>!isPreReleaseVersion(version) && !/^\^/.exec(version);
+    for (const dependencyName of Object.keys(dependencies)){
+        const version = dependencies[dependencyName];
+        assertVersion(version, {
+            name: dependencyName,
+            consumedBy: name
+        });
+        if (version !== "workspace:^" && hasNoCaret(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 of Object.keys(peerDependencies)){
+        const version = peerDependencies[dependencyName];
+        assertVersion(version, {
+            name: dependencyName,
+            consumedBy: name
+        });
+        if (hasNoCaret(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.`, {
+            name: dependencyName,
+            consumedBy: name
+        });
+    }
+};
+const createPackagesVersionMismatchChecker = ()=>{
+    const monorepoDependencies = new Map();
+    const monorepoDevDependencies = new Map();
+    const lint = (pkg, type)=>{
+        const pkgName = pkg.name;
+        const isDev = type === "development";
+        const store = isDev ? monorepoDevDependencies : monorepoDependencies;
+        const dependencies = isDev ? pkg.devDependencies : pkg.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}\`.`, {
+                    name: dependencyName,
+                    consumedBy: pkgName
+                });
+            }
+        }
+    };
+    return (pkg)=>{
+        lint(pkg, "development");
+        lint(pkg, "production");
+    };
+};
+const createPackageError = (message, context)=>{
+    return createError("stack check", !context ? message : `\`${context.name}\` consumed by \`${context.consumedBy}\` doesn't conform to our package policy.\n${message}`);
+};
+function assertVersion(version, { name, consumedBy }) {
+    assert(version, ()=>createPackageError(`\`${name}\` must have a valid version specified (current version equals to \`${String(version)}\`).`, {
+            name,
+            consumedBy
+        }));
+}
+
+const checkLinter = eslint({
+    isFixMode: false
+});
+
+const checkCommit = async ()=>{
+    try {
+        return await helpers.exec('commitlint --extends "@commitlint/config-conventional" --edit');
+    } catch (error) {
+        throw createError("commitlint", error);
+    }
+};
+
+const ONLY_VALUES = [
+    "commit",
+    "linter",
+    "packages",
+    "types"
+];
+const createCheckCommand = (program)=>{
+    program.command({
+        name: "check",
+        description: "Check code health (static analysis)"
+    }).option({
+        key: "only",
+        name: "only",
+        description: `Run only one specified task (accepted value: ${ONLY_VALUES.join(", ")})`,
+        defaultValue: undefined
+    }).task({
+        label: label("Prepare the project"),
+        async handler () {
+            await turbo("build", {
+                hasLiveOutput: false
+            });
+        },
+        skip ({ only }) {
+            return only === "commit"; // No need to build if only commitlint is run
+        }
+    }).task({
+        label: label("Check package guidelines"),
+        async handler () {
+            await checkPackages();
+        },
+        skip: ifOnlyDefinedAndNotEqualTo("packages")
+    }).task({
+        label: label("Check linter rules"),
+        async handler (_, argv) {
+            const filenames = argv.operands;
+            await checkLinter(filenames);
+        },
+        skip: ifOnlyDefinedAndNotEqualTo("linter")
+    }).task({
+        label: label("Check types"),
+        async handler () {
+            await checkTypes();
+        },
+        skip (context, argv) {
+            return ifOnlyDefinedAndNotEqualTo("types")(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({
+        label: label("Check commit"),
+        async handler () {
+            await checkCommit();
+        },
+        skip ({ only }) {
+            return only !== "commit";
+        }
+    });
+};
+const label = (message)=>`${message} 🧐`;
+const ifOnlyDefinedAndNotEqualTo = (only)=>(context)=>{
+        return context.only !== undefined && context.only !== only;
+    };
+
+const createBuildCommand = (program)=>{
+    program.command({
+        name: "build",
+        description: "Build the project in production mode"
+    }).task({
+        async handler () {
+            await turbo("build");
+        }
+    });
+};
+
+const createProgram = (...commandFactories)=>{
+    const program = termost({
+        name: "stack",
+        description: "Toolbox to easily scaffold and maintain a project",
+        version: VERSION
+    });
+    for (const commandBuilder of commandFactories){
+        commandBuilder(program);
+    }
+};
+createProgram(createCreateCommand, createInstallCommand, createCleanCommand, createCheckCommand, createFixCommand, createStartCommand, createBuildCommand, createWatchCommand, createTestCommand, createReleaseCommand);