@mnci/cli 1.9.1 → 1.11.0

package/dist/cli.js

@@ -38,11 +38,32 @@ module.exports = __toCommonJS(cli_exports);
 var import_commander = require("commander");
 
 // src/commands/add.ts
-var import_node_path8 = require("path");
+var import_node_path9 = require("path");
 var import_prompts4 = require("@inquirer/prompts");
 
 // src/nx.ts
 var import_cross_spawn = __toESM(require("cross-spawn"));
+
+// src/util/logger.ts
+var logger = {
+  info(message) {
+    console.log(message);
+  },
+  step(message) {
+    console.log(`\u2192 ${message}`);
+  },
+  success(message) {
+    console.log(`\u2713 ${message}`);
+  },
+  warn(message) {
+    console.warn(`! ${message}`);
+  },
+  error(message) {
+    console.error(`\u2717 ${message}`);
+  }
+};
+
+// src/nx.ts
 function runShell(command, arguments_, cwd) {
   const result = import_cross_spawn.default.sync(command, arguments_, { stdio: "inherit", cwd });
   return result.status ?? 1;
@@ -59,6 +80,14 @@ 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);
+  if (status !== 0) {
+    logger.warn(
+      `Prettier could not format '${target}' (exit code ${status}). The project was generated; run 'npm run format' to normalise it.`
+    );
+  }
+}
 
 // src/prompts.ts
 var import_prompts = require("@inquirer/prompts");
@@ -136,25 +165,6 @@ function fileExists(path) {
   return (0, import_node_fs.existsSync)(path);
 }
 
