create-nx-archweave 0.1.1 → 0.2.1

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`

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
@@ -218,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 {
@@ -309,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 (; ; ) {
@@ -469,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",
@@ -1043,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) {
@@ -1188,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/index.js

@@ -115,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 {
@@ -206,7 +207,8 @@ function parseCliArgs(argv) {
       reviewProvider,
       review,
       pluginSource: parsed.values["plugin-source"],
-      packageManager
+      packageManager,
+      allowNested: parsed.values["allow-nested"] === true
     }
   };
 }
@@ -366,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.1",
+  "version": "0.2.1",
   "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)",

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]})`;
-}

package/dist/cli/parse-args.js

@@ -1,171 +0,0 @@
-import { parseArgs as parseNodeArgs } from 'node:util';
-import { AI_HOST_VALUES, BACKEND_VALUES, FRONTEND_VALUES, LOCALE_VALUES, PLUGIN_VALUES, PRESET_VALUES, REVIEW_PROVIDER_VALUES, } from "./types.js";
-import { isCliPackageManager } from "./package-manager.js";
-import { invalidWorkspaceNameMessage, workspaceNameProblem } from "./workspace-name.js";
-/** The string-valued flags declared below, in their separated two-token form
- * (`--preset solo`). extractReviewFlag must never treat the token AFTER one of
- * these as a review flag — it is that flag's value, so both tokens pass through
- * to parseArgs untouched. parseArgs then consumes it as the value, or, for a
- * dash-leading value like `--plugin-source --review`, rejects it with its own
- * clear "argument is ambiguous / use --plugin-source=-XYZ" error — either way
- * it is never silently reinterpreted as the review flag. */
-const STRING_VALUE_FLAGS = new Set(['--preset', '--frontend', '--backend', '--locale', '--ai-hosts', '--plugins', '--review-provider', '--plugin-source', '--package-manager']);
-/** node:util's parseArgs has no built-in `--no-foo` negation (verified locally: it
- * throws "Unknown option '--no-review'" when `review` is declared as a plain boolean
- * option), so --review/--no-review/--review=true|false are hand-rolled here and
- * stripped out before the rest of argv reaches parseArgs. */
-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(', ')}`;
-}
-/** Pure flag parsing: no I/O, no prompting — bin.ts decides what to do with each
- * outcome (print help/version, print an error and exit non-zero, or hand `args` to
- * prompts.ts for anything still missing). */
-export 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' },
-    };
-    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 === undefined ? undefined : workspaceNameProblem(name);
-    if (name !== undefined && nameProblem !== undefined) {
-        return { kind: 'error', message: invalidWorkspaceNameMessage(name, nameProblem) };
-    }
-    const preset = parsed.values.preset;
-    if (preset !== undefined && !PRESET_VALUES.includes(preset)) {
-        return { kind: 'error', message: invalidChoiceMessage('--preset', preset, PRESET_VALUES) };
-    }
-    const frontend = parsed.values.frontend;
-    if (frontend !== undefined && !FRONTEND_VALUES.includes(frontend)) {
-        return { kind: 'error', message: invalidChoiceMessage('--frontend', frontend, FRONTEND_VALUES) };
-    }
-    const backend = parsed.values.backend;
-    if (backend !== undefined && !BACKEND_VALUES.includes(backend)) {
-        return { kind: 'error', message: invalidChoiceMessage('--backend', backend, BACKEND_VALUES) };
-    }
-    // A workspace needs something to build: no frontend means a backend-only workspace.
-    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 !== undefined && !LOCALE_VALUES.includes(locale)) {
-        return { kind: 'error', message: invalidChoiceMessage('--locale', locale, LOCALE_VALUES) };
-    }
-    const aiHostsRaw = parsed.values['ai-hosts'];
-    let aiHosts;
-    if (aiHostsRaw !== undefined) {
-        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 !== undefined) {
-            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 !== undefined) {
-        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 !== undefined) {
-                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 !== undefined && !REVIEW_PROVIDER_VALUES.includes(reviewProvider)) {
-        return { kind: 'error', message: invalidChoiceMessage('--review-provider', reviewProvider, REVIEW_PROVIDER_VALUES) };
-    }
-    const packageManager = parsed.values['package-manager'];
-    if (packageManager !== undefined && !isCliPackageManager(packageManager)) {
-        return {
-            kind: 'error',
-            message: `--package-manager "${packageManager}" is not supported — create-nx-archweave supports npm, pnpm, yarn and bun.`,
-        };
-    }
-    return {
-        kind: 'ok',
-        args: {
-            name,
-            preset: preset,
-            frontend: frontend,
-            backend: backend,
-            locale: locale,
-            aiHosts,
-            plugins,
-            reviewProvider: reviewProvider,
-            review,
-            pluginSource: parsed.values['plugin-source'],
-            packageManager,
-        },
-    };
-}