@chanyuxi/eslint-waltz 1.4.0 → 1.5.1

package/README.md

@@ -1,39 +1,33 @@
+<p align="center">
+  <img src="./assets/images/github_banner_image.png" alt="@chanyuxi/eslint-waltz" width="100%" />
+</p>
+
 # @chanyuxi/eslint-waltz
 
-Composable ESLint flat config for JavaScript, TypeScript, JSONC, React, Tailwind CSS, Perfectionist, and Vitest.
+Composable ESLint flat config for JavaScript, TypeScript, JSONC, imports, React, Tailwind CSS, Perfectionist, and Vitest.
 
 Requires Node.js `>=20.19.0`.
 
-## Install
+## Quick start
 
-Install the package, ESLint, and the peer dependencies used by the default configuration:
+Run the interactive initializer from your project root:
 
 ```bash
-pnpm add -D @chanyuxi/eslint-waltz eslint eslint-plugin-jsonc eslint-plugin-import-x eslint-plugin-perfectionist jsonc-eslint-parser
+pnpm dlx @chanyuxi/eslint-waltz init
 ```
 
-`@eslint/js`, `@stylistic/eslint-plugin`, `globals`, and `jsonc-parser` are included automatically.
+The initializer detects your package manager and existing dependencies, creates
+`eslint.config.ts`, installs missing dependencies for the selected features,
+and can configure ESLint fix-on-save in VS Code while preserving existing
+settings and comments.
 
-Install peers only for the optional modules you enable:
+If the package is already installed, use its local binary:
 
 ```bash
-# TypeScript
-pnpm add -D typescript-eslint
-
-# React
-pnpm add -D eslint-plugin-react-x eslint-plugin-react-debug eslint-plugin-react-dom eslint-plugin-react-hooks-extra eslint-plugin-react-naming-convention eslint-plugin-react-web-api
-
-# Tailwind CSS
-pnpm add -D eslint-plugin-tailwindcss tailwindcss
-
-# .gitignore support
-pnpm add -D eslint-config-flat-gitignore
-
-# Vitest
-pnpm add -D @vitest/eslint-plugin vitest
+pnpm exec eslint-waltz init
 ```
 
-## Usage
+## Configuration
 
 ```ts
 // eslint.config.ts
@@ -45,37 +39,29 @@ export default waltz({
 })
 ```
 
-Enabled by default:
-
-- JavaScript and stylistic rules
-- JSONC rules
-- import validation
-- Perfectionist with `recommended-alphabetical`
+The default configuration includes JavaScript, stylistic rules, JSONC,
+import validation, and Perfectionist's `recommended-alphabetical` preset.
+Optional modules are enabled with `ts`, `react`, `tailwindcss`, `gitignore`,
+and `vitest`. All options are fully typed.
 
-Optional: `ts`, `react`, `tailwindcss`, `gitignore`, and `vitest`.
+## CLI
 
-More options are documented in the exported TypeScript types.
+```bash
+eslint-waltz init     # create or update eslint.config.ts
+eslint-waltz version  # print the installed version
+```
 
-The potentially expensive module-resolution rules are disabled by default. Enable
-them explicitly when your project needs them:
+Use `eslint-waltz --help` to see the available commands. VS Code
+fix-on-save synchronization is part of `init`.
 
-```ts
-export default waltz({
-  imports: {
-    overrides: {
-      'imports/named': 'error',
-      'imports/namespace': 'error',
-    },
-  },
-})
-```
+## Advanced options
 
-## TypeScript file scope
+### TypeScript scope
 
-When `ts.files` is provided, it is the maximum TypeScript scope used by the
-other modules that automatically include TypeScript files. JavaScript files
-keep their normal scope, and a module's own `files` option can override this
-limit. Vitest additionally intersects its test-file patterns with this scope.
+`ts.files` limits the TypeScript files included by modules that automatically
+support TypeScript. JavaScript files keep their normal scope, and a module's
+own `files` option can narrow or override it. Vitest also intersects its test
+patterns with this scope.
 
 ```ts
 export default waltz({
@@ -84,16 +70,23 @@ export default waltz({
 })
 ```
 
-## VS Code synchronization
+### Module resolution
 
-Run this command from your project root to enable ESLint fix-on-save settings
-while preserving existing `.vscode/settings.json` values and comments:
+Potentially expensive module-resolution rules are disabled by default. Enable
+only the rules you need:
 
