@mayrlabs/setup-project 0.1.6 → 0.1.8

package/dist/index.mjs

@@ -75,14 +75,14 @@ var init_options = __esm({
       { value: "husky", label: "Husky" },
       { value: "formatter", label: "Formatter (Prettier/Oxfmt)" },
       { value: "linter", label: "Linter (Eslint/Oxlint)" },
-      { value: "lint-staged", label: "Lint-staged" },
+      { value: "lintStaged", label: "Lint-staged" },
       { value: "env", label: "Env Validation (@t3-oss/env)" },
       { value: "test", label: "Test Runner (Vitest/Jest)" },
       { value: "editorConfig", label: "EditorConfig" },
       { value: "license", label: "License" }
     ];
     HUSKY_HOOK_OPTIONS = [
-      { value: "lint-staged", label: "lint-staged" },
+      { value: "lintStaged", label: "lint-staged" },
       { value: "custom", label: "Custom script" },
       { value: "none", label: "None" }
     ];
@@ -180,7 +180,7 @@ var init_handle_cancel = __esm({
   }
 });
 
-// src/services/husky.ts
+// src/features/husky.ts
 import { select, log, text } from "@clack/prompts";
 import { execa as execa2 } from "execa";
 import fs from "fs-extra";
@@ -195,7 +195,7 @@ async function promptHusky(config2) {
   );
   const huskyConfig = config2.get("husky");
   huskyConfig.options = { hookType };
