@mnci/cli 1.5.0 → 1.7.0

package/README.md

@@ -29,10 +29,12 @@ first-party (or established community) Nx equivalent:
 ```sh
 mnci new my-repo            # create a monorepo (prompts scope + registry)
 mnci new my-repo --yes --registry npm --scope @my
+mnci new my-repo --yes --registry npm --scope @my --nx-cloud  # opt in to Nx Cloud
 
 cd my-repo
 mnci add react-app web         # @nx/react (Vite + Jest)
 mnci add node-app svc          # @nx/node (plain Node app, esbuild)
+mnci add node-app api --framework express  # ...or fastify | koa | nest
 mnci add node-function-app api # @nx/node + an Azure Functions v4 overlay
 mnci add npm-lib sdk           # @nx/js publishable lib -> packages/
 mnci add internal-lib utils    # @nx/js private lib -> libs/
@@ -42,6 +44,7 @@ mnci add python-app svc            # app -> apps/ (wheel, zipped into the drop)
 mnci add python-function-app fn    # Azure Functions (Python v2) -> apps/
 mnci add python-lib shared         # publishable -> python-packages/ (twine upload)
 mnci add python-internal-lib core  # private shared lib -> libs/
+mnci add python-vendor shared --lib core  # wire core's module into shared's built wheel
 
 mnci upgrade                  # re-apply the latest overlay (see below)
 mnci upgrade --agent windows-latest   # ...with an explicit override
@@ -58,6 +61,7 @@ each a single cross-platform command:
 | `npm run affected`    | `nx affected -t lint,test,build` (vs `main`) |
 | `npm run graph`       | `nx graph`                      |
 | `npm run release:preview` | `nx release --dry-run`      |
+| `npm run python:install` | fixed Python toolchain (ruff/pytest/build/twine) + editable-install every Python project — the same two guards CI runs, for local dev |
 | `prepare`             | `husky` (commit-msg lint hook)  |
 
 ## What `new` actually does
@@ -339,6 +343,30 @@ only for `github`/`both` — an `azure`-only workspace gets no
 `.github/dependabot.yml`, matching every other GitHub-only file this CLI
 writes.
 
+### Nx Cloud (`--nx-cloud`, opt-in)
+
+`mnci new` never connects to Nx Cloud unless asked — `--nx-cloud` (or
+answering "yes" to the interactive prompt) opts in; the flagless/`--yes`
+default stays fully disconnected, exactly as before this existed. When
+opted in, `mnci` passes `create-nx-workspace` a **named** `--nxCloud`
+provider value derived from the chosen `--ci` (`azure`→`azure`,
+`github`/`both`→`github`) — never the bare `--nxCloud=yes`. Verified
+empirically: bare `yes` prompts "Will you be using GitHub as your git
+hosting provider?" even with `--no-interactive` set, and exits without
+creating the workspace at all when stdin isn't a TTY — a real
+`create-nx-workspace` inconsistency, not something `mnci` can configure
+around. The named-provider value sidesteps it and completes non-interactively
+every time. The only visible effect of *which* named value is chosen is a
+throwaway CI workflow file `create-nx-workspace` writes as a side effect of
+Cloud setup — this CLI's own overlay unconditionally overwrites whatever
+lands at that path immediately after, so the pipeline you actually get is
+always the same one described above, Nx Cloud or not.
+
+Connecting still requires finishing setup in a browser: `create-nx-workspace`
+prints a `https://cloud.nx.app/connect/…` URL to complete linking the
+workspace to an Nx Cloud account (remote caching, CI insights, `nx
+fix-ci`) — `mnci` does not automate that step.
+
 ## Dependency & risk notes
 
 Being upfront about what mnci leans on, so it's a conscious trade-off rather
@@ -394,18 +422,34 @@ than a surprise:
   Python project workspace-wide (see "Workspace-wide install" above),
   straight into whatever `<python>` resolves to on the agent (`python3` on
   POSIX, `python` on Windows — see above); locally, create your own venv
-  (`python3 -m venv` / `python -m venv` on Windows) and reproduce the same
-  two installs by hand (`pip install -r requirements-dev.txt`, then
-  `pip install -e <dir>` for each Python project).
+  (`python3 -m venv` / `python -m venv` on Windows) and run
+  `npm run python:install` to reproduce the same two installs — the root
+  script chains the identical two guards CI runs (see the scripts table
+  above).
 
 ## How Node apps work (plain `@nx/node:application`, no Azure Functions plugin)
 
 `node-app` and `node-function-app` are both the **official**
