@mnci/cli 1.6.0 → 1.8.0

package/dist/cli.js

@@ -35,13 +35,11 @@ __export(cli_exports, {
   main: () => main
 });
 module.exports = __toCommonJS(cli_exports);
-var import_node_fs3 = 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_node_path8 = require("path");
+var import_prompts4 = require("@inquirer/prompts");
 
 // src/nx.ts
 var import_cross_spawn = __toESM(require("cross-spawn"));
@@ -100,14 +98,13 @@ async function promptCi() {
     ]
   });
 }
-async function promptStack() {
-  const linter = await (0, import_prompts.select)({
-    message: "Linter",
-    choices: [
-      { name: "ESLint", value: "eslint" },
-      { name: "Oxlint", value: "oxlint" }
-    ]
+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 testRunner = await (0, import_prompts.select)({
     message: "Unit-test runner",
     choices: [
@@ -115,7 +112,7 @@ async function promptStack() {
       { name: "Vitest", value: "vitest" }
     ]
   });
-  return { linter, testRunner };
+  return { testRunner };
 }
 
 // src/util/fsx.ts
@@ -161,11 +158,14 @@ var logger = {
 // 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').`);
+    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
+// src/commands/add/go.ts
+var import_node_fs2 = require("fs");
 var import_node_path3 = require("path");
 
 // src/commands/add/shared.ts
@@ -180,7 +180,11 @@ function ensureAdmZip(workspaceRoot) {
     return;
   }
   logger.step("Installing the app packager (adm-zip)");
-  if (runShell("npm", ["install", "--save-dev", "adm-zip", "--no-audit", "--no-fund"], workspaceRoot) !== 0) {
+  if (runShell(
+    "npm",
+    ["install", "--save-dev", "adm-zip", "--no-audit", "--no-fund"],
+    workspaceRoot
+  ) !== 0) {
     throw new Error("npm install of adm-zip failed");
   }
 }
@@ -193,10 +197,179 @@ 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 } } }));
+  writeFileEnsured(
+    manifestPath,
+    toJson({ ...manifest, nx: { ...nx, targets: { ...targets, ...newTargets } } })
+  );
+}
+
+// src/commands/add/go.ts
+function ensureGo(workspaceRoot) {
+  if (runShell("go", ["version"], workspaceRoot) !== 0) {
+    throw new Error("Go not found. Install Go 1.21+ first: https://go.dev/dl/");
+  }
+}
+function warnIfNoGolangciLint(workspaceRoot) {
+  if (runShell("golangci-lint", ["--version"], workspaceRoot) !== 0) {
+    logger.warn(
+      "golangci-lint not found \u2014 the generated lint target needs it. Install: https://golangci-lint.run/welcome/install/"
+    );
+  }
+}
+function nxGoPluginSpec() {
+  return process.env.MNCI_NX_GO_SPEC ?? "@nx-go/nx-go";
+}
+function ensureNxGoPlugin(workspaceRoot) {
+  if (hasPlugin(workspaceRoot, "@nx-go/nx-go")) {
+    return;
+  }
+  const spec = nxGoPluginSpec();
+  logger.step(`Installing the Go toolchain plugin (${spec})`);
+  if (runShell("npm", ["install", "--save-dev", spec, "--no-audit", "--no-fund"], workspaceRoot) !== 0) {
+    throw new Error("npm install of @nx-go/nx-go failed");
+  }
+}
+function ensureGoModule(workspaceRoot) {
+  if (fileExists((0, import_node_path3.join)(workspaceRoot, "go.mod"))) {
+    return;
+  }
+  logger.step("Bootstrapping the workspace Go module (single root go.mod)");
+  runNx(["g", "@nx-go/nx-go:init", "--no-interactive"], workspaceRoot);
+  runNx(["g", "@nx-go/nx-go:convert-to-one-mod", "--no-interactive"], workspaceRoot);
+}
+function goModulePath(workspaceRoot) {
+  try {
+    const contents = (0, import_node_fs2.readFileSync)((0, import_node_path3.join)(workspaceRoot, "go.mod"), "utf8");
+    return /^module\s+(\S+)/m.exec(contents)?.[1];
+  } catch {
+    return void 0;
+  }
+}
+function addProjectJsonTargets(projectJsonPath, newTargets) {
+  const project = readJson(projectJsonPath);
+  const targets = project.targets ?? {};
+  writeFileEnsured(projectJsonPath, toJson({ ...project, targets: { ...targets, ...newTargets } }));
+}
+function goTestTarget() {
+  return { executor: "@nx-go/nx-go:test" };
+}
+function goLintTarget() {
+  return { executor: "@nx-go/nx-go:lint", options: { linter: "golangci-lint", args: ["run"] } };
+}
+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}` }
+  };
+}
+function goPackageTarget(tag, name) {
+  const zip = `dist/drop/${tag}-${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('dist/apps/${name}');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 prepareGo(workspaceRoot) {
+  ensureGo(workspaceRoot);
+  warnIfNoGolangciLint(workspaceRoot);
+  ensureNxGoPlugin(workspaceRoot);
+  ensureGoModule(workspaceRoot);
+}
+function addGoApp(workspaceRoot, name) {
+  prepareGo(workspaceRoot);
+  ensureAdmZip(workspaceRoot);
+  runNx(
+    [
+      "g",
+      "@nx-go/nx-go:application",
+      `apps/${name}`,
+      `--name=${name}`,
+      "--tags=type:go-app",
+      "--no-interactive"
+    ],
+    workspaceRoot
+  );
+  addProjectJsonTargets((0, import_node_path3.join)(workspaceRoot, "apps", name, "project.json"), {
+    build: goBuildTarget(name),
+    test: goTestTarget(),
+    lint: goLintTarget(),
+    package: goPackageTarget("go-app", name)
+  });
+}
+function addGoFunctionApp(workspaceRoot, name) {
+  prepareGo(workspaceRoot);
+  ensureAdmZip(workspaceRoot);
+  runNx(
+    [
+      "g",
+      "@nx-go/nx-go:application",
+      `apps/${name}`,
+      `--name=${name}`,
+      "--tags=type:go-function-app",
+      "--no-interactive"
+    ],
+    workspaceRoot
+  );
+  addProjectJsonTargets((0, import_node_path3.join)(workspaceRoot, "apps", name, "project.json"), {
+    build: goBuildTarget(name),
+    test: goTestTarget(),
+    lint: goLintTarget(),
+    package: goPackageTarget("go-function-app", name)
+  });
+}
+function addGoLib(workspaceRoot, name) {
+  prepareGo(workspaceRoot);
+  runNx(
+    [
+      "g",
+      "@nx-go/nx-go:library",
+      `packages/${name}`,
+      `--name=${name}`,
+      "--tags=type:go-lib",
+      "--no-interactive"
+    ],
+    workspaceRoot
+  );
+  addProjectJsonTargets((0, import_node_path3.join)(workspaceRoot, "packages", name, "project.json"), {
+    test: goTestTarget(),
+    lint: goLintTarget()
+  });
+  const module2 = goModulePath(workspaceRoot);
+  if (module2) {
+    logger.step(`Import it as ${module2}/packages/${name}`);
+  }
+}
+function addGoInternalLib(workspaceRoot, name) {
+  prepareGo(workspaceRoot);
+  runNx(
+    [
+      "g",
+      "@nx-go/nx-go:library",
+      `libs/${name}`,
+      `--name=${name}`,
+      "--tags=type:go-internal-lib",
+      "--no-interactive"
+    ],
+    workspaceRoot
+  );
+  addProjectJsonTargets((0, import_node_path3.join)(workspaceRoot, "libs", name, "project.json"), {
+    test: goTestTarget(),
+    lint: goLintTarget()
+  });
+  const module2 = goModulePath(workspaceRoot);
+  if (module2) {
+    logger.step(`Import it as ${module2}/libs/${name}`);
+  }
 }
 
 // src/commands/add/node.ts
+var import_node_path4 = require("path");
 function ensurePlugin(workspaceRoot, packageName) {
   if (hasPlugin(workspaceRoot, packageName)) {
     return;
@@ -206,17 +379,20 @@ function ensurePlugin(workspaceRoot, packageName) {
 }
 function runNodeApp(workspaceRoot, name, stack, framework) {
   ensurePlugin(workspaceRoot, "@nx/node");
-  runNx([
-    "g",
-    "@nx/node:application",
-    `apps/${name}`,
-    "--bundler=esbuild",
-    `--unitTestRunner=${stack.testRunner}`,
-    `--linter=${stack.linter}`,
-    "--e2eTestRunner=none",
-    `--framework=${framework}`,
-    "--no-interactive"
-  ], workspaceRoot);
+  runNx(
+    [
+      "g",
+      "@nx/node:application",
+      `apps/${name}`,
+      "--bundler=esbuild",
+      `--unitTestRunner=${stack.testRunner}`,
+      "--linter=eslint",
+      "--e2eTestRunner=none",
+      `--framework=${framework}`,
+      "--no-interactive"
+    ],
+    workspaceRoot
+  );
 }
 function nodeAppPackageTarget(name) {
   const zip = `dist/drop/node-app-${name}.zip`;
@@ -232,7 +408,9 @@ function nodeAppPackageTarget(name) {
 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) });
+  addNxTargets((0, import_node_path4.join)(workspaceRoot, "apps", name, "package.json"), {
+    package: nodeAppPackageTarget(name)
+  });
 }
 function ensureAzureFunctionsPackage(workspaceRoot) {
   if (hasPlugin(workspaceRoot, "@azure/functions")) {
@@ -283,15 +461,20 @@ describe('buildGreeting', () => {
 })
 `;
 function repairNodeFunctionAppManifest(nodeFunctionAppRoot, workspaceRoot) {
-  const manifestPath = (0, import_node_path3.join)(nodeFunctionAppRoot, "package.json");
+  const manifestPath = (0, import_node_path4.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 azureFunctionsVersion = readJson(
+    (0, import_node_path4.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}` }
-  }));
+  writeFileEnsured(
+    manifestPath,
+    toJson({
+      ...manifest,
+      main: "main.js",
+      dependencies: { ...dependencies, "@azure/functions": `^${azureFunctionsVersion}` }
+    })
+  );
 }
 function nodeFunctionAppPackageTarget(name) {
   const zip = `dist/drop/node-function-app-${name}.zip`;
@@ -308,19 +491,27 @@ function nodeFunctionAppPackageTarget(name) {
 function addNodeFunctionApp(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);
-  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);
+  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);
+  writeFileEnsured(
+    (0, import_node_path4.join)(nodeFunctionAppRoot, "src/functions/greeting.ts"),
+    NODE_FUNCTION_APP_GREETING
+  );
+  writeFileEnsured(
+    (0, import_node_path4.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);
   repairNodeFunctionAppManifest(nodeFunctionAppRoot, workspaceRoot);
   ensureAdmZip(workspaceRoot);
-  addNxTargets((0, import_node_path3.join)(nodeFunctionAppRoot, "package.json"), { package: nodeFunctionAppPackageTarget(name) });
+  addNxTargets((0, import_node_path4.join)(nodeFunctionAppRoot, "package.json"), {
+    package: nodeFunctionAppPackageTarget(name)
+  });
 }
 
 // src/commands/add/npmLib.ts