-  if (hookType === "lint-staged") {
+  if (hookType === "lintStaged") {
     config2.enableTool("lintStaged");
   } else if (hookType === "custom") {
     const script = await withCancelHandling(
@@ -221,7 +221,7 @@ async function installHusky(config2) {
   const husky = config2.get("husky");
   const hookType = husky.options.hookType;
   const customScript = husky.options.customScript;
-  if (hookType === "lint-staged") {
+  if (hookType === "lintStaged") {
     await fs.outputFile(".husky/pre-commit", "npx lint-staged\n", {
       mode: 493
     });
@@ -233,7 +233,7 @@ async function installHusky(config2) {
   }
 }
 var init_husky = __esm({
-  "src/services/husky.ts"() {
+  "src/features/husky.ts"() {
     "use strict";
     init_esm_shims();
     init_pm();
@@ -242,15 +242,1392 @@ var init_husky = __esm({
   }
 });
 
-// src/services/formatter.ts
-import { select as select2, log as log2 } from "@clack/prompts";
+// src/utils/config-file.ts
 import fs2 from "fs-extra";
+import { select as select2 } from "@clack/prompts";
+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 () => select2({
+      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_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 (e) {
+    }
+  }
+  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_eslint = __esm({
+  "src/features/linter/eslint.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_pm();
+    init_plugins();
+    init_config_file();
+  }
+});
+
+// src/steps/install-plugin.ts
+import { multiselect, outro, confirm as confirm2 } from "@clack/prompts";
 import pc2 from "picocolors";
+async function installPlugins(tool) {
+  const pluginsList = PLUGINS[tool];
+  const selectedPlugins = await withCancelHandling(
+    async () => multiselect({
+      message: `Select ${tool} plugins to install:`,
+      options: pluginsList,
+      required: true
+    })
+  );
+  if (selectedPlugins.length === 0) {
+    outro(pc2.yellow("No plugins selected."));
+    return;
+  }
+  const packagesToInstall = selectedPlugins.map((val) => {
+    const p = pluginsList.find((opt) => opt.value === val);
+    return p ? p.package : val;
+  });
+  outro(
+    pc2.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 () => confirm2({
+      message: `Do you want to configure the selected plugins in your ${tool} config file?`,
+      initialValue: true
+    })
+  );
+  if (!shouldConfigure) {
+    outro(pc2.yellow("Skipping configuration."));
+    return;
+  }
+  switch (tool) {
+    case "prettier":
+      await configurePrettierPlugins(plugins);
+      outro(pc2.green("Prettier plugins configured in .prettierrc"));
+      break;
+    case "eslint":
+      await configureEslintPlugins(plugins);
+      outro(pc2.green("ESLint plugins configured in .eslintrc.json"));
+      break;
+  }
+}
+var init_install_plugin = __esm({
+  "src/steps/install-plugin.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_plugins();
+    init_prettier();
+    init_eslint();
+    init_handle_cancel();
+    init_pm();
+  }
+});
+
+// src/features/formatter.ts
+import { select as select3, log as log2, confirm as confirm3 } from "@clack/prompts";
+import pc3 from "picocolors";
 async function promptFormatter(config2) {
   const formatterConfig = config2.get("formatter");
-  log2.message(pc2.bgBlue(pc2.black(" Formatter Configuration ")));
+  log2.message(pc3.bgBlue(pc3.white(" Formatter Configuration ")));
   const formatter = await withCancelHandling(
-    async () => select2({
+    async () => select3({
       message: "Select a formatter:",
       options: FORMATTER_OPTIONS,
       initialValue: formatterConfig.options.choice
@@ -259,40 +1636,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;
+  log2.message(pc3.white(pc3.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 () => confirm3({
+      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_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 { select as select4, log as log3, confirm as confirm4 } from "@clack/prompts";
+import pc4 from "picocolors";
 async function promptLinter(config2) {
   const linterConfig = config2.get("linter");
-  log3.message(pc3.bgYellow(pc3.black(" Linter Configuration ")));
+  log3.message(pc4.bgYellow(pc4.black(" Linter Configuration ")));
   const linter = await withCancelHandling(
-    async () => select3({
+    async () => select4({
       message: "Select a linter:",
       options: LINTER_OPTIONS,
       initialValue: linterConfig.options.choice
@@ -301,50 +1692,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;
+  log3.message(pc4.white(pc4.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 () => confirm4({
+      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_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 { multiselect as multiselect2, log as log4 } from "@clack/prompts";
+import pc5 from "picocolors";
 async function promptLintStaged(config2) {
-  log4.message(pc4.bgGreen(pc4.black(" Lint-staged Configuration ")));
+  log4.message(pc5.bgGreen(pc5.black(" Lint-staged Configuration ")));
   const lintExtensions = await withCancelHandling(
-    async () => multiselect({
+    async () => multiselect2({
       message: "Select extensions to lint:",
       options: LINT_STAGED_EXTENSIONS,
       required: false
     })
   );
   const formatExtensions = await withCancelHandling(
-    async () => multiselect({
+    async () => multiselect2({
       message: "Select extensions to format:",
       options: LINT_STAGED_EXTENSIONS,
       required: false
@@ -365,6 +1754,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,10 +1783,10 @@ 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_pm();
@@ -398,37 +1794,38 @@ var init_lint_staged = __esm({
     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 { select as select5, confirm as confirm5, text as text2, multiselect as multiselect3, log as log5 } from "@clack/prompts";
 import fs5 from "fs-extra";
-import path2 from "path";
-import pc5 from "picocolors";
+import path3 from "path";
+import pc6 from "picocolors";
 async function promptEnv(config2) {
-  log5.message(pc5.bgCyan(pc5.black(" Env Validation Configuration ")));
+  log5.message(pc6.bgCyan(pc6.black(" Env Validation Configuration ")));
   const variant = await withCancelHandling(
-    async () => select4({
+    async () => select5({
       message: "Which @t3-oss/env variant?",
       options: ENV_VARIANT_OPTIONS
     })
   );
   const validator = await withCancelHandling(
-    async () => select4({
+    async () => select5({
       message: "Which validator?",
       options: ENV_VALIDATOR_OPTIONS
     })
   );
   const installPresets = await withCancelHandling(
-    async () => confirm2({
+    async () => confirm5({
       message: "Install presets?"
     })
   );
   let presets;
   if (installPresets) {
     presets = await withCancelHandling(
-      async () => multiselect2({
+      async () => multiselect3({
         message: "Select preset to extend:",
         options: ENV_PRESET_OPTIONS,
         required: false
@@ -436,7 +1833,7 @@ async function promptEnv(config2) {
     );
   }
   const split = await withCancelHandling(
-    async () => select4({
+    async () => select5({
       message: "Split or Joined env files?",
       options: ENV_SPLIT_OPTIONS
     })
@@ -460,7 +1857,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 +1867,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 +1878,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 +1892,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,7 +1910,7 @@ export const env = createEnv({
   }
 }
 var init_env = __esm({
-  "src/services/env.ts"() {
+  "src/features/env.ts"() {
     "use strict";
     init_esm_shims();
     init_pm();
@@ -522,14 +1919,14 @@ var init_env = __esm({
   }
 });
 
-// src/services/test.ts
-import { select as select5, log as log6 } from "@clack/prompts";
+// src/features/test.ts
+import { select as select6, log as log6 } from "@clack/prompts";
 import fs6 from "fs-extra";
-import pc6 from "picocolors";
+import pc7 from "picocolors";
 async function promptTest(config2) {
-  log6.message(pc6.bgRed(pc6.black(" Test Runner Configuration ")));
+  log6.message(pc7.bgRed(pc7.white(" Test Runner Configuration ")));
   const runner = await withCancelHandling(
-    async () => select5({
+    async () => select6({
       message: "Select a test runner:",
       options: TEST_RUNNER_OPTIONS
     })
@@ -571,7 +1968,7 @@ module.exports = {
   }
 }
 var init_test = __esm({
-  "src/services/test.ts"() {
+  "src/features/test.ts"() {
     "use strict";
     init_esm_shims();
     init_pm();
@@ -580,15 +1977,15 @@ var init_test = __esm({
   }
 });
 
-// src/services/editor-config.ts
-import { select as select6, log as log7 } from "@clack/prompts";
+// src/features/editor-config.ts
+import { select as select7, log as log7 } from "@clack/prompts";
 import fs7 from "fs-extra";
-import pc7 from "picocolors";
+import pc8 from "picocolors";
 async function promptEditorConfig(config2) {
-  log7.message(pc7.bgWhite(pc7.black(" EditorConfig Configuration ")));
+  log7.message(pc8.bgWhite(pc8.black(" EditorConfig Configuration ")));
   const currentPreset = config2.get("editorConfig").options.preset;
   const preset = await withCancelHandling(
-    async () => select6({
+    async () => select7({
       message: "Select EditorConfig preset:",
       options: EDITOR_CONFIG_OPTIONS,
       initialValue: currentPreset
@@ -609,7 +2006,7 @@ 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_options();
@@ -617,13 +2014,13 @@ var init_editor_config = __esm({
   }
 });
 
-// src/services/license.ts
-import { text as text3, select as select7, log as log8 } from "@clack/prompts";
+// src/features/license.ts
+import { text as text3, select as select8, log as log8 } from "@clack/prompts";
 import fs8 from "fs-extra";
-import path3 from "path";
-import pc8 from "picocolors";
+import path4 from "path";
+import pc9 from "picocolors";
 async function promptLicense(config2) {
-  log8.message(pc8.bgGreen(pc8.black(" License Configuration ")));
+  log8.message(pc9.bgGreen(pc9.black(" License Configuration ")));
   const licenseOptions = config2.get("license").options;
   licenseOptions.name = await withCancelHandling(
     async () => text3({
@@ -647,7 +2044,7 @@ async function promptLicense(config2) {
     })
   );
   licenseOptions.type = await withCancelHandling(
-    async () => select7({
+    async () => select8({
       message: "Select License Type:",
       options: LICENSE_TYPE_OPTIONS
     })
@@ -658,7 +2055,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,7 +2079,7 @@ Licensed under ${type}`;
   }
 }
 var init_license = __esm({
-  "src/services/license.ts"() {
+  "src/features/license.ts"() {
     "use strict";
     init_esm_shims();
     init_options();
@@ -690,11 +2087,11 @@ var init_license = __esm({
   }
 });
 
-// src/config/config.ts
-import pc9 from "picocolors";
+// src/core/config.ts
+import pc10 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 +2122,7 @@ var init_config = __esm({
               installPresets: false,
               presets: [],
               split: "split",
-              location: "src/env"
+              location: "src/lib"
             }
           },
           test: {
@@ -750,47 +2147,47 @@ var init_config = __esm({
       }
       get summary() {
         const lines = [];
-        lines.push(pc9.bold("The following actions will be performed:"));
+        lines.push(pc10.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(pc10.magenta(`\u2022 Install and configure Husky`));
           if (this.data.husky.options.hookType === "custom") {
-            lines.push(pc9.dim(`  - Custom hook script`));
+            lines.push(pc10.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(pc10.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(pc10.yellow(`\u2022 Install and configure ${choice || "Linter"}`));
         }
         if (this.data.lintStaged.selected) {
-          lines.push(pc9.green(`\u2022 Install and configure Lint-staged`));
+          lines.push(pc10.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(pc10.dim(`  - Lint: ${lintExts}`));
+          if (formatExts) lines.push(pc10.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(pc10.cyan(`\u2022 Install and configure Env Validation`));
+          lines.push(pc10.dim(`  - Variant: ${this.data.env.options.variant}`));
+          lines.push(pc10.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(pc10.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(pc10.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(pc10.green(`\u2022 Create LICENSE (${type})`));
+          lines.push(pc10.dim(`  - Holder: ${name}`));
         }
         return lines.join("\n");
       }
@@ -864,16 +2261,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 +2290,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,11 +2324,11 @@ var init_git = __esm({
 });
 
 // src/steps/git-check.ts
-import { confirm as confirm3, spinner as spinner2, text as text4 } from "@clack/prompts";
+import { confirm as confirm6, 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 confirm6({
         message: "Your working directory is dirty. Would you like to commit changes before proceeding?"
       });
       if (shouldCommit) {
@@ -966,7 +2363,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@mayrlabs/setup-project",
-      version: "0.1.6",
+      version: "0.1.8",
       description: "Interactive CLI to setup project tools",
       private: false,
       publishConfig: {
@@ -1008,7 +2405,8 @@ var init_package = __esm({
       main: "dist/index.js",
       scripts: {
         build: "tsup",
-        demo: "tsx src/index.ts",
+        demo: "tsx src/cli/index.ts",
+        test: "vitest",
         prepublishOnly: "npm run build"
       },
       dependencies: {
@@ -1024,21 +2422,23 @@ var init_package = __esm({
         "@types/figlet": "^1.7.0",
         "@types/fs-extra": "^11.0.4",
         "@types/node": "^20.11.16",
+        "@vitest/coverage-v8": "^4.0.18",
         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 pc11 from "picocolors";
 import figlet from "figlet";
 function introScreen() {
   console.log();
   console.log(
-    pc10.cyan(
+    pc11.cyan(
       figlet.textSync("MayR\nLabs", {
         font: "Graceful",
         horizontalLayout: "default",
@@ -1048,39 +2448,41 @@ function introScreen() {
       })
     )
   );
-  console.log(pc10.cyan(`@mayrlabs/setup-project v${package_default.version}`));
+  console.log(pc11.cyan(`${package_default.name} - v${package_default.version}`));
   console.log();
 }
 function showAbout() {
   introScreen();
-  console.log(pc10.bold("About:"));
+  console.log(pc11.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(pc11.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(pc11.bold("Project Homepage:"));
+  console.log(pc11.underline(pc11.cyan(package_default.homepage)));
   console.log("");
 }
 function showManual() {
   introScreen();
-  console.log(pc10.bold("Usage:"));
+  console.log(pc11.bold("Usage:"));
   console.log("  npx @mayrlabs/setup-project [command] [options]");
   console.log("");
-  console.log(pc10.bold("Commands:"));
+  console.log(pc11.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(pc11.bold("Options:"));
   console.log("  -a, --about        Show project details");
   console.log("  -v, --version      Show version information");
   console.log("  -V, --visit        Visit project homepage");
@@ -1095,12 +2497,134 @@ 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 { intro, outro as outro2, select as select9 } from "@clack/prompts";
+import pc12 from "picocolors";
+async function configure(toolName) {
+  introScreen();
+  intro(pc12.inverse(pc12.bold(pc12.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(
+        pc12.yellow(`Tool '${toolName}' not found or not configurable.`)
+      );
+    }
+  }
+  if (!selectedTool) {
+    const selection = await withCancelHandling(
+      async () => select9({
+        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;
+    }
+    outro2(pc12.green(`${selectedTool} configured successfully!`));
+  } catch (error) {
+    outro2(pc12.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_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 { intro as intro2, outro as outro3, select as select10 } from "@clack/prompts";
+import pc13 from "picocolors";
+async function plugin(toolName) {
+  introScreen();
+  intro2(pc13.inverse(pc13.bold(pc13.magenta(" Plugin Manager "))));
+  await gitCheck();
+  if (!toolName) {
+    toolName = await withCancelHandling(
+      async () => select10({
+        message: "Select a tool to add plugins to:",
+        options: [
+          { value: "eslint", label: "ESLint" },
+          { value: "prettier", label: "Prettier" }
+        ]
+      })
+    );
+  }
+  await installPlugins(toolName);
+  outro3(pc13.green("Plugins installed successfully!"));
+}
+var init_plugin = __esm({
+  "src/cli/commands/plugin.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_handle_cancel();
+    init_display();
+    init_git_check();
+    init_install_plugin();
+  }
+});
+
+// src/cli/index.ts
+import { outro as outro4, multiselect as multiselect4, note, confirm as confirm7, intro as intro3 } from "@clack/prompts";
+import pc14 from "picocolors";
 import { program } from "commander";
 var require_index = __commonJS({
-  "src/index.ts"() {
+  "src/cli/index.ts"() {
     init_esm_shims();
     init_husky();
     init_formatter();
@@ -1117,15 +2641,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 ")))
+        intro3(
+          pc14.inverse(pc14.bold(pc14.cyan(" Welcome to the Project Setup Wizard ")))
         );
         await gitCheck();
         const tools = await withCancelHandling(
-          async () => multiselect3({
+          async () => multiselect4({
             message: "Select tools to configure:",
             options: TOOL_OPTIONS,
             required: false
@@ -1142,19 +2668,19 @@ var require_index = __commonJS({
         if (config.get("license").selected) await promptLicense(config);
         note(config.summary, "Configuration Summary");
         const proceed = await withCancelHandling(
-          async () => confirm4({
+          async () => confirm7({
             message: "Do you want to proceed with the installation?"
           })
         );
         if (!proceed) {
-          outro(pc11.yellow("Installation cancelled."));
+          outro4(pc14.yellow("Installation cancelled."));
           process.exit(0);
         }
         await execution(config);
-        outro(pc11.green("Setup complete!"));
+        outro4(pc14.green("Setup complete!"));
       } catch (error) {
         const logPath = await logError(error);
-        outro(pc11.red(`
+        outro4(pc14.red(`
 Something went wrong!
 Error log saved to: ${logPath}`));
         process.exit(1);
@@ -1178,6 +2704,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();