@mnci/cli 1.18.0 → 1.19.1

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,53 @@ 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 (~6x faster on this repo)                          |
+| Formats `.toml`                 | no — Prettier has no TOML parser       | **yes**                                                  |
+| 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.
+
+**Exactly one formatter is declared, and that is a fix rather than tidiness.**
+`prettier` under `eslint`, `oxfmt` under `oxlint`, and switching modes drops the
+other from `devDependencies`. prettier stays in `node_modules` either way, since
+`@mnci/eslint-config` depends on it — so what matters is the _declaration_:
+`esbenp.prettier-vscode` resolves the formatter from the **project's**
+dependencies, so an oxlint workspace that still declared prettier is one where a
+globally installed Prettier extension reformats on save against the opinion oxfmt
+is not applying, while `npm run format:check` (oxfmt) reports the result as
+unformatted. Both configs valid, both binaries resolvable, neither one wrong on
+its own — the `.prettierrc` precedence bug in another costume. `mnci doctor`
+checks it.
+
+**oxfmt formats `.toml`; Prettier cannot.** `prettier` on a `.toml` exits with
+`No parser could be inferred for file`, so an oxlint workspace gets a formatted
+`pyproject.toml` and the default cannot — the one gap
+`@mnci/eslint-config`'s parser-only TOML block has always documented as
+unenforceable. It is the only file type where the two formatters differ in what
+they can parse, which is why `[toml]` is pinned for format-on-save under `oxlint`
+only: pinning it under `eslint` would route the file to a formatter that errors
+on it.
+
 **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

@@ -80,11 +80,12 @@ function runNpx(arguments_, cwd) {
     throw new Error(`npx ${arguments_.join(" ")} failed with exit code ${status}`);
   }
 }
-function runPrettier(cwd, target = ".") {
-  const status = runShell("npx", ["prettier", "--write", "--log-level", "warn", target], cwd);
+function runFormatter(cwd, linter, target = ".") {
+  const [command, arguments_] = linter === "oxlint" ? ["oxfmt", ["--write", target]] : ["prettier", ["--write", "--log-level", "warn", target]];
+  const status = runShell("npx", [command, ...arguments_], cwd);
   if (status !== 0) {
     logger.warn(
-      `Prettier could not format '${target}' (exit code ${status}). The project was generated; run 'npm run format' to normalise it.`
+      `${command} could not format '${target}' (exit code ${status}). The project was generated; run 'npm run format' to normalise it.`
     );
   }
 }
@@ -1215,7 +1216,7 @@ async function runAdd(kind, name, options) {
     case "python-vendor": {
       await addPythonVendor(workspaceRoot, resolvedName, options, kindProvided);
       syncProjectReferences(workspaceRoot);
-      runPrettier(workspaceRoot);
+      runFormatter(workspaceRoot, stack.linter);
       return;
     }
     default: {
@@ -1226,7 +1227,7 @@ async function runAdd(kind, name, options) {
     }
   }
   syncProjectReferences(workspaceRoot);
-  runPrettier(workspaceRoot);
+  runFormatter(workspaceRoot, stack.linter);
   logger.success(`Added ${resolvedKind} '${resolvedName}'.`);
 }
 function syncProjectReferences(workspaceRoot) {
@@ -1243,7 +1244,14 @@ function readWorkspaceStack(workspaceRoot) {
   );
   const stack = nxJson.mnci?.stack;
   return {
-    testRunner: stack?.testRunner === "vitest" ? "vitest" : "jest"
+    testRunner: stack?.testRunner === "vitest" ? "vitest" : "jest",
+    // Defaults to `eslint` when absent, the same call `mnci upgrade` makes and
+    // for the same reason: every workspace generated before the choice existed
+    // has no persisted value and is an ESLint workspace. Reading it at all is
+    // the fix — this function returned `testRunner` alone, so `add` finished by
+    // formatting an oxlint workspace with Prettier, against Prettier's defaults,
+    // since the overlay had deleted the config that would have corrected it.
+    linter: stack?.linter === "oxlint" ? "oxlint" : "eslint"
   };
 }
 
@@ -1438,6 +1446,39 @@ function eslintToolchainDependencies(nxVersion) {
     "@mnci/eslint-config": eslintConfigSpec()
   };
 }
+var LINTER_ONLY_DEPENDENCIES = {
+  eslint: ["prettier"],
+  oxlint: ["@mnci/oxlint-config", "oxlint", "oxfmt"]
+};
+function withoutStaleLinterDependencies(devDeps, linter) {
+  const stale = new Set(LINTER_ONLY_DEPENDENCIES[linter === "oxlint" ? "eslint" : "oxlint"]);
+  return Object.fromEntries(Object.entries(devDeps).filter(([name]) => !stale.has(name)));
+}
+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 +1536,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 +1610,22 @@ var SHARED_VSCODE_EXTENSIONS = [
   "nrwl.angular-console",
   "firsttris.vscode-jest-runner"
 ];
+var FORMATTED_LANGUAGES = [
+  "javascript",
+  "javascriptreact",
+  "typescript",
+  "typescriptreact",
+  "json",
+  "jsonc",
+  "yaml",
+  "markdown",
+  "css",
+  "html"
+];
+var OXFMT_ONLY_LANGUAGES = ["toml"];
+function formattedLanguages(linter) {
+  return [...FORMATTED_LANGUAGES, ...linter === "oxlint" ? OXFMT_ONLY_LANGUAGES : []];
+}
 function vscodeExtensions(linter) {
   return [...LINTER_EXTENSIONS[linter], ...SHARED_VSCODE_EXTENSIONS];
 }
