@mnci/cli 1.18.0 → 1.19.0

package/README.md

@@ -30,6 +30,7 @@ first-party (or established community) Nx equivalent:
 mnci new my-repo            # create a monorepo (prompts scope + registry)
 mnci new my-repo --yes --registry npm --scope @my
 mnci new my-repo --yes --registry npm --scope @my --nx-cloud  # opt in to Nx Cloud
+mnci new my-repo --yes --registry npm --scope @my --linter oxlint  # Rust toolchain
 
 cd my-repo
 mnci add react-app web         # @nx/react (Vite + Jest)
@@ -75,15 +76,17 @@ Every check corresponds to an invariant that has **actually** been violated, in
 this repo or in a workspace it generated. None are hypothetical; a check nobody has
 ever needed is noise that trains people to ignore the output.
 
-| Check                                                   | The failure it catches                                                                                                             |
-| ------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
-| Exactly one root ESLint config, and no per-project ones | The config fragmenting — every `@nx/*` generator writes one, so each project ends up linting against whichever config sits nearest |
-| No stray `.prettierrc`                                  | It outranks `.prettierrc.mjs`, so the whole formatting opinion is silently discarded while both files look fine                    |
-| `@nx/eslint/plugin` registered in `nx.json`             | Without it `npm run lint` exits 0 while linting nothing                                                                            |
-| The **resolved** `eslint` major                         | A declared range and an installed version are different things — manifests once said `^10` while the pin said 9                    |
-| `.npmrc` matches the recorded registry                  | The two registry kinds get different files; an Azure workspace also needs its scope routed                                         |
-| `versionActions` on publishable Dart/Python packages    | Its absence aborts `nx release` for the **whole** workspace, not just that project                                                 |
-| `nx sync:check`                                         | A stale TypeScript project reference that was never committed                                                                      |
+| Check                                                   | The failure it catches                                                                                                                              |
+| ------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Exactly one root ESLint config, and no per-project ones | The config fragmenting — every `@nx/*` generator writes one, so each project ends up linting against whichever config sits nearest                  |
+| No stray `.prettierrc`                                  | It outranks `.prettierrc.mjs`, so the whole formatting opinion is silently discarded while both files look fine                                     |
+| `@nx/eslint/plugin` registered in `nx.json`             | Without it `npm run lint` exits 0 while linting nothing                                                                                             |
+| The **resolved** `eslint` major                         | A declared range and an installed version are different things — manifests once said `^10` while the pin said 9                                     |
+| `.npmrc` matches the recorded registry                  | The two registry kinds get different files; an Azure workspace also needs its scope routed                                                          |
+| `versionActions` on publishable Dart/Python packages    | Its absence aborts `nx release` for the **whole** workspace, not just that project                                                                  |
+| `nx sync:check`                                         | A stale TypeScript project reference that was never committed                                                                                       |
+| Only the chosen linter's config files present           | Two formatter configs is not a visible error — each is valid, the CLI picks one, the editor may pick the other, and the two gates disagree silently |
+| oxlint toolchain declared                               | `@mnci/oxlint-config` peers on `oxlint`, so a missing declaration turns `npm run lint` into "command not found" at the worst moment                 |
 
 Everything else is plain Nx, surfaced as a small curated set of root scripts —
 each a single cross-platform command:
@@ -262,6 +265,31 @@ contradicting each other. `mnci` runs Prettier itself at the end of `new` and ev
 generators emit semicolons and double quotes, and without that pass the first
 commit buries every real change under generator noise.
 
