@mnci/cli 1.17.2 → 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

@@ -141,7 +141,20 @@ async function promptStack() {
       { name: "Vitest", value: "vitest" }
     ]
   });
-  return { testRunner };
+  const linter = await (0, import_prompts.select)({
+    message: "Linter and formatter",
+    choices: [
+      {
+        name: "ESLint + Prettier \u2014 every file type, the widest rule coverage",
+        value: "eslint"
+      },
+      {
+        name: "oxlint + oxfmt for JS/TS, ESLint for the rest \u2014 much faster, same style",
+        value: "oxlint"
+      }
+    ]
+  });
+  return { testRunner, linter };
 }
 
 // src/util/fsx.ts
@@ -1241,7 +1254,7 @@ var import_node_path12 = require("path");
 // src/overlay.ts
 var import_node_fs6 = require("fs");
 var import_node_path11 = require("path");
-var DEFAULT_STACK = { testRunner: "jest" };
+var DEFAULT_STACK = { testRunner: "jest", linter: "eslint" };
 var PRETTIER_VERSION = "^3.8.1";
 var TS_COMPILER_DEPENDENCIES = {
   "@typescript/native": "npm:typescript@^7.0.2",
@@ -1375,7 +1388,7 @@ function eslintConfigSpec() {
   return process.env.MNCI_ESLINT_CONFIG_SPEC ?? ESLINT_CONFIG_VERSION;
 }
 var ESLINT_VERSION = "^10.8.0";
-function devcontainerJson(workspaceName) {
+function devcontainerJson(workspaceName, linter) {
   return `${toJson({
     name: workspaceName,
     image: `mcr.microsoft.com/devcontainers/typescript-node:${NODE_VERSION}-bookworm`,
@@ -1394,7 +1407,7 @@ function devcontainerJson(workspaceName) {
     // The same recommendations the `.code-workspace` file carries, so opening
     // the folder in a container suggests the identical toolset.
     customizations: {
-      vscode: { extensions: [...VSCODE_RECOMMENDED_EXTENSIONS] }
+      vscode: { extensions: vscodeExtensions(linter) }
     }
   })}
 `;
@@ -1422,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)
@@ -1482,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
@@ -1501,43 +1593,75 @@ __pycache__
 .ruff_cache
 .dart_tool
 `;
-var VSCODE_RECOMMENDED_EXTENSIONS = [
-  "dbaeumer.vscode-eslint",
-  "esbenp.prettier-vscode",
+var LINTER_EXTENSIONS = {
+  eslint: ["dbaeumer.vscode-eslint", "esbenp.prettier-vscode"],
+  oxlint: ["oxc.oxc-vscode", "dbaeumer.vscode-eslint"]
+};
+var SHARED_VSCODE_EXTENSIONS = [
   "nrwl.angular-console",
   "firsttris.vscode-jest-runner"
 ];
-function vscodeWorkspace(workspaceName, existingTasks) {
+var FORMATTED_LANGUAGES = [
+  "javascript",
+  "javascriptreact",
+  "typescript",
+  "typescriptreact",
+  "json",
+  "jsonc",
+  "yaml",
+  "markdown",
+  "css"
+];
+function vscodeExtensions(linter) {
+  return [...LINTER_EXTENSIONS[linter], ...SHARED_VSCODE_EXTENSIONS];
+}
+function vscodeSettings(linter) {
+  const formatter = linter === "oxlint" ? "oxc.oxc-vscode" : "esbenp.prettier-vscode";
+  const eslintLanguages = linter === "oxlint" ? ["json", "jsonc", "markdown", "yaml", "html", "css"] : [
+    "javascript",
+    "javascriptreact",
+    "typescript",
+    "typescriptreact",
+    "json",
+    "jsonc",
+    "markdown",
+    "yaml"
+  ];
+  return {
+    "eslint.validate": eslintLanguages,
+    "editor.codeActionsOnSave": {
+      "source.fixAll.eslint": "explicit"
+    },
+    "editor.defaultFormatter": formatter,
+    "editor.formatOnSave": true,
+    // 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) {
   return JSON.stringify(
     {
       folders: [{ path: ".", name: workspaceName }],
-      settings: {
-        "eslint.validate": [
-          "javascript",
-          "javascriptreact",
-          "typescript",
-          "typescriptreact",
-          "json",
-          "jsonc",
-          "markdown",
-          "yaml"
-        ],
-        "editor.codeActionsOnSave": {
-          "source.fixAll.eslint": "explicit"
-        },
-        "editor.defaultFormatter": "esbenp.prettier-vscode",
-        "editor.formatOnSave": true,
-        "[json]": {
-          "editor.defaultFormatter": "esbenp.prettier-vscode"
-        },
-        "[jsonc]": {
-          "editor.defaultFormatter": "esbenp.prettier-vscode"
-        },
-        "[yaml]": {
-          "editor.defaultFormatter": "esbenp.prettier-vscode"
-        }
-      },
-      extensions: { recommendations: [...VSCODE_RECOMMENDED_EXTENSIONS] },
+      settings: vscodeSettings(linter),
+      extensions: { recommendations: vscodeExtensions(linter) },
       tasks: {
         version: existingTasks?.version ?? "2.0.0",
         tasks: existingTasks?.tasks ?? []
@@ -1557,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}`
   };
 }