-`@nx/node:application` generator (`--bundler=esbuild --framework=none`) — no
-third-party Azure Functions plugin, and no post-generation build-output
-rewiring. `node-function-app` is exactly that generator plus a hand-written
-Azure Functions v4 file overlay, the same split `python-app`/
-`python-function-app` already use:
+`@nx/node:application` generator (`--bundler=esbuild`) — no third-party Azure
+Functions plugin, and no post-generation build-output rewiring.
+`node-function-app` is exactly that generator plus a hand-written Azure
+Functions v4 file overlay, the same split `python-app`/`python-function-app`
+already use:
+
+- **`node-app` framework choice** (`--framework`, default `none`): plain flag
+  plumbing to the generator's own `express`/`fastify`/`koa`/`nest`/`none`
+  choices — `mnci` adds no framework-specific logic of its own. Verified
+  empirically that all four scaffold, build and test cleanly on Nx 23.1.0.
+  One quirk worth knowing: `--framework=nest` silently overrides
+  `--bundler=esbuild` — NestJS needs its own webpack build (decorator/DI
+  metadata emission esbuild's transform-only approach can't produce), so a
+  `nest` app's `dist/main.js` is a single webpack bundle instead of the
+  esbuild non-bundled mirrored-tree + shim the other frameworks (and `none`)
+  produce. The `package` target needs no framework branch either way — both
+  shapes' runnable entry is `dist/main.js`, so zipping the whole `dist` folder
+  works unchanged. `node-function-app` never accepts `--framework`: the Azure
+  Functions v4 programming model (`app.http(...)` registration) runs its own
+  request lifecycle, so a full HTTP server framework doesn't apply there.
 
 - `build` = the generator's own `@nx/esbuild:esbuild` target, **non-bundled**
   (`bundle: false`): it transpiles each file individually and mirrors the