+**Choosing the linter.** `--linter=eslint` (default) or `--linter=oxlint`, also a
+prompt at `mnci new` and overridable on `mnci upgrade`. The formatter rides along
+— ESLint pairs with Prettier, oxlint with oxfmt — because both are the same seven
+Standard options, so the choice is about speed and toolchain, never about how the
+code ends up looking.
+
+**`oxlint` is a hybrid, not a swap**, and that is deliberate. oxlint parses
+JS/TS/JSX/Vue and nothing else, so an oxlint workspace keeps a trimmed ESLint
+config (`@mnci/eslint-config`'s `nonJs()`) for the file types oxlint cannot read:
+
+|                                 | `eslint`                               | `oxlint`                                                 |
+| ------------------------------- | -------------------------------------- | -------------------------------------------------------- |
+| JS/TS lint                      | ESLint, 452 rules                      | oxlint, 206 native + 225 bridged                         |
+| YAML/TOML/MD/CSS/HTML/JSON lint | ESLint                                 | **ESLint** (unchanged)                                   |
+| `@nx/dependency-checks`         | yes                                    | **yes** (unchanged)                                      |
+| Formatter                       | Prettier                               | oxfmt (~30x faster)                                      |
+| Config files                    | `eslint.config.mjs`, `.prettierrc.mjs` | `oxlint.config.ts`, `.oxfmtrc.json`, `eslint.config.mjs` |
+| VS Code extension               | ESLint + Prettier                      | Oxc (covers both) + ESLint                               |
+
+A pure swap was considered and rejected: it would leave a duplicate key in a CI
+pipeline, a malformed `pyproject.toml`, and a publishable package's wrong manifest
+all reported by nothing. Switching modes with `mnci upgrade --linter=<other>`
+rewrites the config files **and deletes the mode you left**, so a workspace never
+carries two formatter configs.
+
 **Finding and overriding a rule.** One root config importing a package is easy to
 own and hard to read: nothing in three lines says which of ~20 plugins reported
 the thing you disagree with. Every block in `@mnci/eslint-config` therefore

package/dist/cli.js

@@ -1435,9 +1435,41 @@ function eslintToolchainDependencies(nxVersion) {
     eslint: ESLINT_VERSION,
     "@nx/eslint": nxVersion,
     "@nx/eslint-plugin": nxVersion,
-    "@mnci/eslint-config": eslintConfigSpec()
+    "@mnci/eslint-config": eslintConfigSpec(),
+    // Declared rather than left to hoisting. `@mnci/eslint-config` depends on
+    // prettier, so `npx prettier` works either way — but the VS Code extension
+    // resolves prettier from the PROJECT's dependencies and silently falls back
+    // to its own bundled copy when it finds none. A workspace should declare the
+    // formatter it formats with instead of relying on npm flattening someone
+    // else's transitive dependency to the root.
+    prettier: PRETTIER_VERSION
+  };
+}
+function rootLintTarget(linter) {
+  if (linter !== "oxlint") return ROOT_LINT_TARGET;
+  return {
+    executor: "nx:run-commands",
+    cache: true,
+    options: {
+      commands: ["oxlint .", ROOT_LINT_TARGET.options.command],
+      parallel: false,
+      cwd: "."
+    }
+  };
+}
+var OXLINT_VERSION = "^1.76.0";
+var OXFMT_VERSION = "^0.61.0";
+function oxlintToolchainDependencies() {
+  return {
+    "@mnci/oxlint-config": oxlintConfigSpec(),
+    oxlint: OXLINT_VERSION,
+    oxfmt: OXFMT_VERSION
   };
 }
+var OXLINT_CONFIG_VERSION = "^0.1.0";
+function oxlintConfigSpec() {
+  return process.env.MNCI_OXLINT_CONFIG_SPEC ?? OXLINT_CONFIG_VERSION;
+}
 var ESLINT_BLOCK_INVENTORY = `// WHAT IS IN HERE. Each line is one config block, by the \`name\` it carries.
 //
 //   mnci/ignores                  paths never linted (dist, coverage, .venv, \u2026)
@@ -1495,6 +1527,53 @@ ${ESLINT_BLOCK_INVENTORY}//
 // impossible to satisfy at the same time. Formatting lives in .prettierrc.mjs.
 export default mnci({ workspaceRoot: import.meta.dirname })
 `;