-// src/util/logger.ts
-var logger = {
-  info(message) {
-    console.log(message);
-  },
-  step(message) {
-    console.log(`\u2192 ${message}`);
-  },
-  success(message) {
-    console.log(`\u2713 ${message}`);
-  },
-  warn(message) {
-    console.warn(`! ${message}`);
-  },
-  error(message) {
-    console.error(`\u2717 ${message}`);
-  }
-};
-
 // src/util/names.ts
 function assertValidProjectName(name, label) {
   if (!/^[a-z][a-z0-9-]*$/.test(name)) {
@@ -164,7 +174,11 @@ function assertValidProjectName(name, label) {
   }
 }
 
+// src/commands/add/flutter.ts
+var import_node_path3 = require("path");
+
 // src/commands/add/shared.ts
+var import_node_fs2 = require("fs");
 var import_node_path2 = require("path");
 function hasPlugin(workspaceRoot, packageName) {
   const manifest = readJson((0, import_node_path2.join)(workspaceRoot, "package.json"));
@@ -198,8 +212,93 @@ function addNxTargets(manifestPath, newTargets) {
     toJson({ ...manifest, nx: { ...nx, targets: { ...targets, ...newTargets } } })
   );
 }
+var ESLINT_CONFIG_FILENAMES = [
+  "eslint.config.js",
+  "eslint.config.mjs",
+  "eslint.config.cjs",
+  "eslint.config.ts",
+  "eslint.config.mts",
+  "eslint.config.cts"
+];
+function removeGeneratedEslintConfig(workspaceRoot, projectRoot) {
+  for (const filename of ESLINT_CONFIG_FILENAMES) {
+    (0, import_node_fs2.rmSync)((0, import_node_path2.join)(workspaceRoot, projectRoot, filename), { force: true });
+  }
+  (0, import_node_fs2.rmSync)((0, import_node_path2.join)(workspaceRoot, ".vscode"), { recursive: true, force: true });
+}
+function findCodeWorkspaceFile(workspaceRoot) {
+  try {
+    const entry = (0, import_node_fs2.readdirSync)(workspaceRoot).find((file) => file.endsWith(".code-workspace"));
+    return entry ? (0, import_node_path2.join)(workspaceRoot, entry) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function readCodeWorkspaceFile(path) {
+  const contents = (0, import_node_fs2.readFileSync)(path, "utf8").replaceAll(/,(\s*[}\]])/g, "$1");
+  return JSON.parse(contents);
+}
+function projectTask(name, kind) {
+  const script = `${name}:${kind}`;
+  const base = { label: `${name}: ${kind}`, type: "npm", script, problemMatcher: [] };
+  return kind === "start" ? { ...base, isBackground: true } : { ...base, group: kind };
+}
+function registerProjectCommands(workspaceRoot, name, commands) {
+  const scripts = {
+    [`${name}:qa`]: `nx run ${name}:lint && nx run ${name}:test`
+  };
+  if (commands.build) {
+    scripts[`${name}:build`] = `nx run ${name}:build`;
+  }
+  if (commands.start) {
+    scripts[`${name}:start`] = commands.start;
+  }
+  const manifestPath = (0, import_node_path2.join)(workspaceRoot, "package.json");
+  const manifest = readJson(manifestPath);
+  const existingScripts = manifest.scripts ?? {};
+  writeFileEnsured(
+    manifestPath,
+    toJson({ ...manifest, scripts: { ...existingScripts, ...scripts } })
+  );
+  const codeWorkspacePath = findCodeWorkspaceFile(workspaceRoot);
+  if (!codeWorkspacePath) {
+    return;
+  }
+  const workspaceFile = readCodeWorkspaceFile(codeWorkspacePath);
+  const label = (task) => task.label ?? "";
+  const existingTasks = (workspaceFile.tasks?.tasks ?? []).filter(
+    (task) => !label(task).startsWith(`${name}: `)
+  );
+  const newTasks = [
+    projectTask(name, "qa"),
+    ...commands.build ? [projectTask(name, "build")] : [],
+    ...commands.start ? [projectTask(name, "start")] : []
+  ];
+  writeFileEnsured(
+    codeWorkspacePath,
+    toJson({
+      ...workspaceFile,
+      tasks: {
+        version: workspaceFile.tasks?.version ?? "2.0.0",
+        tasks: [...existingTasks, ...newTasks]
+      }
+    })
+  );
+}
 
 // src/commands/add/flutter.ts
+function addProjectJsonTargets(projectJsonPath, newTargets) {
+  const project = readJson(projectJsonPath);
+  const targets = project.targets ?? {};
+  writeFileEnsured(projectJsonPath, toJson({ ...project, targets: { ...targets, ...newTargets } }));
+}
+function flutterAppStartTarget(name) {
+  return {
+    executor: "nx:run-commands",
+    continuous: true,
+    options: { command: "flutter run -d chrome", cwd: `apps/${name}` }
+  };
+}
 function ensureFlutter(workspaceRoot) {
   if (runShell("flutter", ["--version"], workspaceRoot) !== 0) {
     throw new Error(
@@ -228,19 +327,25 @@ function addFlutterApp(workspaceRoot, name) {
   prepareFlutter(workspaceRoot);
   ensureAdmZip(workspaceRoot);
   runNx(["g", "@mnci/nx-flutter:application", name, "--no-interactive"], workspaceRoot);
+  addProjectJsonTargets((0, import_node_path3.join)(workspaceRoot, "apps", name, "project.json"), {
+    start: flutterAppStartTarget(name)
+  });
+  registerProjectCommands(workspaceRoot, name, { build: true, start: `nx run ${name}:start` });
 }
 function addFlutterLib(workspaceRoot, name) {
   prepareFlutter(workspaceRoot);
   runNx(["g", "@mnci/nx-flutter:library", name, "--no-interactive"], workspaceRoot);
+  registerProjectCommands(workspaceRoot, name, { build: false });
 }
 function addFlutterInternalLib(workspaceRoot, name) {
   prepareFlutter(workspaceRoot);
   runNx(["g", "@mnci/nx-flutter:internal-library", name, "--no-interactive"], workspaceRoot);
+  registerProjectCommands(workspaceRoot, name, { build: false });
 }
 
 // src/commands/add/go.ts
-var import_node_fs2 = require("fs");
-var import_node_path3 = require("path");
+var import_node_fs3 = require("fs");
+var import_node_path4 = require("path");
 function ensureGo(workspaceRoot) {
   if (runShell("go", ["version"], workspaceRoot) !== 0) {
     throw new Error("Go not found. Install Go 1.21+ first: https://go.dev/dl/");
@@ -267,7 +372,7 @@ function ensureNxGoPlugin(workspaceRoot) {
   }
 }
 function ensureGoModule(workspaceRoot) {
-  if (fileExists((0, import_node_path3.join)(workspaceRoot, "go.mod"))) {
+  if (fileExists((0, import_node_path4.join)(workspaceRoot, "go.mod"))) {
     return;
   }
   logger.step("Bootstrapping the workspace Go module (single root go.mod)");
@@ -276,13 +381,13 @@ function ensureGoModule(workspaceRoot) {
 }
 function goModulePath(workspaceRoot) {
   try {
-    const contents = (0, import_node_fs2.readFileSync)((0, import_node_path3.join)(workspaceRoot, "go.mod"), "utf8");
+    const contents = (0, import_node_fs3.readFileSync)((0, import_node_path4.join)(workspaceRoot, "go.mod"), "utf8");
     return /^module\s+(\S+)/m.exec(contents)?.[1];
   } catch {
     return void 0;
   }
 }
-function addProjectJsonTargets(projectJsonPath, newTargets) {
+function addProjectJsonTargets2(projectJsonPath, newTargets) {
   const project = readJson(projectJsonPath);
   const targets = project.targets ?? {};
   writeFileEnsured(projectJsonPath, toJson({ ...project, targets: { ...targets, ...newTargets } }));
@@ -296,7 +401,6 @@ function goLintTarget() {
 function goBuildTarget(name) {
   return {
     executor: "@nx-go/nx-go:build",
-    // eslint-disable-next-line unicorn/no-incorrect-template-string-interpolation -- {workspaceRoot} is an Nx output token
     outputs: [`{workspaceRoot}/dist/apps/${name}`],
     options: { outputPath: `../../dist/apps/${name}/${name}` }
   };
@@ -307,11 +411,17 @@ function goPackageTarget(tag, name) {
   return {
     executor: "nx:run-commands",
     dependsOn: ["build"],
-    // eslint-disable-next-line unicorn/no-incorrect-template-string-interpolation -- {workspaceRoot} is an Nx output token
     outputs: [`{workspaceRoot}/${zip}`],
     options: { command }
   };
 }
+function goStartTarget(name) {
+  return {
+    executor: "nx:run-commands",
+    continuous: true,
+    options: { command: "go run .", cwd: `apps/${name}` }
+  };
+}
 function prepareGo(workspaceRoot) {
   ensureGo(workspaceRoot);
   warnIfNoGolangciLint(workspaceRoot);
@@ -332,12 +442,14 @@ function addGoApp(workspaceRoot, name) {
     ],
     workspaceRoot
   );
-  addProjectJsonTargets((0, import_node_path3.join)(workspaceRoot, "apps", name, "project.json"), {
+  addProjectJsonTargets2((0, import_node_path4.join)(workspaceRoot, "apps", name, "project.json"), {
     build: goBuildTarget(name),
     test: goTestTarget(),
     lint: goLintTarget(),
-    package: goPackageTarget("go-app", name)
+    package: goPackageTarget("go-app", name),
+    start: goStartTarget(name)
   });
+  registerProjectCommands(workspaceRoot, name, { build: true, start: `nx run ${name}:start` });
 }
 function addGoFunctionApp(workspaceRoot, name) {
   prepareGo(workspaceRoot);
@@ -353,12 +465,13 @@ function addGoFunctionApp(workspaceRoot, name) {
     ],
     workspaceRoot
   );
-  addProjectJsonTargets((0, import_node_path3.join)(workspaceRoot, "apps", name, "project.json"), {
+  addProjectJsonTargets2((0, import_node_path4.join)(workspaceRoot, "apps", name, "project.json"), {
     build: goBuildTarget(name),
     test: goTestTarget(),
     lint: goLintTarget(),
     package: goPackageTarget("go-function-app", name)
   });
+  registerProjectCommands(workspaceRoot, name, { build: true });
 }
 function addGoLib(workspaceRoot, name) {
   prepareGo(workspaceRoot);
@@ -373,10 +486,11 @@ function addGoLib(workspaceRoot, name) {
     ],
     workspaceRoot
   );
-  addProjectJsonTargets((0, import_node_path3.join)(workspaceRoot, "packages", name, "project.json"), {
+  addProjectJsonTargets2((0, import_node_path4.join)(workspaceRoot, "packages", name, "project.json"), {
     test: goTestTarget(),
     lint: goLintTarget()
   });
+  registerProjectCommands(workspaceRoot, name, { build: false });
   const module2 = goModulePath(workspaceRoot);
   if (module2) {
     logger.step(`Import it as ${module2}/packages/${name}`);
@@ -395,10 +509,11 @@ function addGoInternalLib(workspaceRoot, name) {
     ],
     workspaceRoot
   );
-  addProjectJsonTargets((0, import_node_path3.join)(workspaceRoot, "libs", name, "project.json"), {
+  addProjectJsonTargets2((0, import_node_path4.join)(workspaceRoot, "libs", name, "project.json"), {
     test: goTestTarget(),
     lint: goLintTarget()
   });
+  registerProjectCommands(workspaceRoot, name, { build: false });
   const module2 = goModulePath(workspaceRoot);
   if (module2) {
     logger.step(`Import it as ${module2}/libs/${name}`);
@@ -406,7 +521,7 @@ function addGoInternalLib(workspaceRoot, name) {
 }
 
 // src/commands/add/node.ts
-var import_node_path4 = require("path");
+var import_node_path5 = require("path");
 function ensurePlugin(workspaceRoot, packageName) {
   if (hasPlugin(workspaceRoot, packageName)) {
     return;
@@ -423,7 +538,7 @@ function runNodeApp(workspaceRoot, name, stack, framework) {
       `apps/${name}`,
       "--bundler=esbuild",
       `--unitTestRunner=${stack.testRunner}`,
-      "--linter=eslint",
+      "--linter=none",
       "--e2eTestRunner=none",
       `--framework=${framework}`,
       "--no-interactive"
@@ -437,7 +552,6 @@ function nodeAppPackageTarget(name) {
   return {
     executor: "nx:run-commands",
     dependsOn: ["build"],
-    // eslint-disable-next-line unicorn/no-incorrect-template-string-interpolation -- {workspaceRoot} is an Nx output token
     outputs: [`{workspaceRoot}/${zip}`],
     options: { command }
   };
@@ -445,9 +559,11 @@ function nodeAppPackageTarget(name) {
 function addNodeApp(workspaceRoot, name, stack, framework = "none") {
   runNodeApp(workspaceRoot, name, stack, framework);
   ensureAdmZip(workspaceRoot);
-  addNxTargets((0, import_node_path4.join)(workspaceRoot, "apps", name, "package.json"), {
+  addNxTargets((0, import_node_path5.join)(workspaceRoot, "apps", name, "package.json"), {
     package: nodeAppPackageTarget(name)
   });
+  removeGeneratedEslintConfig(workspaceRoot, `apps/${name}`);
+  registerProjectCommands(workspaceRoot, name, { build: true, start: `nx run ${name}:serve` });
 }
 function ensureAzureFunctionsPackage(workspaceRoot) {
   if (hasPlugin(workspaceRoot, "@azure/functions")) {
@@ -470,10 +586,11 @@ var NODE_FUNCTION_APP_HOST_JSON = `{
   }
 }
 `;
-var NODE_FUNCTION_APP_HELLO = `import { app, HttpRequest, HttpResponseInit } from '@azure/functions'
+var NODE_FUNCTION_APP_HELLO = `import { app } from '@azure/functions'
+import type { HttpRequest, HttpResponseInit } from '@azure/functions'
 import { buildGreeting } from './greeting'
 
-async function hello (request: HttpRequest): Promise<HttpResponseInit> {
+async function hello(request: HttpRequest): Promise<HttpResponseInit> {
   const name = request.query.get('name') ?? 'world'
   return { body: buildGreeting(name) }
 }
@@ -498,17 +615,17 @@ describe('buildGreeting', () => {
 })
 `;
 function repairNodeFunctionAppManifest(nodeFunctionAppRoot, workspaceRoot) {
-  const manifestPath = (0, import_node_path4.join)(nodeFunctionAppRoot, "package.json");
+  const manifestPath = (0, import_node_path5.join)(nodeFunctionAppRoot, "package.json");
   const manifest = readJson(manifestPath);
   const azureFunctionsVersion = readJson(
-    (0, import_node_path4.join)(workspaceRoot, "node_modules/@azure/functions/package.json")
+    (0, import_node_path5.join)(workspaceRoot, "node_modules/@azure/functions/package.json")
   ).version;
   const dependencies = manifest.dependencies ?? {};
   writeFileEnsured(
     manifestPath,
     toJson({
       ...manifest,
-      main: "main.js",
+      main: "dist/main.js",
       dependencies: { ...dependencies, "@azure/functions": `^${azureFunctionsVersion}` }
     })
   );
@@ -516,90 +633,49 @@ function repairNodeFunctionAppManifest(nodeFunctionAppRoot, workspaceRoot) {
 function nodeFunctionAppPackageTarget(name) {
   const zip = `dist/drop/node-function-app-${name}.zip`;
   const root = `apps/${name}`;
-  const command = `node -e "const fs=require('node:fs');fs.mkdirSync('dist/drop',{recursive:true});const A=require('adm-zip');const z=new A();z.addLocalFolder('${root}/dist');z.addLocalFile('${root}/host.json');z.addLocalFile('${root}/package.json');z.writeZip('${zip}')"`;
+  const command = `node -e "const fs=require('node:fs');fs.mkdirSync('dist/drop',{recursive:true});const A=require('adm-zip');const z=new A();z.addLocalFolder('${root}/dist','dist');z.addLocalFile('${root}/host.json');z.addLocalFile('${root}/package.json');z.writeZip('${zip}')"`;
   return {
     executor: "nx:run-commands",
     dependsOn: ["build"],
-    // eslint-disable-next-line unicorn/no-incorrect-template-string-interpolation -- {workspaceRoot} is an Nx output token
     outputs: [`{workspaceRoot}/${zip}`],
     options: { command }
   };
 }
+function nodeFunctionAppStartTarget(name) {
+  return {
+    executor: "nx:run-commands",
+    dependsOn: ["build"],
+    continuous: true,
+    options: { command: "func start", cwd: `apps/${name}` }
+  };
+}
 function addNodeFunctionApp(workspaceRoot, name, stack) {
   runNodeApp(workspaceRoot, name, stack, "none");
   ensureAzureFunctionsPackage(workspaceRoot);
-  const nodeFunctionAppRoot = (0, import_node_path4.join)(workspaceRoot, "apps", name);
-  writeFileEnsured((0, import_node_path4.join)(nodeFunctionAppRoot, "src/main.ts"), NODE_FUNCTION_APP_MAIN);
-  writeFileEnsured((0, import_node_path4.join)(nodeFunctionAppRoot, "src/functions/hello.ts"), NODE_FUNCTION_APP_HELLO);
+  const nodeFunctionAppRoot = (0, import_node_path5.join)(workspaceRoot, "apps", name);
+  writeFileEnsured((0, import_node_path5.join)(nodeFunctionAppRoot, "src/main.ts"), NODE_FUNCTION_APP_MAIN);
+  writeFileEnsured((0, import_node_path5.join)(nodeFunctionAppRoot, "src/functions/hello.ts"), NODE_FUNCTION_APP_HELLO);
   writeFileEnsured(
-    (0, import_node_path4.join)(nodeFunctionAppRoot, "src/functions/greeting.ts"),
+    (0, import_node_path5.join)(nodeFunctionAppRoot, "src/functions/greeting.ts"),
     NODE_FUNCTION_APP_GREETING
   );
   writeFileEnsured(
-    (0, import_node_path4.join)(nodeFunctionAppRoot, "src/functions/greeting.spec.ts"),
+    (0, import_node_path5.join)(nodeFunctionAppRoot, "src/functions/greeting.spec.ts"),
     NODE_FUNCTION_APP_GREETING_SPEC
   );
-  writeFileEnsured((0, import_node_path4.join)(nodeFunctionAppRoot, "host.json"), NODE_FUNCTION_APP_HOST_JSON);
+  writeFileEnsured((0, import_node_path5.join)(nodeFunctionAppRoot, "host.json"), NODE_FUNCTION_APP_HOST_JSON);
   repairNodeFunctionAppManifest(nodeFunctionAppRoot, workspaceRoot);
   ensureAdmZip(workspaceRoot);
-  addNxTargets((0, import_node_path4.join)(nodeFunctionAppRoot, "package.json"), {
-    package: nodeFunctionAppPackageTarget(name)
+  addNxTargets((0, import_node_path5.join)(nodeFunctionAppRoot, "package.json"), {
+    package: nodeFunctionAppPackageTarget(name),
+    start: nodeFunctionAppStartTarget(name)
   });
+  removeGeneratedEslintConfig(workspaceRoot, `apps/${name}`);
+  registerProjectCommands(workspaceRoot, name, { build: true, start: `nx run ${name}:start` });
 }
 
 // src/commands/add/npmLib.ts
-var import_node_path5 = require("path");
-var NPM_LIB_ESLINT_CONFIG = `import { globSync, readFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import baseConfig from '../../eslint.config.mjs';
-
-// Private workspace libs are compiled INTO this package's rollup bundle and
-// never declared in the manifest (a consumer could not install them), so the
-// dependency check must ignore them. Computed at lint time: adding a new
-// internal lib never requires touching this file.
-const workspaceRoot = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
-const privateWorkspacePackages = globSync(['libs/*/package.json', 'packages/*/package.json'], { cwd: workspaceRoot })
-  .map((manifestPath) => JSON.parse(readFileSync(join(workspaceRoot, manifestPath), 'utf8')))
-  .filter((manifest) => manifest.private === true)
-  .map((manifest) => manifest.name);
-
-export default [
-  ...baseConfig,
-  {
-    files: ['**/*.json'],
-    rules: {
-      '@nx/dependency-checks': [
-        'error',
-        {
-          ignoredDependencies: privateWorkspacePackages,
-          ignoredFiles: [
-            '{projectRoot}/eslint.config.{js,cjs,mjs,ts,cts,mts}',
-            '{projectRoot}/rollup.config.{js,ts,mjs,mts,cjs,cts}',
-            // Same reasoning as the two config files above, extended to the test
-            // toolchain: rollup bundles from the entry point only, so neither the
-            // Vitest config nor the spec files reach the published package \u2014 their
-            // imports must not drive the published manifest.
-            //
-            // Without this, a vitest-stack workspace fails \`npm run lint\` on a
-            // freshly generated npm-lib: Nx's own spec imports \`vitest\`, and
-            // @nx/dependency-checks then demands it be declared as a runtime
-            // dependency of a package that never uses it at runtime.
-            '{projectRoot}/vitest.config.{js,ts,mjs,mts,cjs,cts}',
-            '{projectRoot}/**/*.spec.{js,ts,jsx,tsx}',
-          ],
-        },
-      ],
-    },
-    languageOptions: {
-      parser: await import('jsonc-eslint-parser'),
-    },
-  },
-  {
-    ignores: ['**/out-tsc'],
-  },
-];
-`;
+var import_node_path6 = require("path");
 async function addNpmLib(workspaceRoot, name, options, kindProvided, stack) {
   const scope = options.scope ?? (kindProvided ? defaultScope(workspaceRoot) : await promptText("npm scope for the published package", defaultScope(workspaceRoot)));
   runNx(
@@ -611,16 +687,14 @@ async function addNpmLib(workspaceRoot, name, options, kindProvided, stack) {
       `--importPath=${scope}/${name}`,
       "--bundler=rollup",
       `--unitTestRunner=${stack.testRunner}`,
-      "--linter=eslint",
+      "--linter=none",
       "--no-interactive"
     ],
     workspaceRoot
   );
-  markPublic((0, import_node_path5.join)(workspaceRoot, "packages", name, "package.json"));
-  writeFileEnsured(
-    (0, import_node_path5.join)(workspaceRoot, "packages", name, "eslint.config.mjs"),
-    NPM_LIB_ESLINT_CONFIG
-  );
+  markPublic((0, import_node_path6.join)(workspaceRoot, "packages", name, "package.json"));
+  removeGeneratedEslintConfig(workspaceRoot, `packages/${name}`);
+  registerProjectCommands(workspaceRoot, name, { build: true });
 }
 function markPublic(manifestPath) {
   const manifest = readJson(manifestPath);
@@ -628,8 +702,8 @@ function markPublic(manifestPath) {
 }
 
 // src/commands/add/python.ts
-var import_node_fs3 = require("fs");
-var import_node_path6 = require("path");
+var import_node_fs4 = require("fs");
+var import_node_path7 = require("path");
 function ensurePython(workspaceRoot) {
   const hasPython = runShell("python3", ["--version"], workspaceRoot) === 0 || runShell("python", ["--version"], workspaceRoot) === 0;
   if (!hasPython) {
@@ -658,7 +732,7 @@ pytest
 pip-audit
 `;
 function ensureRequirementsDev(workspaceRoot) {
-  const requirementsDevPath = (0, import_node_path6.join)(workspaceRoot, "requirements-dev.txt");
+  const requirementsDevPath = (0, import_node_path7.join)(workspaceRoot, "requirements-dev.txt");
   if (!fileExists(requirementsDevPath)) {
     writeFileEnsured(requirementsDevPath, PYTHON_REQUIREMENTS_DEV);
   }
@@ -666,18 +740,40 @@ function ensureRequirementsDev(workspaceRoot) {
 function pythonModuleDirectory(name) {
   return name.replaceAll("-", "_");
 }
-function addProjectJsonTargets2(projectJsonPath, newTargets) {
+function addProjectJsonTargets3(projectJsonPath, newTargets) {
   const project = readJson(projectJsonPath);
   const targets = project.targets ?? {};
   writeFileEnsured(projectJsonPath, toJson({ ...project, targets: { ...targets, ...newTargets } }));
 }
+function pythonAppMain(name) {
+  return `def main() -> None:
+    print('${name} is running')
+
+
+if __name__ == '__main__':
+    main()
+`;
+}
+function pythonAppStartTarget(name) {
+  return {
+    executor: "nx:run-commands",
+    continuous: true,
+    options: { command: "python3 main.py", cwd: `apps/${name}` }
+  };
+}
+function pythonFunctionAppStartTarget(name) {
+  return {
+    executor: "nx:run-commands",
+    continuous: true,
+    options: { command: "func start", cwd: `apps/${name}` }
+  };
+}
 function pythonAppPackageTarget(name) {
   const zip = `dist/drop/python-app-${name}.zip`;
   const command = `node -e "const fs=require('node:fs');fs.mkdirSync('dist/drop',{recursive:true});const A=require('adm-zip');const z=new A();z.addLocalFolder('apps/${name}/dist');z.writeZip('${zip}')"`;
   return {
     executor: "nx:run-commands",
     dependsOn: ["build"],
-    // eslint-disable-next-line unicorn/no-incorrect-template-string-interpolation -- {workspaceRoot} is an Nx output token
     outputs: [`{workspaceRoot}/${zip}`],
     options: { command }
   };
@@ -688,7 +784,6 @@ function pythonFunctionAppPackageTarget(name, moduleDirectory) {
   const command = `node -e "const fs=require('node:fs');fs.mkdirSync('dist/drop',{recursive:true});const A=require('adm-zip');const z=new A();z.addLocalFile('${root}/function_app.py');z.addLocalFile('${root}/host.json');z.addLocalFile('${root}/requirements.txt');z.addLocalFolder('${root}/${moduleDirectory}','${moduleDirectory}');z.writeZip('${zip}')"`;
   return {
     executor: "nx:run-commands",
-    // eslint-disable-next-line unicorn/no-incorrect-template-string-interpolation -- {workspaceRoot} is an Nx output token
     outputs: [`{workspaceRoot}/${zip}`],
     options: { command }
   };
@@ -702,9 +797,12 @@ function addPythonApp(workspaceRoot, name) {
     ["g", "@mnci/nx-python-pip:application", name, `--directory=apps/${name}`, "--no-interactive"],
     workspaceRoot
   );
-  addProjectJsonTargets2((0, import_node_path6.join)(workspaceRoot, "apps", name, "project.json"), {
-    package: pythonAppPackageTarget(name)
+  writeFileEnsured((0, import_node_path7.join)(workspaceRoot, "apps", name, "main.py"), pythonAppMain(name));
+  addProjectJsonTargets3((0, import_node_path7.join)(workspaceRoot, "apps", name, "project.json"), {
+    package: pythonAppPackageTarget(name),
+    start: pythonAppStartTarget(name)
   });
+  registerProjectCommands(workspaceRoot, name, { build: true, start: `nx run ${name}:start` });
 }
 function addPythonFunctionApp(workspaceRoot, name) {
   ensurePython(workspaceRoot);
@@ -722,9 +820,11 @@ function addPythonFunctionApp(workspaceRoot, name) {
     workspaceRoot
   );
   const moduleDirectory = pythonModuleDirectory(name);
-  addProjectJsonTargets2((0, import_node_path6.join)(workspaceRoot, "apps", name, "project.json"), {
-    package: pythonFunctionAppPackageTarget(name, moduleDirectory)
+  addProjectJsonTargets3((0, import_node_path7.join)(workspaceRoot, "apps", name, "project.json"), {
+    package: pythonFunctionAppPackageTarget(name, moduleDirectory),
+    start: pythonFunctionAppStartTarget(name)
   });
+  registerProjectCommands(workspaceRoot, name, { build: false, start: `nx run ${name}:start` });
 }
 function addPythonLib(workspaceRoot, name) {
   ensurePython(workspaceRoot);
@@ -740,6 +840,7 @@ function addPythonLib(workspaceRoot, name) {
     ],
     workspaceRoot
   );
+  registerProjectCommands(workspaceRoot, name, { build: true });
 }
 function addPythonInternalLib(workspaceRoot, name) {
   ensurePython(workspaceRoot);
@@ -755,11 +856,12 @@ function addPythonInternalLib(workspaceRoot, name) {
     ],
     workspaceRoot
   );
+  registerProjectCommands(workspaceRoot, name, { build: false });
 }
 var PYTHON_PROJECT_DIRS = ["apps", "python-packages", "libs"];
 function findPythonProjectDirectory(workspaceRoot, name) {
   return PYTHON_PROJECT_DIRS.find(
-    (directory) => fileExists((0, import_node_path6.join)(workspaceRoot, directory, name, "pyproject.toml"))
+    (directory) => fileExists((0, import_node_path7.join)(workspaceRoot, directory, name, "pyproject.toml"))
   );
 }
 function parseVendorEntries(pyprojectToml) {
@@ -798,7 +900,7 @@ async function addPythonVendor(workspaceRoot, consumer, options, kindProvided) {
       `No Python project named '${consumer}' with a pyproject.toml found (checked apps/, python-packages/, libs/). A Python function app has no pyproject.toml \u2014 there is nothing to vendor into.`
     );
   }
-  if (!fileExists((0, import_node_path6.join)(workspaceRoot, "libs", lib, "pyproject.toml"))) {
+  if (!fileExists((0, import_node_path7.join)(workspaceRoot, "libs", lib, "pyproject.toml"))) {
     throw new Error(
       `No internal Python library named '${lib}' found at libs/${lib}/pyproject.toml. Only an internal library (added via 'mnci add python-internal-lib') can be vendored.`
     );
@@ -806,8 +908,8 @@ async function addPythonVendor(workspaceRoot, consumer, options, kindProvided) {
   if (consumerDirectory === "libs" && consumer === lib) {
     throw new Error(`'${consumer}' cannot vendor itself.`);
   }
-  const pyprojectPath = (0, import_node_path6.join)(workspaceRoot, consumerDirectory, consumer, "pyproject.toml");
-  const pyprojectToml = (0, import_node_fs3.readFileSync)(pyprojectPath, "utf8");
+  const pyprojectPath = (0, import_node_path7.join)(workspaceRoot, consumerDirectory, consumer, "pyproject.toml");
+  const pyprojectToml = (0, import_node_fs4.readFileSync)(pyprojectPath, "utf8");
   if (parseVendorEntries(pyprojectToml).includes(lib)) {
     logger.info(`'${consumer}' already vendors '${lib}' \u2014 nothing to do.`);
     return;
@@ -819,8 +921,8 @@ async function addPythonVendor(workspaceRoot, consumer, options, kindProvided) {
 }
 
 // src/commands/add/reactApp.ts
-var import_node_fs4 = require("fs");
-var import_node_path7 = require("path");
+var import_node_fs5 = require("fs");
+var import_node_path8 = require("path");
 function ensurePlugin2(workspaceRoot, packageName) {
   if (hasPlugin(workspaceRoot, packageName)) {
     return;
@@ -841,7 +943,6 @@ function reactAppTargets(name) {
   for (const environment of REACT_ENVIRONMENTS) {
     targets[`build-${environment}`] = {
       executor: "nx:run-commands",
-      // eslint-disable-next-line unicorn/no-incorrect-template-string-interpolation -- {workspaceRoot} is an Nx output token
       outputs: [`{workspaceRoot}/apps/${name}/dist-${environment}`],
       options: {
         command: `vite build --mode ${environment} --outDir dist-${environment}`,
@@ -856,7 +957,6 @@ function reactAppTargets(name) {
     executor: "nx:run-commands",
     dependsOn: REACT_ENVIRONMENTS.map((environment) => `build-${environment}`),
     outputs: REACT_ENVIRONMENTS.map(
-      // eslint-disable-next-line unicorn/no-incorrect-template-string-interpolation
       (environment) => `{workspaceRoot}/dist/drop/react-app-${name}-${environment}.zip`
     ),
     options: {
@@ -866,12 +966,12 @@ function reactAppTargets(name) {
   return targets;
 }
 function allowEnvFiles(workspaceRoot) {
-  const gitignorePath = (0, import_node_path7.join)(workspaceRoot, ".gitignore");
+  const gitignorePath = (0, import_node_path8.join)(workspaceRoot, ".gitignore");
   if (!fileExists(gitignorePath)) {
     return;
   }
   const marker = "# MoNecromanCI: keep the committed per-environment Vite config (public VITE_ values)";
-  const current = (0, import_node_fs4.readFileSync)(gitignorePath, "utf8");
+  const current = (0, import_node_fs5.readFileSync)(gitignorePath, "utf8");
   if (current.includes(marker)) {
     return;
   }
@@ -890,7 +990,7 @@ function addReactApp(workspaceRoot, name, stack) {
       `apps/${name}`,
       "--bundler=vite",
       `--unitTestRunner=${stack.testRunner}`,
-      "--linter=eslint",
+      "--linter=none",
       "--style=css",
       "--e2eTestRunner=none",
       "--no-interactive"
@@ -898,12 +998,14 @@ function addReactApp(workspaceRoot, name, stack) {
     workspaceRoot
   );
   ensureAdmZip(workspaceRoot);
-  const reactAppRoot = (0, import_node_path7.join)(workspaceRoot, "apps", name);
+  const reactAppRoot = (0, import_node_path8.join)(workspaceRoot, "apps", name);
   for (const environment of REACT_ENVIRONMENTS) {
-    writeFileEnsured((0, import_node_path7.join)(reactAppRoot, `.env.${environment}`), reactEnvironmentFile(environment));
+    writeFileEnsured((0, import_node_path8.join)(reactAppRoot, `.env.${environment}`), reactEnvironmentFile(environment));
   }
   allowEnvFiles(workspaceRoot);
-  addNxTargets((0, import_node_path7.join)(reactAppRoot, "package.json"), reactAppTargets(name));
+  addNxTargets((0, import_node_path8.join)(reactAppRoot, "package.json"), reactAppTargets(name));
+  removeGeneratedEslintConfig(workspaceRoot, `apps/${name}`);
+  registerProjectCommands(workspaceRoot, name, { build: true, start: `nx run ${name}:serve` });
 }
 
 // src/commands/add.ts
@@ -928,7 +1030,7 @@ var PROJECT_KINDS = [
 ];
 async function runAdd(kind, name, options) {
   const workspaceRoot = process.cwd();
-  if (!fileExists((0, import_node_path8.join)(workspaceRoot, "nx.json"))) {
+  if (!fileExists((0, import_node_path9.join)(workspaceRoot, "nx.json"))) {
     throw new Error("No nx.json found here. Run `add` from the workspace root.");
   }
   const stack = readWorkspaceStack(workspaceRoot);
@@ -964,12 +1066,14 @@ async function runAdd(kind, name, options) {
           `libs/${resolvedName}`,
           "--bundler=tsc",
           `--unitTestRunner=${stack.testRunner}`,
-          "--linter=eslint",
+          "--linter=none",
           "--no-interactive"
         ],
         workspaceRoot
       );
-      markPrivate((0, import_node_path8.join)(workspaceRoot, "libs", resolvedName, "package.json"));
+      markPrivate((0, import_node_path9.join)(workspaceRoot, "libs", resolvedName, "package.json"));
+      removeGeneratedEslintConfig(workspaceRoot, `libs/${resolvedName}`);
+      registerProjectCommands(workspaceRoot, resolvedName, { build: true });
       break;
     }
     case "python-app": {
@@ -1019,6 +1123,7 @@ async function runAdd(kind, name, options) {
     case "python-vendor": {
       await addPythonVendor(workspaceRoot, resolvedName, options, kindProvided);
       syncProjectReferences(workspaceRoot);
+      runPrettier(workspaceRoot);
       return;
     }
     default: {
@@ -1029,6 +1134,7 @@ async function runAdd(kind, name, options) {
     }
   }
   syncProjectReferences(workspaceRoot);
+  runPrettier(workspaceRoot);
   logger.success(`Added ${resolvedKind} '${resolvedName}'.`);
 }
 function syncProjectReferences(workspaceRoot) {
@@ -1041,7 +1147,7 @@ function syncProjectReferences(workspaceRoot) {
 }
 function readWorkspaceStack(workspaceRoot) {
   const nxJson = readJson(
-    (0, import_node_path8.join)(workspaceRoot, "nx.json")
+    (0, import_node_path9.join)(workspaceRoot, "nx.json")
   );
   const stack = nxJson.mnci?.stack;
   return {
@@ -1054,48 +1160,31 @@ function markPrivate(manifestPath) {
 }
 
 // src/commands/interactive.ts
-var import_node_path12 = require("path");
+var import_node_path13 = require("path");
 var import_prompts7 = require("@inquirer/prompts");
 
 // src/commands/new.ts
-var import_node_path10 = require("path");
+var import_node_path11 = require("path");
 
 // src/overlay.ts
-var import_node_path9 = require("path");
+var import_node_fs6 = require("fs");
+var import_node_path10 = require("path");
 var DEFAULT_STACK = { testRunner: "jest" };
 var PRETTIER_VERSION = "^3.8.1";
 var TS_COMPILER_DEPENDENCIES = {
   "@typescript/native": "npm:typescript@^7.0.2",
   typescript: "npm:@typescript/typescript6@^6.0.2"
 };
-function npmrcContent(registry, scope) {
-  const scopeName = scope.replace(/^@/, "");
-  const lines = [
-    "registry=https://registry.npmjs.org/",
-    "; Community Nx plugins (e.g. the Azure Functions one) peer on the previous",
-    "; Nx major for a while after each release; accept the resolved tree.",
-    "legacy-peer-deps=true"
-  ];
-  if (registry.kind === "azure-artifacts") {
-    const base = `https://pkgs.dev.azure.com/${registry.organization}/${registry.project}/_packaging/${registry.artifactsFeed}`;
-    const registryHost = `${base}/npm/registry/`.replace(/^https:\/\//, "");
-    const feedHost = `${base}/`.replace(/^https:\/\//, "");
-    lines.push(
-      `@${scopeName}:registry=${base}/npm/registry/`,
-      "; Azure Artifacts auth \u2014 the base64 PAT is expanded at runtime from the",
-      "; PAT env var (CI: your PAT variable group; locally: export PAT=<base64 token>).",
-      `//${registryHost}:username=${registry.organization}`,
-      `//${registryHost}:_password=\${PAT}`,
-      `//${registryHost}:email=npm@example.com`,
-      `//${feedHost}:username=${registry.organization}`,
-      `//${feedHost}:_password=\${PAT}`,
-      `//${feedHost}:email=npm@example.com`
-    );
-  } else {
-    lines.push(`//registry.npmjs.org/:_authToken=\${NODE_AUTH_TOKEN}`);
-  }
-  lines.push("");
-  return lines.join("\n");
+function npmrcContent(_registry, _scope) {
+  return `; Intentionally empty.
+;
+; Publish authentication is not configured yet. The generated CI exports a
+; token for the release step (NODE_AUTH_TOKEN for public npm, PAT for Azure
+; Artifacts), but nothing here consumes it, so 'npm publish' will not
+; authenticate until this is wired up.
+;
+; See "Known gaps" in the @mnci/cli README.
+`;
 }
 function releaseConfig(ci) {
   const githubReleases = ci === "github";
@@ -1122,6 +1211,18 @@ function releaseConfig(ci) {
   };
 }
 var SYNC_CONFIG = { applyChanges: true };
+var ESLINT_PLUGIN_CONFIG = {
+  plugin: "@nx/eslint/plugin",
+  options: { targetName: "lint" }
+};
+function pluginName(entry) {
+  return typeof entry === "string" ? entry : entry.plugin;
+}
+function withEslintPlugin(nxJson) {
+  const plugins = nxJson.plugins ?? [];
+  const registered = plugins.some((entry) => pluginName(entry) === ESLINT_PLUGIN_CONFIG.plugin);
+  return registered ? { ...nxJson, plugins } : { ...nxJson, plugins: [...plugins, ESLINT_PLUGIN_CONFIG] };
+}
 function withReleaseConfig(nxJson, ci) {
   return { ...nxJson, defaultBase: "main", release: releaseConfig(ci) };
 }
@@ -1132,13 +1233,30 @@ var COMMIT_MSG_HOOK = `npx --no -- commitlint --edit "$1"
 var PRETTIER_CONFIG = `{
   "semi": false,
   "singleQuote": true,
-  "trailingComma": "es5",
+  "trailingComma": "none",
   "arrowParens": "avoid",
   "printWidth": 100,
   "tabWidth": 2,
   "useTabs": false
 }
 `;
+var ESLINT_CONFIG_VERSION = "^0.1.0";
+function eslintConfigSpec() {
+  return process.env.MNCI_ESLINT_CONFIG_SPEC ?? ESLINT_CONFIG_VERSION;
+}
+var ESLINT_VERSION = "^9.39.0";
+function eslintToolchainDependencies(nxVersion) {
+  return {
+    eslint: ESLINT_VERSION,
+    "@nx/eslint": nxVersion,
+    "@nx/eslint-plugin": nxVersion,
+    "@mnci/eslint-config": eslintConfigSpec()
+  };
+}
+var ESLINT_CONFIG = `import mnci from '@mnci/eslint-config'
+
+export default mnci({ workspaceRoot: import.meta.dirname })
+`;
 var PRETTIER_IGNORE = `node_modules
 dist
 dist-dev
@@ -1155,12 +1273,7 @@ package-lock.json
 function vscodeWorkspace(workspaceName) {
   return JSON.stringify(
     {
-      folders: [
-        { path: ".", name: workspaceName },
-        { path: "packages/cli", name: "@mnci/cli" },
-        { path: "packages/nx-python-pip", name: "@mnci/nx-python-pip" },
-        { path: "libs/monecromanci-v2", name: "@mnci/monecromanci" }
-      ],
+      folders: [{ path: ".", name: workspaceName }],
       settings: {
         "eslint.validate": [
           "javascript",
@@ -1194,7 +1307,8 @@ function vscodeWorkspace(workspaceName) {
           "nrwl.angular-console",
           "firsttris.vscode-jest-runner"
         ]
-      }
+      },
+      tasks: { version: "2.0.0", tasks: [] }
     },
     null,
     2
@@ -1219,7 +1333,13 @@ function rootScripts() {
 }
 function generatorDefaults(stack) {
   const shared = {
-    linter: "eslint",
+    // `none`, not `eslint`, and the workspace is still fully linted. The root
+    // config plus `@nx/eslint/plugin` ({@link ESLINT_PLUGIN_CONFIG}) give every
+    // project its `lint` target; `eslint` here would only make the generator
+    // scaffold a per-project config mnci deletes anyway — and drag in
+    // `eslint-plugin-import@2.31.0`, which peer-caps at ESLint 9 and breaks the
+    // install outright on this workspace's ESLint 10.
+    linter: "none",
     unitTestRunner: stack.testRunner
   };
   return {
@@ -1239,7 +1359,7 @@ function mnciConfig(options) {
   };
 }
 function readMnciConfig(workspaceRoot) {
-  const nxJson = readJson((0, import_node_path9.join)(workspaceRoot, "nx.json"));
+  const nxJson = readJson((0, import_node_path10.join)(workspaceRoot, "nx.json"));
   return nxJson.mnci ?? {};
 }
 function pythonPublishUrl(registry) {
@@ -1664,8 +1784,23 @@ updates:
     schedule:
       interval: weekly
 `;
+var NX_SCAFFOLDING_TO_REMOVE = [".prettierrc", ".vscode"];
+function removeNxScaffolding(workspaceRoot) {
+  for (const entry of NX_SCAFFOLDING_TO_REMOVE) {
+    (0, import_node_fs6.rmSync)((0, import_node_path10.join)(workspaceRoot, entry), { recursive: true, force: true });
+  }
+  removeProjectEslintConfigs(workspaceRoot);
+}
+function removeProjectEslintConfigs(workspaceRoot) {
+  const matches = (0, import_node_fs6.globSync)("{apps,libs,packages}/*/eslint.config.{js,mjs,cjs,ts,mts,cts}", {
+    cwd: workspaceRoot
+  });
+  for (const match of matches) {
+    (0, import_node_fs6.rmSync)((0, import_node_path10.join)(workspaceRoot, match), { force: true });
+  }
+}
 function applyOverlay(workspaceRoot, options) {
-  const nxJsonPath = (0, import_node_path9.join)(workspaceRoot, "nx.json");
+  const nxJsonPath = (0, import_node_path10.join)(workspaceRoot, "nx.json");
   const nxJson = readJson(nxJsonPath);
   const generators = {
     ...nxJson.generators,
@@ -1673,49 +1808,52 @@ function applyOverlay(workspaceRoot, options) {
   };
   const sync = { ...nxJson.sync, ...SYNC_CONFIG };
   const mnci = { ...nxJson.mnci, ...mnciConfig(options) };
-  writeFileEnsured(
-    nxJsonPath,
-    toJson({ ...withReleaseConfig(nxJson, options.ci), generators, sync, mnci })
-  );
-  const manifestPath = (0, import_node_path9.join)(workspaceRoot, "package.json");
+  const patched = withEslintPlugin(withReleaseConfig(nxJson, options.ci));
+  writeFileEnsured(nxJsonPath, toJson({ ...patched, generators, sync, mnci }));
+  const manifestPath = (0, import_node_path10.join)(workspaceRoot, "package.json");
   const manifest = readJson(manifestPath);
   const scripts = {
     ...manifest.scripts,
     ...rootScripts()
   };
+  const existingDevDeps = manifest.devDependencies;
   const devDeps = {
-    ...manifest.devDependencies,
+    ...existingDevDeps,
     ...TS_COMPILER_DEPENDENCIES,
+    // The preset pins `nx` itself; the ESLint plugins must match it exactly.
+    ...eslintToolchainDependencies(existingDevDeps?.nx ?? "latest"),
     prettier: PRETTIER_VERSION
   };
   writeFileEnsured(
     manifestPath,
     toJson({ ...manifest, name: `${options.scope}/source`, scripts, devDependencies: devDeps })
   );
-  writeFileEnsured((0, import_node_path9.join)(workspaceRoot, ".npmrc"), npmrcContent(options.registry, options.scope));
-  writeFileEnsured((0, import_node_path9.join)(workspaceRoot, "commitlint.config.mjs"), COMMITLINT_CONFIG);
-  const hookPath = (0, import_node_path9.join)(workspaceRoot, ".husky/commit-msg");
+  writeFileEnsured((0, import_node_path10.join)(workspaceRoot, ".npmrc"), npmrcContent(options.registry, options.scope));
+  writeFileEnsured((0, import_node_path10.join)(workspaceRoot, "commitlint.config.mjs"), COMMITLINT_CONFIG);
+  const hookPath = (0, import_node_path10.join)(workspaceRoot, ".husky/commit-msg");
   writeFileEnsured(hookPath, COMMIT_MSG_HOOK);
   markExecutable(hookPath);
-  writeFileEnsured((0, import_node_path9.join)(workspaceRoot, ".prettierrc.json"), PRETTIER_CONFIG);
-  writeFileEnsured((0, import_node_path9.join)(workspaceRoot, ".prettierignore"), PRETTIER_IGNORE);
+  writeFileEnsured((0, import_node_path10.join)(workspaceRoot, "eslint.config.mjs"), ESLINT_CONFIG);
+  writeFileEnsured((0, import_node_path10.join)(workspaceRoot, ".prettierrc.json"), PRETTIER_CONFIG);
+  writeFileEnsured((0, import_node_path10.join)(workspaceRoot, ".prettierignore"), PRETTIER_IGNORE);
+  removeNxScaffolding(workspaceRoot);
   writeFileEnsured(
-    (0, import_node_path9.join)(workspaceRoot, `${options.workspaceName}.code-workspace`),
+    (0, import_node_path10.join)(workspaceRoot, `${options.workspaceName}.code-workspace`),
     vscodeWorkspace(options.workspaceName)
   );
   const publishUrl = pythonPublishUrl(options.registry);
   if (options.ci === "azure" || options.ci === "both") {
     writeFileEnsured(
-      (0, import_node_path9.join)(workspaceRoot, "azure-pipelines.yml"),
+      (0, import_node_path10.join)(workspaceRoot, "azure-pipelines.yml"),
       azurePipelinesYaml(options.agent, options.variableGroup, publishUrl, options.registry.kind)
     );
   }
   if (options.ci === "github" || options.ci === "both") {
     writeFileEnsured(
-      (0, import_node_path9.join)(workspaceRoot, ".github/workflows/ci.yml"),
+      (0, import_node_path10.join)(workspaceRoot, ".github/workflows/ci.yml"),
       githubActionsYaml(options.agent, publishUrl, options.registry.kind, options.ci)
     );
-    writeFileEnsured((0, import_node_path9.join)(workspaceRoot, ".github/dependabot.yml"), DEPENDABOT_CONFIG);
+    writeFileEnsured((0, import_node_path10.join)(workspaceRoot, ".github/dependabot.yml"), DEPENDABOT_CONFIG);
   }
 }
 
@@ -1784,12 +1922,12 @@ async function runNew(name, options) {
     ],
     process.cwd()
   );
-  const workspaceRoot = (0, import_node_path10.join)(process.cwd(), workspaceName);
+  const workspaceRoot = (0, import_node_path11.join)(process.cwd(), workspaceName);
   logger.step(
     "Applying MoNecromanCI overlay (VS Code workspace, release config, .npmrc, commitlint, pipeline, stack)"
   );
   applyOverlay(workspaceRoot, { workspaceName, scope, registry, agent, variableGroup, ci, stack });
-  logger.step("Installing the toolchain (commitlint + husky)");
+  logger.step("Installing the toolchain (commitlint + husky + linting/formatting)");
   const installStatus = runShell(
     "npm",
     ["install", "--save-dev", "husky", "@commitlint/cli", "@commitlint/config-conventional"],
@@ -1799,6 +1937,8 @@ 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.success("Done. Next steps:");
   logger.info(`  cd ${workspaceName}`);
   logger.info(
@@ -1817,7 +1957,7 @@ async function runNew(name, options) {
 }
 
 // src/commands/upgrade.ts
-var import_node_path11 = require("path");
+var import_node_path12 = require("path");
 function resolveRegistry2(options, persisted) {
   if (options.registry === "azure-artifacts" || options.organization && options.artifactsFeed) {
     const persistedAzure = persisted?.kind === "azure-artifacts" ? persisted : void 0;
@@ -1869,7 +2009,7 @@ function resolveOverlayOptions(options, persisted) {
   return { scope, registry, agent, variableGroup, ci, stack: { testRunner } };
 }
 function runUpgrade(workspaceRoot, options) {
-  if (!fileExists((0, import_node_path11.join)(workspaceRoot, "nx.json"))) {
+  if (!fileExists((0, import_node_path12.join)(workspaceRoot, "nx.json"))) {
     throw new Error(
       `No nx.json found in ${workspaceRoot} \u2014 this does not look like an Nx workspace. Run 'mnci upgrade' from the workspace root.`
     );
@@ -1885,7 +2025,7 @@ function runUpgrade(workspaceRoot, options) {
 
 // src/commands/interactive.ts
 async function runInteractive() {
-  const inWorkspace = fileExists((0, import_node_path12.join)(process.cwd(), "nx.json"));
+  const inWorkspace = fileExists((0, import_node_path13.join)(process.cwd(), "nx.json"));
   const newChoice = { name: "Create a new monorepo", value: "new" };
   const addChoice = { name: "Add a project to this workspace", value: "add" };
   const upgradeChoice = {
@@ -1906,8 +2046,8 @@ async function runInteractive() {
 }
 
 // src/util/versionChecker.ts
-var import_node_fs5 = require("fs");
-var import_node_path13 = require("path");
+var import_node_fs7 = require("fs");
+var import_node_path14 = require("path");
 var import_cross_spawn2 = __toESM(require("cross-spawn"));
 var PACKAGE_NAME = "@mnci/cli";
 var REGISTRY_TIMEOUT_MS = 2e3;
@@ -1963,8 +2103,8 @@ function releaseTriple(version) {
 }
 function readCliVersion(packageDirectory) {
   try {
-    const manifestPath = (0, import_node_path13.join)(packageDirectory, "..", "package.json");
-    const manifest = JSON.parse((0, import_node_fs5.readFileSync)(manifestPath, "utf8"));
+    const manifestPath = (0, import_node_path14.join)(packageDirectory, "..", "package.json");
+    const manifest = JSON.parse((0, import_node_fs7.readFileSync)(manifestPath, "utf8"));
     return manifest.version ?? "0.0.0";
   } catch {
     return "0.0.0";