@zayne-labs/eslint-config 0.13.13 → 0.13.15

package/README.md

@@ -1,11 +1,14 @@
 # @zayne-labs/eslint-config
 
+[![npm](https://img.shields.io/npm/v/@zayne-labs/eslint-config?color=444&label=)](https://npmjs.com/package/@zayne-labs/eslint-config)
+
 Opinionated ESLint config with sensible defaults and zero-config setup.
 
 - One-line setup with reasonable defaults and best practices
 - Works out-of-the-box with TypeScript, JSX, Vue, JSON, YAML, TOML, Markdown, and more
 - [ESLint Flat config](https://eslint.org/docs/latest/use/configure/configuration-files-new) for easy composition
-- Optional framework support: [Vue](#vue), [React](#react), [Svelte](#svelte), [Astro](#astro), [Solid](#solid)
+- Optional framework support: [Vue](#vue), [React](#react), [Astro](#astro), [Solid](#solid), and [Expo](#expo-react-native)
+- First-class integrations for [Better Tailwind CSS](#better-tailwind-css), [TanStack](#tanstack), [pnpm catalogs](#pnpm-workspaces-and-catalogs), and dependency checks
 - Respects `.gitignore` by default
 - Highly [customizable](#customization) when you need it
 - Requires ESLint v9.5.0+ and Node.js v20+
@@ -25,10 +28,18 @@ pnpx @zayne-labs/eslint-config@latest
 
 The CLI will guide you through:
 
-- Framework selection (React, Vue, Svelte, Astro)
-- Additional integrations (TailwindCSS, etc.)
+- Framework selection (React, Vue, Solid, Astro)
+- Additional integrations (Better TailwindCSS, etc.)
 - Automatic dependency installation
 
+The wizard also supports non-interactive setup:
+
+```bash
+pnpx @zayne-labs/eslint-config@latest --yes --template react --extra tailwindcss-better
+```
+
+Run it in a project that does not already have an `eslint.config.*` file. Existing legacy ESLint files are left untouched and listed for manual review after migration.
+
 ### Manual Installation
 
 ```bash
@@ -121,7 +132,6 @@ Install the [ESLint extension](https://marketplace.visualstudio.com/items?itemNa
 		"gql",
 		"graphql",
 		"astro",
-		"svelte",
 		"css",
 		"less",
 		"scss",
@@ -161,7 +171,6 @@ lspconfig.eslint.setup(
       "gql",
       "graphql",
       "astro",
-      "svelte",
       "css",
       "less",
       "scss",
@@ -211,7 +220,7 @@ export default zayne({
 	// Parse the `.gitignore` file to get the ignores, on by default
 	gitignore: true,
 
-	// Project type: 'app' (default) or 'lib'
+	// Project type: "app" (default), "app-strict", "lib", or "lib-strict"
 	type: "app",
 
 	// Disable all optional configs at once (keeps only essentials)
@@ -236,6 +245,30 @@ export default zayne({
 });
 ```
 
+### Configuration Reference
+
+The factory accepts booleans for simple enable/disable cases and option objects when an integration needs files, rule overrides, or plugin-specific settings.
+
+| Option                                                                                                                                     | Default        | Purpose                                                                                                          |
+| ------------------------------------------------------------------------------------------------------------------------------------------ | -------------- | ---------------------------------------------------------------------------------------------------------------- |
+| `type`                                                                                                                                     | `"app"`        | Selects `"app"`, `"app-strict"`, `"lib"`, or `"lib-strict"` rule behavior.                                       |
+| `withDefaults`                                                                                                                             | `true`         | Controls the standard optional baseline without disabling essential JavaScript, ignore, JSX, or command support. |
+| `gitignore`                                                                                                                                | `true`         | Reads the nearest `.gitignore`; accepts the underlying flat-gitignore options.                                   |
+| `typescript`                                                                                                                               | Auto-detected  | Enables TypeScript rules and optional type-aware or erasable-syntax rules.                                       |
+| `react`                                                                                                                                    | Auto-detected  | Enables the React integration when React is installed.                                                           |
+| `pnpm`                                                                                                                                     | Auto-detected  | Enables workspace rules when a `pnpm-workspace.yaml` is found.                                                   |
+| `baseline`, `comments`, `imports`, `jsdoc`, `jsonc`, `markdown`, `node`, `perfectionist`, `regexp`, `stylistic`, `toml`, `unicorn`, `yaml` | `withDefaults` | Controls the standard integrations; Baseline defaults to widely available JS/TS compatibility warnings.          |
+| `astro`, `vue`, `solid`, `expo`                                                                                                            | `false`        | Enables framework-specific parsing and rules.                                                                    |
+| `depend`, `tailwindcssBetter`, `tanstack`                                                                                                  | `false`        | Enables optional dependency, Tailwind CSS, and TanStack integrations.                                            |
+
+Most integrations accept an `overrides` object. Integrations that apply to special file types also accept `files`. TypeScript, Baseline, and React provide separate type-aware file and override options, while Solid provides a separate `filesTypeAware` scope.
+
+[Baseline JS](https://baselinejs.vercel.app/docs/config) automatically uses type-aware checks for TypeScript files when type-aware linting is active.
+
+### Optional Dependencies
+
+Optional framework and integration plugins are loaded only when their feature is enabled. In an interactive terminal outside CI, the config can offer to install a missing peer dependency. In CI and non-interactive environments, install the documented peers explicitly.
+
 ### Custom Rules
 
 Pass additional configs as extra arguments:
@@ -264,6 +297,65 @@ export default zayne(
 );
 ```
 
+Rules from an integration can also be overridden alongside that integration. This keeps the correct file scope and parser configuration:
+
+```js
+import { zayne } from "@zayne-labs/eslint-config";
+
+export default zayne({
+	react: {
+		overrides: {
+			"react/no-array-index-key": "off",
+		},
+	},
+	typescript: {
+		overrides: {
+			"ts-eslint/consistent-type-definitions": ["error", "type"],
+		},
+		overridesTypeAware: {
+			"ts-eslint/no-unsafe-assignment": "warn",
+		},
+		tsconfigPath: true,
+	},
+});
+```
+
+### Plugin Renaming
+
+Plugin prefixes are normalized by default so rule names stay stable if the underlying implementation package changes:
+
+| Prefix                 | Original plugin prefix |
+| ---------------------- | ---------------------- |
+| `react/*`              | `@eslint-react/*`      |
+| `nextjs/*`             | `@next/next/*`         |
+| `stylistic/*`          | `@stylistic/*`         |
+| `tanstack-query/*`     | `@tanstack/query/*`    |
+| `tanstack-router/*`    | `@tanstack/router/*`   |
+| `ts-eslint/*`          | `@typescript-eslint/*` |
+| `tailwindcss-better/*` | `better-tailwindcss/*` |
+| `import/*`             | `import-x/*`           |
+| `node/*`               | `n/*`                  |
+
+The factory also renames matching rule prefixes in custom configs. Set `autoRenamePlugins: false` to opt out, or use the returned composer's `renamePlugins()` method to define another mapping.
+
+### Config Composer
+
+`zayne()` returns a [`FlatConfigComposer`](https://github.com/antfu/eslint-flat-config-utils), so configurations can be inserted or overridden by their stable `zayne/*` names:
+
+```js
+import { zayne } from "@zayne-labs/eslint-config";
+
+export default zayne()
+	.prepend({
+		ignores: ["**/generated/**"],
+	})
+	.override("zayne/stylistic/rules", {
+		rules: {
+			"stylistic/quotes": ["error", "single"],
+		},
+	});
+```
+
 ### Advanced Composition
 
 Import and compose fine-grained configs directly:
@@ -276,6 +368,8 @@ Import and compose fine-grained configs directly:
 ```js
 import {
 	astro,
+	baseline,
+	command,
 	comments,
 	depend,
 	expo,
@@ -290,6 +384,7 @@ import {
 	perfectionist,
 	pnpm,
 	react,
+	regexp,
 	solid,
 	sortPackageJson,
 	sortTsconfig,
@@ -307,14 +402,17 @@ import { FlatConfigComposer } from "eslint-flat-config-utils";
 export default new FlatConfigComposer().append(
 	ignores(),
 	javascript(),
+	command(),
 	typescript(),
 	jsx(),
+	baseline(),
 	comments(),
 	node(),
 	jsdoc(),
 	imports(),
 	unicorn(),
 	perfectionist(),
+	regexp(),
 	stylistic(),
 	react(),
 	vue(),
@@ -327,7 +425,7 @@ export default new FlatConfigComposer().append(
 
 </details>
 
-See [configs](https://github.com/zayne-labs/eslint-config/blob/main/src/configs) and [factory](https://github.com/zayne-labs/eslint-config/blob/main/src/factory.ts) for implementation details.
+See [configs](https://github.com/zayne-labs/config/tree/main/packages/eslint-config/src/configs) and [factory](https://github.com/zayne-labs/config/blob/main/packages/eslint-config/src/factory.ts) for implementation details.
 
 > Thanks to [antfu/eslint-config](https://github.com/antfu/eslint-config) for the inspiration and reference.
 
@@ -345,10 +443,24 @@ export default zayne({
 });
 ```
 
+Vue 3 and custom SFC block processing are enabled by default. Vue 2 can be selected explicitly, accessibility rules are opt-in, and SFC block processing can be disabled when it is not needed:
+
+```js
+export default zayne({
+	vue: {
+		a11y: true,
+		sfcBlocks: false,
+		vueVersion: 2,
+	},
+});
+```
+
 Install peer dependencies:
 
 ```bash
-pnpm i -D eslint-plugin-vue vue-eslint-parser
+pnpm i -D eslint-plugin-vue vue-eslint-parser eslint-processor-vue-blocks
+# When a11y is enabled:
+pnpm i -D eslint-plugin-vuejs-accessibility
 ```
 
 ### React
@@ -359,31 +471,38 @@ Auto-detected in most cases, or enable explicitly:
 import { zayne } from "@zayne-labs/eslint-config";
 
 export default zayne({
-	react: true,
+	react: {
+		compiler: true,
+		nextjs: true,
+		refresh: true,
+		youMightNotNeedAnEffect: true,
+	},
 });
 ```
 
+The base React integration, React Compiler checks, refresh rules, and effect guidance can each be configured or disabled independently. Next.js rules are enabled only through `react.nextjs`.
+
 Install peer dependencies (prompted automatically when running ESLint):
 
 ```bash
-pnpm i -D @eslint-react/eslint-plugin eslint-plugin-react-hooks eslint-plugin-react-refresh
+pnpm i -D @eslint-react/eslint-plugin eslint-plugin-react-hooks eslint-plugin-react-refresh eslint-plugin-react-you-might-not-need-an-effect
+# When react.nextjs is enabled:
+pnpm i -D @next/eslint-plugin-next
 ```
 
-### Svelte
+#### Next.js
 
-```js
-import { zayne } from "@zayne-labs/eslint-config";
+Next.js is supported but must be enabled explicitly. Set `nextjs: true` inside the React integration:
 
+```js
 export default zayne({
-	svelte: true,
+	react: {
+		nextjs: true,
+	},
 });
 ```
 
-Install peer dependencies:
-
-```bash
-pnpm i -D eslint-plugin-svelte
-```
+The integration combines the plugin's recommended and Core Web Vitals rules. Its refresh configuration also permits the standard Next.js route exports. Pass an object instead when custom `files` or `overrides` are needed.
 
 ### Astro
 
@@ -398,7 +517,7 @@ export default zayne({
 Install peer dependencies:
 
 ```bash
-pnpm i -D eslint-plugin-astro
+pnpm i -D eslint-plugin-astro astro-eslint-parser
 ```
 
 ### Solid
@@ -417,7 +536,23 @@ Install peer dependencies:
 pnpm i -D eslint-plugin-solid
 ```
 
-### TailwindCSS
+### JSX Accessibility
+
+JSX syntax is enabled by default. Accessibility rules are opt-in and work independently of the React integration:
+
+```js
+export default zayne({
+	jsx: {
+		a11y: true,
+	},
+});
+```
+
+```bash
+pnpm i -D eslint-plugin-jsx-a11y
+```
+
+### Better Tailwind CSS
 
 Uses the enhanced `eslint-plugin-better-tailwindcss` for improved class sorting and validation:
 
@@ -451,6 +586,18 @@ Install peer dependencies:
 pnpm i -D eslint-config-expo
 ```
 
+### Node Security
+
+Node rules are enabled by default. The additional `eslint-plugin-security` rules are opt-in:
+
+```js
+export default zayne({
+	node: {
+		security: true,
+	},
+});
+```
+
 ### TanStack
 
 Support for TanStack Query and Router:
@@ -472,15 +619,20 @@ Install peer dependencies:
 pnpm i -D @tanstack/eslint-plugin-query @tanstack/eslint-plugin-router
 ```
 
-### PNPM Catalogs
+### PNPM Workspaces and Catalogs
 
-Lint PNPM catalog protocol usage:
+pnpm support is auto-detected from the nearest `pnpm-workspace.yaml`. It can validate package and workspace manifests, require catalog usage, and sort workspace YAML entries:
 
 ```js
 import { zayne } from "@zayne-labs/eslint-config";
 
 export default zayne({
-	pnpm: true,
+	pnpm: {
+		catalogs: true,
+		json: true,
+		sort: true,
+		yaml: true,
+	},
 });
 ```
 
@@ -508,6 +660,19 @@ Install peer dependencies:
 pnpm i -D eslint-plugin-depend
 ```
 
+### Command Comments
+
+[`eslint-plugin-command`](https://github.com/antfu/eslint-plugin-command) is always available for explicit, comment-driven transformations. Place a supported triple-slash command directly above the code and run ESLint with fixes:
+
+```ts
+/// to-for-of
+items.forEach((item) => {
+	console.log(item);
+});
+```
+
+Commands are intended as temporary codemods; their trigger comments are removed with the transformation.
+
 ## Type-Aware Rules
 
 Type-aware linting is automatically enabled when TypeScript is detected. It uses the nearest `tsconfig.json` by default.
@@ -541,27 +706,52 @@ export default zayne({
 });
 ```
 
+Set `tsconfigPath: true` to use the nearest project automatically. Type-aware file globs and rules can be refined with `filesTypeAware`, `ignoresTypeAware`, and `overridesTypeAware`.
+
+Projects targeting erasable TypeScript syntax can enable the corresponding optional rules:
+
+```js
+export default zayne({
+	typescript: {
+		erasableOnly: true,
+	},
+});
+```
+
 ### Editor Specific Disables
 
 Auto-fixing for the following rules are disabled when ESLint is running in a code editor:
 
 - [`prefer-const`](https://eslint.org/docs/rules/prefer-const)
-- [`test/no-only-tests`](https://github.com/levibuzolic/eslint-plugin-no-only-tests)
 - [`pnpm/json-enforce-catalog`](https://github.com/antfu/pnpm-workspace-utils/tree/main/packages/eslint-plugin-pnpm#rules)
 - [`pnpm/json-prefer-workspace-settings`](https://github.com/antfu/pnpm-workspace-utils/tree/main/packages/eslint-plugin-pnpm#rules)
 - [`pnpm/json-valid-catalog`](https://github.com/antfu/pnpm-workspace-utils/tree/main/packages/eslint-plugin-pnpm#rules)
 
-This is to prevent unused imports from getting removed by the editor during refactoring to get a better developer experience. Those rules will be applied when you run ESLint in the terminal or [Lint Staged](#lint-staged). If you don't want this behavior, you can disable them:
+This prevents editor autosave from applying potentially disruptive fixes while code is being refactored. Full autofix behavior is restored when ESLint runs in the terminal or through [lint-staged](#lint-staged). If you don't want this behavior, disable editor detection explicitly:
 
 ```js
 // eslint.config.js
-import { zayne } from "@antfu/eslint-config";
+import { zayne } from "@zayne-labs/eslint-config";
 
 export default zayne({
 	isInEditor: false,
 });
 ```
 
+### Lint Staged
+
+To apply safe autofixes before each commit:
+
+```json
+{
+	"lint-staged": {
+		"*": "eslint --fix"
+	}
+}
+```
+
+When ESLint runs through lint-staged or a Git hook, terminal rule behavior is preserved instead of the editor-specific non-fixable mode.
+
 ## Inspecting Config
 
 View active rules using the [ESLint Config Inspector](https://github.com/eslint/config-inspector):

package/dist/cli/index.d.ts

@@ -1 +1 @@
-export { };
+export {}

package/dist/cli/index.js

@@ -10,14 +10,14 @@ import fsp from "node:fs/promises";
 import parse from "parse-gitignore";
 import { execSync } from "node:child_process";
 //#region package.json
-var version = "0.13.13";
+var version = "0.13.15";
 //#endregion
 //#region src/cli/constants.ts
 const vscodeSettingsString = `
   // Auto fix
-  // "editor.codeActionsOnSave": {
-  //   "source.fixAll.eslint": "explicit",
-  // },
+  "editor.codeActionsOnSave": {
+    "source.fixAll.eslint": "explicit",
+  },
 
   // Enable eslint for all supported languages
   "eslint.validate": [
@@ -37,10 +37,10 @@ const vscodeSettingsString = `
     "gql",
     "graphql",
     "astro",
-    "svelte",
     "css",
     "less",
     "scss",
+    "pcss",
     "postcss"
   ]
 `;
@@ -53,10 +53,6 @@ const frameworkOptions = [
 		label: c.cyan("React"),
 		value: "react"
 	},
-	{
-		label: c.red("Svelte"),
-		value: "svelte"
-	},
 	{
 		label: c.magenta("Astro"),
 		value: "astro"
@@ -81,7 +77,6 @@ const dependenciesMap = defineEnumDeep({
 		"eslint-plugin-react-you-might-not-need-an-effect"
 	],
 	solid: ["eslint-plugin-solid"],
-	svelte: ["eslint-plugin-svelte", "svelte-eslint-parser"],
 	"tailwindcss-better": ["eslint-plugin-better-tailwindcss"],
 	vue: [
 		"eslint-plugin-vue",
@@ -110,6 +105,8 @@ ${mainConfig}
 };
 //#endregion
 //#region src/cli/stages/update-eslint-files.ts
+const ESLINT = "eslint";
+const ESLINT_CONFIG = "eslint.config.";
 const updateEslintFiles = async (result) => {
 	const cwd = process.cwd();
 	const pathESLintIgnore = path.join(cwd, ".eslintignore");
@@ -120,37 +117,39 @@ const updateEslintFiles = async (result) => {
 	const eslintIgnores = [];
 	if (fs.existsSync(pathESLintIgnore)) {
 		p.log.step(c.cyan`Migrating existing .eslintignore`);
-		const globs = parse(await fsp.readFile(pathESLintIgnore, "utf8")).globs();
-		for (const glob of globs) {
-			if (glob.type === "ignore") eslintIgnores.push(...glob.patterns);
-			if (glob.type === "unignore") eslintIgnores.push(...glob.patterns.map((pattern) => `!${pattern}`));
-		}
+		const content = await fsp.readFile(pathESLintIgnore, "utf8");
+		const globs = parse(content).globs();
+		for (const glob of globs) if (glob.type === "ignore") eslintIgnores.push(...glob.patterns);
+		else if (glob.type === "unignore") eslintIgnores.push(...glob.patterns.map((pattern) => `!${pattern}`));
 	}
 	const configLines = [];
 	if (eslintIgnores.length > 0) configLines.push(`ignores: ${JSON.stringify(eslintIgnores)},`);
-	if (result.extra.includes("tailwindcssBetter")) configLines.push(`tailwindcssBetter: true,`);
+	if (result.extra.includes("tailwindcss-better")) configLines.push(`tailwindcssBetter: true,`);
 	for (const framework of result.frameworks) configLines.push(`${framework}: true,`);
-	const eslintConfigContent = getEslintConfigContent(configLines.map((line) => `  ${line}`).join("\n"), []);
+	const mainConfig = configLines.map((line) => `  ${line}`).join("\n");
+	const eslintConfigContent = getEslintConfigContent(mainConfig, []);
 	await fsp.writeFile(pathFlatConfig, eslintConfigContent);
 	p.log.success(c.green`Created ${configFileName}`);
+	const files = fs.readdirSync(cwd);
+	const legacyConfig = [];
+	for (const file of files) if (file.includes(ESLINT) && !file.includes(ESLINT_CONFIG)) legacyConfig.push(file);
+	if (legacyConfig.length > 0) p.note(c.dim(legacyConfig.join(", ")), "You can now remove those files manually");
 };
 //#endregion
 //#region src/cli/constants-generated.ts
 const versionsMap = defineEnum({
-	"@eslint-react/eslint-plugin": "^5.8.1",
-	"astro-eslint-parser": "^1.4.0",
-	eslint: "^10.4.0",
-	"eslint-plugin-astro": "^1.7.0",
-	"eslint-plugin-better-tailwindcss": "^4.5.0",
+	"@eslint-react/eslint-plugin": "^5.19.0",
+	"astro-eslint-parser": "^3.1.0",
+	eslint: "^10.10.0",
+	"eslint-plugin-astro": "^3.1.0",
+	"eslint-plugin-better-tailwindcss": "^4.7.0",
 	"eslint-plugin-react-hooks": "^7.1.1",
-	"eslint-plugin-react-refresh": "^0.5.2",
-	"eslint-plugin-react-you-might-not-need-an-effect": "^0.10.1",
-	"eslint-plugin-solid": "^0.14.5",
-	"eslint-plugin-svelte": "^3.17.1",
-	"eslint-plugin-vue": "^10.9.1",
+	"eslint-plugin-react-refresh": "^0.5.6",
+	"eslint-plugin-react-you-might-not-need-an-effect": "^1.0.2",
+	"eslint-plugin-solid": "^0.17.0",
+	"eslint-plugin-vue": "^10.11.0",
 	"eslint-processor-vue-blocks": "^2.0.0",
-	"svelte-eslint-parser": "^1.6.1",
-	"vue-eslint-parser": "^10.4.0"
+	"vue-eslint-parser": "^10.4.1"
 });
 //#endregion
 //#region src/cli/stages/update-package-json.ts
@@ -164,23 +163,20 @@ const updatePackageJson = async (result) => {
 	pkg.devDependencies["@zayne-labs/eslint-config"] = `^${version}`;
 	pkg.devDependencies.eslint ??= versionsMap.eslint;
 	const addedPackages = [];
-	for (const item of result.extra) switch (item) {
-		case "tailwindcss-better":
-			dependenciesMap["tailwindcss-better"].forEach((depName) => {
-				pkg.devDependencies && (pkg.devDependencies[depName] = versionsMap[depName]);
-				addedPackages.push(depName);
-			});
-			break;
-		default:
+	for (const item of result.extra) {
+		const dependencies = dependenciesMap[item];
+		for (const dependency of dependencies) {
+			pkg.devDependencies[dependency] = versionsMap[dependency];
+			addedPackages.push(dependency);
+		}
 	}
 	for (const framework of result.frameworks) {
 		const dependencies = dependenciesMap[framework];
 		if (!dependencies) continue;
-		dependencies.forEach((dependency) => {
-			if (!pkg.devDependencies) return;
+		for (const dependency of dependencies) {
 			pkg.devDependencies[dependency] = versionsMap[dependency];
 			addedPackages.push(dependency);
-		});
+		}
 	}
 	if (addedPackages.length > 0) p.note(c.dim(addedPackages.join(", ")), "Added packages");
 	await fsp.writeFile(pathPackageJSON, JSON.stringify(pkg, null, 2));
@@ -189,8 +185,8 @@ const updatePackageJson = async (result) => {
 //#endregion
 //#region src/cli/stages/update-vscode-settings.ts
 const updateVscodeSettings = async (result) => {
-	const cwd = process.cwd();
 	if (!result.updateVscodeSettings) return;
+	const cwd = process.cwd();
 	const dotVscodePath = path.join(cwd, ".vscode");
 	const settingsPath = path.join(dotVscodePath, "settings.json");
 	if (!fs.existsSync(dotVscodePath)) await fsp.mkdir(dotVscodePath, { recursive: true });
@@ -208,12 +204,24 @@ const updateVscodeSettings = async (result) => {
 };
 //#endregion
 //#region src/cli/run.ts
+const ESLINT_CONFIG_FILES = [
+	"eslint.config.js",
+	"eslint.config.mjs",
+	"eslint.config.cjs",
+	"eslint.config.ts",
+	"eslint.config.mts",
+	"eslint.config.cts"
+];
 const runCli = async (options = {}) => {
-	const argSkipPrompt = Boolean(process.env.SKIP_PROMPT) || options.yes;
-	const argTemplate = options.frameworks?.map((m) => m.trim()).filter(Boolean);
-	const argExtra = options.extra?.map((m) => m.trim()).filter(Boolean);
-	if (fs.existsSync(path.join(process.cwd(), "eslint.config.js"))) {
-		p.log.warn(c.yellow`eslint.config.js already exists, migration wizard exited.`);
+	const isSkippingPrompts = Boolean(process.env.SKIP_PROMPT) || Boolean(options.yes);
+	const argTemplate = options.frameworks?.filter((framework) => typeof framework === "string").map((framework) => framework.trim()).filter(Boolean);
+	const argExtra = options.extra?.filter((extraOption) => typeof extraOption === "string").map((extraOption) => extraOption.trim()).filter(Boolean);
+	const invalidFrameworks = argTemplate?.filter((framework) => !frameworks.includes(framework));
+	const invalidExtras = argExtra?.filter((extraOption) => !extra.includes(extraOption));
+	if (isSkippingPrompts && ((invalidFrameworks?.length ?? 0) > 0 || (invalidExtras?.length ?? 0) > 0)) throw new Error(`Invalid CLI options.${invalidFrameworks?.length ? ` Frameworks: ${invalidFrameworks.join(", ")}.` : ""}${invalidExtras?.length ? ` Extras: ${invalidExtras.join(", ")}.` : ""}`);
+	const existingConfigFile = ESLINT_CONFIG_FILES.find((fileName) => fs.existsSync(path.join(process.cwd(), fileName)));
+	if (existingConfigFile) {
+		p.log.warn(c.yellow`${existingConfigFile} already exists, migration wizard exited.`);
 		return process.exit(1);
 	}
 	let result = {
@@ -222,7 +230,7 @@ const runCli = async (options = {}) => {
 		uncommittedConfirmed: false,
 		updateVscodeSettings: true
 	};
-	if (!argSkipPrompt) {
+	if (!isSkippingPrompts) {
 		result = await p.group({
 			uncommittedConfirmed: () => {
 				if (isGitClean()) return Promise.resolve(true);
@@ -232,8 +240,7 @@ const runCli = async (options = {}) => {
 				});
 			},
 			frameworks: ({ results }) => {
-				const isArgTemplateValid = (argTemplate?.length ?? 0) > 0 && (argTemplate ?? []).filter((element) => !frameworks.includes(element)).length === 0;
-				if (!results.uncommittedConfirmed || isArgTemplateValid) return;
+				if ((argTemplate?.length ?? 0) > 0 && (argTemplate ?? []).filter((element) => !frameworks.includes(element)).length === 0 || !results.uncommittedConfirmed) return;
 				const message = argTemplate ? `"${JSON.stringify(argTemplate)}" isn't a valid template. Please choose from below: ` : "Select a framework:";
 				return p.multiselect({
 					message: c.reset(message),
@@ -242,8 +249,7 @@ const runCli = async (options = {}) => {
 				});
 			},
 			extra: ({ results }) => {
-				const isArgExtraValid = (argExtra?.length ?? 0) > 0 && (argExtra ?? []).filter((element) => !extra.includes(element)).length === 0;
-				if (!results.uncommittedConfirmed || isArgExtraValid) return;
+				if ((argExtra?.length ?? 0) > 0 && (argExtra ?? []).filter((element) => !extra.includes(element)).length === 0 || !results.uncommittedConfirmed) return;
 				const message = argExtra ? `"${JSON.stringify(argExtra)}" isn't a valid extra util. Please choose from below: ` : "Select an extra util:";
 				return p.multiselect({
 					message: c.reset(message),
@@ -276,7 +282,7 @@ const header = () => {
 	p.intro(`${c.green`@zayne-labs/eslint-config `}${c.dim`v${version}`}`);
 };
 const cli = cac("@zayne-labs/eslint-config");
-cli.command("", "Run the initialization or migration").option("--yes, -y", "Skip prompts and use default values", { default: false }).option("--template, -t <template>", "Use the framework template for optimal customization: vue / react / svelte / astro", { type: [] }).option("--extra, -e <extra>", "Use the extra utils: tailwindcss", { type: [] }).action(async (options) => {
+cli.command("", "Run the initialization or migration").option("--yes, -y", "Skip prompts and use default values", { default: false }).option("--template, -t <template>", "Use the framework template for optimal customization: vue / react / solid / astro", { type: [] }).option("--extra, -e <extra>", "Use the extra utils: tailwindcss-better", { type: [] }).action(async (options) => {
 	header();
 	try {
 		await runCli(options);