@mayrlabs/setup-project 0.1.3 → 0.1.5

package/dist/index.mjs

@@ -16,6 +16,19 @@ var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename, getDirname, __dirname;
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+    getFilename = () => fileURLToPath(import.meta.url);
+    getDirname = () => path.dirname(getFilename());
+    __dirname = /* @__PURE__ */ getDirname();
+  }
+});
+
 // src/utils/pm.ts
 import { execa } from "execa";
 async function getPackageManager() {
@@ -48,37 +61,156 @@ async function installPackages(packages, dev = false) {
 var init_pm = __esm({
   "src/utils/pm.ts"() {
     "use strict";
+    init_esm_shims();
   }
 });
 
-// src/services/husky.ts
-import { select, text } from "@clack/prompts";
-import { execa as execa2 } from "execa";
-import fs from "fs-extra";
-async function promptHusky(config) {
-  const hookType = await select({
-    message: "What pre-commit hook would you like to use?",
-    options: [
+// src/constants/options.ts
+var TOOL_OPTIONS, HUSKY_HOOK_OPTIONS, FORMATTER_OPTIONS, LINTER_OPTIONS, LINT_STAGED_EXTENSIONS, ENV_VARIANT_OPTIONS, ENV_VALIDATOR_OPTIONS, ENV_PRESET_OPTIONS, ENV_SPLIT_OPTIONS, TEST_RUNNER_OPTIONS, EDITOR_CONFIG_OPTIONS, LICENSE_TYPE_OPTIONS;
+var init_options = __esm({
+  "src/constants/options.ts"() {
+    "use strict";
+    init_esm_shims();
+    TOOL_OPTIONS = [
+      { value: "husky", label: "Husky" },
+      { value: "formatter", label: "Formatter (Prettier/Oxfmt)" },
+      { value: "linter", label: "Linter (Eslint/Oxlint)" },
+      { value: "lint-staged", label: "Lint-staged" },
+      { value: "env", label: "Env Validation (@t3-oss/env)" },
+      { value: "test", label: "Test Runner (Vitest/Jest)" },
+      { value: "editorConfig", label: "EditorConfig" },
+      { value: "license", label: "License" }
+    ];
+    HUSKY_HOOK_OPTIONS = [
       { value: "lint-staged", label: "lint-staged" },
       { value: "custom", label: "Custom script" },
       { value: "none", label: "None" }
-    ]
-  });
-  config.huskyHookType = hookType;
+    ];
+    FORMATTER_OPTIONS = [
+      { value: "prettier", label: "Prettier" },
+      { value: "oxfmt", label: "Oxfmt" }
+    ];
+    LINTER_OPTIONS = [
+      { value: "eslint", label: "ESLint" },
+      { value: "oxlint", label: "Oxlint" }
+    ];
+    LINT_STAGED_EXTENSIONS = [
+      { value: "js", label: "js" },
+      { value: "ts", label: "ts" },
+      { value: "jsx", label: "jsx" },
+      { value: "tsx", label: "tsx" },
+      { value: "html", label: "html" },
+      { value: "vue", label: "vue" },
+      { value: "svelte", label: "svelte" },
+      { value: "css", label: "css" },
+      { value: "scss", label: "scss" },
+      { value: "json", label: "json" },
+      { value: "yaml", label: "yaml" },
+      { value: "md", label: "md" }
+    ];
+    ENV_VARIANT_OPTIONS = [
+      { value: "@t3-oss/env-nextjs", label: "Next.js" },
+      { value: "@t3-oss/env-nuxt", label: "Nuxt" },
+      { value: "@t3-oss/env-core", label: "Core" }
+    ];
+    ENV_VALIDATOR_OPTIONS = [
+      { value: "zod", label: "Zod" },
+      { value: "valibot", label: "Valibot" },
+      { value: "arktype", label: "Arktype" }
+    ];
+    ENV_PRESET_OPTIONS = [
+      { value: "netlify", label: "Netlify" },
+      { value: "vercel", label: "Vercel" },
+      { value: "neonVercel", label: "Neon (Vercel)" },
+      { value: "supabaseVercel", label: "Supabase (Vercel)" },
+      { value: "uploadThing", label: "UploadThing" },
+      { value: "render", label: "Render" },
+      { value: "railway", label: "Railway" },
+      { value: "fly.io", label: "Fly.io" },
+      { value: "upstashRedis", label: "Upstash Redis" },
+      { value: "coolify", label: "Coolify" },
+      { value: "vite", label: "Vite" },
+      { value: "wxt", label: "WXT" }
+    ];
+    ENV_SPLIT_OPTIONS = [
+      { value: "split", label: "Split (env/server.ts, env/client.ts)" },
+      { value: "joined", label: "Joined (env.ts)" }
+    ];
+    TEST_RUNNER_OPTIONS = [
+      { value: "vitest", label: "Vitest" },
+      { value: "jest", label: "Jest" }
+    ];
+    EDITOR_CONFIG_OPTIONS = [
+      { value: "default", label: "Default (Spaces 2)" },
+      { value: "spaces4", label: "Spaces 4" },
+      { value: "tabs", label: "Tabs" }
+    ];
+    LICENSE_TYPE_OPTIONS = [
+      { value: "MIT", label: "MIT" },
+      { value: "ISC", label: "ISC" },
+      { value: "Apache-2.0", label: "Apache 2.0" },
+      { value: "UNLICENSED", label: "UNLICENSED" }
+    ];
+  }
+});
+
+// src/utils/handle-cancel.ts
+import { cancel, isCancel, confirm } from "@clack/prompts";
+async function withCancelHandling(promptFn, cancelMessage = "Operation cancelled.") {
+  while (true) {
+    const response = await promptFn();
+    if (isCancel(response)) {
+      const shouldCancel = await confirm({
+        message: "Do you really want to cancel options selection?"
+      });
+      if (isCancel(shouldCancel) || shouldCancel) {
+        cancel(cancelMessage);
+        process.exit(0);
+      }
+      continue;
+    } else {
+      return response;
+    }
+  }
+}
+var init_handle_cancel = __esm({
+  "src/utils/handle-cancel.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/services/husky.ts
+import { select, log, text } from "@clack/prompts";
+import { execa as execa2 } from "execa";
+import fs from "fs-extra";
+import pc from "picocolors";
+async function promptHusky(config2) {
+  log.message(pc.bgMagenta(pc.black(" Husky Configuration ")));
+  const hookType = await withCancelHandling(
+    async () => select({
+      message: "What pre-commit hook would you like to use?",
+      options: HUSKY_HOOK_OPTIONS
+    })
+  );
+  const huskyConfig = config2.get("husky");
+  huskyConfig.options = { hookType };
   if (hookType === "lint-staged") {
-    config.lintStaged = true;
+    config2.enableTool("lintStaged");
   } else if (hookType === "custom") {
-    const script = await text({
-      message: "Enter your custom pre-commit script:",
-      placeholder: "npm test",
-      validate(value) {
-        if (value.length === 0) return "Value is required!";
-      }
-    });
-    config.huskyCustomScript = script;
+    const script = await withCancelHandling(
+      async () => text({
+        message: "Enter your custom pre-commit script:",
+        placeholder: huskyConfig.options.customScript,
+        validate(value) {
+          if (value.length === 0) return "Value is required!";
+        }
+      })
+    );
+    huskyConfig.options.customScript = script;
   }
 }
-async function installHusky(config) {
+async function installHusky(config2) {
   await installPackages(["husky"], true);
   try {
     await execa2("npx", ["husky", "init"]);
@@ -86,12 +218,15 @@ async function installHusky(config) {
     await execa2("npm", ["pkg", "set", "scripts.prepare=husky"]);
     await execa2("npm", ["run", "prepare"]);
   }
-  if (config.huskyHookType === "lint-staged") {
+  const husky = config2.get("husky");
+  const hookType = husky.options.hookType;
+  const customScript = husky.options.customScript;
+  if (hookType === "lint-staged") {
     await fs.outputFile(".husky/pre-commit", "npx lint-staged\n", {
       mode: 493
     });
-  } else if (config.huskyHookType === "custom" && config.huskyCustomScript) {
-    await fs.outputFile(".husky/pre-commit", `${config.huskyCustomScript}
+  } else if (hookType === "custom" && customScript) {
+    await fs.outputFile(".husky/pre-commit", `${customScript}
 `, {
       mode: 493
     });
@@ -100,27 +235,32 @@ async function installHusky(config) {
 var init_husky = __esm({
   "src/services/husky.ts"() {
     "use strict";
+    init_esm_shims();
     init_pm();
+    init_options();
+    init_handle_cancel();
   }
 });
 
 // src/services/formatter.ts
-import { select as select2 } from "@clack/prompts";
+import { select as select2, log as log2 } from "@clack/prompts";
 import fs2 from "fs-extra";
-async function promptFormatter(config) {
-  if (!config.formatterChoice) {
-    const formatter = await select2({
+import pc2 from "picocolors";
+async function promptFormatter(config2) {
+  const formatterConfig = config2.get("formatter");
+  log2.message(pc2.bgBlue(pc2.black(" Formatter Configuration ")));
+  const formatter = await withCancelHandling(
+    async () => select2({
       message: "Select a formatter:",
-      options: [
-        { value: "prettier", label: "Prettier" },
-        { value: "oxfmt", label: "Oxfmt" }
-      ]
-    });
-    config.formatterChoice = formatter;
-  }
+      options: FORMATTER_OPTIONS,
+      initialValue: formatterConfig.options.choice
+    })
+  );
+  formatterConfig.options = { choice: formatter };
 }
-async function installFormatter(config) {
-  if (config.formatterChoice === "prettier") {
+async function installFormatter(config2) {
+  const choice = config2.get("formatter").options.choice;
+  if (choice === "prettier") {
     await installPackages(["prettier"], true);
     const configContent = {
       semi: true,
@@ -130,34 +270,39 @@ async function installFormatter(config) {
       tabWidth: 2
     };
     await fs2.writeJson(".prettierrc", configContent, { spaces: 2 });
-  } else if (config.formatterChoice === "oxfmt") {
+  } else if (choice === "oxfmt") {
     await installPackages(["oxfmt"], true);
   }
 }
 var init_formatter = __esm({
   "src/services/formatter.ts"() {
     "use strict";
+    init_esm_shims();
     init_pm();
+    init_options();
+    init_handle_cancel();
   }
 });
 
 // src/services/linter.ts
-import { select as select3 } from "@clack/prompts";
+import { select as select3, log as log3 } from "@clack/prompts";
 import fs3 from "fs-extra";
-async function promptLinter(config) {
-  if (!config.linterChoice) {
-    const linter = await select3({
+import pc3 from "picocolors";
+async function promptLinter(config2) {
+  const linterConfig = config2.get("linter");
+  log3.message(pc3.bgYellow(pc3.black(" Linter Configuration ")));
+  const linter = await withCancelHandling(
+    async () => select3({
       message: "Select a linter:",
-      options: [
-        { value: "eslint", label: "ESLint" },
-        { value: "oxlint", label: "Oxlint" }
-      ]
-    });
-    config.linterChoice = linter;
-  }
+      options: LINTER_OPTIONS,
+      initialValue: linterConfig.options.choice
+    })
+  );
+  linterConfig.options = { choice: linter };
 }
-async function installLinter(config) {
-  if (config.linterChoice === "eslint") {
+async function installLinter(config2) {
+  const choice = config2.get("linter").options.choice;
+  if (choice === "eslint") {
     await installPackages(["eslint"], true);
     const configContent = {
       extends: ["eslint:recommended"],
@@ -171,81 +316,72 @@ async function installLinter(config) {
       }
     };
     await fs3.writeJson(".eslintrc.json", configContent, { spaces: 2 });
-  } else if (config.linterChoice === "oxlint") {
+  } else if (choice === "oxlint") {
     await installPackages(["oxlint"], true);
   }
 }
 var init_linter = __esm({
   "src/services/linter.ts"() {
     "use strict";
+    init_esm_shims();
     init_pm();
+    init_options();
+    init_handle_cancel();
   }
 });
 
 // src/services/lint-staged.ts
-import { multiselect } from "@clack/prompts";
+import { multiselect, log as log4 } from "@clack/prompts";
 import fs4 from "fs-extra";
-async function promptLintStaged(config) {
-  const lintExtensions = await multiselect({
-    message: "Select extensions to lint:",
-    options: [
-      { value: "js", label: "js" },
-      { value: "ts", label: "ts" },
-      { value: "jsx", label: "jsx" },
-      { value: "tsx", label: "tsx" },
-      { value: "html", label: "html" },
-      { value: "vue", label: "vue" },
-      { value: "svelte", label: "svelte" }
-    ],
-    required: false
-  });
-  const formatExtensions = await multiselect({
-    message: "Select extensions to format:",
-    options: [
-      { value: "md", label: "md" },
-      { value: "css", label: "css" },
-      { value: "scss", label: "scss" },
-      { value: "json", label: "json" },
-      { value: "yaml", label: "yaml" },
-      { value: "html", label: "html" },
-      { value: "js", label: "js" },
-      { value: "ts", label: "ts" },
-      { value: "jsx", label: "jsx" },
-      { value: "tsx", label: "tsx" },
-      { value: "vue", label: "vue" },
-      { value: "svelte", label: "svelte" }
-    ],
-    required: false
-  });
-  config.lintStagedLintExtensions = lintExtensions;
-  config.lintStagedFormatExtensions = formatExtensions;
-  if (lintExtensions.length > 0 && !config.linterChoice) {
-    await promptLinter(config);
-    config.linter = true;
-  }
-  if (formatExtensions.length > 0 && !config.formatterChoice) {
-    await promptFormatter(config);
-    config.formatter = true;
+import pc4 from "picocolors";
+async function promptLintStaged(config2) {
+  log4.message(pc4.bgGreen(pc4.black(" Lint-staged Configuration ")));
+  const lintExtensions = await withCancelHandling(
+    async () => multiselect({
+      message: "Select extensions to lint:",
+      options: LINT_STAGED_EXTENSIONS,
+      required: false
+    })
+  );
+  const formatExtensions = await withCancelHandling(
+    async () => multiselect({
+      message: "Select extensions to format:",
+      options: LINT_STAGED_EXTENSIONS,
+      required: false
+    })
+  );
+  config2.get("lintStaged").options = {
+    lintExtensions,
+    formatExtensions
+  };
+  if (lintExtensions.length > 0 && !config2.get("linter").selected) {
+    await promptLinter(config2);
+    config2.enableTool("linter");
+  }
+  if (formatExtensions.length > 0 && !config2.get("formatter").selected) {
+    await promptFormatter(config2);
+    config2.enableTool("formatter");
   }
 }
-async function installLintStaged(config) {
+async function installLintStaged(config2) {
   await installPackages(["lint-staged"], true);
   const lintStagedConfig = {};
-  const lintExts = config.lintStagedLintExtensions || [];
-  const formatExts = config.lintStagedFormatExtensions || [];
+  const lintStagedOptions = config2.get("lintStaged").options;
+  const lintExts = lintStagedOptions?.lintExtensions || [];
+  const formatExts = lintStagedOptions?.formatExtensions || [];
   if (lintExts.length > 0) {
-    await installLinter(config);
+    await installLinter(config2);
     const glob = `*.{${lintExts.join(",")}}`;
-    if (config.linterChoice === "oxlint") {
+    if (config2.get("linter").options.choice === "oxlint") {
       lintStagedConfig[glob] = ["npx oxlint --fix"];
     } else {
       lintStagedConfig[glob] = ["eslint --fix"];
     }
   }
   if (formatExts.length > 0) {
-    await installFormatter(config);
+    await installFormatter(config2);
     const glob = `*.{${formatExts.join(",")}}`;
-    if (config.formatterChoice === "oxfmt") {
+    if (config2.get("formatter").options.choice === "oxfmt") {
       lintStagedConfig[glob] = ["npx oxfmt"];
     } else {
       lintStagedConfig[glob] = ["prettier --write"];
@@ -256,92 +392,85 @@ async function installLintStaged(config) {
 var init_lint_staged = __esm({
   "src/services/lint-staged.ts"() {
     "use strict";
+    init_esm_shims();
     init_pm();
     init_formatter();
     init_linter();
+    init_options();
+    init_handle_cancel();
   }
 });
 
 // src/services/env.ts
-import { select as select5, confirm, text as text2, multiselect as multiselect2 } from "@clack/prompts";
+import { select as select4, confirm as confirm2, text as text2, multiselect as multiselect2, log as log5 } from "@clack/prompts";
 import fs5 from "fs-extra";
-import path from "path";
-async function promptEnv(config) {
-  const variant = await select5({
-    message: "Which @t3-oss/env variant?",
-    options: [
-      { value: "@t3-oss/env-nextjs", label: "Next.js" },
-      { value: "@t3-oss/env-nuxt", label: "Nuxt" },
-      { value: "@t3-oss/env-core", label: "Core" }
-    ]
-  });
-  config.envVariant = variant;
-  const validator = await select5({
-    message: "Which validator?",
-    options: [
-      { value: "zod", label: "Zod" },
-      { value: "valibot", label: "Valibot" },
-      { value: "arktype", label: "Arktype" }
-    ]
-  });
-  config.envValidator = validator;
-  const installPresets = await confirm({
-    message: "Install presets?"
-  });
-  config.envInstallPresets = installPresets;
+import path2 from "path";
+import pc5 from "picocolors";
+async function promptEnv(config2) {
+  log5.message(pc5.bgCyan(pc5.black(" Env Validation Configuration ")));
+  const variant = await withCancelHandling(
+    async () => select4({
+      message: "Which @t3-oss/env variant?",
+      options: ENV_VARIANT_OPTIONS
+    })
+  );
+  const validator = await withCancelHandling(
+    async () => select4({
+      message: "Which validator?",
+      options: ENV_VALIDATOR_OPTIONS
+    })
+  );
+  const installPresets = await withCancelHandling(
+    async () => confirm2({
+      message: "Install presets?"
+    })
+  );
+  let presets;
   if (installPresets) {
-    const presets = await multiselect2({
-      message: "Select preset to extend:",
-      options: [
-        { value: "netlify", label: "Netlify" },
-        { value: "vercel", label: "Vercel" },
-        { value: "neonVercel", label: "Neon (Vercel)" },
-        { value: "supabaseVercel", label: "Supabase (Vercel)" },
-        { value: "uploadThing", label: "UploadThing" },
-        { value: "render", label: "Render" },
-        { value: "railway", label: "Railway" },
-        { value: "fly.io", label: "Fly.io" },
-        { value: "upstashRedis", label: "Upstash Redis" },
-        { value: "coolify", label: "Coolify" },
-        { value: "vite", label: "Vite" },
-        { value: "wxt", label: "WXT" }
-      ],
-      required: false
-    });
-    config.envPresets = presets;
+    presets = await withCancelHandling(
+      async () => multiselect2({
+        message: "Select preset to extend:",
+        options: ENV_PRESET_OPTIONS,
+        required: false
+      })
+    );
   }
-  const split = await select5({
-    message: "Split or Joined env files?",
-    options: [
-      { value: "split", label: "Split (env/server.ts, env/client.ts)" },
-      { value: "joined", label: "Joined (env.ts)" }
-    ]
-  });
-  config.envSplit = split;
-  const location = await text2({
-    message: "Where should the environment files be created?",
-    initialValue: "src/lib",
-    placeholder: "src/lib"
-  });
-  config.envLocation = location;
+  const split = await withCancelHandling(
+    async () => select4({
+      message: "Split or Joined env files?",
+      options: ENV_SPLIT_OPTIONS
+    })
+  );
+  const location = await withCancelHandling(
+    async () => text2({
+      message: "Where should the environment files be created?",
+      initialValue: config2.get("env").options.location || "src/lib",
+      placeholder: "src/lib"
+    })
+  );
+  config2.get("env").options = {
+    variant,
+    validator,
+    installPresets,
+    presets: presets || [],
+    split,
+    location
+  };
 }
-async function installEnv(config) {
-  await installPackages([config.envVariant, config.envValidator], true);
-  if (config.envInstallPresets) {
-    const presetPackage = `@t3-oss/env-core/presets-${config.envValidator}`;
-    await installPackages([presetPackage], true);
-  }
-  const targetDir = config.envLocation;
-  await fs5.ensureDir(targetDir);
-  const presetImport = config.envPresets && config.envPresets.length > 0 ? `// Presets: ${config.envPresets.join(", ")}
+async function installEnv(config2) {
+  const envOptions = config2.get("env").options;
+  const { variant, validator, location, presets, split } = envOptions;
+  await installPackages([variant, validator], true);
+  await fs5.ensureDir(location);
+  const presetImport = presets && presets.length > 0 ? `// Presets: ${presets.join(", ")}
 ` : "";
-  const content = `import { createEnv } from "${config.envVariant}";
-import { ${config.envValidator} } from "${config.envValidator}";
+  const content = `import { createEnv } from "${variant}";
+import { ${validator} } from "${validator}";
 
 ${presetImport}`;
-  if (config.envSplit === "split") {
+  if (split === "split") {
     await fs5.outputFile(
-      path.join(targetDir, "env/server.ts"),
+      path2.join(location, "env/server.ts"),
       `${content}
 // Server env definition
 export const env = createEnv({
@@ -352,7 +481,7 @@ export const env = createEnv({
 });`
     );
     await fs5.outputFile(
-      path.join(targetDir, "env/client.ts"),
+      path2.join(location, "env/client.ts"),
       `${content}
 // Client env definition
 export const env = createEnv({
@@ -366,7 +495,7 @@ export const env = createEnv({
     );
   } else {
     await fs5.outputFile(
-      path.join(targetDir, "env.ts"),
+      path2.join(location, "env.ts"),
       `${content}
 // Joined env definition
 export const env = createEnv({
@@ -386,7 +515,385 @@ export const env = createEnv({
 var init_env = __esm({
   "src/services/env.ts"() {
     "use strict";
+    init_esm_shims();
+    init_pm();
+    init_options();
+    init_handle_cancel();
+  }
+});
+
+// src/services/test.ts
+import { select as select5, log as log6 } from "@clack/prompts";
+import fs6 from "fs-extra";
+import pc6 from "picocolors";
+async function promptTest(config2) {
+  log6.message(pc6.bgRed(pc6.black(" Test Runner Configuration ")));
+  const runner = await withCancelHandling(
+    async () => select5({
+      message: "Select a test runner:",
+      options: TEST_RUNNER_OPTIONS
+    })
+  );
+  config2.get("test").options = { runner };
+}
+async function installTest(config2) {
+  const runner = config2.get("test").options.runner;
+  if (runner === "vitest") {
+    await installPackages(["vitest"], true);
+    const configFile = "vitest.config.ts";
+    if (!await fs6.pathExists(configFile)) {
+      await fs6.outputFile(
+        configFile,
+        `import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+  },
+});
+`
+      );
+    }
+  } else if (runner === "jest") {
+    await installPackages(["jest", "ts-jest", "@types/jest"], true);
+    const configFile = "jest.config.js";
+    if (!await fs6.pathExists(configFile)) {
+      await fs6.outputFile(
+        configFile,
+        `/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+};
+`
+      );
+    }
+  }
+}
+var init_test = __esm({
+  "src/services/test.ts"() {
+    "use strict";
+    init_esm_shims();
     init_pm();
+    init_options();
+    init_handle_cancel();
+  }
+});
+
+// src/services/editor-config.ts
+import { select as select6, log as log7 } from "@clack/prompts";
+import fs7 from "fs-extra";
+import pc7 from "picocolors";
+async function promptEditorConfig(config2) {
+  log7.message(pc7.bgWhite(pc7.black(" EditorConfig Configuration ")));
+  const currentPreset = config2.get("editorConfig").options.preset;
+  const preset = await withCancelHandling(
+    async () => select6({
+      message: "Select EditorConfig preset:",
+      options: EDITOR_CONFIG_OPTIONS,
+      initialValue: currentPreset
+    })
+  );
+  config2.get("editorConfig").options = { preset };
+}
+async function installEditorConfig(config2) {
+  let content = "root = true\n\n[*]\ncharset = utf-8\nend_of_line = lf\ninsert_final_newline = true\ntrim_trailing_whitespace = true\n";
+  const preset = config2.get("editorConfig").options.preset;
+  if (preset === "default") {
+    content += "indent_style = space\nindent_size = 2\n";
+  } else if (preset === "spaces4") {
+    content += "indent_style = space\nindent_size = 4\n";
+  } else if (preset === "tabs") {
+    content += "indent_style = tab\n";
+  }
+  await fs7.outputFile(".editorconfig", content);
+}
+var init_editor_config = __esm({
+  "src/services/editor-config.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_options();
+    init_handle_cancel();
+  }
+});
+
+// src/services/license.ts
+import { text as text3, select as select7, log as log8 } from "@clack/prompts";
+import fs8 from "fs-extra";
+import path3 from "path";
+import pc8 from "picocolors";
+async function promptLicense(config2) {
+  log8.message(pc8.bgGreen(pc8.black(" License Configuration ")));
+  const licenseOptions = config2.get("license").options;
+  licenseOptions.name = await withCancelHandling(
+    async () => text3({
+      message: "License Holder Name:",
+      placeholder: "John Doe",
+      initialValue: licenseOptions.name
+    })
+  );
+  licenseOptions.email = await withCancelHandling(
+    async () => text3({
+      message: "License Holder Email:",
+      placeholder: "john@example.com",
+      initialValue: licenseOptions.email
+    })
+  );
+  licenseOptions.website = await withCancelHandling(
+    async () => text3({
+      message: "License Holder Website:",
+      placeholder: "https://example.com",
+      initialValue: licenseOptions.website
+    })
+  );
+  licenseOptions.type = await withCancelHandling(
+    async () => select7({
+      message: "Select License Type:",
+      options: LICENSE_TYPE_OPTIONS
+    })
+  );
+}
+async function installLicense(config2) {
+  const licenseOptions = config2.get("license").options;
+  const { type, name, email, website } = licenseOptions;
+  if (type !== "UNLICENSED") {
+    const year = (/* @__PURE__ */ new Date()).getFullYear().toString();
+    const templatePath = path3.join(__dirname, "licenses", `${type}.txt`);
+    if (await fs8.pathExists(templatePath)) {
+      let licenseContent = await fs8.readFile(templatePath, "utf-8");
+      licenseContent = licenseContent.replace(/{YEAR}/g, year);
+      licenseContent = licenseContent.replace(/{HOLDER}/g, name || "");
+      licenseContent = licenseContent.replace(/{EMAIL}/g, email || "");
+      licenseContent = licenseContent.replace(/{WEBSITE}/g, website || "");
+      await fs8.outputFile("LICENSE", licenseContent);
+    } else {
+      const simpleContent = `Copyright (c) ${year} ${name}
+Licensed under ${type}`;
+      await fs8.outputFile("LICENSE", simpleContent);
+    }
+  }
+  if (await fs8.pathExists("package.json")) {
+    const pkg = await fs8.readJson("package.json");
+    pkg.license = type;
+    if (name) {
+      pkg.author = { name, email, url: website };
+    }
+    await fs8.writeJson("package.json", pkg, { spaces: 2 });
+  }
+}
+var init_license = __esm({
+  "src/services/license.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_options();
+    init_handle_cancel();
+  }
+});
+
+// src/config/config.ts
+import pc9 from "picocolors";
+var Config, config;
+var init_config = __esm({
+  "src/config/config.ts"() {
+    "use strict";
+    init_esm_shims();
+    Config = class {
+      data;
+      constructor() {
+        this.data = {
+          husky: {
+            selected: false,
+            options: { hookType: "none", customScript: "npm run test" }
+          },
+          formatter: {
+            selected: false,
+            options: { choice: "prettier" }
+          },
+          linter: {
+            selected: false,
+            options: { choice: "eslint" }
+          },
+          lintStaged: {
+            selected: false,
+            options: { lintExtensions: [], formatExtensions: [] }
+          },
+          env: {
+            selected: false,
+            options: {
+              variant: "@t3-oss/env-nextjs",
+              validator: "zod",
+              installPresets: false,
+              presets: [],
+              split: "split",
+              location: "src/env"
+            }
+          },
+          test: {
+            selected: false,
+            options: { runner: "vitest" }
+          },
+          editorConfig: {
+            selected: false,
+            options: { preset: "default" }
+          },
+          license: {
+            selected: false,
+            options: { name: "", email: "", website: "", type: "MIT" }
+          }
+        };
+      }
+      get(tool) {
+        return this.data[tool];
+      }
+      enableTool(tool) {
+        this.data[tool].selected = true;
+      }
+      get summary() {
+        const lines = [];
+        lines.push(pc9.bold("The following actions will be performed:"));
+        lines.push("");
+        if (this.data.husky.selected) {
+          lines.push(pc9.magenta(`\u2022 Install and configure Husky`));
+          if (this.data.husky.options.hookType === "custom") {
+            lines.push(pc9.dim(`  - Custom hook script`));
+          }
+        }
+        if (this.data.formatter.selected) {
+          const choice = this.data.formatter.options.choice;
+          lines.push(pc9.blue(`\u2022 Install and configure ${choice || "Formatter"}`));
+        }
+        if (this.data.linter.selected) {
+          const choice = this.data.linter.options.choice;
+          lines.push(pc9.yellow(`\u2022 Install and configure ${choice || "Linter"}`));
+        }
+        if (this.data.lintStaged.selected) {
+          lines.push(pc9.green(`\u2022 Install and configure Lint-staged`));
+          const lintExts = this.data.lintStaged.options.lintExtensions.join(", ");
+          const formatExts = this.data.lintStaged.options.formatExtensions.join(", ");
+          if (lintExts) lines.push(pc9.dim(`  - Lint: ${lintExts}`));
+          if (formatExts) lines.push(pc9.dim(`  - Format: ${formatExts}`));
+        }
+        if (this.data.env.selected) {
+          lines.push(pc9.cyan(`\u2022 Install and configure Env Validation`));
+          lines.push(pc9.dim(`  - Variant: ${this.data.env.options.variant}`));
+          lines.push(pc9.dim(`  - Validator: ${this.data.env.options.validator}`));
+        }
+        if (this.data.test.selected) {
+          const runner = this.data.test.options.runner;
+          lines.push(pc9.red(`\u2022 Install and configure Test Runner (${runner})`));
+        }
+        if (this.data.editorConfig.selected) {
+          const preset = this.data.editorConfig.options.preset;
+          lines.push(pc9.white(`\u2022 Create .editorconfig (${preset})`));
+        }
+        if (this.data.license.selected) {
+          const type = this.data.license.options.type;
+          const name = this.data.license.options.name;
+          lines.push(pc9.green(`\u2022 Create LICENSE (${type})`));
+          lines.push(pc9.dim(`  - Holder: ${name}`));
+        }
+        return lines.join("\n");
+      }
+    };
+    config = new Config();
+  }
+});
+
+// src/steps/execution.ts
+import { spinner } from "@clack/prompts";
+async function execution(config2) {
+  const s = spinner();
+  if (config2.get("husky").selected) {
+    s.start("Setting up Husky...");
+    await installHusky(config2);
+    s.stop("Husky setup complete.");
+  }
+  if (config2.get("formatter").selected) {
+    const choice = config2.get("formatter").options.choice;
+    s.start(`Setting up ${choice}...`);
+    await installFormatter(config2);
+    s.stop(`${choice} setup complete.`);
+  }
+  if (config2.get("linter").selected) {
+    const choice = config2.get("linter").options.choice;
+    s.start(`Setting up ${choice}...`);
+    await installLinter(config2);
+    s.stop(`${choice} setup complete.`);
+  }
+  if (config2.get("lintStaged").selected) {
+    s.start("Setting up Lint-staged...");
+    await installLintStaged(config2);
+    s.stop("Lint-staged setup complete.");
+  }
+  if (config2.get("env").selected) {
+    s.start("Setting up Env Validation...");
+    await installEnv(config2);
+    s.stop("Env Validation setup complete.");
+  }
+  if (config2.get("test").selected) {
+    const runner = config2.get("test").options.runner;
+    s.start(`Setting up ${runner}...`);
+    await installTest(config2);
+    s.stop(`${runner} setup complete.`);
+  }
+  if (config2.get("editorConfig").selected) {
+    s.start("Creating .editorconfig...");
+    await installEditorConfig(config2);
+    s.stop(".editorconfig created.");
+  }
+  if (config2.get("license").selected) {
+    s.start("Creating LICENSE...");
+    await installLicense(config2);
+    s.stop("LICENSE created.");
+  }
+}
+var init_execution = __esm({
+  "src/steps/execution.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_husky();
+    init_formatter();
+    init_linter();
+    init_lint_staged();
+    init_env();
+    init_test();
+    init_editor_config();
+    init_license();
+  }
+});
+
+// src/utils/logger.ts
+import fs9 from "fs-extra";
+import path4 from "path";
+async function logError(error) {
+  try {
+    await fs9.ensureDir(ERRORS_DIR);
+    const gitignorePath = path4.join(LOG_DIR, ".gitignore");
+    if (!await fs9.pathExists(gitignorePath)) {
+      await fs9.outputFile(gitignorePath, "*\n");
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const logFile = path4.join(ERRORS_DIR, `log-${timestamp}.txt`);
+    const errorMessage = error instanceof Error ? error.stack || error.message : String(error);
+    const logContent = `Timestamp: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+Error:
+${errorMessage}
+`;
+    await fs9.outputFile(logFile, logContent);
+    return logFile;
+  } catch (e) {
+    console.error("Failed to log error:", e);
+    return "";
+  }
+}
+var LOG_DIR, ERRORS_DIR;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    "use strict";
+    init_esm_shims();
+    LOG_DIR = ".mayrlabs/setup-project";
+    ERRORS_DIR = path4.join(LOG_DIR, "errors");
   }
 });
 
@@ -415,6 +922,41 @@ async function commitChanges(message) {
 var init_git = __esm({
   "src/utils/git.ts"() {
     "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/steps/git-check.ts
+import { confirm as confirm3, spinner as spinner2, text as text4 } from "@clack/prompts";
+async function gitCheck() {
+  if (await isGitRepository()) {
+    if (await isGitDirty()) {
+      const shouldCommit = await confirm3({
+        message: "Your working directory is dirty. Would you like to commit changes before proceeding?"
+      });
+      if (shouldCommit) {
+        const message = text4({
+          message: "Enter commit message:",
+          placeholder: "wip: pre-setup commit",
+          validate(value) {
+            if (value.length === 0) return "Commit message is required";
+          }
+        });
+        if (typeof message === "string") {
+          const s = spinner2();
+          s.start("Committing changes...");
+          await commitChanges(message);
+          s.stop("Changes committed.");
+        }
+      }
+    }
+  }
+}
+var init_git_check = __esm({
+  "src/steps/git-check.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_git();
   }
 });
 
@@ -424,7 +966,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@mayrlabs/setup-project",
-      version: "0.1.3",
+      version: "0.1.5",
       description: "Interactive CLI to setup project tools",
       private: false,
       publishConfig: {
@@ -457,7 +999,11 @@ var init_package = __esm({
         directory: "packages/setup-project"
       },
       license: "MIT",
-      author: "Aghogho Meyoron <youngmayor.dev@gmail.com>",
+      author: {
+        name: "Aghogho Meyoron",
+        email: "youngmayor.dev@gmail.com",
+        url: "https://mayrlabs.com"
+      },
       type: "commonjs",
       main: "dist/index.js",
       scripts: {
@@ -469,143 +1015,188 @@ var init_package = __esm({
         "@clack/prompts": "^0.7.0",
         commander: "^11.1.0",
         execa: "^8.0.1",
+        figlet: "^1.10.0",
         "fs-extra": "^11.2.0",
         picocolors: "^1.0.0",
         zod: "^3.22.4"
       },
       devDependencies: {
+        "@types/figlet": "^1.7.0",
         "@types/fs-extra": "^11.0.4",
         "@types/node": "^20.11.16",
         tsup: "^8.5.1",
+        tsx: "^4.21.0",
         typescript: "^5.3.3"
       }
     };
   }
 });
 
+// src/utils/display.ts
+import pc10 from "picocolors";
+import figlet from "figlet";
+function introScreen() {
+  console.log();
+  console.log(
+    pc10.cyan(
+      figlet.textSync("MayR\nLabs", {
+        font: "Graceful",
+        horizontalLayout: "default",
+        verticalLayout: "default",
+        width: 80,
+        whitespaceBreak: true
+      })
+    )
+  );
+  console.log(pc10.cyan(`@mayrlabs/setup-project v${package_default.version}`));
+  console.log();
+}
+function showAbout() {
+  introScreen();
+  console.log(pc10.bold("About:"));
+  console.log(
+    "  Interactive CLI to setup project tools like Husky, Prettier, ESLint, etc."
+  );
+  console.log("");
+  console.log(pc10.bold("How to use:"));
+  console.log(
+    "  Run 'npx @mayrlabs/setup-project' and follow the interactive prompts."
+  );
+  console.log("");
+}
+function showVisit() {
+  console.log(pc10.bold("Project Homepage:"));
+  console.log(pc10.underline(pc10.cyan(package_default.homepage)));
+  console.log("");
+}
+function showManual() {
+  introScreen();
+  console.log(pc10.bold("Usage:"));
+  console.log("  npx @mayrlabs/setup-project [command] [options]");
+  console.log("");
+  console.log(pc10.bold("Commands:"));
+  console.log("  about              Show project details");
+  console.log("  version            Show version information");
+  console.log("  visit              Visit project homepage");
+  console.log("  help               Show this help message");
+  console.log("");
+  console.log(pc10.bold("Options:"));
+  console.log("  -a, --about        Show project details");
+  console.log("  -v, --version      Show version information");
+  console.log("  -V, --visit        Visit project homepage");
+  console.log("  -h, --help         Show this help message");
+  console.log("");
+}
+var init_display = __esm({
+  "src/utils/display.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_package();
+  }
+});
+
 // src/index.ts
-import {
-  intro,
-  outro,
-  multiselect as multiselect3,
-  isCancel,
-  cancel,
-  note,
-  confirm as confirm2,
-  spinner
-} from "@clack/prompts";
-import pc from "picocolors";
+import { outro, multiselect as multiselect3, note, confirm as confirm4, intro } from "@clack/prompts";
+import pc11 from "picocolors";
 import { program } from "commander";
 var require_index = __commonJS({
   "src/index.ts"() {
+    init_esm_shims();
     init_husky();
     init_formatter();
     init_linter();
     init_lint_staged();
     init_env();
-    init_git();
-    init_package();
+    init_test();
+    init_editor_config();
+    init_license();
+    init_config();
+    init_handle_cancel();
+    init_options();
+    init_execution();
+    init_logger();
+    init_git_check();
+    init_display();
     async function main() {
-      intro(pc.bgCyan(pc.black(" @mayrlabs/setup-project ")));
-      if (await isGitRepository()) {
-        if (await isGitDirty()) {
-          const shouldCommit = await confirm2({
-            message: "Your working directory is dirty. Would you like to commit changes before proceeding?"
-          });
-          if (shouldCommit) {
-            const message = await import("@clack/prompts").then(
-              (m) => m.text({
-                message: "Enter commit message:",
-                placeholder: "wip: pre-setup commit",
-                validate(value) {
-                  if (value.length === 0) return "Commit message is required";
-                }
-              })
-            );
-            if (typeof message === "string") {
-              const s2 = spinner();
-              s2.start("Committing changes...");
-              await commitChanges(message);
-              s2.stop("Changes committed.");
-            }
-          }
+      try {
+        introScreen();
+        intro(
+          pc11.inverse(pc11.bold(pc11.cyan(" Welcome to the Project Setup Wizard ")))
+        );
+        await gitCheck();
+        const tools = await withCancelHandling(
+          async () => multiselect3({
+            message: "Select tools to configure:",
+            options: TOOL_OPTIONS,
+            required: false
+          })
+        );
+        tools.forEach((tool) => config.enableTool(tool));
+        if (config.get("husky").selected) await promptHusky(config);
+        if (config.get("formatter").selected) await promptFormatter(config);
+        if (config.get("linter").selected) await promptLinter(config);
+        if (config.get("lintStaged").selected) await promptLintStaged(config);
+        if (config.get("env").selected) await promptEnv(config);
+        if (config.get("test").selected) await promptTest(config);
+        if (config.get("editorConfig").selected) await promptEditorConfig(config);
+        if (config.get("license").selected) await promptLicense(config);
+        note(config.summary, "Configuration Summary");
+        const proceed = await withCancelHandling(
+          async () => confirm4({
+            message: "Do you want to proceed with the installation?"
+          })
+        );
+        if (!proceed) {
+          outro(pc11.yellow("Installation cancelled."));
+          process.exit(0);
         }
+        await execution(config);
+        outro(pc11.green("Setup complete!"));
+      } catch (error) {
+        const logPath = await logError(error);
+        outro(pc11.red(`
+Something went wrong!
+Error log saved to: ${logPath}`));
+        process.exit(1);
       }
-      const tools = await multiselect3({
-        message: "Select tools to configure:",
-        options: [
-          { value: "husky", label: "Husky" },
-          { value: "formatter", label: "Formatter (Prettier/Oxfmt)" },
-          { value: "linter", label: "Linter (Eslint/Oxlint)" },
-          { value: "lint-staged", label: "Lint-staged" },
-          { value: "env", label: "Env Validation (@t3-oss/env)" }
-        ],
-        required: false
-      });
-      if (isCancel(tools)) {
-        cancel("Operation cancelled.");
+    }
+    program.helpOption(false);
+    program.name("setup-project").description("Interactive setup for common project tools").option("-a, --about", "Show project details").option("-v, --version", "Show version info").option("-V, --visit", "Visit project homepage").option("-h, --help", "Show help");
+    program.command("about").action(() => {
+      showAbout();
+      process.exit(0);
+    });
+    program.command("version").action(() => {
+      introScreen();
+      process.exit(0);
+    });
+    program.command("visit").action(() => {
+      showVisit();
+      process.exit(0);
+    });
+    program.command("help").action(() => {
+      showManual();
+      process.exit(0);
+    });
+    program.action(async (options) => {
+      if (options.about) {
+        showAbout();
         process.exit(0);
       }
-      const selectedTools = tools;
-      const config = {
-        husky: selectedTools.includes("husky"),
-        formatter: selectedTools.includes("formatter"),
-        linter: selectedTools.includes("linter"),
-        lintStaged: selectedTools.includes("lint-staged"),
-        env: selectedTools.includes("env")
-      };
-      if (config.husky) await promptHusky(config);
-      if (config.formatter) await promptFormatter(config);
-      if (config.linter) await promptLinter(config);
-      if (config.lintStaged) await promptLintStaged(config);
-      if (config.env) await promptEnv(config);
-      let summary = "The following actions will be performed:\n\n";
-      if (config.husky) summary += "- Install and configure Husky\n";
-      if (config.formatter)
-        summary += `- Install and configure ${config.formatterChoice}
-`;
-      if (config.linter)
-        summary += `- Install and configure ${config.linterChoice}
-`;
-      if (config.lintStaged) summary += "- Install and configure Lint-staged\n";
-      if (config.env) summary += "- Install and configure @t3-oss/env\n";
-      note(summary, "Configuration Summary");
-      const proceed = await confirm2({
-        message: "Do you want to proceed with the installation?"
-      });
-      if (!proceed || isCancel(proceed)) {
-        cancel("Installation cancelled. Configuration saved.");
+      if (options.version) {
+        introScreen();
         process.exit(0);
       }
-      const s = spinner();
-      if (config.husky) {
-        s.start("Setting up Husky...");
-        await installHusky(config);
-        s.stop("Husky setup complete.");
-      }
-      if (config.formatter) {
-        s.start(`Setting up ${config.formatterChoice}...`);
-        await installFormatter(config);
-        s.stop(`${config.formatterChoice} setup complete.`);
-      }
-      if (config.linter) {
-        s.start(`Setting up ${config.linterChoice}...`);
-        await installLinter(config);
-        s.stop(`${config.linterChoice} setup complete.`);
-      }
-      if (config.lintStaged) {
-        s.start("Setting up Lint-staged...");
-        await installLintStaged(config);
-        s.stop("Lint-staged setup complete.");
+      if (options.visit) {
+        showVisit();
+        process.exit(0);
       }
-      if (config.env) {
-        s.start("Setting up Env Validation...");
-        await installEnv(config);
-        s.stop("Env Validation setup complete.");
+      if (options.help) {
+        showManual();
+        process.exit(0);
       }
-      outro(pc.green("Setup complete!"));
-    }
-    program.name("setup-project").description("Interactive setup for common project tools").version(package_default.version).action(main);
+      await main();
+    });
     program.parse();
   }
 });
@@ -616,4 +1207,3 @@ export default require_index();
  * Software should feel intentional.
  */
 
-//# sourceMappingURL=index.mjs.map