-var import_node_path4 = require("path");
+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';
@@ -363,21 +554,25 @@ export default [
 `;
 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);
-  }
+  runNx(
+    [
+      "g",
+      "@nx/js:lib",
+      `packages/${name}`,
+      "--publishable",
+      `--importPath=${scope}/${name}`,
+      "--bundler=rollup",
+      `--unitTestRunner=${stack.testRunner}`,
+      "--linter=eslint",
+      "--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
+  );
 }
 function markPublic(manifestPath) {
   const manifest = readJson(manifestPath);
@@ -385,11 +580,14 @@ function markPublic(manifestPath) {
 }
 
 // src/commands/add/python.ts
-var import_node_path5 = require("path");
+var import_node_fs3 = require("fs");
+var import_node_path6 = 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/");
+    throw new Error(
+      "Python not found. Install Python 3.9+ first: https://www.python.org/downloads/"
+    );
   }
 }
 function pythonPipPluginSpec() {
@@ -412,7 +610,7 @@ pytest
 pip-audit
 `;
 function ensureRequirementsDev(workspaceRoot) {
-  const requirementsDevPath = (0, import_node_path5.join)(workspaceRoot, "requirements-dev.txt");
+  const requirementsDevPath = (0, import_node_path6.join)(workspaceRoot, "requirements-dev.txt");
   if (!fileExists(requirementsDevPath)) {
     writeFileEnsured(requirementsDevPath, PYTHON_REQUIREMENTS_DEV);
   }
@@ -420,7 +618,7 @@ function ensureRequirementsDev(workspaceRoot) {
 function pythonModuleDirectory(name) {
   return name.replaceAll("-", "_");
 }
-function addProjectJsonTargets(projectJsonPath, newTargets) {
+function addProjectJsonTargets2(projectJsonPath, newTargets) {
   const project = readJson(projectJsonPath);
   const targets = project.targets ?? {};
   writeFileEnsured(projectJsonPath, toJson({ ...project, targets: { ...targets, ...newTargets } }));
@@ -452,34 +650,129 @@ function addPythonApp(workspaceRoot, name) {
   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) });
+  runNx(
+    ["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)
+  });
 }
 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);
+  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) });
+  addProjectJsonTargets2((0, import_node_path6.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);
+  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);
+  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_path6.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_path6.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_path6.join)(workspaceRoot, consumerDirectory, consumer, "pyproject.toml");
+  const pyprojectToml = (0, import_node_fs3.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_path6 = require("path");
+var import_node_fs4 = require("fs");
+var import_node_path7 = require("path");
 function ensurePlugin2(workspaceRoot, packageName) {
   if (hasPlugin(workspaceRoot, packageName)) {
     return;
@@ -502,26 +795,35 @@ function reactAppTargets(name) {
       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}` }
+      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(";");
+  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}"` }
+    outputs: REACT_ENVIRONMENTS.map(
+      // eslint-disable-next-line unicorn/no-incorrect-template-string-interpolation
+      (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");
+  const gitignorePath = (0, import_node_path7.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");
+  const current = (0, import_node_fs4.readFileSync)(gitignorePath, "utf8");
   if (current.includes(marker)) {
     return;
   }
@@ -533,24 +835,27 @@ ${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);
+  runNx(
+    [
+      "g",
+      "@nx/react:app",
+      `apps/${name}`,
+      "--bundler=vite",
+      `--unitTestRunner=${stack.testRunner}`,
+      "--linter=eslint",
+      "--style=css",
+      "--e2eTestRunner=none",
+      "--no-interactive"
+    ],
+    workspaceRoot
+  );
   ensureAdmZip(workspaceRoot);
-  const reactAppRoot = (0, import_node_path6.join)(workspaceRoot, "apps", name);
+  const reactAppRoot = (0, import_node_path7.join)(workspaceRoot, "apps", name);
   for (const environment of REACT_ENVIRONMENTS) {
-    writeFileEnsured((0, import_node_path6.join)(reactAppRoot, `.env.${environment}`), reactEnvironmentFile(environment));
+    writeFileEnsured((0, import_node_path7.join)(reactAppRoot, `.env.${environment}`), reactEnvironmentFile(environment));
   }
   allowEnvFiles(workspaceRoot);
-  addNxTargets((0, import_node_path6.join)(reactAppRoot, "package.json"), reactAppTargets(name));
+  addNxTargets((0, import_node_path7.join)(reactAppRoot, "package.json"), reactAppTargets(name));
 }
 
 // src/commands/add.ts
@@ -563,16 +868,21 @@ var PROJECT_KINDS = [
   "python-app",
   "python-function-app",
   "python-lib",
-  "python-internal-lib"
+  "python-internal-lib",
+  "python-vendor",
+  "go-app",
+  "go-function-app",
+  "go-lib",
+  "go-internal-lib"
 ];
 async function runAdd(kind, name, options) {
   const workspaceRoot = process.cwd();
-  if (!fileExists((0, import_node_path7.join)(workspaceRoot, "nx.json"))) {
+  if (!fileExists((0, import_node_path8.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)({
+  const resolvedKind = kind ?? await (0, import_prompts4.select)({
     message: "What kind of project?",
     choices: PROJECT_KINDS.map((value) => ({ name: value, value }))
   });
@@ -596,16 +906,19 @@ async function runAdd(kind, name, options) {
       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"));
+      runNx(
+        [
+          "g",
+          "@nx/js:lib",
+          `libs/${resolvedName}`,
+          "--bundler=tsc",
+          `--unitTestRunner=${stack.testRunner}`,
+          "--linter=eslint",
+          "--no-interactive"
+        ],
+        workspaceRoot
+      );
+      markPrivate((0, import_node_path8.join)(workspaceRoot, "libs", resolvedName, "package.json"));
       break;
     }
     case "python-app": {
@@ -624,9 +937,32 @@ async function runAdd(kind, name, options) {
       addPythonInternalLib(workspaceRoot, resolvedName);
       break;
     }
+    case "go-app": {
+      addGoApp(workspaceRoot, resolvedName);
+      break;
+    }
+    case "go-function-app": {
+      addGoFunctionApp(workspaceRoot, resolvedName);
+      break;
+    }
+    case "go-lib": {
+      addGoLib(workspaceRoot, resolvedName);
+      break;
+    }
+    case "go-internal-lib": {
+      addGoInternalLib(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(", ")}.`);
+      throw new Error(
+        `Unknown project kind '${exhaustive}'. Expected one of: ${PROJECT_KINDS.join(", ")}.`
+      );
     }
   }
   syncProjectReferences(workspaceRoot);
@@ -635,14 +971,17 @@ async function runAdd(kind, name, options) {
 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.");
+    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 nxJson = readJson(
+    (0, import_node_path8.join)(workspaceRoot, "nx.json")
+  );
   const stack = nxJson.mnci?.stack;
   return {
-    linter: stack?.linter === "oxlint" ? "none" : "eslint",
     testRunner: stack?.testRunner === "vitest" ? "vitest" : "jest"
   };
 }
@@ -652,15 +991,16 @@ function markPrivate(manifestPath) {
 }
 
 // src/commands/interactive.ts
-var import_node_path10 = require("path");
-var import_prompts6 = require("@inquirer/prompts");
+var import_node_path12 = require("path");
+var import_prompts7 = require("@inquirer/prompts");
 
 // src/commands/new.ts
-var import_node_path9 = require("path");
+var import_node_path10 = require("path");
 
 // src/overlay.ts
-var import_node_path8 = require("path");
-var DEFAULT_STACK = { linter: "eslint", testRunner: "jest" };
+var import_node_path9 = 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"
@@ -720,6 +1060,77 @@ var COMMITLINT_CONFIG = `export default { extends: ['@commitlint/config-conventi
 `;
 var COMMIT_MSG_HOOK = `npx --no -- commitlint --edit "$1"
 `;
+var PRETTIER_CONFIG = `{
+  "semi": false,
+  "singleQuote": true,
+  "trailingComma": "es5",
+  "arrowParens": "avoid",
+  "printWidth": 100,
+  "tabWidth": 2,
+  "useTabs": false
+}
+`;
+var PRETTIER_IGNORE = `node_modules
+dist
+dist-dev
+dist-uat
+dist-prod
+coverage
+.next
+out
+.nx
+tmp
+package-lock.json
+*.lock
+`;
+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" }
+      ],
+      settings: {
+        "eslint.validate": [
+          "javascript",
+          "javascriptreact",
+          "typescript",
+          "typescriptreact",
+          "json",
+          "jsonc",
+          "markdown",
+          "yaml"
+        ],
+        "editor.codeActionsOnSave": {
+          "source.fixAll.eslint": "explicit"
+        },
+        "editor.defaultFormatter": "esbenp.prettier-vscode",
+        "editor.formatOnSave": true,
+        "[json]": {
+          "editor.defaultFormatter": "esbenp.prettier-vscode"
+        },
+        "[jsonc]": {
+          "editor.defaultFormatter": "esbenp.prettier-vscode"
+        },
+        "[yaml]": {
+          "editor.defaultFormatter": "esbenp.prettier-vscode"
+        }
+      },
+      extensions: {
+        recommendations: [
+          "dbaeumer.vscode-eslint",
+          "esbenp.prettier-vscode",
+          "nrwl.angular-console",
+          "firsttris.vscode-jest-runner"
+        ]
+      }
+    },
+    null,
+    2
+  );
+}
 var ROOT_SCRIPTS = {
   build: "nx run-many -t build",
   lint: "nx run-many -t lint",
@@ -729,19 +1140,19 @@ var ROOT_SCRIPTS = {
   "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 rootScripts() {
+  return {
+    ...ROOT_SCRIPTS,
+    format: "prettier --write .",
+    "format:check": "prettier --check .",
+    "python:install": `${PYTHON_INSTALL_GUARD} && ${PYTHON_WORKSPACE_INSTALL_GUARD}`
+  };
 }
 function generatorDefaults(stack) {
-  const shared = { linter: stack.linter === "oxlint" ? "none" : "eslint", unitTestRunner: stack.testRunner };
+  const shared = {
+    linter: "eslint",
+    unitTestRunner: stack.testRunner
+  };
   return {
     "@nx/react:application": shared,
     "@nx/react:library": shared,
@@ -755,40 +1166,13 @@ function mnciConfig(options) {
     agent: options.agent,
     variableGroup: options.variableGroup,
     ci: options.ci,
-    stack: { linter: options.stack.linter, testRunner: options.stack.testRunner }
+    stack: { testRunner: options.stack.testRunner }
   };
 }
 function readMnciConfig(workspaceRoot) {
-  const nxJson = readJson((0, import_node_path8.join)(workspaceRoot, "nx.json"));
+  const nxJson = readJson((0, import_node_path9.join)(workspaceRoot, "nx.json"));
   return nxJson.mnci ?? {};
 }
-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/`;
@@ -798,6 +1182,11 @@ function pythonPublishUrl(registry) {
 var PYTHON_INSTALL_GUARD = `node -e "if(!require('node:fs').existsSync('requirements-dev.txt')){console.log('No Python projects - skipping.');process.exit(0)}const py=process.platform==='win32'?'python':'python3';process.exit(require('node:child_process').spawnSync(py+' -m pip install -r requirements-dev.txt',{stdio:'inherit',shell:true}).status ?? 1)"`;
 var PYTHON_WORKSPACE_INSTALL_GUARD = `node -e "const fs=require('node:fs'),path=require('node:path');const editableDirs=[...fs.globSync('apps/*/pyproject.toml'),...fs.globSync('python-packages/*/pyproject.toml'),...fs.globSync('libs/*/pyproject.toml')].map((p)=>path.dirname(p));const requirementsFiles=fs.globSync('apps/*/requirements.txt');if(editableDirs.length===0&&requirementsFiles.length===0){console.log('No Python projects - skipping.');process.exit(0)}const args=['-m','pip','install','--quiet',...editableDirs.flatMap((d)=>['-e',d]),...requirementsFiles.flatMap((f)=>['-r',f])];const py=process.platform==='win32'?'python':'python3';process.exit(require('node:child_process').spawnSync(py,args,{stdio:'inherit'}).status ?? 1)"`;
 var PIP_AUDIT_GUARD = `node -e "if(!require('node:fs').existsSync('requirements-dev.txt')){console.log('No Python projects - skipping.');process.exit(0)}const py=process.platform==='win32'?'python':'python3';require('node:child_process').spawnSync(py,['-m','pip_audit'],{stdio:'inherit'});process.exit(0)"`;
+var GO_MODULE_DOWNLOAD_GUARD = `node -e "if(!require('node:fs').existsSync('go.mod')){console.log('No Go projects - skipping.');process.exit(0)}process.exit(require('node:child_process').spawnSync('go',['mod','download'],{stdio:'inherit'}).status ?? 1)"`;
+var GOLANGCI_LINT_INSTALL_GUARD = `node -e "const fs=require('node:fs'),cp=require('node:child_process');if(!fs.existsSync('go.mod')){console.log('No Go projects - skipping.');process.exit(0)}if(cp.spawnSync('golangci-lint',['--version'],{stdio:'ignore'}).status===0){console.log('golangci-lint already installed - skipping.');process.exit(0)}process.exit(cp.spawnSync('go',['install','github.com/golangci/golangci-lint/v2/cmd/golangci-lint@latest'],{stdio:'inherit'}).status ?? 1)"`;
+var GO_TOOL_PATH_PRELUDE = `const fs=require('node:fs'),cp=require('node:child_process');if(!fs.existsSync('go.mod')){console.log('No Go projects - skipping.');process.exit(0)}const r=cp.spawnSync('go',['env','GOPATH'],{encoding:'utf8'});if(r.status!==0){console.log('Could not resolve GOPATH - skipping.');process.exit(0)}const bin=require('node:path').join(r.stdout.trim(),'bin');`;
+var GO_TOOL_PATH_AZURE = `node -e "${GO_TOOL_PATH_PRELUDE}console.log('##vso[task.prependpath]'+bin)"`;
+var GO_TOOL_PATH_GITHUB = `node -e "${GO_TOOL_PATH_PRELUDE}if(!process.env.GITHUB_PATH){console.log('Not running in GitHub Actions - skipping.');process.exit(0)}fs.appendFileSync(process.env.GITHUB_PATH,bin+${String.raw`'\n'`})"`;
 var NPM_AUDIT_STEP = "npm audit --audit-level=high || echo npm audit found vulnerabilities, see log above - non-blocking, run npm audit locally to inspect";
 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) {
@@ -897,6 +1286,22 @@ steps:
   - script: ${PIP_AUDIT_GUARD}
     displayName: pip-audit (non-blocking)
 
+  # Go, if the workspace has any: hosted agents ship the toolchain, so only
+  # the module cache and the linter need seeding. Both guards skip cleanly on
+  # a workspace with no root go.mod.
+  - script: ${GO_MODULE_DOWNLOAD_GUARD}
+    displayName: Download Go module dependencies
+
+  # golangci-lint is what the generated Go lint target actually runs (the
+  # plugin's own default is 'go fmt', which only reformats). 'go install'
+  # drops it in GOPATH/bin, which is not on PATH by default on a hosted
+  # agent \u2014 so prepend it for every later step in the job.
+  - script: ${GOLANGCI_LINT_INSTALL_GUARD}
+    displayName: Install golangci-lint
+
+  - script: ${GO_TOOL_PATH_AZURE}
+    displayName: Add Go tool bin to PATH
+
   # 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
@@ -960,7 +1365,10 @@ steps:
 }
 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} }}`);
+  const [npmAuthName, npmAuthValue] = npmAuthEnvVariable(
+    registryKind,
+    (name) => `\${{ secrets.${name} }}`
+  );
   return `name: CI
 
 # Generated by MoNecromanCI. Deliberately thin: Nx builds, 'nx release'
@@ -1030,6 +1438,22 @@ jobs:
       - run: ${PIP_AUDIT_GUARD}
         name: pip-audit (non-blocking)
 
+      # Go, if the workspace has any: hosted runners ship the toolchain, so
+      # only the module cache and the linter need seeding. Both guards skip
+      # cleanly on a workspace with no root go.mod.
+      - run: ${GO_MODULE_DOWNLOAD_GUARD}
+        name: Download Go module dependencies
+
+      # golangci-lint is what the generated Go lint target actually runs (the
+      # plugin's own default is 'go fmt', which only reformats). 'go install'
+      # drops it in GOPATH/bin, which is not on PATH by default on a hosted
+      # runner \u2014 so publish it for every later step in the job.
+      - run: ${GOLANGCI_LINT_INSTALL_GUARD}
+        name: Install golangci-lint
+
+      - run: ${GO_TOOL_PATH_GITHUB}
+        name: Add Go tool bin to PATH
+
       # 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
@@ -1111,50 +1535,70 @@ updates:
       interval: weekly
 `;
 function applyOverlay(workspaceRoot, options) {
-  const nxJsonPath = (0, import_node_path8.join)(workspaceRoot, "nx.json");
+  const nxJsonPath = (0, import_node_path9.join)(workspaceRoot, "nx.json");
   const nxJson = readJson(nxJsonPath);
-  const generators = { ...nxJson.generators, ...generatorDefaults(options.stack) };
+  const generators = {
+    ...nxJson.generators,
+    ...generatorDefaults(options.stack)
+  };
   const sync = { ...nxJson.sync, ...SYNC_CONFIG };
   const mnci = { ...nxJson.mnci, ...mnciConfig(options) };
   writeFileEnsured(nxJsonPath, toJson({ ...withReleaseConfig(nxJson), generators, sync, mnci }));
-  const manifestPath = (0, import_node_path8.join)(workspaceRoot, "package.json");
+  const manifestPath = (0, import_node_path9.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");
+  const scripts = {
+    ...manifest.scripts,
+    ...rootScripts()
+  };
+  const devDeps = {
+    ...manifest.devDependencies,
+    ...TS_COMPILER_DEPENDENCIES,
+    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(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);
-  }
+  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_path9.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_path8.join)(workspaceRoot, "azure-pipelines.yml"), azurePipelinesYaml(options.agent, options.variableGroup, publishUrl, options.registry.kind));
+    writeFileEnsured(
+      (0, import_node_path9.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));
-    writeFileEnsured((0, import_node_path8.join)(workspaceRoot, ".github/dependabot.yml"), DEPENDABOT_CONFIG);
+    writeFileEnsured(
+      (0, import_node_path9.join)(workspaceRoot, ".github/workflows/ci.yml"),
+      githubActionsYaml(options.agent, publishUrl, options.registry.kind)
+    );
+    writeFileEnsured((0, import_node_path9.join)(workspaceRoot, ".github/dependabot.yml"), DEPENDABOT_CONFIG);
   }
 }
 
 // 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);
-  if (complete || options.yes) {
+  if (options.testRunner || options.yes) {
     return {
-      linter: fromFlags.linter ?? DEFAULT_STACK.linter,
-      testRunner: fromFlags.testRunner ?? DEFAULT_STACK.testRunner
+      testRunner: options.testRunner ?? DEFAULT_STACK.testRunner
     };
   }
   const prompted = await promptStack();
   return {
-    linter: fromFlags.linter ?? prompted.linter,
-    testRunner: fromFlags.testRunner ?? prompted.testRunner
+    testRunner: prompted.testRunner
   };
 }
 var CI_PROVIDERS = /* @__PURE__ */ new Set(["azure", "github", "both"]);
@@ -1187,52 +1631,52 @@ async function runNew(name, options) {
   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 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",
-    "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);
+  runNpx(
+    [
+      "--yes",
+      "create-nx-workspace@latest",
+      workspaceName,
+      "--preset=ts",
+      "--pm=npm",
+      nxCloud ? `--nxCloud=${nxCloudProviderValue(ci)}` : "--nxCloud=skip",
+      "--no-interactive"
+    ],
+    process.cwd()
+  );
+  const workspaceRoot = (0, import_node_path10.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)");
+  const installStatus = runShell(
+    "npm",
+    ["install", "--save-dev", "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("  mnci 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(
+    "  mnci 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/commands/upgrade.ts
 var import_node_path11 = require("path");
 function resolveRegistry2(options, persisted) {
@@ -1242,7 +1686,9 @@ function resolveRegistry2(options, persisted) {
     const project = options.project ?? persistedAzure?.project;
     const artifactsFeed = options.artifactsFeed ?? persistedAzure?.artifactsFeed;
     if (!organization || !project || !artifactsFeed) {
-      throw new Error("Azure Artifacts registry needs --organization, --project and --artifacts-feed (none found in nx.json's persisted config either).");
+      throw new Error(
+        "Azure Artifacts registry needs --organization, --project and --artifacts-feed (none found in nx.json's persisted config either)."
+      );
     }
     return { kind: "azure-artifacts", organization, project, artifactsFeed };
   }
@@ -1252,7 +1698,9 @@ function resolveRegistry2(options, persisted) {
   if (persisted) {
     return persisted;
   }
-  throw new Error("No registry found in nx.json's persisted config. Pass --registry npm or --registry azure-artifacts (with --organization/--project/--artifacts-feed).");
+  throw new Error(
+    "No registry found in nx.json's persisted config. Pass --registry npm or --registry azure-artifacts (with --organization/--project/--artifacts-feed)."
+  );
 }
 function resolveOverlayOptions(options, persisted) {
   const scope = options.scope ?? persisted.scope;
@@ -1262,52 +1710,157 @@ function resolveOverlayOptions(options, persisted) {
   const registry = resolveRegistry2(options, persisted.registry);
   const ci = options.ci ?? persisted.ci;
   if (!ci) {
-    throw new Error("No CI provider found in nx.json's persisted config. Pass --ci azure|github|both explicitly.");
+    throw new Error(
+      "No CI provider found in nx.json's persisted config. Pass --ci azure|github|both explicitly."
+    );
   }
   const agent = options.agent ?? persisted.agent;
   if (!agent) {
-    throw new Error("No CI build agent found in nx.json's persisted config. Pass --agent explicitly.");
+    throw new Error(
+      "No CI build agent found in nx.json's persisted config. Pass --agent explicitly."
+    );
   }
   const variableGroup = options.variableGroup ?? persisted.variableGroup ?? "Build";
-  const linter = options.linter ?? persisted.stack?.linter;
   const testRunner = options.testRunner ?? persisted.stack?.testRunner;
-  if (!linter || !testRunner) {
-    throw new Error("No stack (linter/test runner) found in nx.json's persisted config. Pass --linter and --test-runner explicitly.");
+  if (!testRunner) {
+    throw new Error(
+      "No testRunner found in nx.json's persisted config. Pass --test-runner explicitly."
+    );
   }
-  return { scope, registry, agent, variableGroup, ci, stack: { linter, testRunner } };
+  return { scope, registry, agent, variableGroup, ci, stack: { testRunner } };
 }
 function runUpgrade(workspaceRoot, options) {
   if (!fileExists((0, import_node_path11.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.`);
+    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.`
+    );
   }
   const persisted = readMnciConfig(workspaceRoot);
   const resolved = resolveOverlayOptions(options, persisted);
-  logger.step("Re-applying the MoNecromanCI overlay (release config, .npmrc, commitlint, pipeline, stack)");
+  logger.step(
+    "Re-applying the MoNecromanCI overlay (release config, .npmrc, commitlint, pipeline, stack)"
+  );
   applyOverlay(workspaceRoot, resolved);
   logger.success("Done. Review the changes with `git diff` before committing.");
 }
 
-// src/cli.ts
-function readVersion() {
+// src/commands/interactive.ts
+async function runInteractive() {
+  const inWorkspace = fileExists((0, import_node_path12.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 = {
+    name: "Upgrade this workspace (re-apply the latest overlay)",
+    value: "upgrade"
+  };
+  const action = await (0, import_prompts7.select)({
+    message: "What would you like to do?",
+    choices: inWorkspace ? [addChoice, upgradeChoice, newChoice] : [newChoice, addChoice, upgradeChoice]
+  });
+  if (action === "new") {
+    await runNew(void 0, {});
+  } else if (action === "upgrade") {
+    runUpgrade(process.cwd(), {});
+  } else {
+    await runAdd(void 0, void 0, {});
+  }
+}
+
+// src/util/versionChecker.ts
+var import_node_fs5 = require("fs");
+var import_node_path13 = require("path");
+var import_cross_spawn2 = __toESM(require("cross-spawn"));
+var PACKAGE_NAME = "@mnci/cli";
+var REGISTRY_TIMEOUT_MS = 2e3;
+function checkForUpdate(currentVersion) {
+  try {
+    if (!process.stdout.isTTY) {
+      return;
+    }
+    setImmediate(() => {
+      try {
+        reportIfOutdated(currentVersion);
+      } catch {
+      }
+    });
+  } catch {
+  }
+}
+function reportIfOutdated(currentVersion) {
+  const result = import_cross_spawn2.default.sync("npm", ["view", PACKAGE_NAME, "version"], {
+    encoding: "utf8",
+    timeout: REGISTRY_TIMEOUT_MS,
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  if (result.error || result.status !== 0) {
+    return;
+  }
+  const latestVersion = (result.stdout ?? "").trim();
+  if (!latestVersion || !isNewerVersion(latestVersion, currentVersion)) {
+    return;
+  }
+  logger.info("");
+  logger.info(`A new version of ${PACKAGE_NAME} is available: ${latestVersion}`);
+  logger.info(`  Current version: ${currentVersion}`);
+  logger.info(`  Update with: npm install -g ${PACKAGE_NAME}@latest`);
+  logger.info("");
+}
+function isNewerVersion(candidate, current) {
+  const candidateParts = releaseTriple(candidate);
+  const currentParts = releaseTriple(current);
+  if (!candidateParts || !currentParts) {
+    return false;
+  }
+  for (const [index, candidatePart] of candidateParts.entries()) {
+    if (candidatePart !== currentParts[index]) {
+      return candidatePart > currentParts[index];
+    }
+  }
+  return false;
+}
+function releaseTriple(version) {
+  const match = /^(\d+)\.(\d+)\.(\d+)/.exec(version.trim());
+  return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : void 0;
+}
+function readCliVersion(packageDirectory) {
   try {
-    const package_ = JSON.parse((0, import_node_fs3.readFileSync)((0, import_node_path12.join)(__dirname, "..", "package.json"), "utf8"));
-    return package_.version ?? "0.0.0";
+    const manifestPath = (0, import_node_path13.join)(packageDirectory, "..", "package.json");
+    const manifest = JSON.parse((0, import_node_fs5.readFileSync)(manifestPath, "utf8"));
+    return manifest.version ?? "0.0.0";
   } catch {
     return "0.0.0";
   }
 }
-function buildProgram() {
+
+// src/cli.ts
+function buildProgram(cliVersion) {
   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.name("mnci").description("MoNecromanCI \u2014 a thin CLI over official Nx plugins").version(cliVersion, "-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("--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) => {
+  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(
+    "--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>)").option("--framework <framework>", "node-app only: express | fastify | koa | nest | none (default: none)").action(async (kind, name, options) => {
-    await runAdd(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 () => {
     await runInteractive();
   });
@@ -1315,7 +1868,15 @@ function buildProgram() {
 }
 async function main() {
   try {
-    await buildProgram().parseAsync(process.argv);
+    const cliVersion = readCliVersion(__dirname);
+    const program = buildProgram(cliVersion);
+    checkForUpdate(cliVersion);
+    const arguments_ = new Set(process.argv.slice(2));
+    const requestedVersionFlag = arguments_.has("-v") || arguments_.has("--version");
+    if (process.stdout.isTTY && !requestedVersionFlag) {
+      logger.info(`mnci v${cliVersion}`);
+    }
+    await program.parseAsync(process.argv);
   } catch (error) {
     logger.error(error instanceof Error ? error.message : String(error));
     process.exitCode = 1;