@solvro/config 1.8.3 → 1.10.0

package/dist/cli/index.js

@@ -1,46 +1,39 @@
 // src/cli/index.ts
 import * as p6 from "@clack/prompts";
-import { $ as $4 } from "execa";
-import { isPackageListed as isPackageListed2 } from "local-pkg";
 import c from "picocolors";
 
-// src/utils/get-project-type.ts
-import { isPackageExists } from "local-pkg";
-var getProjectType = () => {
-  const isAdonis = isPackageExists("@adonisjs/core");
-  const isNext = isPackageExists("next");
-  if (isNext && isAdonis) {
-    throw new Error(
-      "You can't use both Adonis and Next.js in the same project"
-    );
-  }
-  if (isAdonis) {
-    return "adonis";
-  }
-  if (isNext) {
-    return "next";
-  }
-  return "node";
-};
-
-// src/utils/git-root.ts
-import { execSync } from "node:child_process";
-var gitRoot = () => {
-  const root = execSync("git rev-parse --show-toplevel").toString().trim();
-  return root;
-};
-
 // src/utils/is-git-clean.ts
-import { execSync as execSync2 } from "node:child_process";
+import { execSync } from "node:child_process";
 function isGitClean() {
   try {
-    execSync2("git diff-index --quiet HEAD --");
+    execSync("git diff-index --quiet HEAD --");
     return true;
   } catch {
     return false;
   }
 }
 
+// src/utils/package-json.ts
+import * as p2 from "@clack/prompts";
+import { $ } from "execa";
+import {
+  getPackageInfo,
+  isPackageExists,
+  isPackageListed,
+  loadPackageJSON
+} from "local-pkg";
+import assert from "node:assert";
+import { writeFile } from "node:fs/promises";
+import path from "node:path";
+import semver from "semver";
+
+// src/utils/git-root.ts
+import { execSync as execSync2 } from "node:child_process";
+var gitRoot = () => {
+  const root2 = execSync2("git rev-parse --show-toplevel").toString().trim();
+  return root2;
+};
+
 // src/utils/polish-confirm.ts
 import * as p from "@clack/prompts";
 var polishConfirm = async (props) => {
@@ -51,17 +44,141 @@ var polishConfirm = async (props) => {
   });
 };
 
-// src/cli/install-eslint.ts
-import * as p2 from "@clack/prompts";
-import { $ } from "execa";
-import { getPackageInfo } from "local-pkg";
-import { existsSync } from "node:fs";
-import * as fs from "node:fs/promises";
-import path from "node:path";
-import semver from "semver";
+// src/utils/package-json.ts
 var $$ = $({
   cwd: gitRoot()
 });
