create-nx-archweave 0.1.1 → 0.2.0

package/dist/cli/plan.js

@@ -1,434 +0,0 @@
-import { AI_HOST_CHOICES } from "./types.js";
-import { CLI_VERSION } from "../render-usage.js";
-/** The plugin release this CLI was built and tested with — caret-pinned so a later
- * breaking 0.x plugin never pairs with an older CLI (release prep, 2026-10-17). */
-const DEFAULT_PLUGIN_SOURCE = `@clearlydev/nx-archweave@^${CLI_VERSION}`;
-/** E2E-CI finding (2026-10-08): the react-monorepo layout differed between CI and
- * local runs — first blamed on a 23.2.0 → 23.2.1 minor bump, later traced to the
- * agent detection documented on createWorkspaceSourceArgs (2026-10-13). The CLI pins the exact version its own E2E
- * gate validated either way — bumping this constant is done together with a green
- * `node tools/e2e-create.mjs` run for both PMs. */
-const VALIDATED_CREATE_NX_WORKSPACE_VERSION = '23.3.0';
-/** npm 10 (bundled with Node 22) crashes inside create-nx-workspace's own install
- * of the react template's dependency tree — an arborist bug in its peer-set
- * resolution, reproduced on every npm 10 release up to 10.9.9 and absent in npm 11
- * (E2E CI finding, 2026-10-13). The next preset installs fine on npm 10
- * (2026-10-14), so only react-vite + npm is affected: package-manager.ts never lets a
- * known npm 10 pick it, and the create step keeps this hint for the case the version
- * could not be read. */
-export const NPM_10_CREATE_WORKSPACE_HINT = "If the npm error above is \"Cannot read properties of null (reading 'edgesOut')\", that is a known npm 10 bug " +
-    'with the current Nx workspace dependencies — upgrade npm (npm install -g npm@11), or, if pnpm is installed, re-run with --package-manager=pnpm.';
-/** yarn 1 cannot resolve the `workspace:*` packages Nx's react template declares
- * (measured 2026-10-15); the same guard and fallback as npm 10 above. */
-export const YARN_1_CREATE_WORKSPACE_HINT = 'If the yarn error above is "Couldn\'t find package …@workspace:*", that is yarn 1 (classic), which cannot resolve ' +
-    "the workspace:* packages in Nx's react template — use yarn 2+ (corepack enable, then yarn set version stable) or re-run with another package manager.";
-/** `nx` through the workspace's own manager. npm never gets a bare `nx` (its exec needs `--`). */
-function nxArgs(pm) {
-    return pm === 'npm' ? ['exec', 'nx', '--'] : ['nx'];
-}
-/** `pnpm nx g` / `npm exec nx -- g` — how the user runs a generator in the new workspace. */
-export function nxGenerateCommand(pm) {
-    return `${pm} ${nxArgs(pm).join(' ')} g`;
-}
-/** A dev dependency at the workspace root. pnpm: -w (it refuses a root install without
- * it — ERR_PNPM_ADDING_TO_ROOT). npm: plain root install, never -w (it means
- * --workspace=<name> there). bun: plain root add (measured, bun 1.4). yarn: classic
- * needs -W, berry rejects it — so the created workspace decides (`.yarnrc.yml` / a
- * `__metadata:` lockfile mark berry). */
-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];
-}
-export function isYarnBerry(ctx) {
-    return ctx.readFile('.yarnrc.yml') !== undefined || /^__metadata:/m.test(ctx.readFile('yarn.lock') ?? '');
-}
-/** yarn berry refuses to write a lockfile when it detects CI (YN0028, measured), which
- * would fail create-nx-workspace's own install in CI and agent runs. Classic ignores it. */
-const YARN_PLAN_ENV = { YARN_ENABLE_IMMUTABLE_INSTALLS: 'false' };
-/**
- * Maps our `frontend` option to what `create-nx-workspace` builds the workspace
- * from: react-vite → `--template=nrwl/react-template`, next → `--preset=next`.
- *
- * Why react-vite names the template (E2E CI finding, 2026-10-13): with
- * `--preset=react-monorepo`, create-nx-workspace 23.2 builds the fullstack
- * GitHub template (apps/shop + an Express apps/api) ONLY when it detects an AI
- * agent in the environment (CLAUDECODE, CLAUDE_CODE, OPENCODE, CODEX_THREAD_ID,
- * ...); from a plain terminal — and in CI — the same flags run the classic preset
- * (apps/<name> only, no api, a different package layout). Every measurement this
- * CLI and its docs rely on was taken on the template, so naming it makes every
- * user get that workspace. The template flow downloads from github.com.
- *
- * `--preset=next` needs no further flag with `--interactive=false` — Nx fills
- * every unspecified option with its own default (non-interactive probe against
- * create-nx-workspace v23.2.1, 2026-09-16).
- */
-function createWorkspaceSourceArgs(frontend, backend) {
-    if (frontend === 'react-vite')
-        return ['--template=nrwl/react-template'];
-    if (frontend === 'next')
-        return ['--preset=next'];
-    // Backend-only: Nx's own preset builds the api, named the way every other path names
-    // it (measured 2026-10-16, 23.2.0: express → apps/api as a package.json project,
-    // nest → apps/api with a project.json; both with apps/api-e2e).
-    return [`--preset=${backend}`, '--appName=api'];
-}
-function buildNextSteps(input) {
-    const lines = [
-        `cd ${input.name}`,
-        ...(input.backend !== 'none'
-            ? [`${input.packageManager} install   (links the new shared-types workspace package — do this before the first commit)`]
-            : []),
-        'git add -A && git commit -m "chore: initial commit"',
-        '(create-nx-archweave never commits for you — review what the init report above generated first.)',
-    ];
-    if (input.review === false)
-        return lines;
-    // Deliberately vague about WHICH secret: the init report above prints the
-    // authoritative secret name for the chosen provider (owned by
-    // template-engine/review) — repeating a specific name here would duplicate
-    // that content knowledge into the CLI.
-    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;
-}
-/**
- * Pure: builds the ordered command list plus the next-steps guidance text
- * (step 5). No I/O — `cli/execute.ts` is what actually runs
- * these commands.
- */
-export function buildPlan(input) {
-    const pluginSource = input.pluginSource ?? DEFAULT_PLUGIN_SOURCE;
-    const workspaceSource = createWorkspaceSourceArgs(input.frontend, input.backend);
-    // One flag per host — create-nx-workspace rejects a comma list (measured, 23.2.0). The
-    // react template ships every host's files anyway; the flag decides them for next.
-    const aiAgentArgs = input.aiHosts.map((host) => `--aiAgents=${AI_HOST_CHOICES.find((choice) => choice.id === host)?.nxAgent ?? host}`);
-    const pm = input.packageManager;
-    // npm's -w means --workspace=<name>, never "workspace root" — npm installs
-    // at the root by default, so the flag is simply absent there.
-    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.
-        '--allowDirty=true',
-    ];
-    if (input.review !== undefined) {
-        initArgs.push(`--review=${input.review}`);
-    }
-    if (input.reviewProvider !== undefined && input.review !== false) {
-        initArgs.push(`--reviewProvider=${input.reviewProvider}`);
-    }
-    // Decision (i): the CLI just created this workspace, so init writes the ESLint rules for
-    // real instead of printing snippets — the scope constraints (backend axis) and the FSD
-    // layer rule alike.
-    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' && pm === 'npm' ? { failureHint: NPM_10_CREATE_WORKSPACE_HINT } : {}),
-            ...(input.frontend === 'react-vite' && pm === 'yarn' ? { failureHint: YARN_1_CREATE_WORKSPACE_HINT } : {}),
-        },
-        {
-            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 } : {}),
-    };
-}
-/** Last of all: install-integration runs the host's own
- * installer, verifies the result live and records it — at project scope, so the plugin is
- * recorded in the workspace rather than in the user's settings. Optional: the workspace is
- * complete without it. The generator reports a failed install itself and still exits 0, so
- * the note points at its report; a non-zero exit (it crashed) gets the retry command. */
-function installPluginStep(plugin, workspaceName, pm) {
-    const hostLabel = 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 ${hostLabel} (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(' ')}`,
-    };
-}
-/** pnpm 11 turned `strictDepBuilds` on: an install that meets a dependency build
- * script with no `allowBuilds` decision writes a placeholder and fails
- * (ERR_PNPM_IGNORED_BUILDS) — inside create-nx-workspace's own install of the next
- * preset, and in any install an Nx generator runs later. Every pnpm step runs with
- * it off (pnpm 11 reads `pnpm_config_<snake_case>` variables), so a skipped script
- * stays skipped; the final settle step records those skips as decisions. pnpm 10
- * never fails here, so this is a no-op there. */
-const PNPM_PLAN_ENV = { pnpm_config_strict_dep_builds: 'false' };
-/** The value pnpm 11 writes under `allowBuilds` for a dependency whose build script
- * it skipped without a decision (pnpm 11.9 `handleIgnoredBuilds`). Left in place,
- * the next plain `pnpm install` fails on it again. */
-export const PNPM_PENDING_BUILD_PLACEHOLDER = 'set this to true or false';
-/** Package names pnpm left awaiting a build decision in pnpm-workspace.yaml — the
- * `allowBuilds` entries still holding the placeholder, in the block form pnpm's
- * writer uses and the single-line flow form it keeps when the file had
- * `allowBuilds: {}`. Keys may contain colons (`foo@file:../foo`), so a line is
- * anchored on the placeholder, not split at the first colon; comments never count.
- * The file is pnpm's own output, and an unexpected shape just yields no names (the
- * user then sees pnpm's own ERR_PNPM_IGNORED_BUILDS guidance on the next install). */
-export 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 undefined;
-        return entry.exec(trimmed)?.[2];
-    };
-    const names = [];
-    let inAllowBuilds = false;
-    for (const line of workspaceYaml.split(/\r?\n/)) {
-        if (/^\s*#/.test(line))
-            continue; // a comment, even at column 0, neither ends nor joins a block
-        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 name = pendingKey(item);
-                    if (name !== undefined)
-                        names.push(name);
-                }
-            }
-            continue;
-        }
-        if (!inAllowBuilds)
-            continue;
-        const name = pendingKey(line);
-        if (name !== undefined)
-            names.push(name);
-    }
-    return names;
-}
-/** Last pnpm step: every build script pnpm skipped during the flow (and wrote down
- * as pending) is recorded as NOT allowed, through pnpm's own non-interactive
- * `approve-builds !<pkg>` — the conservative choice (no third-party install script
- * runs without the user's say), and the one Nx's own templates make for @swc/core
- * and esbuild. Without it the user's first `pnpm install` fails on the placeholders. */
-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 === undefined ? [] : 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 — 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.',
-    };
-}
-/** Last bun step: bun blocks the install scripts of dependencies outside its trusted
- * list without a word during the install (measured: @swc/core's postinstall in Nx's react
- * template). Read-only — `bun pm untrusted` prints bun's own list, and exits 0 with
- * "Found 0 untrusted dependencies" when nothing was blocked (measured, bun 1.4.2). The
- * scripts stay blocked; the note names the one-line way back. */
-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 — they stay blocked. ' +
-            `To allow one later, run inside "${workspaceName}": bun pm trust <package>`,
-        failureHint: 'The workspace itself is complete — every earlier step finished; only listing the blocked install scripts failed. ' +
-            `Inside "${workspaceName}", run bun pm untrusted to see them.`,
-    };
-}
-/** The two official-generator steps (3 and 4). Both need
- * execution-time facts: the created workspace's nx version (so @nx/* versions
- * can never drift from nx's) and the frontend app's directory name. */
-function backendSteps(backend, workspaceName, pm, initCommand) {
-    const nxG = nxGenerateCommand(pm);
-    // Measured realities (probed 2026-10-05 against create-nx-workspace
-    // v23.2.x): the react-vite path builds Nx's fullstack template (named
-    // explicitly — see createWorkspaceSourceArgs), which ALREADY ships an Express
-    // apps/api — so for express the two official
-    // steps are satisfied-by-template (skip), and for nest the api slot is
-    // taken (clear refusal instead of a collision). The next preset (re-measured
-    // 2026-10-16, Nx 23.2.0) builds apps/<name> + apps/<name>-e2e with no api, so
-    // both steps run there as on a template without one. A workspace without apps/
-    // (a layout neither path builds today) still stops with the manual path.
-    const templateApi = (ctx) => ctx.listDir('apps').includes('api');
-    const standaloneError = 'this workspace has no apps/ directory — 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 nestConflictError = "the workspace template already ships an Express apps/api — re-run with --backend=express " +
-        'to wire it, or remove apps/api and scaffold Nest yourself, then run add-backend. ' +
-        `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 (templateApi(ctx)) {
-                    return backend === 'express'
-                        ? { skip: 'the workspace template already ships the Express api' }
-                        : { error: nestConflictError };
-                }
-                const raw = ctx.readFile('package.json');
-                if (raw === undefined)
-                    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'],
-            cwd: workspaceName,
-            finalizeArgs: (ctx) => {
-                const all = ctx.listDir('apps');
-                if (all.length === 0)
-                    return { error: standaloneError };
-                if (all.includes('api')) {
-                    return backend === 'express'
-                        ? { skip: 'the workspace template already ships the Express api' }
-                        : { error: nestConflictError };
-                }
-                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(', ')}) — cannot pick --frontendProject` };
-                // The template registers SCOPED project names (@org/web) while the
-                // directory stays apps/web — --frontendProject needs the project name
-                // (E2E-CI finding: the directory name made nx fail with "Cannot find
-                // configuration"). project.json name, then package.json name, then dir.
-                const frontendProject = (() => {
-                    for (const file of [`apps/${apps[0]}/project.json`, `apps/${apps[0]}/package.json`]) {
-                        const raw = ctx.readFile(file);
-                        if (raw === undefined)
-                            continue;
-                        try {
-                            const name = JSON.parse(raw).name;
-                            if (typeof name === 'string' && name.length > 0)
-                                return name;
-                        }
-                        catch {
-                            // unreadable — fall through
-                        }
-                    }
-                    return apps[0];
-                })();
-                return [...nxArgs(pm), 'g', `@nx/${backend}:application`, 'apps/api', `--frontendProject=${frontendProject}`];
-            },
-        },
-    ];
-}

package/dist/cli/plugins.js

@@ -1,74 +0,0 @@
-import { AI_HOST_CHOICES, PLUGIN_CHOICES } from "./types.js";
-const hostLabel = (host) => AI_HOST_CHOICES.find((choice) => choice.id === host)?.label ?? host;
-/** `--plugins` against the picked hosts: an unknown id or a plugin of a host not picked is
- * an error. bin.ts runs it before any question when both flags were passed. */
-export function resolvePluginFlag(ids, aiHosts) {
-    const plugins = [];
-    for (const id of ids) {
-        const plugin = PLUGIN_CHOICES.find((choice) => choice.id === id);
-        if (!plugin)
-            return { error: `Unknown plugin "${id}" in --plugins. Supported: ${PLUGIN_CHOICES.map((choice) => choice.id).join(', ')}.` };
-        if (!aiHosts.includes(plugin.host)) {
-            return {
-                error: `--plugins=${id} installs into ${hostLabel(plugin.host)}, which is not among the AI hosts (${aiHosts.join(', ')}) — ` +
-                    `add ${plugin.host} to --ai-hosts or drop the plugin.`,
-            };
-        }
-        plugins.push(plugin);
-    }
-    return { plugins };
-}
-/** `1`, `1,2`, `ponytail` or a mix, among `offered`; empty means none. Undefined for
- * anything else — the question is asked again. */
-export function parsePluginAnswer(answer, offered) {
-    const tokens = answer.split(/[\s,]+/).filter((token) => token.length > 0);
-    const picked = [];
-    for (const token of tokens) {
-        const byNumber = /^\d+$/.test(token) ? offered[Number(token) - 1] : undefined;
-        const plugin = byNumber ?? offered.find((choice) => choice.id === token.toLowerCase());
-        if (!plugin)
-            return undefined;
-        if (!picked.includes(plugin))
-            picked.push(plugin);
-    }
-    return picked;
-}
-export function pluginQuestion(host, offered) {
-    return [
-        `? Plugins for ${hostLabel(host)} — install now, into this workspace (project scope)?`,
-        ...offered.map((plugin, index) => `  ${index + 1}) ${plugin.label} — ${plugin.description} (${plugin.license})`),
-        'Choose, e.g. 1 — Enter to skip []: ',
-    ].join('\n');
-}
-/**
- * The optional plugins, asked last. A flag always wins; it
- * may only name plugins of a picked host. Without a terminal and without the flag: none.
- * Asked once per picked host that has catalog plugins and whose CLI was found — installing
- * runs that CLI, so a host this machine lacks gets a one-line "later" hint instead.
- */
-export async function choosePlugins(input, ask, log) {
-    if (input.flag !== undefined)
-        return resolvePluginFlag(input.flag, input.aiHosts);
-    if (!input.interactive)
-        return { plugins: [] };
-    const plugins = [];
-    for (const host of input.aiHosts) {
-        const offered = PLUGIN_CHOICES.filter((plugin) => plugin.host === host);
-        if (offered.length === 0)
-            continue;
-        if (input.installedHosts !== undefined && input.installedHosts[host] === undefined) {
-            log(`${hostLabel(host)} was not found, so its plugins (${offered.map((plugin) => plugin.id).join(', ')}) are not offered. ` +
-                `Once it is installed, inside the workspace: ${input.nxG} @clearlydev/nx-archweave:install-integration --tool=<plugin> --apply`);
-            continue;
-        }
-        const question = pluginQuestion(host, offered);
-        for (;;) {
-            const picked = parsePluginAnswer(await ask(question), offered);
-            if (picked) {
-                plugins.push(...picked);
-                break;
-            }
-        }
-    }
-    return { plugins };
-}

package/dist/cli/preflight.js

@@ -1,7 +0,0 @@
-/** The major version of a `<manager> --version`-style string, or undefined when it does
- * not start with one. The compatibility rule that uses it lives in package-manager.ts
- * (one gate for flag, launcher and question). */
-export function parseMajor(version) {
-    const match = /^\s*v?(\d+)\./.exec(version ?? '');
-    return match ? Number(match[1]) : undefined;
-}

package/dist/cli/prompts.js

@@ -1,150 +0,0 @@
-import { AI_HOST_CHOICES, BACKEND_VALUES, DEFAULT_AI_HOSTS, FRONTEND_VALUES, LOCALE_VALUES, PRESET_VALUES, REVIEW_PROVIDER_CHOICES, } from "./types.js";
-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());
-}
-/** `1,3`, `1 3`, `codex,cursor` or a mix; empty means the default. Undefined for anything
- * that is not a listed number or id — the question is asked again. */
-export 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] : undefined;
-        const host = byNumber ?? AI_HOST_CHOICES.find((choice) => choice.id === token.toLowerCase());
-        if (!host)
-            return undefined;
-        if (!picked.includes(host.id))
-            picked.push(host.id);
-    }
-    return picked;
-}
-/** `installed 2.1.300` / `not found`, or nothing when the hosts were not probed. */
-export function hostStatus(host, installed) {
-    if (installed === undefined)
-        return '';
-    const version = installed[host];
-    if (version === undefined)
-        return 'not found';
-    return version.length > 0 ? `installed ${version}` : 'installed';
-}
-export 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;
-    }
-}
-/**
- * Only asks about whatever `input` doesn't already have (flags always win; only the
- * gaps become interactive questions):
- *  - preset: asked if missing.
- *  - frontend: asked if missing, for every preset; `none` makes a backend-only workspace,
- *    so a backend is then required (and `none` is not offered when the backend is none).
- *  - backend: asked if missing, for every preset — the stack choice is never
- *    minimized away.
- *  - locale: quick-start forces 'en' with NO question (keep later questions minimal);
- *    solo/team ask if missing.
- *  - aiHosts: asked if missing, for every preset, as a numbered multi-select;
- *    never without a terminal (the default host then).
- *  - review: asked with a single yes/no ONLY when the resolved preset is quick-start
- *    (the opt-in preset, which asks a single install-or-not question) AND no
- *    --review/--no-review flag was given.
- *    solo/team never ask — an explicit flag still overrides their preset default,
- *    but absent one, `review` stays undefined for the init generator to default.
- *
- * NOTE: "quick-start is the only preset that asks about review" is this CLI's own rule,
- * but it mirrors what
- * `packages/template-engine/src/presets/preset-config.ts` encodes (quick-start is
- * opt-in, solo/team default review on) without importing it — the CLI must not
- * depend on template-engine. Like `types.ts`'s enum copies,
- * this is a deliberate hand-synced literal: if a preset's review default ever
- * changes there, update this question gate to match.
- */
-export async function collectMissingInputs(input, ask) {
-    const preset = input.preset ?? (await askChoice(ask, `Preset (${PRESET_VALUES.join('/')}): `, PRESET_VALUES));
-    // none/none would build nothing: whichever is asked second leaves `none` out when the
-    // other is already none (both passed as flags is refused by parse-args).
-    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));
-    // Asked for every preset: the hosts decide which files the workspace gets.
-    const aiHosts = input.aiHosts ?? (input.interactive ? await askAiHosts(ask, input.installedHosts) : [...DEFAULT_AI_HOSTS]);
-    let review = input.review;
-    if (review === undefined && preset === 'quick-start') {
-        const answer = await ask('Enable AI PR review? (y/N): ');
-        review = parseYesNo(answer);
-    }
-    // The provider is asked only when review will be on: an explicit yes, or solo/team's own
-    // default (the same hand-synced rule as the question above). Enter keeps init's default.
-    let reviewProvider = input.reviewProvider;
-    if (reviewProvider === undefined && reviewWillBeOn(preset, review) && input.interactive) {
-        reviewProvider = await askReviewProvider(ask, aiHosts[0]);
-    }
-    return { preset, frontend, backend, locale, aiHosts, review, reviewProvider };
-}
-/** Whether init will set up AI PR review: an explicit --review / --no-review, else every preset
- * but quick-start (hand-synced with template-engine's preset defaults, like the question). */
-export function reviewWillBeOn(preset, review) {
-    return review ?? preset !== 'quick-start';
-}
-/** `--review-provider` with review off is refused rather than dropped without a word. Undefined
- * when there is nothing to refuse (no flag, or review on). */
-export function reviewProviderConflict(preset, review, reviewProvider) {
-    if (reviewProvider === undefined)
-        return undefined;
-    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 === undefined || reviewWillBeOn(preset, review))
-        return undefined;
-    return '--review-provider needs AI PR review on, and the quick-start preset leaves it off: add --review, or drop --review-provider.';
-}
-export 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 — ${host?.label})` : ''}`),
-        `Choose 1-${REVIEW_PROVIDER_CHOICES.length} [${defaultIndex + 1}]: `,
-    ].join('\n');
-}
-/** A number or an id; empty → undefined (init's default). Anything else is asked again. */
-export function parseReviewProviderAnswer(answer) {
-    const token = answer.trim().toLowerCase();
-    if (token === '')
-        return undefined;
-    const byNumber = /^\d+$/.test(token) ? REVIEW_PROVIDER_CHOICES[Number(token) - 1] : undefined;
-    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;
-    }
-}