@adbayb/stack 2.32.0 → 2.33.0-next-40f7a45

package/dist/index.js

@@ -1,8 +1,8 @@
 import { helpers, termost } from 'termost';
-import { resolve, join } from 'node:path';
 import { createRequire } from 'node:module';
-import { writeFile, chmod, mkdir, symlink, rm } from 'node:fs/promises';
-import { existsSync, cpSync, readFileSync, renameSync, writeFileSync, readdirSync } from 'node:fs';
+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';
 
 const require$1 = createRequire(import.meta.url);
@@ -41,9 +41,9 @@ function assert(expectedCondition, createError) {
 │ ◠   ◠  ${input.title}
 │   ${type === "error" ? "◠" : "◡"} │  ${input.description}
 ╰─────╯
-${!input.body ? "" : `
+${input.body ? `
 ${input.body}
-`}`, {
+` : ""}`, {
         color: colorByType[type]
     }));
 };
@@ -73,13 +73,6 @@ const createError = (bin, 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");
@@ -87,17 +80,8 @@ const getNpmVersion = async ()=>{
         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 getStackCommand = (command)=>{
+    return `pnpm stack ${command}`;
 };
 const hasDependency = (packageName)=>{
     return Boolean(require$1.resolve(packageName));
@@ -197,190 +181,308 @@ const ESLINT_EXTENSIONS = [
     "mdx"
 ];
 
-var version = "2.32.0";
-
-const createWatchCommand = (program)=>{
+const createBuildCommand = (program)=>{
     program.command({
-        name: "watch",
-        description: "Build and start the project in development mode"
+        description: "Build the project in production mode",
+        name: "build"
     }).task({
         async handler () {
-            await turbo("watch");
+            await turbo("build");
         }
     });
 };
 
-const createTestCommand = (program)=>{
-    program.command({
-        name: "test",
-        description: "Test the code execution"
-    }).task({
-        async handler () {
-            await turbo("test");
-        }
-    });
+const checkChangelog = async ()=>{
+    try {
+        return await helpers.exec("changeset status --since=origin/main");
+    } catch (error) {
+        throw createError("changeset", error);
+    }
 };
 
-const createStartCommand = (program)=>{
-    program.command({
-        name: "start",
-        description: "Start the project in production mode"
-    }).task({
-        async handler () {
-            await turbo("start");
-        }
-    });
-};
+const checkCode = eslint({
+    isFixMode: false
+});
 
-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 () {
-            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 checkCommit = async ()=>{
+    try {
+        return await helpers.exec('commitlint --extends "@commitlint/config-conventional" --edit');
+    } catch (error) {
+        throw createError("commitlint", error);
+    }
 };
-const ifNotEqualTo = (validOption)=>(context)=>{
-        return !context[validOption];
-    };
 
-const createInstallCommand = (program)=>{
-    program.command({
-        name: "install",
-        description: "Install required setup"
-    }).task({
-        label: label$4("Install `git.pre-commit` hook"),
-        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`);
-        }
-    }).task({
-        label: label$4("Install `git.commit-msg` hook"),
-        async handler () {
-            await installGitHook("commit-msg", getStackCommand("check --filter commit", false));
-        }
-    }).task({
-        label: label$4("Check the package manager"),
-        async handler () {
-            await checkPackageManager();
-        }
+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 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 = [
-    "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));
+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
         });
-        if (prettierFiles.length === 0) return;
     }
-    const arguments_ = [
-        ...prettierFiles
-    ];
-    if (existsSync(resolveFromProjectDirectory(".gitignore"))) {
-        arguments_.push("--ignore-path .gitignore");
+    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
+        });
     }
-    arguments_.push("--write", "--ignore-unknown", "--no-error-on-unmatched-pattern");
+    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(`prettier ${arguments_.join(" ")}`);
+        return await helpers.exec("pnpm --parallel exec tsc --noEmit");
     } catch (error) {
-        throw createError("prettier", error);
+        throw createError("tsc", error);
     }
 };
 
-const createFixCommand = (program)=>{
+const ONLY_VALUES = [
+    "changelog",
+    "commit",
+    "code",
+    "dependency",
+    "type"
+];
+const createCheckCommand = (program)=>{
     program.command({
-        name: "fix",
-        description: "Fix auto-fixable issues"
+        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({
-        label: label$3("Prepare the project"),
         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({
-        label: label$3("Fix linter issues"),
+        async handler () {
+            await checkChangelog();
+        },
+        label: label$4("Check changelog compliance"),
+        skip: ifFilterDefinedAndNotEqualTo("changelog")
+    }).task({
+        async handler () {
+            await checkDependency();
+        },
+        label: label$4("Check dependency compliance"),
+        skip: ifFilterDefinedAndNotEqualTo("dependency")
+    }).task({
         async handler (_, argv) {
-            await fixLinter(argv.operands);
+            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({
-        label: label$3("Fix formatting issues"),
-        async handler (_, argv) {
-            await fixFormatting(argv.operands);
+        async handler () {
+            await checkCommit();
+        },
+        label: label$4("Check commit compliance"),
+        skip (context) {
+            return context.filter !== "commit";
         }
     });
 };
-const label$3 = (message)=>`${message} 🚑`;
+const label$4 = (message)=>`${message} 🧐`;
+const ifFilterDefinedAndNotEqualTo = (filter)=>(context)=>{
+        return context.filter !== undefined && context.filter !== filter;
+    };
 
-const createCreateCommand = (program)=>{
+const createCleanCommand = (program)=>{
     program.command({
-        name: "create",
-        description: "Scaffold a new project"
+        description: "Clean the project",
+        name: "clean"
     }).task({
-        handler () {
-            botMessage({
-                title: `I'm Stack v${version}, your bot assistant`,
-                description: "I can guarantee you a project creation in under 1 minute 🚀",
+        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"
+];
+
+var version = "2.33.0-next-40f7a45";
+
+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({
-        label: label$2("Check pre-requisites"),
         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?",
@@ -390,22 +492,20 @@ const createCreateCommand = (program)=>{
         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)",
-        defaultValue: "git@github.com:adbayb/xxx.git",
         type: "text"
     }).input({
+        defaultValue: "single-project",
         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, inputUrl }) {
             if (!inputName) {
                 throw createError("stack create", "The project name is not optional. Make sure to provide a valid value (non-empty string).");
@@ -414,50 +514,51 @@ const createCreateCommand = (program)=>{
             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")).replace("v", "");
-            const npmVersion = (await request.get("https://registry.npmjs.org/pnpm/latest", "json")).version;
+            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,
-                npmVersion,
+                nodeVersion: nodeVersion.replace("v", ""),
+                npmVersion: String(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`);
         },
+        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({
-        label: label$2("Initialize `git`"),
         async handler ({ data }) {
             await helpers.exec("git init");
             await helpers.exec(`git remote add origin ${data.projectUrl}`);
-        }
+        },
+        label: label$2("Initialize `git`")
     }).task({
-        label: label$2("Apply template"),
         handler ({ data, inputTemplate }) {
             applyTemplate(inputTemplate, data);
-        }
+        },
+        label: label$2("Apply template")
     }).task({
-        label: label$2("Create a symlink to `README.md` file"),
         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({
-        label: label$2("Set up the package manager"),
         async handler () {
             await setPackageManager();
-        }
+        },
+        label: label$2("Set up the package manager")
     }).task({
-        label: label$2("Install dependencies"),
         async handler ({ data }) {
             const localDevelopmentDependencies = [
                 "quickbundle",
@@ -473,23 +574,24 @@ const createCreateCommand = (program)=>{
             } catch (error) {
                 throw createError("pnpm", error);
             }
-        }
+        },
+        label: label$2("Install dependencies")
     }).task({
-        label: label$2("Run `stack install`"),
         async handler () {
             await helpers.exec("stack install");
-        }
+        },
+        label: label$2("Run `stack install`")
     }).task({
-        label: label$2("Commit"),
         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({
-                title: "The project was successfully created",
                 description: `Run \`cd ./${data.projectName}\` and Enjoy 🚀`,
+                title: "The project was successfully created",
                 type: "success"
             });
         }
@@ -533,281 +635,173 @@ const label$2 = (message)=>`${message} 🔨`;
     });
 };
 
-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(files.join("\n   "), {
-                label: "Removed assets",
-                lineBreak: {
-                    end: false,
-                    start: true
-                },
-                type: "information"
-            });
-        },
-        skip ({ files }) {
-            return files.length === 0;
-        }
-    });
-};
-const label$1 = (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"
+const PRETTIER_IGNORE_FILES = [
+    "pnpm-lock.yaml"
 ];
-
-const checkType = async ()=>{
-    try {
-        return await helpers.exec("pnpm --parallel exec tsc --noEmit");
-    } catch (error) {
-        throw createError("tsc", 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 {
-            name: package_.name,
-            dependencies,
-            devDependencies,
-            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 = ({ name, dependencies, devDependencies, peerDependencies })=>{
-    for (const dependencyName of Object.keys(devDependencies)){
-        const version = devDependencies[dependencyName];
-        assertVersion(version, {
-            name: dependencyName,
-            consumedBy: name
-        });
-        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.`, {
-            name: dependencyName,
-            consumedBy: name
-        });
-    }
-    for (const dependencyName of Object.keys(dependencies)){
-        const version = dependencies[dependencyName];
-        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
+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;
     }
-    for (const dependencyName of Object.keys(peerDependencies)){
-        const version = peerDependencies[dependencyName];
-        assertVersion(version, {
-            name: dependencyName,
-            consumedBy: name
-        });
-        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.`, {
-            name: dependencyName,
-            consumedBy: name
-        });
+    const arguments_ = [
+        ...prettierFiles
+    ];
+    if (existsSync(resolveFromProjectDirectory(".gitignore"))) {
+        arguments_.push("--ignore-path .gitignore");
     }
-};
-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}\`).`, {
-                    name: dependencyName,
-                    consumedBy: packageName
-                });
-            }
-        }
-    };
-    return (package_)=>{
-        lint(package_, "development");
-        lint(package_, "production");
-    };
-};
-const createPackageError = (message, context)=>{
-    return createError("stack check", !context ? message : `\`${context.name}\` consumed by \`${context.consumedBy}\` doesn't conform to package guidelines.\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 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 checkCommit = async ()=>{
+    arguments_.push("--write", "--ignore-unknown", "--no-error-on-unmatched-pattern");
     try {
-        return await helpers.exec('commitlint --extends "@commitlint/config-conventional" --edit');
+        return await helpers.exec(`prettier ${arguments_.join(" ")}`);
     } catch (error) {
-        throw createError("commitlint", error);
+        throw createError("prettier", error);
     }
 };
 
-const checkCode = eslint({
-    isFixMode: false
+const fixLinter = eslint({
+    isFixMode: true
 });
 
-const ONLY_VALUES = [
-    "commit",
-    "code",
-    "dependency",
-    "type"
-];
-const createCheckCommand = (program)=>{
+const createFixCommand = (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: undefined
+        description: "Fix auto-fixable issues",
+        name: "fix"
     }).task({
         handler (_, argv) {
             logCheckableFiles(argv.operands);
-        },
-        skip: ifFilterDefinedAndNotEqualTo("code")
+        }
     }).task({
-        label: label("Prepare the project"),
         async handler () {
             await turbo("build", {
                 excludeExamples: true,
                 hasLiveOutput: false
             });
         },
-        skip ({ filter }) {
-            return filter === "commit"; // No need to build if only commit is checked
-        }
+        label: label$1("Prepare the project")
     }).task({
-        label: label("Check dependency compliance"),
-        async handler () {
-            await checkDependency();
+        async handler (_, argv) {
+            await fixLinter(argv.operands);
         },
-        skip: ifFilterDefinedAndNotEqualTo("dependency")
+        label: label$1("Fix linter issues")
     }).task({
-        label: label("Check code compliance"),
         async handler (_, argv) {
-            const filenames = argv.operands;
-            await checkCode(filenames);
+            await fixFormatting(argv.operands);
         },
-        skip: ifFilterDefinedAndNotEqualTo("code")
+        label: label$1("Fix formatting issues")
+    });
+};
+const label$1 = (message)=>`${message} 🚑`;
+
+const createInstallCommand = (program)=>{
+    program.command({
+        description: "Install required setup",
+        name: "install"
     }).task({
-        label: label("Check type compliance"),
         async handler () {
-            await checkType();
+            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`);
         },
-        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;
-        }
+        label: label("Install `git.pre-commit` hook")
     }).task({
-        label: label("Check commit compliance"),
         async handler () {
-            await checkCommit();
+            await installGitHook("commit-msg", getStackCommand("check --filter commit"));
         },
-        skip (context) {
-            return context.filter !== "commit";
-        }
+        label: label("Install `git.commit-msg` hook")
     });
 };
-const label = (message)=>`${message} 🧐`;
-const ifFilterDefinedAndNotEqualTo = (filter)=>(context)=>{
-        return context.filter !== undefined && context.filter !== filter;
+const label = (message)=>`${message} 📲`;
+const installGitHook = async (hook, content)=>{
+    const filename = resolveFromProjectDirectory(`.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];
     };
 
-const createBuildCommand = (program)=>{
+const createStartCommand = (program)=>{
     program.command({
-        name: "build",
-        description: "Build the project in production mode"
+        description: "Start the project in production mode",
+        name: "start"
     }).task({
         async handler () {
-            await turbo("build");
+            await turbo("start");
+        }
+    });
+};
+
+const createTestCommand = (program)=>{
+    program.command({
+        description: "Test the code execution",
+        name: "test"
+    }).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");
         }
     });
 };
 
 const createProgram = (...commandFactories)=>{
     const program = termost({
-        name: "stack",
         description: "Toolbox to easily scaffold and maintain a project",
+        name: "stack",
         onException () {
             botMessage({
-                title: "Oops, an error occurred",
                 description: "Keep calm and carry on with some coffee ☕️",
+                title: "Oops, an error occurred",
                 type: "error"
             });
         },