+var ESLINT_CONFIG_NON_JS = `import { nonJs } from '@mnci/eslint-config'
+
+// This workspace lints JS/TS with oxlint (see oxlint.config.ts). ESLint keeps
+// the file types oxlint cannot parse at all \u2014 YAML, TOML, Markdown, CSS, HTML,
+// JSON \u2014 plus @nx/dependency-checks on publishable manifests.
+//
+// The JS/TS rule blocks are deliberately NOT composed here. Running both linters
+// over the same file would report one defect twice under two different names.
+//
+// TO OVERRIDE, append a named block after the spread, exactly as the full config
+// documents. To change a JS/TS rule, edit oxlint.config.ts instead \u2014 this file
+// does not lint JS/TS.
+export default [...nonJs({ workspaceRoot: import.meta.dirname })]
+`;
+var OXLINT_CONFIG = `import { defineConfig } from 'oxlint'
+import mnci from '@mnci/oxlint-config'
+
+// oxlint owns JS/TS/JSX here; eslint.config.mjs keeps everything oxlint cannot
+// parse. The contract @mnci/oxlint-config holds itself to: anything
+// @mnci/eslint-config accepts must pass oxlint, so switching linters never turns
+// a green codebase red.
+//
+// oxlint.config.ts, not .oxlintrc.json, and that is not a preference: .oxlintrc's
+// \`extends\` takes PATHS relative to the config file, so
+// \`extends: ["@mnci/oxlint-config"]\` fails with "No such file or directory".
+// defineConfig is the only shareable-config route oxlint offers.
+//
+// Type-aware rules (no-floating-promises and friends) are opt-in \u2014 pass
+// { typeAware: true } AND run oxlint with --type-aware. They report findings the
+// ESLint stack accepts, so they are off by default to keep the contract above.
+export default defineConfig({ extends: [mnci()] })
+`;
+var OXFMT_CONFIG = `${JSON.stringify(
+  {
+    $schema: "./node_modules/oxfmt/configuration_schema.json",
+    semi: false,
+    singleQuote: true,
+    trailingComma: "none",
+    arrowParens: "avoid",
+    printWidth: 100,
+    tabWidth: 2,
+    useTabs: false
+  },
+  null,
+  2
+)}
+`;
 var PRETTIER_IGNORE = `node_modules
 dist
 dist-dev
@@ -1522,6 +1601,17 @@ var SHARED_VSCODE_EXTENSIONS = [
   "nrwl.angular-console",
   "firsttris.vscode-jest-runner"
 ];
+var FORMATTED_LANGUAGES = [
+  "javascript",
+  "javascriptreact",
+  "typescript",
+  "typescriptreact",
+  "json",
+  "jsonc",
+  "yaml",
+  "markdown",
+  "css"
+];
 function vscodeExtensions(linter) {
   return [...LINTER_EXTENSIONS[linter], ...SHARED_VSCODE_EXTENSIONS];
 }
@@ -1544,9 +1634,26 @@ function vscodeSettings(linter) {
     },
     "editor.defaultFormatter": formatter,
     "editor.formatOnSave": true,
-    "[json]": { "editor.defaultFormatter": formatter },
-    "[jsonc]": { "editor.defaultFormatter": formatter },
-    "[yaml]": { "editor.defaultFormatter": formatter }
+    // Every language spelled out, and the global default above is NOT enough on
+    // its own — which is the bug this fixes rather than a belt-and-braces habit.
+    //
+    // VS Code resolves a language-specific setting ahead of a general one, and it
+    // does that comparison BEFORE scope. So a `[typescript]` block in someone's
+    // USER settings — left over from any other project — outranks this file's
+    // workspace-level `editor.defaultFormatter`, and format-on-save quietly uses
+    // that other formatter instead. Nothing reports it: Prettier is installed,
+    // the config resolves, `npm run format:check` still finds the 68 unformatted
+    // files, and the editor simply never applies it.
+    //
+    // Reported from a real workspace where `.ts` files were not being formatted
+    // while `.json`/`.jsonc`/`.yaml` were — exactly the three that had explicit
+    // entries here and nothing else did.
+    ...Object.fromEntries(
+      FORMATTED_LANGUAGES.map((language) => [
+        `[${language}]`,
+        { "editor.defaultFormatter": formatter }
+      ])
+    )
   };
 }
 function vscodeWorkspace(workspaceName, linter, existingTasks) {
@@ -1574,11 +1681,12 @@ var ROOT_SCRIPTS = {
   "release:preview": "nx release --dry-run",
   prepare: "husky"
 };
-function rootScripts() {
+function rootScripts(linter = "eslint") {
+  const formatter = linter === "oxlint" ? "oxfmt" : "prettier";
   return {
     ...ROOT_SCRIPTS,
-    format: "prettier --write .",
-    "format:check": "prettier --check .",
+    format: linter === "oxlint" ? "oxfmt ." : "prettier --write .",
+    "format:check": `${formatter} --check .`,
     "python:install": `${PYTHON_INSTALL_GUARD} && ${PYTHON_WORKSPACE_INSTALL_GUARD}`
   };
 }
@@ -2123,6 +2231,9 @@ function removeNxScaffolding(workspaceRoot) {
   }
   removeProjectEslintConfigs(workspaceRoot);
 }
+function removeIfPresent(path) {
+  (0, import_node_fs6.rmSync)(path, { recursive: true, force: true });
+}
 function removeProjectEslintConfigs(workspaceRoot) {
   const matches = (0, import_node_fs6.globSync)("{apps,libs,packages}/*/eslint.config.{js,mjs,cjs,ts,mts,cts}", {
     cwd: workspaceRoot
@@ -2146,7 +2257,7 @@ function applyOverlay(workspaceRoot, options) {
   const manifest = readJson(manifestPath);
   const scripts = {
     ...manifest.scripts,
-    ...rootScripts()
+    ...rootScripts(options.stack.linter)
   };
   const existingDevDeps = manifest.devDependencies;
   const devDeps = {
@@ -2154,6 +2265,9 @@ function applyOverlay(workspaceRoot, options) {
     ...TS_COMPILER_DEPENDENCIES,
     // The preset pins `nx` itself; the ESLint plugins must match it exactly.
     ...eslintToolchainDependencies(existingDevDeps?.nx ?? "latest"),
+    // Additive, not a replacement: the hybrid keeps the whole ESLint toolchain
+    // for the file types oxlint cannot parse.
+    ...options.stack.linter === "oxlint" && oxlintToolchainDependencies(),
     prettier: PRETTIER_VERSION
   };
   const overrides = {
@@ -2166,7 +2280,7 @@ function applyOverlay(workspaceRoot, options) {
     includedScripts: existingNx?.includedScripts ?? [],
     targets: {
       ...existingNx?.targets,
-      lint: ROOT_LINT_TARGET
+      lint: rootLintTarget(options.stack.linter)
     }
   };
   writeFileEnsured(
@@ -2185,8 +2299,17 @@ function applyOverlay(workspaceRoot, options) {
   const hookPath = (0, import_node_path11.join)(workspaceRoot, ".husky/commit-msg");
   writeFileEnsured(hookPath, COMMIT_MSG_HOOK);
   markExecutable(hookPath);
-  writeFileEnsured((0, import_node_path11.join)(workspaceRoot, "eslint.config.mjs"), ESLINT_CONFIG);
-  writeFileEnsured((0, import_node_path11.join)(workspaceRoot, ".prettierrc.mjs"), PRETTIER_CONFIG);
+  if (options.stack.linter === "oxlint") {
+    writeFileEnsured((0, import_node_path11.join)(workspaceRoot, "oxlint.config.ts"), OXLINT_CONFIG);
+    writeFileEnsured((0, import_node_path11.join)(workspaceRoot, ".oxfmtrc.json"), OXFMT_CONFIG);
+    writeFileEnsured((0, import_node_path11.join)(workspaceRoot, "eslint.config.mjs"), ESLINT_CONFIG_NON_JS);
+    removeIfPresent((0, import_node_path11.join)(workspaceRoot, ".prettierrc.mjs"));
+  } else {
+    writeFileEnsured((0, import_node_path11.join)(workspaceRoot, "eslint.config.mjs"), ESLINT_CONFIG);
+    writeFileEnsured((0, import_node_path11.join)(workspaceRoot, ".prettierrc.mjs"), PRETTIER_CONFIG);
+    removeIfPresent((0, import_node_path11.join)(workspaceRoot, "oxlint.config.ts"));
+    removeIfPresent((0, import_node_path11.join)(workspaceRoot, ".oxfmtrc.json"));
+  }
   writeFileEnsured(
     (0, import_node_path11.join)(workspaceRoot, ".devcontainer/devcontainer.json"),
     devcontainerJson(options.workspaceName, options.stack.linter)
@@ -2249,6 +2372,44 @@ function checkPrettierConfig(workspaceRoot) {
     remedy: "delete .prettierrc (or run `mnci upgrade`, which deletes it)"
   };
 }
+function checkLinterModeIsConsistent(workspaceRoot) {
+  const linter = readMnciConfig(workspaceRoot).stack?.linter ?? "eslint";
+  const oxlintFiles = ["oxlint.config.ts", ".oxfmtrc.json"].filter(
+    (file) => fileExists((0, import_node_path12.join)(workspaceRoot, file))
+  );
+  const hasPrettier = fileExists((0, import_node_path12.join)(workspaceRoot, ".prettierrc.mjs"));
+  const stray = linter === "oxlint" ? hasPrettier ? [".prettierrc.mjs"] : [] : oxlintFiles;
+  return {
+    check: `linter is ${linter} and only ${linter}'s config files are present`,
+    ok: stray.length === 0,
+    detail: `${stray.join(", ")} belongs to the other linter mode, so two configs are in play at once`,
+    remedy: "run `mnci upgrade`, which removes the mode the workspace did not choose"
+  };
+}
+function checkOxlintToolchainDeclared(workspaceRoot) {
+  const linter = readMnciConfig(workspaceRoot).stack?.linter ?? "eslint";
+  if (linter !== "oxlint") {
+    return {
+      check: "oxlint toolchain declared",
+      ok: true,
+      detail: "not an oxlint workspace",
+      remedy: ""
+    };
+  }
+  const manifest = readJson(
+    (0, import_node_path12.join)(workspaceRoot, "package.json")
+  );
+  const devDeps = manifest?.devDependencies ?? {};
+  const missing = ["oxlint", "oxfmt", "@mnci/oxlint-config"].filter(
+    (dependency) => devDeps[dependency] === void 0
+  );
+  return {
+    check: "oxlint toolchain declared in devDependencies",
+    ok: missing.length === 0,
+    detail: `missing: ${missing.join(", ")} \u2014 lint or format will fail with "command not found"`,
+    remedy: "run `mnci upgrade`, which writes the toolchain the chosen linter needs"
+  };
+}
 function checkEslintPlugin(nxJson) {
   const plugins = nxJson.plugins ?? [];
   const registered = plugins.some(
@@ -2343,6 +2504,8 @@ function collectFindings(workspaceRoot) {
   return [
     ...checkEslintConfigs(workspaceRoot),
     checkPrettierConfig(workspaceRoot),
+    checkLinterModeIsConsistent(workspaceRoot),
+    checkOxlintToolchainDeclared(workspaceRoot),
     checkEslintPlugin(nxJson),
     checkResolvedEslint(workspaceRoot),
     checkNpmrc(workspaceRoot, nxJson.mnci?.registry, nxJson.mnci?.scope),