@mayrlabs/setup-project 0.1.4 → 0.1.6

package/dist/index.js

@@ -33,12 +33,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/index.ts
-var import_prompts9 = require("@clack/prompts");
-var import_picocolors = __toESM(require("picocolors"));
+var import_prompts12 = require("@clack/prompts");
+var import_picocolors11 = __toESM(require("picocolors"));
 var import_commander = require("commander");
 
 // src/services/husky.ts
-var import_prompts = require("@clack/prompts");
+var import_prompts2 = require("@clack/prompts");
 
 // src/utils/pm.ts
 var import_execa = require("execa");
@@ -73,30 +73,137 @@ async function installPackages(packages, dev = false) {
 // src/services/husky.ts
 var import_execa2 = require("execa");
 var import_fs_extra = __toESM(require("fs-extra"));
-async function promptHusky(config) {
-  const hookType = await (0, import_prompts.select)({
-    message: "What pre-commit hook would you like to use?",
-    options: [
-      { value: "lint-staged", label: "lint-staged" },
-      { value: "custom", label: "Custom script" },
-      { value: "none", label: "None" }
-    ]
-  });
-  config.huskyHookType = hookType;
+var import_picocolors = __toESM(require("picocolors"));
+
+// src/constants/options.ts
+var 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" }
+];
+var HUSKY_HOOK_OPTIONS = [
+  { value: "lint-staged", label: "lint-staged" },
+  { value: "custom", label: "Custom script" },
+  { value: "none", label: "None" }
+];
+var FORMATTER_OPTIONS = [
+  { value: "prettier", label: "Prettier" },
+  { value: "oxfmt", label: "Oxfmt" }
+];
+var LINTER_OPTIONS = [
+  { value: "eslint", label: "ESLint" },
+  { value: "oxlint", label: "Oxlint" }
+];
+var 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" }
+];
+var 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" }
+];
+var ENV_VALIDATOR_OPTIONS = [
+  { value: "zod", label: "Zod" },
+  { value: "valibot", label: "Valibot" },
+  { value: "arktype", label: "Arktype" }
+];
+var 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" }
+];
+var ENV_SPLIT_OPTIONS = [
+  { value: "split", label: "Split (env/server.ts, env/client.ts)" },
+  { value: "joined", label: "Joined (env.ts)" }
+];
+var TEST_RUNNER_OPTIONS = [
+  { value: "vitest", label: "Vitest" },
+  { value: "jest", label: "Jest" }
+];
+var EDITOR_CONFIG_OPTIONS = [
+  { value: "default", label: "Default (Spaces 2)" },
+  { value: "spaces4", label: "Spaces 4" },
+  { value: "tabs", label: "Tabs" }
+];
+var 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
+var import_prompts = require("@clack/prompts");
+async function withCancelHandling(promptFn, cancelMessage = "Operation cancelled.") {
+  while (true) {
+    const response = await promptFn();
+    if ((0, import_prompts.isCancel)(response)) {
+      const shouldCancel = await (0, import_prompts.confirm)({
+        message: "Do you really want to cancel options selection?"
+      });
+      if ((0, import_prompts.isCancel)(shouldCancel) || shouldCancel) {
+        (0, import_prompts.cancel)(cancelMessage);
+        process.exit(0);
+      }
+      continue;
+    } else {
+      return response;
+    }
+  }
+}
+
+// src/services/husky.ts
+async function promptHusky(config2) {
+  import_prompts2.log.message(import_picocolors.default.bgMagenta(import_picocolors.default.black(" Husky Configuration ")));
+  const hookType = await withCancelHandling(
+    async () => (0, import_prompts2.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 (0, import_prompts.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 () => (0, import_prompts2.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 (0, import_execa2.execa)("npx", ["husky", "init"]);
@@ -104,12 +211,15 @@ async function installHusky(config) {
     await (0, import_execa2.execa)("npm", ["pkg", "set", "scripts.prepare=husky"]);
     await (0, import_execa2.execa)("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 import_fs_extra.default.outputFile(".husky/pre-commit", "npx lint-staged\n", {
       mode: 493
     });
-  } else if (config.huskyHookType === "custom" && config.huskyCustomScript) {
-    await import_fs_extra.default.outputFile(".husky/pre-commit", `${config.huskyCustomScript}
+  } else if (hookType === "custom" && customScript) {
+    await import_fs_extra.default.outputFile(".husky/pre-commit", `${customScript}
 `, {
       mode: 493
     });
@@ -117,22 +227,24 @@ async function installHusky(config) {
 }
 
 // src/services/formatter.ts
-var import_prompts2 = require("@clack/prompts");
+var import_prompts3 = require("@clack/prompts");
 var import_fs_extra2 = __toESM(require("fs-extra"));
-async function promptFormatter(config) {
-  if (!config.formatterChoice) {
-    const formatter = await (0, import_prompts2.select)({
+var import_picocolors2 = __toESM(require("picocolors"));
+async function promptFormatter(config2) {
+  const formatterConfig = config2.get("formatter");
+  import_prompts3.log.message(import_picocolors2.default.bgBlue(import_picocolors2.default.black(" Formatter Configuration ")));
+  const formatter = await withCancelHandling(
+    async () => (0, import_prompts3.select)({
       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,
@@ -142,28 +254,30 @@ async function installFormatter(config) {
       tabWidth: 2
     };
     await import_fs_extra2.default.writeJson(".prettierrc", configContent, { spaces: 2 });
-  } else if (config.formatterChoice === "oxfmt") {
+  } else if (choice === "oxfmt") {
     await installPackages(["oxfmt"], true);
   }
 }
 
 // src/services/linter.ts
-var import_prompts3 = require("@clack/prompts");
+var import_prompts4 = require("@clack/prompts");
 var import_fs_extra3 = __toESM(require("fs-extra"));
-async function promptLinter(config) {
-  if (!config.linterChoice) {
-    const linter = await (0, import_prompts3.select)({
+var import_picocolors3 = __toESM(require("picocolors"));
+async function promptLinter(config2) {
+  const linterConfig = config2.get("linter");
+  import_prompts4.log.message(import_picocolors3.default.bgYellow(import_picocolors3.default.black(" Linter Configuration ")));
+  const linter = await withCancelHandling(
+    async () => (0, import_prompts4.select)({
       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"],
@@ -177,75 +291,63 @@ async function installLinter(config) {
       }
     };
     await import_fs_extra3.default.writeJson(".eslintrc.json", configContent, { spaces: 2 });
-  } else if (config.linterChoice === "oxlint") {
+  } else if (choice === "oxlint") {
     await installPackages(["oxlint"], true);
   }
 }
 
 // src/services/lint-staged.ts
-var import_prompts4 = require("@clack/prompts");
+var import_prompts5 = require("@clack/prompts");
 var import_fs_extra4 = __toESM(require("fs-extra"));
-async function promptLintStaged(config) {
-  const lintExtensions = await (0, import_prompts4.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 (0, import_prompts4.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;
+var import_picocolors4 = __toESM(require("picocolors"));
+async function promptLintStaged(config2) {
+  import_prompts5.log.message(import_picocolors4.default.bgGreen(import_picocolors4.default.black(" Lint-staged Configuration ")));
+  const lintExtensions = await withCancelHandling(
+    async () => (0, import_prompts5.multiselect)({
+      message: "Select extensions to lint:",
+      options: LINT_STAGED_EXTENSIONS,
+      required: false
+    })
+  );
+  const formatExtensions = await withCancelHandling(
+    async () => (0, import_prompts5.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"];
@@ -255,85 +357,75 @@ async function installLintStaged(config) {
 }
 
 // src/services/env.ts
-var import_prompts5 = require("@clack/prompts");
+var import_prompts6 = require("@clack/prompts");
 var import_fs_extra5 = __toESM(require("fs-extra"));
 var import_path = __toESM(require("path"));
-async function promptEnv(config) {
-  const variant = await (0, import_prompts5.select)({
-    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 (0, import_prompts5.select)({
-    message: "Which validator?",
-    options: [
-      { value: "zod", label: "Zod" },
-      { value: "valibot", label: "Valibot" },
-      { value: "arktype", label: "Arktype" }
-    ]
-  });
-  config.envValidator = validator;
-  const installPresets = await (0, import_prompts5.confirm)({
-    message: "Install presets?"
-  });
-  config.envInstallPresets = installPresets;
+var import_picocolors5 = __toESM(require("picocolors"));
+async function promptEnv(config2) {
+  import_prompts6.log.message(import_picocolors5.default.bgCyan(import_picocolors5.default.black(" Env Validation Configuration ")));
+  const variant = await withCancelHandling(
+    async () => (0, import_prompts6.select)({
+      message: "Which @t3-oss/env variant?",
+      options: ENV_VARIANT_OPTIONS
+    })
+  );
+  const validator = await withCancelHandling(
+    async () => (0, import_prompts6.select)({
+      message: "Which validator?",
+      options: ENV_VALIDATOR_OPTIONS
+    })
+  );
+  const installPresets = await withCancelHandling(
+    async () => (0, import_prompts6.confirm)({
+      message: "Install presets?"
+    })
+  );
+  let presets;
   if (installPresets) {
-    const presets = await (0, import_prompts5.multiselect)({
-      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;
-  }
-  const split = await (0, import_prompts5.select)({
-    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 (0, import_prompts5.text)({
-    message: "Where should the environment files be created?",
-    initialValue: "src/lib",
-    placeholder: "src/lib"
-  });
-  config.envLocation = location;
+    presets = await withCancelHandling(
+      async () => (0, import_prompts6.multiselect)({
+        message: "Select preset to extend:",
+        options: ENV_PRESET_OPTIONS,
+        required: false
+      })
+    );
+  }
+  const split = await withCancelHandling(
+    async () => (0, import_prompts6.select)({
+      message: "Split or Joined env files?",
+      options: ENV_SPLIT_OPTIONS
+    })
+  );
+  const location = await withCancelHandling(
+    async () => (0, import_prompts6.text)({
+      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 import_fs_extra5.default.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 import_fs_extra5.default.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 import_fs_extra5.default.outputFile(
-      import_path.default.join(targetDir, "env/server.ts"),
+      import_path.default.join(location, "env/server.ts"),
       `${content}
 // Server env definition
 export const env = createEnv({
@@ -344,7 +436,7 @@ export const env = createEnv({
 });`
     );
     await import_fs_extra5.default.outputFile(
-      import_path.default.join(targetDir, "env/client.ts"),
+      import_path.default.join(location, "env/client.ts"),
       `${content}
 // Client env definition
 export const env = createEnv({
@@ -358,7 +450,7 @@ export const env = createEnv({
     );
   } else {
     await import_fs_extra5.default.outputFile(
-      import_path.default.join(targetDir, "env.ts"),
+      import_path.default.join(location, "env.ts"),
       `${content}
 // Joined env definition
 export const env = createEnv({
@@ -377,20 +469,22 @@ export const env = createEnv({
 }
 
 // src/services/test.ts
-var import_prompts6 = require("@clack/prompts");
+var import_prompts7 = require("@clack/prompts");
 var import_fs_extra6 = __toESM(require("fs-extra"));
-async function promptTest(config) {
-  const runner = await (0, import_prompts6.select)({
-    message: "Select a test runner:",
-    options: [
-      { value: "vitest", label: "Vitest" },
-      { value: "jest", label: "Jest" }
-    ]
-  });
-  config.testRunner = runner;
+var import_picocolors6 = __toESM(require("picocolors"));
+async function promptTest(config2) {
+  import_prompts7.log.message(import_picocolors6.default.bgRed(import_picocolors6.default.black(" Test Runner Configuration ")));
+  const runner = await withCancelHandling(
+    async () => (0, import_prompts7.select)({
+      message: "Select a test runner:",
+      options: TEST_RUNNER_OPTIONS
+    })
+  );
+  config2.get("test").options = { runner };
 }
-async function installTest(config) {
-  if (config.testRunner === "vitest") {
+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 import_fs_extra6.default.pathExists(configFile)) {
@@ -406,7 +500,7 @@ export default defineConfig({
 `
       );
     }
-  } else if (config.testRunner === "jest") {
+  } else if (runner === "jest") {
     await installPackages(["jest", "ts-jest", "@types/jest"], true);
     const configFile = "jest.config.js";
     if (!await import_fs_extra6.default.pathExists(configFile)) {
@@ -424,97 +518,278 @@ module.exports = {
 }
 
 // src/services/editor-config.ts
-var import_prompts7 = require("@clack/prompts");
+var import_prompts8 = require("@clack/prompts");
 var import_fs_extra7 = __toESM(require("fs-extra"));
-async function promptEditorConfig(config) {
-  const preset = await (0, import_prompts7.select)({
-    message: "Select EditorConfig preset:",
-    options: [
-      { value: "default", label: "Default (Spaces 2)" },
-      { value: "spaces4", label: "Spaces 4" },
-      { value: "tabs", label: "Tabs" }
-    ]
-  });
-  config.editorConfigPreset = preset;
+var import_picocolors7 = __toESM(require("picocolors"));
+async function promptEditorConfig(config2) {
+  import_prompts8.log.message(import_picocolors7.default.bgWhite(import_picocolors7.default.black(" EditorConfig Configuration ")));
+  const currentPreset = config2.get("editorConfig").options.preset;
+  const preset = await withCancelHandling(
+    async () => (0, import_prompts8.select)({
+      message: "Select EditorConfig preset:",
+      options: EDITOR_CONFIG_OPTIONS,
+      initialValue: currentPreset
+    })
+  );
+  config2.get("editorConfig").options = { preset };
 }
-async function installEditorConfig(config) {
+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";
-  if (config.editorConfigPreset === "default" || config.editorConfigPreset === "spaces2") {
+  const preset = config2.get("editorConfig").options.preset;
+  if (preset === "default") {
     content += "indent_style = space\nindent_size = 2\n";
-  } else if (config.editorConfigPreset === "spaces4") {
+  } else if (preset === "spaces4") {
     content += "indent_style = space\nindent_size = 4\n";
-  } else if (config.editorConfigPreset === "tabs") {
+  } else if (preset === "tabs") {
     content += "indent_style = tab\n";
   }
   await import_fs_extra7.default.outputFile(".editorconfig", content);
 }
 
 // src/services/license.ts
-var import_prompts8 = require("@clack/prompts");
+var import_prompts9 = require("@clack/prompts");
 var import_fs_extra8 = __toESM(require("fs-extra"));
 var import_path2 = __toESM(require("path"));
-async function promptLicense(config) {
-  const name = await (0, import_prompts8.text)({
-    message: "License Holder Name:",
-    placeholder: "John Doe",
-    initialValue: config.authorName || ""
-  });
-  config.licenseName = name;
-  const email = await (0, import_prompts8.text)({
-    message: "License Holder Email:",
-    placeholder: "john@example.com"
-  });
-  config.licenseEmail = email;
-  const website = await (0, import_prompts8.text)({
-    message: "License Holder Website:",
-    placeholder: "https://example.com"
-  });
-  config.licenseWebsite = website;
-  const type = await (0, import_prompts8.select)({
-    message: "Select License Type:",
-    options: [
-      { value: "MIT", label: "MIT" },
-      { value: "ISC", label: "ISC" },
-      { value: "Apache-2.0", label: "Apache 2.0" },
-      { value: "UNLICENSED", label: "UNLICENSED" }
-    ]
-  });
-  config.licenseType = type;
+var import_picocolors8 = __toESM(require("picocolors"));
+async function promptLicense(config2) {
+  import_prompts9.log.message(import_picocolors8.default.bgGreen(import_picocolors8.default.black(" License Configuration ")));
+  const licenseOptions = config2.get("license").options;
+  licenseOptions.name = await withCancelHandling(
+    async () => (0, import_prompts9.text)({
+      message: "License Holder Name:",
+      placeholder: "John Doe",
+      initialValue: licenseOptions.name
+    })
+  );
+  licenseOptions.email = await withCancelHandling(
+    async () => (0, import_prompts9.text)({
+      message: "License Holder Email:",
+      placeholder: "john@example.com",
+      initialValue: licenseOptions.email
+    })
+  );
+  licenseOptions.website = await withCancelHandling(
+    async () => (0, import_prompts9.text)({
+      message: "License Holder Website:",
+      placeholder: "https://example.com",
+      initialValue: licenseOptions.website
+    })
+  );
+  licenseOptions.type = await withCancelHandling(
+    async () => (0, import_prompts9.select)({
+      message: "Select License Type:",
+      options: LICENSE_TYPE_OPTIONS
+    })
+  );
 }
-async function installLicense(config) {
-  if (config.licenseType !== "UNLICENSED") {
+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 = import_path2.default.join(
-      __dirname,
-      "licenses",
-      `${config.licenseType}.txt`
-    );
+    const templatePath = import_path2.default.join(__dirname, "licenses", `${type}.txt`);
     if (await import_fs_extra8.default.pathExists(templatePath)) {
       let licenseContent = await import_fs_extra8.default.readFile(templatePath, "utf-8");
       licenseContent = licenseContent.replace(/{YEAR}/g, year);
-      licenseContent = licenseContent.replace(/{HOLDER}/g, config.licenseName);
-      licenseContent = licenseContent.replace(/{EMAIL}/g, config.licenseEmail);
-      licenseContent = licenseContent.replace(
-        /{WEBSITE}/g,
-        config.licenseWebsite
-      );
+      licenseContent = licenseContent.replace(/{HOLDER}/g, name || "");
+      licenseContent = licenseContent.replace(/{EMAIL}/g, email || "");
+      licenseContent = licenseContent.replace(/{WEBSITE}/g, website || "");
       await import_fs_extra8.default.outputFile("LICENSE", licenseContent);
     } else {
-      const simpleContent = `Copyright (c) ${year} ${config.licenseName}
-Licensed under ${config.licenseType}`;
+      const simpleContent = `Copyright (c) ${year} ${name}
+Licensed under ${type}`;
       await import_fs_extra8.default.outputFile("LICENSE", simpleContent);
     }
   }
   if (await import_fs_extra8.default.pathExists("package.json")) {
     const pkg = await import_fs_extra8.default.readJson("package.json");
-    pkg.license = config.licenseType;
-    if (config.licenseName) {
-      pkg.author = `${config.licenseName} <${config.licenseEmail}> (${config.licenseWebsite})`;
+    pkg.license = type;
+    if (name) {
+      pkg.author = { name, email, url: website };
     }
     await import_fs_extra8.default.writeJson("package.json", pkg, { spaces: 2 });
   }
 }
 
+// src/config/config.ts
+var import_picocolors9 = __toESM(require("picocolors"));
+var 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(import_picocolors9.default.bold("The following actions will be performed:"));
+    lines.push("");
+    if (this.data.husky.selected) {
+      lines.push(import_picocolors9.default.magenta(`\u2022 Install and configure Husky`));
+      if (this.data.husky.options.hookType === "custom") {
+        lines.push(import_picocolors9.default.dim(`  - Custom hook script`));
+      }
+    }
+    if (this.data.formatter.selected) {
+      const choice = this.data.formatter.options.choice;
+      lines.push(import_picocolors9.default.blue(`\u2022 Install and configure ${choice || "Formatter"}`));
+    }
+    if (this.data.linter.selected) {
+      const choice = this.data.linter.options.choice;
+      lines.push(import_picocolors9.default.yellow(`\u2022 Install and configure ${choice || "Linter"}`));
+    }
+    if (this.data.lintStaged.selected) {
+      lines.push(import_picocolors9.default.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(import_picocolors9.default.dim(`  - Lint: ${lintExts}`));
+      if (formatExts) lines.push(import_picocolors9.default.dim(`  - Format: ${formatExts}`));
+    }
+    if (this.data.env.selected) {
+      lines.push(import_picocolors9.default.cyan(`\u2022 Install and configure Env Validation`));
+      lines.push(import_picocolors9.default.dim(`  - Variant: ${this.data.env.options.variant}`));
+      lines.push(import_picocolors9.default.dim(`  - Validator: ${this.data.env.options.validator}`));
+    }
+    if (this.data.test.selected) {
+      const runner = this.data.test.options.runner;
+      lines.push(import_picocolors9.default.red(`\u2022 Install and configure Test Runner (${runner})`));
+    }
+    if (this.data.editorConfig.selected) {
+      const preset = this.data.editorConfig.options.preset;
+      lines.push(import_picocolors9.default.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(import_picocolors9.default.green(`\u2022 Create LICENSE (${type})`));
+      lines.push(import_picocolors9.default.dim(`  - Holder: ${name}`));
+    }
+    return lines.join("\n");
+  }
+};
+var config = new Config();
+
+// src/steps/execution.ts
+var import_prompts10 = require("@clack/prompts");
+async function execution(config2) {
+  const s = (0, import_prompts10.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.");
+  }
+}
+
+// src/utils/logger.ts
+var import_fs_extra9 = __toESM(require("fs-extra"));
+var import_path3 = __toESM(require("path"));
+var LOG_DIR = ".mayrlabs/setup-project";
+var ERRORS_DIR = import_path3.default.join(LOG_DIR, "errors");
+async function logError(error) {
+  try {
+    await import_fs_extra9.default.ensureDir(ERRORS_DIR);
+    const gitignorePath = import_path3.default.join(LOG_DIR, ".gitignore");
+    if (!await import_fs_extra9.default.pathExists(gitignorePath)) {
+      await import_fs_extra9.default.outputFile(gitignorePath, "*\n");
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const logFile = import_path3.default.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 import_fs_extra9.default.outputFile(logFile, logContent);
+    return logFile;
+  } catch (e) {
+    console.error("Failed to log error:", e);
+    return "";
+  }
+}
+
 // src/utils/git.ts
 var import_execa3 = require("execa");
 async function isGitRepository() {
@@ -538,10 +813,41 @@ async function commitChanges(message) {
   await (0, import_execa3.execa)("git", ["commit", "-m", message]);
 }
 
+// src/steps/git-check.ts
+var import_prompts11 = require("@clack/prompts");
+async function gitCheck() {
+  if (await isGitRepository()) {
+    if (await isGitDirty()) {
+      const shouldCommit = await (0, import_prompts11.confirm)({
+        message: "Your working directory is dirty. Would you like to commit changes before proceeding?"
+      });
+      if (shouldCommit) {
+        const message = await (0, import_prompts11.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 s = (0, import_prompts11.spinner)();
+          s.start("Committing changes...");
+          await commitChanges(message);
+          s.stop("Changes committed.");
+        }
+      }
+    }
+  }
+}
+
+// src/utils/display.ts
+var import_picocolors10 = __toESM(require("picocolors"));
+var import_figlet = __toESM(require("figlet"));
+
 // package.json
 var package_default = {
   name: "@mayrlabs/setup-project",
-  version: "0.1.4",
+  version: "0.1.6",
   description: "Interactive CLI to setup project tools",
   private: false,
   publishConfig: {
@@ -590,186 +896,156 @@ var package_default = {
     "@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/logger.ts
-var import_fs_extra9 = __toESM(require("fs-extra"));
-var import_path3 = __toESM(require("path"));
-var LOG_DIR = ".mayrlabs/setup-project";
-var ERRORS_DIR = import_path3.default.join(LOG_DIR, "errors");
-async function logError(error) {
-  try {
-    await import_fs_extra9.default.ensureDir(ERRORS_DIR);
-    const gitignorePath = import_path3.default.join(LOG_DIR, ".gitignore");
-    if (!await import_fs_extra9.default.pathExists(gitignorePath)) {
-      await import_fs_extra9.default.outputFile(gitignorePath, "*\n");
-    }
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const logFile = import_path3.default.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 import_fs_extra9.default.outputFile(logFile, logContent);
-    return logFile;
-  } catch (e) {
-    console.error("Failed to log error:", e);
-    return "";
-  }
+// src/utils/display.ts
+function introScreen() {
+  console.log();
+  console.log(
+    import_picocolors10.default.cyan(
+      import_figlet.default.textSync("MayR\nLabs", {
+        font: "Graceful",
+        horizontalLayout: "default",
+        verticalLayout: "default",
+        width: 80,
+        whitespaceBreak: true
+      })
+    )
+  );
+  console.log(import_picocolors10.default.cyan(`@mayrlabs/setup-project v${package_default.version}`));
+  console.log();
+}
+function showAbout() {
+  introScreen();
+  console.log(import_picocolors10.default.bold("About:"));
+  console.log(
+    "  Interactive CLI to setup project tools like Husky, Prettier, ESLint, etc."
+  );
+  console.log("");
+  console.log(import_picocolors10.default.bold("How to use:"));
+  console.log(
+    "  Run 'npx @mayrlabs/setup-project' and follow the interactive prompts."
+  );
+  console.log("");
+}
+function showVisit() {
+  console.log(import_picocolors10.default.bold("Project Homepage:"));
+  console.log(import_picocolors10.default.underline(import_picocolors10.default.cyan(package_default.homepage)));
+  console.log("");
+}
+function showManual() {
+  introScreen();
+  console.log(import_picocolors10.default.bold("Usage:"));
+  console.log("  npx @mayrlabs/setup-project [command] [options]");
+  console.log("");
+  console.log(import_picocolors10.default.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(import_picocolors10.default.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("");
 }
 
 // src/index.ts
 async function main() {
   try {
-    (0, import_prompts9.intro)(import_picocolors.default.bgCyan(import_picocolors.default.black(" @mayrlabs/setup-project ")));
-    if (await isGitRepository()) {
-      if (await isGitDirty()) {
-        const shouldCommit = await (0, import_prompts9.confirm)({
-          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 = (0, import_prompts9.spinner)();
-            s2.start("Committing changes...");
-            await commitChanges(message);
-            s2.stop("Changes committed.");
-          }
-        }
-      }
-    }
-    const tools = await (0, import_prompts9.multiselect)({
-      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)" },
-        { value: "test", label: "Test Runner (Vitest/Jest)" },
-        { value: "editorConfig", label: "EditorConfig" },
-        { value: "license", label: "License" }
-      ],
-      required: false
-    });
-    if ((0, import_prompts9.isCancel)(tools)) {
-      (0, import_prompts9.cancel)("Operation cancelled.");
-      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"),
-      test: selectedTools.includes("test"),
-      editorConfig: selectedTools.includes("editorConfig"),
-      license: selectedTools.includes("license")
-    };
-    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);
-    if (config.test) await promptTest(config);
-    if (config.editorConfig) await promptEditorConfig(config);
-    if (config.license) await promptLicense(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";
-    if (config.test)
-      summary += `- Install and configure ${config.testRunner}
-`;
-    if (config.editorConfig) summary += "- Create .editorconfig\n";
-    if (config.license) summary += `- Create LICENSE (${config.licenseType})
-`;
-    (0, import_prompts9.note)(summary, "Configuration Summary");
-    const proceed = await (0, import_prompts9.confirm)({
-      message: "Do you want to proceed with the installation?"
-    });
-    if (!proceed || (0, import_prompts9.isCancel)(proceed)) {
-      (0, import_prompts9.cancel)("Installation cancelled. Configuration saved.");
+    introScreen();
+    (0, import_prompts12.intro)(
+      import_picocolors11.default.inverse(import_picocolors11.default.bold(import_picocolors11.default.cyan(" Welcome to the Project Setup Wizard ")))
+    );
+    await gitCheck();
+    const tools = await withCancelHandling(
+      async () => (0, import_prompts12.multiselect)({
+        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);
+    (0, import_prompts12.note)(config.summary, "Configuration Summary");
+    const proceed = await withCancelHandling(
+      async () => (0, import_prompts12.confirm)({
+        message: "Do you want to proceed with the installation?"
+      })
+    );
+    if (!proceed) {
+      (0, import_prompts12.outro)(import_picocolors11.default.yellow("Installation cancelled."));
       process.exit(0);
     }
-    const s = (0, import_prompts9.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 (config.env) {
-      s.start("Setting up Env Validation...");
-      await installEnv(config);
-      s.stop("Env Validation setup complete.");
-    }
-    if (config.test) {
-      s.start(`Setting up ${config.testRunner}...`);
-      await installTest(config);
-      s.stop(`${config.testRunner} setup complete.`);
-    }
-    if (config.editorConfig) {
-      s.start("Creating .editorconfig...");
-      await installEditorConfig(config);
-      s.stop(".editorconfig created.");
-    }
-    if (config.license) {
-      s.start("Creating LICENSE...");
-      await installLicense(config);
-      s.stop("LICENSE created.");
-    }
-    (0, import_prompts9.outro)(import_picocolors.default.green("Setup complete!"));
+    await execution(config);
+    (0, import_prompts12.outro)(import_picocolors11.default.green("Setup complete!"));
   } catch (error) {
     const logPath = await logError(error);
-    (0, import_prompts9.outro)(import_picocolors.default.red(`
+    (0, import_prompts12.outro)(import_picocolors11.default.red(`
 Something went wrong!
 Error log saved to: ${logPath}`));
     process.exit(1);
   }
 }
-import_commander.program.name("setup-project").description("Interactive setup for common project tools").version(package_default.version).action(main);
+import_commander.program.helpOption(false);
+import_commander.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");
+import_commander.program.command("about").action(() => {
+  showAbout();
+  process.exit(0);
+});
+import_commander.program.command("version").action(() => {
+  introScreen();
+  process.exit(0);
+});
+import_commander.program.command("visit").action(() => {
+  showVisit();
+  process.exit(0);
+});
+import_commander.program.command("help").action(() => {
+  showManual();
+  process.exit(0);
+});
+import_commander.program.action(async (options) => {
+  if (options.about) {
+    showAbout();
+    process.exit(0);
+  }
+  if (options.version) {
+    introScreen();
+    process.exit(0);
+  }
+  if (options.visit) {
+    showVisit();
+    process.exit(0);
+  }
+  if (options.help) {
+    showManual();
+    process.exit(0);
+  }
+  await main();
+});
 import_commander.program.parse();
 
 /**