@mayrlabs/setup-project 0.1.7 → 0.1.9

package/dist/index.mjs

@@ -29,6 +29,262 @@ var init_esm_shims = __esm({
   }
 });
 
+// src/utils/prompts/clack.ts
+import {
+  intro,
+  outro,
+  text,
+  confirm,
+  select,
+  multiselect,
+  note,
+  isCancel,
+  cancel,
+  log
+} from "@clack/prompts";
+var ClackProvider;
+var init_clack = __esm({
+  "src/utils/prompts/clack.ts"() {
+    "use strict";
+    init_esm_shims();
+    ClackProvider = class {
+      intro(message) {
+        intro(message);
+      }
+      outro(message) {
+        outro(message);
+      }
+      async text(opts) {
+        return text(opts);
+      }
+      async confirm(opts) {
+        return confirm(opts);
+      }
+      async select(opts) {
+        return select({
+          message: opts.message,
+          options: opts.options.map((o) => ({
+            label: o.label,
+            value: o.value,
+            hint: o.hint
+          }))
+        });
+      }
+      async multiselect(opts) {
+        return multiselect({
+          message: opts.message,
+          options: opts.options.map((o) => ({
+            label: o.label,
+            value: o.value,
+            hint: o.hint
+          }))
+        });
+      }
+      note(message, title) {
+        note(message, title);
+      }
+      isCancel(value) {
+        return isCancel(value);
+      }
+      cancel(message) {
+        cancel(message);
+      }
+      log = {
+        message: (msg) => log.message(msg),
+        info: (msg) => log.info(msg),
+        success: (msg) => log.success(msg),
+        warn: (msg) => log.warn(msg),
+        error: (msg) => log.error(msg)
+      };
+    };
+  }
+});
+
+// src/utils/prompts/top.ts
+import { confirm as confirm2, question, select as select2, multiselect as multiselect2 } from "@topcli/prompts";
+import pc from "picocolors";
+var CANCEL_SYMBOL, TopCliProvider;
+var init_top = __esm({
+  "src/utils/prompts/top.ts"() {
+    "use strict";
+    init_esm_shims();
+    CANCEL_SYMBOL = /* @__PURE__ */ Symbol("cancel");
+    TopCliProvider = class {
+      intro(message) {
+        console.log(pc.bgCyan(pc.black(` ${message} `)));
+      }
+      outro(message) {
+        console.log(pc.bgCyan(pc.black(` ${message} `)));
+      }
+      async text(opts) {
+        try {
+          return await question(opts.message, {
+            defaultValue: opts.initialValue || opts.defaultValue,
+            validators: [
+              {
+                validate: (value) => opts.validate?.(value) || ""
+              }
+            ]
+          });
+        } catch {
+          return CANCEL_SYMBOL;
+        }
+      }
+      async confirm(opts) {
+        try {
+          return await confirm2(opts.message, {
+            initial: opts.initialValue
+          });
+        } catch {
+          return CANCEL_SYMBOL;
+        }
+      }
+      async select(opts) {
+        try {
+          const optionMap = /* @__PURE__ */ new Map();
+          const choices = opts.options.map((o) => {
+            const key = String(o.value);
+            optionMap.set(key, o.value);
+            const isSelected = opts.initialValue === o.value;
+            return {
+              label: o.label,
+              value: key,
+              description: o.hint,
+              selected: isSelected
+            };
+          });
+          const resultKey = await select2(opts.message, {
+            choices,
+            autocomplete: true,
+            maxVisible: 10
+          });
+          return optionMap.get(resultKey);
+        } catch {
+          return CANCEL_SYMBOL;
+        }
+      }
+      async multiselect(opts) {
+        try {
+          const optionMap = /* @__PURE__ */ new Map();
+          const choices = opts.options.map((o) => {
+            const key = String(o.value);
+            optionMap.set(key, o.value);
+            const isSelected = opts.initialValue?.some((iv) => iv === o.value);
+            return {
+              label: o.label,
+              value: key,
+              description: o.hint,
+              selected: isSelected
+            };
+          });
+          const resultKeys = await multiselect2(opts.message, {
+            choices,
+            autocomplete: true,
+            maxVisible: 10,
+            showHint: true
+          });
+          return resultKeys.map((k) => optionMap.get(k));
+        } catch {
+          return CANCEL_SYMBOL;
+        }
+      }
+      note(message, title) {
+        if (title) {
+          console.log(pc.blue(pc.bold(`${title}`)));
+        }
+        console.log(pc.dim(message));
+      }
+      isCancel(value) {
+        return value === CANCEL_SYMBOL;
+      }
+      cancel(message) {
+        if (message) console.log(pc.red(pc.bold("\xD7")) + " " + message);
+        else console.log(pc.red(pc.bold("\xD7")) + " Operation cancelled.");
+      }
+      log = {
+        message: (msg) => console.log(msg),
+        info: (msg) => console.log(pc.blue(pc.bold("INFO")) + " " + msg),
+        success: (msg) => console.log(pc.green(pc.bold("SUCCESS")) + " " + msg),
+        warn: (msg) => console.log(pc.yellow(pc.bold("WARN")) + " " + msg),
+        error: (msg) => console.log(pc.red(pc.bold("ERROR")) + " " + msg)
+      };
+    };
+  }
+});
+
+// src/utils/prompts/types.ts
+var init_types = __esm({
+  "src/utils/prompts/types.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/utils/prompts/index.ts
+var Prompts, prompts;
+var init_prompts = __esm({
+  "src/utils/prompts/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_clack();
+    init_top();
+    init_types();
+    Prompts = class _Prompts {
+      provider;
+      static instance;
+      constructor() {
+        this.provider = new TopCliProvider();
+      }
+      static getInstance() {
+        if (!_Prompts.instance) {
+          _Prompts.instance = new _Prompts();
+        }
+        return _Prompts.instance;
+      }
+      setProvider(provider) {
+        this.provider = provider;
+      }
+      useClack() {
+        this.provider = new ClackProvider();
+      }
+      useTopCli() {
+        this.provider = new TopCliProvider();
+      }
+      intro(message) {
+        this.provider.intro(message);
+      }
+      outro(message) {
+        this.provider.outro(message);
+      }
+      text(opts) {
+        return this.provider.text(opts);
+      }
+      confirm(opts) {
+        return this.provider.confirm(opts);
+      }
+      select(opts) {
+        return this.provider.select(opts);
+      }
+      multiselect(opts) {
+        return this.provider.multiselect(opts);
+      }
+      note(message, title) {
+        this.provider.note(message, title);
+      }
+      isCancel(value) {
+        return this.provider.isCancel(value);
+      }
+      cancel(message) {
+        this.provider.cancel(message);
+      }
+      get log() {
+        return this.provider.log;
+      }
+    };
+    prompts = Prompts.getInstance();
+  }
+});
+
 // src/utils/pm.ts
 import { execa } from "execa";
 async function getPackageManager() {
@@ -155,102 +411,1479 @@ var init_options = __esm({
 });
 
 // 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({
+    if (prompts.isCancel(response)) {
+      const shouldCancel = await prompts.confirm({
         message: "Do you really want to cancel options selection?"
       });
-      if (isCancel(shouldCancel) || shouldCancel) {
-        cancel(cancelMessage);
+      if (prompts.isCancel(shouldCancel) || shouldCancel) {
+        prompts.cancel(cancelMessage);
         process.exit(0);
       }
-      continue;
-    } else {
-      return response;
+      continue;
+    } else {
+      return response;
+    }
+  }
+}
+var init_handle_cancel = __esm({
+  "src/utils/handle-cancel.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_prompts();
+  }
+});
+
+// src/features/husky.ts
+import { execa as execa2 } from "execa";
+import fs from "fs-extra";
+import pc2 from "picocolors";
+async function promptHusky(config2) {
+  prompts.log.message(pc2.bgMagenta(pc2.black(" Husky Configuration ")));
+  const hookType = await withCancelHandling(
+    async () => prompts.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 === "lintStaged") {
+    config2.enableTool("lintStaged");
+  } else if (hookType === "custom") {
+    const script = await withCancelHandling(
+      async () => prompts.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(config2) {
+  await installPackages(["husky"], true);
+  try {
+    await execa2("npx", ["husky", "init"]);
+  } catch {
+    await execa2("npm", ["pkg", "set", "scripts.prepare=husky"]);
+    await execa2("npm", ["run", "prepare"]);
+  }
+  const husky = config2.get("husky");
+  const hookType = husky.options.hookType;
+  const customScript = husky.options.customScript;
+  if (hookType === "lintStaged") {
+    await fs.outputFile(".husky/pre-commit", "npx lint-staged\n", {
+      mode: 493
+    });
+  } else if (hookType === "custom" && customScript) {
+    await fs.outputFile(".husky/pre-commit", `${customScript}
+`, {
+      mode: 493
+    });
+  }
+}
+var init_husky = __esm({
+  "src/features/husky.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_prompts();
+    init_pm();
+    init_options();
+    init_handle_cancel();
+  }
+});
+
+// src/utils/config-file.ts
+import fs2 from "fs-extra";
+import path2 from "path";
+async function resolveConfigFile(toolName, candidates) {
+  for (const file of candidates) {
+    if (await fs2.pathExists(file)) return file;
+  }
+  const response = await withCancelHandling(
+    async () => prompts.select({
+      message: `Where do you want to store the ${toolName} config?`,
+      options: candidates.map((c) => ({ value: c, label: c })),
+      initialValue: candidates[0]
+    })
+  );
+  return response;
+}
+async function writeConfig(filePath, config2) {
+  const ext = path2.extname(filePath);
+  if (ext === ".json" || ext === "") {
+    await fs2.writeJson(filePath, config2, { spaces: 2 });
+  } else if (ext === ".js" || ext === ".cjs") {
+    const content = `module.exports = ${JSON.stringify(config2, null, 2)};`;
+    await fs2.writeFile(filePath, content);
+  } else if (ext === ".mjs") {
+    const content = `export default ${JSON.stringify(config2, null, 2)};`;
+    await fs2.writeFile(filePath, content);
+  } else {
+    await fs2.writeJson(filePath, config2, { spaces: 2 });
+  }
+}
+var init_config_file = __esm({
+  "src/utils/config-file.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_prompts();
+    init_handle_cancel();
+  }
+});
+
+// src/features/formatter/prettier.ts
+import fs3 from "fs-extra";
+async function installPrettier() {
+  await installPackages(["prettier"], true);
+  const configFile = await resolveConfigFile("Prettier", [
+    ".prettierrc",
+    ".prettierrc.json",
+    "prettier.config.js",
+    ".prettierrc.js"
+  ]);
+  if (!await fs3.pathExists(configFile)) {
+    await writeConfig(configFile, {
+      semi: true,
+      singleQuote: false,
+      tabWidth: 2,
+      trailingComma: "es5",
+      printWidth: 80,
+      plugins: []
+    });
+  }
+  if (!await fs3.pathExists(".prettierignore")) {
+    await fs3.writeFile(
+      ".prettierignore",
+      `node_modules
+dist
+coverage
+.next
+.nuxt
+build
+.astro
+.output
+`
+    );
+  }
+}
+async function configurePrettierPlugins(plugins) {
+  const configFile = await resolveConfigFile("Prettier", [
+    ".prettierrc",
+    ".prettierrc.json",
+    "prettier.config.js",
+    ".prettierrc.js"
+  ]);
+  let currentConfig = {};
+  if (await fs3.pathExists(configFile)) {
+    try {
+      if (configFile.endsWith(".js") || configFile.endsWith(".cjs")) {
+        return;
+      }
+      currentConfig = await fs3.readJson(configFile);
+    } catch {
+    }
+  }
+  const existingPlugins = currentConfig.plugins || [];
+  const newPlugins = [.../* @__PURE__ */ new Set([...existingPlugins, ...plugins])];
+  currentConfig.plugins = newPlugins;
+  await writeConfig(configFile, currentConfig);
+}
+var init_prettier = __esm({
+  "src/features/formatter/prettier.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_pm();
+    init_config_file();
+  }
+});
+
+// src/features/formatter/oxfmt.ts
+async function installOxfmt() {
+  await installPackages(["oxfmt@latest"], true);
+}
+var init_oxfmt = __esm({
+  "src/features/formatter/oxfmt.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_pm();
+  }
+});
+
+// src/constants/plugins.ts
+var ESLINT_PLUGINS, PRETTIER_PLUGINS, PLUGINS, PLUGINABLE_TOOLS;
+var init_plugins = __esm({
+  "src/constants/plugins.ts"() {
+    "use strict";
+    init_esm_shims();
+    ESLINT_PLUGINS = [
+      // Code Quality
+      {
+        value: "depend",
+        label: "depend",
+        package: "eslint-plugin-depend",
+        hint: "Detect junk dependencies"
+      },
+      {
+        value: "github",
+        label: "github",
+        package: "eslint-plugin-github",
+        hint: "GitHub's ESLint rules"
+      },
+      {
+        value: "sonarjs",
+        label: "sonarjs",
+        package: "eslint-plugin-sonarjs",
+        hint: "Detect bugs and suspicious patterns"
+      },
+      {
+        value: "unicorn",
+        label: "unicorn",
+        package: "eslint-plugin-unicorn",
+        hint: "Various awesome ESLint rules"
+      },
+      {
+        value: "mysticatea",
+        label: "mysticatea",
+        package: "@mysticatea/eslint-plugin",
+        hint: "Misc rules"
+      },
+      {
+        value: "brettz9",
+        label: "brettz9",
+        package: "@brettz9/eslint-plugin",
+        hint: "Misc rules without personal config"
+      },
+      {
+        value: "de-morgan",
+        label: "de-morgan",
+        package: "eslint-plugin-de-morgan",
+        hint: "Transform logical expressions"
+      },
+      {
+        value: "code-complete",
+        label: "code-complete",
+        package: "eslint-plugin-code-complete",
+        hint: "Clean, maintainable software design"
+      },
+      // Compatibility
+      {
+        value: "compat",
+        label: "compat",
+        package: "eslint-plugin-compat",
+        hint: "Browser compatibility checking"
+      },
+      {
+        value: "es-compat",
+        label: "es-compat",
+        package: "eslint-plugin-es-compat",
+        hint: "Disable unsupported ES features"
+      },
+      {
+        value: "es-x",
+        label: "es-x",
+        package: "eslint-plugin-es-x",
+        hint: "Disable specific ES versions"
+      },
+      {
+        value: "es5",
+        label: "es5",
+        package: "eslint-plugin-es5",
+        hint: "Forbid ES2015+ usage"
+      },
+      {
+        value: "ie11",
+        label: "ie11",
+        package: "eslint-plugin-ie11",
+        hint: "Detect unsupported ES6 features in IE11"
+      },
+      // CSS in JS
+      {
+        value: "css-modules",
+        label: "css-modules",
+        package: "eslint-plugin-css-modules",
+        hint: "Lint css modules"
+      },
+      {
+        value: "emotion",
+        label: "emotion",
+        package: "@emotion/eslint-plugin",
+        hint: "Rules for emotion"
+      },
+      {
+        value: "better-styled-components",
+        label: "better-styled-components",
+        package: "eslint-plugin-better-styled-components",
+        hint: "Auto fixable rules for styled components"
+      },
+      {
+        value: "styled-components-a11y",
+        label: "styled-components-a11y",
+        package: "eslint-plugin-styled-components-a11y",
+        hint: "A11y for Styled Components"
+      },
+      {
+        value: "vanilla-extract",
+        label: "vanilla-extract",
+        package: "@vanilla-extract/eslint-plugin",
+        hint: "Enforce CSS property ordering"
+      },
+      // Deprecation
+      {
+        value: "deprecate",
+        label: "deprecate",
+        package: "eslint-plugin-deprecate",
+        hint: "Mark functions/modules as deprecated"
+      },
+      {
+        value: "disable",
+        label: "disable",
+        package: "eslint-plugin-disable",
+        hint: "Disable plugins using patterns"
+      },
+      // Embedded
+      {
+        value: "html",
+        label: "html",
+        package: "eslint-plugin-html",
+        hint: "Linting JS inside HTML"
+      },
+      {
+        value: "markdown",
+        label: "markdown",
+        package: "eslint-plugin-markdown",
+        hint: "Linting JS inside Markdown"
+      },
+      // Frameworks
+      {
+        value: "angular",
+        label: "angular",
+        package: "@angular-eslint/eslint-plugin",
+        hint: "Linting for Angular"
+      },
+      {
+        value: "angularjs",
+        label: "angularjs",
+        package: "eslint-plugin-angular",
+        hint: "Linting for AngularJS"
+      },
+      {
+        value: "astro",
+        label: "astro",
+        package: "eslint-plugin-astro",
+        hint: "Linting for Astro"
+      },
+      {
+        value: "backbone",
+        label: "backbone",
+        package: "eslint-plugin-backbone",
+        hint: "Linting for Backbone"
+      },
+      {
+        value: "ember",
+        label: "ember",
+        package: "eslint-plugin-ember",
+        hint: "Linting for Ember"
+      },
+      {
+        value: "hapi",
+        label: "hapi",
+        package: "eslint-plugin-hapi",
+        hint: "Linting for Hapi"
+      },
+      {
+        value: "meteor",
+        label: "meteor",
+        package: "eslint-plugin-meteor",
+        hint: "Linting for Meteor"
+      },
+      {
+        value: "jsx-a11y",
+        label: "jsx-a11y",
+        package: "eslint-plugin-jsx-a11y",
+        hint: "Accessibility rules on JSX"
+      },
+      {
+        value: "react",
+        label: "react",
+        package: "eslint-plugin-react",
+        hint: "Linting for React/JSX"
+      },
+      {
+        value: "react-hooks",
+        label: "react-hooks",
+        package: "eslint-plugin-react-hooks",
+        hint: "Linting for React Hooks"
+      },
+      {
+        value: "react-native",
+        label: "react-native",
+        package: "eslint-plugin-react-native",
+        hint: "React Native specific rules"
+      },
+      {
+        value: "react-redux",
+        label: "react-redux",
+        package: "eslint-plugin-react-redux",
+        hint: "React-Redux specific rules"
+      },
+      {
+        value: "react-refresh",
+        label: "react-refresh",
+        package: "eslint-plugin-react-refresh",
+        hint: "Improve HMR with Vite"
+      },
+      {
+        value: "solid",
+        label: "solid",
+        package: "eslint-plugin-solid",
+        hint: "Linting for Solid"
+      },
+      {
+        value: "svelte",
+        label: "svelte",
+        package: "eslint-plugin-svelte",
+        hint: "Linting for Svelte"
+      },
+      {
+        value: "vuejs",
+        label: "vuejs",
+        package: "eslint-plugin-vue",
+        hint: "Linting for VueJS"
+      },
+      {
+        value: "vue-scoped-css",
+        label: "vue-scoped-css",
+        package: "eslint-plugin-vue-scoped-css",
+        hint: "Scoped CSS in VueJS"
+      },
+      // Languages and Environments
+      {
+        value: "babel",
+        label: "babel",
+        package: "@babel/eslint-plugin",
+        hint: "Babel features"
+      },
+      {
+        value: "flowtype",
+        label: "flowtype",
+        package: "eslint-plugin-flowtype",
+        hint: "Flow type linting"
+      },
+      {
+        value: "flowtype-errors",
+        label: "flowtype-errors",
+        package: "eslint-plugin-flowtype-errors",
+        hint: "Run Flow as plugin"
+      },
+      {
+        value: "html-eslint",
+        label: "html-eslint",
+        package: "@html-eslint/eslint-plugin",
+        hint: "Linting for HTML"
+      },
+      {
+        value: "json",
+        label: "json",
+        package: "eslint-plugin-json",
+        hint: "Lint JSON files"
+      },
+      {
+        value: "json-format",
+        label: "json-format",
+        package: "eslint-plugin-json-format",
+        hint: "Lint/Format/Fix JSON"
+      },
+      {
+        value: "jsonc",
+        label: "jsonc",
+        package: "eslint-plugin-jsonc",
+        hint: "JSON with comments"
+      },
+      {
+        value: "json-schema-validator",
+        label: "json-schema-validator",
+        package: "eslint-plugin-json-schema-validator",
+        hint: "Validate data using JSON Schema"
+      },
+      {
+        value: "package-json",
+        label: "package-json",
+        package: "eslint-plugin-package-json",
+        hint: "Rules for package.json"
+      },
+      {
+        value: "mdx",
+        label: "mdx",
+        package: "eslint-plugin-mdx",
+        hint: "Lint MDX"
+      },
+      { value: "n", label: "n", package: "eslint-plugin-n", hint: "Node.js rules" },
+      {
+        value: "sql",
+        label: "sql",
+        package: "eslint-plugin-sql",
+        hint: "SQL linting"
+      },
+      {
+        value: "toml",
+        label: "toml",
+        package: "eslint-plugin-toml",
+        hint: "Lint TOML"
+      },
+      {
+        value: "typescript",
+        label: "typescript",
+        package: "@typescript-eslint/eslint-plugin",
+        hint: "Lint TypeScript"
+      },
+      {
+        value: "erasable-syntax-only",
+        label: "erasable-syntax-only",
+        package: "eslint-plugin-erasable-syntax-only",
+        hint: "Enforce TS erasableSyntaxOnly"
+      },
+      {
+        value: "expect-type",
+        label: "expect-type",
+        package: "eslint-plugin-expect-type",
+        hint: "Type assertions"
+      },
+      {
+        value: "yaml",
+        label: "yaml",
+        package: "eslint-plugin-yml",
+        hint: "Lint YAML"
+      },
+      // Libraries
+      {
+        value: "graphql",
+        label: "graphql",
+        package: "@graphql-eslint/eslint-plugin",
+        hint: "Validate GraphQL operations/schema"
+      },
+      {
+        value: "graphql-schema",
+        label: "graphql-schema",
+        package: "eslint-plugin-graphql",
+        hint: "Check GraphQL queries against schema"
+      },
+      {
+        value: "type-graphql",
+        label: "type-graphql",
+        package: "eslint-plugin-type-graphql",
+        hint: "Lint TypeGraphQL"
+      },
+      {
+        value: "jquery",
+        label: "jquery",
+        package: "eslint-plugin-no-jquery",
+        hint: "Lint jQuery (deprecated features)"
+      },
+      {
+        value: "jsdoc",
+        label: "jsdoc",
+        package: "eslint-plugin-jsdoc",
+        hint: "Lint JSDoc comments"
+      },
+      {
+        value: "lodash",
+        label: "lodash",
+        package: "eslint-plugin-lodash",
+        hint: "Lodash rules"
+      },
+      {
+        value: "lodash-fp",
+        label: "lodash-fp",
+        package: "eslint-plugin-lodash-fp",
+        hint: "Lodash/fp rules"
+      },
+      {
+        value: "lodash-template",
+        label: "lodash-template",
+        package: "eslint-plugin-lodash-template",
+        hint: "Lodash template rules"
+      },
+      {
+        value: "microtemplates",
+        label: "microtemplates",
+        package: "eslint-plugin-microtemplates",
+        hint: "Microtemplates rules"
+      },
+      {
+        value: "mongodb",
+        label: "mongodb",
+        package: "eslint-plugin-mongodb",
+        hint: "MongoDB driver rules"
+      },
+      {
+        value: "ramda",
+        label: "ramda",
+        package: "eslint-plugin-ramda",
+        hint: "Ramda rules"
+      },
+      {
+        value: "requirejs",
+        label: "requirejs",
+        package: "eslint-plugin-requirejs",
+        hint: "RequireJS rules"
+      },
+      {
+        value: "tailwindcss",
+        label: "tailwindcss",
+        package: "eslint-plugin-tailwindcss",
+        hint: "Tailwind CSS rules"
+      },
+      {
+        value: "better-tailwindcss",
+        label: "better-tailwindcss",
+        package: "eslint-plugin-better-tailwindcss",
+        hint: "Improve readability/best practices"
+      },
+      // Misc
+      {
+        value: "diff",
+        label: "diff",
+        package: "eslint-plugin-diff",
+        hint: "Lint changed lines only"
+      },
+      {
+        value: "misc",
+        label: "misc",
+        package: "eslint-plugin-misc",
+        hint: "Miscellaneous rules"
+      },
+      {
+        value: "notice",
+        label: "notice",
+        package: "eslint-plugin-notice",
+        hint: "Check top of files"
+      },
+      {
+        value: "only-error",
+        label: "only-error",
+        package: "eslint-plugin-only-error",
+        hint: "Convert all rules to errors"
+      },
+      {
+        value: "only-warn",
+        label: "only-warn",
+        package: "eslint-plugin-only-warn",
+        hint: "Convert all rules to warnings"
+      },
+      {
+        value: "putout",
+        label: "putout",
+        package: "eslint-plugin-putout",
+        hint: "Integrate PutOut linter"
+      },
+      {
+        value: "typelint",
+        label: "typelint",
+        package: "eslint-plugin-typelint",
+        hint: "Introduce types based on schemas"
+      },
+      {
+        value: "woke",
+        label: "woke",
+        package: "eslint-plugin-woke",
+        hint: "Catch insensitive words"
+      },
+      // Practices and Specific ES Features
+      {
+        value: "array-func",
+        label: "array-func",
+        package: "eslint-plugin-array-func",
+        hint: "Avoid redundancy with array methods"
+      },
+      {
+        value: "proper-arrows",
+        label: "proper-arrows",
+        package: "eslint-plugin-proper-arrows",
+        hint: "Ensure proper arrow function definitions"
+      },
+      {
+        value: "boundaries",
+        label: "boundaries",
+        package: "eslint-plugin-boundaries",
+        hint: "Enforce architecture boundaries"
+      },
+      {
+        value: "eslint-comments",
+        label: "eslint-comments",
+        package: "eslint-plugin-eslint-comments",
+        hint: "Best practices for ESLint directives"
+      },
+      {
+        value: "error-cause",
+        label: "error-cause",
+        package: "eslint-plugin-error-cause",
+        hint: "Preserve error context"
+      },
+      {
+        value: "hexagonal-architecture",
+        label: "hexagonal-architecture",
+        package: "eslint-plugin-hexagonal-architecture",
+        hint: "Hexagonal architecture best practices"
+      },
+      {
+        value: "signature-design",
+        label: "signature-design",
+        package: "eslint-plugin-signature-design",
+        hint: "Enforce object-based signatures"
+      },
+      {
+        value: "write-good-comments",
+        label: "write-good-comments",
+        package: "eslint-plugin-write-good-comments",
+        hint: "Enforce good comment style"
+      },
+      {
+        value: "exception-handling",
+        label: "exception-handling",
+        package: "eslint-plugin-exception-handling",
+        hint: "Lint unhandled exceptions"
+      },
+      {
+        value: "fp",
+        label: "fp",
+        package: "eslint-plugin-fp",
+        hint: "Functional programming rules"
+      },
+      {
+        value: "functional",
+        label: "functional",
+        package: "eslint-plugin-functional",
+        hint: "Disable mutation, promote FP"
+      },
+      {
+        value: "mutate",
+        label: "mutate",
+        package: "eslint-plugin-mutate",
+        hint: "Prevent accidental mutations"
+      },
+      {
+        value: "immutable",
+        label: "immutable",
+        package: "eslint-plugin-immutable",
+        hint: "Disable all mutation"
+      },
+      {
+        value: "import",
+        label: "import",
+        package: "eslint-plugin-import",
+        hint: "Lint import/export syntax"
+      },
+      {
+        value: "import-x",
+        label: "import-x",
+        package: "eslint-plugin-import-x",
+        hint: "Lightweight fork of eslint-plugin-import"
+      },
+      {
+        value: "math",
+        label: "math",
+        package: "eslint-plugin-math",
+        hint: "Math object rules"
+      },
+      {
+        value: "new-with-error",
+        label: "new-with-error",
+        package: "eslint-plugin-new-with-error",
+        hint: "Require new with Error"
+      },
+      {
+        value: "no-argument-spread",
+        label: "no-argument-spread",
+        package: "eslint-plugin-no-argument-spread",
+        hint: "Lint against spread arguments"
+      },
+      {
+        value: "no-comments",
+        label: "no-comments",
+        package: "eslint-plugin-no-comments",
+        hint: "Prevent leaking comments"
+      },
+      {
+        value: "no-constructor-bind",
+        label: "no-constructor-bind",
+        package: "eslint-plugin-no-constructor-bind",
+        hint: "Encourage class properties"
+      },
+      {
+        value: "no-inferred-method-name",
+        label: "no-inferred-method-name",
+        package: "eslint-plugin-no-inferred-method-name",
+        hint: "Check inferred method names"
+      },
+      {
+        value: "no-loops",
+        label: "no-loops",
+        package: "eslint-plugin-no-loops",
+        hint: "Disallow loops"
+      },
+      {
+        value: "query",
+        label: "query",
+        package: "eslint-plugin-query",
+        hint: "Show queried syntax content"
+      },
+      {
+        value: "no-use-extend-native",
+        label: "no-use-extend-native",
+        package: "eslint-plugin-no-use-extend-native",
+        hint: "Prevent using extended native objects"
+      },
+      {
+        value: "promise",
+        label: "promise",
+        package: "eslint-plugin-promise",
+        hint: "Promise best practices"
+      },
+      {
+        value: "pure",
+        label: "pure",
+        package: "eslint-plugin-pure",
+        hint: "Enforce pure functions"
+      },
+      {
+        value: "redos",
+        label: "redos",
+        package: "eslint-plugin-redos",
+        hint: "Find ReDoS vulnerabilities"
+      },
+      {
+        value: "redos-detector",
+        label: "redos-detector",
+        package: "eslint-plugin-redos-detector",
+        hint: "Find ReDoS vulnerabilities"
+      },
+      {
+        value: "regexp",
+        label: "regexp",
+        package: "eslint-plugin-regexp",
+        hint: "Find regexp mistakes"
+      },
+      {
+        value: "sort-keys-fix",
+        label: "sort-keys-fix",
+        package: "eslint-plugin-sort-keys-fix",
+        hint: "Fixer for sort-keys"
+      },
+      {
+        value: "this",
+        label: "this",
+        package: "eslint-plugin-this",
+        hint: "Disallow this"
+      },
+      {
+        value: "toplevel",
+        label: "toplevel",
+        package: "eslint-plugin-toplevel",
+        hint: "Disallow side effects at top level"
+      },
+      // Performance
+      {
+        value: "dom",
+        label: "dom",
+        package: "eslint-plugin-dom",
+        hint: "DOM performance"
+      },
+      {
+        value: "optimize-regex",
+        label: "optimize-regex",
+        package: "eslint-plugin-optimize-regex",
+        hint: "Optimize regex literals"
+      },
+      {
+        value: "perf-standard",
+        label: "perf-standard",
+        package: "eslint-plugin-perf-standard",
+        hint: "Performance standard rules"
+      },
+      // Security
+      {
+        value: "no-secrets",
+        label: "no-secrets",
+        package: "eslint-plugin-no-secrets",
+        hint: "Detect potential secrets"
+      },
+      {
+        value: "no-unsanitized",
+        label: "no-unsanitized",
+        package: "eslint-plugin-no-unsanitized",
+        hint: "Checks for innerHTML etc"
+      },
+      {
+        value: "pii",
+        label: "pii",
+        package: "eslint-plugin-pii",
+        hint: "Enforce PII compliance"
+      },
+      {
+        value: "pg",
+        label: "pg",
+        package: "eslint-plugin-pg",
+        hint: "PostgreSQL security"
+      },
+      {
+        value: "security",
+        label: "security",
+        package: "eslint-plugin-security",
+        hint: "Node Security rules"
+      },
+      {
+        value: "xss",
+        label: "xss",
+        package: "eslint-plugin-xss",
+        hint: "Detect XSS issues"
+      },
+      // Style
+      {
+        value: "stylistic",
+        label: "stylistic",
+        package: "@stylistic/eslint-plugin",
+        hint: "Formatting and stylistic rules"
+      },
+      {
+        value: "const-case",
+        label: "const-case",
+        package: "eslint-plugin-const-case",
+        hint: "Enforce capitalization of constants"
+      },
+      {
+        value: "editorconfig",
+        label: "editorconfig",
+        package: "eslint-plugin-editorconfig",
+        hint: "Derive rules from .editorconfig"
+      },
+      {
+        value: "simple-import-sort",
+        label: "simple-import-sort",
+        package: "eslint-plugin-simple-import-sort",
+        hint: "Easy import sorting"
+      },
+      {
+        value: "perfectionist",
+        label: "perfectionist",
+        package: "eslint-plugin-perfectionist",
+        hint: "Sort objects, imports, etc."
+      },
+      {
+        value: "split-and-sort-imports",
+        label: "split-and-sort-imports",
+        package: "eslint-plugin-split-and-sort-imports",
+        hint: "Split and sort imports"
+      },
+      {
+        value: "switch-case",
+        label: "switch-case",
+        package: "eslint-plugin-switch-case",
+        hint: "Switch-case specific rules"
+      },
+      {
+        value: "padding",
+        label: "padding",
+        package: "eslint-plugin-padding",
+        hint: "Padding between statements"
+      },
+      {
+        value: "paths",
+        label: "paths",
+        package: "eslint-plugin-paths",
+        hint: "Use paths from tsconfig/jsconfig"
+      },
+      {
+        value: "no-relative-imports",
+        label: "no-relative-imports",
+        package: "@gitbutler/no-relative-imports",
+        hint: "Auto fix relative paths"
+      },
+      // Testing Tools
+      {
+        value: "ava",
+        label: "ava",
+        package: "eslint-plugin-ava",
+        hint: "AVA rules"
+      },
+      {
+        value: "chai-expect",
+        label: "chai-expect",
+        package: "eslint-plugin-chai-expect",
+        hint: "Chai expect practices"
+      },
+      {
+        value: "chai-friendly",
+        label: "chai-friendly",
+        package: "eslint-plugin-chai-friendly",
+        hint: "Chai unused expressions"
+      },
+      {
+        value: "chai-expect-keywords",
+        label: "chai-expect-keywords",
+        package: "eslint-plugin-chai-expect-keywords",
+        hint: "Permitted keywords"
+      },
+      {
+        value: "chai-as-promised",
+        label: "chai-as-promised",
+        package: "eslint-plugin-chai-as-promised",
+        hint: "Chai as promised"
+      },
+      {
+        value: "chai-assert-bdd",
+        label: "chai-assert-bdd",
+        package: "eslint-plugin-chai-assert-bdd",
+        hint: "Chai globals"
+      },
+      {
+        value: "cucumber",
+        label: "cucumber",
+        package: "eslint-plugin-cucumber",
+        hint: "Cucumber rules"
+      },
+      {
+        value: "cypress",
+        label: "cypress",
+        package: "eslint-plugin-cypress",
+        hint: "Cypress rules"
+      },
+      {
+        value: "jasmine",
+        label: "jasmine",
+        package: "eslint-plugin-jasmine",
+        hint: "Jasmine rules"
+      },
+      {
+        value: "jest",
+        label: "jest",
+        package: "eslint-plugin-jest",
+        hint: "Jest practices"
+      },
+      {
+        value: "jest-formatting",
+        label: "jest-formatting",
+        package: "eslint-plugin-jest-formatting",
+        hint: "Jest formatting"
+      },
+      {
+        value: "jest-async",
+        label: "jest-async",
+        package: "eslint-plugin-jest-async",
+        hint: "Jest async rules"
+      },
+      {
+        value: "jest-dom",
+        label: "jest-dom",
+        package: "eslint-plugin-jest-dom",
+        hint: "Jest-DOM rules"
+      },
+      {
+        value: "mocha",
+        label: "mocha",
+        package: "eslint-plugin-mocha",
+        hint: "Mocha practices"
+      },
+      {
+        value: "mocha-cleanup",
+        label: "mocha-cleanup",
+        package: "eslint-plugin-mocha-cleanup",
+        hint: "Mocha cleanup"
+      },
+      {
+        value: "playwright",
+        label: "playwright",
+        package: "eslint-plugin-playwright",
+        hint: "Playwright rules"
+      },
+      {
+        value: "qunit",
+        label: "qunit",
+        package: "eslint-plugin-qunit",
+        hint: "QUnit rules"
+      },
+      {
+        value: "testcafe-community",
+        label: "testcafe-community",
+        package: "eslint-plugin-testcafe-community",
+        hint: "TestCafe rules"
+      },
+      {
+        value: "testing-library",
+        label: "testing-library",
+        package: "eslint-plugin-testing-library",
+        hint: "Testing Library rules"
+      }
+    ];
+    PRETTIER_PLUGINS = [
+      // Official
+      {
+        value: "php",
+        label: "php",
+        package: "@prettier/plugin-php",
+        hint: "Prettier for PHP"
+      },
+      {
+        value: "pug",
+        label: "pug",
+        package: "@prettier/plugin-pug",
+        hint: "Prettier for Pug"
+      },
+      {
+        value: "ruby",
+        label: "ruby",
+        package: "@prettier/plugin-ruby",
+        hint: "Prettier for Ruby"
+      },
+      {
+        value: "xml",
+        label: "xml",
+        package: "@prettier/plugin-xml",
+        hint: "Prettier for XML"
+      },
+      // Community
+      {
+        value: "apex",
+        label: "apex",
+        package: "prettier-plugin-apex",
+        hint: "Prettier for Apex"
+      },
+      {
+        value: "astro",
+        label: "astro",
+        package: "prettier-plugin-astro",
+        hint: "Prettier for Astro"
+      },
+      {
+        value: "bigcommerce",
+        label: "bigcommerce",
+        package: "prettier-plugin-bigcommerce-stencil",
+        hint: "Prettier for BigCommerce"
+      },
+      {
+        value: "elm",
+        label: "elm",
+        package: "prettier-plugin-elm",
+        hint: "Prettier for Elm"
+      },
+      {
+        value: "erb",
+        label: "erb",
+        package: "prettier-plugin-erb",
+        hint: "Prettier for ERB"
+      },
+      {
+        value: "gherkin",
+        label: "gherkin",
+        package: "prettier-plugin-gherkin",
+        hint: "Prettier for Gherkin"
+      },
+      {
+        value: "glsl",
+        label: "glsl",
+        package: "prettier-plugin-glsl",
+        hint: "Prettier for GLSL"
+      },
+      {
+        value: "go-template",
+        label: "go-template",
+        package: "prettier-plugin-go-template",
+        hint: "Prettier for Go Templates"
+      },
+      {
+        value: "hugo",
+        label: "hugo",
+        package: "prettier-plugin-hugo-post",
+        hint: "Prettier for Hugo"
+      },
+      {
+        value: "java",
+        label: "java",
+        package: "prettier-plugin-java",
+        hint: "Prettier for Java"
+      },
+      {
+        value: "jinja",
+        label: "jinja",
+        package: "prettier-plugin-jinja-template",
+        hint: "Prettier for Jinja"
+      },
+      {
+        value: "jsonata",
+        label: "jsonata",
+        package: "prettier-plugin-jsonata",
+        hint: "Prettier for JSONata"
+      },
+      {
+        value: "kotlin",
+        label: "kotlin",
+        package: "prettier-plugin-kotlin",
+        hint: "Prettier for Kotlin"
+      },
+      {
+        value: "marko",
+        label: "marko",
+        package: "prettier-plugin-marko",
+        hint: "Prettier for Marko"
+      },
+      {
+        value: "motoko",
+        label: "motoko",
+        package: "prettier-plugin-motoko",
+        hint: "Prettier for Motoko"
+      },
+      {
+        value: "nginx",
+        label: "nginx",
+        package: "prettier-plugin-nginx",
+        hint: "Prettier for Nginx"
+      },
+      {
+        value: "prisma",
+        label: "prisma",
+        package: "prettier-plugin-prisma",
+        hint: "Prettier for Prisma"
+      },
+      {
+        value: "properties",
+        label: "properties",
+        package: "prettier-plugin-properties",
+        hint: "Prettier for Properties"
+      },
+      {
+        value: "rust",
+        label: "rust",
+        package: "prettier-plugin-rust",
+        hint: "Prettier for Rust"
+      },
+      {
+        value: "sh",
+        label: "sh",
+        package: "prettier-plugin-sh",
+        hint: "Prettier for Shell"
+      },
+      {
+        value: "sql",
+        label: "sql",
+        package: "prettier-plugin-sql",
+        hint: "Prettier for SQL"
+      },
+      {
+        value: "sql-cst",
+        label: "sql-cst",
+        package: "prettier-plugin-sql-cst",
+        hint: "Prettier for SQL (CST)"
+      },
+      {
+        value: "solidity",
+        label: "solidity",
+        package: "prettier-plugin-solidity",
+        hint: "Prettier for Solidity"
+      },
+      {
+        value: "svelte",
+        label: "svelte",
+        package: "prettier-plugin-svelte",
+        hint: "Prettier for Svelte"
+      },
+      {
+        value: "toml",
+        label: "toml",
+        package: "prettier-plugin-toml",
+        hint: "Prettier for TOML"
+      },
+      {
+        value: "xquery",
+        label: "xquery",
+        package: "prettier-plugin-xquery",
+        hint: "Prettier for XQuery"
+      },
+      // Existing
+      {
+        value: "tailwindcss",
+        label: "tailwindcss",
+        package: "prettier-plugin-tailwindcss",
+        hint: "Prettier for Tailwind CSS"
+      },
+      {
+        value: "organize-imports",
+        label: "organize-imports",
+        package: "prettier-plugin-organize-imports",
+        hint: "Organize imports"
+      },
+      {
+        value: "sort-imports",
+        label: "sort-imports",
+        package: "@trivago/prettier-plugin-sort-imports",
+        hint: "Sort imports"
+      },
+      {
+        value: "pkg",
+        label: "pkg",
+        package: "prettier-plugin-pkg",
+        hint: "Format package.json"
+      }
+    ];
+    PLUGINS = {
+      eslint: ESLINT_PLUGINS,
+      prettier: PRETTIER_PLUGINS
+    };
+    PLUGINABLE_TOOLS = Object.keys(PLUGINS);
+  }
+});
+
+// src/features/linter/eslint.ts
+import fs4 from "fs-extra";
+async function installEslint() {
+  const packages = ["eslint", "globals", "@eslint/js", "typescript-eslint"];
+  await installPackages(packages, true);
+  const configFile = await resolveConfigFile("ESLint", [
+    "eslint.config.mjs",
+    "eslint.config.js",
+    "eslint.config.cjs"
+  ]);
+  if (!await fs4.pathExists(configFile)) {
+    await fs4.writeFile(
+      configFile,
+      `import globals from "globals";
+import pluginJs from "@eslint/js";
+import tseslint from "typescript-eslint";
+
+
+export default [
+  {files: ["**/*.{js,mjs,cjs,ts}"]},
+  {languageOptions: { globals: globals.browser }},
+  pluginJs.configs.recommended,
+  ...tseslint.configs.recommended,
+];`
+    );
+  }
+}
+async function configureEslintPlugins(plugins) {
+  const configFile = await resolveConfigFile("ESLint", [
+    "eslint.config.mjs",
+    "eslint.config.js",
+    "eslint.config.cjs"
+  ]);
+  if (!await fs4.pathExists(configFile)) {
+    return;
+  }
+  let configContent = await fs4.readFile(configFile, "utf-8");
+  const newImports = [];
+  const newPluginConfigs = [];
+  for (const pluginName of plugins) {
+    const pluginDef = PLUGINS.eslint.find((p) => p.value === pluginName);
+    const packageName = pluginDef?.package || `eslint-plugin-${pluginName}`;
+    const safeVarName = pluginName.replace(/[^a-zA-Z0-9]/g, "") + "Plugin";
+    if (!configContent.includes(`import ${safeVarName}`)) {
+      newImports.push(`import ${safeVarName} from "${packageName}";`);
+    }
+    const shorPluginName = pluginName.replace(/^eslint-plugin-/, "");
+    newPluginConfigs.push(`"${shorPluginName}": ${safeVarName}`);
+  }
+  if (newImports.length > 0) {
+    const lastImportIndex = configContent.lastIndexOf("import ");
+    const endOfLastImport = configContent.indexOf("\n", lastImportIndex) + 1;
+    configContent = configContent.slice(0, endOfLastImport) + newImports.join("\n") + "\n" + configContent.slice(endOfLastImport);
+  }
+  if (newPluginConfigs.length > 0) {
+    const exportDefaultStart = configContent.indexOf("export default [");
+    if (exportDefaultStart !== -1) {
+      const pluginsBlock = `
+  {
+    plugins: {
+      ${newPluginConfigs.join(",\n      ")}
+    }
+  },`;
+      const insertPos = exportDefaultStart + "export default [".length;
+      configContent = configContent.slice(0, insertPos) + pluginsBlock + configContent.slice(insertPos);
     }
   }
+  await fs4.writeFile(configFile, configContent);
 }
