@mnci/cli 4.6.2 → 4.7.1

package/README.md

@@ -81,6 +81,7 @@ consumers point at it.
 mnci new my-repo            # create a monorepo (prompts scope + registry)
 mnci new my-repo --yes --registry npm --scope @my
 mnci new my-repo --yes --registry npm --scope @my --nx-cloud  # opt in to Nx Cloud
+mnci new --into .           # ...or bootstrap into a clone that already exists
 
 cd my-repo
 mnci add react-app web         # @nx/react (Vite + Jest)
@@ -613,6 +614,23 @@ the editor. It also makes `space-before-function-paren` enforceable for the
 first time: every Prettier-compatible formatter, oxfmt included, rewrites
 `function f (a)` back to `function f(a)`.
 
+**`npm run lint` checks one thing `npm run format` does not.** `lint` is
+`nx run-many -t lint`; `format` is a bare `eslint . --fix --cache`. The
+`@nx/dependency-checks` rule needs the Nx project graph, and outside a target it
+prints `No cached ProjectGraph is available. The rule will be skipped.` So a
+dependency problem shows up in `lint` and never in `format`, your editor, or a
+pre-commit hook.
+
+That asymmetry is now a safety property rather than a hazard. The rule is
+**fixable**, and `format` passes `--fix`; when the graph was warm — which it is
+after any `nx` command in the same workspace — a `format` run could and did
+rewrite `package.json`. `@mnci/eslint-config` turns off the two checks whose
+fixers do that (`checkObsoleteDependencies`, `checkVersionMismatches`), so
+neither path is destructive, and the skip means `format` cannot reach a manifest
+at all. Warm the graph deliberately (`npx nx show projects`) if you want the
+rule evaluated in `format` too; mnci does not, because it would make every
+format run pay for a graph computation to enforce what `lint` already gates.
+
 **Upgrading an older workspace.** `mnci upgrade` deletes every config a previous
 version could have written for a second tool — `.prettierrc`, `.prettierrc.json`,
 `.prettierrc.mjs`, `.prettierignore`, `.oxfmtrc.json`, `oxlint.config.ts` — and
@@ -623,6 +641,47 @@ formatter from the **project's** dependencies, so a stale declaration is enough
 to reformat on save against an opinion nothing checks. `mnci doctor` reports a
 workspace that has not been upgraded yet.
 
+## `--into`: bootstrapping into a repository that already exists
+
+`create-nx-workspace <name>` creates the directory itself and exits with
+`DIRECTORY_EXISTS` when one is already there. That rules out the most common
+way a repository actually starts: the host creates it, you clone it, and the
+clone holds a `.git` directory, a README and a licence. Doing it by hand means
+generating into a temp parent, copying everything except `.git` and
+`node_modules` across, and reinstalling — four steps, each of which can quietly
+lose a file.
+
+`mnci new --into <dir>` is that, done once and tested:
+
+```sh
+git clone git@github.com:me/my-repo.git
+cd my-repo
+mnci new --into .
+```
+
+The workspace name defaults to the directory's name, because the directory is
+already named and retyping it is a way to get the two out of step; pass a name
+argument to override it.
+
+What it does with the files that are already there is the whole of the risk, so
+every case is decided in advance:
+
+| Already in the directory | What happens |
+| --- | --- |
+| `.git` | Never touched. Keeping it is the point. |
+| `README.md`, `LICENSE*` | **Kept.** The generator's README is boilerplate; yours is usually the only hand-written file in the repository. |
+| `.gitignore` | **Merged.** Your lines stay, and the generated ones (`.nx/cache`, `dist`, `out-tsc`, …) are appended under a labelled heading. Lines already present are not repeated, so it is idempotent. |
+| Anything else the new workspace also writes | **Refused**, naming every collision, before a single file is written. |
+| Anything the new workspace does not write | Left alone. |
+
+Two checks, not one. A directory holding `package.json`, `nx.json`,
+`tsconfig.base.json`, `node_modules`, `apps/`, `libs/` or `packages/` is
+rejected **before** anything is generated — it is a project already, and the
+answer there is `mnci upgrade`, not `mnci new`. The full collision check needs
+the generated tree, so it runs afterwards, but still before the first write:
+a refusal leaves the target byte-identical to how it was found, and the staging
+copy is discarded.
+
 ## Layout convention = release scoping
 
 | Directory          | Contents                                                       | Released?                              |

