create-nx-archweave 0.1.0 → 0.2.0

package/README.md

@@ -118,6 +118,7 @@ When something goes wrong:
 | `--ai-hosts` | `claude-code`, `codex`, `cursor`, `gemini-cli` |
 | `--plugins` | catalog ids (`ponytail`), or `none` |
 | `--package-manager` | `npm` \| `pnpm` \| `yarn` \| `bun` |
+| `--allow-nested` | create the workspace even inside a git repository or a folder with a `package.json` (refused otherwise) |
 | `-h`, `--help` / `-v`, `--version` | — |
 
 ### `--preset`
@@ -185,7 +186,7 @@ The printed next steps cover the first commit. If review is enabled, they also c
 
 - `nx build create-nx-archweave` runs tsc, for local dev and typecheck.
 - `nx test` runs Jest.
-- `nx bundle` (depends on `build`) uses esbuild to bundle `src/index.ts` and `src/bin.ts` into `dist/`. The `bin.js` shebang is preserved, and only `tslib` stays external.
+- `nx bundle` (depends on `build`) uses esbuild to bundle `src/index.ts` and `src/bin.ts` into `dist/`. The `bin.js` shebang is preserved, and the CLI has no runtime dependencies.
 - The CLI has no runtime import of the plugin. It only names the plugin as an install spec.
 
 ## License

package/dist/bin.js

@@ -2,6 +2,8 @@
 
 // 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 { createInterface } from "node:readline/promises";
 
 // src/cli/parse-args.ts
@@ -153,6 +155,25 @@ function describeResolution(resolution) {
   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) {
@@ -199,7 +220,8 @@ function parseCliArgs(argv) {
     plugins: { type: "string" },
     "review-provider": { type: "string" },
     "plugin-source": { type: "string" },
-    "package-manager": { type: "string" }
+    "package-manager": { type: "string" },
+    "allow-nested": { type: "boolean" }
   };
   let parsed;
   try {
@@ -216,6 +238,10 @@ function parseCliArgs(argv) {
     };
   }
   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) };
@@ -286,11 +312,31 @@ function parseCliArgs(argv) {
       reviewProvider,
       review,
       pluginSource: parsed.values["plugin-source"],
-      packageManager
+      packageManager,
+      allowNested: parsed.values["allow-nested"] === true
     }
   };
 }
 
