lintmax 0.0.11 → 0.0.12

package/README.md

@@ -1,105 +1,49 @@
 # lintmax
 
-Maximum strictness linting, formatting, and type-checking in one package.
+Opinionated max-strict lint/format/typecheck with a minimal config surface.
 
-Wraps **6 tools** into a single CLI: [Biome](https://biomejs.dev), [oxlint](https://oxc.rs), [ESLint](https://eslint.org), [Prettier](https://prettier.io) (markdown), [sort-package-json](https://github.com/keithamus/sort-package-json), and [Flowmark](https://github.com/jlevy/flowmark) (optional).
+## Quick start
 
-All rules enabled at `error` by default. You only disable what you don’t need.
-
-## Install
+Install and initialize:
 
 ```bash
 bun add -d lintmax
 bunx lintmax init
 ```
 
-`lintmax init` scaffolds:
-
-- `tsconfig.json` extending `lintmax/tsconfig`
-- `package.json` scripts (`fix`, `check`)
-- `.gitignore` entries
-- `.vscode/settings.json` (biome formatter, eslint, codeActionsOnSave)
-- `.vscode/extensions.json`
-
-## Usage
+Run checks:
 
 ```bash
-bun fix    # auto-fix and format everything
-bun check  # check without modifying
+bun fix
+bun check
 ```
 
-## Customization
+`lintmax` works without configuration. Add `lintmax.config.ts` only when you need to tune behavior.
+
+## Canonical knobs
 
-### Biome and oxlint overrides
+- `off`: disable rules
+- `ignores`: ignore file globs
+- `overrides`: map file globs to per-linter `off` arrays
 
-Create `lintmax.config.ts`:
+Example:
 
 ```ts
 import { defineConfig } from 'lintmax'
 
 export default defineConfig({
-  compact: true,
-  globalIgnorePatterns: ['packages/ui/**', '.intlayer/cache/**'],
-  biome: {
-    rules: { noBarrelFile: 'off' },
-    overrides: [{ disableLinter: true, includes: ['packages/ui/**'] }]
-  },
-  oxlint: {
-    ignorePatterns: ['_generated/'],
-    rules: { 'unicorn/filename-case': 'off' }
-  }
-})
-```
-
-- `globalIgnorePatterns` appends patterns to Biome, ESLint, and oxlint ignore sets.
-- `compact` runs a whitespace compaction pass before linting (`false` by default).
-- `lintmax fix`: rewrites tracked/untracked text files by collapsing 2+ blank lines to 1.
-- `lintmax check`: verifies compaction state without modifying files.
-
-### ESLint overrides
-
-Create `eslint.config.ts`:
-
-```ts
-import { eslint } from 'lintmax/eslint'
-
-export default eslint({
-  rules: { '@typescript-eslint/no-magic-numbers': 'off' },
   ignores: ['vendor/**'],
-  tailwind: 'src/styles/globals.css',
-  append: [{ files: ['tests/**'], rules: { 'no-magic-numbers': 'off' } }]
+  eslint: { off: ['@typescript-eslint/no-magic-numbers'] },
+  overrides: {
+    '**/*.test.ts': {
+      eslint: ['no-console'],
+      oxlint: ['no-console'],
+      biome: ['noConsole']
+    }
+  }
 })
 ```
 
-Without `eslint.config.ts`, lintmax generates a default config automatically.
-
-### TypeScript
-
-`tsconfig.json`:
-
-```json
-{ "extends": "lintmax/tsconfig" }
-```
-
-Strict mode, bundler resolution, ESNext target, JSX preserve. One preset for all.
-
-## How it stays up to date
-
-Biome config is built **dynamically** from the installed `@biomejs/biome` schema at runtime. New rules, category changes, and nursery promotions are picked up automatically.
-
-ESLint plugins and oxlint are dependencies with auto-updating versions. Run `bun update` to get the latest rules without waiting for a lintmax release.
-
-## What each tool handles
-
-| Tool              | Scope                                                                           |
-| ----------------- | ------------------------------------------------------------------------------- |
-| Biome             | Formatting (JS/TS/JSX/TSX/CSS/JSON) + linting                                   |
-| oxlint            | Fast linting (correctness, perf, style, pedantic)                               |
-| ESLint            | Type-aware linting (typescript-eslint, React, Next.js, Tailwind, Perfectionist) |
-| Prettier          | Markdown formatting                                                             |
-| sort-package-json | package.json field ordering                                                     |
-| Flowmark          | Markdown prose wrapping (optional, uses system install)                         |
-
-## License
+Advanced options: `doc/advanced-configuration.md`.
 
-MIT
+License: MIT

package/dist/cli.js

@@ -1,499 +1,24 @@
 #!/usr/bin/env bun
-import { env as bunEnv, file, spawnSync, write } from 'bun';
-import { cacheDir, sync } from './index.js';
-import { dirnamePath, fromFileUrl, joinPath } from './path.js';
-class CliExitError extends Error {
-    code;
-    constructor({ code, message }) {
-        super(message ?? '');
-        this.code = code;
-    }
-}
-const COMPACT_REGEX = /(?:\r?\n){2,}/gu, compactBasenames = new Set(['.env.example', '.gitignore', '.npmrc', '.prettierignore', 'Dockerfile', 'Makefile']), compactExtensions = new Set([
-    '.cjs',
-    '.css',
-    '.gql',
-    '.graphql',
-    '.html',
-    '.js',
-    '.json',
-    '.jsonc',
-    '.jsx',
-    '.md',
-    '.mjs',
-    '.mts',
-    '.scss',
-    '.sql',
-    '.ts',
-    '.tsx',
-    '.txt',
-    '.yaml',
-    '.yml'
-]), decoder = new TextDecoder(), cwd = process.cwd(), cmd = process.argv[2], ignoreEntries = ['.cache/', '.eslintcache'], lintmaxRoot = dirnamePath(dirnamePath(fromFileUrl(import.meta.url))), decodeText = (bytes) => decoder.decode(bytes ?? new Uint8Array()), pathExists = async ({ path }) => file(path).exists(), readJson = async ({ path }) => {
-    if (!(await pathExists({ path })))
-        return {};
-    try {
-        const text = await file(path).text();
-        return JSON.parse(text);
-    }
-    catch {
-        return {};
-    }
-}, readRequiredJson = async ({ path }) => {
-    const text = await file(path).text();
-    return JSON.parse(text);
-}, writeJson = async ({ data, path }) => write(path, `${JSON.stringify(data, null, 2)}\n`), basename = ({ path }) => {
-    const index = path.lastIndexOf('/');
-    if (index === -1)
-        return path;
-    return path.slice(index + 1);
-}, extension = ({ path }) => {
-    const slashIndex = path.lastIndexOf('/'), dotIndex = path.lastIndexOf('.');
-    return dotIndex > slashIndex ? path.slice(dotIndex) : '';
-}, compactContent = ({ content }) => content.replace(COMPACT_REGEX, '\n'), isCompactCandidate = ({ relativePath }) => {
-    const fileName = basename({ path: relativePath });
-    if (compactBasenames.has(fileName))
-        return true;
-    return compactExtensions.has(extension({ path: relativePath }));
-}, isBinary = ({ bytes }) => {
-    for (const byte of bytes)
-        if (byte === 0)
-            return true;
-    return false;
-}, listCompactFiles = ({ env, root }) => {
-    const result = spawnSync({
-        cmd: ['git', '-C', root, 'ls-files', '-z', '--cached', '--others', '--exclude-standard'],
-        env,
-        stderr: 'pipe',
-        stdout: 'pipe'
-    });
-    if (result.exitCode !== 0) {
-        const stderr = decodeText(result.stderr).trim();
-        throw new CliExitError({
-            code: result.exitCode,
-            message: stderr.length > 0 ? stderr : 'Failed to list files for compact step'
-        });
-    }
-    const entries = decodeText(result.stdout).split('\0'), files = [];
-    for (const entry of entries)
-        if (entry.length > 0 && entry !== 'bun.lock')
-            files.push(entry);
-    return files;
-}, runCompact = async ({ env, mode, root }) => {
-    const files = listCompactFiles({ env, root }), results = await Promise.all(files.map(async (relativePath) => {
-        if (!isCompactCandidate({ relativePath }))
-            return { changed: false, relativePath, scanned: false };
-        const absolutePath = joinPath(root, relativePath), source = file(absolutePath);
-        if (!(await source.exists()))
-            return { changed: false, relativePath, scanned: false };
-        const bytes = new Uint8Array(await source.arrayBuffer());
-        if (isBinary({ bytes }))
-            return { changed: false, relativePath, scanned: true };
-        const content = decodeText(bytes), compacted = compactContent({ content });
-        if (content === compacted)
-            return { changed: false, relativePath, scanned: true };
-        if (mode === 'fix')
-            await write(absolutePath, compacted);
-        return { changed: true, relativePath, scanned: true };
-    })), changed = [];
-    let scanned = 0;
-    for (const result of results) {
-        if (result.scanned)
-            scanned += 1;
-        if (result.changed)
-            changed.push(result.relativePath);
-    }
-    if (mode === 'fix') {
-        process.stdout.write(`[compact] Scanned ${scanned} files\n`);
-        process.stdout.write(`[compact] Updated ${changed.length} files\n`);
-        return;
-    }
-    if (changed.length === 0)
-        return;
-    const shown = changed.slice(0, 10), suffix = changed.length > shown.length ? `\n...and ${changed.length - shown.length} more` : '';
-    throw new CliExitError({
-        code: 1,
-        message: `[compact]\nFiles requiring compaction:\n${shown.join('\n')}${suffix}\nRun: lintmax fix`
-    });
-}, ensureDirectory = ({ directory }) => {
-    const result = spawnSync({
-        cmd: ['mkdir', '-p', directory],
-        stderr: 'pipe',
-        stdout: 'pipe'
-    });
-    if (result.exitCode === 0)
-        return;
-    const stderr = decodeText(result.stderr).trim();
-    throw new CliExitError({
-        code: result.exitCode,
-        message: stderr.length > 0 ? stderr : `Failed to create directory: ${directory}`
-    });
-}, sortKeys = (obj) => {
-    const sorted = {}, keys = Object.keys(obj).toSorted();
-    for (const key of keys)
-        sorted[key] = obj[key];
-    return sorted;
-}, initScripts = async ({ pkg, pkgPath }) => {
-    const scripts = pkg.scripts ?? {};
-    let changed = false;
-    if (!scripts.fix) {
-        scripts.fix = 'lintmax fix';
-        changed = true;
-    }
-    if (!scripts.check) {
-        scripts.check = 'lintmax check';
-        changed = true;
-    }
-    if (!changed)
-        return;
-    pkg.scripts = scripts;
-    await writeJson({ data: pkg, path: pkgPath });
-}, initTsconfig = async ({ configFiles }) => {
-    const tsconfigPath = joinPath(cwd, 'tsconfig.json');
-    if (!(await pathExists({ path: tsconfigPath }))) {
-        const tsconfig = { extends: 'lintmax/tsconfig' };
-        if (configFiles.length > 0)
-            tsconfig.include = configFiles;
-        await writeJson({ data: tsconfig, path: tsconfigPath });
-        return;
-    }
-    try {
-        const tsconfig = await readRequiredJson({ path: tsconfigPath });
-        let changed = false;
-        if (tsconfig.extends !== 'lintmax/tsconfig') {
-            tsconfig.extends = 'lintmax/tsconfig';
-            changed = true;
-        }
-        const toAdd = configFiles.filter(f => !(tsconfig.include ?? []).includes(f));
-        if (toAdd.length > 0) {
-            tsconfig.include = [...(tsconfig.include ?? []), ...toAdd];
-            changed = true;
-        }
-        if (changed)
-            await writeJson({ data: tsconfig, path: tsconfigPath });
-    }
-    catch {
-        process.stderr.write('tsconfig.json: could not parse, add "extends": "lintmax/tsconfig" manually\n');
-    }
-}, initGitignore = async () => {
-    const gitignorePath = joinPath(cwd, '.gitignore');
-    if (await pathExists({ path: gitignorePath })) {
-        const content = await file(gitignorePath).text(), toAdd = [];
-        for (const entry of ignoreEntries)
-            if (!content.includes(entry))
-                toAdd.push(entry);
-        if (toAdd.length > 0)
-            await write(gitignorePath, `${content.trimEnd()}\n${toAdd.join('\n')}\n`);
-        return;
-    }
-    await write(gitignorePath, `${ignoreEntries.join('\n')}\n`);
-}, initVscodeSettings = async ({ pkg }) => {
-    const vscodePath = joinPath(cwd, '.vscode');
-    ensureDirectory({ directory: vscodePath });
-    const settingsPath = joinPath(vscodePath, 'settings.json'), settings = await readJson({ path: settingsPath });
-    settings['biome.configPath'] = 'node_modules/.cache/lintmax/biome.json';
-    const formatterLangs = [
-        'css',
-        'graphql',
-        'javascript',
-        'javascriptreact',
-        'json',
-        'jsonc',
-        'typescript',
-        'typescriptreact'
-    ];
-    for (const lang of formatterLangs) {
-        const key = `[${lang}]`, existing = (settings[key] ?? {});
-        settings[key] = {
-            ...existing,
-            'editor.defaultFormatter': 'biomejs.biome'
-        };
-    }
-    const existingActions = (settings['editor.codeActionsOnSave'] ?? {});
-    settings['editor.codeActionsOnSave'] = {
-        ...existingActions,
-        'source.fixAll.biome': 'always',
-        'source.fixAll.eslint': 'always',
-        'source.organizeImports.biome': 'always'
-    };
-    settings['editor.formatOnSave'] = true;
-    settings['eslint.rules.customizations'] = [{ rule: '*', severity: 'warn' }];
-    if (pkg.workspaces && !settings['eslint.workingDirectories']) {
-        const dirs = [];
-        for (const ws of pkg.workspaces) {
-            const pattern = ws.endsWith('/') ? ws : `${ws}/`;
-            dirs.push({ pattern });
-        }
-        if (dirs.length > 0)
-            settings['eslint.workingDirectories'] = dirs;
-    }
-    await writeJson({ data: sortKeys(settings), path: settingsPath });
-}, initVscodeExtensions = async () => {
-    const extensionsPath = joinPath(cwd, '.vscode', 'extensions.json'), extJson = (await readJson({ path: extensionsPath })), recommendations = ['biomejs.biome', 'dbaeumer.vscode-eslint'], currentRecs = extJson.recommendations ?? [], recsToAdd = [];
-    for (const rec of recommendations)
-        if (!currentRecs.includes(rec))
-            recsToAdd.push(rec);
-    if (recsToAdd.length > 0 || !extJson.recommendations) {
-        extJson.recommendations = [...currentRecs, ...recsToAdd];
-        await writeJson({ data: extJson, path: extensionsPath });
-    }
-}, findLegacyConfigs = async () => {
-    const legacyConfigs = [
-        '.eslintrc',
-        '.eslintrc.json',
-        '.eslintrc.js',
-        '.eslintrc.cjs',
-        '.eslintrc.yml',
-        '.eslintrc.yaml',
-        '.prettierrc',
-        '.prettierrc.json',
-        '.prettierrc.js',
-        '.prettierrc.yml',
-        '.prettierrc.yaml',
-        '.prettierrc.toml',
-        'biome.json',
-        'biome.jsonc',
-        '.oxlintrc.json'
-    ], checks = legacyConfigs.map(async (configFile) => ({
-        configFile,
-        exists: await pathExists({ path: joinPath(cwd, configFile) })
-    })), resolved = await Promise.all(checks), found = [];
-    for (const item of resolved)
-        if (item.exists)
-            found.push(item.configFile);
-    return found;
-}, readVersion = async () => {
-    const pkg = await readRequiredJson({
-        path: joinPath(lintmaxRoot, 'package.json')
-    });
-    return pkg.version;
-}, usage = ({ version }) => {
-    process.stdout.write(`lintmax v${version}\n\n`);
-    process.stdout.write('Usage: lintmax <command>\n\n');
-    process.stdout.write('Commands:\n');
-    process.stdout.write('  init     Scaffold config files for a new project\n');
-    process.stdout.write('  fix      Auto-fix and format all files\n');
-    process.stdout.write('  check    Check all files without modifying\n');
-    process.stdout.write('  --version  Show version\n');
-}, resolvePackageJsonPath = async ({ pkg }) => {
-    try {
-        return fromFileUrl(import.meta.resolve(`${pkg}/package.json`));
-    }
-    catch {
-        const consumerCandidate = joinPath(cwd, 'node_modules', pkg, 'package.json');
-        if (await pathExists({ path: consumerCandidate }))
-            return consumerCandidate;
-        return null;
-    }
-}, resolveBin = async ({ bin, pkg }) => {
-    const packageJsonPath = await resolvePackageJsonPath({ pkg });
-    if (!packageJsonPath)
-        throw new CliExitError({
-            code: 1,
-            message: `Cannot find ${pkg} — run: bun add -d lintmax`
-        });
-    const pkgJson = await readRequiredJson({ path: packageJsonPath }), pkgDir = dirnamePath(packageJsonPath), binPath = typeof pkgJson.bin === 'string' ? pkgJson.bin : (pkgJson.bin?.[bin] ?? '');
-    return joinPath(pkgDir, binPath);
-}, run = ({ args, command, env, label, silent = false }) => {
-    const result = spawnSync({
-        cmd: [command, ...args],
-        cwd,
-        env,
-        stderr: silent ? 'pipe' : 'inherit',
-        stdout: silent ? 'pipe' : 'inherit'
-    });
-    if (result.exitCode === 0)
-        return;
-    if (silent) {
-        process.stderr.write(`[${label}]\n`);
-        const stdout = decodeText(result.stdout);
-        if (stdout.length > 0)
-            process.stderr.write(stdout);
-        const stderr = decodeText(result.stderr);
-        if (stderr.length > 0)
-            process.stderr.write(stderr);
-    }
-    throw new CliExitError({ code: result.exitCode });
-}, runInit = async () => {
-    const pkgPath = joinPath(cwd, 'package.json');
-    if (!(await pathExists({ path: pkgPath })))
-        throw new CliExitError({ code: 1, message: 'No package.json found' });
-    const pkg = await readRequiredJson({ path: pkgPath }), configFiles = [];
-    if (await pathExists({ path: joinPath(cwd, 'eslint.config.ts') }))
-        configFiles.push('eslint.config.ts');
-    if (await pathExists({ path: joinPath(cwd, 'lintmax.config.ts') }))
-        configFiles.push('lintmax.config.ts');
-    await initScripts({ pkg, pkgPath });
-    await initTsconfig({ configFiles });
-    await initGitignore();
-    await initVscodeSettings({ pkg });
-    await initVscodeExtensions();
-    const foundLegacy = await findLegacyConfigs();
-    process.stdout.write('tsconfig.json    extends lintmax/tsconfig');
-    if (configFiles.length > 0)
-        process.stdout.write(`, include: ${configFiles.join(', ')}`);
-    process.stdout.write('\n');
-    process.stdout.write('package.json     "fix": "lintmax fix", "check": "lintmax check"\n');
-    process.stdout.write(`.gitignore       ${ignoreEntries.join(', ')}\n`);
-    process.stdout.write('.vscode/settings biome formatter, codeActionsOnSave, eslint\n');
-    process.stdout.write('.vscode/ext      biomejs.biome, dbaeumer.vscode-eslint\n');
-    if (foundLegacy.length > 0)
-        process.stdout.write(`\nLegacy configs found (can be removed): ${foundLegacy.join(', ')}\n`);
-    process.stdout.write('\nRun: bun fix\n');
-}, runLint = async () => {
-    const dir = joinPath(cwd, cacheDir);
-    ensureDirectory({ directory: dir });
-    const configPath = joinPath(cwd, 'lintmax.config.ts'), hasConfig = await pathExists({ path: configPath }), bundledBinA = joinPath(lintmaxRoot, 'node_modules', '.bin'), bundledBinB = joinPath(dirnamePath(lintmaxRoot), '.bin'), cwdBinDir = joinPath(cwd, 'node_modules', '.bin'), runtimePath = joinPath(dir, 'lintmax.json'), env = {
-        ...bunEnv,
-        PATH: `${bundledBinA}:${bundledBinB}:${cwdBinDir}:${bunEnv.PATH ?? ''}`
-    };
-    if (hasConfig)
-        run({
-            args: [
-                '-e',
-                `const m = await import('${configPath}'); const { sync: s } = await import('lintmax'); await s(m.default);`
-            ],
-            command: 'bun',
-            env,
-            label: 'config',
-            silent: true
-        });
-    else
-        await sync();
-    const runtime = (await readJson({ path: runtimePath }));
-    if (runtime.compact === true)
-        await runCompact({
-            env,
-            mode: cmd === 'fix' ? 'fix' : 'check',
-            root: cwd
-        });
-    const hasEslintConfig = (await pathExists({ path: joinPath(cwd, 'eslint.config.ts') })) ||
-        (await pathExists({ path: joinPath(cwd, 'eslint.config.js') })) ||
-        (await pathExists({ path: joinPath(cwd, 'eslint.config.mjs') })), eslintArgs = hasEslintConfig ? [] : ['--config', joinPath(dir, 'eslint.config.mjs')], [sortPkgJson, biomeBin, oxlintBin, eslintBin, prettierBin] = await Promise.all([
-        resolveBin({ bin: 'sort-package-json', pkg: 'sort-package-json' }),
-        resolveBin({ bin: 'biome', pkg: '@biomejs/biome' }),
-        resolveBin({ bin: 'oxlint', pkg: 'oxlint' }),
-        resolveBin({ bin: 'eslint', pkg: 'eslint' }),
-        resolveBin({ bin: 'prettier', pkg: 'prettier' })
-    ]), prettierMd = [
-        '--single-quote',
-        '--no-semi',
-        '--trailing-comma',
-        'none',
-        '--print-width',
-        '80',
-        '--arrow-parens',
-        'avoid',
-        '--tab-width',
-        '2',
-        '--prose-wrap',
-        'preserve'
-    ], hasFlowmark = spawnSync({
-        cmd: ['which', 'flowmark'],
-        env,
-        stderr: 'pipe',
-        stdout: 'pipe'
-    }).exitCode === 0;
-    if (cmd === 'fix') {
-        run({
-            args: [sortPkgJson, '**/package.json', '--ignore', '**/node_modules/**'],
-            command: 'bun',
-            env,
-            label: 'sort-package-json',
-            silent: true
-        });
-        run({
-            args: [biomeBin, 'check', '--config-path', dir, '--fix', '--diagnostic-level=error'],
-            command: 'bun',
-            env,
-            label: 'biome',
-            silent: true
-        });
-        run({
-            args: [oxlintBin, '-c', joinPath(dir, '.oxlintrc.json'), '--fix', '--fix-suggestions', '--quiet'],
-            command: 'bun',
-            env,
-            label: 'oxlint',
-            silent: true
-        });
-        run({
-            args: [eslintBin, ...eslintArgs, '--fix', '--cache', '--cache-location', joinPath(cwd, '.cache', '.eslintcache')],
-            command: 'bun',
-            env,
-            label: 'eslint',
-            silent: true
-        });
-        run({
-            args: [biomeBin, 'check', '--config-path', dir, '--fix', '--diagnostic-level=error'],
-            command: 'bun',
-            env,
-            label: 'biome',
-            silent: true
-        });
-        if (hasFlowmark)
-            run({
-                args: ['-w', '0', '--auto', '.'],
-                command: 'flowmark',
-                env,
-                label: 'flowmark',
-                silent: true
-            });
-        run({
-            args: [prettierBin, ...prettierMd, '--write', '--no-error-on-unmatched-pattern', '**/*.md'],
-            command: 'bun',
-            env,
-            label: 'prettier',
-            silent: true
-        });
-        return;
-    }
-    run({
-        args: [sortPkgJson, '--check', '**/package.json', '--ignore', '**/node_modules/**'],
-        command: 'bun',
-        env,
-        label: 'sort-package-json'
-    });
-    run({
-        args: [biomeBin, 'ci', '--config-path', dir, '--diagnostic-level=error'],
-        command: 'bun',
-        env,
-        label: 'biome'
-    });
-    run({
-        args: [oxlintBin, '-c', joinPath(dir, '.oxlintrc.json'), '--quiet'],
-        command: 'bun',
-        env,
-        label: 'oxlint'
-    });
-    run({
-        args: [eslintBin, ...eslintArgs, '--cache', '--cache-location', joinPath(cwd, '.cache', '.eslintcache')],
-        command: 'bun',
-        env,
-        label: 'eslint'
-    });
-    run({
-        args: [prettierBin, ...prettierMd, '--check', '--no-error-on-unmatched-pattern', '**/*.md'],
-        command: 'bun',
-        env,
-        label: 'prettier'
-    });
-}, main = async () => {
+import { CliExitError, readVersion, usage } from './core.js';
+import { runInit } from './init.js';
+import { runLint } from './pipeline.js';
+const command = process.argv[2], main = async () => {
     const version = await readVersion();
-    if (cmd === 'init') {
+    if (command === 'init') {
         await runInit();
         return;
     }
-    if (cmd === '--version' || cmd === '-v') {
+    if (command === '--version' || command === '-v') {
         process.stdout.write(`${version}\n`);
         return;
     }
-    if (cmd !== 'fix' && cmd !== 'check') {
+    if (command !== 'fix' && command !== 'check') {
         usage({ version });
-        if (cmd === '--help' || cmd === '-h')
+        if (command === '--help' || command === '-h')
             return;
         throw new CliExitError({ code: 1 });
     }
-    await runLint();
+    await runLint({ command });
 };
 try {
     await main();