@@ -518,18 +562,21 @@ identically to a Linux/macOS one.
   <name>` just like the TS apps.
 - **Internal-lib vendoring** replaces `@nxlv/python`'s `bundleLocalDependencies`:
   plain pip has no bundled-local-dependency feature, so a project that imports
-  a workspace-internal Python library needs a hand-added `vendor` entry (under
+  a workspace-internal Python library needs a `vendor` entry (under
   `[tool.mnci-python-pip]`) in its own `pyproject.toml` (the pip-world
-  counterpart of hand-wiring a `dependencies = [...]` entry — neither mnci
-  nor the plugin wires cross-project Python dependencies automatically). The
-  plugin's `build` executor reads that entry, resolves the named project's
-  root via the **Nx project graph**, copies its module into a staged copy of
-  the consuming project, and builds from there — so the resulting wheel
-  contains the vendored module as a real top-level package. Verified
-  empirically that this does **not** reproduce the old `@nxlv/python` bug
-  where combining a vendored internal lib and a real external dependency on
-  the same project silently dropped the external one from the wheel's
-  metadata — both survive correctly.
+  counterpart of a `dependencies = [...]` entry — neither mnci nor the plugin
+  wires cross-project Python dependencies automatically). `mnci add
+  python-vendor <consumer> --lib <name>` automates writing that entry —
+  idempotent (safe to run twice), and works on any consumer with a
+  `pyproject.toml` (app, publishable lib, or another internal lib), not just
+  apps. The plugin's `build` executor reads the entry, resolves the named
+  project's root via the **Nx project graph**, copies its module into a
+  staged copy of the consuming project, and builds from there — so the
+  resulting wheel contains the vendored module as a real top-level package.
+  Verified empirically that this does **not** reproduce the old
+  `@nxlv/python` bug where combining a vendored internal lib and a real
+  external dependency on the same project silently dropped the external one
+  from the wheel's metadata — both survive correctly.
 - **Workspace-wide install** (mnci's own CI step, not the plugin's) — pip has
   no npm-workspaces-style hoisting, so mnci writes one: a guarded step
   editable-installs every Python project (`apps/*`, `python-packages/*`,

package/dist/cli.js

@@ -35,13 +35,13 @@ __export(cli_exports, {
   main: () => main
 });
 module.exports = __toCommonJS(cli_exports);
-var import_node_fs3 = require("fs");
+var import_node_fs4 = require("fs");
 var import_node_path12 = require("path");
 var import_commander = require("commander");
 
 // src/commands/add.ts
 var import_node_path7 = require("path");
-var import_prompts3 = require("@inquirer/prompts");
+var import_prompts4 = require("@inquirer/prompts");
 
 // src/nx.ts
 var import_cross_spawn = __toESM(require("cross-spawn"));
@@ -100,6 +100,12 @@ async function promptCi() {
     ]
   });
 }
+async function promptNxCloud() {
+  return await (0, import_prompts.confirm)({
+    message: "Connect this workspace to Nx Cloud (remote caching + CI insights)?",
+    default: false
+  });
+}
 async function promptStack() {
   const linter = await (0, import_prompts.select)({
     message: "Linter",
@@ -204,7 +210,7 @@ function ensurePlugin(workspaceRoot, packageName) {
   logger.step(`Installing Nx plugin ${packageName}`);
   runNx(["add", packageName], workspaceRoot);
 }
-function runNodeApp(workspaceRoot, name, stack) {
+function runNodeApp(workspaceRoot, name, stack, framework) {
   ensurePlugin(workspaceRoot, "@nx/node");
   runNx([
     "g",
@@ -214,7 +220,7 @@ function runNodeApp(workspaceRoot, name, stack) {
     `--unitTestRunner=${stack.testRunner}`,
     `--linter=${stack.linter}`,
     "--e2eTestRunner=none",
-    "--framework=none",
+    `--framework=${framework}`,
     "--no-interactive"
   ], workspaceRoot);
 }
@@ -229,8 +235,8 @@ function nodeAppPackageTarget(name) {
     options: { command }
   };
 }
-function addNodeApp(workspaceRoot, name, stack) {
-  runNodeApp(workspaceRoot, name, stack);
+function addNodeApp(workspaceRoot, name, stack, framework = "none") {
+  runNodeApp(workspaceRoot, name, stack, framework);
   ensureAdmZip(workspaceRoot);
   addNxTargets((0, import_node_path3.join)(workspaceRoot, "apps", name, "package.json"), { package: nodeAppPackageTarget(name) });
 }
@@ -306,7 +312,7 @@ function nodeFunctionAppPackageTarget(name) {
   };
 }
 function addNodeFunctionApp(workspaceRoot, name, stack) {
-  runNodeApp(workspaceRoot, name, stack);
+  runNodeApp(workspaceRoot, name, stack, "none");
   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);
@@ -385,6 +391,7 @@ function markPublic(manifestPath) {
 }
 
 // src/commands/add/python.ts
+var import_node_fs2 = require("fs");
 var import_node_path5 = require("path");
 function ensurePython(workspaceRoot) {
   const hasPython = runShell("python3", ["--version"], workspaceRoot) === 0 || runShell("python", ["--version"], workspaceRoot) === 0;
@@ -476,9 +483,57 @@ function addPythonInternalLib(workspaceRoot, name) {
   ensureRequirementsDev(workspaceRoot);
   runNx(["g", "@mnci/nx-python-pip:internal-library", name, `--directory=libs/${name}`, "--no-interactive"], workspaceRoot);
 }
+var PYTHON_PROJECT_DIRS = ["apps", "python-packages", "libs"];
+function findPythonProjectDirectory(workspaceRoot, name) {
+  return PYTHON_PROJECT_DIRS.find((directory) => fileExists((0, import_node_path5.join)(workspaceRoot, directory, name, "pyproject.toml")));
+}
+function parseVendorEntries(pyprojectToml) {
+  const match = /^\s*vendor\s*=\s*\[([^\]]*)\]/m.exec(pyprojectToml);
+  if (!match) {
+    return [];
+  }
+  return match[1].split(",").map((entry) => entry.trim().replaceAll(/^["']|["']$/g, "")).filter(Boolean);
+}
+function addVendorEntry(pyprojectToml, lib) {
+  const existing = parseVendorEntries(pyprojectToml);
+  if (existing.length > 0) {
+    const merged = [...existing, lib].map((name) => `"${name}"`).join(", ");
+    return pyprojectToml.replace(/^(\s*vendor\s*=\s*)\[([^\]]*)\]/m, (_match, prefix) => `${prefix}[${merged}]`);
+  }
+  const table = `[tool.mnci-python-pip]
+vendor = ["${lib}"]
+
+`;
+  return pyprojectToml.includes("[tool.pytest.ini_options]") ? pyprojectToml.replace("[tool.pytest.ini_options]", () => `${table}[tool.pytest.ini_options]`) : `${pyprojectToml}
+${table}`;
+}
+async function addPythonVendor(workspaceRoot, consumer, options, kindProvided) {
+  const lib = options.lib ?? (kindProvided ? void 0 : await promptText("Internal Python library to vendor (an existing libs/<name>)"));
+  if (!lib) {
+    throw new Error("`add python-vendor` needs the library to vendor: pass --lib <name> (an existing libs/<name> internal library).");
+  }
+  const consumerDirectory = findPythonProjectDirectory(workspaceRoot, consumer);
+  if (!consumerDirectory) {
+    throw new Error(`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_path5.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.`);
+  }
+  if (consumerDirectory === "libs" && consumer === lib) {
+    throw new Error(`'${consumer}' cannot vendor itself.`);
+  }
+  const pyprojectPath = (0, import_node_path5.join)(workspaceRoot, consumerDirectory, consumer, "pyproject.toml");
+  const pyprojectToml = (0, import_node_fs2.readFileSync)(pyprojectPath, "utf8");
+  if (parseVendorEntries(pyprojectToml).includes(lib)) {
+    logger.info(`'${consumer}' already vendors '${lib}' \u2014 nothing to do.`);
+    return;
+  }
+  writeFileEnsured(pyprojectPath, addVendorEntry(pyprojectToml, lib));
+  logger.success(`'${consumer}' now vendors '${lib}' \u2014 its wheel will include '${lib}''s module on the next build.`);
+}
 
 // src/commands/add/reactApp.ts
-var import_node_fs2 = require("fs");
+var import_node_fs3 = require("fs");
 var import_node_path6 = require("path");
 function ensurePlugin2(workspaceRoot, packageName) {
   if (hasPlugin(workspaceRoot, packageName)) {
@@ -521,7 +576,7 @@ function allowEnvFiles(workspaceRoot) {
     return;
   }
   const marker = "# MoNecromanCI: keep the committed per-environment Vite config (public VITE_ values)";
-  const current = (0, import_node_fs2.readFileSync)(gitignorePath, "utf8");
+  const current = (0, import_node_fs3.readFileSync)(gitignorePath, "utf8");
   if (current.includes(marker)) {
     return;
   }
@@ -563,7 +618,8 @@ var PROJECT_KINDS = [
   "python-app",
   "python-function-app",
   "python-lib",
-  "python-internal-lib"
+  "python-internal-lib",
+  "python-vendor"
 ];
 async function runAdd(kind, name, options) {
   const workspaceRoot = process.cwd();
@@ -572,7 +628,7 @@ async function runAdd(kind, name, options) {
   }
   const stack = readWorkspaceStack(workspaceRoot);
   const kindProvided = kind !== void 0;
-  const resolvedKind = kind ?? await (0, import_prompts3.select)({
+  const resolvedKind = kind ?? await (0, import_prompts4.select)({
     message: "What kind of project?",
     choices: PROJECT_KINDS.map((value) => ({ name: value, value }))
   });
@@ -584,7 +640,7 @@ async function runAdd(kind, name, options) {
       break;
     }
     case "node-app": {
-      addNodeApp(workspaceRoot, resolvedName, stack);
+      addNodeApp(workspaceRoot, resolvedName, stack, options.framework);
       break;
     }
     case "node-function-app": {
@@ -624,6 +680,11 @@ async function runAdd(kind, name, options) {
       addPythonInternalLib(workspaceRoot, resolvedName);
       break;
     }
+    case "python-vendor": {
+      await addPythonVendor(workspaceRoot, resolvedName, options, kindProvided);
+      syncProjectReferences(workspaceRoot);
+      return;
+    }
     default: {
       const exhaustive = resolvedKind;
       throw new Error(`Unknown project kind '${exhaustive}'. Expected one of: ${PROJECT_KINDS.join(", ")}.`);
@@ -653,7 +714,7 @@ function markPrivate(manifestPath) {
 
 // src/commands/interactive.ts
 var import_node_path10 = require("path");
-var import_prompts6 = require("@inquirer/prompts");
+var import_prompts7 = require("@inquirer/prompts");
 
 // src/commands/new.ts
 var import_node_path9 = require("path");
@@ -730,15 +791,13 @@ var ROOT_SCRIPTS = {
   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 };
+  const scripts = stack.linter === "oxlint" ? {
+    ...ROOT_SCRIPTS,
+    lint: "oxlint",
+    format: "oxfmt -c oxfmt.config.mts .",
+    "format:check": "oxfmt -c oxfmt.config.mts --check ."
+  } : { ...ROOT_SCRIPTS };
+  return { ...scripts, "python:install": `${PYTHON_INSTALL_GUARD} && ${PYTHON_WORKSPACE_INSTALL_GUARD}` };
 }
 function generatorDefaults(stack) {
   const shared = { linter: stack.linter === "oxlint" ? "none" : "eslint", unitTestRunner: stack.testRunner };
@@ -1142,6 +1201,9 @@ function applyOverlay(workspaceRoot, options) {
 }
 
 // src/commands/new.ts
+function nxCloudProviderValue(ci) {
+  return ci === "azure" ? "azure" : "github";
+}
 async function resolveStack(options) {
   const fromFlags = { linter: options.linter, testRunner: options.testRunner };
   const complete = Boolean(fromFlags.linter && fromFlags.testRunner);
@@ -1190,6 +1252,7 @@ async function runNew(name, 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);
+  const nxCloud = options.nxCloud ?? (options.yes ? false : await promptNxCloud());
   logger.step(`Creating Nx workspace '${workspaceName}' (preset: ts)`);
   runNpx([
     "--yes",
@@ -1197,7 +1260,7 @@ async function runNew(name, options) {
     workspaceName,
     "--preset=ts",
     "--pm=npm",
-    "--nxCloud=skip",
+    nxCloud ? `--nxCloud=${nxCloudProviderValue(ci)}` : "--nxCloud=skip",
     "--no-interactive"
   ], process.cwd());
   const workspaceRoot = (0, import_node_path9.join)(process.cwd(), workspaceName);
@@ -1222,7 +1285,7 @@ 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)({
+  const action = await (0, import_prompts7.select)({
     message: "What would you like to do?",
     choices: inWorkspace ? [addChoice, newChoice] : [newChoice, addChoice]
   });
@@ -1290,7 +1353,7 @@ function runUpgrade(workspaceRoot, options) {
 // src/cli.ts
 function readVersion() {
   try {
-    const package_ = JSON.parse((0, import_node_fs3.readFileSync)((0, import_node_path12.join)(__dirname, "..", "package.json"), "utf8"));
+    const package_ = JSON.parse((0, import_node_fs4.readFileSync)((0, import_node_path12.join)(__dirname, "..", "package.json"), "utf8"));
     return package_.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -1299,13 +1362,13 @@ function readVersion() {
 function buildProgram() {
   const program = new import_commander.Command();
   program.name("mnci").description("MoNecromanCI \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) => {
+  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").option("--nx-cloud", "connect the workspace to Nx Cloud (remote caching + CI insights)").action(async (name, options) => {
     await runNew(name, options);
   });
   program.command("upgrade").description("Re-apply the latest MoNecromanCI overlay to this workspace (release config, pipeline, npmrc, commitlint, husky hook, curated scripts)").option("--scope <scope>", "npm scope for publishable packages (overrides the persisted value)").option("--registry <kind>", "azure-artifacts | npm (overrides the persisted value)").option("--organization <name>", "Azure DevOps organization").option("--project <name>", "Azure DevOps project").option("--artifacts-feed <name>", "Azure Artifacts feed").option("--agent <pool>", "CI build agent (overrides the persisted value)").option("--variable-group <name>", "Azure DevOps variable group holding the npm PAT").option("--ci <provider>", "CI provider: azure | github | both (overrides the persisted value)").option("--linter <linter>", "linter: eslint | oxlint (overrides the persisted value)").option("--test-runner <runner>", "unit-test runner: jest | vitest (overrides the persisted value)").action((options) => {
     runUpgrade(process.cwd(), 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) => {
+  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>)").option("--framework <framework>", "node-app only: express | fastify | koa | nest | none (default: none)").option("--lib <name>", "python-vendor only: the internal Python library (libs/<name>) to vendor into <name>").action(async (kind, name, options) => {
     await runAdd(kind, name, options);
   });
   program.action(async () => {