+// src/cli/location-check.ts
+function checkInvocationDirectory(dir, probe) {
+  const gitRoot2 = probe.gitRoot(dir);
+  if (gitRoot2 !== null) return { ok: false, reason: "git", at: gitRoot2 };
+  if (probe.hasPackageJson(dir)) return { ok: false, reason: "package", at: dir };
+  return { ok: true };
+}
+function renderLocationRefusal(check) {
+  const where = check.reason === "git" ? `${check.at} is a git repository` : `${check.at} has a package.json`;
+  return [
+    `create-nx-archweave makes a new workspace in a new folder, but ${where}.`,
+    "To set up an existing repository instead, run these in it:",
+    "  npx nx@latest init",
+    "  nx g @clearlydev/nx-archweave:init",
+    "To create a separate workspace, run create-nx-archweave from a folder outside it.",
+    "To nest a workspace here anyway, pass --allow-nested."
+  ].join("\n");
+}
+
 // src/cli/prompts.ts
 async function askChoice(ask, question, choices) {
   for (; ; ) {
@@ -446,6 +492,7 @@ function renderUsage() {
     "  --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",
@@ -1020,6 +1067,13 @@ async function main(argv) {
     return 1;
   }
   const name = args.name;
+  if (!args.allowNested) {
+    const location = checkInvocationDirectory(process.cwd(), { gitRoot, hasPackageJson: (dir) => existsSync2(join3(dir, "package.json")) });
+    if (!location.ok) {
+      console.error(renderLocationRefusal(location));
+      return 1;
+    }
+  }
   const rl = createInterface({ input: process.stdin, output: process.stdout });
   const ask = (question) => {
     if (!process.stdin.isTTY) {
@@ -1165,3 +1219,7 @@ main(process.argv.slice(2)).then((code) => {
   console.error(error instanceof Error ? error.stack ?? error.message : String(error));
   process.exitCode = 1;
 });
+function gitRoot(dir) {
+  const result = spawnSync2("git", ["rev-parse", "--show-toplevel"], { cwd: dir, encoding: "utf-8" });
+  return result.status === 0 && result.stdout.trim() !== "" ? result.stdout.trim() : null;
+}

package/dist/cli/location-check.d.ts

@@ -0,0 +1,23 @@
+/** Where create-nx-archweave was started: a new workspace goes into a new folder, so a
+ * directory that already belongs to a project is almost always a mistake — the workspace would
+ * land inside that repository as untracked files, its `.github/` would have no effect, and the
+ * suggested `git add -A` would stage the outer repository's changes too. */
+export type InvocationCheck = {
+    ok: true;
+} | {
+    ok: false;
+    reason: 'git' | 'package';
+    at: string;
+};
+export interface LocationProbe {
+    /** The top of the git repository containing `dir`, or null outside one. */
+    gitRoot(dir: string): string | null;
+    hasPackageJson(dir: string): boolean;
+}
+/** A package.json counts only in `dir` itself: one further up (a home directory's) says
+ * nothing about the folder the workspace goes into. */
+export declare function checkInvocationDirectory(dir: string, probe: LocationProbe): InvocationCheck;
+export declare function renderLocationRefusal(check: Extract<InvocationCheck, {
+    ok: false;
+}>): string;
+//# sourceMappingURL=location-check.d.ts.map

package/dist/cli/parse-args.d.ts

@@ -22,6 +22,9 @@ export interface ParsedArgs {
      * passed" — package-manager.ts then asks or reads the launching manager. Any other
      * value is refused before this field is ever set. */
     packageManager: CliPackageManager | undefined;
+    /** `--allow-nested`: create the workspace even inside a git repository or a package.json
+     * project (location-check.ts refuses that otherwise). */
+    allowNested: boolean;
 }
 export type ParseArgsOutcome = {
     kind: 'help';

package/dist/cli/workspace-name.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Why `name` can't be a workspace name, or undefined when it can. The name becomes the
+ * directory and the root package.json name, and it reaches create-nx-workspace as an
+ * argument — on Windows through cmd.exe — so only npm's package-name characters pass:
+ * lowercase letters, digits, "-", "_" and ".", not starting with "." or "_".
+ */
+export declare function workspaceNameProblem(name: string): string | undefined;
+export declare function invalidWorkspaceNameMessage(name: string, problem: string): string;
+//# sourceMappingURL=workspace-name.d.ts.map

package/dist/index.js

@@ -50,6 +50,25 @@ function isCliPackageManager(name) {
   return SUPPORTED.includes(name);
 }
 
+// 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) {
@@ -96,7 +115,8 @@ function parseCliArgs(argv) {
     plugins: { type: "string" },
     "review-provider": { type: "string" },
     "plugin-source": { type: "string" },
-    "package-manager": { type: "string" }
+    "package-manager": { type: "string" },
+    "allow-nested": { type: "boolean" }
   };
   let parsed;
   try {
@@ -113,6 +133,10 @@ function parseCliArgs(argv) {
     };
   }
   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) };
@@ -183,7 +207,8 @@ function parseCliArgs(argv) {
       reviewProvider,
       review,
       pluginSource: parsed.values["plugin-source"],
-      packageManager
+      packageManager,
+      allowNested: parsed.values["allow-nested"] === true
     }
   };
 }
@@ -343,6 +368,7 @@ function renderUsage() {
     "  --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",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-nx-archweave",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "One command from an empty directory to a configured Nx workspace: FSD Lite structure, AI agent rules, GitHub templates, and optional AI PR review (Claude, Gemini, GPT, Cursor)",
   "license": "MIT",
   "author": "clearlydev (https://github.com/clearlydev)",
@@ -74,8 +74,5 @@
         ]
       }
     }
-  },
-  "dependencies": {
-    "tslib": "^2.3.0"
   }
 }

package/dist/cli/execute.js

