@eimerreis/linting 0.1.0 → 0.3.0

package/README.md

@@ -2,6 +2,10 @@
 
 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
@@ -17,7 +21,13 @@ Default focus:
 ## Install
 
 ```bash
-npm add -D @eimerreis/linting oxlint oxfmt
+npm add -D @eimerreis/linting
+```
+
+`lint` also executes react-doctor via:
+
+```bash
+npx react-doctor -y .
 ```
 
 ## Quick Start
@@ -39,7 +49,7 @@ This creates:
 - `.oxlintrc.json`
 - `.oxfmtrc.json`
 
-And updates `package.json` scripts (if present):
+And updates `package.json` scripts (if present) so linting is executed through this package:
 
 - `lint`
 - `lint:fix`
@@ -49,11 +59,30 @@ And updates `package.json` scripts (if present):
 ### CLI options
 
 ```bash
-eimerreis-linting [init] [targetDir] [--force]
+eimerreis-linting init [targetDir] [--force]
+eimerreis-linting lint [targetDir] [--fix]
+eimerreis-linting format [targetDir] [--check]
 ```
 
-- `targetDir`: scaffold config in another directory
-- `--force`: overwrite existing `.oxlintrc.json` / `.oxfmtrc.json` and script values
+- `init --force`: overwrite existing `.oxlintrc.json` / `.oxfmtrc.json` and script values
+- `lint --fix`: run `oxlint --fix .` and then run react-doctor
+- `format --check`: run `oxfmt --check .`
+
+`react-doctor` runs only when the target package has `react`, `react-dom`, or `next` in dependencies/devDependencies/peerDependencies.
+
+### 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
 
@@ -63,7 +92,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"]
 }
 ```
 
@@ -71,6 +100,55 @@ 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"
+    }
+}
+```
+
+`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,102 +1,397 @@
 #!/usr/bin/env node
 
+import { spawn } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
 import { dirname, 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);
 
-const rawArgs = process.argv.slice(2);
+function ensureDirectory(filePath) {
+    const dir = dirname(filePath);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+}
 
-if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
-  console.log("Usage: eimerreis-linting [init] [targetDir] [--force]");
-  process.exit(0);
+function writeJson(filePath, data) {
+    ensureDirectory(filePath);
+    writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`, "utf8");
 }
 
-const args = rawArgs[0] === "init" ? rawArgs.slice(1) : rawArgs;
-const force = args.includes("--force");
-const targetArg = args.find((arg) => !arg.startsWith("-"));
-const targetDir = resolve(process.cwd(), targetArg ?? ".");
+function readJson(filePath) {
+    return JSON.parse(readFileSync(filePath, "utf8"));
+}
 
-const targetPackageJsonPath = resolve(targetDir, "package.json");
-const oxlintPath = resolve(targetDir, ".oxlintrc.json");
-const oxfmtPath = resolve(targetDir, ".oxfmtrc.json");
+function getSelfDependencyRange() {
+    try {
+        const selfPackageJsonPath = resolve(packageRoot, "package.json");
+        const selfPackageJson = readJson(selfPackageJsonPath);
+        if (selfPackageJson.version) {
+            return `^${selfPackageJson.version}`;
+        }
+    } catch {
+        // ignore
+    }
 
-function ensureDirectory(filePath) {
-  const dir = dirname(filePath);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
+    return "latest";
 }
 
-function writeJson(filePath, data) {
-  ensureDirectory(filePath);
-  writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+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 readJson(filePath) {
-  return JSON.parse(readFileSync(filePath, "utf8"));
+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]");
+}
+
+function parseCommand(rawArgs) {
+    const firstArg = rawArgs[0];
+    if (!firstArg || firstArg === "init" || firstArg.startsWith("-")) {
+        return {
+            command: "init",
+            args: firstArg === "init" ? rawArgs.slice(1) : rawArgs,
+        };
+    }
+
+    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;
+        }
+
+        if (targetDirArg) {
+            throw new Error(`Unexpected argument: ${arg}`);
+        }
+
+        targetDirArg = arg;
+    }
+
+    return {
+        targetDir: resolve(process.cwd(), targetDirArg ?? "."),
+        flags,
+    };
 }
 
