@mnci/cli 4.51.0 → 4.53.0

package/dist/cli.js

@@ -4805,11 +4805,11 @@ function addGoInternalLib(workspaceRoot, name) {
   }
 }
 
-// src/project-scaffolding/esm-conversion.use-case.ts
+// src/esm-conversion/esm-conversion.use-case.ts
 var import_node_fs19 = require("fs");
 var import_node_path18 = require("path");
 
-// src/project-scaffolding/esm-specifiers.algorithm.ts
+// src/esm-conversion/esm-specifiers.algorithm.ts
 var RELATIVE_SPECIFIER = /((?:\bfrom|\bimport)\s*)(['"])(\.{1,2}\/[^'"\n]*|\.{1,2})\2/g;
 var HAS_EXTENSION = /\.(?:[cm]?js|json|node)$/;
 function withJsSpecifiers(source, directories = []) {
@@ -4822,7 +4822,7 @@ function withJsSpecifiers(source, directories = []) {
   });
 }
 
-// src/project-scaffolding/esm-conversion.use-case.ts
+// src/esm-conversion/esm-conversion.use-case.ts
 var SAMPLE_DIRECTORIES = ["./hello"];
 var JEST_ANCHOR = "  moduleFileExtensions:";
 var JEST_MAPPER = String.raw`  moduleNameMapper: { '^(\\.{1,2}/.*)\\.js$': '$1' },`;
@@ -8360,11 +8360,26 @@ var import_node_child_process2 = require("child_process");
 var import_node_fs32 = require("fs");
 var import_node_path38 = require("path");
 
-// src/workspace-diagnostics/locate-stranded-release-tags.use-case.ts
+// src/release-tag-lineage/create-baseline-tags.use-case.ts
+function createBaselineTags(repositoryRoot, stranded) {
+  const result = { created: [], existing: [], failed: [] };
+  for (const entry of stranded) {
+    const present = runCapture("git", ["rev-parse", "--verify", "--quiet", `refs/tags/${entry.newTag}`], repositoryRoot);
+    if (present.status === 0) {
+      result.existing.push(entry.newTag);
+      continue;
+    }
+    const made = runCapture("git", ["tag", entry.newTag, `${entry.oldTag}^{commit}`], repositoryRoot);
+    (made.status === 0 ? result.created : result.failed).push(entry.newTag);
+  }
+  return result;
+}
+
+// src/release-tag-lineage/locate-stranded-release-tags.use-case.ts
 var import_node_fs31 = require("fs");
 var import_node_path37 = require("path");
 
-// src/workspace-diagnostics/stranded-release-tags.algorithm.ts
+// src/release-tag-lineage/stranded-release-tags.algorithm.ts
 function compareVersions2(left, right) {
   const a = left.split(".").map(Number);
   const b = right.split(".").map(Number);
@@ -8389,7 +8404,7 @@ function findStrandedReleaseTags(projects, tags) {
   return stranded;
 }
 
-// src/workspace-diagnostics/locate-stranded-release-tags.use-case.ts
+// src/release-tag-lineage/locate-stranded-release-tags.use-case.ts
 var MNCI_TAG_PATTERN = "{projectName}@{version}";
 function locateStrandedReleaseTags(workspaceRoot, tagPattern) {
   if (tagPattern !== void 0 && tagPattern !== MNCI_TAG_PATTERN) {
@@ -8403,6 +8418,17 @@ function locateStrandedReleaseTags(workspaceRoot, tagPattern) {
   return findStrandedReleaseTags(projects, listed.stdout.split(/\r?\n/).filter(Boolean));
 }
 
+// src/workspace-diagnostics/check-release-tags-resolve.use-case.ts
+function checkReleaseTagsResolve(workspaceRoot, nxJson) {
+  const stranded = locateStrandedReleaseTags(workspaceRoot, nxJson.release?.releaseTag?.pattern);
+  return {
+    check: "release tags resolve under each project's current name",
+    ok: stranded.length === 0,
+    detail: `${stranded.map((entry) => `${entry.project} has only ${entry.oldTag}`).join("; ")} - nx release finds no tag under the new name and would release from the disk version, a downgrade`,
+    remedy: `run \`mnci adopt --tags\` to create the baseline tag for each (${stranded.map((entry) => entry.newTag).join(", ")}) on the commit of its old tag, then push the tags`
+  };
+}
+
 // src/workspace-diagnostics/check-invariants.use-case.ts
 var SUPPORTED_ESLINT_MAJOR = ESLINT_VERSION.replace(/^\D*/, "").split(".", 1)[0];
 function toPosix2(path) {
@@ -8872,15 +8898,6 @@ function checkLockfileHasNoLocalRegistry(workspaceRoot) {
     remedy: "run `mnci upgrade`, which removes it, then commit package-lock.json"
   };
 }
-function checkReleaseTagsResolve(workspaceRoot, nxJson) {
-  const stranded = locateStrandedReleaseTags(workspaceRoot, nxJson.release?.releaseTag?.pattern);
-  return {
-    check: "release tags resolve under each project's current name",
-    ok: stranded.length === 0,
-    detail: `${stranded.map((entry) => `${entry.project} has only ${entry.oldTag}`).join("; ")} - nx release finds no tag under the new name and would release from the disk version, a downgrade`,
-    remedy: `run \`mnci adopt --tags\` to create the baseline tag for each (${stranded.map((entry) => entry.newTag).join(", ")}) on the commit of its old tag, then push the tags`
-  };
-}
 function collectFindings(workspaceRoot) {
   const nxJsonPath = (0, import_node_path38.join)(workspaceRoot, "nx.json");
   if (!fileExists(nxJsonPath)) {
@@ -8946,11 +8963,11 @@ function runDoctor(workspaceRoot, options = {}) {
   process.exitCode = 1;
 }
 
-// src/repository-adoption/adopt-dependencies.use-case.ts
+// src/dependency-adoption/adopt-dependencies.use-case.ts
 var import_node_fs33 = require("fs");
 var import_node_path39 = require("path");
 
-// src/repository-adoption/clean-working-tree.validator.ts
+// src/clean-working-tree/clean-working-tree.validator.ts
 function requireCleanWorkingTree(repositoryRoot, capture = runCapture) {
   if (capture("git", ["rev-parse", "--is-inside-work-tree"], repositoryRoot).status !== 0) {
     throw new Error("This directory is not a git repository. Every adoption step is one diff to review, so it needs git.");
@@ -8960,7 +8977,7 @@ function requireCleanWorkingTree(repositoryRoot, capture = runCapture) {
   }
 }
 
-// src/repository-adoption/extract-imports.algorithm.ts
+// src/dependency-adoption/extract-imports.algorithm.ts
 var import_node_module = require("module");
 var SPECIFIER2 = /(?:\bfrom\s*|\bimport\s*(?:\(\s*)?|\brequire\s*\(\s*)(['"`])([^'"`\n]+)\1/g;
 var BUILTINS = new Set(import_node_module.builtinModules);
@@ -8986,7 +9003,7 @@ function extractImportedPackages(source) {
   return found;
 }
 
-// src/repository-adoption/plan-dependency-moves.algorithm.ts
+// src/dependency-adoption/plan-dependency-moves.algorithm.ts
 function planDependencyMoves(rootDependencies, usage, declared) {
   const plan = { moves: [], removed: [], keptAtRoot: [], conflicts: [] };
   for (const [name, range] of Object.entries(rootDependencies)) {
@@ -9014,7 +9031,7 @@ function planDependencyMoves(rootDependencies, usage, declared) {
   return plan;
 }
 
-// src/repository-adoption/adopt-dependencies.use-case.ts
+// src/dependency-adoption/adopt-dependencies.use-case.ts
 var SOURCE_FILE = /\.(?:[cm]?[jt]s|[jt]sx)$/;
 var TEST_FILE = /\.(?:spec|test)\.[^.]+$|[\\/](?:__tests__|tests?|e2e)[\\/]/;
 var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "coverage", "out", ".git", ".nx", "tmp"]);
@@ -9107,11 +9124,11 @@ function adoptDependencies(repositoryRoot, dependencies = {}) {
   return { plan, installed };
 }
 
-// src/repository-adoption/adopt-kinds.use-case.ts
+// src/kind-adoption/adopt-kinds.use-case.ts
 var import_node_fs34 = require("fs");
 var import_node_path40 = require("path");
 
-// src/repository-adoption/infer-project-kind.algorithm.ts
+// src/kind-adoption/infer-project-kind.algorithm.ts
 var SERVER_FRAMEWORKS = ["express", "koa", "fastify", "@nestjs/core"];
 function declares(manifest, name) {
   return ["dependencies", "devDependencies", "peerDependencies"].some((key) => {
@@ -9207,7 +9224,7 @@ function inferProjectKind(evidence) {
   }
 }
 
-// src/repository-adoption/adopt-kinds.use-case.ts
+// src/kind-adoption/adopt-kinds.use-case.ts
 var TYPE_TAG = "type:";
 function readEvidence(repositoryRoot, location) {
   const directory = (0, import_node_path40.join)(repositoryRoot, location.dir);
@@ -9483,7 +9500,7 @@ function detectTestRunner(repositoryRoot) {
 function adoptOverlay(repositoryRoot, options, dependencies = {}) {
   requireCleanWorkingTree(repositoryRoot, dependencies.capture ?? runCapture);
   if (!fileExists((0, import_node_path42.join)(repositoryRoot, "nx.json"))) {
-    throw new Error("There is no nx.json, so Nx is not set up here. Set it up first (`npx nx@latest init`); adopt does not install Nx yet.");
+    throw new Error("There is no nx.json, so Nx is not set up here. Run `mnci adopt --toolchain` first: it sets Nx up (nx init, then nx add), and the overlay needs that.");
   }
   const persisted = readMnciConfig(repositoryRoot);
   const filled = {
@@ -9494,10 +9511,10 @@ function adoptOverlay(repositoryRoot, options, dependencies = {}) {
   (dependencies.upgrade ?? runUpgrade)(repositoryRoot, filled);
 }
 
-// src/repository-adoption/adopt-toolchain.use-case.ts
-var import_node_path44 = require("path");
+// src/toolchain-adoption/adopt-toolchain.use-case.ts
+var import_node_path45 = require("path");
 
-// src/repository-adoption/align-nx-family.algorithm.ts
+// src/toolchain-adoption/align-nx-family.algorithm.ts
 var VERSION = /^[\^~]?(\d+)\.(\d+)\.(\d+)$/;
 function isNxFamily(name) {
   return name === "nx" || name.startsWith("@nx/");
@@ -9532,25 +9549,56 @@ function alignNxFamily(dependencies, version) {
   return { dependencies: aligned, changed };
 }
 
-// src/repository-adoption/retire-tooling.use-case.ts
-var import_node_fs37 = require("fs");
+// src/toolchain-adoption/bootstrap-nx.use-case.ts
 var import_node_path43 = require("path");
+var BASE_PLUGIN = "@nx/js";
+var TOOL_PLUGINS = [
+  ["eslint", "@nx/eslint"],
+  ["jest", "@nx/jest"],
+  ["vitest", "@nx/vite"]
+];
+function pluginsFor(repositoryRoot) {
+  const manifestPath = (0, import_node_path43.join)(repositoryRoot, "package.json");
+  const manifest = fileExists(manifestPath) ? readJson(manifestPath) : {};
+  const declared = Object.keys({ ...manifest.dependencies, ...manifest.devDependencies });
+  return [BASE_PLUGIN, ...TOOL_PLUGINS.filter(([tool]) => declared.includes(tool)).map(([, plugin]) => plugin)];
+}
+function bootstrapNx(repositoryRoot, nxVersion, dependencies) {
+  if (fileExists((0, import_node_path43.join)(repositoryRoot, "nx.json"))) {
+    return { bootstrapped: false, plugins: [] };
+  }
+  const initialised = dependencies.run("npx", ["--yes", `nx@${nxVersion ?? "latest"}`, "init", "--interactive=false", "--nxCloud=skip", "--plugins=skip"], repositoryRoot);
+  if (initialised !== 0) {
+    throw new Error("`nx init` failed, so Nx could not be set up here. Read its output above; nothing else was changed after it.");
+  }
+  const plugins = pluginsFor(repositoryRoot);
+  for (const plugin of plugins) {
+    if (dependencies.run("npx", ["nx", "add", plugin], repositoryRoot) !== 0) {
+      throw new Error(`\`nx add ${plugin}\` failed. Nx itself is set up (nx.json exists); add the plugin by hand once its error is dealt with.`);
+    }
+  }
+  return { bootstrapped: true, plugins };
+}
+
+// src/toolchain-adoption/retire-tooling.use-case.ts
+var import_node_fs37 = require("fs");
+var import_node_path44 = require("path");
 var RETIRED_COMMAND = /\b(?:prettier|oxfmt|oxlint)\b/;
 function retireTooling(repositoryRoot) {
   const removed = [];
   for (const file of RETIRED_FORMATTER_FILES) {
-    if (!fileExists((0, import_node_path43.join)(repositoryRoot, file))) {
+    if (!fileExists((0, import_node_path44.join)(repositoryRoot, file))) {
       continue;
     }
-    (0, import_node_fs37.rmSync)((0, import_node_path43.join)(repositoryRoot, file), { force: true });
+    (0, import_node_fs37.rmSync)((0, import_node_path44.join)(repositoryRoot, file), { force: true });
     removed.push(file);
   }
-  const hadRegistry = fileExists((0, import_node_path43.join)(repositoryRoot, ".verdaccio"));
+  const hadRegistry = fileExists((0, import_node_path44.join)(repositoryRoot, ".verdaccio"));
   removeLocalRegistryScaffolding(repositoryRoot);
   if (hadRegistry) {
     removed.push(".verdaccio, its dependency and the local-registry target");
   }
-  const manifestPath = (0, import_node_path43.join)(repositoryRoot, "package.json");
+  const manifestPath = (0, import_node_path44.join)(repositoryRoot, "package.json");
   if (!fileExists(manifestPath)) {
     return removed;
   }
@@ -9578,7 +9626,7 @@ function retireTooling(repositoryRoot) {
   return removed;
 }
 
-// src/repository-adoption/adopt-toolchain.use-case.ts
+// src/toolchain-adoption/adopt-toolchain.use-case.ts
 var MAX_AUDIT_FIX_PASSES = 4;
 function publishedNxVersions(repositoryRoot, capture) {
   const answer = capture("npm", ["view", "nx", "versions", "--json"], repositoryRoot);
@@ -9597,10 +9645,14 @@ function adoptToolchain(repositoryRoot, options = {}, dependencies = {}) {
     console.log(message);
   });
   requireCleanWorkingTree(repositoryRoot, capture);
-  const manifestPath = (0, import_node_path44.join)(repositoryRoot, "package.json");
+  const manifestPath = (0, import_node_path45.join)(repositoryRoot, "package.json");
   if (!fileExists(manifestPath)) {
     throw new Error("No package.json at the repository root.");
   }
+  const bootstrap = bootstrapNx(repositoryRoot, options.nxVersion, { run });
+  if (bootstrap.bootstrapped) {
+    log(`Set Nx up (nx init, then nx add ${bootstrap.plugins.join(" ")})`);
+  }
   log("Removing retired tooling");
   const removed = retireTooling(repositoryRoot);
   const manifest = readJson(manifestPath);
@@ -9628,27 +9680,12 @@ function adoptToolchain(repositoryRoot, options = {}, dependencies = {}) {
     run("npm", ["audit", "fix", "--no-fund"], repositoryRoot);
     passes = audit(repositoryRoot) === 0;
   }
-  return { removed, aligned: { names, version }, auditFixes, auditPasses: passes };
-}
-
-// src/repository-adoption/create-baseline-tags.use-case.ts
-function createBaselineTags(repositoryRoot, stranded) {
-  const result = { created: [], existing: [], failed: [] };
-  for (const entry of stranded) {
-    const present = runCapture("git", ["rev-parse", "--verify", "--quiet", `refs/tags/${entry.newTag}`], repositoryRoot);
-    if (present.status === 0) {
-      result.existing.push(entry.newTag);
-      continue;
-    }
-    const made = runCapture("git", ["tag", entry.newTag, `${entry.oldTag}^{commit}`], repositoryRoot);
-    (made.status === 0 ? result.created : result.failed).push(entry.newTag);
-  }
-  return result;
+  return { bootstrapped: bootstrap.plugins, removed, aligned: { names, version }, auditFixes, auditPasses: passes };
 }
 
-// src/repository-adoption/inspect-repository.use-case.ts
+// src/adoption-report/inspect-repository.use-case.ts
 var import_node_fs38 = require("fs");
-var import_node_path45 = require("path");
+var import_node_path46 = require("path");
 var LOCKFILES = [
   ["package-lock.json", "npm"],
   ["pnpm-lock.yaml", "pnpm"],
@@ -9669,22 +9706,22 @@ function inspectRepository(repositoryRoot) {
   const isGitRepo = inside.status === 0 && inside.stdout.trim() === "true";
   const dirty = isGitRepo && runCapture("git", ["status", "--porcelain"], repositoryRoot).stdout.trim() !== "";
   const tags = isGitRepo ? runCapture("git", ["tag", "--list"], repositoryRoot).stdout.split(/\r?\n/).filter(Boolean) : [];
-  const manifestPath = (0, import_node_path45.join)(repositoryRoot, "package.json");
+  const manifestPath = (0, import_node_path46.join)(repositoryRoot, "package.json");
   const manifest = fileExists(manifestPath) ? readJson(manifestPath) : {};
-  const nxJsonPath = (0, import_node_path45.join)(repositoryRoot, "nx.json");
+  const nxJsonPath = (0, import_node_path46.join)(repositoryRoot, "nx.json");
   const nxJson = fileExists(nxJsonPath) ? readJson(nxJsonPath) : {};
   const ci = [];
   const pipelines = [];
-  if ((0, import_node_fs38.existsSync)((0, import_node_path45.join)(repositoryRoot, "azure-pipelines.yml"))) {
+  if ((0, import_node_fs38.existsSync)((0, import_node_path46.join)(repositoryRoot, "azure-pipelines.yml"))) {
     ci.push("azure");
-    pipelines.push((0, import_node_path45.join)(repositoryRoot, "azure-pipelines.yml"));
+    pipelines.push((0, import_node_path46.join)(repositoryRoot, "azure-pipelines.yml"));
   }
-  const workflows = (0, import_node_path45.join)(repositoryRoot, ".github", "workflows");
+  const workflows = (0, import_node_path46.join)(repositoryRoot, ".github", "workflows");
   if ((0, import_node_fs38.existsSync)(workflows)) {
     const files = (0, import_node_fs38.readdirSync)(workflows).filter((file) => /\.ya?ml$/.test(file));
     if (files.length > 0) {
       ci.push("github");
-      pipelines.push(...files.map((file) => (0, import_node_path45.join)(workflows, file)));
+      pipelines.push(...files.map((file) => (0, import_node_path46.join)(workflows, file)));
     }
   }
   const rootFiles = (0, import_node_fs38.readdirSync)(repositoryRoot);
@@ -9704,7 +9741,7 @@ function inspectRepository(repositoryRoot) {
   };
 }
 
-// src/repository-adoption/judge-adoption.policy.ts
+// src/adoption-report/judge-adoption.policy.ts
 function judgeAdoption(facts) {
   const findings = [];
   const blocker = (detail, step) => {
@@ -9728,7 +9765,7 @@ function judgeAdoption(facts) {
     warning("nx.json already carries an mnci block, so this is an mnci workspace", "use `mnci upgrade`; adopt is for repositories mnci has not touched");
   }
   if (facts.nxVersion === void 0) {
-    warning("Nx is not installed", "set Nx up first (`npx nx@latest init`); adopt does not install it yet, and the toolchain and overlay steps need an nx.json");
+    warning("Nx is not installed", "run `mnci adopt --toolchain`, which sets Nx up through nx init and nx add before it does anything else; the overlay step needs the nx.json that makes");
   }
   if (facts.strandedTags.length > 0) {
     warning(
@@ -9749,10 +9786,12 @@ function judgeAdoption(facts) {
   return { ready: ordered.every((finding) => finding.severity !== "blocker"), facts, findings: ordered };
 }
 
-// src/repository-adoption/run-adopt.use-case.ts
+// src/adoption-report/report-adoption.use-case.ts
 function reportAdoption(repositoryRoot) {
   return judgeAdoption(inspectRepository(repositoryRoot));
 }
+
+// src/repository-adoption/run-adopt.use-case.ts
 function runAdopt(repositoryRoot, options = {}) {
   const report = reportAdoption(repositoryRoot);
   if (options.dependencies === true) {
@@ -9833,6 +9872,9 @@ function runToolchain(repositoryRoot, options) {
     const result = adoptToolchain(repositoryRoot, { nxVersion: options.nx }, { log: (message) => {
       logger.step(message);
     } });
+    if (result.bootstrapped.length > 0) {
+      logger.info(`Nx was not set up here, so it is now: ${result.bootstrapped.join(", ")} (nx.json and the plugins; review it with \`git diff\`).`);
+    }
     for (const line of result.removed) {
       logger.info(`removed ${line}`);
     }
@@ -9996,13 +10038,13 @@ function runCommands(program, options) {
 }
 
 // src/workspace-info/list-projects.use-case.ts
-var import_node_path46 = require("path");
+var import_node_path47 = require("path");
 var TYPE_TAG_PREFIX = "type:";
 function listProjects(workspaceRoot) {
   return locateProjects(workspaceRoot).map((location) => {
-    const projectJsonPath = (0, import_node_path46.join)(workspaceRoot, location.dir, "project.json");
+    const projectJsonPath = (0, import_node_path47.join)(workspaceRoot, location.dir, "project.json");
     const project = fileExists(projectJsonPath) ? readJson(projectJsonPath) : {};
-    const manifestPath = (0, import_node_path46.join)(workspaceRoot, location.dir, "package.json");
+    const manifestPath = (0, import_node_path47.join)(workspaceRoot, location.dir, "package.json");
     const manifestTags = fileExists(manifestPath) ? readJson(manifestPath).nx?.tags ?? [] : [];
     const typeTag = [...project.tags ?? [], ...manifestTags].find((tag) => tag.startsWith(TYPE_TAG_PREFIX));
     return {
@@ -10015,7 +10057,7 @@ function listProjects(workspaceRoot) {
   }).toSorted((a, b) => a.dir.localeCompare(b.dir));
 }
 function runProjects(workspaceRoot, options) {
-  if (!fileExists((0, import_node_path46.join)(workspaceRoot, "nx.json"))) {
+  if (!fileExists((0, import_node_path47.join)(workspaceRoot, "nx.json"))) {
     throw new Error("No nx.json found here. Run `projects` from the workspace root.");
   }
   const projects = listProjects(workspaceRoot);
@@ -10029,11 +10071,11 @@ function runProjects(workspaceRoot, options) {
 }
 
 // src/workspace-info/read-workspace-info.use-case.ts
-var import_node_path48 = require("path");
+var import_node_path49 = require("path");
 
 // src/cli-version/check-for-update.use-case.ts
 var import_node_fs39 = require("fs");
-var import_node_path47 = require("path");
+var import_node_path48 = require("path");
 var import_cross_spawn4 = __toESM(require("cross-spawn"));
 var PACKAGE_NAME2 = "@mnci/cli";
 var REGISTRY_TIMEOUT_MS = 2e3;
@@ -10092,7 +10134,7 @@ function releaseTriple(version) {
 }
 function readCliVersion(packageDirectory) {
   try {
-    const manifestPath = (0, import_node_path47.join)(packageDirectory, "..", "package.json");
+    const manifestPath = (0, import_node_path48.join)(packageDirectory, "..", "package.json");
     const manifest = JSON.parse((0, import_node_fs39.readFileSync)(manifestPath, "utf8"));
     return manifest.version ?? "0.0.0";
   } catch {
@@ -10103,7 +10145,7 @@ function readCliVersion(packageDirectory) {
 // src/workspace-info/read-workspace-info.use-case.ts
 function readWorkspaceInfo(workspaceRoot, cliVersion) {
   const latest = fetchLatestVersion() ?? null;
-  const isWorkspace = fileExists((0, import_node_path48.join)(workspaceRoot, "nx.json"));
+  const isWorkspace = fileExists((0, import_node_path49.join)(workspaceRoot, "nx.json"));
   return {
     cli: {
       version: cliVersion,
@@ -10124,7 +10166,7 @@ function runInfo(workspaceRoot, cliVersion, options) {
 }
 
 // src/interactive-wizard/interactive-wizard.use-case.ts
-var import_node_path49 = require("path");
+var import_node_path50 = require("path");
 
 // src/interactive-wizard/adopt-steps.config.ts
 var ADOPT_GLOBAL_OPTIONS = ["json"];
@@ -10305,7 +10347,7 @@ function wizardMenu(commands, inWorkspace) {
 }
 async function runInteractive(program, prompter = createInquirerPrompter(), workingDirectory = process.cwd()) {
   const commands = describeCommands(program);
-  const inWorkspace = fileExists((0, import_node_path49.join)(workingDirectory, "nx.json"));
+  const inWorkspace = fileExists((0, import_node_path50.join)(workingDirectory, "nx.json"));
   const name = await prompter.select("What would you like to do?", wizardMenu(commands, inWorkspace));
   const command = commands.find((candidate) => candidate.name === name);
   const argv = buildArgv(command, await askCommand(command, prompter));
@@ -10317,9 +10359,281 @@ async function runInteractive(program, prompter = createInquirerPrompter(), work
   }
 }
 
-// src/workspace-creation/adopt-directory.use-case.ts
+// src/workspace-presets/preset-catalog.config.ts
+var PRESETS = [
+  {
+    id: "web-api",
+    summary: "a React frontend and an Express API that share one internal library: the web asks the API, the API answers with the shared greeting, and `mnci dev web api` starts both",
+    projects: [
+      { kind: "internal-lib", name: "shared", options: {} },
+      { kind: "node-app", name: "api", options: { framework: "express" } },
+      { kind: "react-app", name: "web", options: {} }
+    ]
+  }
+];
+var PRESET_IDS = PRESETS.map((preset) => preset.id);
+
+// src/workspace-presets/wire-web-api.use-case.ts
 var import_node_fs40 = require("fs");
-var import_node_path50 = require("path");
+var import_node_path51 = require("path");
+
+// src/workspace-presets/web-api-wiring.algorithm.ts
+function apiHandler(shared) {
+  return `import { greet } from '${shared}'
+import type { Request, Response } from 'express'
+
+export function helloHandler (request: Request, response: Response): void {
+  const name = typeof request.query.name === 'string' ? request.query.name : 'world'
+  response.send(greet(name))
+}
+`;
+}
+function apiHandlerSpec(shared) {
+  return String.raw`import { greet } from '${shared}'
+import type { Request, Response } from 'express'
+import { helloHandler } from './hello.handler'
+
+/** A response that keeps what it was sent, so the spec needs no mock library and runs under Jest or Vitest. */
+function recordingResponse (): { response: Response, sent: unknown[] } {
+  const sent: unknown[] = []
+
+  return { sent, response: { send: (value: unknown) => { sent.push(value) } } as unknown as Response }
+}
+
+describe('helloHandler', () => {
+  it('answers with the shared library\'s greeting for the name asked', () => {
+    const { response, sent } = recordingResponse()
+
+    helloHandler({ query: { name: 'web' } } as unknown as Request, response)
+
+    expect(sent).toEqual([greet('web')])
+  })
+
+  it('greets the world when no name is asked', () => {
+    const { response, sent } = recordingResponse()
+
+    helloHandler({ query: {} } as unknown as Request, response)
+
+    expect(sent).toEqual([greet('world')])
+  })
+})
+`;
+}
+function apiBarrel() {
+  return "export * from './hello.handler'\n";
+}
+function webGreetingClient(shared) {
+  return `import type { Greeting } from '${shared}'
+
+export async function fetchGreeting (name: string, request: typeof fetch = fetch): Promise<Greeting> {
+  const response = await request('/api/greeting?name=' + encodeURIComponent(name))
+
+  return await response.json() as Greeting
+}
+`;
+}
+function webGreetingClientSpec() {
+  return String.raw`import { fetchGreeting } from './greeting.client'
+
+describe('fetchGreeting', () => {
+  it('asks the API\'s greeting route for the name and returns the answer', async () => {
+    const requested: string[] = []
+    const answering = (async (input: string) => {
+      requested.push(input)
+
+      return { json: async () => ({ message: 'Hello, web!' }) } as Response
+    }) as unknown as typeof fetch
+
+    expect(await fetchGreeting('web', answering)).toEqual({ message: 'Hello, web!' })
+    expect(requested).toEqual(['/api/greeting?name=web'])
+  })
+})
+`;
+}
+function webGreetingComponent(shared) {
+  return `import { useEffect, useState } from 'react'
+import type { Greeting } from '${shared}'
+import { fetchGreeting } from './greeting.client'
+
+export interface GreetingViewProps {
+  readonly name: string
+  readonly load?: (name: string) => Promise<Greeting>
+}
+
+export function GreetingView ({ name, load = fetchGreeting }: GreetingViewProps) {
+  const [greeting, setGreeting] = useState<Greeting | undefined>()
+  const [failed, setFailed] = useState(false)
+
+  useEffect(() => {
+    void (async () => {
+      try {
+        setGreeting(await load(name))
+      } catch {
+        setFailed(true)
+      }
+    })()
+  }, [name, load])
+
+  if (failed) {
+    return <p>Could not reach the API.</p>
+  }
+
+  return <p>{greeting?.message ?? 'Loading...'}</p>
+}
+`;
+}
+function webGreetingSpec() {
+  return `import { render } from '@testing-library/react'
+
+import { GreetingView } from './greeting.component'
+
+async function answering (name: string): Promise<{ message: string }> {
+  return { message: 'Hello, ' + name + '!' }
+}
+
+async function offline (): Promise<never> {
+  throw new Error('offline')
+}
+
+describe('GreetingView', () => {
+  it('shows the greeting its loader returns for its name', async () => {
+    const { findByText } = render(<GreetingView name='world' load={answering} />)
+
+    expect(await findByText('Hello, world!')).toBeTruthy()
+  })
+
+  it('says so when the API cannot be reached', async () => {
+    const { findByText } = render(<GreetingView name='world' load={offline} />)
+
+    expect(await findByText('Could not reach the API.')).toBeTruthy()
+  })
+})
+`;
+}
+function webGreetingBarrel() {
+  return "export * from './greeting.client'\nexport * from './greeting.component'\n";
+}
+function webAppSpec() {
+  return `import { render } from '@testing-library/react'
+
+import App from './app.component'
+
+describe('App', () => {
+  it('renders, and shows that it is loading the greeting', () => {
+    const { getByText } = render(<App />)
+
+    expect(getByText('Loading...')).toBeTruthy()
+  })
+})
+`;
+}
+function withApiProxy(config, target) {
+  const start = config.indexOf("server:");
+  const end = start === -1 ? -1 : config.indexOf("},", start);
+  if (end === -1 || config.includes("proxy:")) {
+    return config;
+  }
+  const block = config.slice(start, end).trimEnd();
+  return `${config.slice(0, start)}${block}
+    proxy: { '/api': '${target}' },
+  ${config.slice(end)}`;
+}
+
+// src/workspace-presets/wire-web-api.use-case.ts
+var API_ORIGIN = "http://localhost:3000";
+function declareDependency(manifestPath, name) {
+  const manifest = readJson(manifestPath);
+  writeFileEnsured(manifestPath, toJson({ ...manifest, dependencies: { ...manifest.dependencies, [name]: "*" } }));
+}
+function removeFiles(slice, files) {
+  for (const file of files) {
+    (0, import_node_fs40.rmSync)((0, import_node_path51.join)(slice, file), { force: true });
+  }
+}
+function replaceOnce(path, anchor, replacement) {
+  const text = (0, import_node_fs40.readFileSync)(path, "utf8");
+  if (!text.includes(anchor)) {
+    throw new Error(`${path} has no ${anchor}; the generator's output changed, so the preset cannot wire it.`);
+  }
+  writeFileEnsured(path, text.replace(anchor, () => replacement));
+}
+function proxyApi(viteConfigPath) {
+  const text = (0, import_node_fs40.readFileSync)(viteConfigPath, "utf8");
+  const proxied = withApiProxy(text, API_ORIGIN);
+  if (proxied === text && !text.includes("proxy:")) {
+    throw new Error(`${viteConfigPath} has no server block to add the /api proxy to; the generator's output changed, so the preset cannot wire it.`);
+  }
+  writeFileEnsured(viteConfigPath, proxied);
+}
+function wireWebApi(workspaceRoot, projects) {
+  const sharedManifest = (0, import_node_path51.join)(workspaceRoot, "libs", projects.shared, "package.json");
+  if (!fileExists(sharedManifest)) {
+    throw new Error(`The shared library was not added at libs/${projects.shared}, so there is nothing to wire the API and the frontend to.`);
+  }
+  const shared = readJson(sharedManifest).name;
+  const api = (0, import_node_path51.join)(workspaceRoot, "apps", projects.api);
+  declareDependency((0, import_node_path51.join)(api, "package.json"), shared);
+  const hello = (0, import_node_path51.join)(api, "src", "hello");
+  writeFileEnsured((0, import_node_path51.join)(hello, "hello.handler.ts"), apiHandler(shared));
+  writeFileEnsured((0, import_node_path51.join)(hello, "hello.handler.spec.ts"), apiHandlerSpec(shared));
+  writeFileEnsured((0, import_node_path51.join)(hello, "index.ts"), apiBarrel());
+  removeFiles(hello, ["greet.use-case.ts", "greet.use-case.spec.ts", "greeting.contract.ts"]);
+  replaceOnce((0, import_node_path51.join)(api, "src", "main.ts"), "app.get('/', helloHandler)", "app.get('/api/greeting', helloHandler)");
+  const web = (0, import_node_path51.join)(workspaceRoot, "apps", projects.web);
+  declareDependency((0, import_node_path51.join)(web, "package.json"), shared);
+  const greeting = (0, import_node_path51.join)(web, "src", "greeting");
+  writeFileEnsured((0, import_node_path51.join)(greeting, "greeting.client.ts"), webGreetingClient(shared));
+  writeFileEnsured((0, import_node_path51.join)(greeting, "greeting.client.spec.ts"), webGreetingClientSpec());
+  writeFileEnsured((0, import_node_path51.join)(greeting, "greeting.component.tsx"), webGreetingComponent(shared));
+  writeFileEnsured((0, import_node_path51.join)(greeting, "greeting.component.spec.tsx"), webGreetingSpec());
+  writeFileEnsured((0, import_node_path51.join)(greeting, "index.ts"), webGreetingBarrel());
+  removeFiles(greeting, ["greet.use-case.ts", "greet.use-case.spec.ts", "greeting.contract.ts"]);
+  writeFileEnsured((0, import_node_path51.join)(web, "src", "app", "app.component.spec.tsx"), webAppSpec());
+  proxyApi((0, import_node_path51.join)(web, "vite.config.mts"));
+}
+
+// src/workspace-presets/apply-preset.use-case.ts
+function findPreset(id) {
+  const preset = PRESETS.find((candidate) => candidate.id === id);
+  if (preset === void 0) {
+    throw new Error(`Unknown preset '${id}'. Presets: ${PRESET_IDS.join(", ")}.`);
+  }
+  return preset;
+}
+function nameOf(preset, kind) {
+  const project = preset.projects.find((candidate) => candidate.kind === kind);
+  if (project === void 0) {
+    throw new Error(`The ${preset.id} preset has no ${kind}.`);
+  }
+  return project.name;
+}
+async function applyPreset(workspaceRoot, presetId, dependencies = {}) {
+  const preset = findPreset(presetId);
+  const add = dependencies.add ?? runAdd;
+  const install = dependencies.install ?? ((root) => runShell("npm", ["install", "--ignore-scripts", "--no-audit", "--no-fund"], root));
+  const sync = dependencies.sync ?? syncProjectReferences;
+  const format = dependencies.format ?? runFormatter;
+  logger.step(`Adding the ${preset.id} preset: ${preset.projects.map((project) => project.name).join(", ")}`);
+  const previous = process.cwd();
+  process.chdir(workspaceRoot);
+  try {
+    for (const project of preset.projects) {
+      await add(project.kind, project.name, project.options);
+    }
+  } finally {
+    process.chdir(previous);
+  }
+  wireWebApi(workspaceRoot, { shared: nameOf(preset, "internal-lib"), api: nameOf(preset, "node-app"), web: nameOf(preset, "react-app") });
+  if (install(workspaceRoot) !== 0) {
+    throw new Error("npm install failed after wiring the preset. Run `npm install` and read its error; the projects themselves were added.");
+  }
+  sync(workspaceRoot);
+  format(workspaceRoot);
+}
+
+// src/workspace-creation/adopt-directory.use-case.ts
+var import_node_fs41 = require("fs");
+var import_node_path52 = require("path");
 var NEVER_COPIED = /* @__PURE__ */ new Set([".git", "node_modules"]);
 var AGENT_AND_CI_ENTRIES = [
   "AGENTS.md",
@@ -10350,13 +10664,13 @@ var PREFLIGHT_BLOCKERS = [
   "packages"
 ];
 function assertAdoptableDirectory(target) {
-  if (!(0, import_node_fs40.existsSync)(target)) {
+  if (!(0, import_node_fs41.existsSync)(target)) {
     throw new Error(`--into '${target}' does not exist. Create or clone it first.`);
   }
-  if (!(0, import_node_fs40.statSync)(target).isDirectory()) {
+  if (!(0, import_node_fs41.statSync)(target).isDirectory()) {
     throw new Error(`--into '${target}' is not a directory.`);
   }
-  const blockers = PREFLIGHT_BLOCKERS.filter((entry) => (0, import_node_fs40.existsSync)((0, import_node_path50.join)(target, entry)));
+  const blockers = PREFLIGHT_BLOCKERS.filter((entry) => (0, import_node_fs41.existsSync)((0, import_node_path52.join)(target, entry)));
   if (blockers.length > 0) {
     throw new Error(
       `--into '${target}' already holds ${blockers.join(", ")}, so it is a project already. Use \`mnci upgrade\` to re-apply the overlay to an existing workspace, or point --into at an empty checkout.`
@@ -10364,15 +10678,15 @@ function assertAdoptableDirectory(target) {
   }
 }
 function mergeGitignore(generatedFile, targetFile) {
-  const existing = (0, import_node_fs40.readFileSync)(targetFile, "utf8");
+  const existing = (0, import_node_fs41.readFileSync)(targetFile, "utf8");
   const present = new Set(existing.split("\n").map((line) => line.trim()));
-  const additions = (0, import_node_fs40.readFileSync)(generatedFile, "utf8").split("\n").map((line) => line.trimEnd()).filter((line) => {
+  const additions = (0, import_node_fs41.readFileSync)(generatedFile, "utf8").split("\n").map((line) => line.trimEnd()).filter((line) => {
     const trimmed = line.trim();
     return trimmed !== "" && !trimmed.startsWith("#") && !present.has(trimmed);
   });
   if (additions.length === 0) return false;
   const separator = existing.endsWith("\n") ? "" : "\n";
-  (0, import_node_fs40.writeFileSync)(
+  (0, import_node_fs41.writeFileSync)(
     targetFile,
     `${existing}${separator}
 # Added by mnci (Nx workspace)
@@ -10382,9 +10696,9 @@ ${additions.join("\n")}
   return true;
 }
 function adoptGeneratedWorkspace(generatedRoot, target) {
-  const entries = (0, import_node_fs40.readdirSync)(generatedRoot).filter((entry) => !NEVER_COPIED.has(entry));
+  const entries = (0, import_node_fs41.readdirSync)(generatedRoot).filter((entry) => !NEVER_COPIED.has(entry));
   const collisions = entries.filter(
-    (entry) => (0, import_node_fs40.existsSync)((0, import_node_path50.join)(target, entry)) && !EXISTING_WINS.has(entry) && entry !== ".gitignore"
+    (entry) => (0, import_node_fs41.existsSync)((0, import_node_path52.join)(target, entry)) && !EXISTING_WINS.has(entry) && entry !== ".gitignore"
   );
   if (collisions.length > 0) {
     throw new Error(
@@ -10393,28 +10707,28 @@ function adoptGeneratedWorkspace(generatedRoot, target) {
   }
   const result = { copied: [], kept: [], mergedGitignore: false };
   for (const entry of entries) {
-    const from = (0, import_node_path50.join)(generatedRoot, entry);
-    const to = (0, import_node_path50.join)(target, entry);
-    if (entry === ".gitignore" && (0, import_node_fs40.existsSync)(to)) {
+    const from = (0, import_node_path52.join)(generatedRoot, entry);
+    const to = (0, import_node_path52.join)(target, entry);
+    if (entry === ".gitignore" && (0, import_node_fs41.existsSync)(to)) {
       result.mergedGitignore = mergeGitignore(from, to);
       result.kept.push(entry);
       continue;
     }
-    if ((0, import_node_fs40.existsSync)(to)) {
+    if ((0, import_node_fs41.existsSync)(to)) {
       result.kept.push(entry);
       continue;
     }
-    (0, import_node_fs40.cpSync)(from, to, { recursive: true });
+    (0, import_node_fs41.cpSync)(from, to, { recursive: true });
     result.copied.push(entry);
   }
-  (0, import_node_fs40.rmSync)(generatedRoot, { recursive: true, force: true });
+  (0, import_node_fs41.rmSync)(generatedRoot, { recursive: true, force: true });
   return result;
 }
 
 // src/workspace-creation/create-workspace.use-case.ts
-var import_node_fs41 = require("fs");
+var import_node_fs42 = require("fs");
 var import_node_os2 = require("os");
-var import_node_path51 = require("path");
+var import_node_path53 = require("path");
 function nxCloudProviderValue(ci) {
   return ci === "azure" ? "azure" : "github";
 }
@@ -10457,9 +10771,10 @@ async function resolveRegistry2(options) {
   return await promptRegistry();
 }
 async function runNew(name, options) {
-  const adoptTarget = options.into === void 0 ? void 0 : (0, import_node_path51.resolve)(process.cwd(), options.into);
+  const adoptTarget = options.into === void 0 ? void 0 : (0, import_node_path53.resolve)(process.cwd(), options.into);
   if (adoptTarget !== void 0) assertAdoptableDirectory(adoptTarget);
-  const workspaceName = name ?? (adoptTarget === void 0 ? await promptText("Workspace name") : (0, import_node_path51.basename)(adoptTarget));
+  if (options.preset !== void 0) findPreset(options.preset);
+  const workspaceName = name ?? (adoptTarget === void 0 ? await promptText("Workspace name") : (0, import_node_path53.basename)(adoptTarget));
   assertValidProjectName(workspaceName, "Workspace name");
   const scope = options.scope ?? (options.yes ? `@${workspaceName}` : await promptText("npm scope for publishable packages", `@${workspaceName}`));
   const registry = await resolveRegistry2(options);
@@ -10472,8 +10787,8 @@ async function runNew(name, options) {
   const npmAuth = resolveNpmAuth(options.npmAuth, registry, ci);
   const stack = await resolveStack(options);
   const nxCloud = options.nxCloud ?? (options.yes ? false : await promptNxCloud());
-  const stagingParent = adoptTarget === void 0 ? process.cwd() : (0, import_node_fs41.mkdtempSync)((0, import_node_path51.join)((0, import_node_os2.tmpdir)(), "mnci-new-"));
-  let workspaceRoot = (0, import_node_path51.join)(stagingParent, workspaceName);
+  const stagingParent = adoptTarget === void 0 ? process.cwd() : (0, import_node_fs42.mkdtempSync)((0, import_node_path53.join)((0, import_node_os2.tmpdir)(), "mnci-new-"));
+  let workspaceRoot = (0, import_node_path53.join)(stagingParent, workspaceName);
   try {
     logger.step(`Creating Nx workspace '${workspaceName}' (preset: ts)`);
     runNpx(
@@ -10496,7 +10811,7 @@ async function runNew(name, options) {
       workspaceRoot = adoptTarget;
     }
   } finally {
-    if (adoptTarget !== void 0) (0, import_node_fs41.rmSync)(stagingParent, { recursive: true, force: true });
+    if (adoptTarget !== void 0) (0, import_node_fs42.rmSync)(stagingParent, { recursive: true, force: true });
   }
   logger.step(
     "Applying MoNecromanCI overlay (VS Code workspace, release config, .npmrc, commitlint, pipeline, stack)"
@@ -10506,8 +10821,8 @@ async function runNew(name, options) {
     { workspaceName, scope, registry, agent, variableGroup, ci, stack, ...npmAuth && { npmAuth } },
     logger.detail
   );
-  (0, import_node_fs41.rmSync)((0, import_node_path51.join)(workspaceRoot, "node_modules"), { recursive: true, force: true });
-  (0, import_node_fs41.rmSync)((0, import_node_path51.join)(workspaceRoot, "package-lock.json"), { force: true });
+  (0, import_node_fs42.rmSync)((0, import_node_path53.join)(workspaceRoot, "node_modules"), { recursive: true, force: true });
+  (0, import_node_fs42.rmSync)((0, import_node_path53.join)(workspaceRoot, "package-lock.json"), { force: true });
   logger.step("Installing the toolchain (commitlint + husky + linting/formatting)");
   const installStatus = runShell(
     "npm",
@@ -10520,6 +10835,9 @@ async function runNew(name, options) {
   runShell("npx", ["husky"], workspaceRoot);
   logger.step("Formatting the workspace (eslint --fix, JavaScript Standard Style)");
   runFormatter(workspaceRoot);
+  if (options.preset !== void 0) {
+    await applyPreset(workspaceRoot, options.preset);
+  }
   logger.success("Done. Next steps:");
   if (adoptTarget === void 0) logger.info(`  cd ${workspaceName}`);
   for (const line of projectKindHintLines()) {
@@ -10557,6 +10875,8 @@ function buildProgram(cliVersion) {
   ).addOption(new import_commander.Option("--ci <provider>", "CI provider").choices(["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)").option(
     "--into <dir>",
     "bootstrap into an existing directory (a fresh clone holding only .git); the directory name is the workspace name unless one is given"
+  ).addOption(
+    new import_commander.Option("--preset <preset>", "also scaffold a whole shape of workspace, its projects wired together (web-api: a React frontend and an Express API sharing one library)").choices(PRESET_IDS)
   ).action(async (name, options) => {
     await runNew(name, options);
   });