@mnci/cli 4.42.0 → 4.43.0

package/README.md

@@ -505,6 +505,23 @@ from File`), and the curated root scripts.
 4. Installs the chosen **stack** (see below), `husky` + `@commitlint/*` for
    real, so versions resolve at generation time.
 
+## `mnci adopt`: reading an existing repository before changing it
+
+`mnci adopt` is the start of bringing a repository that already has history, tooling and published
+packages under mnci (the plan is #383). So far it is **report mode only and changes nothing**:
+
+```bash
+mnci adopt          # what was found, what blocks, what clears each
+mnci adopt --json   # the same, as one document
+```
+
+It reads git and the filesystem (no Nx, no install, no network) and reports the package manager, the
+`nx` version, every project manifest, the tags and any release tags stranded under an old project name,
+the CI pipelines and whether they already call `mnci ci`, retired tooling (Prettier, oxfmt, verdaccio)
+and the root files that are yours (`CLAUDE.md`, `AGENTS.md`). A **blocker** (not a git repository,
+uncommitted changes, a package manager other than npm, no projects) makes it exit non-zero; a **warning**
+names the later adoption step that clears it. Each later step is its own issue under #383.
+
 ## `mnci upgrade`: re-applying the overlay to an existing workspace
 
 Every fix to `workspace-overlay/overlay.use-case.ts` — a release-config correction, a CI guard rewritten,

package/dist/cli.js

@@ -8485,11 +8485,146 @@ function runDoctor(workspaceRoot, options = {}) {
   process.exitCode = 1;
 }
 
+// src/repository-adoption/inspect-repository.use-case.ts
+var import_node_fs31 = require("fs");
+var import_node_path36 = require("path");
+var LOCKFILES = [
+  ["package-lock.json", "npm"],
+  ["pnpm-lock.yaml", "pnpm"],
+  ["yarn.lock", "yarn"],
+  ["bun.lock", "bun"],
+  ["bun.lockb", "bun"]
+];
+var PERSONAL_FILES = ["CLAUDE.md", "AGENTS.md"];
+var RETIRED_FILE_PATTERN = /^(?:\.prettierrc.*|\.prettierignore|\.oxfmtrc\.json|oxlint\.config\.ts)$/;
+var RETIRED_NAMES = ["prettier", "oxfmt", "oxlint", "verdaccio"];
+function retiredNamesIn(manifest) {
+  const declared = Object.keys({ ...manifest.dependencies, ...manifest.devDependencies });
+  const scripts = Object.values(manifest.scripts ?? {}).join(" ");
+  return RETIRED_NAMES.filter((name) => declared.includes(name) || new RegExp(String.raw`\b${name}\b`).test(scripts));
+}
+function inspectRepository(repositoryRoot) {
+  const inside = runCapture("git", ["rev-parse", "--is-inside-work-tree"], 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_path36.join)(repositoryRoot, "package.json");
+  const manifest = fileExists(manifestPath) ? readJson(manifestPath) : {};
+  const nxJsonPath = (0, import_node_path36.join)(repositoryRoot, "nx.json");
+  const nxJson = fileExists(nxJsonPath) ? readJson(nxJsonPath) : {};
+  const ci = [];
+  const pipelines = [];
+  if ((0, import_node_fs31.existsSync)((0, import_node_path36.join)(repositoryRoot, "azure-pipelines.yml"))) {
+    ci.push("azure");
+    pipelines.push((0, import_node_path36.join)(repositoryRoot, "azure-pipelines.yml"));
+  }
+  const workflows = (0, import_node_path36.join)(repositoryRoot, ".github", "workflows");
+  if ((0, import_node_fs31.existsSync)(workflows)) {
+    const files = (0, import_node_fs31.readdirSync)(workflows).filter((file) => /\.ya?ml$/.test(file));
+    if (files.length > 0) {
+      ci.push("github");
+      pipelines.push(...files.map((file) => (0, import_node_path36.join)(workflows, file)));
+    }
+  }
+  const rootFiles = (0, import_node_fs31.readdirSync)(repositoryRoot);
+  return {
+    isGitRepo,
+    dirty,
+    packageManager: LOCKFILES.find(([file]) => rootFiles.includes(file))?.[1],
+    nxVersion: manifest.devDependencies?.nx ?? manifest.dependencies?.nx,
+    alreadyMnci: nxJson.mnci !== void 0,
+    projects: locateProjects(repositoryRoot).map(({ name, dir, ecosystem }) => ({ name, dir, ecosystem })),
+    tagCount: tags.length,
+    strandedTags: isGitRepo ? locateStrandedReleaseTags(repositoryRoot, nxJson.release?.releaseTag?.pattern) : [],
+    ci,
+    pipelineUsesMnci: pipelines.some((file) => /\bmnci ci\b/.test((0, import_node_fs31.readFileSync)(file, "utf8"))),
+    retiredTooling: [.../* @__PURE__ */ new Set([...rootFiles.filter((file) => RETIRED_FILE_PATTERN.test(file) || file === ".verdaccio"), ...retiredNamesIn(manifest)])],
+    personalFiles: PERSONAL_FILES.filter((file) => rootFiles.includes(file))
+  };
+}
+
+// src/repository-adoption/judge-adoption.policy.ts
+function judgeAdoption(facts) {
+  const findings = [];
+  const blocker = (detail, step) => {
+    findings.push({ severity: "blocker", detail, step });
+  };
+  const warning = (detail, step) => {
+    findings.push({ severity: "warning", detail, step });
+  };
+  if (!facts.isGitRepo) {
+    blocker("this directory is not a git repository", "run `git init` (or clone the repository) so every step can be its own commit");
+  } else if (facts.dirty) {
+    blocker("the working tree has uncommitted changes", "commit or stash them, so adoption starts from a state you can return to");
+  }
+  if (facts.packageManager !== void 0 && facts.packageManager !== "npm") {
+    blocker(`the repository uses ${facts.packageManager}; mnci workspaces are npm workspaces`, "convert to npm first (out of scope for adopt for now)");
+  }
+  if (facts.projects.length === 0) {
+    blocker("no project manifest was found under the repository", "run mnci adopt from the repository root, or `mnci new` for an empty one");
+  }
+  if (facts.alreadyMnci) {
+    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", "the toolchain step installs the Nx family at the version mnci supports (#380)");
+  }
+  if (facts.strandedTags.length > 0) {
+    warning(
+      `${facts.strandedTags.length} project(s) have release tags only under an old name (${facts.strandedTags.map((entry) => entry.project).join(", ")})`,
+      "the tags step creates the baseline tags before the first release (#379)"
+    );
+  }
+  if (facts.retiredTooling.length > 0) {
+    warning(`retired tooling is present: ${facts.retiredTooling.join(", ")}`, "the toolchain step removes it (#380)");
+  }
+  if (facts.ci.length > 0 && !facts.pipelineUsesMnci) {
+    warning(`an existing ${facts.ci.join(" and ")} pipeline does not call mnci`, "the pipeline step moves its custom steps into slots (#381)");
+  }
+  if (facts.personalFiles.length > 0) {
+    warning(`${facts.personalFiles.join(", ")} exist and are yours`, "adoption leaves them alone; only a block marked by Nx is ever removed");
+  }
+  const ordered = [...findings.filter((finding) => finding.severity === "blocker"), ...findings.filter((finding) => finding.severity === "warning")];
+  return { ready: ordered.every((finding) => finding.severity !== "blocker"), facts, findings: ordered };
+}
+
+// src/repository-adoption/run-adopt.use-case.ts
+function reportAdoption(repositoryRoot) {
+  return judgeAdoption(inspectRepository(repositoryRoot));
+}
+function runAdopt(repositoryRoot, options = {}) {
+  const report = reportAdoption(repositoryRoot);
+  if (!report.ready) {
+    process.exitCode = 1;
+  }
+  if (options.json === true) {
+    printJson(report);
+    return;
+  }
+  const { facts } = report;
+  logger.info(`${facts.projects.length} project(s), ${facts.tagCount} tag(s), ${facts.packageManager ?? "no lockfile"}, nx ${facts.nxVersion ?? "not installed"}`);
+  for (const finding of report.findings) {
+    const line = `${finding.severity === "blocker" ? "BLOCKER" : "warning"}: ${finding.detail}
+    next: ${finding.step}`;
+    if (finding.severity === "blocker") {
+      logger.error(line);
+    } else {
+      logger.warn(line);
+    }
+  }
+  if (report.ready) {
+    logger.success("Nothing blocks adoption. This was a read-only report; nothing was changed.");
+  } else {
+    logger.error("Adoption is blocked. Clear the blockers above and run the report again.");
+  }
+}
+
 // src/command-catalog/command-groups.config.ts
 var COMMAND_GROUPS = {
   new: "workspace",
   upgrade: "workspace",
   doctor: "workspace",
+  adopt: "inspect",
   add: "projects",
   install: "dependencies",
   sync: "dependencies",
@@ -8555,11 +8690,11 @@ function runCommands(program, options) {
 }
 
 // src/workspace-info/list-projects.use-case.ts
-var import_node_path36 = require("path");
+var import_node_path37 = require("path");
 var TYPE_TAG_PREFIX = "type:";
 function listProjects(workspaceRoot) {
   return locateProjects(workspaceRoot).map((location) => {
-    const projectJsonPath = (0, import_node_path36.join)(workspaceRoot, location.dir, "project.json");
+    const projectJsonPath = (0, import_node_path37.join)(workspaceRoot, location.dir, "project.json");
     const project = fileExists(projectJsonPath) ? readJson(projectJsonPath) : {};
     const typeTag = (project.tags ?? []).find((tag) => tag.startsWith(TYPE_TAG_PREFIX));
     return {
@@ -8572,7 +8707,7 @@ function listProjects(workspaceRoot) {
   }).toSorted((a, b) => a.dir.localeCompare(b.dir));
 }
 function runProjects(workspaceRoot, options) {
-  if (!fileExists((0, import_node_path36.join)(workspaceRoot, "nx.json"))) {
+  if (!fileExists((0, import_node_path37.join)(workspaceRoot, "nx.json"))) {
     throw new Error("No nx.json found here. Run `projects` from the workspace root.");
   }
   const projects = listProjects(workspaceRoot);
@@ -8586,11 +8721,11 @@ function runProjects(workspaceRoot, options) {
 }
 
 // src/workspace-info/read-workspace-info.use-case.ts
-var import_node_path38 = require("path");
+var import_node_path39 = require("path");
 
 // src/cli-version/check-for-update.use-case.ts
-var import_node_fs31 = require("fs");
-var import_node_path37 = require("path");
+var import_node_fs32 = require("fs");
+var import_node_path38 = require("path");
 var import_cross_spawn3 = __toESM(require("cross-spawn"));
 var PACKAGE_NAME2 = "@mnci/cli";
 var REGISTRY_TIMEOUT_MS = 2e3;
@@ -8649,8 +8784,8 @@ function releaseTriple(version) {
 }
 function readCliVersion(packageDirectory) {
   try {
-    const manifestPath = (0, import_node_path37.join)(packageDirectory, "..", "package.json");
-    const manifest = JSON.parse((0, import_node_fs31.readFileSync)(manifestPath, "utf8"));
+    const manifestPath = (0, import_node_path38.join)(packageDirectory, "..", "package.json");
+    const manifest = JSON.parse((0, import_node_fs32.readFileSync)(manifestPath, "utf8"));
     return manifest.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -8660,7 +8795,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_path38.join)(workspaceRoot, "nx.json"));
+  const isWorkspace = fileExists((0, import_node_path39.join)(workspaceRoot, "nx.json"));
   return {
     cli: {
       version: cliVersion,
@@ -8681,8 +8816,8 @@ function runInfo(workspaceRoot, cliVersion, options) {
 }
 
 // src/workspace-creation/adopt-directory.use-case.ts
-var import_node_fs32 = require("fs");
-var import_node_path39 = require("path");
+var import_node_fs33 = require("fs");
+var import_node_path40 = require("path");
 var NEVER_COPIED = /* @__PURE__ */ new Set([".git", "node_modules"]);
 var AGENT_AND_CI_ENTRIES = [
   "AGENTS.md",
@@ -8713,13 +8848,13 @@ var PREFLIGHT_BLOCKERS = [
   "packages"
 ];
 function assertAdoptableDirectory(target) {
-  if (!(0, import_node_fs32.existsSync)(target)) {
+  if (!(0, import_node_fs33.existsSync)(target)) {
     throw new Error(`--into '${target}' does not exist. Create or clone it first.`);
   }
-  if (!(0, import_node_fs32.statSync)(target).isDirectory()) {
+  if (!(0, import_node_fs33.statSync)(target).isDirectory()) {
     throw new Error(`--into '${target}' is not a directory.`);
   }
-  const blockers = PREFLIGHT_BLOCKERS.filter((entry) => (0, import_node_fs32.existsSync)((0, import_node_path39.join)(target, entry)));
+  const blockers = PREFLIGHT_BLOCKERS.filter((entry) => (0, import_node_fs33.existsSync)((0, import_node_path40.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.`
@@ -8727,15 +8862,15 @@ function assertAdoptableDirectory(target) {
   }
 }
 function mergeGitignore(generatedFile, targetFile) {
-  const existing = (0, import_node_fs32.readFileSync)(targetFile, "utf8");
+  const existing = (0, import_node_fs33.readFileSync)(targetFile, "utf8");
   const present = new Set(existing.split("\n").map((line) => line.trim()));
-  const additions = (0, import_node_fs32.readFileSync)(generatedFile, "utf8").split("\n").map((line) => line.trimEnd()).filter((line) => {
+  const additions = (0, import_node_fs33.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_fs32.writeFileSync)(
+  (0, import_node_fs33.writeFileSync)(
     targetFile,
     `${existing}${separator}
 # Added by mnci (Nx workspace)
@@ -8745,9 +8880,9 @@ ${additions.join("\n")}
   return true;
 }
 function adoptGeneratedWorkspace(generatedRoot, target) {
-  const entries = (0, import_node_fs32.readdirSync)(generatedRoot).filter((entry) => !NEVER_COPIED.has(entry));
+  const entries = (0, import_node_fs33.readdirSync)(generatedRoot).filter((entry) => !NEVER_COPIED.has(entry));
   const collisions = entries.filter(
-    (entry) => (0, import_node_fs32.existsSync)((0, import_node_path39.join)(target, entry)) && !EXISTING_WINS.has(entry) && entry !== ".gitignore"
+    (entry) => (0, import_node_fs33.existsSync)((0, import_node_path40.join)(target, entry)) && !EXISTING_WINS.has(entry) && entry !== ".gitignore"
   );
   if (collisions.length > 0) {
     throw new Error(
@@ -8756,28 +8891,28 @@ function adoptGeneratedWorkspace(generatedRoot, target) {
   }
   const result = { copied: [], kept: [], mergedGitignore: false };
   for (const entry of entries) {
-    const from = (0, import_node_path39.join)(generatedRoot, entry);
-    const to = (0, import_node_path39.join)(target, entry);
-    if (entry === ".gitignore" && (0, import_node_fs32.existsSync)(to)) {
+    const from = (0, import_node_path40.join)(generatedRoot, entry);
+    const to = (0, import_node_path40.join)(target, entry);
+    if (entry === ".gitignore" && (0, import_node_fs33.existsSync)(to)) {
       result.mergedGitignore = mergeGitignore(from, to);
       result.kept.push(entry);
       continue;
     }
-    if ((0, import_node_fs32.existsSync)(to)) {
+    if ((0, import_node_fs33.existsSync)(to)) {
       result.kept.push(entry);
       continue;
     }
-    (0, import_node_fs32.cpSync)(from, to, { recursive: true });
+    (0, import_node_fs33.cpSync)(from, to, { recursive: true });
     result.copied.push(entry);
   }
-  (0, import_node_fs32.rmSync)(generatedRoot, { recursive: true, force: true });
+  (0, import_node_fs33.rmSync)(generatedRoot, { recursive: true, force: true });
   return result;
 }
 
 // src/workspace-creation/create-workspace.use-case.ts
-var import_node_fs33 = require("fs");
+var import_node_fs34 = require("fs");
 var import_node_os2 = require("os");
-var import_node_path40 = require("path");
+var import_node_path41 = require("path");
 function nxCloudProviderValue(ci) {
   return ci === "azure" ? "azure" : "github";
 }
@@ -8820,9 +8955,9 @@ async function resolveRegistry(options) {
   return await promptRegistry();
 }
 async function runNew(name, options) {
-  const adoptTarget = options.into === void 0 ? void 0 : (0, import_node_path40.resolve)(process.cwd(), options.into);
+  const adoptTarget = options.into === void 0 ? void 0 : (0, import_node_path41.resolve)(process.cwd(), options.into);
   if (adoptTarget !== void 0) assertAdoptableDirectory(adoptTarget);
-  const workspaceName = name ?? (adoptTarget === void 0 ? await promptText("Workspace name") : (0, import_node_path40.basename)(adoptTarget));
+  const workspaceName = name ?? (adoptTarget === void 0 ? await promptText("Workspace name") : (0, import_node_path41.basename)(adoptTarget));
   assertValidProjectName(workspaceName, "Workspace name");
   const scope = options.scope ?? (options.yes ? `@${workspaceName}` : await promptText("npm scope for publishable packages", `@${workspaceName}`));
   const registry = await resolveRegistry(options);
@@ -8835,8 +8970,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_fs33.mkdtempSync)((0, import_node_path40.join)((0, import_node_os2.tmpdir)(), "mnci-new-"));
-  let workspaceRoot = (0, import_node_path40.join)(stagingParent, workspaceName);
+  const stagingParent = adoptTarget === void 0 ? process.cwd() : (0, import_node_fs34.mkdtempSync)((0, import_node_path41.join)((0, import_node_os2.tmpdir)(), "mnci-new-"));
+  let workspaceRoot = (0, import_node_path41.join)(stagingParent, workspaceName);
   try {
     logger.step(`Creating Nx workspace '${workspaceName}' (preset: ts)`);
     runNpx(
@@ -8859,7 +8994,7 @@ async function runNew(name, options) {
       workspaceRoot = adoptTarget;
     }
   } finally {
-    if (adoptTarget !== void 0) (0, import_node_fs33.rmSync)(stagingParent, { recursive: true, force: true });
+    if (adoptTarget !== void 0) (0, import_node_fs34.rmSync)(stagingParent, { recursive: true, force: true });
   }
   logger.step(
     "Applying MoNecromanCI overlay (VS Code workspace, release config, .npmrc, commitlint, pipeline, stack)"
@@ -8869,8 +9004,8 @@ async function runNew(name, options) {
     { workspaceName, scope, registry, agent, variableGroup, ci, stack, ...npmAuth && { npmAuth } },
     logger.detail
   );
-  (0, import_node_fs33.rmSync)((0, import_node_path40.join)(workspaceRoot, "node_modules"), { recursive: true, force: true });
-  (0, import_node_fs33.rmSync)((0, import_node_path40.join)(workspaceRoot, "package-lock.json"), { force: true });
+  (0, import_node_fs34.rmSync)((0, import_node_path41.join)(workspaceRoot, "node_modules"), { recursive: true, force: true });
+  (0, import_node_fs34.rmSync)((0, import_node_path41.join)(workspaceRoot, "package-lock.json"), { force: true });
   logger.step("Installing the toolchain (commitlint + husky + linting/formatting)");
   const installStatus = runShell(
     "npm",
@@ -8908,12 +9043,12 @@ function projectKindHintLines(kinds = PROJECT_KINDS) {
 }
 
 // src/workspace-creation/interactive-wizard.use-case.ts
-var import_node_path42 = require("path");
+var import_node_path43 = require("path");
 var import_prompts4 = require("@inquirer/prompts");
 
 // src/workspace-upgrade/upgrade-workspace.use-case.ts
-var import_node_fs34 = require("fs");
-var import_node_path41 = require("path");
+var import_node_fs35 = require("fs");
+var import_node_path42 = require("path");
 function resolveRegistry2(options, persisted) {
   if (options.registry === "azure-artifacts" || options.organization && options.artifactsFeed) {
     const persistedAzure = persisted?.kind === "azure-artifacts" ? persisted : void 0;
@@ -8942,7 +9077,7 @@ function resolveWorkspaceName(workspaceRoot, persisted) {
     return persisted.workspaceName;
   }
   try {
-    const existing = (0, import_node_fs34.readdirSync)(workspaceRoot).find(
+    const existing = (0, import_node_fs35.readdirSync)(workspaceRoot).find(
       (file) => file.endsWith(".code-workspace") && file !== "undefined.code-workspace"
     );
     if (existing) {
@@ -8950,11 +9085,11 @@ function resolveWorkspaceName(workspaceRoot, persisted) {
     }
   } catch {
   }
-  return (0, import_node_path41.basename)(workspaceRoot);
+  return (0, import_node_path42.basename)(workspaceRoot);
 }
 function detectNpmAuth(workspaceRoot) {
   try {
-    return (0, import_node_fs34.readFileSync)((0, import_node_path41.join)(workspaceRoot, "azure-pipelines.yml"), "utf8").includes("npmAuthenticate@0") ? "build-identity" : void 0;
+    return (0, import_node_fs35.readFileSync)((0, import_node_path42.join)(workspaceRoot, "azure-pipelines.yml"), "utf8").includes("npmAuthenticate@0") ? "build-identity" : void 0;
   } catch {
     return void 0;
   }
@@ -9001,7 +9136,7 @@ function resolveOverlayOptions(workspaceRoot, options, persisted) {
   };
 }
 function runUpgrade(workspaceRoot, options) {
-  if (!fileExists((0, import_node_path41.join)(workspaceRoot, "nx.json"))) {
+  if (!fileExists((0, import_node_path42.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.`
     );
@@ -9075,7 +9210,7 @@ function runUpgrade(workspaceRoot, options) {
     "Formatting the workspace (eslint --fix) \u2014 the slowest step, minutes on a large workspace"
   );
   runFormatter(workspaceRoot);
-  const nxJson = readJson((0, import_node_path41.join)(workspaceRoot, "nx.json"));
+  const nxJson = readJson((0, import_node_path42.join)(workspaceRoot, "nx.json"));
   const stranded = locateStrandedReleaseTags(workspaceRoot, nxJson.release?.releaseTag?.pattern);
   for (const entry of stranded) {
     logger.warn(`${entry.project} has release tags only under ${entry.oldTag}: nx release would restart it from its disk version. Run \`git tag ${entry.newTag} ${entry.oldTag}^{commit}\` before the next release (\`mnci doctor\` lists them all).`);
@@ -9086,7 +9221,7 @@ function runUpgrade(workspaceRoot, options) {
 
 // src/workspace-creation/interactive-wizard.use-case.ts
 async function runInteractive() {
-  const inWorkspace = fileExists((0, import_node_path42.join)(process.cwd(), "nx.json"));
+  const inWorkspace = fileExists((0, import_node_path43.join)(process.cwd(), "nx.json"));
   const choiceNew = { name: "Create a new monorepo", value: "new" };
   const choiceAdd = { name: "Add a project to this workspace", value: "add" };
   const choiceUpgrade = {
@@ -9138,6 +9273,9 @@ function buildProgram(cliVersion) {
   ).option("--json", "print the findings as one JSON document, each with its remedy").action((options) => {
     runDoctor(process.cwd(), options);
   });
+  program.command("adopt").description("Read an existing repository and report what bringing it under mnci would involve: blockers, warnings and the step that clears each. Read-only; exits non-zero when something blocks").option("--json", "print the report as one JSON document").action((options) => {
+    runAdopt(process.cwd(), options);
+  });
   program.command("ci").addArgument(new import_commander.Argument("<phase>", "which phase of the pipeline to run").choices(CI_PHASES)).description(
     "Run a phase of the CI pipeline here, the same way CI runs it: `verify` is the sync check and then every project (or, in a pull request, the affected ones) through lint, typecheck, test and build. `setup` installs the Python, Go and Flutter toolchains the workspace needs, `audit` fails on a known advisory that has a fix, `pack` builds the per-app artifacts, `release` versions, tags and publishes, and `native` builds the apps that need a C toolchain on this OS. Exits non-zero when it fails"
   ).action(async (phase) => {