-function upsertScript(packageJson, name, command) {
-  if (!packageJson.scripts || typeof packageJson.scripts !== "object") {
-    packageJson.scripts = {};
-  }
-  if (!packageJson.scripts[name] || force) {
-    packageJson.scripts[name] = command;
-  }
+function runCommand(command, commandArgs, cwd) {
+    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);
+        });
+    });
+}
+
+function hasReactProject(cwd) {
+    const packageJsonPath = resolve(cwd, "package.json");
+
+    if (!existsSync(packageJsonPath)) {
+        return false;
+    }
+
+    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;
+    }
+}
+
+function upsertScript(packageJson, name, command, force) {
+    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}`);
+}
+
+function maybeUpdatePackageJson(targetPackageJsonPath, force) {
+    if (!existsSync(targetPackageJsonPath)) {
+        console.log("skip package.json (not found)");
+        return;
+    }
+
+    const packageJson = readJson(targetPackageJsonPath);
+
+    if (!packageJson.devDependencies || typeof packageJson.devDependencies !== "object") {
+        packageJson.devDependencies = {};
+    }
+
+    const selfDependencyRange = getSelfDependencyRange();
+    if (!packageJson.devDependencies[packageName] || force) {
+        packageJson.devDependencies[packageName] = selfDependencyRange;
+    }
+
+    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);
+
+    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 install");
+    console.log("3) npm run lint && npm run format:check");
 }
 
-function createExtendsConfig(targetPath, exportPath) {
-  if (existsSync(targetPath) && !force) {
-    console.log(`skip ${targetPath} (already exists)`);
-    return;
-  }
+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 (!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);
 
-  writeJson(targetPath, {
-    extends: [`./node_modules/${packageName}/${exportPath}`],
-  });
-  console.log(`write ${targetPath}`);
+    printNextSteps(targetDir);
 }
 
-function maybeUpdatePackageJson() {
-  if (!existsSync(targetPackageJsonPath)) {
-    console.log("skip package.json (not found)");
-    return;
-  }
+async function runLint(args) {
+    if (!hasInstalledPackage("oxlint")) {
+        console.error("oxlint is not installed. Run: npm install");
+        process.exit(1);
+    }
+
+    const { targetDir, flags } = parsePathAndFlags(args, ["--fix"]);
+    const oxlintBinPath = resolvePackageBin("oxlint", "bin/oxlint");
+    const lintArgs = [oxlintBinPath];
+    const lintConfigPath = resolveLintConfigPath(targetDir);
+
+    lintArgs.push("-c", lintConfigPath);
+
+    if (flags.has("--fix")) {
+        lintArgs.push("--fix");
+    }
+
+    lintArgs.push(".");
 
-  const packageJson = readJson(targetPackageJsonPath);
+    const lintExitCode = await runCommand(process.execPath, lintArgs, targetDir);
+    if (lintExitCode !== 0) {
+        process.exit(lintExitCode);
+    }
 
-  upsertScript(packageJson, "lint", "oxlint .");
-  upsertScript(packageJson, "lint:fix", "oxlint --fix .");
-  upsertScript(packageJson, "format", "oxfmt .");
-  upsertScript(packageJson, "format:check", "oxfmt --check .");
+    if (!hasReactProject(targetDir)) {
+        console.log("skip react-doctor (no react/next dependency found)");
+        return;
+    }
 
-  writeJson(targetPackageJsonPath, packageJson);
-  console.log(`update ${targetPackageJsonPath}`);
+    const reactDoctorEntryPath = resolvePackageEntry("react-doctor");
+    const doctorExitCode = await runCommand(process.execPath, [reactDoctorEntryPath, "-y", "."], targetDir);
+    if (doctorExitCode !== 0) {
+        process.exit(doctorExitCode);
+    }
 }
 
-function printNextSteps() {
-  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");
+async function runFormat(args) {
+    if (!hasInstalledPackage("oxfmt")) {
+        console.error("oxfmt is not installed. Run: npm install");
+        process.exit(1);
+    }
+
+    const { targetDir, flags } = parsePathAndFlags(args, ["--check"]);
+    const oxfmtBinPath = resolvePackageBin("oxfmt", "bin/oxfmt");
+    const formatArgs = [oxfmtBinPath];
+    const formatConfigPath = resolveFormatConfigPath(targetDir);
+
+    formatArgs.push("-c", formatConfigPath);
+
+    if (flags.has("--check")) {
+        formatArgs.push("--check");
+    }
+
+    formatArgs.push(".");
+
+    const formatExitCode = await runCommand(process.execPath, formatArgs, targetDir);
+    if (formatExitCode !== 0) {
+        process.exit(formatExitCode);
+    }
 }
 
-function main() {
-  if (!existsSync(packageRoot)) {
-    console.error("init failed: package root not found");
-    process.exit(1);
-  }
+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;
+        }
 
-  createExtendsConfig(oxlintPath, "oxlint.config.json");
-  createExtendsConfig(oxfmtPath, "oxfmt.config.json");
-  maybeUpdatePackageJson();
-  printNextSteps();
+        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,57 +1,59 @@
 {
-  "name": "@eimerreis/linting",
-  "version": "0.1.0",
-  "description": "Personal OXC linting and formatting defaults",
-  "keywords": [
-    "format",
-    "lint",
-    "nextjs",
-    "oxc",
-    "oxfmt",
-    "oxlint",
-    "react",
-    "tailwind",
-    "typescript"
-  ],
-  "license": "MIT",
-  "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": "oxlint .",
-    "lint:fix": "oxlint --fix .",
-    "format": "oxfmt .",
-    "format:check": "oxfmt --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.3.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"
+    }
 }