@@ -1544,9 +1648,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(
+      formattedLanguages(linter).map((language) => [
+        `[${language}]`,
+        { "editor.defaultFormatter": formatter }
+      ])
+    )
   };
 }
 function vscodeWorkspace(workspaceName, linter, existingTasks) {
@@ -1574,11 +1695,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 +2245,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,16 +2271,23 @@ function applyOverlay(workspaceRoot, options) {
   const manifest = readJson(manifestPath);
   const scripts = {
     ...manifest.scripts,
-    ...rootScripts()
+    ...rootScripts(options.stack.linter)
   };
   const existingDevDeps = manifest.devDependencies;
-  const devDeps = {
-    ...existingDevDeps,
-    ...TS_COMPILER_DEPENDENCIES,
-    // The preset pins `nx` itself; the ESLint plugins must match it exactly.
-    ...eslintToolchainDependencies(existingDevDeps?.nx ?? "latest"),
-    prettier: PRETTIER_VERSION
-  };
+  const devDeps = withoutStaleLinterDependencies(
+    {
+      ...existingDevDeps,
+      ...TS_COMPILER_DEPENDENCIES,
+      // The preset pins `nx` itself; the ESLint plugins must match it exactly.
+      ...eslintToolchainDependencies(existingDevDeps?.nx ?? "latest"),
+      // Additive for the linter, exclusive for the formatter: the hybrid keeps
+      // the whole ESLint toolchain for the file types oxlint cannot parse, but
+      // exactly one of prettier/oxfmt formats the workspace. Declaring both is
+      // how an editor ends up applying the one CI does not check.
+      ...options.stack.linter === "oxlint" ? oxlintToolchainDependencies() : { prettier: PRETTIER_VERSION }
+    },
+    options.stack.linter
+  );
   const overrides = {
     ...manifest.overrides,
     ...ESLINT_PEER_OVERRIDES
@@ -2166,7 +2298,7 @@ function applyOverlay(workspaceRoot, options) {
     includedScripts: existingNx?.includedScripts ?? [],
     targets: {
       ...existingNx?.targets,
-      lint: ROOT_LINT_TARGET
+      lint: rootLintTarget(options.stack.linter)
     }
   };
   writeFileEnsured(
@@ -2185,8 +2317,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 +2390,58 @@ 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 declaredDevDependencies(workspaceRoot) {
+  const manifestPath = (0, import_node_path12.join)(workspaceRoot, "package.json");
+  if (!fileExists(manifestPath)) return {};
+  const manifest = readJson(manifestPath);
+  return manifest.devDependencies ?? {};
+}
+function checkOneFormatterDeclared(workspaceRoot) {
+  const linter = readMnciConfig(workspaceRoot).stack?.linter ?? "eslint";
+  const stale = linter === "oxlint" ? "prettier" : "oxfmt";
+  const declared = declaredDevDependencies(workspaceRoot)[stale] !== void 0;
+  return {
+    check: `only ${linter === "oxlint" ? "oxfmt" : "prettier"} is declared as the formatter`,
+    ok: !declared,
+    detail: `${stale} is declared but nothing runs it \u2014 the editor may still resolve and apply it, disagreeing with \`npm run format:check\``,
+    remedy: "run `mnci upgrade`, which drops the formatter of the mode you left"
+  };
+}
+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 devDeps = declaredDevDependencies(workspaceRoot);
+  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 +2536,9 @@ function collectFindings(workspaceRoot) {
   return [
     ...checkEslintConfigs(workspaceRoot),
     checkPrettierConfig(workspaceRoot),
+    checkLinterModeIsConsistent(workspaceRoot),
+    checkOneFormatterDeclared(workspaceRoot),
+    checkOxlintToolchainDeclared(workspaceRoot),
     checkEslintPlugin(nxJson),
     checkResolvedEslint(workspaceRoot),
     checkNpmrc(workspaceRoot, nxJson.mnci?.registry, nxJson.mnci?.scope),
@@ -2458,8 +2654,10 @@ async function runNew(name, options) {
     throw new Error(`npm install of the toolchain failed with exit code ${installStatus}`);
   }
   runShell("npx", ["husky"], workspaceRoot);
-  logger.step("Formatting the workspace (Prettier, JavaScript Standard Style)");
-  runPrettier(workspaceRoot);
+  logger.step(
+    `Formatting the workspace (${stack.linter === "oxlint" ? "oxfmt" : "Prettier"}, JavaScript Standard Style)`
+  );
+  runFormatter(workspaceRoot, stack.linter);
   logger.success("Done. Next steps:");
   logger.info(`  cd ${workspaceName}`);
   logger.info("  mnci add react-app web        # or: react-lib, react-internal-lib, node-app,");
@@ -2565,7 +2763,7 @@ function runUpgrade(workspaceRoot, options) {
     "Re-applying the MoNecromanCI overlay (release config, .npmrc, commitlint, pipeline, stack)"
   );
   applyOverlay(workspaceRoot, resolved);
-  runPrettier(workspaceRoot);
+  runFormatter(workspaceRoot, resolved.stack.linter);
   logger.success("Done. Review the changes with `git diff` before committing.");
 }