@eimerreis/linting 0.2.0 → 0.4.0

package/README.md

@@ -4,6 +4,8 @@ Personal linting and formatting defaults for new JavaScript/TypeScript projects.
 
 Requires Node `^20.19.0 || >=22.12.0`.
 
+Zero peer-dependency setup for consumers: install only `@eimerreis/linting`.
+
 Built on:
 
 - `oxlint` for linting
@@ -19,10 +21,10 @@ Default focus:
 ## Install
 
 ```bash
-npm add -D @eimerreis/linting oxlint oxfmt
+npm add -D @eimerreis/linting
 ```
 
-`lint` also executes `react-doctor` via:
+`lint` also executes react-doctor via:
 
 ```bash
 npx react-doctor -y .
@@ -58,16 +60,51 @@ And updates `package.json` scripts (if present) so linting is executed through t
 
 ```bash
 eimerreis-linting init [targetDir] [--force]
-eimerreis-linting lint [targetDir] [--fix]
-eimerreis-linting format [targetDir] [--check]
+eimerreis-linting lint [targetDir] [--fix] [--ignore-path <path>] [--ignore-pattern <pattern>]
+eimerreis-linting format [targetDir] [--check] [--ignore-path <path>] [--ignore-pattern <pattern>]
 ```
 
 - `init --force`: overwrite existing `.oxlintrc.json` / `.oxfmtrc.json` and script values
-- `lint --fix`: run `oxlint --fix .` and then `npx react-doctor -y .`
+- `lint --fix`: run `oxlint --fix .` and then run react-doctor
 - `format --check`: run `oxfmt --check .`
+- `--ignore-path`: add one ignore file (repeatable) for lint/format
+- `--ignore-pattern`: add one glob pattern (repeatable) for lint/format
 
 `react-doctor` runs only when the target package has `react`, `react-dom`, or `next` in dependencies/devDependencies/peerDependencies.
 
+### Ignoring files
+
+Supported options:
+
+```bash
+eimerreis-linting lint --ignore-path .gitignore
+eimerreis-linting format --check --ignore-path .gitignore --ignore-path .prettierignore
+eimerreis-linting lint --ignore-pattern "dist/**" --ignore-pattern "coverage/**"
+eimerreis-linting format --check --ignore-path .gitignore --ignore-pattern "**/*.generated.ts"
+```
+
+You can also add a dedicated ignore file at project root:
+
+```text
+.eimerreis-lintingignore
+```
+
+If present, it is picked up automatically by both lint and format.
+
+### First-time one-shot usage
+
+You do not need to run `init` first.
+
+```bash
+npx @eimerreis/linting lint
+npx @eimerreis/linting format --check
+```
+
+Behavior:
+
+- If project config exists (`.oxlintrc.*` / `oxlint.config.*`, `.oxfmtrc.*` / `oxfmt.config.*`), it uses that.
+- If not, it falls back to the package's built-in defaults.
+
 ## Manual Setup
 
 If you do not want to use the init script, create the config files manually.
@@ -76,7 +113,7 @@ If you do not want to use the init script, create the config files manually.
 
 ```json
 {
-  "extends": ["./node_modules/@eimerreis/linting/oxlint.config.json"]
+    "extends": ["./node_modules/@eimerreis/linting/oxlint.config.json"]
 }
 ```
 
@@ -84,6 +121,57 @@ If you do not want to use the init script, create the config files manually.
 
 ```json
 {
-  "extends": ["./node_modules/@eimerreis/linting/oxfmt.config.json"]
+    "extends": ["./node_modules/@eimerreis/linting/oxfmt.config.json"]
+}
+```
+
+## Scripts
+
+Generated project scripts:
+
+```json
+{
+    "scripts": {
+        "lint": "eimerreis-linting lint",
+        "lint:fix": "eimerreis-linting lint --fix",
+        "format": "eimerreis-linting format",
+        "format:check": "eimerreis-linting format --check",
+        "lint:ignore": "eimerreis-linting lint --ignore-path .eimerreis-lintingignore",
+        "format:check:ignore": "eimerreis-linting format --check --ignore-path .eimerreis-lintingignore"
+    }
+}
+```
+
+`init` also adds this dev dependency automatically (if missing):
+
+```json
+{
+    "devDependencies": {
+        "@eimerreis/linting": "^<current-version>"
+    }
 }
 ```
+
+## Publish
+
+### Git-based release workflow (Changesets + GitHub Actions)
+
+1. Create a changeset:
+
+```bash
+npm run changeset
+```
+
+2. Commit `.changeset/*.md` and push to `main`.
+3. Workflow `Release` checks for pending changesets.
+4. If changesets exist, it versions, publishes via npm trusted publishing (OIDC), and commits `chore: version packages`.
+
+Trusted publishing setup (one-time on npmjs.com):
+
+1. Package `@eimerreis/linting` -> Settings -> Trusted Publisher
+2. Provider: GitHub Actions
+3. Organization/user: `eimerreis`
+4. Repository: `eimerreis-linting`
+5. Workflow filename: `release.yml`
+
+No `NPM_TOKEN` secret is required for publishing.

package/bin/init.mjs

@@ -1,256 +1,542 @@
 #!/usr/bin/env node
 
 import { spawn } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { dirname, resolve } from "node:path";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
 import process from "node:process";
+import { fileURLToPath } from "node:url";
 
 const packageName = "@eimerreis/linting";
 const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const requireFromHere = createRequire(import.meta.url);
 
 function ensureDirectory(filePath) {
-  const dir = dirname(filePath);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
+    const dir = dirname(filePath);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
 }
 
 function writeJson(filePath, data) {
-  ensureDirectory(filePath);
-  writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+    ensureDirectory(filePath);
+    writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`, "utf8");
 }
 
 function readJson(filePath) {
-  return JSON.parse(readFileSync(filePath, "utf8"));
+    return JSON.parse(readFileSync(filePath, "utf8"));
+}
+
+function getSelfDependencyRange() {
+    try {
+        const selfPackageJsonPath = resolve(packageRoot, "package.json");
+        const selfPackageJson = readJson(selfPackageJsonPath);
+        if (selfPackageJson.version) {
+            return `^${selfPackageJson.version}`;
+        }
+    } catch {
+        // ignore
+    }
+
+    return "latest";
+}
+
+function resolvePackageBin(dependencyName, binRelativePath) {
+    const entryPointPath = requireFromHere.resolve(dependencyName);
+    let cursor = dirname(entryPointPath);
+
+    while (cursor !== dirname(cursor)) {
+        const packageJsonPath = resolve(cursor, "package.json");
+        if (existsSync(packageJsonPath)) {
+            const packageJson = readJson(packageJsonPath);
+            if (packageJson.name === dependencyName) {
+                const binPath = resolve(cursor, binRelativePath);
+                if (!existsSync(binPath)) {
+                    throw new Error(`Cannot find ${dependencyName} binary at ${binPath}`);
+                }
+                return binPath;
+            }
+        }
+        cursor = dirname(cursor);
+    }
+
+    throw new Error(`Unable to resolve package root for ${dependencyName}`);
+}
+
+function resolvePackageEntry(dependencyName) {
+    return requireFromHere.resolve(dependencyName);
+}
+
+function hasInstalledPackage(dependencyName) {
+    try {
+        resolvePackageEntry(dependencyName);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+function resolveExistingConfigPath(targetDir, configCandidates) {
+    for (const candidate of configCandidates) {
+        const candidatePath = resolve(targetDir, candidate);
+        if (existsSync(candidatePath)) {
+            return candidatePath;
+        }
+    }
+
+    return null;
+}
+
+function resolveLintConfigPath(targetDir) {
+    const localConfigPath = resolveExistingConfigPath(targetDir, [
+        ".oxlintrc.json",
+        ".oxlintrc.jsonc",
+        ".oxlintrc.js",
+        ".oxlintrc.mjs",
+        ".oxlintrc.cjs",
+        ".oxlintrc.ts",
+        ".oxlintrc.mts",
+        ".oxlintrc.cts",
+        "oxlint.config.js",
+        "oxlint.config.mjs",
+        "oxlint.config.cjs",
+        "oxlint.config.ts",
+        "oxlint.config.mts",
+        "oxlint.config.cts",
+    ]);
+
+    if (localConfigPath) {
+        return localConfigPath;
+    }
+
+    return resolve(packageRoot, "oxlint.config.json");
+}
+
+function resolveFormatConfigPath(targetDir) {
+    const localConfigPath = resolveExistingConfigPath(targetDir, [
+        ".oxfmtrc.json",
+        ".oxfmtrc.jsonc",
+        ".oxfmtrc.js",
+        ".oxfmtrc.mjs",
+        ".oxfmtrc.cjs",
+        ".oxfmtrc.ts",
+        ".oxfmtrc.mts",
+        ".oxfmtrc.cts",
+        "oxfmt.config.js",
+        "oxfmt.config.mjs",
+        "oxfmt.config.cjs",
+        "oxfmt.config.ts",
+        "oxfmt.config.mts",
+        "oxfmt.config.cts",
+    ]);
+
+    if (localConfigPath) {
+        return localConfigPath;
+    }
+
+    return resolve(packageRoot, "oxfmt.config.json");
 }
 
 function printUsage() {
-  console.log("Usage:");
-  console.log("  eimerreis-linting init [targetDir] [--force]");
-  console.log("  eimerreis-linting lint [targetDir] [--fix]");
-  console.log("  eimerreis-linting format [targetDir] [--check]");
+    console.log("Usage:");
+    console.log("  eimerreis-linting init [targetDir] [--force]");
+    console.log("  eimerreis-linting lint [targetDir] [--fix] [--ignore-path <path>] [--ignore-pattern <pattern>]");
+    console.log("  eimerreis-linting format [targetDir] [--check] [--ignore-path <path>] [--ignore-pattern <pattern>]");
 }
 
 function parseCommand(rawArgs) {
-  const firstArg = rawArgs[0];
-  if (!firstArg || firstArg === "init" || firstArg.startsWith("-")) {
+    const firstArg = rawArgs[0];
+    if (!firstArg || firstArg === "init" || firstArg.startsWith("-")) {
+        return {
+            command: "init",
+            args: firstArg === "init" ? rawArgs.slice(1) : rawArgs,
+        };
+    }
+
     return {
-      command: "init",
-      args: firstArg === "init" ? rawArgs.slice(1) : rawArgs,
+        command: firstArg,
+        args: rawArgs.slice(1),
     };
-  }
-
-  return {
-    command: firstArg,
-    args: rawArgs.slice(1),
-  };
 }
 
 function parsePathAndFlags(args, allowedFlags) {
-  let targetDirArg;
-  const flags = new Set();
-
-  for (const arg of args) {
-    if (arg.startsWith("-")) {
-      if (!allowedFlags.includes(arg)) {
-        throw new Error(`Unknown flag: ${arg}`);
-      }
-      flags.add(arg);
-      continue;
+    let targetDirArg;
+    const flags = new Set();
+
+    for (const arg of args) {
+        if (arg.startsWith("-")) {
+            if (!allowedFlags.includes(arg)) {
+                throw new Error(`Unknown flag: ${arg}`);
+            }
+            flags.add(arg);
+            continue;
+        }
+
+        if (targetDirArg) {
+            throw new Error(`Unexpected argument: ${arg}`);
+        }
+
+        targetDirArg = arg;
     }
 
-    if (targetDirArg) {
-      throw new Error(`Unexpected argument: ${arg}`);
-    }
+    return {
+        targetDir: resolve(process.cwd(), targetDirArg ?? "."),
+        flags,
+    };
+}
 
-    targetDirArg = arg;
-  }
+function parseRunArgs(args, primaryFlag) {
+    let targetDirArg;
+    const ignorePaths = [];
+    const ignorePatterns = [];
+    let primaryEnabled = false;
+
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+
+        if (arg === primaryFlag) {
+            primaryEnabled = true;
+            continue;
+        }
+
+        if (arg === "--ignore-path") {
+            const ignorePath = args[index + 1];
+            if (!ignorePath || ignorePath.startsWith("-")) {
+                throw new Error("Missing value for --ignore-path");
+            }
+            ignorePaths.push(ignorePath);
+            index += 1;
+            continue;
+        }
+
+        if (arg.startsWith("--ignore-path=")) {
+            const ignorePath = arg.slice("--ignore-path=".length);
+            if (!ignorePath) {
+                throw new Error("Missing value for --ignore-path");
+            }
+            ignorePaths.push(ignorePath);
+            continue;
+        }
+
+        if (arg === "--ignore-pattern") {
+            const ignorePattern = args[index + 1];
+            if (!ignorePattern || ignorePattern.startsWith("-")) {
+                throw new Error("Missing value for --ignore-pattern");
+            }
+            ignorePatterns.push(ignorePattern);
+            index += 1;
+            continue;
+        }
+
+        if (arg.startsWith("--ignore-pattern=")) {
+            const ignorePattern = arg.slice("--ignore-pattern=".length);
+            if (!ignorePattern) {
+                throw new Error("Missing value for --ignore-pattern");
+            }
+            ignorePatterns.push(ignorePattern);
+            continue;
+        }
+
+        if (arg.startsWith("-")) {
+            throw new Error(`Unknown flag: ${arg}`);
+        }
+
+        if (targetDirArg) {
+            throw new Error(`Unexpected argument: ${arg}`);
+        }
+
+        targetDirArg = arg;
+    }
 
-  return {
-    targetDir: resolve(process.cwd(), targetDirArg ?? "."),
-    flags,
-  };
+    return {
+        targetDir: resolve(process.cwd(), targetDirArg ?? "."),
+        primaryEnabled,
+        ignorePaths,
+        ignorePatterns,
+    };
 }
 
 function runCommand(command, commandArgs, cwd) {
-  return new Promise((resolvePromise) => {
-    const child = spawn(command, commandArgs, {
-      cwd,
-      stdio: "inherit",
-      shell: process.platform === "win32",
+    return new Promise((resolvePromise) => {
+        const child = spawn(command, commandArgs, {
+            cwd,
+            stdio: "inherit",
+            shell: process.platform === "win32",
+        });
+
+        child.on("error", (error) => {
+            console.error(`failed to run ${command}: ${error.message}`);
+            resolvePromise(1);
+        });
+
+        child.on("close", (code) => {
+            resolvePromise(code ?? 1);
+        });
     });
-
-    child.on("error", (error) => {
-      console.error(`failed to run ${command}: ${error.message}`);
-      resolvePromise(1);
-    });
-
-    child.on("close", (code) => {
-      resolvePromise(code ?? 1);
-    });
-  });
 }
 
 function hasReactProject(cwd) {
-  const packageJsonPath = resolve(cwd, "package.json");
+    const packageJsonPath = resolve(cwd, "package.json");
 
-  if (!existsSync(packageJsonPath)) {
-    return false;
-  }
+    if (!existsSync(packageJsonPath)) {
+        return false;
+    }
 
-  try {
-    const packageJson = readJson(packageJsonPath);
-    const dependencyFields = ["dependencies", "devDependencies", "peerDependencies"];
+    try {
+        const packageJson = readJson(packageJsonPath);
+        const dependencyFields = ["dependencies", "devDependencies", "peerDependencies"];
 
-    return dependencyFields.some((field) => {
-      const deps = packageJson[field];
-      return Boolean(deps?.react || deps?.["react-dom"] || deps?.next);
-    });
-  } catch {
-    return false;
-  }
+        return dependencyFields.some((field) => {
+            const deps = packageJson[field];
+            return Boolean(deps?.react || deps?.["react-dom"] || deps?.next);
+        });
+    } catch {
+        return false;
+    }
 }
 
 function upsertScript(packageJson, name, command, force) {
-  if (!packageJson.scripts || typeof packageJson.scripts !== "object") {
-    packageJson.scripts = {};
-  }
-  if (!packageJson.scripts[name] || force) {
-    packageJson.scripts[name] = command;
-  }
+    if (!packageJson.scripts || typeof packageJson.scripts !== "object") {
+        packageJson.scripts = {};
+    }
+    if (!packageJson.scripts[name] || force) {
+        packageJson.scripts[name] = command;
+    }
 }
 
 function createExtendsConfig(targetPath, exportPath, force) {
-  if (existsSync(targetPath) && !force) {
-    console.log(`skip ${targetPath} (already exists)`);
-    return;
-  }
-
-  writeJson(targetPath, {
-    extends: [`./node_modules/${packageName}/${exportPath}`],
-  });
-  console.log(`write ${targetPath}`);
+    if (existsSync(targetPath) && !force) {
+        console.log(`skip ${targetPath} (already exists)`);
+        return;
+    }
+
+    writeJson(targetPath, {
+        extends: [`./node_modules/${packageName}/${exportPath}`],
+    });
+    console.log(`write ${targetPath}`);
 }
 
 function maybeUpdatePackageJson(targetPackageJsonPath, force) {
-  if (!existsSync(targetPackageJsonPath)) {
-    console.log("skip package.json (not found)");
-    return;
-  }
+    if (!existsSync(targetPackageJsonPath)) {
+        console.log("skip package.json (not found)");
+        return;
+    }
 
-  const packageJson = readJson(targetPackageJsonPath);
+    const packageJson = readJson(targetPackageJsonPath);
 
-  upsertScript(packageJson, "lint", "eimerreis-linting lint", force);
-  upsertScript(packageJson, "lint:fix", "eimerreis-linting lint --fix", force);
-  upsertScript(packageJson, "format", "eimerreis-linting format", force);
-  upsertScript(packageJson, "format:check", "eimerreis-linting format --check", force);
+    if (!packageJson.devDependencies || typeof packageJson.devDependencies !== "object") {
+        packageJson.devDependencies = {};
+    }
+
+    const selfDependencyRange = getSelfDependencyRange();
+    if (!packageJson.devDependencies[packageName] || force) {
+        packageJson.devDependencies[packageName] = selfDependencyRange;
+    }
 
-  writeJson(targetPackageJsonPath, packageJson);
-  console.log(`update ${targetPackageJsonPath}`);
+    upsertScript(packageJson, "lint", "eimerreis-linting lint", force);
+    upsertScript(packageJson, "lint:fix", "eimerreis-linting lint --fix", force);
+    upsertScript(packageJson, "format", "eimerreis-linting format", force);
+    upsertScript(packageJson, "format:check", "eimerreis-linting format --check", force);
+    upsertScript(packageJson, "lint:ignore", "eimerreis-linting lint --ignore-path .eimerreis-lintingignore", force);
+    upsertScript(
+        packageJson,
+        "format:check:ignore",
+        "eimerreis-linting format --check --ignore-path .eimerreis-lintingignore",
+        force
+    );
+
+    writeJson(targetPackageJsonPath, packageJson);
+    console.log(`update ${targetPackageJsonPath}`);
 }
 
 function printNextSteps(targetDir) {
-  const relativePath = targetDir === process.cwd() ? "." : targetDir;
-  console.log("done");
-  console.log("next steps:");
-  console.log(`1) cd ${relativePath}`);
-  console.log("2) npm add -D @eimerreis/linting oxlint oxfmt");
-  console.log("3) npm run lint && npm run format:check");
+    const relativePath = targetDir === process.cwd() ? "." : targetDir;
+    console.log("done");
+    console.log("next steps:");
+    console.log(`1) cd ${relativePath}`);
+    console.log("2) npm install");
+    console.log("3) npm run lint && npm run format:check");
 }
 
-function runInit(args) {
-  const { targetDir, flags } = parsePathAndFlags(args, ["--force"]);
-  const force = flags.has("--force");
-  const targetPackageJsonPath = resolve(targetDir, "package.json");
-  const oxlintPath = resolve(targetDir, ".oxlintrc.json");
-  const oxfmtPath = resolve(targetDir, ".oxfmtrc.json");
-
-  if (!existsSync(packageRoot)) {
-    console.error("init failed: package root not found");
-    process.exit(1);
-  }
-
-  createExtendsConfig(oxlintPath, "oxlint.config.json", force);
-  createExtendsConfig(oxfmtPath, "oxfmt.config.json", force);
-  maybeUpdatePackageJson(targetPackageJsonPath, force);
-  printNextSteps(targetDir);
+function resolveIgnorePaths(targetDir, rawIgnorePaths) {
+    const collectedPaths = [];
+    const defaultIgnorePath = resolve(targetDir, ".eimerreis-lintingignore");
+
+    if (existsSync(defaultIgnorePath)) {
+        collectedPaths.push(defaultIgnorePath);
+    }
+
+    for (const rawIgnorePath of rawIgnorePaths) {
+        const resolvedPath = resolve(targetDir, rawIgnorePath);
+        if (!existsSync(resolvedPath)) {
+            throw new Error(`Ignore file not found: ${resolvedPath}`);
+        }
+        collectedPaths.push(resolvedPath);
+    }
+
+    return [...new Set(collectedPaths)];
 }
 
-async function runLint(args) {
-  const { targetDir, flags } = parsePathAndFlags(args, ["--fix"]);
-  const lintArgs = ["--no-install", "oxlint"];
+function createMergedIgnoreFile(ignorePaths, ignorePatterns) {
+    if (ignorePaths.length === 0 && ignorePatterns.length === 0) {
+        return null;
+    }
+
+    const fileEntries = ignorePaths
+        .map((ignorePath) => readFileSync(ignorePath, "utf8").trim())
+        .filter((entry) => entry.length > 0);
 
-  if (flags.has("--fix")) {
-    lintArgs.push("--fix");
-  }
+    const patternEntries = ignorePatterns.map((pattern) => pattern.trim()).filter((pattern) => pattern.length > 0);
 
-  lintArgs.push(".");
+    const mergedEntries = [...fileEntries, ...patternEntries];
 
-  const lintExitCode = await runCommand("npx", lintArgs, targetDir);
-  if (lintExitCode !== 0) {
-    process.exit(lintExitCode);
-  }
+    if (mergedEntries.length === 0) {
+        return null;
+    }
 
-  if (!hasReactProject(targetDir)) {
-    console.log("skip react-doctor (no react/next dependency found)");
-    return;
-  }
+    const tempDir = mkdtempSync(join(tmpdir(), "eimerreis-linting-"));
+    const mergedIgnorePath = resolve(tempDir, ".ignore");
+    writeFileSync(mergedIgnorePath, `${mergedEntries.join("\n")}\n`, "utf8");
 
-  const doctorExitCode = await runCommand("npx", ["react-doctor", "-y", "."], targetDir);
-  if (doctorExitCode !== 0) {
-    process.exit(doctorExitCode);
-  }
+    return {
+        path: mergedIgnorePath,
+        cleanup: () => rmSync(tempDir, { recursive: true, force: true }),
+    };
 }
 
-async function runFormat(args) {
-  const { targetDir, flags } = parsePathAndFlags(args, ["--check"]);
-  const formatArgs = ["--no-install", "oxfmt"];
+async function runInit(args) {
+    const { targetDir, flags } = parsePathAndFlags(args, ["--force"]);
+    const force = flags.has("--force");
+    const targetPackageJsonPath = resolve(targetDir, "package.json");
+    const oxlintPath = resolve(targetDir, ".oxlintrc.json");
+    const oxfmtPath = resolve(targetDir, ".oxfmtrc.json");
 
-  if (flags.has("--check")) {
-    formatArgs.push("--check");
-  }
+    if (!existsSync(packageRoot)) {
+        console.error("init failed: package root not found");
+        process.exit(1);
+    }
 
-  formatArgs.push(".");
+    createExtendsConfig(oxlintPath, "oxlint.config.json", force);
+    createExtendsConfig(oxfmtPath, "oxfmt.config.json", force);
+    maybeUpdatePackageJson(targetPackageJsonPath, force);
 
-  const formatExitCode = await runCommand("npx", formatArgs, targetDir);
-  if (formatExitCode !== 0) {
-    process.exit(formatExitCode);
-  }
+    printNextSteps(targetDir);
 }
 
-async function main() {
-  try {
-    const rawArgs = process.argv.slice(2);
-    if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
-      printUsage();
-      process.exit(0);
+async function runLint(args) {
+    if (!hasInstalledPackage("oxlint")) {
+        console.error("oxlint is not installed. Run: npm install");
+        process.exit(1);
     }
 
-    const { command, args } = parseCommand(rawArgs);
+    const { targetDir, primaryEnabled, ignorePaths: rawIgnorePaths, ignorePatterns } = parseRunArgs(args, "--fix");
+    const ignorePaths = resolveIgnorePaths(targetDir, rawIgnorePaths);
+    const mergedIgnoreFile = createMergedIgnoreFile(ignorePaths, ignorePatterns);
+    const oxlintBinPath = resolvePackageBin("oxlint", "bin/oxlint");
+    const lintArgs = [oxlintBinPath];
+    const lintConfigPath = resolveLintConfigPath(targetDir);
+
+    lintArgs.push("-c", lintConfigPath);
 
-    if (command === "init") {
-      runInit(args);
-      return;
+    if (mergedIgnoreFile) {
+        lintArgs.push(`--ignore-path=${mergedIgnoreFile.path}`);
     }
 
-    if (command === "lint") {
-      await runLint(args);
-      return;
+    if (primaryEnabled) {
+        lintArgs.push("--fix");
     }
 
-    if (command === "format") {
-      await runFormat(args);
-      return;
+    lintArgs.push(".");
+
+    try {
+        const lintExitCode = await runCommand(process.execPath, lintArgs, targetDir);
+        if (lintExitCode !== 0) {
+            process.exit(lintExitCode);
+        }
+
+        if (!hasReactProject(targetDir)) {
+            console.log("skip react-doctor (no react/next dependency found)");
+            return;
+        }
+
+        const reactDoctorEntryPath = resolvePackageEntry("react-doctor");
+        const doctorExitCode = await runCommand(process.execPath, [reactDoctorEntryPath, "-y", "."], targetDir);
+        if (doctorExitCode !== 0) {
+            process.exit(doctorExitCode);
+        }
+    } finally {
+        mergedIgnoreFile?.cleanup();
     }
+}
+
+async function runFormat(args) {
+    if (!hasInstalledPackage("oxfmt")) {
+        console.error("oxfmt is not installed. Run: npm install");
+        process.exit(1);
+    }
+
+    const { targetDir, primaryEnabled, ignorePaths: rawIgnorePaths, ignorePatterns } = parseRunArgs(args, "--check");
+    const ignorePaths = resolveIgnorePaths(targetDir, rawIgnorePaths);
+    const mergedIgnoreFile = createMergedIgnoreFile(ignorePaths, ignorePatterns);
+    const oxfmtBinPath = resolvePackageBin("oxfmt", "bin/oxfmt");
+    const formatArgs = [oxfmtBinPath];
+    const formatConfigPath = resolveFormatConfigPath(targetDir);
+
+    formatArgs.push("-c", formatConfigPath);
 
-    console.error(`Unknown command: ${command}`);
-    printUsage();
-    process.exit(1);
-  } catch (error) {
-    console.error(error instanceof Error ? error.message : String(error));
-    process.exit(1);
-  }
+    if (mergedIgnoreFile) {
+        formatArgs.push(`--ignore-path=${mergedIgnoreFile.path}`);
+    }
+
+    if (primaryEnabled) {
+        formatArgs.push("--check");
+    }
+
+    formatArgs.push(".");
+
+    try {
+        const formatExitCode = await runCommand(process.execPath, formatArgs, targetDir);
+        if (formatExitCode !== 0) {
+            process.exit(formatExitCode);
+        }
+    } finally {
+        mergedIgnoreFile?.cleanup();
+    }
+}
+
+async function main() {
+    try {
+        const rawArgs = process.argv.slice(2);
+        if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
+            printUsage();
+            process.exit(0);
+        }
+
+        const { command, args } = parseCommand(rawArgs);
+
+        if (command === "init") {
+            await runInit(args);
+            return;
+        }
+
+        if (command === "lint") {
+            await runLint(args);
+            return;
+        }
+
+        if (command === "format") {
+            await runFormat(args);
+            return;
+        }
+
+        console.error(`Unknown command: ${command}`);
+        printUsage();
+        process.exit(1);
+    } catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
 }
 
 main();

package/oxfmt.config.json

@@ -1,19 +1,19 @@
 {
-  "$schema": "./node_modules/oxfmt/configuration_schema.json",
-  "printWidth": 125,
-  "tabWidth": 4,
-  "semi": true,
-  "singleQuote": false,
-  "trailingComma": "es5",
-  "sortImports": {
-    "order": "asc",
-    "ignoreCase": true,
-    "newlinesBetween": true,
-    "groups": ["builtin", "external", "internal", ["parent", "sibling", "index"]],
-    "internalPattern": ["@/", "~/"]
-  },
-  "sortTailwindcss": {
-    "functions": ["cn", "clsx", "cva", "tw"]
-  },
-  "ignorePatterns": ["node_modules/**", ".next/**", "dist/**", "build/**", "coverage/**", "out/**"]
+    "$schema": "./node_modules/oxfmt/configuration_schema.json",
+    "printWidth": 125,
+    "tabWidth": 4,
+    "semi": true,
+    "singleQuote": false,
+    "trailingComma": "es5",
+    "sortImports": {
+        "order": "asc",
+        "ignoreCase": true,
+        "newlinesBetween": true,
+        "groups": ["builtin", "external", "internal", ["parent", "sibling", "index"]],
+        "internalPattern": ["@/", "~/"]
+    },
+    "sortTailwindcss": {
+        "functions": ["cn", "clsx", "cva", "tw"]
+    },
+    "ignorePatterns": ["node_modules/**", ".next/**", "dist/**", "build/**", "coverage/**", "out/**"]
 }

package/oxlint.config.json

@@ -1,38 +1,38 @@
 {
-  "$schema": "./node_modules/oxlint/configuration_schema.json",
-  "plugins": ["eslint", "typescript", "unicorn", "oxc", "react", "nextjs", "import", "vitest"],
-  "categories": {
-    "correctness": "error",
-    "suspicious": "warn"
-  },
-  "env": {
-    "browser": true,
-    "node": true,
-    "es6": true
-  },
-  "rules": {
-    "eslint/no-unused-vars": [
-      "warn",
-      {
-        "varsIgnorePattern": "_"
-      }
-    ],
-    "typescript/no-explicit-any": "off",
-    "react/prop-types": "off",
-    "react/react-in-jsx-scope": "off",
-    "react-hooks/refs": "off",
-    "react-hooks/incompatible-library": "off",
-    "import/no-duplicates": "error",
-    "import/no-self-import": "error",
-    "import/no-cycle": "warn"
-  },
-  "ignorePatterns": ["node_modules/**", ".next/**", "dist/**", "build/**", "coverage/**", "out/**"],
-  "overrides": [
-    {
-      "files": ["**/*.{test,spec}.{js,jsx,ts,tsx}", "**/__tests__/**/*.{js,jsx,ts,tsx}"],
-      "rules": {
-        "typescript/no-explicit-any": "off"
-      }
-    }
-  ]
+    "$schema": "./node_modules/oxlint/configuration_schema.json",
+    "plugins": ["eslint", "typescript", "unicorn", "oxc", "react", "nextjs", "import", "vitest"],
+    "categories": {
+        "correctness": "error",
+        "suspicious": "warn"
+    },
+    "env": {
+        "browser": true,
+        "node": true,
+        "es6": true
+    },
+    "rules": {
+        "eslint/no-unused-vars": [
+            "warn",
+            {
+                "varsIgnorePattern": "_"
+            }
+        ],
+        "typescript/no-explicit-any": "off",
+        "react/prop-types": "off",
+        "react/react-in-jsx-scope": "off",
+        "react-hooks/refs": "off",
+        "react-hooks/incompatible-library": "off",
+        "import/no-duplicates": "error",
+        "import/no-self-import": "error",
+        "import/no-cycle": "warn"
+    },
+    "ignorePatterns": ["node_modules/**", ".next/**", "dist/**", "build/**", "coverage/**", "out/**"],
+    "overrides": [
+        {
+            "files": ["**/*.{test,spec}.{js,jsx,ts,tsx}", "**/__tests__/**/*.{js,jsx,ts,tsx}"],
+            "rules": {
+                "typescript/no-explicit-any": "off"
+            }
+        }
+    ]
 }