-```bash
-npx eslint-waltz sync-vscode
+```ts
+export default waltz({
+  imports: {
+    overrides: {
+      'imports/named': 'error',
+      'imports/namespace': 'error',
+    },
+  },
+})
 ```
 
-React plugin settings can be customized when needed:
+### React settings
 
 ```ts
 export default waltz({

package/dist/cli.js

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 import process$1 from 'node:process';
-import { readFile, mkdir, writeFile } from 'node:fs/promises';
+import { spawn } from 'node:child_process';
+import { readFile, mkdir, writeFile, rm, access } from 'node:fs/promises';
 import { join } from 'node:path';
+import { outro, note, intro, cancel, select, multiselect, confirm, CANCEL_SYMBOL } from '@clack/prompts';
 
 /*---------------------------------------------------------------------------------------------
  *  Copyright (c) Microsoft Corporation. All rights reserved.
@@ -1508,30 +1510,430 @@ async function syncVSCodeSettings(cwd = process.cwd()) {
     return { changed, filePath };
 }
 
-async function main() {
-    const [command] = process$1.argv.slice(2);
-    if (command === '--help' || command === '-h') {
-        printHelp();
-        return;
-    }
-    if (command !== 'sync-vscode') {
-        printHelp();
-        process$1.exitCode = 1;
-        return;
-    }
-    const result = await syncVSCodeSettings();
-    console.log(result.changed
-        ? `Updated ${result.filePath}`
-        : `${result.filePath} is already synchronized`);
+const packageManagers = ['pnpm', 'npm', 'yarn', 'bun'];
+const perfectionistPresets = [
+    'recommended-alphabetical',
+    'recommended-natural',
+    'recommended-line-length',
+    'recommended-custom',
+];
+const features = [
+    'json',
+    'imports',
+    'perfectionist',
+    'typescript',
+    'react',
+    'tailwindcss',
+    'gitignore',
+    'vitest',
+];
+const eslintConfigFiles = [
+    'eslint.config.ts',
+    'eslint.config.mts',
+    'eslint.config.cts',
+    'eslint.config.js',
+    'eslint.config.mjs',
+    'eslint.config.cjs',
+];
+class PromptCancelledError extends Error {
+}
+async function runInit(runtime) {
+    const cwd = runtime.cwd ?? process$1.cwd();
+    const output = runtime.output ?? process$1.stdout;
+    const prompts = runtime.prompts
+        ?? createClackPrompts(runtime.input ?? process$1.stdin, output);
+    try {
+        prompts.intro(`eslint-waltz ${runtime.metadata.version}`);
+        const projectPackage = await readProjectPackage(cwd);
+        const existingConfigs = await findExistingConfigs(cwd);
+        if (existingConfigs.length > 0) {
+            const shouldReplace = await prompts.confirm(`Replace ${existingConfigs.join(', ')} with eslint.config.ts?`, false);
+            if (!shouldReplace) {
+                prompts.cancel('Initialization cancelled.');
+                return;
+            }
+        }
+        const installed = getInstalledDependencies(projectPackage);
+        const selections = await collectSelections(cwd, projectPackage, installed, prompts);
+        const requiredDependencies = getRequiredDependencies(runtime.metadata, selections);
+        const missingDependencies = requiredDependencies.filter(({ name }) => !installed.has(name));
+        let shouldInstall = false;
+        if (missingDependencies.length > 0) {
+            prompts.note(missingDependencies.map(({ spec }) => spec).join('\n'), 'Dependencies to install');
+            shouldInstall = await prompts.confirm('Install these dependencies?', true);
+        }
+        if (shouldInstall) {
+            const install = runtime.install ?? installDependencies;
+            await install(selections.packageManager, missingDependencies.map(({ spec }) => spec), cwd);
+        }
+        const configPath = join(cwd, 'eslint.config.ts');
+        await writeFile(configPath, createConfig(selections), 'utf8');
+        for (const fileName of existingConfigs) {
+            if (fileName !== 'eslint.config.ts') {
+                await rm(join(cwd, fileName));
+            }
+        }
+        const completed = [
+            `${existingConfigs.length > 0 ? 'Updated' : 'Created'} ${configPath}`,
+        ];
+        if (selections.vscode) {
+            const result = await syncVSCodeSettings(cwd);
+            completed.push(result.changed
+                ? `Updated ${result.filePath}`
+                : `${result.filePath} is already synchronized`);
+        }
+        if (missingDependencies.length > 0 && !shouldInstall) {
+            prompts.note(formatInstallCommand(selections.packageManager, missingDependencies.map(({ spec }) => spec)), 'Dependency installation skipped');
+        }
+        prompts.note(completed.join('\n'), 'Files');
+        prompts.outro('eslint-waltz is ready.');
+    }
+    catch (error) {
+        if (error instanceof PromptCancelledError) {
+            prompts.cancel('Initialization cancelled.');
+            return;
+        }
+        throw error;
+    }
+}
+async function collectSelections(cwd, projectPackage, installed, prompts) {
+    const detectedPackageManager = await detectPackageManager(cwd, projectPackage);
+    const packageManager = await prompts.select('Which package manager should install the dependencies?', packageManagers.map(value => ({ label: value, value })), detectedPackageManager);
+    const selectedFeatures = await prompts.multiselect('Which features should be enabled?', [
+        { hint: 'default', label: 'JSON and JSONC', value: 'json' },
+        { hint: 'default', label: 'Import validation', value: 'imports' },
+        { hint: 'default', label: 'Perfectionist sorting', value: 'perfectionist' },
+        { label: 'TypeScript', value: 'typescript' },
+        { label: 'React', value: 'react' },
+        { label: 'Tailwind CSS', value: 'tailwindcss' },
+        { label: '.gitignore', value: 'gitignore' },
+        { label: 'Vitest', value: 'vitest' },
+    ], await detectInitialFeatures(cwd, installed));
+    const enabledFeatures = new Set(selectedFeatures);
+    for (const feature of enabledFeatures) {
+        if (!isFeature(feature)) {
+            throw new Error(`Unsupported feature: ${feature}`);
+        }
+    }
+    const perfectionist = enabledFeatures.has('perfectionist')
+        ? await selectPerfectionistPreset(prompts)
+        : 'recommended-alphabetical';
+    const vscode = await prompts.confirm('Configure VS Code fix-on-save settings?', await fileExists(join(cwd, '.vscode')));
+    if (!isPackageManager(packageManager)) {
+        throw new Error(`Unsupported package manager: ${packageManager}`);
+    }
+    return {
+        features: enabledFeatures,
+        packageManager,
+        perfectionist,
+        vscode,
+    };
+}
+function createClackPrompts(input, output) {
+    const io = { input, output };
+    return {
+        cancel: message => cancel(message, io),
+        async confirm(message, initial) {
+            return unwrapPromptResult(await confirm({
+                ...io,
+                initialValue: initial,
+                message,
+            }));
+        },
+        intro: message => intro(message, io),
+        async multiselect(message, choices, initial) {
+            return unwrapPromptResult(await multiselect({
+                ...io,
+                initialValues: initial,
+                message,
+                options: [...choices],
+                required: false,
+            }));
+        },
+        note: (message, title) => note(message, title, io),
+        outro: message => outro(message, io),
+        async select(message, choices, initial) {
+            return unwrapPromptResult(await select({
+                ...io,
+                initialValue: initial,
+                message,
+                options: [...choices],
+            }));
+        },
+    };
+}
+function createConfig(selections) {
+    const options = [];
+    const { features } = selections;
+    if (features.has('gitignore')) {
+        options.push('  gitignore: true,');
+    }
+    if (!features.has('imports')) {
+        options.push('  imports: false,');
+    }
+    if (!features.has('json')) {
+        options.push('  json: false,');
+    }
+    if (!features.has('perfectionist')) {
+        options.push('  perfectionist: false,');
+    }
+    else if (selections.perfectionist !== 'recommended-alphabetical') {
+        options.push(`  perfectionist: { preset: '${selections.perfectionist}' },`);
+    }
+    if (features.has('react')) {
+        options.push('  react: true,');
+    }
+    if (features.has('tailwindcss')) {
+        options.push('  tailwindcss: true,');
+    }
+    if (features.has('typescript')) {
+        options.push('  ts: true,');
+    }
+    if (features.has('vitest')) {
+        options.push('  vitest: true,');
+    }
+    const invocation = options.length === 0
+        ? 'waltz()'
+        : `waltz({\n${options.join('\n')}\n})`;
+    return `import waltz from '@chanyuxi/eslint-waltz'\n\nexport default ${invocation}\n`;
+}
+async function detectInitialFeatures(cwd, installed) {
+    const initial = ['json', 'imports', 'perfectionist'];
+    if (installed.has('typescript')
+        || installed.has('typescript-eslint')
+        || await fileExists(join(cwd, 'tsconfig.json'))) {
+        initial.push('typescript');
+    }
+    if (installed.has('react') || installed.has('preact')) {
+        initial.push('react');
+    }
+    if (installed.has('tailwindcss')) {
+        initial.push('tailwindcss');
+    }
+    if (await fileExists(join(cwd, '.gitignore'))) {
+        initial.push('gitignore');
+    }
+    if (installed.has('vitest')) {
+        initial.push('vitest');
+    }
+    return initial;
+}
+async function detectPackageManager(cwd, projectPackage) {
+    const configured = projectPackage.packageManager?.split('@')[0];
+    if (isPackageManager(configured)) {
+        return configured;
+    }
+    const lockFiles = [
+        ['pnpm', 'pnpm-lock.yaml'],
+        ['yarn', 'yarn.lock'],
+        ['bun', 'bun.lock'],
+        ['bun', 'bun.lockb'],
+        ['npm', 'package-lock.json'],
+    ];
+    for (const [packageManager, lockFile] of lockFiles) {
+        if (await fileExists(join(cwd, lockFile))) {
+            return packageManager;
+        }
+    }
+    return 'npm';
+}
+async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function findExistingConfigs(cwd) {
+    const results = await Promise.all(eslintConfigFiles.map(async (fileName) => ({
+        exists: await fileExists(join(cwd, fileName)),
+        fileName,
+    })));
+    return results.filter(result => result.exists).map(result => result.fileName);
+}
+function formatInstallCommand(packageManager, dependencies) {
+    return getInstallCommand(packageManager, dependencies).join(' ');
 }
-function printHelp() {
-    console.log(`Usage: eslint-waltz <command>
+function getDependencySpec(metadata, name) {
+    if (name === metadata.name) {
+        return `${name}@${metadata.version}`;
+    }
+    const version = metadata.peerDependencies?.[name]
+        ?? metadata.dependencies?.[name]
+        ?? metadata.devDependencies?.[name];
+    return version ? `${name}@${version}` : name;
+}
+function getInstallCommand(packageManager, dependencies) {
+    switch (packageManager) {
+        case 'npm':
+            return ['npm', 'install', '--save-dev', ...dependencies];
+        case 'yarn':
+            return ['yarn', 'add', '--dev', ...dependencies];
+        default:
+            return [packageManager, 'add', '-D', ...dependencies];
+    }
+}
+function getInstalledDependencies(projectPackage) {
+    return new Set([
+        ...Object.keys(projectPackage.dependencies ?? {}),
+        ...Object.keys(projectPackage.devDependencies ?? {}),
+        ...Object.keys(projectPackage.optionalDependencies ?? {}),
+    ]);
+}
+function getRequiredDependencies(metadata, selections) {
+    const names = [metadata.name, 'eslint', 'jiti'];
+    const { features } = selections;
+    if (features.has('gitignore')) {
+        names.push('eslint-config-flat-gitignore');
+    }
+    if (features.has('imports')) {
+        names.push('eslint-plugin-import-x');
+    }
+    if (features.has('json')) {
+        names.push('eslint-plugin-jsonc', 'jsonc-eslint-parser');
+    }
+    if (features.has('perfectionist')) {
+        names.push('eslint-plugin-perfectionist');
+    }
+    if (features.has('react')) {
+        names.push('eslint-plugin-react-debug', 'eslint-plugin-react-dom', 'eslint-plugin-react-hooks-extra', 'eslint-plugin-react-naming-convention', 'eslint-plugin-react-web-api', 'eslint-plugin-react-x');
+    }
+    if (features.has('tailwindcss')) {
+        names.push('eslint-plugin-tailwindcss', 'tailwindcss');
+    }
+    if (features.has('typescript')) {
+        names.push('typescript', 'typescript-eslint');
+    }
+    if (features.has('vitest')) {
+        names.push('@vitest/eslint-plugin', 'vitest');
+    }
+    return names.map(name => ({
+        name,
+        spec: getDependencySpec(metadata, name),
+    }));
+}
+async function installDependencies(packageManager, dependencies, cwd) {
+    const [command, ...args] = getInstallCommand(packageManager, dependencies);
+    const child = spawn(command, args, {
+        cwd,
+        shell: process$1.platform === 'win32',
+        stdio: 'inherit',
+    });
+    await new Promise((resolve, reject) => {
+        child.on('error', reject);
+        child.on('exit', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`${command} exited with code ${code ?? 'unknown'}.`));
+            }
+        });
+    });
+}
+function isFeature(value) {
+    return features.some(feature => feature === value);
+}
+function isPackageManager(value) {
+    return packageManagers.some(packageManager => packageManager === value);
+}
+function isPerfectionistPreset(value) {
+    return perfectionistPresets.some(preset => preset === value);
+}
+async function readProjectPackage(cwd) {
+    const filePath = join(cwd, 'package.json');
+    try {
+        return JSON.parse(await readFile(filePath, 'utf8'));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new Error(`package.json was not found in ${cwd}.`);
+        }
+        throw new Error(`Unable to read ${filePath}: ${error instanceof Error ? error.message : error}`);
+    }
+}
+async function selectPerfectionistPreset(prompts) {
+    const preset = await prompts.select('Which Perfectionist preset should be used?', [
+        {
+            hint: 'recommended',
+            label: 'Alphabetical',
+            value: 'recommended-alphabetical',
+        },
+        { label: 'Natural', value: 'recommended-natural' },
+        { label: 'Line length', value: 'recommended-line-length' },
+        { label: 'Custom', value: 'recommended-custom' },
+    ], 'recommended-alphabetical');
+    if (!isPerfectionistPreset(preset)) {
+        throw new Error(`Unsupported Perfectionist preset: ${preset}`);
+    }
+    return preset;
+}
+function unwrapPromptResult(result) {
+    if (result === CANCEL_SYMBOL) {
+        throw new PromptCancelledError();
+    }
+    return result;
+}
+
+async function readPackageMetadata() {
+    for (const relativePath of ['../package.json', '../../package.json']) {
+        try {
+            const source = await readFile(new URL(relativePath, import.meta.url), 'utf8');
+            const metadata = JSON.parse(source);
+            if (metadata.name === '@chanyuxi/eslint-waltz') {
+                return metadata;
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+        }
+    }
+    throw new Error('Unable to locate the eslint-waltz package metadata.');
+}
+
+async function runCli(args, runtime = {}) {
+    const output = runtime.output ?? process$1.stdout;
+    const [command, ...rest] = args;
+    if ((command === '--help' || command === '-h') && rest.length === 0) {
+        printHelp(output);
+        return 0;
+    }
+    if (command === 'version' && rest.length === 0) {
+        const metadata = runtime.metadata ?? await readPackageMetadata();
+        output.write(`${metadata.version}\n`);
+        return 0;
+    }
+    if (command === 'init' && rest.length === 0) {
+        const metadata = runtime.metadata ?? await readPackageMetadata();
+        await runInit({
+            cwd: runtime.cwd,
+            input: runtime.input,
+            install: runtime.install,
+            metadata,
+            output,
+            prompts: runtime.prompts,
+        });
+        return 0;
+    }
+    printHelp(output);
+    return 1;
+}
+function printHelp(output) {
+    output.write(`Usage: eslint-waltz <command>
 
 Commands:
-  sync-vscode  Create or update .vscode/settings.json for ESLint fix-on-save
+  version  Display the installed eslint-waltz version
+  init     Interactively create eslint.config.ts
 `);
 }
-main().catch((error) => {
+
+runCli(process$1.argv.slice(2)).then((exitCode) => {
+    process$1.exitCode = exitCode;
+}, (error) => {
     console.error(error instanceof Error ? error.message : error);
     process$1.exitCode = 1;
 });

package/dist/core.d.ts

@@ -0,0 +1,5 @@
+import { WaltzOptions, LinterConfig } from './types.js';
+
+declare function waltz(options?: WaltzOptions, ...orders: LinterConfig[]): Promise<LinterConfig[]>;
+
+export { waltz as default };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { WaltzOptions, LinterConfig } from './types.js';
-export { ImportsOptions, JsOptions, JsoncOptions, PerfectionistOptions, PerfectionistPreset, ReactOptions, SharedOptions, StylisticOptions, TailwindcssOptions, TsOptions, UnresolvedLinterConfig, VitestOptions } from './types.js';
+import waltz from './core.js';
+export { ImportsOptions, JsOptions, JsoncOptions, LinterConfig, PerfectionistOptions, PerfectionistPreset, ReactOptions, SharedOptions, StylisticOptions, TailwindcssOptions, TsOptions, UnresolvedLinterConfig, VitestOptions, WaltzOptions } from './types.js';
 
-declare function waltz(options?: WaltzOptions, ...orders: LinterConfig[]): Promise<LinterConfig[]>;
 
-export { LinterConfig, WaltzOptions, waltz as default };
+
+export { waltz as default };

package/dist/index.js

@@ -92,32 +92,6 @@ const JSON_FILES = '**/*.{json,json5,jsonc}';
 const PACKAGE_JSON_FILES = ['**/package.json'];
 const TS_CONFIG_FILES = ['**/[jt]sconfig.json', '**/[jt]sconfig.*.json'];
 const INTERNAL_IMPORT_GLOB = '@/**';
-function getImportOrderGroups() {
-    return [
-        'type',
-        'builtin',
-        'external',
-        'internal',
-        'parent',
-        'sibling',
-        'index',
-        'object',
-        'unknown',
-    ];
-}
-function getPerfectionistImportGroups() {
-    return [
-        'type',
-        'builtin',
-        'external',
-        'internal',
-        'parent',
-        'sibling',
-        'index',
-        'style',
-        'unknown',
-    ];
-}
 
 function getScriptFiles(scope) {
     return scope.isEnableTypeScript
@@ -200,7 +174,17 @@ async function importsConfig(scriptScope, options = {}) {
                     orderImportKind: 'asc',
                 },
                 'distinctGroup': false,
-                'groups': getImportOrderGroups(),
+                'groups': [
+                    'type',
+                    'builtin',
+                    'external',
+                    'internal',
+                    'parent',
+                    'sibling',
+                    'index',
+                    'object',
+                    'unknown',
+                ],
                 'named': true,
                 'newlines-between': 'always',
                 'pathGroups': [
@@ -606,7 +590,17 @@ async function perfectionistConfig(options = {}, scriptScope) {
                     'error',
                     {
                         ...importSortOptions,
-                        groups: getPerfectionistImportGroups(),
+                        groups: [
+                            'type',
+                            'builtin',
+                            'external',
+                            'internal',
+                            'parent',
+                            'sibling',
+                            'index',
+                            'style',
+                            'unknown',
+                        ],
                         internalPattern: ['^@/.+'],
                     },
                 ],
@@ -855,8 +849,9 @@ async function stylisticConfig(options = {}, scriptScope) {
                 '@stylistic/jsx-curly-newline': 'error',
                 '@stylistic/jsx-curly-spacing': ['error', 'never'],
                 '@stylistic/jsx-equals-spacing': 'error',
-                '@stylistic/jsx-first-prop-new-line': 'error',
-                '@stylistic/jsx-function-call-newline': ['error', 'multiline'],
+                // My style is to place each attribute in JSX on its own line, which makes it easier to read.
+                '@stylistic/jsx-first-prop-new-line': ['error', 'multiprop'],
+                '@stylistic/jsx-function-call-newline': ['error', 'always'],
                 '@stylistic/jsx-indent-props': ['error', 2],
                 '@stylistic/jsx-max-props-per-line': [
                     'error',

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@chanyuxi/eslint-waltz",
   "type": "module",
-  "version": "1.4.0",
+  "version": "1.5.1",
   "packageManager": "pnpm@10.4.1",
   "description": "A composable ESLint flat config for JavaScript, TypeScript, JSONC, imports, React, Tailwind CSS, Perfectionist, and Vitest.",
   "author": "chanyuxi <2438149743@qq.com> (https://github.com/chanyuxi)",
@@ -107,6 +107,7 @@
     }
   },
   "dependencies": {
+    "@clack/prompts": "^1.8.1",
     "@eslint/js": "^10.0.1",
     "@stylistic/eslint-plugin": "^5.10.0",
     "globals": "^17.12.0",