@eimerreis/linting 0.1.0 → 0.2.0

package/README.md

@@ -2,6 +2,8 @@
 
 Personal linting and formatting defaults for new JavaScript/TypeScript projects.
 
+Requires Node `^20.19.0 || >=22.12.0`.
+
 Built on:
 
 - `oxlint` for linting
@@ -20,6 +22,12 @@ Default focus:
 npm add -D @eimerreis/linting oxlint oxfmt
 ```
 
+`lint` also executes `react-doctor` via:
+
+```bash
+npx react-doctor -y .
+```
+
 ## Quick Start
 
 From your project root:
@@ -39,7 +47,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 +57,16 @@ 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 `npx react-doctor -y .`
+- `format --check`: run `oxfmt --check .`
+
+`react-doctor` runs only when the target package has `react`, `react-dom`, or `next` in dependencies/devDependencies/peerDependencies.
 
 ## Manual Setup
 

package/bin/init.mjs

@@ -1,5 +1,6 @@
 #!/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";
@@ -8,22 +9,6 @@ import process from "node:process";
 const packageName = "@eimerreis/linting";
 const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 
-const rawArgs = process.argv.slice(2);
-
-if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
-  console.log("Usage: eimerreis-linting [init] [targetDir] [--force]");
-  process.exit(0);
-}
-
-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 ?? ".");
-
-const targetPackageJsonPath = resolve(targetDir, "package.json");
-const oxlintPath = resolve(targetDir, ".oxlintrc.json");
-const oxfmtPath = resolve(targetDir, ".oxfmtrc.json");
-
 function ensureDirectory(filePath) {
   const dir = dirname(filePath);
   if (!existsSync(dir)) {
@@ -40,7 +25,94 @@ function readJson(filePath) {
   return JSON.parse(readFileSync(filePath, "utf8"));
 }
 
-function upsertScript(packageJson, name, command) {
+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 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 = {};
   }
@@ -49,7 +121,7 @@ function upsertScript(packageJson, name, command) {
   }
 }
 
-function createExtendsConfig(targetPath, exportPath) {
+function createExtendsConfig(targetPath, exportPath, force) {
   if (existsSync(targetPath) && !force) {
     console.log(`skip ${targetPath} (already exists)`);
     return;
@@ -61,7 +133,7 @@ function createExtendsConfig(targetPath, exportPath) {
   console.log(`write ${targetPath}`);
 }
 
-function maybeUpdatePackageJson() {
+function maybeUpdatePackageJson(targetPackageJsonPath, force) {
   if (!existsSync(targetPackageJsonPath)) {
     console.log("skip package.json (not found)");
     return;
@@ -69,16 +141,16 @@ function maybeUpdatePackageJson() {
 
   const packageJson = readJson(targetPackageJsonPath);
 
-  upsertScript(packageJson, "lint", "oxlint .");
-  upsertScript(packageJson, "lint:fix", "oxlint --fix .");
-  upsertScript(packageJson, "format", "oxfmt .");
-  upsertScript(packageJson, "format:check", "oxfmt --check .");
+  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() {
+function printNextSteps(targetDir) {
   const relativePath = targetDir === process.cwd() ? "." : targetDir;
   console.log("done");
   console.log("next steps:");
@@ -87,16 +159,98 @@ function printNextSteps() {
   console.log("3) npm run lint && npm run format:check");
 }
 
-function main() {
+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");
-  createExtendsConfig(oxfmtPath, "oxfmt.config.json");
-  maybeUpdatePackageJson();
-  printNextSteps();
+  createExtendsConfig(oxlintPath, "oxlint.config.json", force);
+  createExtendsConfig(oxfmtPath, "oxfmt.config.json", force);
+  maybeUpdatePackageJson(targetPackageJsonPath, force);
+  printNextSteps(targetDir);
+}
+
+async function runLint(args) {
+  const { targetDir, flags } = parsePathAndFlags(args, ["--fix"]);
+  const lintArgs = ["--no-install", "oxlint"];
+
+  if (flags.has("--fix")) {
+    lintArgs.push("--fix");
+  }
+
+  lintArgs.push(".");
+
+  const lintExitCode = await runCommand("npx", lintArgs, targetDir);
+  if (lintExitCode !== 0) {
+    process.exit(lintExitCode);
+  }
+
+  if (!hasReactProject(targetDir)) {
+    console.log("skip react-doctor (no react/next dependency found)");
+    return;
+  }
+
+  const doctorExitCode = await runCommand("npx", ["react-doctor", "-y", "."], targetDir);
+  if (doctorExitCode !== 0) {
+    process.exit(doctorExitCode);
+  }
+}
+
+async function runFormat(args) {
+  const { targetDir, flags } = parsePathAndFlags(args, ["--check"]);
+  const formatArgs = ["--no-install", "oxfmt"];
+
+  if (flags.has("--check")) {
+    formatArgs.push("--check");
+  }
+
+  formatArgs.push(".");
+
+  const formatExitCode = await runCommand("npx", formatArgs, targetDir);
+  if (formatExitCode !== 0) {
+    process.exit(formatExitCode);
+  }
+}
+
+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") {
+      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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eimerreis/linting",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Personal OXC linting and formatting defaults",
   "keywords": [
     "format",
@@ -14,6 +14,9 @@
     "typescript"
   ],
   "license": "MIT",
+  "repository": {
+    "url": "https://github.com/eimerreis/linting"
+  },
   "bin": {
     "eimerreis-linting": "bin/init.mjs"
   },
@@ -35,10 +38,10 @@
   },
   "scripts": {
     "changeset": "changeset",
-    "lint": "oxlint .",
-    "lint:fix": "oxlint --fix .",
-    "format": "oxfmt .",
-    "format:check": "oxfmt --check .",
+    "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"
   },