@@ -1595,7 +1720,7 @@ function mnciConfig(options) {
     agent: options.agent,
     variableGroup: options.variableGroup,
     ci: options.ci,
-    stack: { testRunner: options.stack.testRunner }
+    stack: { testRunner: options.stack.testRunner, linter: options.stack.linter }
   };
 }
 function readMnciConfig(workspaceRoot) {
@@ -2106,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
@@ -2129,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 = {
@@ -2137,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 = {
@@ -2149,7 +2280,7 @@ function applyOverlay(workspaceRoot, options) {
     includedScripts: existingNx?.includedScripts ?? [],
     targets: {
       ...existingNx?.targets,
-      lint: ROOT_LINT_TARGET
+      lint: rootLintTarget(options.stack.linter)
     }
   };
   writeFileEnsured(
@@ -2168,17 +2299,29 @@ 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)
+    devcontainerJson(options.workspaceName, options.stack.linter)
   );
   writeFileEnsured((0, import_node_path11.join)(workspaceRoot, ".prettierignore"), PRETTIER_IGNORE);
   removeNxScaffolding(workspaceRoot);
   const codeWorkspacePath = (0, import_node_path11.join)(workspaceRoot, `${options.workspaceName}.code-workspace`);
   const existing = readCodeWorkspace(codeWorkspacePath);
-  writeFileEnsured(codeWorkspacePath, vscodeWorkspace(options.workspaceName, existing?.tasks));
+  writeFileEnsured(
+    codeWorkspacePath,
+    vscodeWorkspace(options.workspaceName, options.stack.linter, existing?.tasks)
+  );
   if (options.workspaceName !== "undefined") {
     (0, import_node_fs6.rmSync)((0, import_node_path11.join)(workspaceRoot, "undefined.code-workspace"), { force: true });
   }
@@ -2229,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(
@@ -2323,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),
@@ -2361,14 +2544,16 @@ function nxCloudProviderValue(ci) {
   return ci === "azure" ? "azure" : "github";
 }
 async function resolveStack(options) {
-  if (options.testRunner || options.yes) {
+  if (options.testRunner || options.linter || options.yes) {
     return {
-      testRunner: options.testRunner ?? DEFAULT_STACK.testRunner
+      testRunner: options.testRunner ?? DEFAULT_STACK.testRunner,
+      linter: options.linter ?? DEFAULT_STACK.linter
     };
   }
   const prompted = await promptStack();
   return {
-    testRunner: prompted.testRunner
+    testRunner: prompted.testRunner,
+    linter: prompted.linter
   };
 }
 var CI_PROVIDERS = /* @__PURE__ */ new Set(["azure", "github", "both"]);
@@ -2514,6 +2699,7 @@ function resolveOverlayOptions(workspaceRoot, options, persisted) {
     );
   }
   const variableGroup = options.variableGroup ?? persisted.variableGroup ?? "Build";
+  const linter = options.linter ?? persisted.stack?.linter ?? "eslint";
   const testRunner = options.testRunner ?? persisted.stack?.testRunner;
   if (!testRunner) {
     throw new Error(
@@ -2527,7 +2713,7 @@ function resolveOverlayOptions(workspaceRoot, options, persisted) {
     agent,
     variableGroup,
     ci,
-    stack: { testRunner }
+    stack: { testRunner, linter }
   };
 }
 function runUpgrade(workspaceRoot, options) {
@@ -2641,7 +2827,10 @@ function buildProgram(cliVersion) {
   program.command("new").argument("[name]", "workspace name").description("Create a new monorepo (Nx TS preset + release/pipeline overlay)").option("-y, --yes", "accept defaults for anything not passed as a flag").option("--scope <scope>", "npm scope for publishable packages (e.g. @demo)").option("--registry <kind>", "azure-artifacts | npm").option("--organization <name>", "Azure DevOps organization").option("--project <name>", "Azure DevOps project").option("--artifacts-feed <name>", "Azure Artifacts feed").option(
     "--agent <pool>",
     "CI build agent: a vmImage (e.g. ubuntu-latest) or self-hosted pool name"
-  ).option("--variable-group <name>", "Azure DevOps variable group holding the npm PAT").option("--ci <provider>", "CI provider: azure | github | both").option("--test-runner <runner>", "unit-test runner: jest | vitest").option("--nx-cloud", "connect the workspace to Nx Cloud (remote caching + CI insights)").action(async (name, options) => {
+  ).option("--variable-group <name>", "Azure DevOps variable group holding the npm PAT").option("--ci <provider>", "CI provider: azure | github | both").option("--test-runner <runner>", "unit-test runner: jest | vitest").option(
+    "--linter <linter>",
+    "linter + formatter: eslint (ESLint + Prettier) | oxlint (oxlint + oxfmt for JS/TS, ESLint for the rest)"
+  ).option("--nx-cloud", "connect the workspace to Nx Cloud (remote caching + CI insights)").action(async (name, options) => {
     await runNew(name, options);
   });
   program.command("upgrade").description(
@@ -2649,6 +2838,9 @@ function buildProgram(cliVersion) {
   ).option("--scope <scope>", "npm scope for publishable packages (overrides the persisted value)").option("--registry <kind>", "azure-artifacts | npm (overrides the persisted value)").option("--organization <name>", "Azure DevOps organization").option("--project <name>", "Azure DevOps project").option("--artifacts-feed <name>", "Azure Artifacts feed").option("--agent <pool>", "CI build agent (overrides the persisted value)").option("--variable-group <name>", "Azure DevOps variable group holding the npm PAT").option("--ci <provider>", "CI provider: azure | github | both (overrides the persisted value)").option(
     "--test-runner <runner>",
     "unit-test runner: jest | vitest (overrides the persisted value)"
+  ).option(
+    "--linter <linter>",
+    "linter + formatter: eslint | oxlint (overrides the persisted value)"
   ).action((options) => {
     runUpgrade(process.cwd(), options);
   });