@mayrlabs/setup-project 0.1.7 → 0.1.9

package/dist/index.js

@@ -32,13 +32,222 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// src/index.ts
-var import_prompts12 = require("@clack/prompts");
-var import_picocolors11 = __toESM(require("picocolors"));
-var import_commander = require("commander");
+// src/utils/prompts/clack.ts
+var import_prompts = require("@clack/prompts");
+var ClackProvider = class {
+  intro(message) {
+    (0, import_prompts.intro)(message);
+  }
+  outro(message) {
+    (0, import_prompts.outro)(message);
+  }
+  async text(opts) {
+    return (0, import_prompts.text)(opts);
+  }
+  async confirm(opts) {
+    return (0, import_prompts.confirm)(opts);
+  }
+  async select(opts) {
+    return (0, import_prompts.select)({
+      message: opts.message,
+      options: opts.options.map((o) => ({
+        label: o.label,
+        value: o.value,
+        hint: o.hint
+      }))
+    });
+  }
+  async multiselect(opts) {
+    return (0, import_prompts.multiselect)({
+      message: opts.message,
+      options: opts.options.map((o) => ({
+        label: o.label,
+        value: o.value,
+        hint: o.hint
+      }))
+    });
+  }
+  note(message, title) {
+    (0, import_prompts.note)(message, title);
+  }
+  isCancel(value) {
+    return (0, import_prompts.isCancel)(value);
+  }
+  cancel(message) {
+    (0, import_prompts.cancel)(message);
+  }
+  log = {
+    message: (msg) => import_prompts.log.message(msg),
+    info: (msg) => import_prompts.log.info(msg),
+    success: (msg) => import_prompts.log.success(msg),
+    warn: (msg) => import_prompts.log.warn(msg),
+    error: (msg) => import_prompts.log.error(msg)
+  };
+};
+
+// src/utils/prompts/top.ts
+var import_prompts2 = require("@topcli/prompts");
+var import_picocolors = __toESM(require("picocolors"));
+var CANCEL_SYMBOL = /* @__PURE__ */ Symbol("cancel");
+var TopCliProvider = class {
+  intro(message) {
+    console.log(import_picocolors.default.bgCyan(import_picocolors.default.black(` ${message} `)));
+  }
+  outro(message) {
+    console.log(import_picocolors.default.bgCyan(import_picocolors.default.black(` ${message} `)));
+  }
+  async text(opts) {
+    try {
+      return await (0, import_prompts2.question)(opts.message, {
+        defaultValue: opts.initialValue || opts.defaultValue,
+        validators: [
+          {
+            validate: (value) => opts.validate?.(value) || ""
+          }
+        ]
+      });
+    } catch {
+      return CANCEL_SYMBOL;
+    }
+  }
+  async confirm(opts) {
+    try {
+      return await (0, import_prompts2.confirm)(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 (0, import_prompts2.select)(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 (0, import_prompts2.multiselect)(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(import_picocolors.default.blue(import_picocolors.default.bold(`${title}`)));
+    }
+    console.log(import_picocolors.default.dim(message));
+  }
+  isCancel(value) {
+    return value === CANCEL_SYMBOL;
+  }
+  cancel(message) {
+    if (message) console.log(import_picocolors.default.red(import_picocolors.default.bold("\xD7")) + " " + message);
+    else console.log(import_picocolors.default.red(import_picocolors.default.bold("\xD7")) + " Operation cancelled.");
+  }
+  log = {
+    message: (msg) => console.log(msg),
+    info: (msg) => console.log(import_picocolors.default.blue(import_picocolors.default.bold("INFO")) + " " + msg),
+    success: (msg) => console.log(import_picocolors.default.green(import_picocolors.default.bold("SUCCESS")) + " " + msg),
+    warn: (msg) => console.log(import_picocolors.default.yellow(import_picocolors.default.bold("WARN")) + " " + msg),
+    error: (msg) => console.log(import_picocolors.default.red(import_picocolors.default.bold("ERROR")) + " " + msg)
+  };
+};
+
+// src/utils/prompts/index.ts
+var 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;
+  }
+};
+var prompts = Prompts.getInstance();
 
-// src/services/husky.ts
-var import_prompts2 = require("@clack/prompts");
+// src/cli/index.ts
+var import_picocolors16 = __toESM(require("picocolors"));
+var import_commander = require("commander");
 
 // src/utils/pm.ts
 var import_execa = require("execa");
@@ -70,10 +279,10 @@ async function installPackages(packages, dev = false) {
   await (0, import_execa.execa)(pm, [...args, ...packages]);
 }
 
-// src/services/husky.ts
+// src/features/husky.ts
 var import_execa2 = require("execa");
 var import_fs_extra = __toESM(require("fs-extra"));
-var import_picocolors = __toESM(require("picocolors"));
+var import_picocolors2 = __toESM(require("picocolors"));
 
 // src/constants/options.ts
 var TOOL_OPTIONS = [
@@ -158,16 +367,15 @@ var LICENSE_TYPE_OPTIONS = [
 ];
 
 // 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)({
+    if (prompts.isCancel(response)) {
+      const shouldCancel = await prompts.confirm({
         message: "Do you really want to cancel options selection?"
       });
-      if ((0, import_prompts.isCancel)(shouldCancel) || shouldCancel) {
-        (0, import_prompts.cancel)(cancelMessage);
+      if (prompts.isCancel(shouldCancel) || shouldCancel) {
+        prompts.cancel(cancelMessage);
         process.exit(0);
       }
       continue;
@@ -177,11 +385,11 @@ async function withCancelHandling(promptFn, cancelMessage = "Operation cancelled
   }
 }
 
-// src/services/husky.ts
+// src/features/husky.ts
 async function promptHusky(config2) {
-  import_prompts2.log.message(import_picocolors.default.bgMagenta(import_picocolors.default.black(" Husky Configuration ")));
+  prompts.log.message(import_picocolors2.default.bgMagenta(import_picocolors2.default.black(" Husky Configuration ")));
   const hookType = await withCancelHandling(
-    async () => (0, import_prompts2.select)({
+    async () => prompts.select({
       message: "What pre-commit hook would you like to use?",
       options: HUSKY_HOOK_OPTIONS
     })
@@ -192,7 +400,7 @@ async function promptHusky(config2) {
     config2.enableTool("lintStaged");
   } else if (hookType === "custom") {
     const script = await withCancelHandling(
-      async () => (0, import_prompts2.text)({
+      async () => prompts.text({
         message: "Enter your custom pre-commit script:",
         placeholder: huskyConfig.options.customScript,
         validate(value) {
@@ -207,7 +415,7 @@ async function installHusky(config2) {
   await installPackages(["husky"], true);
   try {
     await (0, import_execa2.execa)("npx", ["husky", "init"]);
-  } catch (e) {
+  } catch {
     await (0, import_execa2.execa)("npm", ["pkg", "set", "scripts.prepare=husky"]);
     await (0, import_execa2.execa)("npm", ["run", "prepare"]);
   }
@@ -226,15 +434,1345 @@ async function installHusky(config2) {
   }
 }
 
-// src/services/formatter.ts
-var import_prompts3 = require("@clack/prompts");
+// src/features/formatter.ts
+var import_picocolors4 = __toESM(require("picocolors"));
+
+// src/features/formatter/prettier.ts
+var import_fs_extra3 = __toESM(require("fs-extra"));
+
+// src/utils/config-file.ts
 var import_fs_extra2 = __toESM(require("fs-extra"));
-var import_picocolors2 = __toESM(require("picocolors"));
+var import_node_path = __toESM(require("path"));
+async function resolveConfigFile(toolName, candidates) {
+  for (const file of candidates) {
+    if (await import_fs_extra2.default.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 = import_node_path.default.extname(filePath);
+  if (ext === ".json" || ext === "") {
+    await import_fs_extra2.default.writeJson(filePath, config2, { spaces: 2 });
+  } else if (ext === ".js" || ext === ".cjs") {
+    const content = `module.exports = ${JSON.stringify(config2, null, 2)};`;
+    await import_fs_extra2.default.writeFile(filePath, content);
+  } else if (ext === ".mjs") {
+    const content = `export default ${JSON.stringify(config2, null, 2)};`;
+    await import_fs_extra2.default.writeFile(filePath, content);
+  } else {
+    await import_fs_extra2.default.writeJson(filePath, config2, { spaces: 2 });
+  }
+}
+
+// src/features/formatter/prettier.ts
+async function installPrettier() {
+  await installPackages(["prettier"], true);
+  const configFile = await resolveConfigFile("Prettier", [
+    ".prettierrc",
+    ".prettierrc.json",
+    "prettier.config.js",
+    ".prettierrc.js"
+  ]);
+  if (!await import_fs_extra3.default.pathExists(configFile)) {
+    await writeConfig(configFile, {
+      semi: true,
+      singleQuote: false,
+      tabWidth: 2,
+      trailingComma: "es5",
+      printWidth: 80,
+      plugins: []
+    });
+  }
+  if (!await import_fs_extra3.default.pathExists(".prettierignore")) {
+    await import_fs_extra3.default.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 import_fs_extra3.default.pathExists(configFile)) {
+    try {
+      if (configFile.endsWith(".js") || configFile.endsWith(".cjs")) {
+        return;
+      }
+      currentConfig = await import_fs_extra3.default.readJson(configFile);
+    } catch {
+    }
+  }
+  const existingPlugins = currentConfig.plugins || [];
+  const newPlugins = [.../* @__PURE__ */ new Set([...existingPlugins, ...plugins])];
+  currentConfig.plugins = newPlugins;
+  await writeConfig(configFile, currentConfig);
+}
+
+// src/features/formatter/oxfmt.ts
+async function installOxfmt() {
+  await installPackages(["oxfmt@latest"], true);
+}
+
+// src/constants/plugins.ts
+var 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"
+  }
+];
+var 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"
+  }
+];
+var PLUGINS = {
+  eslint: ESLINT_PLUGINS,
+  prettier: PRETTIER_PLUGINS
+};
+var PLUGINABLE_TOOLS = Object.keys(PLUGINS);
+
+// src/features/linter/eslint.ts
+var import_fs_extra4 = __toESM(require("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 import_fs_extra4.default.pathExists(configFile)) {
+    await import_fs_extra4.default.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 import_fs_extra4.default.pathExists(configFile)) {
+    return;
+  }
+  let configContent = await import_fs_extra4.default.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 import_fs_extra4.default.writeFile(configFile, configContent);
+}
+
+// src/steps/install-plugin.ts
+var import_picocolors3 = __toESM(require("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: []
+    })
+  );
+  if (selectedPlugins.length === 0) {
+    prompts.outro(import_picocolors3.default.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(
+    import_picocolors3.default.blue(`Installing ${packagesToInstall.length} plugins for ${tool}...`)
+  );
+  await installPackages(packagesToInstall, true);
+  await configurePlugins(tool, selectedPlugins);
+}
+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(import_picocolors3.default.yellow("Skipping configuration."));
+    return;
+  }
+  switch (tool) {
+    case "prettier":
+      await configurePrettierPlugins(plugins);
+      prompts.outro(import_picocolors3.default.green("Prettier plugins configured in .prettierrc"));
+      break;
+    case "eslint":
+      await configureEslintPlugins(plugins);
+      prompts.outro(import_picocolors3.default.green("ESLint plugins configured in .eslintrc.json"));
+      break;
+  }
+}
+
+// src/features/formatter.ts
 async function promptFormatter(config2) {
   const formatterConfig = config2.get("formatter");
-  import_prompts3.log.message(import_picocolors2.default.bgBlue(import_picocolors2.default.black(" Formatter Configuration ")));
+  prompts.log.message(import_picocolors4.default.bgBlue(import_picocolors4.default.white(" Formatter Configuration ")));
   const formatter = await withCancelHandling(
-    async () => (0, import_prompts3.select)({
+    async () => prompts.select({
       message: "Select a formatter:",
       options: FORMATTER_OPTIONS,
       initialValue: formatterConfig.options.choice
@@ -243,31 +1781,36 @@ 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 import_fs_extra2.default.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(import_picocolors4.default.white(import_picocolors4.default.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);
 }
 
-// src/services/linter.ts
-var import_prompts4 = require("@clack/prompts");
-var import_fs_extra3 = __toESM(require("fs-extra"));
-var import_picocolors3 = __toESM(require("picocolors"));
+// src/features/linter.ts
+var import_picocolors5 = __toESM(require("picocolors"));
+
+// src/features/linter/oxlint.ts
+async function installOxlint() {
+  await installPackages(["oxlint@latest"], true);
+}
+
+// src/features/linter.ts
 async function promptLinter(config2) {
   const linterConfig = config2.get("linter");
-  import_prompts4.log.message(import_picocolors3.default.bgYellow(import_picocolors3.default.black(" Linter Configuration ")));
+  prompts.log.message(import_picocolors5.default.bgYellow(import_picocolors5.default.black(" Linter Configuration ")));
   const linter = await withCancelHandling(
-    async () => (0, import_prompts4.select)({
+    async () => prompts.select({
       message: "Select a linter:",
       options: LINTER_OPTIONS,
       initialValue: linterConfig.options.choice
@@ -276,41 +1819,35 @@ 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 import_fs_extra3.default.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(import_picocolors5.default.white(import_picocolors5.default.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);
 }
 
-// src/services/lint-staged.ts
-var import_prompts5 = require("@clack/prompts");
-var import_fs_extra4 = __toESM(require("fs-extra"));
-var import_picocolors4 = __toESM(require("picocolors"));
+// src/features/lint-staged.ts
+var import_picocolors6 = __toESM(require("picocolors"));
 async function promptLintStaged(config2) {
-  import_prompts5.log.message(import_picocolors4.default.bgGreen(import_picocolors4.default.black(" Lint-staged Configuration ")));
+  prompts.log.message(import_picocolors6.default.bgGreen(import_picocolors6.default.black(" Lint-staged Configuration ")));
   const lintExtensions = await withCancelHandling(
-    async () => (0, import_prompts5.multiselect)({
+    async () => prompts.multiselect({
       message: "Select extensions to lint:",
       options: LINT_STAGED_EXTENSIONS,
       required: false
     })
   );
   const formatExtensions = await withCancelHandling(
-    async () => (0, import_prompts5.multiselect)({
+    async () => prompts.multiselect({
       message: "Select extensions to format:",
       options: LINT_STAGED_EXTENSIONS,
       required: false
@@ -331,6 +1868,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 || [];
@@ -353,37 +1897,36 @@ async function installLintStaged(config2) {
       lintStagedConfig[glob] = ["prettier --write"];
     }
   }
-  await import_fs_extra4.default.writeJson(".lintstagedrc", lintStagedConfig, { spaces: 2 });
+  await writeConfig(configFile, lintStagedConfig);
 }
 
-// src/services/env.ts
-var import_prompts6 = require("@clack/prompts");
+// src/features/env.ts
 var import_fs_extra5 = __toESM(require("fs-extra"));
 var import_path = __toESM(require("path"));
-var import_picocolors5 = __toESM(require("picocolors"));
+var import_picocolors7 = __toESM(require("picocolors"));
 async function promptEnv(config2) {
-  import_prompts6.log.message(import_picocolors5.default.bgCyan(import_picocolors5.default.black(" Env Validation Configuration ")));
+  prompts.log.message(import_picocolors7.default.bgCyan(import_picocolors7.default.black(" Env Validation Configuration ")));
   const variant = await withCancelHandling(
-    async () => (0, import_prompts6.select)({
+    async () => prompts.select({
       message: "Which @t3-oss/env variant?",
       options: ENV_VARIANT_OPTIONS
     })
   );
   const validator = await withCancelHandling(
-    async () => (0, import_prompts6.select)({
+    async () => prompts.select({
       message: "Which validator?",
       options: ENV_VALIDATOR_OPTIONS
     })
   );
   const installPresets = await withCancelHandling(
-    async () => (0, import_prompts6.confirm)({
+    async () => prompts.confirm({
       message: "Install presets?"
     })
   );
   let presets;
   if (installPresets) {
     presets = await withCancelHandling(
-      async () => (0, import_prompts6.multiselect)({
+      async () => prompts.multiselect({
         message: "Select preset to extend:",
         options: ENV_PRESET_OPTIONS,
         required: false
@@ -391,13 +1934,13 @@ async function promptEnv(config2) {
     );
   }
   const split = await withCancelHandling(
-    async () => (0, import_prompts6.select)({
+    async () => prompts.select({
       message: "Split or Joined env files?",
       options: ENV_SPLIT_OPTIONS
     })
   );
   const location = await withCancelHandling(
-    async () => (0, import_prompts6.text)({
+    async () => prompts.text({
       message: "Where should the environment files be created?",
       initialValue: config2.get("env").options.location || "src/lib",
       placeholder: "src/lib"
@@ -415,7 +1958,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 import_fs_extra5.default.ensureDir(location);
   const presetImport = presets && presets.length > 0 ? `// Presets: ${presets.join(", ")}
 ` : "";
@@ -468,14 +2011,13 @@ export const env = createEnv({
   }
 }
 
-// src/services/test.ts
-var import_prompts7 = require("@clack/prompts");
+// src/features/test.ts
 var import_fs_extra6 = __toESM(require("fs-extra"));
-var import_picocolors6 = __toESM(require("picocolors"));
+var import_picocolors8 = __toESM(require("picocolors"));
 async function promptTest(config2) {
-  import_prompts7.log.message(import_picocolors6.default.bgRed(import_picocolors6.default.black(" Test Runner Configuration ")));
+  prompts.log.message(import_picocolors8.default.bgRed(import_picocolors8.default.white(" Test Runner Configuration ")));
   const runner = await withCancelHandling(
-    async () => (0, import_prompts7.select)({
+    async () => prompts.select({
       message: "Select a test runner:",
       options: TEST_RUNNER_OPTIONS
     })
@@ -517,15 +2059,14 @@ module.exports = {
   }
 }
 
-// src/services/editor-config.ts
-var import_prompts8 = require("@clack/prompts");
+// src/features/editor-config.ts
 var import_fs_extra7 = __toESM(require("fs-extra"));
-var import_picocolors7 = __toESM(require("picocolors"));
+var import_picocolors9 = __toESM(require("picocolors"));
 async function promptEditorConfig(config2) {
-  import_prompts8.log.message(import_picocolors7.default.bgWhite(import_picocolors7.default.black(" EditorConfig Configuration ")));
+  prompts.log.message(import_picocolors9.default.bgWhite(import_picocolors9.default.black(" EditorConfig Configuration ")));
   const currentPreset = config2.get("editorConfig").options.preset;
   const preset = await withCancelHandling(
-    async () => (0, import_prompts8.select)({
+    async () => prompts.select({
       message: "Select EditorConfig preset:",
       options: EDITOR_CONFIG_OPTIONS,
       initialValue: currentPreset
@@ -546,37 +2087,36 @@ async function installEditorConfig(config2) {
   await import_fs_extra7.default.outputFile(".editorconfig", content);
 }
 
-// src/services/license.ts
-var import_prompts9 = require("@clack/prompts");
+// src/features/license.ts
 var import_fs_extra8 = __toESM(require("fs-extra"));
 var import_path2 = __toESM(require("path"));
-var import_picocolors8 = __toESM(require("picocolors"));
+var import_picocolors10 = __toESM(require("picocolors"));
 async function promptLicense(config2) {
-  import_prompts9.log.message(import_picocolors8.default.bgGreen(import_picocolors8.default.black(" License Configuration ")));
+  prompts.log.message(import_picocolors10.default.bgGreen(import_picocolors10.default.black(" License Configuration ")));
   const licenseOptions = config2.get("license").options;
   licenseOptions.name = await withCancelHandling(
-    async () => (0, import_prompts9.text)({
+    async () => prompts.text({
       message: "License Holder Name:",
       placeholder: "John Doe",
       initialValue: licenseOptions.name
     })
   );
   licenseOptions.email = await withCancelHandling(
-    async () => (0, import_prompts9.text)({
+    async () => prompts.text({
       message: "License Holder Email:",
       placeholder: "john@example.com",
       initialValue: licenseOptions.email
     })
   );
   licenseOptions.website = await withCancelHandling(
-    async () => (0, import_prompts9.text)({
+    async () => prompts.text({
       message: "License Holder Website:",
       placeholder: "https://example.com",
       initialValue: licenseOptions.website
     })
   );
   licenseOptions.type = await withCancelHandling(
-    async () => (0, import_prompts9.select)({
+    async () => prompts.select({
       message: "Select License Type:",
       options: LICENSE_TYPE_OPTIONS
     })
@@ -611,8 +2151,8 @@ Licensed under ${type}`;
   }
 }
 
-// src/config/config.ts
-var import_picocolors9 = __toESM(require("picocolors"));
+// src/core/config.ts
+var import_picocolors11 = __toESM(require("picocolors"));
 var Config = class {
   data;
   constructor() {
@@ -641,7 +2181,50 @@ var Config = class {
           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: {
@@ -666,57 +2249,98 @@ var Config = class {
   }
   get summary() {
     const lines = [];
-    lines.push(import_picocolors9.default.bold("The following actions will be performed:"));
+    lines.push(import_picocolors11.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`));
+      lines.push(import_picocolors11.default.magenta(`\u2022 Install and configure Husky`));
       if (this.data.husky.options.hookType === "custom") {
-        lines.push(import_picocolors9.default.dim(`  - Custom hook script`));
+        lines.push(import_picocolors11.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"}`));
+      lines.push(import_picocolors11.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"}`));
+      lines.push(import_picocolors11.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`));
+      lines.push(import_picocolors11.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 (lintExts) lines.push(import_picocolors11.default.dim(`  - Lint: ${lintExts}`));
+      if (formatExts) lines.push(import_picocolors11.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}`));
+      lines.push(import_picocolors11.default.cyan(`\u2022 Install and configure Env Validation`));
+      lines.push(import_picocolors11.default.dim(`  - Variant: ${this.data.env.options.variant}`));
+      lines.push(import_picocolors11.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})`));
+      lines.push(import_picocolors11.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})`));
+      lines.push(import_picocolors11.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}`));
+      lines.push(import_picocolors11.default.green(`\u2022 Create LICENSE (${type})`));
+      lines.push(import_picocolors11.default.dim(`  - Holder: ${name}`));
     }
     return lines.join("\n");
   }
 };
 var config = new Config();
 
+// src/utils/spinner.ts
+var import_cli_spinners = __toESM(require("cli-spinners"));
+var import_picocolors12 = __toESM(require("picocolors"));
+var Spinner = class {
+  timer = null;
+  frameIndex = 0;
+  spinner = import_cli_spinners.default.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${import_picocolors12.default.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(`${import_picocolors12.default.green("\u2714")} ${text2 || this.text}`);
+  }
+  fail(text2) {
+    this.stop();
+    console.log(`${import_picocolors12.default.red("\u2716")} ${text2 || this.text}`);
+  }
+  message(text2) {
+    this.text = text2;
+  }
+};
+var spinner = () => new Spinner();
+
 // src/steps/execution.ts
-var import_prompts10 = require("@clack/prompts");
 async function execution(config2) {
-  const s = (0, import_prompts10.spinner)();
+  const s = spinner();
   if (config2.get("husky").selected) {
     s.start("Setting up Husky...");
     await installHusky(config2);
@@ -814,15 +2438,14 @@ async function commitChanges(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)({
+      const shouldCommit = await prompts.confirm({
         message: "Your working directory is dirty. Would you like to commit changes before proceeding?"
       });
       if (shouldCommit) {
-        const message = await (0, import_prompts11.text)({
+        const message = await prompts.text({
           message: "Enter commit message:",
           placeholder: "wip: pre-setup commit",
           validate(value) {
@@ -830,7 +2453,7 @@ async function gitCheck() {
           }
         });
         if (typeof message === "string") {
-          const s = (0, import_prompts11.spinner)();
+          const s = spinner();
           s.start("Committing changes...");
           await commitChanges(message);
           s.stop("Changes committed.");
@@ -841,59 +2464,63 @@ async function gitCheck() {
 }
 
 // src/utils/display.ts
-var import_picocolors10 = __toESM(require("picocolors"));
+var import_picocolors13 = __toESM(require("picocolors"));
 var import_figlet = __toESM(require("figlet"));
 
 // package.json
 var 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",
@@ -902,12 +2529,16 @@ var package_default = {
     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"
   }
 };
 
@@ -915,7 +2546,7 @@ var package_default = {
 function introScreen() {
   console.log();
   console.log(
-    import_picocolors10.default.cyan(
+    import_picocolors13.default.cyan(
       import_figlet.default.textSync("MayR\nLabs", {
         font: "Graceful",
         horizontalLayout: "default",
@@ -925,39 +2556,41 @@ function introScreen() {
       })
     )
   );
-  console.log(import_picocolors10.default.cyan(`@mayrlabs/setup-project v${package_default.version}`));
+  console.log(import_picocolors13.default.cyan(`${package_default.name} - v${package_default.version}`));
   console.log();
 }
 function showAbout() {
   introScreen();
-  console.log(import_picocolors10.default.bold("About:"));
+  console.log(import_picocolors13.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(import_picocolors13.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(import_picocolors13.default.bold("Project Homepage:"));
+  console.log(import_picocolors13.default.underline(import_picocolors13.default.cyan(package_default.homepage)));
   console.log("");
 }
 function showManual() {
   introScreen();
-  console.log(import_picocolors10.default.bold("Usage:"));
+  console.log(import_picocolors13.default.bold("Usage:"));
   console.log("  npx @mayrlabs/setup-project [command] [options]");
   console.log("");
-  console.log(import_picocolors10.default.bold("Commands:"));
+  console.log(import_picocolors13.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("  configure [tool]   Configure a specific tool");
+  console.log("  plugin [tool]      Manage plugins for tools");
   console.log("");
-  console.log(import_picocolors10.default.bold("Options:"));
+  console.log(import_picocolors13.default.bold("Options:"));
   console.log("  -a, --about        Show project details");
   console.log("  -v, --version      Show version information");
   console.log("  -V, --visit        Visit project homepage");
@@ -965,16 +2598,107 @@ function showManual() {
   console.log("");
 }
 
-// src/index.ts
+// src/cli/commands/configure.ts
+var import_picocolors14 = __toESM(require("picocolors"));
+async function configure(toolName) {
+  introScreen();
+  prompts.intro(import_picocolors14.default.inverse(import_picocolors14.default.bold(import_picocolors14.default.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(
+        import_picocolors14.default.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(import_picocolors14.default.green(`${selectedTool} configured successfully!`));
+  } catch (error) {
+    prompts.outro(import_picocolors14.default.red(`Failed to configure ${selectedTool}.`));
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/plugin.ts
+var import_picocolors15 = __toESM(require("picocolors"));
+async function plugin(toolName) {
+  introScreen();
+  prompts.intro(import_picocolors15.default.inverse(import_picocolors15.default.bold(import_picocolors15.default.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(import_picocolors15.default.green("Plugins installed successfully!"));
+}
+
+// src/cli/index.ts
 async function main() {
   try {
     introScreen();
-    (0, import_prompts12.intro)(
-      import_picocolors11.default.inverse(import_picocolors11.default.bold(import_picocolors11.default.cyan(" Welcome to the Project Setup Wizard ")))
+    prompts.intro(
+      import_picocolors16.default.inverse(import_picocolors16.default.bold(import_picocolors16.default.cyan(" Welcome to the Project Setup Wizard ")))
     );
     await gitCheck();
     const tools = await withCancelHandling(
-      async () => (0, import_prompts12.multiselect)({
+      async () => prompts.multiselect({
         message: "Select tools to configure:",
         options: TOOL_OPTIONS,
         required: false
@@ -989,23 +2713,25 @@ async function main() {
     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");
+    prompts.note(config.summary, "Configuration Summary");
     const proceed = await withCancelHandling(
-      async () => (0, import_prompts12.confirm)({
+      async () => prompts.confirm({
         message: "Do you want to proceed with the installation?"
       })
     );
     if (!proceed) {
-      (0, import_prompts12.outro)(import_picocolors11.default.yellow("Installation cancelled."));
+      prompts.outro(import_picocolors16.default.yellow("Installation cancelled."));
       process.exit(0);
     }
     await execution(config);
-    (0, import_prompts12.outro)(import_picocolors11.default.green("Setup complete!"));
+    prompts.outro(import_picocolors16.default.green("Setup complete!"));
   } catch (error) {
     const logPath = await logError(error);
-    (0, import_prompts12.outro)(import_picocolors11.default.red(`
+    prompts.outro(
+      import_picocolors16.default.red(`
 Something went wrong!
-Error log saved to: ${logPath}`));
+Error log saved to: ${logPath}`)
+    );
     process.exit(1);
   }
 }
@@ -1027,6 +2753,14 @@ import_commander.program.command("help").action(() => {
   showManual();
   process.exit(0);
 });
+import_commander.program.command("configure [tool]").description("Configure a specific tool").action(async (tool) => {
+  await configure(tool);
+  process.exit(0);
+});
+import_commander.program.command("plugin [tool]").description("Manage plugins for tools").action(async (tool) => {
+  await plugin(tool);
+  process.exit(0);
+});
 import_commander.program.action(async (options) => {
   if (options.about) {
     showAbout();