@mnci/cli 1.1.0

package/dist/cli.js

@@ -0,0 +1,1173 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  buildProgram: () => buildProgram,
+  main: () => main
+});
+module.exports = __toCommonJS(cli_exports);
+var import_node_fs3 = require("fs");
+var import_node_path11 = require("path");
+var import_commander = require("commander");
+
+// src/commands/add.ts
+var import_node_path7 = require("path");
+var import_prompts3 = require("@inquirer/prompts");
+
+// src/nx.ts
+var import_cross_spawn = __toESM(require("cross-spawn"));
+function runShell(command, arguments_, cwd) {
+  const result = import_cross_spawn.default.sync(command, arguments_, { stdio: "inherit", cwd });
+  return result.status ?? 1;
+}
+function runNx(arguments_, cwd) {
+  const status = runShell("npx", ["nx", ...arguments_], cwd);
+  if (status !== 0) {
+    throw new Error(`nx ${arguments_.join(" ")} failed with exit code ${status}`);
+  }
+}
+function runNpx(arguments_, cwd) {
+  const status = runShell("npx", arguments_, cwd);
+  if (status !== 0) {
+    throw new Error(`npx ${arguments_.join(" ")} failed with exit code ${status}`);
+  }
+}
+
+// src/prompts.ts
+var import_prompts = require("@inquirer/prompts");
+async function promptText(message, fallback) {
+  const value = await (0, import_prompts.input)({
+    message,
+    default: fallback,
+    validate: (value2) => value2.trim().length > 0 || "A value is required"
+  });
+  return value.trim();
+}
+async function promptRegistry(fallbackOrganization) {
+  const kind = await (0, import_prompts.select)({
+    message: "Package registry for publishable libraries",
+    choices: [
+      { name: "Azure Artifacts", value: "azure-artifacts" },
+      { name: "Public npm", value: "npm" }
+    ]
+  });
+  if (kind === "npm") {
+    return { kind };
+  }
+  return {
+    kind,
+    organization: await promptText("Azure DevOps organization", fallbackOrganization),
+    project: await promptText("Azure DevOps project"),
+    artifactsFeed: await promptText("Artifacts feed name")
+  };
+}
+async function promptCi() {
+  return await (0, import_prompts.select)({
+    message: "CI provider",
+    choices: [
+      { name: "Azure Pipelines", value: "azure" },
+      { name: "GitHub Actions", value: "github" },
+      { name: "Both", value: "both" }
+    ]
+  });
+}
+async function promptStack() {
+  const linter = await (0, import_prompts.select)({
+    message: "Linter",
+    choices: [
+      { name: "ESLint", value: "eslint" },
+      { name: "Oxlint", value: "oxlint" }
+    ]
+  });
+  const testRunner = await (0, import_prompts.select)({
+    message: "Unit-test runner",
+    choices: [
+      { name: "Jest", value: "jest" },
+      { name: "Vitest", value: "vitest" }
+    ]
+  });
+  return { linter, testRunner };
+}
+
+// src/util/fsx.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+function readJson(path) {
+  return JSON.parse((0, import_node_fs.readFileSync)(path, "utf8"));
+}
+function toJson(value) {
+  return `${JSON.stringify(value, void 0, 2)}
+`;
+}
+function writeFileEnsured(path, content) {
+  (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(path), { recursive: true });
+  (0, import_node_fs.writeFileSync)(path, content);
+}
+function markExecutable(path) {
+  (0, import_node_fs.chmodSync)(path, 493);
+}
+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)) {
+    throw new Error(`${label} '${name}' is invalid \u2014 use lowercase letters, digits and hyphens, starting with a letter (e.g. 'my-project').`);
+  }
+}
+
+// src/commands/add/node.ts
+var import_node_path3 = require("path");
+
+// src/commands/add/shared.ts
+var import_node_path2 = require("path");
+function hasPlugin(workspaceRoot, packageName) {
+  const manifest = readJson((0, import_node_path2.join)(workspaceRoot, "package.json"));
+  const installed = { ...manifest.dependencies, ...manifest.devDependencies };
+  return Object.hasOwn(installed, packageName);
+}
+function ensureAdmZip(workspaceRoot) {
+  if (hasPlugin(workspaceRoot, "adm-zip")) {
+    return;
+  }
+  logger.step("Installing the app packager (adm-zip)");
+  if (runShell("npm", ["install", "--save-dev", "adm-zip", "--no-audit", "--no-fund"], workspaceRoot) !== 0) {
+    throw new Error("npm install of adm-zip failed");
+  }
+}
+function defaultScope(workspaceRoot) {
+  const { name } = readJson((0, import_node_path2.join)(workspaceRoot, "package.json"));
+  const base = (name.startsWith("@") ? name.slice(1) : name).split("/", 1)[0];
+  return `@${base}`;
+}
+function addNxTargets(manifestPath, newTargets) {
+  const manifest = fileExists(manifestPath) ? readJson(manifestPath) : {};
+  const nx = manifest.nx ?? {};
+  const targets = nx.targets ?? {};
+  writeFileEnsured(manifestPath, toJson({ ...manifest, nx: { ...nx, targets: { ...targets, ...newTargets } } }));
+}
+
+// src/commands/add/node.ts
+function ensurePlugin(workspaceRoot, packageName) {
+  if (hasPlugin(workspaceRoot, packageName)) {
+    return;
+  }
+  logger.step(`Installing Nx plugin ${packageName}`);
+  runNx(["add", packageName], workspaceRoot);
+}
+function runNodeApp(workspaceRoot, name, stack) {
+  ensurePlugin(workspaceRoot, "@nx/node");
+  runNx([
+    "g",
+    "@nx/node:application",
+    `apps/${name}`,
+    "--bundler=esbuild",
+    `--unitTestRunner=${stack.testRunner}`,
+    `--linter=${stack.linter}`,
+    "--e2eTestRunner=none",
+    "--framework=none",
+    "--no-interactive"
+  ], workspaceRoot);
+}
+function nodeAppPackageTarget(name) {
+  const zip = `dist/drop/node-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 }
+  };
+}
+function addNodeApp(workspaceRoot, name, stack) {
+  runNodeApp(workspaceRoot, name, stack);
+  ensureAdmZip(workspaceRoot);
+  addNxTargets((0, import_node_path3.join)(workspaceRoot, "apps", name, "package.json"), { package: nodeAppPackageTarget(name) });
+}
+function ensureAzureFunctionsPackage(workspaceRoot) {
+  if (hasPlugin(workspaceRoot, "@azure/functions")) {
+    return;
+  }
+  logger.step("Installing @azure/functions");
+  if (runShell("npm", ["install", "@azure/functions", "--no-audit", "--no-fund"], workspaceRoot) !== 0) {
+    throw new Error("npm install of @azure/functions failed");
+  }
+}
+var NODE_FUNCTION_APP_MAIN = `// esbuild only includes what is reachable from here, so add one import per
+// function file you create under src/functions/.
+import './functions/hello'
+`;
+var NODE_FUNCTION_APP_HOST_JSON = `{
+  "version": "2.0",
+  "extensionBundle": {
+    "id": "Microsoft.Azure.Functions.ExtensionBundle",
+    "version": "[4.*, 5.0.0)"
+  }
+}
+`;
+var NODE_FUNCTION_APP_HELLO = `import { app, HttpRequest, HttpResponseInit } from '@azure/functions'
+import { buildGreeting } from './greeting'
+
+async function hello (request: HttpRequest): Promise<HttpResponseInit> {
+  const name = request.query.get('name') ?? 'world'
+  return { body: buildGreeting(name) }
+}
+
+app.http('hello', {
+  methods: ['GET'],
+  authLevel: 'anonymous',
+  route: 'hello',
+  handler: hello,
+})
+`;
+var NODE_FUNCTION_APP_GREETING = `export function buildGreeting (name: string): string {
+  return 'Hello, ' + name + '!'
+}
+`;
+var NODE_FUNCTION_APP_GREETING_SPEC = `import { buildGreeting } from './greeting'
+
+describe('buildGreeting', () => {
+  it('greets a name', () => {
+    expect(buildGreeting('world')).toBe('Hello, world!')
+  })
+})
+`;
+function repairNodeFunctionAppManifest(nodeFunctionAppRoot, workspaceRoot) {
+  const manifestPath = (0, import_node_path3.join)(nodeFunctionAppRoot, "package.json");
+  const manifest = readJson(manifestPath);
+  const azureFunctionsVersion = readJson((0, import_node_path3.join)(workspaceRoot, "node_modules/@azure/functions/package.json")).version;
+  const dependencies = manifest.dependencies ?? {};
+  writeFileEnsured(manifestPath, toJson({
+    ...manifest,
+    main: "main.js",
+    dependencies: { ...dependencies, "@azure/functions": `^${azureFunctionsVersion}` }
+  }));
+}
+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}')"`;
+  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 addNodeFunctionApp(workspaceRoot, name, stack) {
+  runNodeApp(workspaceRoot, name, stack);
+  ensureAzureFunctionsPackage(workspaceRoot);
+  const nodeFunctionAppRoot = (0, import_node_path3.join)(workspaceRoot, "apps", name);
+  writeFileEnsured((0, import_node_path3.join)(nodeFunctionAppRoot, "src/main.ts"), NODE_FUNCTION_APP_MAIN);
+  writeFileEnsured((0, import_node_path3.join)(nodeFunctionAppRoot, "src/functions/hello.ts"), NODE_FUNCTION_APP_HELLO);
+  writeFileEnsured((0, import_node_path3.join)(nodeFunctionAppRoot, "src/functions/greeting.ts"), NODE_FUNCTION_APP_GREETING);
+  writeFileEnsured((0, import_node_path3.join)(nodeFunctionAppRoot, "src/functions/greeting.spec.ts"), NODE_FUNCTION_APP_GREETING_SPEC);
+  writeFileEnsured((0, import_node_path3.join)(nodeFunctionAppRoot, "host.json"), NODE_FUNCTION_APP_HOST_JSON);
+  repairNodeFunctionAppManifest(nodeFunctionAppRoot, workspaceRoot);
+  ensureAdmZip(workspaceRoot);
+  addNxTargets((0, import_node_path3.join)(nodeFunctionAppRoot, "package.json"), { package: nodeFunctionAppPackageTarget(name) });
+}
+
+// src/commands/add/npmLib.ts
+var import_node_path4 = 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}',
+          ],
+        },
+      ],
+    },
+    languageOptions: {
+      parser: await import('jsonc-eslint-parser'),
+    },
+  },
+  {
+    ignores: ['**/out-tsc'],
+  },
+];
+`;
+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([
+    "g",
+    "@nx/js:lib",
+    `packages/${name}`,
+    "--publishable",
+    `--importPath=${scope}/${name}`,
+    "--bundler=rollup",
+    `--unitTestRunner=${stack.testRunner}`,
+    `--linter=${stack.linter}`,
+    "--no-interactive"
+  ], workspaceRoot);
+  markPublic((0, import_node_path4.join)(workspaceRoot, "packages", name, "package.json"));
+  if (stack.linter === "eslint") {
+    writeFileEnsured((0, import_node_path4.join)(workspaceRoot, "packages", name, "eslint.config.mjs"), NPM_LIB_ESLINT_CONFIG);
+  }
+}
+function markPublic(manifestPath) {
+  const manifest = readJson(manifestPath);
+  writeFileEnsured(manifestPath, toJson({ ...manifest, publishConfig: { access: "public" } }));
+}
+
+// src/commands/add/python.ts
+var import_node_path5 = require("path");
+function ensurePython(workspaceRoot) {
+  const hasPython = runShell("python3", ["--version"], workspaceRoot) === 0 || runShell("python", ["--version"], workspaceRoot) === 0;
+  if (!hasPython) {
+    throw new Error("Python not found. Install Python 3.9+ first: https://www.python.org/downloads/");
+  }
+}
+function pythonPipPluginSpec() {
+  return process.env.MNCI2_PYTHON_PIP_SPEC ?? "@mnci/nx-python-pip";
+}
+function ensurePythonPipPlugin(workspaceRoot) {
+  if (hasPlugin(workspaceRoot, "@mnci/nx-python-pip")) {
+    return;
+  }
+  const spec = pythonPipPluginSpec();
+  logger.step(`Installing the Python toolchain plugin (${spec})`);
+  if (runShell("npm", ["install", "--save-dev", spec, "--no-audit", "--no-fund"], workspaceRoot) !== 0) {
+    throw new Error("npm install of @mnci/nx-python-pip failed");
+  }
+}
+var PYTHON_REQUIREMENTS_DEV = `build
+twine
+ruff
+pytest
+`;
+function ensureRequirementsDev(workspaceRoot) {
+  const requirementsDevPath = (0, import_node_path5.join)(workspaceRoot, "requirements-dev.txt");
+  if (!fileExists(requirementsDevPath)) {
+    writeFileEnsured(requirementsDevPath, PYTHON_REQUIREMENTS_DEV);
+  }
+}
+function pythonModuleDirectory(name) {
+  return name.replaceAll("-", "_");
+}
+function addProjectJsonTargets(projectJsonPath, newTargets) {
+  const project = readJson(projectJsonPath);
+  const targets = project.targets ?? {};
+  writeFileEnsured(projectJsonPath, toJson({ ...project, targets: { ...targets, ...newTargets } }));
+}
+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 }
+  };
+}
+function pythonFunctionAppPackageTarget(name, moduleDirectory) {
+  const zip = `dist/drop/python-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.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 }
+  };
+}
+function addPythonApp(workspaceRoot, name) {
+  ensurePython(workspaceRoot);
+  ensurePythonPipPlugin(workspaceRoot);
+  ensureRequirementsDev(workspaceRoot);
+  ensureAdmZip(workspaceRoot);
+  runNx(["g", "@mnci/nx-python-pip:application", name, `--directory=apps/${name}`, "--no-interactive"], workspaceRoot);
+  addProjectJsonTargets((0, import_node_path5.join)(workspaceRoot, "apps", name, "project.json"), { package: pythonAppPackageTarget(name) });
+}
+function addPythonFunctionApp(workspaceRoot, name) {
+  ensurePython(workspaceRoot);
+  ensurePythonPipPlugin(workspaceRoot);
+  ensureRequirementsDev(workspaceRoot);
+  ensureAdmZip(workspaceRoot);
+  runNx(["g", "@mnci/nx-python-pip:function-application", name, `--directory=apps/${name}`, "--no-interactive"], workspaceRoot);
+  const moduleDirectory = pythonModuleDirectory(name);
+  addProjectJsonTargets((0, import_node_path5.join)(workspaceRoot, "apps", name, "project.json"), { package: pythonFunctionAppPackageTarget(name, moduleDirectory) });
+}
+function addPythonLib(workspaceRoot, name) {
+  ensurePython(workspaceRoot);
+  ensurePythonPipPlugin(workspaceRoot);
+  ensureRequirementsDev(workspaceRoot);
+  runNx(["g", "@mnci/nx-python-pip:library", name, `--directory=python-packages/${name}`, "--no-interactive"], workspaceRoot);
+}
+function addPythonInternalLib(workspaceRoot, name) {
+  ensurePython(workspaceRoot);
+  ensurePythonPipPlugin(workspaceRoot);
+  ensureRequirementsDev(workspaceRoot);
+  runNx(["g", "@mnci/nx-python-pip:internal-library", name, `--directory=libs/${name}`, "--no-interactive"], workspaceRoot);
+}
+
+// src/commands/add/reactApp.ts
+var import_node_fs2 = require("fs");
+var import_node_path6 = require("path");
+function ensurePlugin2(workspaceRoot, packageName) {
+  if (hasPlugin(workspaceRoot, packageName)) {
+    return;
+  }
+  logger.step(`Installing Nx plugin ${packageName}`);
+  runNx(["add", packageName], workspaceRoot);
+}
+var REACT_ENVIRONMENTS = ["dev", "uat", "prod"];
+function reactEnvironmentFile(environment) {
+  return `# Vite compiles VITE_-prefixed vars into the '${environment}' bundle at build time.
+# They ship to the browser, so keep only PUBLIC config here \u2014 never secrets.
+VITE_ENVIRONMENT=${environment}
+VITE_API_URL=https://api.${environment}.example.com
+`;
+}
+function reactAppTargets(name) {
+  const targets = {};
+  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}`, cwd: `apps/${name}` }
+    };
+  }
+  const zipStatements = REACT_ENVIRONMENTS.map((environment) => `z=new A();z.addLocalFolder('apps/${name}/dist-${environment}');z.writeZip('dist/drop/react-app-${name}-${environment}.zip')`).join(";");
+  targets.package = {
+    executor: "nx:run-commands",
+    dependsOn: REACT_ENVIRONMENTS.map((environment) => `build-${environment}`),
+    // eslint-disable-next-line unicorn/no-incorrect-template-string-interpolation -- {workspaceRoot} tokens, not JS interpolation
+    outputs: REACT_ENVIRONMENTS.map((environment) => `{workspaceRoot}/dist/drop/react-app-${name}-${environment}.zip`),
+    options: { command: `node -e "const fs=require('node:fs');fs.mkdirSync('dist/drop',{recursive:true});const A=require('adm-zip');let z;${zipStatements}"` }
+  };
+  return targets;
+}
+function allowEnvFiles(workspaceRoot) {
+  const gitignorePath = (0, import_node_path6.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_fs2.readFileSync)(gitignorePath, "utf8");
+  if (current.includes(marker)) {
+    return;
+  }
+  const allow = REACT_ENVIRONMENTS.map((environment) => `!apps/*/.env.${environment}`).join("\n");
+  writeFileEnsured(gitignorePath, `${current.replace(/\n*$/, "\n")}
+${marker}
+${allow}
+`);
+}
+function addReactApp(workspaceRoot, name, stack) {
+  ensurePlugin2(workspaceRoot, "@nx/react");
+  runNx([
+    "g",
+    "@nx/react:app",
+    `apps/${name}`,
+    "--bundler=vite",
+    `--unitTestRunner=${stack.testRunner}`,
+    `--linter=${stack.linter}`,
+    "--style=css",
+    "--e2eTestRunner=none",
+    "--no-interactive"
+  ], workspaceRoot);
+  ensureAdmZip(workspaceRoot);
+  const reactAppRoot = (0, import_node_path6.join)(workspaceRoot, "apps", name);
+  for (const environment of REACT_ENVIRONMENTS) {
+    writeFileEnsured((0, import_node_path6.join)(reactAppRoot, `.env.${environment}`), reactEnvironmentFile(environment));
+  }
+  allowEnvFiles(workspaceRoot);
+  addNxTargets((0, import_node_path6.join)(reactAppRoot, "package.json"), reactAppTargets(name));
+}
+
+// src/commands/add.ts
+var PROJECT_KINDS = [
+  "react-app",
+  "node-app",
+  "node-function-app",
+  "npm-lib",
+  "internal-lib",
+  "python-app",
+  "python-function-app",
+  "python-lib",
+  "python-internal-lib"
+];
+async function runAdd(kind, name, options) {
+  const workspaceRoot = process.cwd();
+  if (!fileExists((0, import_node_path7.join)(workspaceRoot, "nx.json"))) {
+    throw new Error("No nx.json found here. Run `add` from the workspace root.");
+  }
+  const stack = readWorkspaceStack(workspaceRoot);
+  const kindProvided = kind !== void 0;
+  const resolvedKind = kind ?? await (0, import_prompts3.select)({
+    message: "What kind of project?",
+    choices: PROJECT_KINDS.map((value) => ({ name: value, value }))
+  });
+  const resolvedName = name ?? await promptText("Project name");
+  assertValidProjectName(resolvedName, "Project name");
+  switch (resolvedKind) {
+    case "react-app": {
+      addReactApp(workspaceRoot, resolvedName, stack);
+      break;
+    }
+    case "node-app": {
+      addNodeApp(workspaceRoot, resolvedName, stack);
+      break;
+    }
+    case "node-function-app": {
+      addNodeFunctionApp(workspaceRoot, resolvedName, stack);
+      break;
+    }
+    case "npm-lib": {
+      await addNpmLib(workspaceRoot, resolvedName, options, kindProvided, stack);
+      break;
+    }
+    case "internal-lib": {
+      runNx([
+        "g",
+        "@nx/js:lib",
+        `libs/${resolvedName}`,
+        "--bundler=tsc",
+        `--unitTestRunner=${stack.testRunner}`,
+        `--linter=${stack.linter}`,
+        "--no-interactive"
+      ], workspaceRoot);
+      markPrivate((0, import_node_path7.join)(workspaceRoot, "libs", resolvedName, "package.json"));
+      break;
+    }
+    case "python-app": {
+      addPythonApp(workspaceRoot, resolvedName);
+      break;
+    }
+    case "python-function-app": {
+      addPythonFunctionApp(workspaceRoot, resolvedName);
+      break;
+    }
+    case "python-lib": {
+      addPythonLib(workspaceRoot, resolvedName);
+      break;
+    }
+    case "python-internal-lib": {
+      addPythonInternalLib(workspaceRoot, resolvedName);
+      break;
+    }
+    default: {
+      const exhaustive = resolvedKind;
+      throw new Error(`Unknown project kind '${exhaustive}'. Expected one of: ${PROJECT_KINDS.join(", ")}.`);
+    }
+  }
+  syncProjectReferences(workspaceRoot);
+  logger.success(`Added ${resolvedKind} '${resolvedName}'.`);
+}
+function syncProjectReferences(workspaceRoot) {
+  logger.step("Syncing TypeScript project references (nx sync)");
+  if (runShell("npx", ["nx", "sync"], workspaceRoot) !== 0) {
+    logger.warn("nx sync did not complete \u2014 run `npx nx sync` yourself so cross-project imports resolve in your editor.");
+  }
+}
+function readWorkspaceStack(workspaceRoot) {
+  const nxJson = readJson((0, import_node_path7.join)(workspaceRoot, "nx.json"));
+  const stack = nxJson.mnci2?.stack;
+  return {
+    linter: stack?.linter === "oxlint" ? "none" : "eslint",
+    testRunner: stack?.testRunner === "vitest" ? "vitest" : "jest"
+  };
+}
+function markPrivate(manifestPath) {
+  const manifest = readJson(manifestPath);
+  writeFileEnsured(manifestPath, toJson({ ...manifest, private: true }));
+}
+
+// src/commands/interactive.ts
+var import_node_path10 = require("path");
+var import_prompts6 = require("@inquirer/prompts");
+
+// src/commands/new.ts
+var import_node_path9 = require("path");
+
+// src/overlay.ts
+var import_node_path8 = require("path");
+var DEFAULT_STACK = { linter: "eslint", testRunner: "jest" };
+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");
+}
+var RELEASE_CONFIG = {
+  projectsRelationship: "independent",
+  projects: ["packages/*", "python-packages/*"],
+  releaseTag: { pattern: "{projectName}@{version}" },
+  git: { commit: false, tag: true, push: true },
+  version: {
+    conventionalCommits: true,
+    fallbackCurrentVersionResolver: "disk",
+    // Build only what is being released. Without this, @nx/js:lib's generator
+    // defaults the pre-version command to building EVERY project, so a broken
+    // (or merely slow) app build would block releasing unrelated packages.
+    // Set here at `new` time it wins: the generator only fills this in when
+    // absent (it spreads the existing release.version over its default). Both
+    // globs are listed; `nx run-many` no-ops cleanly when one matches nothing.
+    preVersionCommand: "npx nx run-many -t build --projects=packages/*,python-packages/*"
+  },
+  changelog: { workspaceChangelog: false }
+};
+var SYNC_CONFIG = { applyChanges: true };
+function withReleaseConfig(nxJson) {
+  return { ...nxJson, defaultBase: "main", release: RELEASE_CONFIG };
+}
+var COMMITLINT_CONFIG = `export default { extends: ['@commitlint/config-conventional'] }
+`;
+var COMMIT_MSG_HOOK = `npx --no -- commitlint --edit "$1"
+`;
+var ROOT_SCRIPTS = {
+  build: "nx run-many -t build",
+  lint: "nx run-many -t lint",
+  test: "nx run-many -t test",
+  affected: "nx affected -t lint,test,build",
+  graph: "nx graph",
+  "release:preview": "nx release --dry-run",
+  prepare: "husky"
+};
+function rootScripts(stack) {
+  if (stack.linter === "oxlint") {
+    return {
+      ...ROOT_SCRIPTS,
+      lint: "oxlint",
+      format: "oxfmt -c oxfmt.config.mts .",
+      "format:check": "oxfmt -c oxfmt.config.mts --check ."
+    };
+  }
+  return { ...ROOT_SCRIPTS };
+}
+function generatorDefaults(stack) {
+  const shared = { linter: stack.linter === "oxlint" ? "none" : "eslint", unitTestRunner: stack.testRunner };
+  return {
+    "@nx/react:application": shared,
+    "@nx/react:library": shared,
+    "@nx/js:library": shared
+  };
+}
+function mnci2Config(stack) {
+  return { stack: { linter: stack.linter, testRunner: stack.testRunner } };
+}
+var OXLINT_CONFIG = `import { defineConfig } from 'oxlint'
+import standard from 'oxc-standard/.oxlintrc.json' with { type: 'json' }
+
+// Generated by MoNecromanCI. JavaScript Standard Style linting via the
+// oxc-standard preset (unicorn + React + react-perf + TypeScript + oxc).
+// Add project-specific rule overrides in the \`rules\` block below.
+export default defineConfig({
+  extends: [standard],
+  rules: {
+    // The modern JSX transform (Nx's default) needs no React import in scope.
+    'react/react-in-jsx-scope': 'off',
+  },
+})
+`;
+var OXFMT_CONFIG = `import { defineConfig } from 'oxfmt'
+
+// Generated by MoNecromanCI. JavaScript Standard Style formatting, matching the
+// oxc-standard lint preset: no semicolons, single quotes, 2-space indent.
+export default defineConfig({
+  singleQuote: true,
+  semi: false,
+  printWidth: 100,
+  tabWidth: 2,
+  trailingComma: 'es5',
+  arrowParens: 'avoid',
+})
+`;
+function pythonPublishUrl(registry) {
+  if (registry.kind === "azure-artifacts") {
+    return `https://pkgs.dev.azure.com/${registry.organization}/${registry.project}/_packaging/${registry.artifactsFeed}/pypi/upload/`;
+  }
+  return void 0;
+}
+var PYTHON_INSTALL_GUARD = `node -e "if(!require('node:fs').existsSync('requirements-dev.txt')){console.log('No Python projects - skipping.');process.exit(0)}process.exit(require('node:child_process').spawnSync('python3 -m pip install -r requirements-dev.txt',{stdio:'inherit',shell:true}).status ?? 1)"`;
+var PACK_APPS_GUARD = `node -e "const fs=require('node:fs');fs.mkdirSync('dist/drop',{recursive:true});if(fs.globSync('apps/*/project.json').length===0){console.log('No apps to pack - skipping.');process.exit(0)}process.exit(require('node:child_process').spawnSync('npx nx run-many -t package',{stdio:'inherit',shell:true}).status ?? 1)"`;
+function releaseGuard(pythonPublishEnv) {
+  return `node -e "const fs=require('node:fs'),cp=require('node:child_process');const hasNpm=fs.globSync('packages/*/package.json').length>0;const hasPython=fs.globSync('python-packages/*/pyproject.toml').length>0;if(!hasNpm&&!hasPython){console.log('Nothing to release - skipping.');process.exit(0)}const env={...process.env};${pythonPublishEnv}process.exit(cp.spawnSync('npx nx release --yes',{stdio:'inherit',shell:true,env}).status ?? 1)"`;
+}
+function pythonPublishEnvFragment(pythonPublishUrl2) {
+  return pythonPublishUrl2 ? `if(hasPython){env.TWINE_REPOSITORY_URL='${pythonPublishUrl2}';env.TWINE_USERNAME='AzureArtifacts';env.TWINE_PASSWORD=Buffer.from(process.env.PAT,'base64').toString()}` : "";
+}
+function npmAuthEnvVariable(registryKind, variableReference) {
+  return registryKind === "npm" ? ["NODE_AUTH_TOKEN", variableReference("NPM_TOKEN")] : ["PAT", variableReference("PAT")];
+}
+function poolBlock(agent) {
+  return /^(ubuntu|windows|macos)-/i.test(agent) ? `  vmImage: ${agent}` : `  name: ${agent}`;
+}
+function azurePipelinesYaml(agent, variableGroup, pythonPublishUrl2, registryKind = "azure-artifacts") {
+  const onMain = `and(succeeded(), ne(variables['Build.Reason'], 'PullRequest'), eq(variables['Build.SourceBranchName'], 'main'))`;
+  const [npmAuthName, npmAuthValue] = npmAuthEnvVariable(registryKind, (name) => `$(${name})`);
+  return `name: monorepo-ci-$(Date:yyyyMMdd)$(Rev:.r)
+
+# Generated by MoNecromanCI v2. Deliberately thin: Nx builds, 'nx release'
+# versions from conventional commits and pushes ONLY a tag to main, and each
+# app is packed into dist/drop/<type>-<name>.zip by its own 'package' target.
+#
+# Cross-platform by construction: no bash, no PowerShell. Every step is a
+# built-in task or a single-line git/npm/npx/node command, so the pipeline
+# runs unchanged on Linux, macOS and Windows agents.
+
+trigger:
+  branches:
+    include: [main]
+
+pr:
+  branches:
+    include: [main]
+
+pool:
+${poolBlock(agent)}
+
+variables:
+  # Holds the npm auth secret the root .npmrc reads: the base64-encoded \`PAT\`
+  # for an Azure Artifacts feed, or a raw npm automation token as \`NPM_TOKEN\`
+  # for public npm. Mark it secret in Library. Add app build vars here too if needed.
+  - group: ${variableGroup}
+
+steps:
+  - checkout: self
+    # Lets later steps push release tags back to the repo. The Project
+    # Collection Build Service account needs Contribute permission on this
+    # repo (Project Settings -> Repositories -> Security) \u2014 one-time grant.
+    persistCredentials: true
+    fetchDepth: 0
+
+  # checkout leaves a detached HEAD; nx release needs a real branch.
+  - script: git checkout -B $(Build.SourceBranchName)
+    displayName: Attach HEAD to the source branch
+
+  # Version resolution needs the release tags.
+  - script: git fetch --all --prune --tags
+    displayName: Fetch branches and release tags
+
+  - script: git config user.name "Azure Pipelines" && git config user.email "pipeline@dev.azure.com"
+    displayName: Set the git identity used for release tags
+
+  - task: UseNode@1
+    inputs:
+      version: 24.x
+
+  - script: npm ci
+    displayName: Install dependencies
+    env:
+      ${npmAuthName}: ${npmAuthValue}
+
+  # Installs the fixed Python toolchain (ruff, pytest, build, twine) \u2014 written
+  # by 'mnci2 add' to requirements-dev.txt on the first Python project. Plain
+  # pip, no uv/Poetry: portable guard skips cleanly on a workspace with none.
+  - script: ${PYTHON_INSTALL_GUARD}
+    displayName: Install Python dependencies (ruff, pytest, build, twine)
+
+  # Fails fast, with an unambiguous message, when a stale TypeScript project
+  # reference (or another sync generator's drift) was never synced+committed
+  # locally \u2014 sync.applyChanges (nx.json) only auto-applies interactively, so
+  # CI still needs its own explicit, early check rather than surfacing this as
+  # a confusing failure buried inside the build step below.
+  - script: npx nx sync:check
+    displayName: Verify the workspace is synced (run 'npx nx sync' locally and commit if this fails)
+
+  # One verify for every run (PR and main). \`npm run lint\` abstracts the chosen
+  # linter (eslint via nx, or oxlint), so the pipeline needs no linter branch;
+  # Nx cache makes unchanged test/build projects instant.
+  - script: npm run lint
+    displayName: Lint
+  # \`lint\` here also runs any Nx lint targets \`npm run lint\` does not cover \u2014
+  # notably Python's ruff (every Python project owns a hand-authored \`lint\`
+  # target). For the eslint stack the JS lint runs twice, but Nx caches the
+  # repeat instantly.
+  - script: npx nx run-many -t lint,test,build
+    displayName: Lint, test and build everything
+
+  # Pack every app into dist/drop/<type>-<name>.zip via each app's 'package'
+  # target. Portable guard: skip cleanly when the workspace has no apps yet.
+  - script: ${PACK_APPS_GUARD}
+    displayName: Pack all apps (one zip per app -> dist/drop)
+    condition: ${onMain}
+
+  - task: PublishBuildArtifacts@1
+    displayName: Publish the drop (one zip per app)
+    condition: ${onMain}
+    inputs:
+      PathtoPublish: $(Build.SourcesDirectory)/dist/drop
+      ArtifactName: drop
+
+  # One build tag per packed app, EXACTLY the zip name (type-name), so the
+  # classic release pipeline knows which app to run for. Derived from the zip
+  # filenames so the tag can never drift from the artifact.
+  - script: node -e "const fs=require('node:fs');const path=require('node:path');for(const f of fs.globSync('dist/drop/*.zip')){console.log('##vso[build.addbuildtag]'+path.basename(f,'.zip'))}"
+    displayName: Tag the run per app (type-name)
+    condition: ${onMain}
+
+  # Version + tag + publish, in one release, for npm (packages/*) AND Python
+  # (python-packages/*) \u2014 conventional commits, tag-only push. Portable guard:
+  # nx release errors on an empty scope, so skip cleanly when there is nothing
+  # to release. When there are Python packages and an Azure feed, twine
+  # publish credentials are exported (raw PAT, decoded from the base64 variable).
+  - script: ${releaseGuard(pythonPublishEnvFragment(pythonPublishUrl2))}
+    displayName: Release \u2014 version, tag and publish (npm + Python)
+    condition: ${onMain}
+    env:
+      ${npmAuthName}: ${npmAuthValue}
+`;
+}
+function githubActionsYaml(agent, pythonPublishUrl2, registryKind = "azure-artifacts") {
+  const onMain = `github.event_name != 'pull_request' && github.ref_name == 'main'`;
+  const [npmAuthName, npmAuthValue] = npmAuthEnvVariable(registryKind, (name) => `\${{ secrets.${name} }}`);
+  return `name: CI
+
+# Generated by MoNecromanCI v2. Deliberately thin: Nx builds, 'nx release'
+# versions from conventional commits and pushes ONLY a tag to main, and each
+# app is packed into dist/drop/<type>-<name>.zip by its own 'package' target.
+# The GitHub Actions equivalent of azure-pipelines.yml \u2014 see there for the
+# fuller rationale; both stay hand-kept in lockstep, there is no shared template.
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+permissions:
+  # Lets the release step push the version tag nx release creates back to main.
+  contents: write
+
+jobs:
+  ci:
+    runs-on: ${agent}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      # Version resolution needs the release tags.
+      - run: git fetch --all --prune --tags
+        name: Fetch branches and release tags
+
+      - run: git config user.name "github-actions[bot]" && git config user.email "github-actions[bot]@users.noreply.github.com"
+        name: Set the git identity used for release tags
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+
+      - run: npm ci
+        name: Install dependencies
+        env:
+          ${npmAuthName}: ${npmAuthValue}
+
+      # Installs the fixed Python toolchain (ruff, pytest, build, twine) \u2014 written
+      # by 'mnci2 add' to requirements-dev.txt on the first Python project. Plain
+      # pip, no uv/Poetry: portable guard skips cleanly on a workspace with none.
+      - run: ${PYTHON_INSTALL_GUARD}
+        name: Install Python dependencies (ruff, pytest, build, twine)
+
+      # Fails fast, with an unambiguous message, when a stale TypeScript project
+      # reference (or another sync generator's drift) was never synced+committed
+      # locally \u2014 sync.applyChanges (nx.json) only auto-applies interactively, so
+      # CI still needs its own explicit, early check rather than surfacing this as
+      # a confusing failure buried inside the build step below.
+      - run: npx nx sync:check
+        name: Verify the workspace is synced (run 'npx nx sync' locally and commit if this fails)
+
+      # One verify for every run (PR and main). \`npm run lint\` abstracts the chosen
+      # linter (eslint via nx, or oxlint), so the workflow needs no linter branch;
+      # Nx cache makes unchanged test/build projects instant.
+      - run: npm run lint
+        name: Lint
+      # \`lint\` here also runs any Nx lint targets \`npm run lint\` does not cover \u2014
+      # notably Python's ruff (every Python project owns a hand-authored \`lint\`
+      # target). For the eslint stack the JS lint runs twice, but Nx caches the
+      # repeat instantly.
+      - run: npx nx run-many -t lint,test,build
+        name: Lint, test and build everything
+
+      # Pack every app into dist/drop/<type>-<name>.zip via each app's 'package'
+      # target. Portable guard: skip cleanly when the workspace has no apps yet.
+      - run: ${PACK_APPS_GUARD}
+        name: Pack all apps (one zip per app -> dist/drop)
+        if: \${{ ${onMain} }}
+
+      - uses: actions/upload-artifact@v4
+        if: \${{ ${onMain} }}
+        with:
+          name: drop
+          path: dist/drop
+          if-no-files-found: ignore
+
+      # Version + tag + publish, in one release, for npm (packages/*) AND Python
+      # (python-packages/*) \u2014 conventional commits, tag-only push. Portable guard:
+      # nx release errors on an empty scope, so skip cleanly when there is nothing
+      # to release. When there are Python packages and an Azure feed, twine
+      # publish credentials are exported (raw PAT, decoded from the base64 secret).
+      - run: ${releaseGuard(pythonPublishEnvFragment(pythonPublishUrl2))}
+        name: Release \u2014 version, tag and publish (npm + Python)
+        if: \${{ ${onMain} }}
+        env:
+          ${npmAuthName}: ${npmAuthValue}
+`;
+}
+function applyOverlay(workspaceRoot, options) {
+  const nxJsonPath = (0, import_node_path8.join)(workspaceRoot, "nx.json");
+  const nxJson = readJson(nxJsonPath);
+  const generators = { ...nxJson.generators, ...generatorDefaults(options.stack) };
+  const sync = { ...nxJson.sync, ...SYNC_CONFIG };
+  const mnci2 = { ...nxJson.mnci2, ...mnci2Config(options.stack) };
+  writeFileEnsured(nxJsonPath, toJson({ ...withReleaseConfig(nxJson), generators, sync, mnci2 }));
+  const manifestPath = (0, import_node_path8.join)(workspaceRoot, "package.json");
+  const manifest = readJson(manifestPath);
+  const scripts = { ...manifest.scripts, ...rootScripts(options.stack) };
+  const devDependencies = { ...manifest.devDependencies, ...TS_COMPILER_DEPENDENCIES };
+  writeFileEnsured(manifestPath, toJson({ ...manifest, name: `${options.scope}/source`, scripts, devDependencies }));
+  writeFileEnsured((0, import_node_path8.join)(workspaceRoot, ".npmrc"), npmrcContent(options.registry, options.scope));
+  writeFileEnsured((0, import_node_path8.join)(workspaceRoot, "commitlint.config.mjs"), COMMITLINT_CONFIG);
+  const hookPath = (0, import_node_path8.join)(workspaceRoot, ".husky/commit-msg");
+  writeFileEnsured(hookPath, COMMIT_MSG_HOOK);
+  markExecutable(hookPath);
+  if (options.stack.linter === "oxlint") {
+    writeFileEnsured((0, import_node_path8.join)(workspaceRoot, "oxlint.config.mts"), OXLINT_CONFIG);
+    writeFileEnsured((0, import_node_path8.join)(workspaceRoot, "oxfmt.config.mts"), OXFMT_CONFIG);
+  }
+  const publishUrl = pythonPublishUrl(options.registry);
+  if (options.ci === "azure" || options.ci === "both") {
+    writeFileEnsured((0, import_node_path8.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_path8.join)(workspaceRoot, ".github/workflows/ci.yml"), githubActionsYaml(options.agent, publishUrl, options.registry.kind));
+  }
+}
+
+// src/commands/new.ts
+async function resolveStack(options) {
+  const fromFlags = { linter: options.linter, testRunner: options.testRunner };
+  const complete = Boolean(fromFlags.linter && fromFlags.testRunner);
+  if (complete || options.yes) {
+    return {
+      linter: fromFlags.linter ?? DEFAULT_STACK.linter,
+      testRunner: fromFlags.testRunner ?? DEFAULT_STACK.testRunner
+    };
+  }
+  const prompted = await promptStack();
+  return {
+    linter: fromFlags.linter ?? prompted.linter,
+    testRunner: fromFlags.testRunner ?? prompted.testRunner
+  };
+}
+var CI_PROVIDERS = /* @__PURE__ */ new Set(["azure", "github", "both"]);
+async function resolveCi(options) {
+  if (options.ci && CI_PROVIDERS.has(options.ci)) {
+    return options.ci;
+  }
+  if (options.yes) {
+    return "azure";
+  }
+  return await promptCi();
+}
+async function resolveRegistry(options) {
+  if (options.registry === "azure-artifacts" || options.organization && options.artifactsFeed) {
+    return {
+      kind: "azure-artifacts",
+      organization: options.organization ?? await promptText("Azure DevOps organization"),
+      project: options.project ?? await promptText("Azure DevOps project"),
+      artifactsFeed: options.artifactsFeed ?? await promptText("Artifacts feed name")
+    };
+  }
+  if (options.registry === "npm" || options.yes) {
+    return { kind: "npm" };
+  }
+  return await promptRegistry();
+}
+async function runNew(name, options) {
+  const workspaceName = name ?? await promptText("Workspace name");
+  assertValidProjectName(workspaceName, "Workspace name");
+  const scope = options.scope ?? (options.yes ? `@${workspaceName}` : await promptText("npm scope for publishable packages", `@${workspaceName}`));
+  const registry = await resolveRegistry(options);
+  const ci = await resolveCi(options);
+  const agent = options.agent ?? (options.yes ? "ubuntu-latest" : await promptText("CI build agent/runner (vmImage, GitHub Actions runner label, or self-hosted pool name)", "ubuntu-latest"));
+  const variableGroup = ci === "github" ? options.variableGroup ?? "Build" : options.variableGroup ?? (options.yes ? "Build" : await promptText("Azure DevOps variable group holding the npm PAT", "Build"));
+  const stack = await resolveStack(options);
+  logger.step(`Creating Nx workspace '${workspaceName}' (preset: ts)`);
+  runNpx([
+    "--yes",
+    "create-nx-workspace@latest",
+    workspaceName,
+    "--preset=ts",
+    "--pm=npm",
+    "--nxCloud=skip",
+    "--no-interactive"
+  ], process.cwd());
+  const workspaceRoot = (0, import_node_path9.join)(process.cwd(), workspaceName);
+  logger.step("Applying MoNecromanCI overlay (release config, .npmrc, commitlint, pipeline, stack)");
+  applyOverlay(workspaceRoot, { scope, registry, agent, variableGroup, ci, stack });
+  const stackDependencies = stack.linter === "oxlint" ? ["oxc-standard"] : [];
+  logger.step(`Installing the toolchain (${stack.linter === "oxlint" ? "oxc-standard" : "eslint"}, commit toolchain)`);
+  const installStatus = runShell("npm", ["install", "--save-dev", ...stackDependencies, "husky", "@commitlint/cli", "@commitlint/config-conventional"], workspaceRoot);
+  if (installStatus !== 0) {
+    throw new Error(`npm install of the toolchain failed with exit code ${installStatus}`);
+  }
+  runShell("npx", ["husky"], workspaceRoot);
+  logger.success("Done. Next steps:");
+  logger.info(`  cd ${workspaceName}`);
+  logger.info("  mnci2 add react-app web        # or: node-app, node-function-app, npm-lib, internal-lib,");
+  logger.info("                                 #     python-app, python-function-app, python-lib, python-internal-lib");
+  logger.info('  git add -A && git commit -m "feat: initial workspace"');
+}
+
+// src/commands/interactive.ts
+async function runInteractive() {
+  const inWorkspace = fileExists((0, import_node_path10.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 action = await (0, import_prompts6.select)({
+    message: "What would you like to do?",
+    choices: inWorkspace ? [addChoice, newChoice] : [newChoice, addChoice]
+  });
+  if (action === "new") {
+    await runNew(void 0, {});
+  } else {
+    await runAdd(void 0, void 0, {});
+  }
+}
+
+// src/cli.ts
+function readVersion() {
+  try {
+    const package_ = JSON.parse((0, import_node_fs3.readFileSync)((0, import_node_path11.join)(__dirname, "..", "package.json"), "utf8"));
+    return package_.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function buildProgram() {
+  const program = new import_commander.Command();
+  program.name("mnci2").description("MoNecromanCI v2 \u2014 a thin CLI over official Nx plugins").version(readVersion(), "-v, --version", "display the version");
+  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("--linter <linter>", "linter: eslint | oxlint").option("--test-runner <runner>", "unit-test runner: jest | vitest").action(async (name, options) => {
+    await runNew(name, options);
+  });
+  program.command("add").addArgument(new import_commander.Argument("[kind]", "project kind").choices(PROJECT_KINDS)).argument("[name]", "project name").description("Add a project by delegating to the matching Nx plugin generator").option("--scope <scope>", "npm scope for a publishable lib (defaults to @<workspace name>)").action(async (kind, name, options) => {
+    await runAdd(kind, name, options);
+  });
+  program.action(async () => {
+    await runInteractive();
+  });
+  return program;
+}
+async function main() {
+  try {
+    await buildProgram().parseAsync(process.argv);
+  } catch (error) {
+    logger.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+}
+if (require.main === module) {
+  main();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildProgram,
+  main
+});
+//# sourceMappingURL=cli.js.map