-var init_handle_cancel = __esm({
-  "src/utils/handle-cancel.ts"() {
+var init_eslint = __esm({
+  "src/features/linter/eslint.ts"() {
     "use strict";
     init_esm_shims();
+    init_pm();
+    init_plugins();
+    init_config_file();
   }
 });
 
-// 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
+// src/steps/install-plugin.ts
+import pc3 from "picocolors";
+async function installPlugins(tool) {
+  const pluginsList = PLUGINS[tool];
+  const selectedPlugins = await withCancelHandling(
+    async () => prompts.multiselect({
+      message: `Select ${tool} plugins to install:`,
+      options: pluginsList,
+      required: true,
+      initialValue: []
     })
   );
-  const huskyConfig = config2.get("husky");
-  huskyConfig.options = { hookType };
-  if (hookType === "lintStaged") {
-    config2.enableTool("lintStaged");
-  } else if (hookType === "custom") {
-    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;
+  if (selectedPlugins.length === 0) {
+    prompts.outro(pc3.yellow("No plugins selected."));
+    return;
   }
+  const packagesToInstall = selectedPlugins.map((val) => {
+    const p = pluginsList.find((opt) => opt.value === val);
+    return p ? p.package : val;
+  });
+  prompts.outro(
+    pc3.blue(`Installing ${packagesToInstall.length} plugins for ${tool}...`)
+  );
+  await installPackages(packagesToInstall, true);
+  await configurePlugins(tool, selectedPlugins);
 }
-async function installHusky(config2) {
-  await installPackages(["husky"], true);
-  try {
-    await execa2("npx", ["husky", "init"]);
-  } catch (e) {
-    await execa2("npm", ["pkg", "set", "scripts.prepare=husky"]);
-    await execa2("npm", ["run", "prepare"]);
+async function configurePlugins(tool, plugins) {
+  const shouldConfigure = await withCancelHandling(
+    async () => prompts.confirm({
+      message: `Do you want to configure the selected plugins in your ${tool} config file?`,
+      initialValue: true
+    })
+  );
+  if (!shouldConfigure) {
+    prompts.outro(pc3.yellow("Skipping configuration."));
+    return;
   }
-  const husky = config2.get("husky");
-  const hookType = husky.options.hookType;
-  const customScript = husky.options.customScript;
-  if (hookType === "lintStaged") {
-    await fs.outputFile(".husky/pre-commit", "npx lint-staged\n", {
-      mode: 493
-    });
-  } else if (hookType === "custom" && customScript) {
-    await fs.outputFile(".husky/pre-commit", `${customScript}
-`, {
-      mode: 493
-    });
+  switch (tool) {
+    case "prettier":
+      await configurePrettierPlugins(plugins);
+      prompts.outro(pc3.green("Prettier plugins configured in .prettierrc"));
+      break;
+    case "eslint":
+      await configureEslintPlugins(plugins);
+      prompts.outro(pc3.green("ESLint plugins configured in .eslintrc.json"));
+      break;
   }
 }
-var init_husky = __esm({
-  "src/services/husky.ts"() {
+var init_install_plugin = __esm({
+  "src/steps/install-plugin.ts"() {
     "use strict";
     init_esm_shims();
-    init_pm();
-    init_options();
+    init_plugins();
+    init_prettier();
+    init_eslint();
     init_handle_cancel();
+    init_pm();
+    init_prompts();
   }
 });
 
-// src/services/formatter.ts
-import { select as select2, log as log2 } from "@clack/prompts";
-import fs2 from "fs-extra";
-import pc2 from "picocolors";
+// src/features/formatter.ts
+import pc4 from "picocolors";
 async function promptFormatter(config2) {
   const formatterConfig = config2.get("formatter");
-  log2.message(pc2.bgBlue(pc2.black(" Formatter Configuration ")));
+  prompts.log.message(pc4.bgBlue(pc4.white(" Formatter Configuration ")));
   const formatter = await withCancelHandling(
-    async () => select2({
+    async () => prompts.select({
       message: "Select a formatter:",
       options: FORMATTER_OPTIONS,
       initialValue: formatterConfig.options.choice
@@ -259,40 +1892,54 @@ async function promptFormatter(config2) {
   formatterConfig.options = { choice: formatter };
 }
 async function installFormatter(config2) {
-  const choice = config2.get("formatter").options.choice;
-  if (choice === "prettier") {
-    await installPackages(["prettier"], true);
-    const configContent = {
-      semi: true,
-      singleQuote: true,
-      trailingComma: "all",
-      printWidth: 80,
-      tabWidth: 2
-    };
-    await fs2.writeJson(".prettierrc", configContent, { spaces: 2 });
-  } else if (choice === "oxfmt") {
-    await installPackages(["oxfmt"], true);
-  }
+  const formatter = config2.get("formatter").options.choice;
+  if (!formatter) return;
+  prompts.log.message(pc4.white(pc4.bgBlack(` Installing ${formatter}... `)));
+  if (formatter === "prettier") await installPrettier();
+  else if (formatter === "oxfmt") await installOxfmt();
+  if (!PLUGINABLE_TOOLS.includes(formatter)) return;
+  const shouldConfigure = await withCancelHandling(
+    async () => prompts.confirm({
+      message: `Do you want to install plugins for ${formatter}?`,
+      initialValue: true
+    })
+  );
+  if (!shouldConfigure) return;
+  await installPlugins(formatter);
 }
 var init_formatter = __esm({
-  "src/services/formatter.ts"() {
+  "src/features/formatter.ts"() {
     "use strict";
     init_esm_shims();
-    init_pm();
+    init_prompts();
     init_options();
     init_handle_cancel();
+    init_prettier();
+    init_oxfmt();
+    init_plugins();
+    init_install_plugin();
   }
 });
 
-// src/services/linter.ts
-import { select as select3, log as log3 } from "@clack/prompts";
-import fs3 from "fs-extra";
-import pc3 from "picocolors";
+// src/features/linter/oxlint.ts
+async function installOxlint() {
+  await installPackages(["oxlint@latest"], true);
+}
+var init_oxlint = __esm({
+  "src/features/linter/oxlint.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_pm();
+  }
+});
+
+// src/features/linter.ts
+import pc5 from "picocolors";
 async function promptLinter(config2) {
   const linterConfig = config2.get("linter");
-  log3.message(pc3.bgYellow(pc3.black(" Linter Configuration ")));
+  prompts.log.message(pc5.bgYellow(pc5.black(" Linter Configuration ")));
   const linter = await withCancelHandling(
-    async () => select3({
+    async () => prompts.select({
       message: "Select a linter:",
       options: LINTER_OPTIONS,
       initialValue: linterConfig.options.choice
@@ -301,50 +1948,48 @@ async function promptLinter(config2) {
   linterConfig.options = { choice: linter };
 }
 async function installLinter(config2) {
-  const choice = config2.get("linter").options.choice;
-  if (choice === "eslint") {
-    await installPackages(["eslint"], true);
-    const configContent = {
-      extends: ["eslint:recommended"],
-      env: {
-        node: true,
-        es2021: true
-      },
-      parserOptions: {
-        ecmaVersion: "latest",
-        sourceType: "module"
-      }
-    };
-    await fs3.writeJson(".eslintrc.json", configContent, { spaces: 2 });
-  } else if (choice === "oxlint") {
-    await installPackages(["oxlint"], true);
-  }
+  const linter = config2.get("linter").options.choice;
+  if (!linter) return;
+  prompts.log.message(pc5.white(pc5.bgBlack(` Installing ${linter}... `)));
+  if (linter === "eslint") await installEslint();
+  else if (linter === "oxlint") await installOxlint();
+  if (!PLUGINABLE_TOOLS.includes(linter)) return;
+  const shouldConfigure = await withCancelHandling(
+    async () => prompts.confirm({
+      message: `Do you want to install plugins for ${linter}?`,
+      initialValue: true
+    })
+  );
+  if (!shouldConfigure) return;
+  await installPlugins(linter);
 }
 var init_linter = __esm({
-  "src/services/linter.ts"() {
+  "src/features/linter.ts"() {
     "use strict";
     init_esm_shims();
-    init_pm();
+    init_prompts();
     init_options();
     init_handle_cancel();
+    init_eslint();
+    init_oxlint();
+    init_plugins();
+    init_install_plugin();
   }
 });
 
-// src/services/lint-staged.ts
-import { multiselect, log as log4 } from "@clack/prompts";
-import fs4 from "fs-extra";
-import pc4 from "picocolors";
+// src/features/lint-staged.ts
+import pc6 from "picocolors";
 async function promptLintStaged(config2) {
-  log4.message(pc4.bgGreen(pc4.black(" Lint-staged Configuration ")));
+  prompts.log.message(pc6.bgGreen(pc6.black(" Lint-staged Configuration ")));
   const lintExtensions = await withCancelHandling(
-    async () => multiselect({
+    async () => prompts.multiselect({
       message: "Select extensions to lint:",
       options: LINT_STAGED_EXTENSIONS,
       required: false
     })
   );
   const formatExtensions = await withCancelHandling(
-    async () => multiselect({
+    async () => prompts.multiselect({
       message: "Select extensions to format:",
       options: LINT_STAGED_EXTENSIONS,
       required: false
@@ -365,6 +2010,13 @@ async function promptLintStaged(config2) {
 }
 async function installLintStaged(config2) {
   await installPackages(["lint-staged"], true);
+  const configFile = await resolveConfigFile("Lint-Staged", [
+    ".lintstagedrc",
+    ".lintstagedrc.json",
+    "lint-staged.config.js",
+    ".lintstagedrc.js",
+    ".lintstagedrc.mjs"
+  ]);
   const lintStagedConfig = {};
   const lintStagedOptions = config2.get("lintStaged").options;
   const lintExts = lintStagedOptions?.lintExtensions || [];
@@ -387,48 +2039,49 @@ async function installLintStaged(config2) {
       lintStagedConfig[glob] = ["prettier --write"];
     }
   }
-  await fs4.writeJson(".lintstagedrc", lintStagedConfig, { spaces: 2 });
+  await writeConfig(configFile, lintStagedConfig);
 }
 var init_lint_staged = __esm({
-  "src/services/lint-staged.ts"() {
+  "src/features/lint-staged.ts"() {
     "use strict";
     init_esm_shims();
+    init_prompts();
     init_pm();
     init_formatter();
     init_linter();
     init_options();
     init_handle_cancel();
+    init_config_file();
   }
 });
 
-// src/services/env.ts
-import { select as select4, confirm as confirm2, text as text2, multiselect as multiselect2, log as log5 } from "@clack/prompts";
+// src/features/env.ts
 import fs5 from "fs-extra";
-import path2 from "path";
-import pc5 from "picocolors";
+import path3 from "path";
+import pc7 from "picocolors";
 async function promptEnv(config2) {
-  log5.message(pc5.bgCyan(pc5.black(" Env Validation Configuration ")));
+  prompts.log.message(pc7.bgCyan(pc7.black(" Env Validation Configuration ")));
   const variant = await withCancelHandling(
-    async () => select4({
+    async () => prompts.select({
       message: "Which @t3-oss/env variant?",
       options: ENV_VARIANT_OPTIONS
     })
   );
   const validator = await withCancelHandling(
-    async () => select4({
+    async () => prompts.select({
       message: "Which validator?",
       options: ENV_VALIDATOR_OPTIONS
     })
   );
   const installPresets = await withCancelHandling(
-    async () => confirm2({
+    async () => prompts.confirm({
       message: "Install presets?"
     })
   );
   let presets;
   if (installPresets) {
     presets = await withCancelHandling(
-      async () => multiselect2({
+      async () => prompts.multiselect({
         message: "Select preset to extend:",
         options: ENV_PRESET_OPTIONS,
         required: false
@@ -436,13 +2089,13 @@ async function promptEnv(config2) {
     );
   }
   const split = await withCancelHandling(
-    async () => select4({
+    async () => prompts.select({
       message: "Split or Joined env files?",
       options: ENV_SPLIT_OPTIONS
     })
   );
   const location = await withCancelHandling(
-    async () => text2({
+    async () => prompts.text({
       message: "Where should the environment files be created?",
       initialValue: config2.get("env").options.location || "src/lib",
       placeholder: "src/lib"
@@ -460,7 +2113,7 @@ async function promptEnv(config2) {
 async function installEnv(config2) {
   const envOptions = config2.get("env").options;
   const { variant, validator, location, presets, split } = envOptions;
-  await installPackages([variant, validator], true);
+  await installPackages([variant, validator], false);
   await fs5.ensureDir(location);
   const presetImport = presets && presets.length > 0 ? `// Presets: ${presets.join(", ")}
 ` : "";
@@ -470,7 +2123,7 @@ import { ${validator} } from "${validator}";
 ${presetImport}`;
   if (split === "split") {
     await fs5.outputFile(
-      path2.join(location, "env/server.ts"),
+      path3.join(location, "env/server.ts"),
       `${content}
 // Server env definition
 export const env = createEnv({
@@ -481,7 +2134,7 @@ export const env = createEnv({
 });`
     );
     await fs5.outputFile(
-      path2.join(location, "env/client.ts"),
+      path3.join(location, "env/client.ts"),
       `${content}
 // Client env definition
 export const env = createEnv({
@@ -495,7 +2148,7 @@ export const env = createEnv({
     );
   } else {
     await fs5.outputFile(
-      path2.join(location, "env.ts"),
+      path3.join(location, "env.ts"),
       `${content}
 // Joined env definition
 export const env = createEnv({
@@ -513,23 +2166,23 @@ export const env = createEnv({
   }
 }
 var init_env = __esm({
-  "src/services/env.ts"() {
+  "src/features/env.ts"() {
     "use strict";
     init_esm_shims();
+    init_prompts();
     init_pm();
     init_options();
     init_handle_cancel();
   }
 });
 
-// src/services/test.ts
-import { select as select5, log as log6 } from "@clack/prompts";
+// src/features/test.ts
 import fs6 from "fs-extra";
-import pc6 from "picocolors";
+import pc8 from "picocolors";
 async function promptTest(config2) {
-  log6.message(pc6.bgRed(pc6.black(" Test Runner Configuration ")));
+  prompts.log.message(pc8.bgRed(pc8.white(" Test Runner Configuration ")));
   const runner = await withCancelHandling(
-    async () => select5({
+    async () => prompts.select({
       message: "Select a test runner:",
       options: TEST_RUNNER_OPTIONS
     })
@@ -571,24 +2224,24 @@ module.exports = {
   }
 }
 var init_test = __esm({
-  "src/services/test.ts"() {
+  "src/features/test.ts"() {
     "use strict";
     init_esm_shims();
+    init_prompts();
     init_pm();
     init_options();
     init_handle_cancel();
   }
 });
 
-// src/services/editor-config.ts
-import { select as select6, log as log7 } from "@clack/prompts";
+// src/features/editor-config.ts
 import fs7 from "fs-extra";
-import pc7 from "picocolors";
+import pc9 from "picocolors";
 async function promptEditorConfig(config2) {
-  log7.message(pc7.bgWhite(pc7.black(" EditorConfig Configuration ")));
+  prompts.log.message(pc9.bgWhite(pc9.black(" EditorConfig Configuration ")));
   const currentPreset = config2.get("editorConfig").options.preset;
   const preset = await withCancelHandling(
-    async () => select6({
+    async () => prompts.select({
       message: "Select EditorConfig preset:",
       options: EDITOR_CONFIG_OPTIONS,
       initialValue: currentPreset
@@ -609,45 +2262,45 @@ async function installEditorConfig(config2) {
   await fs7.outputFile(".editorconfig", content);
 }
 var init_editor_config = __esm({
-  "src/services/editor-config.ts"() {
+  "src/features/editor-config.ts"() {
     "use strict";
     init_esm_shims();
+    init_prompts();
     init_options();
     init_handle_cancel();
   }
 });
 
-// src/services/license.ts
-import { text as text3, select as select7, log as log8 } from "@clack/prompts";
+// src/features/license.ts
 import fs8 from "fs-extra";
-import path3 from "path";
-import pc8 from "picocolors";
+import path4 from "path";
+import pc10 from "picocolors";
 async function promptLicense(config2) {
-  log8.message(pc8.bgGreen(pc8.black(" License Configuration ")));
+  prompts.log.message(pc10.bgGreen(pc10.black(" License Configuration ")));
   const licenseOptions = config2.get("license").options;
   licenseOptions.name = await withCancelHandling(
-    async () => text3({
+    async () => prompts.text({
       message: "License Holder Name:",
       placeholder: "John Doe",
       initialValue: licenseOptions.name
     })
   );
   licenseOptions.email = await withCancelHandling(
-    async () => text3({
+    async () => prompts.text({
       message: "License Holder Email:",
       placeholder: "john@example.com",
       initialValue: licenseOptions.email
     })
   );
   licenseOptions.website = await withCancelHandling(
-    async () => text3({
+    async () => prompts.text({
       message: "License Holder Website:",
       placeholder: "https://example.com",
       initialValue: licenseOptions.website
     })
   );
   licenseOptions.type = await withCancelHandling(
-    async () => select7({
+    async () => prompts.select({
       message: "Select License Type:",
       options: LICENSE_TYPE_OPTIONS
     })
@@ -658,7 +2311,7 @@ async function installLicense(config2) {
   const { type, name, email, website } = licenseOptions;
   if (type !== "UNLICENSED") {
     const year = (/* @__PURE__ */ new Date()).getFullYear().toString();
-    const templatePath = path3.join(__dirname, "licenses", `${type}.txt`);
+    const templatePath = path4.join(__dirname, "licenses", `${type}.txt`);
     if (await fs8.pathExists(templatePath)) {
       let licenseContent = await fs8.readFile(templatePath, "utf-8");
       licenseContent = licenseContent.replace(/{YEAR}/g, year);
@@ -682,19 +2335,20 @@ Licensed under ${type}`;
   }
 }
 var init_license = __esm({
-  "src/services/license.ts"() {
+  "src/features/license.ts"() {
     "use strict";
     init_esm_shims();
+    init_prompts();
     init_options();
     init_handle_cancel();
   }
 });
 
-// src/config/config.ts
-import pc9 from "picocolors";
+// src/core/config.ts
+import pc11 from "picocolors";
 var Config, config;
 var init_config = __esm({
-  "src/config/config.ts"() {
+  "src/core/config.ts"() {
     "use strict";
     init_esm_shims();
     Config = class {
@@ -725,7 +2379,50 @@ var init_config = __esm({
               installPresets: false,
               presets: [],
               split: "split",
-              location: "src/env"
+              location: "src/lib"
+            }
+          },
+          test: {
+            selected: false,
+            options: { runner: "vitest" }
+          },
+          editorConfig: {
+            selected: false,
+            options: { preset: "default" }
+          },
+          license: {
+            selected: false,
+            options: { name: "", email: "", website: "", type: "MIT" }
+          }
+        };
+      }
+      clear() {
+        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/lib"
             }
           },
           test: {
@@ -750,47 +2447,47 @@ var init_config = __esm({
       }
       get summary() {
         const lines = [];
-        lines.push(pc9.bold("The following actions will be performed:"));
+        lines.push(pc11.bold("The following actions will be performed:"));
         lines.push("");
         if (this.data.husky.selected) {
-          lines.push(pc9.magenta(`\u2022 Install and configure Husky`));
+          lines.push(pc11.magenta(`\u2022 Install and configure Husky`));
           if (this.data.husky.options.hookType === "custom") {
-            lines.push(pc9.dim(`  - Custom hook script`));
+            lines.push(pc11.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"}`));
+          lines.push(pc11.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"}`));
+          lines.push(pc11.yellow(`\u2022 Install and configure ${choice || "Linter"}`));
         }
         if (this.data.lintStaged.selected) {
-          lines.push(pc9.green(`\u2022 Install and configure Lint-staged`));
+          lines.push(pc11.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 (lintExts) lines.push(pc11.dim(`  - Lint: ${lintExts}`));
+          if (formatExts) lines.push(pc11.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}`));
+          lines.push(pc11.cyan(`\u2022 Install and configure Env Validation`));
+          lines.push(pc11.dim(`  - Variant: ${this.data.env.options.variant}`));
+          lines.push(pc11.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})`));
+          lines.push(pc11.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})`));
+          lines.push(pc11.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}`));
+          lines.push(pc11.green(`\u2022 Create LICENSE (${type})`));
+          lines.push(pc11.dim(`  - Holder: ${name}`));
         }
         return lines.join("\n");
       }
@@ -799,8 +2496,56 @@ var init_config = __esm({
   }
 });
 
+// src/utils/spinner.ts
+import spinners from "cli-spinners";
+import pc12 from "picocolors";
+var Spinner, spinner;
+var init_spinner = __esm({
+  "src/utils/spinner.ts"() {
+    "use strict";
+    init_esm_shims();
+    Spinner = class {
+      timer = null;
+      frameIndex = 0;
+      spinner = spinners.dots;
+      text = "";
+      start(text2) {
+        this.text = text2;
+        this.frameIndex = 0;
+        if (this.timer) clearInterval(this.timer);
+        this.timer = setInterval(() => {
+          const frame = this.spinner.frames[this.frameIndex];
+          process.stdout.write(`\r${pc12.magenta(frame)} ${this.text}`);
+          this.frameIndex = (this.frameIndex + 1) % this.spinner.frames.length;
+        }, this.spinner.interval);
+      }
+      stop(text2) {
+        if (this.timer) {
+          clearInterval(this.timer);
+          this.timer = null;
+          process.stdout.write("\r\x1B[K");
+          if (text2) {
+            console.log(text2);
+          }
+        }
+      }
+      success(text2) {
+        this.stop();
+        console.log(`${pc12.green("\u2714")} ${text2 || this.text}`);
+      }
+      fail(text2) {
+        this.stop();
+        console.log(`${pc12.red("\u2716")} ${text2 || this.text}`);
+      }
+      message(text2) {
+        this.text = text2;
+      }
+    };
+    spinner = () => new Spinner();
+  }
+});
+
 // src/steps/execution.ts
-import { spinner } from "@clack/prompts";
 async function execution(config2) {
   const s = spinner();
   if (config2.get("husky").selected) {
@@ -851,6 +2596,7 @@ var init_execution = __esm({
   "src/steps/execution.ts"() {
     "use strict";
     init_esm_shims();
+    init_spinner();
     init_husky();
     init_formatter();
     init_linter();
@@ -864,16 +2610,16 @@ var init_execution = __esm({
 
 // src/utils/logger.ts
 import fs9 from "fs-extra";
-import path4 from "path";
+import path5 from "path";
 async function logError(error) {
   try {
     await fs9.ensureDir(ERRORS_DIR);
-    const gitignorePath = path4.join(LOG_DIR, ".gitignore");
+    const gitignorePath = path5.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 logFile = path5.join(ERRORS_DIR, `log-${timestamp}.txt`);
     const errorMessage = error instanceof Error ? error.stack || error.message : String(error);
     const logContent = `Timestamp: ${(/* @__PURE__ */ new Date()).toISOString()}
 
@@ -893,7 +2639,7 @@ var init_logger = __esm({
     "use strict";
     init_esm_shims();
     LOG_DIR = ".mayrlabs/setup-project";
-    ERRORS_DIR = path4.join(LOG_DIR, "errors");
+    ERRORS_DIR = path5.join(LOG_DIR, "errors");
   }
 });
 
@@ -927,15 +2673,14 @@ var init_git = __esm({
 });
 
 // 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({
+      const shouldCommit = await prompts.confirm({
         message: "Your working directory is dirty. Would you like to commit changes before proceeding?"
       });
       if (shouldCommit) {
-        const message = await text4({
+        const message = await prompts.text({
           message: "Enter commit message:",
           placeholder: "wip: pre-setup commit",
           validate(value) {
@@ -943,7 +2688,7 @@ async function gitCheck() {
           }
         });
         if (typeof message === "string") {
-          const s = spinner2();
+          const s = spinner();
           s.start("Committing changes...");
           await commitChanges(message);
           s.stop("Changes committed.");
@@ -957,6 +2702,8 @@ var init_git_check = __esm({
     "use strict";
     init_esm_shims();
     init_git();
+    init_prompts();
+    init_spinner();
   }
 });
 
@@ -966,53 +2713,57 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@mayrlabs/setup-project",
-      version: "0.1.7",
-      description: "Interactive CLI to setup project tools",
+      version: "0.1.9",
       private: false,
-      publishConfig: {
-        access: "public"
-      },
+      description: "Interactive CLI to setup project tools",
       keywords: [
-        "setup",
         "cli",
-        "scaffold",
+        "eslint",
         "husky",
         "prettier",
-        "eslint"
-      ],
-      bin: {
-        "setup-project": "dist/index.js"
-      },
-      files: [
-        "dist",
-        "README.md",
-        "CHANGELOG.md",
-        "package.json"
+        "scaffold",
+        "setup"
       ],
       homepage: "https://github.com/MayR-Labs/mayrlabs-js/tree/main/packages/setup-project#readme",
       bugs: {
         url: "https://github.com/MayR-Labs/mayrlabs-js/issues"
       },
-      repository: {
-        type: "git",
-        url: "git+https://github.com/MayR-Labs/mayrlabs-js.git",
-        directory: "packages/setup-project"
-      },
       license: "MIT",
       author: {
         name: "Aghogho Meyoron",
         email: "youngmayor.dev@gmail.com",
         url: "https://mayrlabs.com"
       },
+      repository: {
+        type: "git",
+        url: "git+https://github.com/MayR-Labs/mayrlabs-js.git",
+        directory: "packages/setup-project"
+      },
+      bin: {
+        "setup-project": "dist/index.js"
+      },
+      files: [
+        "dist",
+        "README.md",
+        "CHANGELOG.md",
+        "package.json"
+      ],
       type: "commonjs",
       main: "dist/index.js",
+      publishConfig: {
+        access: "public"
+      },
       scripts: {
         build: "tsup",
-        demo: "tsx src/index.ts",
+        lint: "eslint . --max-warnings 0",
+        demo: "tsx src/cli/index.ts",
+        test: "vitest",
         prepublishOnly: "npm run build"
       },
       dependencies: {
         "@clack/prompts": "^0.7.0",
+        "@topcli/prompts": "^2.4.1",
+        "cli-spinners": "^3.4.0",
         commander: "^11.1.0",
         execa: "^8.0.1",
         figlet: "^1.10.0",
@@ -1021,24 +2772,28 @@ var init_package = __esm({
         zod: "^3.22.4"
       },
       devDependencies: {
+        "@repo/eslint-config": "^0.0.0",
         "@types/figlet": "^1.7.0",
         "@types/fs-extra": "^11.0.4",
         "@types/node": "^20.11.16",
+        "@vitest/coverage-v8": "^4.0.18",
+        eslint: "^9.39.2",
         tsup: "^8.5.1",
         tsx: "^4.21.0",
-        typescript: "^5.3.3"
+        typescript: "^5.3.3",
+        vitest: "^4.0.18"
       }
     };
   }
 });
 
 // src/utils/display.ts
-import pc10 from "picocolors";
+import pc13 from "picocolors";
 import figlet from "figlet";
 function introScreen() {
   console.log();
   console.log(
-    pc10.cyan(
+    pc13.cyan(
       figlet.textSync("MayR\nLabs", {
         font: "Graceful",
         horizontalLayout: "default",
@@ -1048,39 +2803,41 @@ function introScreen() {
       })
     )
   );
-  console.log(pc10.cyan(`@mayrlabs/setup-project v${package_default.version}`));
+  console.log(pc13.cyan(`${package_default.name} - v${package_default.version}`));
   console.log();
 }
 function showAbout() {
   introScreen();
-  console.log(pc10.bold("About:"));
+  console.log(pc13.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(pc13.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(pc13.bold("Project Homepage:"));
+  console.log(pc13.underline(pc13.cyan(package_default.homepage)));
   console.log("");
 }
 function showManual() {
   introScreen();
-  console.log(pc10.bold("Usage:"));
+  console.log(pc13.bold("Usage:"));
   console.log("  npx @mayrlabs/setup-project [command] [options]");
   console.log("");
-  console.log(pc10.bold("Commands:"));
+  console.log(pc13.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("  configure [tool]   Configure a specific tool");
+  console.log("  plugin [tool]      Manage plugins for tools");
   console.log("");
-  console.log(pc10.bold("Options:"));
+  console.log(pc13.bold("Options:"));
   console.log("  -a, --about        Show project details");
   console.log("  -v, --version      Show version information");
   console.log("  -V, --visit        Visit project homepage");
@@ -1095,13 +2852,135 @@ var init_display = __esm({
   }
 });
 
-// src/index.ts
-import { outro, multiselect as multiselect3, note, confirm as confirm4, intro } from "@clack/prompts";
-import pc11 from "picocolors";
+// src/cli/commands/configure.ts
+import pc14 from "picocolors";
+async function configure(toolName) {
+  introScreen();
+  prompts.intro(pc14.inverse(pc14.bold(pc14.blue(" Configuration Mode "))));
+  await gitCheck();
+  let selectedTool;
+  if (toolName) {
+    const tool = TOOL_OPTIONS.find((t) => t.value === toolName);
+    if (tool) {
+      selectedTool = tool.value;
+    } else {
+      console.log(
+        pc14.yellow(`Tool '${toolName}' not found or not configurable.`)
+      );
+    }
+  }
+  if (!selectedTool) {
+    const selection = await withCancelHandling(
+      async () => prompts.select({
+        message: "Select a tool to configure:",
+        options: TOOL_OPTIONS
+      })
+    );
+    selectedTool = selection;
+  }
+  config.enableTool(selectedTool);
+  try {
+    switch (selectedTool) {
+      case "husky":
+        await promptHusky(config);
+        await installHusky(config);
+        break;
+      case "formatter":
+        await promptFormatter(config);
+        await installFormatter(config);
+        break;
+      case "linter":
+        await promptLinter(config);
+        await installLinter(config);
+        break;
+      case "lintStaged":
+        await promptLintStaged(config);
+        await installLintStaged(config);
+        break;
+      case "env":
+        await promptEnv(config);
+        await installEnv(config);
+        break;
+      case "test":
+        await promptTest(config);
+        await installTest(config);
+        break;
+      case "editorConfig":
+        await promptEditorConfig(config);
+        await installEditorConfig(config);
+        break;
+      case "license":
+        await promptLicense(config);
+        await installLicense(config);
+        break;
+    }
+    prompts.outro(pc14.green(`${selectedTool} configured successfully!`));
+  } catch (error) {
+    prompts.outro(pc14.red(`Failed to configure ${selectedTool}.`));
+    console.error(error);
+    process.exit(1);
+  }
+}
+var init_configure = __esm({
+  "src/cli/commands/configure.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_prompts();
+    init_config();
+    init_options();
+    init_husky();
+    init_formatter();
+    init_linter();
+    init_lint_staged();
+    init_env();
+    init_test();
+    init_editor_config();
+    init_license();
+    init_handle_cancel();
+    init_display();
+    init_git_check();
+  }
+});
+
+// src/cli/commands/plugin.ts
+import pc15 from "picocolors";
+async function plugin(toolName) {
+  introScreen();
+  prompts.intro(pc15.inverse(pc15.bold(pc15.magenta(" Plugin Manager "))));
+  await gitCheck();
+  if (!toolName) {
+    toolName = await withCancelHandling(
+      async () => prompts.select({
+        message: "Select a tool to add plugins to:",
+        options: [
+          { value: "eslint", label: "ESLint" },
+          { value: "prettier", label: "Prettier" }
+        ]
+      })
+    );
+  }
+  await installPlugins(toolName);
+  prompts.outro(pc15.green("Plugins installed successfully!"));
+}
+var init_plugin = __esm({
+  "src/cli/commands/plugin.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_prompts();
+    init_handle_cancel();
+    init_display();
+    init_git_check();
+    init_install_plugin();
+  }
+});
+
+// src/cli/index.ts
+import pc16 from "picocolors";
 import { program } from "commander";
 var require_index = __commonJS({
-  "src/index.ts"() {
+  "src/cli/index.ts"() {
     init_esm_shims();
+    init_prompts();
     init_husky();
     init_formatter();
     init_linter();
@@ -1117,15 +2996,17 @@ var require_index = __commonJS({
     init_logger();
     init_git_check();
     init_display();
+    init_configure();
+    init_plugin();
     async function main() {
       try {
         introScreen();
-        intro(
-          pc11.inverse(pc11.bold(pc11.cyan(" Welcome to the Project Setup Wizard ")))
+        prompts.intro(
+          pc16.inverse(pc16.bold(pc16.cyan(" Welcome to the Project Setup Wizard ")))
         );
         await gitCheck();
         const tools = await withCancelHandling(
-          async () => multiselect3({
+          async () => prompts.multiselect({
             message: "Select tools to configure:",
             options: TOOL_OPTIONS,
             required: false
@@ -1140,23 +3021,25 @@ var require_index = __commonJS({
         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");
+        prompts.note(config.summary, "Configuration Summary");
         const proceed = await withCancelHandling(
-          async () => confirm4({
+          async () => prompts.confirm({
             message: "Do you want to proceed with the installation?"
           })
         );
         if (!proceed) {
-          outro(pc11.yellow("Installation cancelled."));
+          prompts.outro(pc16.yellow("Installation cancelled."));
           process.exit(0);
         }
         await execution(config);
-        outro(pc11.green("Setup complete!"));
+        prompts.outro(pc16.green("Setup complete!"));
       } catch (error) {
         const logPath = await logError(error);
-        outro(pc11.red(`
+        prompts.outro(
+          pc16.red(`
 Something went wrong!
-Error log saved to: ${logPath}`));
+Error log saved to: ${logPath}`)
+        );
         process.exit(1);
       }
     }
@@ -1178,6 +3061,14 @@ Error log saved to: ${logPath}`));
       showManual();
       process.exit(0);
     });
+    program.command("configure [tool]").description("Configure a specific tool").action(async (tool) => {
+      await configure(tool);
+      process.exit(0);
+    });
+    program.command("plugin [tool]").description("Manage plugins for tools").action(async (tool) => {
+      await plugin(tool);
+      process.exit(0);
+    });
     program.action(async (options) => {
       if (options.about) {
         showAbout();