package/dist/cli.js

@@ -147,7 +147,7 @@ function runCapture(command, arguments_, cwd) {
   return { status: result.status ?? 1, stdout: result.stdout ?? "" };
 }
 async function runCaptureAsync(command, arguments_, cwd) {
-  return await new Promise((resolve) => {
+  return await new Promise((resolve2) => {
     const child = (0, import_cross_spawn.default)(command, arguments_, {
       cwd,
       timeout: CAPTURE_TIMEOUT_MS,
@@ -159,10 +159,10 @@ async function runCaptureAsync(command, arguments_, cwd) {
       stdout += chunk;
     });
     child.on("error", () => {
-      resolve({ status: 1, stdout: "" });
+      resolve2({ status: 1, stdout: "" });
     });
     child.on("close", (code) => {
-      resolve({ status: code ?? 1, stdout });
+      resolve2({ status: code ?? 1, stdout });
     });
   });
 }
@@ -1558,7 +1558,58 @@ updates:
   }
   return config;
 }
-var NX_SCAFFOLDING_TO_REMOVE = [".prettierrc", ".prettierrc.json", ".vscode"];
+var NX_SCAFFOLDING_TO_REMOVE = [
+  ".prettierrc",
+  ".prettierrc.json",
+  ".vscode",
+  // See LOCAL_REGISTRY_SCAFFOLDING: the config half of a publishing mechanism
+  // this workspace does not use.
+  ".verdaccio",
+  // The AI-agent set, in full. See the remarks above: a partial delete leaves
+  // every `nx` command printing an "outdated configuration" nag.
+  ".agents",
+  ".claude",
+  ".codex",
+  ".cursor",
+  ".gemini",
+  ".opencode",
+  ".github/agents",
+  ".github/prompts",
+  ".github/skills",
+  "AGENTS.md",
+  "CLAUDE.md",
+  "opencode.json"
+];
+function withoutKey(record, key) {
+  return Object.fromEntries(Object.entries(record).filter(([name]) => name !== key));
+}
+var LOCAL_REGISTRY_SCAFFOLDING = {
+  /** The config directory, removed with the rest of {@link NX_SCAFFOLDING_TO_REMOVE}. */
+  directory: ".verdaccio",
+  /** The root devDependency the target runs. */
+  devDependency: "verdaccio",
+  /** The root Nx target wired to both of the above. */
+  rootTarget: "local-registry"
+};
+function removeLocalRegistryScaffolding(workspaceRoot) {
+  (0, import_node_fs2.rmSync)((0, import_node_path2.join)(workspaceRoot, LOCAL_REGISTRY_SCAFFOLDING.directory), {
+    recursive: true,
+    force: true
+  });
+  const manifestPath = (0, import_node_path2.join)(workspaceRoot, "package.json");
+  if (!fileExists(manifestPath)) return;
+  const manifest = readJson(manifestPath);
+  if (manifest.devDependencies?.[LOCAL_REGISTRY_SCAFFOLDING.devDependency] !== void 0) {
+    delete manifest.devDependencies[LOCAL_REGISTRY_SCAFFOLDING.devDependency];
+    if (Object.keys(manifest.devDependencies).length === 0) delete manifest.devDependencies;
+  }
+  if (manifest.nx?.targets?.[LOCAL_REGISTRY_SCAFFOLDING.rootTarget] !== void 0) {
+    delete manifest.nx.targets[LOCAL_REGISTRY_SCAFFOLDING.rootTarget];
+    if (Object.keys(manifest.nx.targets).length === 0) delete manifest.nx.targets;
+    if (Object.keys(manifest.nx).length === 0) delete manifest.nx;
+  }
+  writeFileEnsured(manifestPath, toJson(manifest));
+}
 function removeNxScaffolding(workspaceRoot) {
   for (const entry of NX_SCAFFOLDING_TO_REMOVE) {
     (0, import_node_fs2.rmSync)((0, import_node_path2.join)(workspaceRoot, entry), { recursive: true, force: true });
@@ -1586,6 +1637,38 @@ function ensureEslintCacheIgnored(workspaceRoot) {
 `
   );
 }
+var PYTHON_ARTEFACT_IGNORES = ["__pycache__/", "*.py[cod]"];
+function ensurePythonArtefactsIgnored(workspaceRoot) {
+  const gitignorePath = (0, import_node_path2.join)(workspaceRoot, ".gitignore");
+  if (!fileExists(gitignorePath)) {
+    return;
+  }
+  const hasPython = (0, import_node_fs2.globSync)(
+    ["python-packages/*/pyproject.toml", "apps/*/pyproject.toml", "libs/*/pyproject.toml"],
+    { cwd: workspaceRoot }
+  ).length > 0;
+  if (!hasPython) {
+    return;
+  }
+  const current = (0, import_node_fs2.readFileSync)(gitignorePath, "utf8");
+  const present = new Set(current.split("\n").map((line) => line.trim()));
+  const missing = PYTHON_ARTEFACT_IGNORES.filter((line) => !present.has(line));
+  if (missing.length === 0) {
+    return;
+  }
+  const withoutTrailingBlankLines = current.replace(/\n+$/u, "");
+  const separator = withoutTrailingBlankLines.length > 0 ? "\n\n" : "";
+  const heading = [
+    "# Added by MoNecromanCI: Python bytecode. The tool caches (.mypy_cache,",
+    "# .pytest_cache, .ruff_cache) write their own .gitignore; CPython does not."
+  ].join("\n");
+  writeFileEnsured(
+    gitignorePath,
+    `${withoutTrailingBlankLines}${separator}${heading}
+${missing.join("\n")}
+`
+  );
+}
 function removeProjectEslintConfigs(workspaceRoot) {
   const matches = (0, import_node_fs2.globSync)("{apps,libs,packages}/*/eslint.config.{js,mjs,cjs,ts,mts,cts}", {
     cwd: workspaceRoot
@@ -1621,12 +1704,15 @@ function applyOverlay(workspaceRoot, options, onProgress = () => {
     ...rootScripts()
   };
   const existingDevDeps = manifest.devDependencies;
-  const devDeps = withoutRetiredFormatterDependencies({
-    ...existingDevDeps,
-    ...TS_COMPILER_DEPENDENCIES,
-    // The preset pins `nx` itself; the ESLint plugins must match it exactly.
-    ...eslintToolchainDependencies(existingDevDeps?.nx ?? "latest")
-  });
+  const devDeps = withoutKey(
+    withoutRetiredFormatterDependencies({
+      ...existingDevDeps,
+      ...TS_COMPILER_DEPENDENCIES,
+      // The preset pins `nx` itself; the ESLint plugins must match it exactly.
+      ...eslintToolchainDependencies(existingDevDeps?.nx ?? "latest")
+    }),
+    LOCAL_REGISTRY_SCAFFOLDING.devDependency
+  );
   const overrides = {
     ...manifest.overrides,
     ...ESLINT_PEER_OVERRIDES,
@@ -1638,11 +1724,15 @@ function applyOverlay(workspaceRoot, options, onProgress = () => {
     ...reactExpressPeerOverride(manifest)
   };
   const existingNx = manifest.nx;
+  const existingTargets = withoutKey(
+    existingNx?.targets ?? {},
+    LOCAL_REGISTRY_SCAFFOLDING.rootTarget
+  );
   const nx = {
     ...existingNx,
     includedScripts: existingNx?.includedScripts ?? [],
     targets: {
-      ...existingNx?.targets,
+      ...existingTargets,
       lint: ROOT_LINT_TARGET
     }
   };
@@ -1670,6 +1760,7 @@ function applyOverlay(workspaceRoot, options, onProgress = () => {
   writeFileEnsured((0, import_node_path2.join)(workspaceRoot, ESLINT_MNCI_FILENAME), ESLINT_MNCI_CONFIG);
   writeEslintEntryPoint(workspaceRoot, onProgress);
   ensureEslintCacheIgnored(workspaceRoot);
+  ensurePythonArtefactsIgnored(workspaceRoot);
   for (const retired of RETIRED_FORMATTER_FILES) {
     removeIfPresent((0, import_node_path2.join)(workspaceRoot, retired));
   }
@@ -2937,6 +3028,7 @@ async function addNpmLib(workspaceRoot, name, options, kindProvided, stack) {
       repairDeclarationSpecifiers(projectRoot);
       writeProjectReadme(projectRoot, `${scope}/${name}`, stack.testRunner);
       removeGeneratedEslintConfig(workspaceRoot, `packages/${name}`);
+      removeLocalRegistryScaffolding(workspaceRoot);
       registerProjectCommands(workspaceRoot, name, { build: true });
     }
   );
@@ -3283,6 +3375,7 @@ async function addReactLib(workspaceRoot, name, options, kindProvided, stack) {
       repairDeclarationSpecifiers(projectRoot);
       writeProjectReadme(projectRoot, `${scope}/${name}`, stack.testRunner);
       removeGeneratedEslintConfig(workspaceRoot, `packages/${name}`);
+      removeLocalRegistryScaffolding(workspaceRoot);
       registerProjectCommands(workspaceRoot, name, { build: true });
     }
   );
@@ -4838,9 +4931,86 @@ function runDoctor(workspaceRoot) {
   process.exitCode = 1;
 }
 
-// src/workspace-creation/create-workspace.use-case.ts
+// src/workspace-creation/adopt-directory.use-case.ts
 var import_node_fs13 = require("fs");
 var import_node_path20 = require("path");
+var NEVER_COPIED = /* @__PURE__ */ new Set([".git", "node_modules"]);
+var EXISTING_WINS = /* @__PURE__ */ new Set(["README.md", "LICENSE", "LICENSE.md", "LICENSE.txt"]);
+var PREFLIGHT_BLOCKERS = [
+  "package.json",
+  "nx.json",
+  "tsconfig.base.json",
+  "node_modules",
+  "apps",
+  "libs",
+  "packages"
+];
+function assertAdoptableDirectory(target) {
+  if (!(0, import_node_fs13.existsSync)(target)) {
+    throw new Error(`--into '${target}' does not exist. Create or clone it first.`);
+  }
+  if (!(0, import_node_fs13.statSync)(target).isDirectory()) {
+    throw new Error(`--into '${target}' is not a directory.`);
+  }
+  const blockers = PREFLIGHT_BLOCKERS.filter((entry) => (0, import_node_fs13.existsSync)((0, import_node_path20.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.`
+    );
+  }
+}
+function mergeGitignore(generatedFile, targetFile) {
+  const existing = (0, import_node_fs13.readFileSync)(targetFile, "utf8");
+  const present = new Set(existing.split("\n").map((line) => line.trim()));
+  const additions = (0, import_node_fs13.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_fs13.writeFileSync)(
+    targetFile,
+    `${existing}${separator}
+# Added by mnci (Nx workspace)
+${additions.join("\n")}
+`
+  );
+  return true;
+}
+function adoptGeneratedWorkspace(generatedRoot, target) {
+  const entries = (0, import_node_fs13.readdirSync)(generatedRoot).filter((entry) => !NEVER_COPIED.has(entry));
+  const collisions = entries.filter(
+    (entry) => (0, import_node_fs13.existsSync)((0, import_node_path20.join)(target, entry)) && !EXISTING_WINS.has(entry) && entry !== ".gitignore"
+  );
+  if (collisions.length > 0) {
+    throw new Error(
+      `--into '${target}' already contains ${collisions.join(", ")}, which the new workspace also writes. Move those aside and run it again; nothing has been changed.`
+    );
+  }
+  const result = { copied: [], kept: [], mergedGitignore: false };
+  for (const entry of entries) {
+    const from = (0, import_node_path20.join)(generatedRoot, entry);
+    const to = (0, import_node_path20.join)(target, entry);
+    if (entry === ".gitignore" && (0, import_node_fs13.existsSync)(to)) {
+      result.mergedGitignore = mergeGitignore(from, to);
+      result.kept.push(entry);
+      continue;
+    }
+    if ((0, import_node_fs13.existsSync)(to)) {
+      result.kept.push(entry);
+      continue;
+    }
+    (0, import_node_fs13.cpSync)(from, to, { recursive: true });
+    result.copied.push(entry);
+  }
+  (0, import_node_fs13.rmSync)(generatedRoot, { recursive: true, force: true });
+  return result;
+}
+
+// src/workspace-creation/create-workspace.use-case.ts
+var import_node_fs14 = require("fs");
+var import_node_os = require("os");
+var import_node_path21 = require("path");
 function nxCloudProviderValue(ci) {
   return ci === "azure" ? "azure" : "github";
 }
@@ -4876,7 +5046,9 @@ async function resolveRegistry(options) {
   return await promptRegistry();
 }
 async function runNew(name, options) {
-  const workspaceName = name ?? await promptText("Workspace name");
+  const adoptTarget = options.into === void 0 ? void 0 : (0, import_node_path21.resolve)(process.cwd(), options.into);
+  if (adoptTarget !== void 0) assertAdoptableDirectory(adoptTarget);
+  const workspaceName = name ?? (adoptTarget === void 0 ? await promptText("Workspace name") : (0, import_node_path21.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);
@@ -4888,6 +5060,7 @@ async function runNew(name, options) {
   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());
+  const stagingParent = adoptTarget === void 0 ? process.cwd() : (0, import_node_fs14.mkdtempSync)((0, import_node_path21.join)((0, import_node_os.tmpdir)(), "mnci-new-"));
   logger.step(`Creating Nx workspace '${workspaceName}' (preset: ts)`);
   runNpx(
     [
@@ -4899,9 +5072,17 @@ async function runNew(name, options) {
       nxCloud ? `--nxCloud=${nxCloudProviderValue(ci)}` : "--nxCloud=skip",
       "--no-interactive"
     ],
-    process.cwd()
+    stagingParent
   );
-  const workspaceRoot = (0, import_node_path20.join)(process.cwd(), workspaceName);
+  let workspaceRoot = (0, import_node_path21.join)(stagingParent, workspaceName);
+  if (adoptTarget !== void 0) {
+    logger.step(`Adopting ${adoptTarget} (keeping its .git)`);
+    const adoption = adoptGeneratedWorkspace(workspaceRoot, adoptTarget);
+    for (const kept of adoption.kept) logger.detail(`kept the existing ${kept}`);
+    if (adoption.mergedGitignore) logger.detail("merged the generated .gitignore into the existing one");
+    (0, import_node_fs14.rmSync)(stagingParent, { recursive: true, force: true });
+    workspaceRoot = adoptTarget;
+  }
   logger.step(
     "Applying MoNecromanCI overlay (VS Code workspace, release config, .npmrc, commitlint, pipeline, stack)"
   );
@@ -4910,8 +5091,8 @@ async function runNew(name, options) {
     { workspaceName, scope, registry, agent, variableGroup, ci, stack },
     logger.detail
   );
-  (0, import_node_fs13.rmSync)((0, import_node_path20.join)(workspaceRoot, "node_modules"), { recursive: true, force: true });
-  (0, import_node_fs13.rmSync)((0, import_node_path20.join)(workspaceRoot, "package-lock.json"), { force: true });
+  (0, import_node_fs14.rmSync)((0, import_node_path21.join)(workspaceRoot, "node_modules"), { recursive: true, force: true });
+  (0, import_node_fs14.rmSync)((0, import_node_path21.join)(workspaceRoot, "package-lock.json"), { force: true });
   logger.step("Installing the toolchain (commitlint + husky + linting/formatting)");
   const installStatus = runShell(
     "npm",
@@ -4925,7 +5106,7 @@ async function runNew(name, options) {
   logger.step("Formatting the workspace (eslint --fix, JavaScript Standard Style)");
   runFormatter(workspaceRoot);
   logger.success("Done. Next steps:");
-  logger.info(`  cd ${workspaceName}`);
+  if (adoptTarget === void 0) logger.info(`  cd ${workspaceName}`);
   logger.info("  mnci add react-app web        # or: react-lib, react-internal-lib, node-app,");
   logger.info("                                 #     node-function-app, npm-lib, internal-lib,");
   logger.info(
@@ -4941,12 +5122,12 @@ async function runNew(name, options) {
 }
 
 // src/workspace-creation/interactive-wizard.use-case.ts
-var import_node_path22 = require("path");
+var import_node_path23 = require("path");
 var import_prompts4 = require("@inquirer/prompts");
 
 // src/workspace-upgrade/upgrade-workspace.use-case.ts
-var import_node_fs14 = require("fs");
-var import_node_path21 = require("path");
+var import_node_fs15 = require("fs");
+var import_node_path22 = require("path");
 function resolveRegistry2(options, persisted) {
   if (options.registry === "azure-artifacts" || options.organization && options.artifactsFeed) {
     const persistedAzure = persisted?.kind === "azure-artifacts" ? persisted : void 0;
@@ -4975,7 +5156,7 @@ function resolveWorkspaceName(workspaceRoot, persisted) {
     return persisted.workspaceName;
   }
   try {
-    const existing = (0, import_node_fs14.readdirSync)(workspaceRoot).find(
+    const existing = (0, import_node_fs15.readdirSync)(workspaceRoot).find(
       (file) => file.endsWith(".code-workspace") && file !== "undefined.code-workspace"
     );
     if (existing) {
@@ -4983,7 +5164,7 @@ function resolveWorkspaceName(workspaceRoot, persisted) {
     }
   } catch {
   }
-  return (0, import_node_path21.basename)(workspaceRoot);
+  return (0, import_node_path22.basename)(workspaceRoot);
 }
 function resolveOverlayOptions(workspaceRoot, options, persisted) {
   const scope = options.scope ?? persisted.scope;
@@ -5021,7 +5202,7 @@ function resolveOverlayOptions(workspaceRoot, options, persisted) {
   };
 }
 function runUpgrade(workspaceRoot, options) {
-  if (!fileExists((0, import_node_path21.join)(workspaceRoot, "nx.json"))) {
+  if (!fileExists((0, import_node_path22.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.`
     );
@@ -5060,7 +5241,7 @@ function runUpgrade(workspaceRoot, options) {
 
 // src/workspace-creation/interactive-wizard.use-case.ts
 async function runInteractive() {
-  const inWorkspace = fileExists((0, import_node_path22.join)(process.cwd(), "nx.json"));
+  const inWorkspace = fileExists((0, import_node_path23.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 = {
@@ -5081,8 +5262,8 @@ async function runInteractive() {
 }
 
 // src/cli-version/check-for-update.use-case.ts
-var import_node_fs15 = require("fs");
-var import_node_path23 = require("path");
+var import_node_fs16 = require("fs");
+var import_node_path24 = require("path");
 var import_cross_spawn2 = __toESM(require("cross-spawn"));
 var PACKAGE_NAME = "@mnci/cli";
 var REGISTRY_TIMEOUT_MS = 2e3;
@@ -5138,8 +5319,8 @@ function releaseTriple(version) {
 }
 function readCliVersion(packageDirectory) {
   try {
-    const manifestPath = (0, import_node_path23.join)(packageDirectory, "..", "package.json");
-    const manifest = JSON.parse((0, import_node_fs15.readFileSync)(manifestPath, "utf8"));
+    const manifestPath = (0, import_node_path24.join)(packageDirectory, "..", "package.json");
+    const manifest = JSON.parse((0, import_node_fs16.readFileSync)(manifestPath, "utf8"));
     return manifest.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -5153,7 +5334,10 @@ function buildProgram(cliVersion) {
   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) => {
+  ).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)").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"
+  ).action(async (name, options) => {
     await runNew(name, options);
   });
   program.command("upgrade").description(