@@ -1,153 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { readdirSync, readFileSync, statSync } from 'node:fs';
-import { join } from 'node:path';
-import { spawnableCommand } from "./spawnable-command.js";
-/** Variables a launcher sets only for the command it started. `npm exec --package=<x>`
- * exports `npm_config_package=<x>`, and a child `npx -y create-nx-workspace@…` would read
- * it and treat create-nx-workspace as a command inside <x> ("not found"). The positional
- * `npx create-nx-archweave` form sets nothing here (measured 2026-10-15). */
-const LAUNCHER_ONLY = /^npm_config_package$/i;
-/** The environment every step runs with: the inherited one minus launcher-only
- * variables, plus the plan's overrides. PATH, HOME, proxies and registry settings stay. */
-export 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 statSync(path).isFile();
-    }
-    catch {
-        return false;
-    }
-}
-export function createProcessExec() {
-    return (command, args, options) => {
-        // npx, npm, pnpm, yarn and bun are .cmd shims on Windows, which Node cannot start
-        // without cmd.exe; there they run through it with every argument escaped.
-        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 };
-    };
-}
-/** Real StepContext over the created workspace (tests inject their own). */
-export function createStepContext(workspacePath) {
-    return {
-        workspacePath,
-        readFile: (relativePath) => {
-            try {
-                return readFileSync(join(workspacePath, relativePath), 'utf-8');
-            }
-            catch {
-                return undefined;
-            }
-        },
-        listDir: (relativePath) => {
-            try {
-                // directories only — a stray apps/.DS_Store must never count as an app
-                return readdirSync(join(workspacePath, relativePath), { withFileTypes: true })
-                    .filter((entry) => entry.isDirectory())
-                    .map((entry) => entry.name);
-            }
-            catch {
-                return [];
-            }
-        },
-    };
-}
-/**
- * Runs the plan's steps in order. On the first non-zero exit, stops immediately —
- * later steps never run — and reports which step failed clearly, leaving the generated
- * directory in place with cleanup guidance instead of deleting it automatically. An
- * `optional` step is the exception: its failure is recorded and the run goes on. This function itself never deletes anything;
- * it only reports.
- */
-export function executePlan(plan, exec, invokedFromDir, ctxFactory = createStepContext) {
-    const completed = [];
-    for (const step of plan.steps) {
-        const cwd = step.cwd === null ? invokedFromDir : join(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) {
-                // satisfied without running (e.g. the template already provides it)
-                completed.push({ step, result: { status: 0 }, skipped: finalized.skip });
-                continue;
-            }
-            args = finalized;
-        }
-        const result = exec(step.command, args, plan.env ? { cwd, env: plan.env } : { cwd });
-        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 });
-                continue;
-            }
-            return { ok: false, completed, failedStep: step, failedResult: result };
-        }
-        completed.push({ step, result, args });
-    }
-    return { ok: true, completed };
-}
-/** Renders the final message printed after `executePlan` returns — success prints the
- * plan's next-steps guidance; failure explains which step failed and how to recover,
- * explicitly noting the created directory is left in place (never auto-deleted). */
-export function renderExecuteReport(report, plan, workspaceName) {
-    if (report.ok) {
-        const skippedLines = report.completed
-            .filter((c) => c.skipped !== undefined)
-            .map((c) => `  skipped "${c.step.id}": ${c.skipped}`);
-        const noteLines = report.completed.flatMap((c) => c.skipped === undefined && c.optionalFailure === undefined && c.args !== undefined && c.step.successNote
-            ? [`  note: ${c.step.successNote(c.args)}`]
-            : []);
-        const failedOptional = report.completed.filter((c) => c.optionalFailure !== undefined);
-        const optionalLines = failedOptional.flatMap((c) => [
-            `  optional step "${c.step.id}" failed — ${c.step.description}.`,
-            `    ${c.optionalFailure}`,
-            ...(c.step.failureHint ? [`    ${c.step.failureHint}`] : []),
-        ]);
-        return [
-            '',
-            failedOptional.length === 0
-                ? 'create-nx-archweave finished successfully.'
-                : `create-nx-archweave finished — 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 — ${failedStep.description}.`,
-        `  ${detail}`,
-        ...(!report.finalizeError && failedStep.failureHint ? [`  ${failedStep.failureHint}`] : []),
-        '',
-        `The "${workspaceName}" directory (if it was created) was left in place — create-nx-archweave never deletes it automatically.`,
-        `Inspect the error above, fix the issue, then either re-run the failed command yourself inside "${workspaceName}" or remove the directory and start over.`,
-    ].join('\n');
-}

package/dist/cli/host-probe.js

@@ -1,27 +0,0 @@
-import { AI_HOST_PROBES, AI_HOST_VALUES } from "./types.js";
-/** The version in a probe's output — `2.1.300 (Claude Code)` → `2.1.300`, `codex-cli
- * 0.162.1` → `0.162.1` (measured) — else its first line, shortened. */
-export function parseProbeVersion(output) {
-    const firstLine = output.trim().split(/\r?\n/)[0]?.trim() ?? '';
-    const version = /\d+(?:\.\d+)+(?:[-+][0-9A-Za-z.]+)?/.exec(firstLine)?.[0];
-    if (version)
-        return version;
-    return firstLine.length > 40 ? `${firstLine.slice(0, 39)}…` : firstLine;
-}
-/** Runs every host's probe at once (gemini alone takes ~2.4 s). A probe that cannot run
- * means "not found", never an error. */
-export async function detectInstalledHosts(probe) {
-    const results = await Promise.all(AI_HOST_VALUES.map(async (host) => {
-        try {
-            return [host, await probe(AI_HOST_PROBES[host])];
-        }
-        catch {
-            return [host, undefined];
-        }
-    }));
-    const installed = {};
-    for (const [host, output] of results)
-        if (output !== undefined)
-            installed[host] = parseProbeVersion(output);
-    return installed;
-}

package/dist/cli/package-manager.js

@@ -1,139 +0,0 @@
-import { parseMajor } from "./preflight.js";
-/** Question order: npm first (always installed), then the rest. */
-const SUPPORTED = ['npm', 'pnpm', 'yarn', 'bun'];
-export function isCliPackageManager(name) {
-    return SUPPORTED.includes(name);
-}
-/** The package manager that started this process, from `npm_config_user_agent`
- * (`npm/10.9.4 node/v22 …`, `pnpm/11.9.0 npm/? node/v22 …`, `yarn/4.18.1 npm/? …`,
- * `bun/1.4.2 npm/? node/v26 …`) — set
- * by npm, pnpm, yarn and bun for everything they run, unset for a direct `node` call. */
-export function parseUserAgent(userAgent) {
-    const match = /^([a-z][a-z0-9-]*)\/(\S+)/.exec(userAgent?.trim() ?? '');
-    if (!match)
-        return undefined;
-    return { name: match[1], version: match[2] === '?' ? undefined : match[2] };
-}
-/**
- * The supported managers that are installed. npm always is (Node ships it); pnpm, yarn
- * and bun are when they run (a Windows `*.cmd` shim runs through cmd.exe), or when they
- * launched this command. The launcher's own version is used instead of probing it again.
- */
-export function listInstalledManagers(launcher, probe) {
-    const installed = [];
-    for (const name of SUPPORTED) {
-        const version = launcher?.name === name ? launcher.version ?? '' : probe(name)?.trim();
-        if (version !== undefined)
-            installed.push({ name, version: version === '' ? undefined : version });
-        // npm ships with Node, so it is listed even when its version cannot be read
-        else if (name === 'npm')
-            installed.push({ name, version: undefined });
-    }
-    return installed;
-}
-/**
- * Why this manager cannot create the chosen workspace, or undefined when it can.
- * Both known cases fail inside create-nx-workspace's own install of
- * Nx's react template, so a pick is never allowed — an unknown version is not held
- * against the manager.
- */
-export function managerIncompatibility(manager, frontend) {
-    const major = parseMajor(manager.version);
-    if (frontend !== 'react-vite' || major === undefined)
-        return undefined;
-    if (manager.name === 'npm' && major < 11)
-        return "react-vite needs npm 11 — npm 10 crashes in Nx's react template";
-    if (manager.name === 'yarn' && major < 2)
-        return "react-vite needs yarn 2+ — yarn 1 cannot resolve the template's workspace:* packages";
-    return undefined;
-}
-const NOTHING_CREATED = 'Nothing was created.';
-/**
- * Flag > (interactive) the question > launcher > npm. One rule everywhere: a manager
- * that cannot create the chosen workspace is never used — the question shows it with its
- * reason but does not offer it, and a flag or launcher naming it stops the run before
- * anything is created. Non-interactive runs launched by an unsupported manager are
- * refused the same way.
- */
-export async function choosePackageManager(input, ask, tell) {
-    const launcher = parseUserAgent(input.userAgent);
-    // flag / launcher / default: the version comes from the launcher when it is the same
-    // manager, otherwise from a probe — so the compatibility rule can apply.
-    const resolveNamed = (name, source) => {
-        const version = launcher?.name === name && launcher.version ? launcher.version : input.probe(name)?.trim() || undefined;
-        const reason = managerIncompatibility({ name, version }, input.frontend);
-        if (reason) {
-            return {
-                error: `create-nx-archweave stopped before creating anything: ${name} ${version} cannot create this workspace — ${reason}. ` +
-                    `${INSTALL_ADVICE} ${NOTHING_CREATED}`,
-            };
-        }
-        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) — choosing from the supported ones instead.`);
-    }
-    const installed = listInstalledManagers(launcher, input.probe);
-    const reasons = installed.map((manager) => managerIncompatibility(manager, input.frontend));
-    const selectable = installed.filter((_, index) => reasons[index] === undefined);
-    const unavailable = installed.filter((_, index) => reasons[index] !== undefined);
-    const unavailableLines = unavailable.map((manager) => `     ${manager.name.padEnd(6)}${manager.version ?? ''}  — not available: ${reasons[installed.indexOf(manager)]}`);
-    if (selectable.length === 0) {
-        return {
-            error: ['create-nx-archweave stopped before creating anything: no installed package manager can create this workspace.', ...unavailableLines, `${INSTALL_ADVICE} ${NOTHING_CREATED}`].join('\n'),
-        };
-    }
-    // Nothing to choose: the plan print names the manager (and why) next.
-    if (selectable.length === 1) {
-        if (unavailable.length > 0)
-            tell(['Package manager:', ...unavailableLines].join('\n'));
-        return { packageManager: selectable[0].name, source: unavailable.length > 0 ? 'only-compatible' : 'only-installed', version: selectable[0].version };
-    }
-    const defaultIndex = Math.max(0, selectable.findIndex((manager) => manager.name === launcher?.name));
-    tell('? Package manager');
-    selectable.forEach((manager, index) => {
-        const head = `  ${index + 1}) ${manager.name.padEnd(6)}${manager.version ?? ''}`.trimEnd();
-        tell(index === defaultIndex ? `${head}  (default)` : head);
-    });
-    unavailableLines.forEach((line) => tell(line));
-    for (;;) {
-        const answer = (await ask(`Choose 1-${selectable.length} [${defaultIndex + 1}]: `)).trim().toLowerCase();
-        const byNumber = /^\d+$/.test(answer) ? Number(answer) - 1 : -1;
-        const index = answer === '' ? defaultIndex : byNumber >= 0 ? byNumber : selectable.findIndex((manager) => manager.name === answer);
-        if (index >= 0 && index < selectable.length) {
-            return { packageManager: selectable[index].name, source: 'asked', version: selectable[index].version };
-        }
-        const blocked = unavailable.find((manager) => manager.name === answer);
-        tell(blocked
-            ? `${blocked.name} is not available here: ${reasons[installed.indexOf(blocked)]}.`
-            : `Choose a number from 1 to ${selectable.length} (or a name: ${selectable.map((manager) => manager.name).join(', ')}).`);
-    }
-}
-const SUPPORTED_TEXT = 'npm, pnpm, yarn and bun';
-const INSTALL_ADVICE = 'Use npm 11+, pnpm, yarn 2+ (Corepack: corepack enable) or bun, or pass --package-manager= with one of them.';
-const SOURCE_TEXT = {
-    flag: '--package-manager',
-    launcher: 'the package manager that ran this command',
-    default: 'default — no launching package manager detected',
-    asked: 'chosen',
-    'only-installed': 'the only one installed',
-    'only-compatible': 'the only installed one that can create this workspace',
-};
-/** `npm 11.6.2 (the package manager that ran this command)` — for the plan print. */
-export function describeResolution(resolution) {
-    const name = resolution.version ? `${resolution.packageManager} ${resolution.version}` : resolution.packageManager;
-    return `${name} (${SOURCE_TEXT[resolution.source]})`;
-}