+var PackageJson = class {
+  json = null;
+  async load() {
+    const json = await loadPackageJSON(gitRoot());
+    if (json === null) {
+      p2.cancel(
+        "Nie znaleziono package.json. Upewnij si\u0119, \u017Ce jeste\u015B w katalogu projektu."
+      );
+      process.exit(1);
+    }
+    this.json = json;
+  }
+  hasPackage(pkg) {
+    return isPackageListed(pkg);
+  }
+  async doesSatisfies(pkg, version) {
+    await this.load();
+    assert(this.json !== null);
+    if (this.json.dependencies?.[pkg] === void 0) {
+      return false;
+    }
+    return semver.satisfies(this.json.dependencies[pkg], version);
+  }
+  async ensureESM() {
+    await this.load();
+    const isConfirmed = await polishConfirm({
+      message: `Tw\xF3j projekt nie u\u017Cywa ESM (brak type: "module" w package.json). Czy chcesz to doda\u0107? (Wymagane by kontynuowa\u0107)`
+    });
+    if (p2.isCancel(isConfirmed) || !isConfirmed) {
+      p2.cancel("Zmie\u0144 projekt na ESM i spr\xF3buj ponownie.");
+      process.exit(1);
+    }
+    assert(this.json !== null);
+    this.json.type = "module";
+    await this.save();
+  }
+  async getProjectType() {
+    const isAdonis = isPackageExists("@adonisjs/core");
+    const isNext = isPackageExists("next");
+    if (isNext && isAdonis) {
+      throw new Error(
+        "You can't use both Adonis and Next.js in the same project"
+      );
+    }
+    if (isAdonis) {
+      return "adonis";
+    }
+    if (isNext) {
+      return "next";
+    }
+    return "node";
+  }
+  async save() {
+    await writeFile(
+      path.join(gitRoot(), "package.json"),
+      JSON.stringify(this.json, null, 2)
+    );
+  }
+  async addScriptIfNotExists(name, script) {
+    await this.load();
+    assert(this.json !== null);
+    if (this.json.scripts?.[name] !== void 0) {
+      return;
+    }
+    this.json.scripts = this.json.scripts ?? {};
+    this.json.scripts[name] = script;
+    await this.save();
+  }
+  async install(pkg, options) {
+    const info = await getPackageInfo(pkg);
+    if (info?.version !== void 0 && options?.minVersion !== void 0) {
+      if (!semver.satisfies(info.version, options.minVersion)) {
+        const spinner3 = p2.spinner();
+        spinner3.start(`Aktualizowanie ${pkg}`);
+        await $$`npm i ${options.dev === true ? "-D" : ""}@latest ${pkg}`;
+        spinner3.stop(`${pkg} zaktualizowany \u{1F60D}`);
+        await this.load();
+        return;
+      } else {
+        return;
+      }
+    }
+    if (info !== void 0) {
+      return;
+    }
+    const spinner2 = p2.spinner();
+    spinner2.start(`Instalowanie ${pkg}`);
+    await $$`npm i ${options?.dev === true ? "-D" : ""}@latest ${pkg}`;
+    spinner2.stop(`${pkg} zainstalowany \u{1F60D}`);
+    await this.load();
+  }
+};
+
+// src/cli/install-commitlint.ts
+import { writeFile as writeFile2 } from "fs/promises";
+import path2 from "path";
+
+// src/utils/$$.ts
+import { $ as $2 } from "execa";
+var $$2 = $2({
+  cwd: gitRoot()
+});
+
+// src/cli/templates/commitlint.ts
+var commitlint = () => `export default {
+  extends: ["@solvro/config/commitlint"],
+};
+`;
+
+// src/cli/install-commitlint.ts
+var root = gitRoot();
+var packageJson = new PackageJson();
+var installCommitLint = async () => {
+  if (!await packageJson.hasPackage("husky")) {
+    await packageJson.install("husky", { dev: true });
+    await $$2`npx husky init`;
+  }
+  await packageJson.install("@commitlint/cli", { dev: true });
+  await packageJson.install("@commitlint/config-conventional", { dev: true });
+  await writeFile2(
+    path2.join(root, ".husky/commit-msg"),
+    'npx commitlint --edit "$1"\n'
+  );
+  await writeFile2(path2.join(root, ".commitlintrc.js"), commitlint());
+};
+
+// src/cli/install-eslint.ts
+import * as p3 from "@clack/prompts";
+import { existsSync } from "node:fs";
+import * as fs from "node:fs/promises";
+import path3 from "node:path";
 var eslintConfigNames = [
   ".eslintrc.js",
   ".eslintrc.cjs",
@@ -76,75 +193,70 @@ var eslintConfigNames = [
   "eslint.config.mts",
   "eslint.config.cts"
 ];
+var packageJson2 = new PackageJson();
 var installEslint = async () => {
-  const root = gitRoot();
-  const eslint = await getPackageInfo("eslint");
-  if (typeof eslint?.version !== "string") {
-    const isConfirmed = await polishConfirm({
-      message: `Eslint nie jest zainstalowany. Czy chcesz go zainstalowa\u0107?`
-    });
-    if (!isConfirmed || p2.isCancel(isConfirmed)) {
-      p2.cancel("Zainstaluj Eslint i spr\xF3buj ponownie.");
-      process.exit(1);
-    }
-    const spinner4 = p2.spinner();
-    spinner4.start("Instalowanie Eslint");
-    await $$`npm i -D eslint`;
-    spinner4.stop("Eslint zainstalowany");
-  } else if (!semver.satisfies(eslint.version, ">=9")) {
-    const isConfirmed = await polishConfirm({
-      message: `Eslint jest zainstalowany, ale trzeba go zaktualizowa\u0107. Czy chcesz zaktualizowa\u0107?`
-    });
-    if (!isConfirmed || p2.isCancel(isConfirmed)) {
-      p2.cancel("Zaktualizuj Eslint i spr\xF3buj ponownie.");
+  const root2 = gitRoot();
+  await packageJson2.load();
+  await packageJson2.install("eslint", { dev: true, minVersion: ">=9" });
+  const type = await packageJson2.getProjectType();
+  if (type === "next") {
+    const is15 = await packageJson2.doesSatisfies("next", ">=15");
+    if (!is15) {
+      p3.cancel(
+        "Next.js musi by\u0107 w conajmniej wersji 15. Zaktualizuj Next.js i spr\xF3buj ponownie.\nWi\u0119cej informacji tutaj: https://nextjs.org/docs/app/building-your-application/upgrading/version-15"
+      );
       process.exit(1);
     }
-    const spinner4 = p2.spinner();
-    spinner4.start("Aktualizowanie Eslinta");
-    await $$`npm i -D eslint@latest`;
-    spinner4.stop("Eslint zaktualizowany");
+    await packageJson2.install("@next/eslint-plugin-next", { dev: true });
   }
   const eslintConfig = eslintConfigNames.find(
-    (configName) => existsSync(path.join(root, configName))
+    (configName) => existsSync(path3.join(root2, configName))
   );
-  if (eslintConfig) {
+  if (eslintConfig !== void 0) {
     const eslintContent = await fs.readFile(
-      path.join(root, eslintConfig),
+      path3.join(root2, eslintConfig),
       "utf-8"
     );
     if (eslintContent.includes("export default solvro(")) {
-      p2.note("Eslint jest ju\u017C skonfigurowany. Pomijam.");
+      p3.note("Eslint jest ju\u017C skonfigurowany. Pomijam.");
       return;
     } else {
       const isConfirmed = await polishConfirm({
         message: `Znaleziono plik konfiguracyjny Eslint. Czy chcesz go nadpisa\u0107?`
       });
-      if (!isConfirmed || p2.isCancel(isConfirmed)) {
-        p2.cancel("Nadpisz plik konfiguracyjny Eslint i spr\xF3buj ponownie.");
+      if (p3.isCancel(isConfirmed) || !isConfirmed) {
+        p3.cancel("Nadpisz plik konfiguracyjny Eslint i spr\xF3buj ponownie.");
         process.exit(1);
       }
-      await fs.rm(path.join(root, eslintConfig));
+      await fs.rm(path3.join(root2, eslintConfig));
     }
   }
   await fs.writeFile(
-    path.join(gitRoot(), "eslint.config.js"),
+    path3.join(gitRoot(), "eslint.config.js"),
     `import { solvro } from "@solvro/config/eslint";
 
 export default solvro();
 `
   );
-  p2.note("Plik konfiguracyjny Eslint zosta\u0142 utworzony.");
+  p3.note("Plik konfiguracyjny Eslint zosta\u0142 utworzony.");
 };
 
 // src/cli/install-ga.ts
-import * as p3 from "@clack/prompts";
-import { loadPackageJSON } from "local-pkg";
+import * as p4 from "@clack/prompts";
 import { existsSync as existsSync2 } from "node:fs";
 import * as fs2 from "node:fs/promises";
-import path2 from "node:path";
+import path4 from "node:path";
+
+// src/cli/templates/commit-lint-ci.ts
+var commitLintCi = () => `      - name: Run commitlint check
+        run: npx commitlint -f \${{ github.event.pull_request.base.sha }}
+`;
 
 // src/cli/templates/adonis-ci.ts
-var adonisCi = ({ nodeVersion }) => `name: CI
+var adonisCi = ({
+  nodeVersion,
+  withCommitlint
+}) => `name: CI
 
 on:
   push:
@@ -171,7 +283,7 @@ jobs:
         run: |
           cp .env.example .env
           node ace generate:key
-
+${withCommitlint ? commitLintCi() : ""}
       - name: Run prettier
         run: npm run format:check
         if: always()
@@ -204,7 +316,10 @@ updates:
 `;
 
 // src/cli/templates/next-ci.ts
-var nextCi = ({ nodeVersion }) => `name: CI
+var nextCi = ({
+  nodeVersion,
+  withCommitlint
+}) => `name: CI
 
 on:
   push:
@@ -226,7 +341,7 @@ jobs:
 
       - name: Install dependencies
         run: npm ci
-
+${withCommitlint ? commitLintCi() : ""}
       - name: Format check
         run: npm run format:check
         if: always()
@@ -236,116 +351,72 @@ jobs:
         if: always()`;
 
 // src/cli/install-ga.ts
+var packageJson3 = new PackageJson();
 var installGithubActions = async () => {
-  const root = gitRoot();
-  const ghWorkflowsDir = path2.join(root, ".github/workflows");
+  const root2 = gitRoot();
+  await packageJson3.load();
+  const ghWorkflowsDir = path4.join(root2, ".github/workflows");
   await fs2.mkdir(ghWorkflowsDir, { recursive: true });
-  const type = getProjectType();
+  const type = await packageJson3.getProjectType();
+  const withCommitlint = await packageJson3.hasPackage("@commitlint/cli");
   if (type === "adonis") {
-    if (!existsSync2(path2.join(root, ".env.example"))) {
-      p3.cancel(
+    if (!existsSync2(path4.join(root2, ".env.example"))) {
+      p4.cancel(
         "Nie znaleziono pliku .env.example. Upewnij si\u0119, \u017Ce jeste\u015B w katalogu projektu Adonisa."
       );
       process.exit(1);
     }
     await fs2.writeFile(
-      path2.join(ghWorkflowsDir, "ci.yml"),
+      path4.join(ghWorkflowsDir, "ci.yml"),
       adonisCi({
-        nodeVersion: "22"
+        nodeVersion: "22",
+        withCommitlint
       })
     );
   }
   if (type === "next") {
     await fs2.writeFile(
-      path2.join(ghWorkflowsDir, "ci.yml"),
+      path4.join(ghWorkflowsDir, "ci.yml"),
       nextCi({
-        nodeVersion: "22"
+        nodeVersion: "22",
+        withCommitlint
       })
     );
   }
-  if (!existsSync2(path2.join(root, ".github/dependabot.yml"))) {
-    await fs2.writeFile(path2.join(root, ".github/dependabot.yml"), dependabot());
+  if (!existsSync2(path4.join(root2, ".github/dependabot.yml"))) {
+    await fs2.writeFile(path4.join(root2, ".github/dependabot.yml"), dependabot());
   }
-  const packageJson = await loadPackageJSON(root);
-  if (!packageJson) {
-    p3.cancel(
-      "Nie znaleziono package.json. Upewnij si\u0119, \u017Ce jeste\u015B w katalogu projektu."
-    );
-    process.exit(1);
-  }
-  packageJson.scripts = packageJson.scripts ?? {};
-  if (!packageJson.scripts["format:check"]) {
-    packageJson.scripts["format:check"] = "prettier --check .";
-  }
-  if (!packageJson.scripts.lint) {
-    packageJson.scripts.lint = "eslint .";
-  }
-  if (!packageJson.scripts.format) {
-    packageJson.scripts.format = "prettier --write .";
-  }
-  if (!packageJson.scripts.typecheck) {
-    packageJson.scripts.typecheck = "tsc --noEmit";
-  }
-  await fs2.writeFile(
-    path2.join(root, "package.json"),
-    JSON.stringify(packageJson, null, 2)
-  );
-  p3.note("Dodano konfiguracj\u0119 CI i skrypty.");
+  await packageJson3.addScriptIfNotExists("format:check", "prettier --check .");
+  await packageJson3.addScriptIfNotExists("lint", "eslint . --max-warnings=0");
+  await packageJson3.addScriptIfNotExists("format", "prettier --write .");
+  await packageJson3.addScriptIfNotExists("typecheck", "tsc --noEmit");
+  p4.note("Dodano konfiguracj\u0119 CI i skrypty.");
 };
 
 // src/cli/install-lint-staged.ts
-import * as p4 from "@clack/prompts";
-import { $ as $2 } from "execa";
-import { writeFile as writeFile3 } from "fs/promises";
-import { isPackageListed, loadPackageJSON as loadPackageJSON2 } from "local-pkg";
-import path3 from "path";
-var $$2 = $2({
-  cwd: gitRoot()
-});
+import assert2 from "assert";
+import { writeFile as writeFile5 } from "fs/promises";
+var packageJson4 = new PackageJson();
 var installLintStaged = async () => {
-  const lintStaged = await isPackageListed("lint-staged");
-  const husky = await isPackageListed("husky");
-  if (!lintStaged) {
-    const spinner4 = p4.spinner();
-    spinner4.start("Instalowanie lint-staged");
-    await $$2`npm i -D lint-staged`;
-    spinner4.stop("lint-staged zainstalowany");
-  }
-  if (!husky) {
-    const spinner4 = p4.spinner();
-    spinner4.start("Instalowanie husky");
-    await $$2`npm i -D husky`;
-    await $2`npx husky init`;
-    spinner4.stop("husky zainstalowany");
+  await packageJson4.load();
+  assert2(packageJson4.json !== null);
+  if (!await packageJson4.hasPackage("husky")) {
+    await packageJson4.install("husky");
+    await $$2`npx husky init`;
   }
-  await writeFile3(".husky/pre-commit", "npx lint-staged\n");
-  const packageJson = await loadPackageJSON2(gitRoot());
-  if (!packageJson) {
-    p4.cancel(
-      "Nie znaleziono package.json. Upewnij si\u0119, \u017Ce jeste\u015B w katalogu projektu."
-    );
-    process.exit(1);
-  }
-  packageJson["lint-staged"] = {
+  await writeFile5(".husky/pre-commit", "npx lint-staged\n");
+  packageJson4.json["lint-staged"] = {
     "*": "prettier -w --ignore-unknown"
   };
-  await writeFile3(
-    path3.join(gitRoot(), "package.json"),
-    JSON.stringify(packageJson, null, 2)
-  );
+  await packageJson4.save();
 };
 
 // src/cli/install-prettier.ts
 import * as p5 from "@clack/prompts";
-import { $ as $3 } from "execa";
-import { getPackageInfo as getPackageInfo2, loadPackageJSON as loadPackageJSON3 } from "local-pkg";
+import assert3 from "node:assert";
 import { existsSync as existsSync3 } from "node:fs";
 import * as fs3 from "node:fs/promises";
-import path4 from "node:path";
-import semver2 from "semver";
-var $$3 = $3({
-  cwd: gitRoot()
-});
+import path5 from "node:path";
 var prettierConfigNames = [
   ".prettierrc.js",
   ".prettierrc.cjs",
@@ -360,87 +431,55 @@ var prettierConfigNames = [
   "prettier.config.mts",
   "prettier.config.cts"
 ];
+var packageJson5 = new PackageJson();
 var installPrettier = async () => {
-  const root = gitRoot();
-  const packageJsonPath = path4.join(root, "package.json");
-  const prettier = await getPackageInfo2("prettier");
-  if (typeof prettier?.version !== "string") {
-    const isConfirmed = await polishConfirm({
-      message: `Prettier nie jest zainstalowany. Czy chcesz go zainstalowa\u0107?`
-    });
-    if (!isConfirmed || p5.isCancel(isConfirmed)) {
-      p5.cancel("Zainstaluj Prettiera i spr\xF3buj ponownie.");
-      process.exit(1);
-    }
-    const spinner4 = p5.spinner();
-    spinner4.start("Instalowanie Prettiera");
-    await $$3`npm i -D prettier`;
-    spinner4.stop("Prettiera zainstalowany");
-  } else if (!semver2.satisfies(prettier.version, ">=3")) {
-    const isConfirmed = await polishConfirm({
-      message: `Prettier jest zainstalowany, ale trzeba go zaktualizowa\u0107. Czy chcesz zaktualizowa\u0107?`
-    });
-    if (p5.isCancel(isConfirmed) || !isConfirmed) {
-      p5.cancel("Zaktualizuj Prettiera i spr\xF3buj ponownie.");
-      process.exit(1);
-    }
-    const spinner4 = p5.spinner();
-    spinner4.start("Aktualizowanie Prettiera");
-    await $$3`npm i -D eslint@latest`;
-    spinner4.stop("Prettier zaktualizowany");
-  }
+  const root2 = gitRoot();
+  await packageJson5.load();
+  assert3(packageJson5.json !== null);
   const prettierConfig = prettierConfigNames.find(
-    (configName) => existsSync3(path4.join(root, configName))
+    (configName) => existsSync3(path5.join(root2, configName))
   );
-  const packageJson = await loadPackageJSON3();
-  if (!packageJson) {
-    p5.cancel("Nie znaleziono pliku package.json.");
-    process.exit(1);
-  }
   const solvroPrettierPath = "@solvro/config/prettier";
-  if (prettierConfig || packageJson.prettier) {
-    if (packageJson.prettier === solvroPrettierPath) {
+  if (prettierConfig !== void 0 || packageJson5.json.prettier !== void 0) {
+    if (packageJson5.json.prettier === solvroPrettierPath) {
       p5.note("Konfiguracja Prettiera jest ju\u017C ustawiona. Pomijam.");
       return;
     }
     const isConfirmed = await polishConfirm({
       message: `Znaleziono konfiguracj\u0119 Prettiera. Czy chcesz j\u0105 nadpisa\u0107?`
     });
-    if (!isConfirmed || p5.isCancel(isConfirmed)) {
+    if (p5.isCancel(isConfirmed) || !isConfirmed) {
       p5.cancel("Usu\u0144 konfiguracje Prettiera i spr\xF3buj ponownie.");
       process.exit(1);
     }
     for (const configName of prettierConfigNames) {
-      await fs3.rm(path4.join(root, configName)).catch(() => null);
+      await fs3.rm(path5.join(root2, configName)).catch(() => null);
     }
   }
-  const newPackageJson = await loadPackageJSON3();
-  if (!newPackageJson) {
-    p5.cancel("Nie znaleziono pliku package.json.");
-    process.exit(1);
-  }
-  newPackageJson.prettier = solvroPrettierPath;
-  await fs3.writeFile(packageJsonPath, JSON.stringify(newPackageJson, null, 2));
+  packageJson5.json.prettier = solvroPrettierPath;
+  await packageJson5.save();
   p5.note("Konfiguracja Prettiera zosta\u0142a dodana.");
 };
 
 // src/cli/index.ts
-p6.intro(`${c.bold(c.bgBlue("  @solvro/config  "))}`);
-var projectType = getProjectType();
+p6.intro(c.bold(c.bgBlue("  @solvro/config  ")));
 if (!isGitClean()) {
   const isConfirmed = await polishConfirm({
     message: `Masz niezapisane zmiany w Git. Czy chcesz kontynuowa\u0107?`
   });
-  if (!isConfirmed || p6.isCancel(isConfirmed)) {
+  if (p6.isCancel(isConfirmed) || !isConfirmed) {
     p6.cancel("Zapisz zmiany w Git i spr\xF3buj ponownie.");
     process.exit(1);
   }
 }
+var packageJson6 = new PackageJson();
+await packageJson6.ensureESM();
+var projectType = await packageJson6.getProjectType();
 if (projectType === "adonis") {
   const isConfirmed = await polishConfirm({
     message: `Wygl\u0105da jakby\u015B u\u017Cywa\u0142 Adonisa. Czy to si\u0119 zgadza?`
   });
-  if (!isConfirmed || p6.isCancel(isConfirmed)) {
+  if (p6.isCancel(isConfirmed) || !isConfirmed) {
     p6.cancel("Zg\u0142o\u015B b\u0142\u0105d na GitHubie :(, a my spr\xF3bujemy pom\xF3c.");
     process.exit(1);
   }
@@ -466,42 +505,36 @@ if (projectType === "node") {
 }
 var additionalTools = await p6.multiselect({
   message: `Kt\xF3re rzeczy Ci\u0119 interesuj\u0105? ${c.gray("zaznacz spacj\u0105, potwierd\u017A enterem")}`,
-  initialValues: ["eslint", "prettier", "gh-action"],
+  initialValues: ["eslint", "prettier", "gh-action", "commitlint"],
   options: [
     {
       value: "eslint",
-      label: `${c.bold(c.blueBright("ESLint"))}`,
+      label: c.bold(c.blueBright("ESLint")),
       hint: "sprawdzanie jako\u015Bci kodu"
     },
     {
       value: "prettier",
-      label: `${c.bold(c.yellowBright("Prettier"))}`,
+      label: c.bold(c.yellowBright("Prettier")),
       hint: "formatowanie"
     },
     {
       value: "gh-action",
-      label: `${c.bold("GitHub Actions")}`,
+      label: c.bold("GitHub Actions"),
       hint: "automatyczne testy na Githubie"
+    },
+    {
+      value: "commitlint",
+      label: c.bold("Commitlint"),
+      hint: "walidacja tre\u015Bci commit\xF3w"
     }
   ],
   required: false
 });
-var $$4 = $4({
-  cwd: gitRoot()
-});
-if (p6.isCancel(additionalTools)) {
+if (p6.isCancel(additionalTools) || additionalTools.length === 0) {
   p6.cancel("Nie wybrano \u017Cadnych narz\u0119dzi.");
   process.exit(1);
 }
-await p6.tasks([
-  {
-    title: "Instalowanie @solvro/config",
-    enabled: !await isPackageListed2("@solvro/config"),
-    task: async () => {
-      await $$4`npm i -D @solvro/config`;
-    }
-  }
-]);
+await packageJson6.install("@solvro/config", { dev: true });
 if (additionalTools.includes("eslint")) {
   await installEslint();
 }
@@ -509,6 +542,10 @@ if (additionalTools.includes("prettier")) {
   await installPrettier();
   await installLintStaged();
 }
+if (additionalTools.includes("commitlint")) {
+  await installCommitLint();
+}
 if (additionalTools.includes("gh-action")) {
   await installGithubActions();
 }
+//# sourceMappingURL=index.js.map