package/package.json

@@ -1,60 +1,59 @@
 {
-  "name": "@eimerreis/linting",
-  "version": "0.2.0",
-  "description": "Personal OXC linting and formatting defaults",
-  "keywords": [
-    "format",
-    "lint",
-    "nextjs",
-    "oxc",
-    "oxfmt",
-    "oxlint",
-    "react",
-    "tailwind",
-    "typescript"
-  ],
-  "license": "MIT",
-  "repository": {
-    "url": "https://github.com/eimerreis/linting"
-  },
-  "bin": {
-    "eimerreis-linting": "bin/init.mjs"
-  },
-  "files": [
-    "bin",
-    "oxlint.config.json",
-    "oxfmt.config.json",
-    "README.md",
-    "LICENSE"
-  ],
-  "type": "module",
-  "exports": {
-    "./oxlint": "./oxlint.config.json",
-    "./oxfmt": "./oxfmt.config.json",
-    "./package.json": "./package.json"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {
-    "changeset": "changeset",
-    "lint": "node ./bin/init.mjs lint",
-    "lint:fix": "node ./bin/init.mjs lint --fix",
-    "format": "node ./bin/init.mjs format",
-    "format:check": "node ./bin/init.mjs format --check",
-    "version-packages": "changeset version",
-    "release": "changeset publish"
-  },
-  "devDependencies": {
-    "@changesets/cli": "^2.29.7",
-    "oxfmt": "^0.41.0",
-    "oxlint": "^1.56.0"
-  },
-  "peerDependencies": {
-    "oxfmt": "^0.41.0",
-    "oxlint": "^1.56.0"
-  },
-  "engines": {
-    "node": "^20.19.0 || >=22.12.0"
-  }
+    "name": "@eimerreis/linting",
+    "version": "0.4.0",
+    "description": "Personal OXC linting and formatting defaults",
+    "keywords": [
+        "format",
+        "lint",
+        "nextjs",
+        "oxc",
+        "oxfmt",
+        "oxlint",
+        "react",
+        "tailwind",
+        "typescript"
+    ],
+    "license": "MIT",
+    "repository": {
+        "url": "https://github.com/eimerreis/linting"
+    },
+    "bin": {
+        "eimerreis-linting": "bin/init.mjs"
+    },
+    "files": [
+        "bin",
+        "oxlint.config.json",
+        "oxfmt.config.json",
+        "README.md",
+        "LICENSE"
+    ],
+    "type": "module",
+    "exports": {
+        "./oxlint": "./oxlint.config.json",
+        "./oxfmt": "./oxfmt.config.json",
+        "./package.json": "./package.json"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "scripts": {
+        "changeset": "changeset",
+        "lint": "node ./bin/init.mjs lint",
+        "lint:fix": "node ./bin/init.mjs lint --fix",
+        "format": "node ./bin/init.mjs format",
+        "format:check": "node ./bin/init.mjs format --check",
+        "version-packages": "changeset version",
+        "release": "changeset publish"
+    },
+    "dependencies": {
+        "oxfmt": "^0.41.0",
+        "oxlint": "^1.56.0",
+        "react-doctor": "^0.0.30"
+    },
+    "devDependencies": {
+        "@changesets/cli": "^2.29.7"
+    },
+    "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+    }
 }