create-nx-archweave 0.3.2 → 0.3.3

package/dist/bin.js

@@ -1,284 +1,31 @@
 #!/usr/bin/env node
+import {
+  AI_HOST_CHOICES,
+  AI_HOST_PROBES,
+  AI_HOST_VALUES,
+  PLUGIN_CHOICES,
+  buildPlan,
+  choosePackageManager,
+  collectMissingInputs,
+  createProcessExec,
+  describeResolution,
+  executePlan,
+  nxGenerateCommand,
+  parseCliArgs,
+  renderExecuteReport,
+  renderStepTimings,
+  renderUsage,
+  renderVersion,
+  reviewProviderConflict,
+  spawnableCommand
+} from "./_chunks/chunk-WIJBUA2L.js";
 
 // src/bin.ts
-import { execFile, spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync2 } from "node:fs";
-import { join as join3 } from "node:path";
+import { execFile, spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
 import { createInterface } from "node:readline/promises";
 
-// src/cli/parse-args.ts
-import { parseArgs as parseNodeArgs } from "node:util";
-
-// src/cli/types.ts
-var PRESET_VALUES = ["quick-start", "solo", "team"];
-var FRONTEND_VALUES = ["react-vite", "next", "none"];
-var BACKEND_VALUES = ["express", "nest", "none"];
-var LOCALE_VALUES = ["ko", "en"];
-var AI_HOST_CHOICES = [
-  { id: "claude-code", label: "Claude Code", nxAgent: "claude", reviewProvider: "claude" },
-  { id: "codex", label: "Codex", nxAgent: "codex", reviewProvider: "gpt" },
-  { id: "cursor", label: "Cursor", nxAgent: "cursor", reviewProvider: "cursor" },
-  { id: "gemini-cli", label: "Gemini CLI", nxAgent: "gemini", reviewProvider: "gemini" }
-];
-var REVIEW_PROVIDER_CHOICES = [
-  { id: "claude", label: "Claude" },
-  { id: "gemini", label: "Gemini (beta)" },
-  { id: "gpt", label: "GPT (beta)" },
-  { id: "cursor", label: "Cursor (beta)" }
-];
-var REVIEW_PROVIDER_VALUES = REVIEW_PROVIDER_CHOICES.map((provider) => provider.id);
-var AI_HOST_VALUES = AI_HOST_CHOICES.map((host) => host.id);
-var DEFAULT_AI_HOSTS = ["claude-code"];
-var AI_HOST_PROBES = {
-  "claude-code": "claude",
-  codex: "codex",
-  cursor: "cursor-agent",
-  "gemini-cli": "gemini"
-};
-var PLUGIN_CHOICES = [
-  {
-    id: "ponytail",
-    label: "ponytail",
-    description: 'over-engineering review rules and skills \u2014 "makes your AI agent think like the laziest senior dev in the room"',
-    license: "MIT",
-    host: "claude-code"
-  }
-];
-var PLUGIN_VALUES = PLUGIN_CHOICES.map((plugin) => plugin.id);
-
-// src/cli/package-manager.ts
-var SUPPORTED = ["npm", "pnpm", "yarn", "bun"];
-function isCliPackageManager(name) {
-  return SUPPORTED.includes(name);
-}
-function parseUserAgent(userAgent) {
-  const match = /^([a-z][a-z0-9-]*)\/(\S+)/.exec(userAgent?.trim() ?? "");
-  if (!match) return void 0;
-  return { name: match[1], version: match[2] === "?" ? void 0 : match[2] };
-}
-function listInstalledManagers(launcher, probe) {
-  const installed = [];
-  for (const name of SUPPORTED) {
-    const version = launcher?.name === name ? launcher.version ?? "" : probe(name)?.trim();
-    if (version !== void 0) installed.push({ name, version: version === "" ? void 0 : version });
-    else if (name === "npm") installed.push({ name, version: void 0 });
-  }
-  return installed;
-}
-var NOTHING_CREATED = "Nothing was created.";
-async function choosePackageManager(input, ask, tell) {
-  const launcher = parseUserAgent(input.userAgent);
-  const resolveNamed = (name, source) => {
-    const version = launcher?.name === name && launcher.version ? launcher.version : input.probe(name)?.trim() || void 0;
-    return { packageManager: name, source, version };
-  };
-  if (input.flag) return resolveNamed(input.flag, "flag");
-  if (!input.interactive) {
-    if (!launcher) return resolveNamed("npm", "default");
-    if (!isCliPackageManager(launcher.name)) {
-      return {
-        error: `create-nx-archweave was started with ${launcher.name}, which it does not support (${SUPPORTED_TEXT} are). Re-run with npx, pnpm dlx, yarn dlx or bunx, or pass --package-manager=${SUPPORTED.join("|")}. ${NOTHING_CREATED}`
-      };
-    }
-    return resolveNamed(launcher.name, "launcher");
-  }
-  if (launcher && !isCliPackageManager(launcher.name)) {
-    tell(`${launcher.name} is not supported (${SUPPORTED_TEXT} are) \u2014 choosing from the supported ones instead.`);
-  }
-  const installed = listInstalledManagers(launcher, input.probe);
-  if (installed.length === 1) return { packageManager: installed[0].name, source: "only-installed", version: installed[0].version };
-  const defaultIndex = Math.max(0, installed.findIndex((manager) => manager.name === launcher?.name));
-  tell("? Package manager");
-  installed.forEach((manager, index) => {
-    const head = `  ${index + 1}) ${manager.name.padEnd(6)}${manager.version ?? ""}`.trimEnd();
-    tell(index === defaultIndex ? `${head}  (default)` : head);
-  });
-  for (; ; ) {
-    const answer = (await ask(`Choose 1-${installed.length} [${defaultIndex + 1}]: `)).trim().toLowerCase();
-    const byNumber = /^\d+$/.test(answer) ? Number(answer) - 1 : -1;
-    const index = answer === "" ? defaultIndex : byNumber >= 0 ? byNumber : installed.findIndex((manager) => manager.name === answer);
-    if (index >= 0 && index < installed.length) {
-      return { packageManager: installed[index].name, source: "asked", version: installed[index].version };
-    }
-    tell(`Choose a number from 1 to ${installed.length} (or a name: ${installed.map((manager) => manager.name).join(", ")}).`);
-  }
-}
-var SUPPORTED_TEXT = "npm, pnpm, yarn and bun";
-var SOURCE_TEXT = {
-  flag: "--package-manager",
-  launcher: "the package manager that ran this command",
-  default: "default \u2014 no launching package manager detected",
-  asked: "chosen",
-  "only-installed": "the only one installed"
-};
-function describeResolution(resolution) {
-  const name = resolution.version ? `${resolution.packageManager} ${resolution.version}` : resolution.packageManager;
-  return `${name} (${SOURCE_TEXT[resolution.source]})`;
-}
-
-// src/cli/workspace-name.ts
-var MAX_LENGTH = 214;
-var EXAMPLE = "my-app";
-function workspaceNameProblem(name) {
-  if (name.length === 0) return "it is empty";
-  if (/\s/.test(name)) return "it contains whitespace";
-  if (name.length > MAX_LENGTH) return `it is ${name.length} characters long, and npm allows at most ${MAX_LENGTH}`;
-  if (name.startsWith(".") || name.startsWith("_")) return `it starts with "${name[0]}"`;
-  if (/[A-Z]/.test(name)) return "it contains uppercase letters, and npm package names are lowercase";
-  const others = [...new Set(name.replace(/[a-z0-9._-]/g, ""))];
-  if (others.length > 0) {
-    return `it contains ${others.map((char) => `"${char}"`).join(", ")} \u2014 only lowercase letters, digits, "-", "_" and "." are allowed`;
-  }
-  return void 0;
-}
-function invalidWorkspaceNameMessage(name, problem) {
-  return `Invalid workspace name "${name}": ${problem}. For example: ${EXAMPLE}`;
-}
-
-// src/cli/parse-args.ts
-var STRING_VALUE_FLAGS = /* @__PURE__ */ new Set(["--preset", "--frontend", "--backend", "--locale", "--ai-hosts", "--plugins", "--review-provider", "--plugin-source", "--package-manager"]);
-function extractReviewFlag(argv) {
-  const rest = [];
-  let review;
-  let error;
-  for (let i = 0; i < argv.length; i++) {
-    const token = argv[i];
-    if (STRING_VALUE_FLAGS.has(token)) {
-      rest.push(token);
-      if (i + 1 < argv.length) {
-        rest.push(argv[i + 1]);
-        i++;
-      }
-    } else if (token === "--review") {
-      review = true;
-    } else if (token === "--no-review") {
-      review = false;
-    } else if (token.startsWith("--review=")) {
-      const value = token.slice("--review=".length);
-      if (value === "true") review = true;
-      else if (value === "false") review = false;
-      else error ??= `Invalid --review value "${value}". Expected "true" or "false".`;
-    } else {
-      rest.push(token);
-    }
-  }
-  return { review, error, rest };
-}
-function invalidChoiceMessage(flag, value, choices) {
-  return `Invalid ${flag} value "${value}". Expected one of: ${choices.join(", ")}`;
-}
-function parseCliArgs(argv) {
-  const { review, error: reviewError, rest } = extractReviewFlag(argv);
-  if (reviewError) return { kind: "error", message: reviewError };
-  const options = {
-    help: { type: "boolean", short: "h" },
-    version: { type: "boolean", short: "v" },
-    preset: { type: "string" },
-    frontend: { type: "string" },
-    backend: { type: "string" },
-    locale: { type: "string" },
-    "ai-hosts": { type: "string" },
-    plugins: { type: "string" },
-    "review-provider": { type: "string" },
-    "plugin-source": { type: "string" },
-    "package-manager": { type: "string" },
-    "allow-nested": { type: "boolean" }
-  };
-  let parsed;
-  try {
-    parsed = parseNodeArgs({ args: rest, allowPositionals: true, options });
-  } catch (error) {
-    return { kind: "error", message: error instanceof Error ? error.message : String(error) };
-  }
-  if (parsed.values.help) return { kind: "help" };
-  if (parsed.values.version) return { kind: "version" };
-  if (parsed.positionals.length > 1) {
-    return {
-      kind: "error",
-      message: `Unexpected extra argument(s): ${parsed.positionals.slice(1).join(", ")}`
-    };
-  }
-  const name = parsed.positionals[0];
-  const nameProblem = name === void 0 ? void 0 : workspaceNameProblem(name);
-  if (name !== void 0 && nameProblem !== void 0) {
-    return { kind: "error", message: invalidWorkspaceNameMessage(name, nameProblem) };
-  }
-  const preset = parsed.values.preset;
-  if (preset !== void 0 && !PRESET_VALUES.includes(preset)) {
-    return { kind: "error", message: invalidChoiceMessage("--preset", preset, PRESET_VALUES) };
-  }
-  const frontend = parsed.values.frontend;
-  if (frontend !== void 0 && !FRONTEND_VALUES.includes(frontend)) {
-    return { kind: "error", message: invalidChoiceMessage("--frontend", frontend, FRONTEND_VALUES) };
-  }
-  const backend = parsed.values.backend;
-  if (backend !== void 0 && !BACKEND_VALUES.includes(backend)) {
-    return { kind: "error", message: invalidChoiceMessage("--backend", backend, BACKEND_VALUES) };
-  }
-  if (frontend === "none" && backend === "none") {
-    return { kind: "error", message: "--frontend=none creates a backend-only workspace: pass --backend=express or --backend=nest." };
-  }
-  const locale = parsed.values.locale;
-  if (locale !== void 0 && !LOCALE_VALUES.includes(locale)) {
-    return { kind: "error", message: invalidChoiceMessage("--locale", locale, LOCALE_VALUES) };
-  }
-  const aiHostsRaw = parsed.values["ai-hosts"];
-  let aiHosts;
-  if (aiHostsRaw !== void 0) {
-    const tokens = aiHostsRaw.split(",").map((token) => token.trim().toLowerCase()).filter((token) => token.length > 0);
-    const unknown = tokens.find((token) => !AI_HOST_VALUES.includes(token));
-    if (tokens.length === 0 || unknown !== void 0) {
-      return { kind: "error", message: invalidChoiceMessage("--ai-hosts", unknown ?? aiHostsRaw, AI_HOST_VALUES) + " (comma-separated)" };
-    }
-    aiHosts = [...new Set(tokens)];
-  }
-  const pluginsRaw = parsed.values.plugins;
-  let plugins;
-  if (pluginsRaw !== void 0) {
-    const tokens = pluginsRaw.split(",").map((token) => token.trim().toLowerCase()).filter((token) => token.length > 0);
-    if (tokens.length === 1 && tokens[0] === "none") {
-      plugins = [];
-    } else {
-      const unknown = tokens.find((token) => !PLUGIN_VALUES.includes(token));
-      if (tokens.length === 0 || unknown !== void 0) {
-        return {
-          kind: "error",
-          message: invalidChoiceMessage("--plugins", unknown ?? pluginsRaw, [...PLUGIN_VALUES, "none"]) + " (comma-separated)"
-        };
-      }
-      plugins = [...new Set(tokens)];
-    }
-  }
-  const reviewProvider = parsed.values["review-provider"];
-  if (reviewProvider !== void 0 && !REVIEW_PROVIDER_VALUES.includes(reviewProvider)) {
-    return { kind: "error", message: invalidChoiceMessage("--review-provider", reviewProvider, REVIEW_PROVIDER_VALUES) };
-  }
-  const packageManager = parsed.values["package-manager"];
-  if (packageManager !== void 0 && !isCliPackageManager(packageManager)) {
-    return {
-      kind: "error",
-      message: `--package-manager "${packageManager}" is not supported \u2014 create-nx-archweave supports npm, pnpm, yarn and bun.`
-    };
-  }
-  return {
-    kind: "ok",
-    args: {
-      name,
-      preset,
-      frontend,
-      backend,
-      locale,
-      aiHosts,
-      plugins,
-      reviewProvider,
-      review,
-      pluginSource: parsed.values["plugin-source"],
-      packageManager,
-      allowNested: parsed.values["allow-nested"] === true
-    }
-  };
-}
-
 // src/cli/location-check.ts
 function checkInvocationDirectory(dir, probe) {
   const gitRoot2 = probe.gitRoot(dir);
@@ -298,477 +45,6 @@ function renderLocationRefusal(check) {
   ].join("\n");
 }
 
-// src/cli/prompts.ts
-async function askChoice(ask, question, choices) {
-  for (; ; ) {
-    const answer = (await ask(question)).trim();
-    if (choices.includes(answer)) return answer;
-  }
-}
-function parseYesNo(answer) {
-  return /^y(es)?$/i.test(answer.trim());
-}
-function parseAiHostAnswer(answer) {
-  const tokens = answer.split(/[\s,]+/).filter((token) => token.length > 0);
-  if (tokens.length === 0) return [...DEFAULT_AI_HOSTS];
-  const picked = [];
-  for (const token of tokens) {
-    const byNumber = /^\d+$/.test(token) ? AI_HOST_CHOICES[Number(token) - 1] : void 0;
-    const host = byNumber ?? AI_HOST_CHOICES.find((choice) => choice.id === token.toLowerCase());
-    if (!host) return void 0;
-    if (!picked.includes(host.id)) picked.push(host.id);
-  }
-  return picked;
-}
-function hostStatus(host, installed) {
-  if (installed === void 0) return "";
-  const version = installed[host];
-  if (version === void 0) return "not found";
-  return version.length > 0 ? `installed ${version}` : "installed";
-}
-function aiHostsQuestion(installed) {
-  const width = Math.max(...AI_HOST_CHOICES.map((host) => host.label.length)) + 2;
-  return [
-    "? AI coding tools you use (choose one or more)",
-    ...AI_HOST_CHOICES.map((host, index) => {
-      const status = hostStatus(host.id, installed);
-      return `  ${index + 1}) ${status ? host.label.padEnd(width) + status : host.label}`;
-    }),
-    `Choose, e.g. 1,3 [1]: `
-  ].join("\n");
-}
-async function askAiHosts(ask, installed) {
-  const question = aiHostsQuestion(installed);
-  for (; ; ) {
-    const picked = parseAiHostAnswer(await ask(question));
-    if (picked) return picked;
-  }
-}
-async function collectMissingInputs(input, ask) {
-  const preset = input.preset ?? await askChoice(ask, `Preset (${PRESET_VALUES.join("/")}): `, PRESET_VALUES);
-  const frontendChoices = input.backend === "none" ? FRONTEND_VALUES.filter((value) => value !== "none") : FRONTEND_VALUES;
-  const frontend = input.frontend ?? await askChoice(ask, `Frontend (${frontendChoices.join("/")}): `, frontendChoices);
-  const backendChoices = frontend === "none" ? BACKEND_VALUES.filter((value) => value !== "none") : BACKEND_VALUES;
-  const backend = input.backend ?? await askChoice(ask, `Backend (${backendChoices.join("/")}): `, backendChoices);
-  const locale = preset === "quick-start" ? input.locale ?? "en" : input.locale ?? await askChoice(ask, `Locale (${LOCALE_VALUES.join("/")}): `, LOCALE_VALUES);
-  const aiHosts = input.aiHosts ?? (input.interactive ? await askAiHosts(ask, input.installedHosts) : [...DEFAULT_AI_HOSTS]);
-  let review = input.review;
-  if (review === void 0 && preset === "quick-start") {
-    const answer = await ask("Enable AI PR review? (y/N): ");
-    review = parseYesNo(answer);
-  }
-  let reviewProvider = input.reviewProvider;
-  if (reviewProvider === void 0 && reviewWillBeOn(preset, review) && input.interactive) {
-    reviewProvider = await askReviewProvider(ask, aiHosts[0]);
-  }
-  return { preset, frontend, backend, locale, aiHosts, review, reviewProvider };
-}
-function reviewWillBeOn(preset, review) {
-  return review ?? preset !== "quick-start";
-}
-function reviewProviderConflict(preset, review, reviewProvider) {
-  if (reviewProvider === void 0) return void 0;
-  if (review === false) return "--review-provider needs AI PR review on, but --no-review was passed (or review was declined): drop one of them.";
-  if (preset === void 0 || reviewWillBeOn(preset, review)) return void 0;
-  return "--review-provider needs AI PR review on, and the quick-start preset leaves it off: add --review, or drop --review-provider.";
-}
-function reviewProviderQuestion(firstHost) {
-  const host = AI_HOST_CHOICES.find((choice) => choice.id === firstHost);
-  const defaultIndex = REVIEW_PROVIDER_CHOICES.findIndex((provider) => provider.id === host?.reviewProvider);
-  return [
-    "? AI PR review provider",
-    ...REVIEW_PROVIDER_CHOICES.map(
-      (provider, index) => `  ${index + 1}) ${provider.label}${index === defaultIndex ? `  (default \u2014 ${host?.label})` : ""}`
-    ),
-    `Choose 1-${REVIEW_PROVIDER_CHOICES.length} [${defaultIndex + 1}]: `
-  ].join("\n");
-}
-function parseReviewProviderAnswer(answer) {
-  const token = answer.trim().toLowerCase();
-  if (token === "") return void 0;
-  const byNumber = /^\d+$/.test(token) ? REVIEW_PROVIDER_CHOICES[Number(token) - 1] : void 0;
-  const provider = byNumber ?? REVIEW_PROVIDER_CHOICES.find((choice) => choice.id === token);
-  return provider ? provider.id : null;
-}
-async function askReviewProvider(ask, firstHost) {
-  const question = reviewProviderQuestion(firstHost);
-  for (; ; ) {
-    const picked = parseReviewProviderAnswer(await ask(question));
-    if (picked !== null) return picked;
-  }
-}
-
-// src/render-usage.ts
-import { existsSync, readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-var AVAILABLE_GENERATORS = [
-  "doctor",
-  "init",
-  "add-integration",
-  "add-review",
-  "add-backend",
-  "add-agent-rules",
-  "add-github-templates",
-  "add-fsd-lite",
-  "page",
-  "widget",
-  "feature",
-  "entity",
-  "shared",
-  "install-integration",
-  "record-integration",
-  "allow-builds"
-];
-function ownVersion() {
-  let dir = dirname(fileURLToPath(import.meta.url));
-  for (; ; ) {
-    const manifest = join(dir, "package.json");
-    if (existsSync(manifest)) {
-      const pkg = JSON.parse(readFileSync(manifest, "utf-8"));
-      if (pkg.name === "create-nx-archweave" && pkg.version) return pkg.version;
-    }
-    const parent = dirname(dir);
-    if (parent === dir) throw new Error("create-nx-archweave: its own package.json was not found");
-    dir = parent;
-  }
-}
-var CLI_VERSION = ownVersion();
-var PLUGIN_LIST = PLUGIN_CHOICES.map(
-  (plugin) => `${plugin.id} (${AI_HOST_CHOICES.find((host) => host.id === plugin.host)?.label ?? plugin.host})`
-).join(", ");
-function renderUsage() {
-  return [
-    "Usage: create-nx-archweave <name> [options]",
-    "",
-    "Options:",
-    "  --preset <quick-start|solo|team>   Preset that configures the generated workspace",
-    "  --frontend <react-vite|next|none> Target frontend (none: a backend-only workspace \u2014 needs --backend)",
-    "  --backend <express|nest|none>      Backend app, wired with shared-types and enforced boundaries (asked if omitted)",
-    "  --locale <ko|en>                   Generated content language (asked if omitted; quick-start: en)",
-    "  --ai-hosts <list>                  AI coding tools, comma-separated: claude-code, codex, cursor, gemini-cli",
-    "                                     (asked if omitted, showing which are installed; without a terminal: claude-code)",
-    "  --plugins <list|none>              Optional plugins for the picked AI hosts, comma-separated: " + PLUGIN_LIST,
-    "                                     (asked if omitted, for hosts installed here; without a terminal: none)",
-    "  --review, --no-review              Force AI PR review on/off (quick-start asks y/N; solo/team: on)",
-    "  --review-provider <name>           claude, gemini, gpt or cursor (asked when review is on; default: the first AI tool's)",
-    "  --plugin-source <spec>             Override the nx-archweave plugin package/version to install",
-    "  --allow-nested                     Create the workspace even inside a git repository or package.json project",
-    "  --package-manager <name>           npm, pnpm, yarn or bun (asked if omitted; without a terminal: the one that ran this command, else npm)",
-    "  -h, --help                         Show this help",
-    "  -v, --version                      Show the CLI version",
-    "",
-    "Any required option left unset above is asked interactively.",
-    "",
-    "Available generators (once installed):",
-    `  ${AVAILABLE_GENERATORS.join(", ")}`
-  ].join("\n");
-}
-function renderVersion() {
-  return CLI_VERSION;
-}
-
-// src/cli/plan.ts
-var DEFAULT_PLUGIN_SOURCE = `@clearlydev/nx-archweave@^${CLI_VERSION}`;
-var VALIDATED_CREATE_NX_WORKSPACE_VERSION = "24.0.1";
-function nxArgs(pm) {
-  return pm === "npm" ? ["exec", "nx", "--"] : ["nx"];
-}
-function nxGenerateCommand(pm) {
-  return `${pm} ${nxArgs(pm).join(" ")} g`;
-}
-function addDevArgs(pm, spec, ctx) {
-  if (pm === "pnpm") return ["add", "-D", "-w", spec];
-  if (pm === "npm") return ["install", "-D", spec];
-  if (pm === "bun") return ["add", "-d", spec];
-  return ctx && isYarnBerry(ctx) ? ["add", "-D", spec] : ["add", "-D", "-W", spec];
-}
-function isYarnBerry(ctx) {
-  return ctx.readFile(".yarnrc.yml") !== void 0 || /^__metadata:/m.test(ctx.readFile("yarn.lock") ?? "");
-}
-var YARN_PLAN_ENV = { YARN_ENABLE_IMMUTABLE_INSTALLS: "false" };
-var NO_E2E = ["--e2eTestRunner=none"];
-function createWorkspaceSourceArgs(frontend, backend) {
-  if (frontend === "react-vite") return ["--preset=empty"];
-  if (frontend === "next") return ["--preset=next", "--appName=web", ...NO_E2E];
-  return [`--preset=${backend}`, "--appName=api", ...NO_E2E, "--unitTestRunner=vitest"];
-}
-function buildNextSteps(input) {
-  const lines = [
-    `cd ${input.name}`,
-    ...input.backend !== "none" ? [`${input.packageManager} install   (links the new shared-types workspace package \u2014 do this before the first commit)`] : [],
-    'git add -A && git commit -m "chore: initial commit"',
-    "(create-nx-archweave never commits for you \u2014 review what the init report above generated first.)"
-  ];
-  if (input.review === false) return lines;
-  if (input.review === true) {
-    lines.push(
-      "AI PR review is enabled: add the review secret named in the init report above to the repository before opening a pull request.",
-      "Verify the default branch matches what the init report above expects before relying on branch protection."
-    );
-  } else {
-    lines.push(
-      "If the init report above shows AI PR review enabled, add the review secret it names to the repository before opening a pull request, and verify the default branch first."
-    );
-  }
-  return lines;
-}
-function buildPlan(input) {
-  const pluginSource = input.pluginSource ?? DEFAULT_PLUGIN_SOURCE;
-  const workspaceSource = createWorkspaceSourceArgs(input.frontend, input.backend);
-  const aiAgentArgs = input.aiHosts.length === 0 ? ["--aiAgents=none"] : input.aiHosts.map((host) => `--aiAgents=${AI_HOST_CHOICES.find((choice) => choice.id === host)?.nxAgent ?? host}`);
-  const pm = input.packageManager;
-  const nxPrefix = nxArgs(pm);
-  const initArgs = [
-    ...nxPrefix,
-    "g",
-    "@clearlydev/nx-archweave:init",
-    `--preset=${input.preset}`,
-    `--frontend=${input.frontend}`,
-    `--backend=${input.backend}`,
-    `--locale=${input.locale}`,
-    `--aiHosts=${input.aiHosts.join(",")}`,
-    `--packageManager=${pm}`,
-    // Step 2 (the plugin install) always dirties the fresh workspace's tree
-    // (package.json + lockfile), so init's clean-tree refusal would otherwise
-    // always fire here. This is orchestration knowledge, not policy: the CLI
-    // knows what its own previous step did. For the same reason the report's note about
-    // reverting earlier user changes doesn't apply: the only changes are that install's.
-    "--allowDirty=true",
-    "--dirtyFromCaller=true"
-  ];
-  if (input.review !== void 0) {
-    initArgs.push(`--review=${input.review}`);
-  }
-  if (input.reviewProvider !== void 0 && input.review !== false) {
-    initArgs.push(`--reviewProvider=${input.reviewProvider}`);
-  }
-  initArgs.push("--applyEslint=true");
-  const steps = [
-    {
-      id: "create-workspace",
-      description: `Create the Nx workspace "${input.name}"`,
-      // pnpm launches with its own dlx; npm, yarn and bun through npx (always present
-      // with Node, and how every yarn and bun row of the measurements was produced).
-      command: pm === "pnpm" ? "pnpm" : "npx",
-      args: pm === "pnpm" ? [
-        "dlx",
-        `create-nx-workspace@${VALIDATED_CREATE_NX_WORKSPACE_VERSION}`,
-        input.name,
-        ...workspaceSource,
-        ...aiAgentArgs,
-        "--pm=pnpm",
-        "--nxCloud=skip",
-        "--interactive=false"
-      ] : [
-        "-y",
-        `create-nx-workspace@${VALIDATED_CREATE_NX_WORKSPACE_VERSION}`,
-        input.name,
-        ...workspaceSource,
-        ...aiAgentArgs,
-        `--pm=${pm}`,
-        "--nxCloud=skip",
-        "--interactive=false"
-      ],
-      cwd: null
-    },
-    ...input.frontend === "react-vite" ? reactAppSteps(input.name, pm) : [],
-    {
-      id: "install-plugin",
-      description: `Install ${pluginSource}`,
-      command: pm,
-      args: addDevArgs(pm, pluginSource),
-      cwd: input.name,
-      // yarn's flags depend on its flavor, which only the created workspace tells.
-      ...pm === "yarn" ? { finalizeArgs: (ctx) => addDevArgs(pm, pluginSource, ctx) } : {}
-    },
-    // Backend-only: the preset already built apps/api, so neither official step runs.
-    ...input.backend === "none" || input.frontend === "none" ? [] : backendSteps(input.backend, input.name, pm, `${pm} ${initArgs.join(" ")}`),
-    {
-      id: "run-init",
-      description: "Run the nx-archweave init generator",
-      command: pm,
-      args: initArgs,
-      cwd: input.name
-    },
-    ...pm === "pnpm" ? [settleBuildApprovalsStep(input.name)] : [],
-    ...pm === "bun" ? [listBlockedScriptsStep(input.name)] : [],
-    ...(input.plugins ?? []).map((plugin) => installPluginStep(plugin, input.name, pm))
-  ];
-  return {
-    steps,
-    nextSteps: buildNextSteps(input),
-    ...pm === "pnpm" ? { env: PNPM_PLAN_ENV } : {},
-    ...pm === "yarn" ? { env: YARN_PLAN_ENV } : {}
-  };
-}
-function installPluginStep(plugin, workspaceName, pm) {
-  const hostLabel2 = AI_HOST_CHOICES.find((choice) => choice.id === plugin.host)?.label ?? plugin.host;
-  const args = [
-    ...nxArgs(pm),
-    "g",
-    "@clearlydev/nx-archweave:install-integration",
-    `--tool=${plugin.id}`,
-    `--target=${plugin.host}`,
-    "--scope=project",
-    "--apply"
-  ];
-  return {
-    id: "install-ai-plugin",
-    description: `Install the ${plugin.label} plugin for ${hostLabel2} (project scope)`,
-    command: pm,
-    args,
-    cwd: workspaceName,
-    optional: true,
-    successNote: () => `the ${plugin.label} report above says whether it was installed and recorded; if not, it names what to do next.`,
-    failureHint: `The workspace itself is complete. To retry inside "${workspaceName}": ${pm} ${args.join(" ")}`
-  };
-}
-var PNPM_PLAN_ENV = { pnpm_config_strict_dep_builds: "false" };
-var PNPM_PENDING_BUILD_PLACEHOLDER = "set this to true or false";
-function pendingBuildDecisions(workspaceYaml) {
-  const placeholder = PNPM_PENDING_BUILD_PLACEHOLDER;
-  const entry = new RegExp(`^(['"]?)(.+)\\1:\\s+(['"]?)${placeholder}\\3$`);
-  const pendingKey = (text) => {
-    const trimmed = text.trim();
-    if (trimmed.startsWith("#")) return void 0;
-    return entry.exec(trimmed)?.[2];
-  };
-  const names = [];
-  let inAllowBuilds = false;
-  for (const line of workspaceYaml.split(/\r?\n/)) {
-    if (/^\s*#/.test(line)) continue;
-    if (/^\S/.test(line)) {
-      inAllowBuilds = /^allowBuilds:\s*$/.test(line);
-      const flow = /^allowBuilds:\s*\{(.*)\}\s*$/.exec(line);
-      if (flow) {
-        for (const item of flow[1].split(",")) {
-          const name2 = pendingKey(item);
-          if (name2 !== void 0) names.push(name2);
-        }
-      }
-      continue;
-    }
-    if (!inAllowBuilds) continue;
-    const name = pendingKey(line);
-    if (name !== void 0) names.push(name);
-  }
-  return names;
-}
-function settleBuildApprovalsStep(workspaceName) {
-  return {
-    id: "settle-build-approvals",
-    description: "Record the dependency build scripts pnpm skipped as not allowed (pnpm-workspace.yaml allowBuilds)",
-    command: "pnpm",
-    args: ["approve-builds"],
-    cwd: workspaceName,
-    finalizeArgs: (ctx) => {
-      const yaml = ctx.readFile("pnpm-workspace.yaml");
-      const pending = yaml === void 0 ? [] : pendingBuildDecisions(yaml);
-      if (pending.length === 0) return { skip: "no dependency build script is awaiting a decision" };
-      return ["approve-builds", ...pending.map((name) => `!${name}`)];
-    },
-    // Once denied, pnpm 11.9's `approve-builds` no longer lists a package (it only
-    // offers what is still pending), so the way back is the file plus a rebuild —
-    // which the plugin's allow-builds generator (installed by an earlier step) does.
-    successNote: (args) => {
-      const names = args.filter((arg) => arg.startsWith("!")).map((arg) => arg.slice(1));
-      return `pnpm skipped the build scripts of ${names.join(", ")}; they stay disabled (allowBuilds: false in pnpm-workspace.yaml). To allow one later, run inside "${workspaceName}": pnpm nx g @clearlydev/nx-archweave:allow-builds --packages=<package> --apply`;
-    },
-    failureHint: 'The workspace itself is complete \u2014 every earlier step finished; only recording the build decisions failed. Inside it, set each allowBuilds entry in pnpm-workspace.yaml that still reads "set this to true or false" to true or false yourself, then run pnpm install.'
-  };
-}
-function listBlockedScriptsStep(workspaceName) {
-  return {
-    id: "list-blocked-scripts",
-    description: "List the dependency install scripts bun blocked (bun pm untrusted)",
-    command: "bun",
-    args: ["pm", "untrusted"],
-    cwd: workspaceName,
-    successNote: () => `bun blocks the install scripts of dependencies it does not trust; the list above (bun pm untrusted) shows the ones it blocked here \u2014 they stay blocked. To allow one later, run inside "${workspaceName}": bun pm trust <package>`,
-    failureHint: `The workspace itself is complete \u2014 every earlier step finished; only listing the blocked install scripts failed. Inside "${workspaceName}", run bun pm untrusted to see them.`
-  };
-}
-function reactAppSteps(workspaceName, pm) {
-  return [
-    {
-      id: "add-react-plugin",
-      description: "Add @nx/react with nx add (at the workspace nx version)",
-      command: pm,
-      args: [...nxArgs(pm), "add", "@nx/react"],
-      cwd: workspaceName
-    },
-    {
-      id: "create-web-app",
-      description: "Create the React + Vite app in apps/web with the official @nx/react generator",
-      command: pm,
-      args: [...nxArgs(pm), "g", "@nx/react:app", "apps/web", ...REACT_APP_OPTIONS],
-      cwd: workspaceName
-    }
-  ];
-}
-var REACT_APP_OPTIONS = ["--bundler=vite", "--linter=eslint", "--style=css", "--unitTestRunner=vitest", ...NO_E2E, "--routing=false"];
-var API_APP_OPTIONS = ["--unitTestRunner=vitest", ...NO_E2E];
-function backendSteps(backend, workspaceName, pm, initCommand) {
-  const nxG = nxGenerateCommand(pm);
-  const apiExists = (ctx) => ctx.listDir("apps").includes("api");
-  const standaloneError = `this workspace has no apps/ directory \u2014 CLI backend wiring needs the frontend under apps/. Create the api app with the official @nx generator, then run \`${nxG} @clearlydev/nx-archweave:add-backend\` yourself. Finish setup inside "${workspaceName}" with: ${initCommand}`;
-  const apiExistsError = `the workspace already has an apps/api \u2014 wire it with \`${nxG} @clearlydev/nx-archweave:add-backend --backend=${backend}\`, or remove it and run the official generator yourself. Either way, finish setup inside "${workspaceName}" with: ${initCommand}`;
-  return [
-    {
-      id: "install-backend-plugin",
-      description: `Install @nx/${backend} (pinned to the workspace's nx version)`,
-      command: pm,
-      args: addDevArgs(pm, `@nx/${backend}`),
-      cwd: workspaceName,
-      finalizeArgs: (ctx) => {
-        if (ctx.listDir("apps").length === 0) return { error: standaloneError };
-        if (apiExists(ctx)) return { error: apiExistsError };
-        const raw = ctx.readFile("package.json");
-        if (raw === void 0) return { error: "could not read the created workspace's package.json to pin the @nx version" };
-        try {
-          const parsed = JSON.parse(raw);
-          const nxVersion = parsed.devDependencies?.["nx"] ?? parsed.dependencies?.["nx"];
-          if (!nxVersion) return { error: "nx version not found in the created workspace's package.json" };
-          return addDevArgs(pm, `@nx/${backend}@${nxVersion}`, ctx);
-        } catch {
-          return { error: "could not parse the created workspace's package.json" };
-        }
-      }
-    },
-    {
-      id: "create-api-app",
-      description: `Create the api app with the official @nx/${backend} generator`,
-      command: pm,
-      // Since Nx 20 the positional is a directory relative to the workspace root —
-      // a bare `api` would land at the root instead of beside the frontend.
-      args: [...nxArgs(pm), "g", `@nx/${backend}:application`, "apps/api", ...API_APP_OPTIONS],
-      cwd: workspaceName,
-      finalizeArgs: (ctx) => {
-        const all = ctx.listDir("apps");
-        if (all.length === 0) return { error: standaloneError };
-        if (all.includes("api")) return { error: apiExistsError };
-        const apps = all.filter((name) => name !== "api" && name !== "e2e" && !name.endsWith("-e2e"));
-        if (apps.length === 0) return { error: "no frontend app directory found under apps/ in the created workspace" };
-        if (apps.length > 1) return { error: `multiple app directories found under apps/ (${apps.join(", ")}) \u2014 cannot pick --frontendProject` };
-        const frontendProject = (() => {
-          for (const file of [`apps/${apps[0]}/project.json`, `apps/${apps[0]}/package.json`]) {
-            const raw = ctx.readFile(file);
-            if (raw === void 0) continue;
-            try {
-              const name = JSON.parse(raw).name;
-              if (typeof name === "string" && name.length > 0) return name;
-            } catch {
-            }
-          }
-          return apps[0];
-        })();
-        return [...nxArgs(pm), "g", `@nx/${backend}:application`, "apps/api", `--frontendProject=${frontendProject}`, ...API_APP_OPTIONS];
-      }
-    }
-  ];
-}
-
 // src/cli/host-probe.ts
 function parseProbeVersion(output) {
   const firstLine = output.trim().split(/\r?\n/)[0]?.trim() ?? "";
@@ -850,203 +126,6 @@ async function choosePlugins(input, ask, log) {
   return { plugins };
 }
 
-// src/cli/spawnable-command.ts
-import { statSync } from "node:fs";
-import { win32 } from "node:path";
-function isFile(path) {
-  try {
-    return statSync(path).isFile();
-  } catch {
-    return false;
-  }
-}
-var DEFAULT_ENV = { platform: process.platform, env: process.env, isFile };
-function envValue(env, name) {
-  const key = Object.keys(env).find((candidate) => candidate.toUpperCase() === name);
-  return key === void 0 ? void 0 : env[key];
-}
-function resolveWindowsCommand(command, environment) {
-  const exts = (envValue(environment.env, "PATHEXT") ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean);
-  const candidates = (base) => win32.extname(base) !== "" ? [base] : exts.map((ext) => base + ext);
-  if (win32.isAbsolute(command) || /[\\/]/.test(command)) {
-    return candidates(command).find(environment.isFile);
-  }
-  const dirs = (envValue(environment.env, "PATH") ?? "").split(";").filter(Boolean);
-  for (const dir of dirs) {
-    const found = candidates(win32.join(dir, command)).find(environment.isFile);
-    if (found !== void 0) return found;
-  }
-  return void 0;
-}
-var META_CHARS = /([()\][%!^"`<>&|;, *?])/g;
-var BIN_SHIM = /node_modules[\\/]\.bin[\\/][^\\/]+\.cmd$/i;
-function escapeCmdArgument(arg, doubleEscape = false) {
-  let quoted = arg.replace(/(\\*)"/g, '$1$1\\"');
-  quoted = quoted.replace(/(\\*)$/, "$1$1");
-  const escaped = `"${quoted}"`.replace(META_CHARS, "^$1");
-  return doubleEscape ? escaped.replace(META_CHARS, "^$1") : escaped;
-}
-function spawnableCommand(command, args, environment = DEFAULT_ENV) {
-  if (environment.platform !== "win32") return { command, args: [...args] };
-  const resolved = resolveWindowsCommand(command, environment);
-  if (resolved === void 0 || !/\.(cmd|bat)$/i.test(resolved)) return { command, args: [...args] };
-  const doubleEscape = BIN_SHIM.test(resolved);
-  const line = [resolved.replace(META_CHARS, "^$1"), ...args.map((arg) => escapeCmdArgument(arg, doubleEscape))].join(" ");
-  return {
-    command: envValue(environment.env, "COMSPEC") ?? "cmd.exe",
-    args: ["/d", "/s", "/c", `"${line}"`],
-    windowsVerbatimArguments: true
-  };
-}
-
-// src/cli/execute.ts
-import { spawnSync } from "node:child_process";
-import { readdirSync, readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
-import { join as join2 } from "node:path";
-var LAUNCHER_ONLY = /^npm_config_package$/i;
-function childEnv(parent, overrides = {}) {
-  const env = {};
-  for (const [key, value] of Object.entries(parent)) if (!LAUNCHER_ONLY.test(key)) env[key] = value;
-  return { ...env, ...overrides };
-}
-function isFileOnDisk(path) {
-  try {
-    return statSync2(path).isFile();
-  } catch {
-    return false;
-  }
-}
-function createProcessExec() {
-  return (command, args, options) => {
-    const env = childEnv(process.env, options.env);
-    const spawnable = spawnableCommand(command, args, { platform: process.platform, env, isFile: isFileOnDisk });
-    const result = spawnSync(spawnable.command, spawnable.args, {
-      cwd: options.cwd,
-      stdio: "inherit",
-      env,
-      windowsVerbatimArguments: spawnable.windowsVerbatimArguments
-    });
-    return { status: result.status ?? null };
-  };
-}
-function createStepContext(workspacePath) {
-  return {
-    workspacePath,
-    readFile: (relativePath) => {
-      try {
-        return readFileSync2(join2(workspacePath, relativePath), "utf-8");
-      } catch {
-        return void 0;
-      }
-    },
-    listDir: (relativePath) => {
-      try {
-        return readdirSync(join2(workspacePath, relativePath), { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-      } catch {
-        return [];
-      }
-    }
-  };
-}
-function executePlan(plan, exec, invokedFromDir, ctxFactory = createStepContext, now = Date.now) {
-  const completed = [];
-  for (const step of plan.steps) {
-    const cwd = step.cwd === null ? invokedFromDir : join2(invokedFromDir, step.cwd);
-    let args = step.args;
-    if (step.finalizeArgs) {
-      const finalized = step.finalizeArgs(ctxFactory(cwd));
-      if ("error" in finalized) {
-        if (step.optional) {
-          completed.push({ step, result: { status: null }, optionalFailure: `stopped before execution: ${finalized.error}` });
-          continue;
-        }
-        return { ok: false, completed, failedStep: step, failedResult: { status: null }, finalizeError: finalized.error };
-      }
-      if ("skip" in finalized) {
-        completed.push({ step, result: { status: 0 }, skipped: finalized.skip });
-        continue;
-      }
-      args = finalized;
-    }
-    const startedAt = now();
-    const result = exec(step.command, args, plan.env ? { cwd, env: plan.env } : { cwd });
-    const durationMs = now() - startedAt;
-    if (result.status !== 0) {
-      if (step.optional) {
-        const optionalFailure = result.status === null ? "it did not start or was stopped (no exit code)" : `exit code: ${result.status} (its own error output is printed above)`;
-        completed.push({ step, result, args, optionalFailure, durationMs });
-        continue;
-      }
-      return { ok: false, completed, failedStep: step, failedResult: result, failedArgs: args, failedDurationMs: durationMs };
-    }
-    completed.push({ step, result, args, durationMs });
-  }
-  return { ok: true, completed };
-}
-function renderExecuteReport(report, plan, workspaceName) {
-  if (report.ok) {
-    const skippedLines = report.completed.filter((c) => c.skipped !== void 0).map((c) => `  skipped "${c.step.id}": ${c.skipped}`);
-    const noteLines = report.completed.flatMap(
-      (c) => c.skipped === void 0 && c.optionalFailure === void 0 && c.args !== void 0 && c.step.successNote ? [`  note: ${c.step.successNote(c.args)}`] : []
-    );
-    const failedOptional = report.completed.filter((c) => c.optionalFailure !== void 0);
-    const optionalLines = failedOptional.flatMap((c) => [
-      `  optional step "${c.step.id}" failed \u2014 ${c.step.description}.`,
-      `    ${c.optionalFailure}`,
-      ...c.step.failureHint ? [`    ${c.step.failureHint}`] : []
-    ]);
-    return [
-      "",
-      failedOptional.length === 0 ? "create-nx-archweave finished successfully." : `create-nx-archweave finished \u2014 the workspace is complete, but ${failedOptional.length} optional step(s) failed:`,
-      ...optionalLines,
-      ...skippedLines,
-      ...noteLines,
-      "",
-      "Next steps:",
-      ...plan.nextSteps.map((line) => `  ${line}`)
-    ].join("\n");
-  }
-  const { failedStep, failedResult } = report;
-  const detail = report.finalizeError ? `stopped before execution: ${report.finalizeError}` : `exit code: ${failedResult.status ?? "unknown"} (the command's own error output is printed above)`;
-  return [
-    "",
-    `create-nx-archweave stopped: step "${failedStep.id}" failed \u2014 ${failedStep.description}.`,
-    `  ${detail}`,
-    ...!report.finalizeError && failedStep.failureHint ? [`  ${failedStep.failureHint}`] : [],
-    "",
-    `The "${workspaceName}" directory (if it was created) was left in place \u2014 create-nx-archweave never deletes it automatically.`,
-    `Inspect the error above and fix the issue. Then either run the remaining steps below yourself, or remove the directory and start over.`,
-    "",
-    ...renderRemainingSteps(report, plan, workspaceName)
-  ].join("\n");
-}
-function renderStepTimings(report) {
-  const rows = report.completed.filter((c) => c.durationMs !== void 0).map((c) => [c.step.id, c.durationMs]);
-  if (!report.ok && report.failedDurationMs !== void 0) rows.push([`${report.failedStep.id} (failed)`, report.failedDurationMs]);
-  return ["Step timings:", ...rows.map(([id, ms]) => `  ${(ms / 1e3).toFixed(1).padStart(7)}s  ${id}`)].join("\n");
-}
-function renderRemainingSteps(report, plan, workspaceName) {
-  const start = plan.steps.indexOf(report.failedStep);
-  const remaining = start === -1 ? [report.failedStep] : plan.steps.slice(start);
-  const lines = [`Remaining steps, in order (printed only \u2014 create-nx-archweave does not run them again):`];
-  const env = Object.entries(plan.env ?? {});
-  if (env.length > 0) lines.push(`  Run them with ${env.map(([key, value]) => `${key}=${value}`).join(" ")} set, as the CLI does.`);
-  remaining.forEach((step, index) => {
-    const ranArgs = step === report.failedStep ? report.failedArgs : void 0;
-    const args = ranArgs ?? step.args;
-    const where = step.cwd === null ? "in the directory you ran create-nx-archweave from" : `inside "${workspaceName}"`;
-    lines.push(`  ${index + 1}. ${step.description}${step.optional ? " (optional)" : ""} \u2014 ${where}:`);
-    lines.push(`       ${[step.command, ...args].map(shellQuote).join(" ")}`);
-    if (step.finalizeArgs && ranArgs === void 0) {
-      lines.push("       (the CLI works out this step's exact arguments when it runs \u2014 check them against the workspace first)");
-    }
-  });
-  return lines;
-}
-function shellQuote(word) {
-  return /^[\w@%+=:,./^~-]+$/.test(word) ? word : `'${word.replace(/'/g, `'\\''`)}'`;
-}
-
 // src/bin.ts
 var NonInteractiveInputError = class extends Error {
 };
@@ -1075,7 +154,7 @@ async function main(argv) {
   }
   const name = args.name;
   if (!args.allowNested) {
-    const location = checkInvocationDirectory(process.cwd(), { gitRoot, hasPackageJson: (dir) => existsSync2(join3(dir, "package.json")) });
+    const location = checkInvocationDirectory(process.cwd(), { gitRoot, hasPackageJson: (dir) => existsSync(join(dir, "package.json")) });
     if (!location.ok) {
       console.error(renderLocationRefusal(location));
       return 1;
@@ -1199,7 +278,7 @@ ${renderStepTimings(report)}`);
 function readVersion(manager) {
   const env = { ...process.env, COREPACK_ENABLE_DOWNLOAD_PROMPT: "0", COREPACK_ENABLE_STRICT: "0" };
   const spawnable = spawnableCommand(manager, ["--version"]);
-  const result = spawnSync2(spawnable.command, spawnable.args, {
+  const result = spawnSync(spawnable.command, spawnable.args, {
     encoding: "utf-8",
     timeout: 5e3,
     env,
@@ -1228,6 +307,6 @@ main(process.argv.slice(2)).then((code) => {
   process.exitCode = 1;
 });
 function gitRoot(dir) {
-  const result = spawnSync2("git", ["rev-parse", "--show-toplevel"], { cwd: dir, encoding: "utf-8" });
+  const result = spawnSync("git", ["rev-parse", "--show-toplevel"], { cwd: dir, encoding: "utf-8" });
   return result.status === 0 && result.stdout.trim() !== "" ? result.stdout.trim() : null;
 }