@mizen-labs/cli 0.0.0-stage → 0.1.0

package/dist/doctor/workspace.js

@@ -0,0 +1,169 @@
+import { lstat } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { row } from "../output.js";
+import { doctor } from "./doctor.js";
+import { exists, manifestAt } from "./files.js";
+import { frameworkOf } from "./project.js";
+import { check, formatDiagnostic, report, summaryLine, } from "./report.js";
+import { findWorkspace, linkedProject, memberPath, WorkspaceConfigError, workspaceMembers, } from "./workspace-config.js";
+function skipped(workspace, project, name, reason, uncertain = false) {
+    return {
+        ...(uncertain
+            ? {
+                diagnostic: check("workspace.package", "unverified", reason, [project], "Inspect this package explicitly with mizen doctor --cwd <APP_DIR>."),
+            }
+            : {}),
+        skipped: {
+            name,
+            path: memberPath(workspace.project, project),
+            project,
+            reason,
+            status: uncertain ? "unverified" : "skipped",
+        },
+    };
+}
+function uncertainFramework(manifest) {
+    const dependencies = {
+        ...manifest.dependencies,
+        ...manifest.devDependencies,
+    };
+    return [
+        "next",
+        "@tanstack/react-start",
+        "astro",
+        "@react-router/dev",
+        "@sveltejs/kit",
+    ].some((name) => name in dependencies);
+}
+async function inspectMember(workspace, project, nodeRange) {
+    const path = join(project, "package.json");
+    try {
+        if ((await lstat(project)).isSymbolicLink() ||
+            (await linkedProject(project))) {
+            return skipped(workspace, project, null, "Linked package directories are not inspected implicitly.", true);
+        }
+        const manifest = await manifestAt(path);
+        if (!manifest) {
+            return {};
+        }
+        return inspectApp(workspace, project, manifest, nodeRange);
+    }
+    catch {
+        return {
+            diagnostic: check("workspace.manifest", "error", "A workspace package manifest or directory is invalid or unreadable.", [path], "Repair this package's manifest or directory, then rerun mizen doctor --workspace."),
+            skipped: {
+                name: null,
+                path: memberPath(workspace.project, project),
+                project,
+                reason: "The package cannot be classified because its metadata is unavailable.",
+                status: "unverified",
+            },
+        };
+    }
+}
+async function inspectApp(workspace, project, manifest, nodeRange) {
+    const framework = frameworkOf(manifest);
+    if (framework === "unknown") {
+        return skipped(workspace, project, manifest.name ?? null, uncertainFramework(manifest)
+            ? "The package declares an unsupported or ambiguous application framework."
+            : "No supported application framework is declared.", uncertainFramework(manifest));
+    }
+    if (framework === "vite" && !(await exists(join(project, "index.html")))) {
+        return skipped(workspace, project, manifest.name ?? null, "React and Vite are declared without index.html; this may be a library or a custom app.", true);
+    }
+    const result = await doctor(project, nodeRange, {
+        allowWorkspaceRoot: true,
+    }).catch(() => report(project, [
+        check("workspace.inspection", "error", "The application could not be inspected.", [project], "Run mizen doctor --cwd <APP_DIR> to inspect this failure separately."),
+    ]));
+    return {
+        app: {
+            ...result,
+            framework,
+            name: manifest.name ?? null,
+            path: memberPath(workspace.project, project),
+        },
+    };
+}
+function aggregate(workspace, diagnostics, members) {
+    const apps = members.flatMap((member) => (member.app ? [member.app] : []));
+    const skippedPackages = members.flatMap((member) => member.skipped ? [member.skipped] : []);
+    const all = [
+        ...diagnostics,
+        ...members.flatMap((member) => member.diagnostic ? [member.diagnostic] : []),
+        ...apps.flatMap((app) => app.diagnostics.map((item) => ({ ...item, project: app.project }))),
+    ];
+    if (!apps.length) {
+        all.push(check("workspace.apps", "unverified", "No supported applications were inspected.", [workspace.source], "Check workspace patterns and skipped packages, or inspect an app with mizen doctor --cwd <APP_DIR>."));
+    }
+    return {
+        ...report(workspace.project, all),
+        apps,
+        skipped: skippedPackages,
+        workspace: {
+            kind: workspace.kind,
+            patterns: workspace.patterns,
+            source: workspace.source,
+        },
+    };
+}
+export async function workspaceDoctor(cwd, nodeRange) {
+    try {
+        const workspace = await findWorkspace(cwd);
+        const { diagnostics, projects } = await workspaceMembers(workspace);
+        const members = [];
+        for (const project of projects) {
+            // biome-ignore lint/performance/noAwaitInLoops: Keep filesystem inspection bounded and report apps independently.
+            members.push(await inspectMember(workspace, project, nodeRange));
+        }
+        return aggregate(workspace, diagnostics, members);
+    }
+    catch (error) {
+        const diagnostic = error instanceof WorkspaceConfigError
+            ? error.diagnostic
+            : check("workspace.discovery", "error", "The workspace could not be read.", [resolve(cwd)], "Check directory permissions and workspace configuration, then rerun mizen doctor --workspace.");
+        return {
+            ...report(resolve(cwd), [diagnostic]),
+            apps: [],
+            skipped: [],
+            workspace: null,
+        };
+    }
+}
+function appLabel(app) {
+    return `${app.path} (${app.framework}${app.name ? `, ${app.name}` : ""})`;
+}
+export function formatWorkspace(style, result) {
+    const appFindings = result.apps.flatMap((app) => {
+        const findings = app.diagnostics.filter((item) => item.status !== "pass");
+        return findings.length
+            ? [
+                style.bold(appLabel(app)),
+                ...findings.flatMap((item) => formatDiagnostic(style, item, app.path)),
+            ]
+            : [];
+    });
+    const rootFindings = result.diagnostics.filter((item) => !("project" in item) && item.status !== "pass");
+    return [
+        row("Workspace", result.project ?? "Not found"),
+        ...(result.workspace ? [row("Declared in", result.workspace.source)] : []),
+        "",
+        ...(result.apps.length
+            ? [
+                style.bold("Apps"),
+                ...result.apps.map((app) => row(`${app.status[0]?.toUpperCase()}${app.status.slice(1)}`, appLabel(app))),
+                "",
+            ]
+            : []),
+        ...rootFindings.flatMap((item) => formatDiagnostic(style, item)),
+        ...appFindings,
+        ...(result.skipped.length
+            ? [
+                style.bold("Skipped"),
+                ...result.skipped.map((item) => row(item.path, item.reason)),
+                "",
+            ]
+            : []),
+        summaryLine(style, result),
+    ].join("\n");
+}

package/dist/errors.js

@@ -0,0 +1,81 @@
+import { nextStep, row, status } from "./output.js";
+const SAFE = /^[\w./:=@<>-]+$/u;
+/** argv as one command line, quoting what the shell would split. */
+export function commandLine(argv) {
+    return argv
+        .map((arg) => (SAFE.test(arg) ? arg : `'${arg.replaceAll("'", "'\\''")}'`))
+        .join(" ");
+}
+/**
+ * A failure with one class. `reason` is a stable snake_case code; the exit
+ * code is 2 for usage and missing input, 1 for every other failure.
+ */
+export class CliError extends Error {
+    reason;
+    exitCode;
+    detail;
+    constructor(reason, message, exitCode, detail = {}) {
+        super(message);
+        this.reason = reason;
+        this.exitCode = exitCode;
+        this.detail = detail;
+    }
+}
+function seeHelp(command) {
+    return {
+        argv: ["mizen", ...(command ? [command] : []), "--help"],
+        benefit: "See usage",
+    };
+}
+export function invalidUsage(message, command, reason = "invalid_arguments") {
+    throw new CliError(reason, message, 2, { next: seeHelp(command) });
+}
+const UNKNOWN_OPTION = /Unknown option '(?<option>[^']+)'/u;
+export function normalizeError(error, command) {
+    if (error instanceof CliError) {
+        return error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    const code = error instanceof TypeError && "code" in error ? String(error.code) : "";
+    const where = `mizen${command ? ` ${command}` : ""}`;
+    if (code === "ERR_PARSE_ARGS_UNKNOWN_OPTION") {
+        const option = UNKNOWN_OPTION.exec(message)?.[1] ?? "option";
+        return new CliError("unknown_option", `Unknown option ${option} for ${where}.`, 2, { next: seeHelp(command) });
+    }
+    if (code.startsWith("ERR_PARSE_ARGS")) {
+        return new CliError("invalid_arguments", `Can't read the options for ${where}. ${message}`, 2, { next: seeHelp(command) });
+    }
+    return new CliError("internal_error", `Unexpected error in ${where}. This is a bug in Mizen CLI.`, 1, {
+        next: {
+            argv: ["mizen", "--version"],
+            benefit: "Report it with your version",
+        },
+        rows: [["Cause", message]],
+    });
+}
+/** The human error block, for stderr. */
+export function formatError(style, failure) {
+    const { next, rows = [] } = failure.detail;
+    return [
+        status(style, "fail", failure.message),
+        ...rows.map(([label, value]) => row(label, value)),
+        ...(next
+            ? ["", nextStep(style, next.benefit, commandLine(next.argv))]
+            : []),
+    ].join("\n");
+}
+/** The machine error document: one line on stderr. */
+export function errorDocument(failure) {
+    const { data, next } = failure.detail;
+    return {
+        error: {
+            ...(data ? { data } : {}),
+            message: failure.message,
+            ...(next
+                ? { next: [{ argv: next.argv, command: commandLine(next.argv) }] }
+                : {}),
+            reason: failure.reason,
+        },
+        schemaVersion: 1,
+    };
+}

package/dist/help.js

@@ -0,0 +1,192 @@
+import { CliError, invalidUsage } from "./errors.js";
+export const argumentOptions = {
+    cwd: { type: "string" },
+    "dry-run": { type: "boolean" },
+    feature: { multiple: true, type: "string" },
+    help: { short: "h", type: "boolean" },
+    json: { type: "boolean" },
+    "no-color": { type: "boolean" },
+    package: { type: "string" },
+    "package-manager": { type: "string" },
+    strict: { type: "boolean" },
+    version: { short: "v", type: "boolean" },
+    workspace: { type: "boolean" },
+    yes: { type: "boolean" },
+};
+const optionHelp = {
+    cwd: ["--cwd <DIR>", "Select the app directory (default: current directory)"],
+    "dry-run": [
+        "--dry-run",
+        "Print the plan without applying it, even with --yes",
+    ],
+    feature: [
+        "--feature <FEATURE>",
+        "Add an optional feature, repeatable. Accepts: diagram",
+    ],
+    help: ["-h, --help", "Show help"],
+    json: ["--json", "Print one JSON document (schema version 1)"],
+    "no-color": ["--no-color", "Turn off color"],
+    package: [
+        "--package <FILE>",
+        "Install @mizen-labs/ui from a local .tgz archive",
+    ],
+    "package-manager": [
+        "--package-manager <NAME>",
+        "Use npm or pnpm when the app declares neither",
+    ],
+    strict: ["--strict", "Fail when any check is unverified"],
+    version: ["-v, --version", "Show the version"],
+    workspace: ["--workspace", "Check every app in the nearest workspace"],
+    yes: ["--yes", "Apply the plan. Conflicts still stop init"],
+};
+const globals = ["help", "json", "no-color", "version"];
+const commands = {
+    doctor: {
+        examples: [
+            "mizen doctor --cwd ./apps/web",
+            "mizen doctor --workspace --strict",
+        ],
+        group: "Setup",
+        notes: [
+            "Checks Next.js App Router, TanStack Start, and React + Vite apps.",
+            "With --workspace, --cwd selects where to look for the workspace root.",
+            "Linked, external, and ambiguous packages stay unverified.",
+            "Exits 1 when a check fails, or with --strict when one is unverified.",
+        ],
+        options: ["cwd", "strict", "workspace"],
+        summary: "Check an app's Mizen setup without changing files",
+        usage: "mizen doctor [options]",
+    },
+    info: {
+        examples: ["mizen info button", "mizen info button --json"],
+        group: "Components",
+        notes: [
+            "Accepts a component slug or name.",
+            "Describes the bundled catalog, which may differ from your installed version.",
+            "Works offline and never reads your project.",
+        ],
+        options: [],
+        summary: "Show a component's API, imports, guidance, and examples",
+        usage: "mizen info <COMPONENT> [options]",
+    },
+    init: {
+        examples: [
+            "mizen init --cwd ./apps/web",
+            "mizen init --cwd ./apps/web --yes",
+            "mizen init --cwd ./apps/web --package ./mizen-ui-0.1.0.tgz --yes",
+        ],
+        group: "Setup",
+        notes: [
+            "Prints a plan by default. Only --yes applies it, and --dry-run always wins.",
+            "Supports Next.js App Router, TanStack Start, and React + Vite apps.",
+            "The package manager must match the app's declaration and lockfile.",
+            "Installs skip lifecycle scripts.",
+            "Until @mizen-labs/ui is published, pass a matching local archive with --package.",
+            "--yes never overwrites a conflict. If init stops midway,",
+            ".mizen-init-journal.json records each edit. Restore or finish them,",
+            "then remove the journal.",
+            "Exits 1 on a conflict, or when an install or check fails.",
+        ],
+        options: ["cwd", "dry-run", "feature", "package", "package-manager", "yes"],
+        summary: "Plan or apply Mizen setup in an app",
+        usage: "mizen init [options]",
+    },
+    search: {
+        examples: ["mizen search dialog", "mizen search keyboard navigation"],
+        group: "Components",
+        notes: [
+            "Matches every query word, ignoring case. With no query, lists every component.",
+            "Works offline and never reads your project.",
+        ],
+        options: [],
+        summary: "Find components in the bundled catalog",
+        usage: "mizen search [QUERY] [options]",
+    },
+};
+export function isCommand(value) {
+    return value !== undefined && Object.hasOwn(commands, value);
+}
+// Edit distance, for one close suggestion on a mistyped command.
+function distance(a, b) {
+    let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+    for (const [i, letter] of [...a].entries()) {
+        const current = [i + 1];
+        for (const [j, other] of [...b].entries()) {
+            const substitution = (previous[j] ?? 0) + (letter === other ? 0 : 1);
+            current.push(Math.min((previous[j + 1] ?? 0) + 1, (current[j] ?? 0) + 1, substitution));
+        }
+        previous = current;
+    }
+    return previous[b.length] ?? 0;
+}
+/** The one known name within two edits of the input, if any. */
+export function closest(input, names) {
+    const ranked = names
+        .map((name) => ({ name, score: distance(input, name) }))
+        .filter((item) => item.score <= 2)
+        .toSorted((a, b) => a.score - b.score);
+    return ranked[0]?.name;
+}
+export function unknownCommand(command) {
+    const suggestion = closest(command, Object.keys(commands));
+    throw new CliError("unknown_command", `Unknown command ${command} for mizen.${suggestion ? ` Did you mean ${suggestion}?` : ""}`, 2, {
+        next: {
+            argv: suggestion
+                ? ["mizen", suggestion, "--help"]
+                : ["mizen", "--help"],
+            benefit: suggestion ? `See ${suggestion} usage` : "See usage",
+        },
+    });
+}
+const sorted = (options) => options.toSorted((a, b) => a.localeCompare(b));
+function optionRows(options) {
+    const width = Math.max(...options.map((name) => optionHelp[name][0].length)) + 3;
+    return sorted(options).map((name) => {
+        const [label, description] = optionHelp[name];
+        return `  ${label.padEnd(width)}${description}`;
+    });
+}
+function section(style, title, lines) {
+    return lines.length ? ["", style.heading(`${title}:`), ...lines] : [];
+}
+function examples(style, list) {
+    return section(style, "Examples", list.map((command) => `    ${style.command(command)}`));
+}
+function rootHelp(style) {
+    const groups = ["Components", "Setup"];
+    return [
+        style.bold("mizen <COMMAND> [options]"),
+        "Find Mizen components and set up apps that use them",
+        ...groups.flatMap((group) => section(style, group, Object.entries(commands)
+            .filter(([, item]) => item.group === group)
+            .map(([name, item]) => `  ${style.bold(name.padEnd(10))}${item.summary}`))),
+        ...section(style, "Global Options", optionRows(globals)),
+        ...examples(style, ["mizen search dialog", "mizen init --cwd ./apps/web"]),
+    ].join("\n");
+}
+/** Help for the root, or for one command. Help never reads the project. */
+export function help(style, command) {
+    if (!command) {
+        return rootHelp(style);
+    }
+    if (!isCommand(command)) {
+        return unknownCommand(command);
+    }
+    const entry = commands[command];
+    return [
+        style.bold(entry.usage),
+        entry.summary,
+        ...section(style, "Options", entry.options.length ? optionRows(entry.options) : []),
+        "",
+        `${style.heading("Global Options:")} See mizen --help`,
+        ...examples(style, entry.examples),
+        ...section(style, "Notes", entry.notes.map((line) => `  ${line}`)),
+    ].join("\n");
+}
+export function validateOptions(command, values) {
+    const allowed = new Set([...commands[command].options, ...globals]);
+    const invalid = Object.entries(values).find(([option, value]) => value !== undefined && !allowed.has(option))?.[0];
+    if (invalid) {
+        invalidUsage(`Unknown option --${invalid} for mizen ${command}.`, command, "unknown_option");
+    }
+}

package/dist/init/config.js

@@ -0,0 +1,75 @@
+import { isNode, nameOf, parseSource, property, staticArrayContains, staticConfig, } from "../doctor/syntax.js";
+import { addProperty, changes, conflict, fileEdit, position, sourceFile, } from "./edit.js";
+function literalObject(value) {
+    if (!isNode(value) ||
+        value.type !== "ObjectExpression" ||
+        !Array.isArray(value.properties)) {
+        return false;
+    }
+    return value.properties.every((item) => isNode(item) &&
+        !item.computed &&
+        ["ObjectProperty", "ObjectMethod"].includes(item.type));
+}
+export function member(object, key) {
+    if (!literalObject(object)) {
+        return conflict("Computed keys or spreads can override configuration. Configure Mizen manually before init.");
+    }
+    const matches = object.properties.filter((item) => nameOf(item.key) === key);
+    if (matches.length > 1) {
+        return conflict(`Duplicate ${key} configuration requires manual review.`);
+    }
+    return matches.length === 1;
+}
+function arrayChange(value) {
+    const present = staticArrayContains(value, "@mizen-labs/ui");
+    if (present === null) {
+        return conflict("The bundling setting is not a literal string array. Configure Mizen manually.");
+    }
+    if (present) {
+        return null;
+    }
+    const at = position(value, "start") + 1;
+    const node = value;
+    const comma = node.elements.length ? ", " : "";
+    return { end: at, start: at, text: `"@mizen-labs/ui"${comma}` };
+}
+function bundlingChange(_source, config, framework) {
+    if (framework === "next") {
+        if (!member(config, "transpilePackages")) {
+            return addProperty(config, "transpilePackages", '["@mizen-labs/ui"]');
+        }
+        return arrayChange(property(config, "transpilePackages"));
+    }
+    if (!member(config, "ssr")) {
+        return addProperty(config, "ssr", '{ noExternal: ["@mizen-labs/ui"] }');
+    }
+    const ssr = property(config, "ssr");
+    if (!literalObject(ssr)) {
+        return conflict("Computed ssr configuration needs manual setup.");
+    }
+    if (!member(ssr, "noExternal")) {
+        return addProperty(ssr, "noExternal", '["@mizen-labs/ui"]');
+    }
+    const external = property(ssr, "noExternal");
+    if (isNode(external) &&
+        external.type === "BooleanLiteral" &&
+        external.value === true) {
+        return null;
+    }
+    return arrayChange(external);
+}
+export async function configEdit(project, framework) {
+    if (framework === "vite") {
+        return null;
+    }
+    const prefix = framework === "next" ? "next.config" : "vite.config";
+    const template = framework === "next" ? "export default {};\n" : undefined;
+    const file = await sourceFile(project, ["mjs", "js", "ts", "mts", "cjs", "cts"].map((extension) => `${prefix}.${extension}`), template);
+    const config = staticConfig(parseSource(file.source));
+    if (!config) {
+        return conflict(`${file.path} has a wrapped or computed export. Configure Mizen bundling manually before init.`);
+    }
+    const edit = bundlingChange(file.source, config, framework);
+    const after = edit ? changes(file.source, [edit]) : file.source;
+    return fileEdit(file.path, file.before, after);
+}

package/dist/init/dependencies.js

@@ -0,0 +1,130 @@
+import semver from "semver";
+import { installedFrom, versionCheck, } from "../doctor/packages.js";
+import { frameworkOf, packageManagerCheck } from "../doctor/project.js";
+import { diagnosticDetail } from "../doctor/report.js";
+import { supportsInitialization } from "../vite/render.js";
+import { conflict } from "./edit.js";
+import { releaseArchive } from "./release.js";
+export async function managerFor(project, explicit) {
+    const diagnostic = await packageManagerCheck(project);
+    const lockfiles = diagnostic.evidence.filter((path) => !path.endsWith("package.json"));
+    if (diagnostic.status !== "pass" && lockfiles.length) {
+        return conflict("The package-manager declaration and lockfiles disagree.", diagnosticDetail(diagnostic));
+    }
+    const detected = diagnostic.packageManager;
+    if (!detected && diagnostic.evidence.length) {
+        return conflict("The package-manager declaration needs review.", diagnosticDetail(diagnostic));
+    }
+    const command = selectedManager(explicit, detected);
+    return { command, needsLockfile: !lockfiles.length };
+}
+async function compatiblePeers(project, manifest) {
+    const checks = await Promise.all(["react", "react-dom"].map(async (name) => {
+        const installed = await installedFrom(project, name);
+        if (!installed) {
+            return conflict(`Install ${name} in this app before init.`);
+        }
+        const check = versionCheck(name, installed.manifest.version, manifest.peerDependencies?.[name], [installed.path]);
+        if (check.status !== "pass") {
+            return conflict(`${name}: ${check.message} Resolve compatibility before init.`);
+        }
+        return installed.manifest.version;
+    }));
+    if (checks[0] !== checks[1]) {
+        conflict("React and ReactDOM versions must match before init.");
+    }
+}
+async function optionalPackages(project, manifest, ui, features) {
+    if (features.some((feature) => feature !== "diagram")) {
+        return conflict("The supported optional feature is diagram.");
+    }
+    if (!features.includes("diagram")) {
+        return [];
+    }
+    const range = ui.peerDependencies?.pele;
+    if (!(range && semver.validRange(range))) {
+        return conflict("This Mizen archive has no valid Pele peer range.");
+    }
+    const pele = await installedFrom(project, "pele");
+    validatePele(pele, range);
+    const declared = { ...manifest.dependencies, ...manifest.devDependencies }
+        .pele;
+    return pele && declared ? [] : [`pele@${range}`];
+}
+function installCommand(command, packages, archive) {
+    const args = command === "npm"
+        ? [
+            "install",
+            "--ignore-scripts",
+            "--no-audit",
+            "--no-fund",
+            "--save-exact",
+            "--include=dev",
+            ...packages,
+        ]
+        : [
+            packages.length ? "add" : "install",
+            "--ignore-scripts",
+            "--prod=false",
+            ...packages,
+        ];
+    return {
+        archive: archive ? { path: archive.path, sha256: archive.sha256 } : null,
+        args,
+        command,
+        packages,
+    };
+}
+async function selectedRelease(project, version, specifier) {
+    const archive = specifier ? await releaseArchive(specifier, version) : null;
+    const installed = await installedFrom(project, "@mizen-labs/ui");
+    const ui = archive?.manifest ?? installed?.manifest;
+    if (!ui || ui.version !== version) {
+        return conflict(`Mizen is unpublished. Pass --package /path/to/mizen-ui.tgz for @mizen-labs/ui ${version}.`);
+    }
+    await compatiblePeers(project, ui);
+    return { archive, installed, ui };
+}
+function mizenPackage(manifest, release, version) {
+    const declared = { ...manifest.dependencies, ...manifest.devDependencies }["@mizen-labs/ui"];
+    if (release.installed &&
+        declared &&
+        release.installed.manifest.version === version &&
+        (frameworkOf(manifest) !== "vite" ||
+            supportsInitialization(release.installed.manifest))) {
+        return [];
+    }
+    if (!release.archive) {
+        return conflict("Declare Mizen in the target app with --package /path/to/mizen-ui.tgz.");
+    }
+    return [release.archive.path];
+}
+export async function installation(project, manifest, version, specifier, features, manager) {
+    const release = await selectedRelease(project, version, specifier);
+    if (frameworkOf(manifest) === "vite" && !supportsInitialization(release.ui)) {
+        return conflict("This UI build lacks synchronous client theme initialization. Rebuild and pack @mizen-labs/ui before running Vite init.");
+    }
+    const packages = [
+        ...mizenPackage(manifest, release, version),
+        ...(await optionalPackages(project, manifest, release.ui, features)),
+    ];
+    if (!(packages.length || manager.needsLockfile)) {
+        return null;
+    }
+    return installCommand(manager.command, packages, release.archive);
+}
+function selectedManager(explicit, detected) {
+    if (explicit && detected && explicit !== detected) {
+        return conflict("The requested package manager conflicts with the project's lockfile or declaration.");
+    }
+    const selected = explicit ?? detected;
+    if (selected !== "npm" && selected !== "pnpm") {
+        return conflict("Init currently supports verified npm and pnpm writes. Select --package-manager npm or pnpm for an app without a lockfile, or configure this app manually.");
+    }
+    return selected;
+}
+function validatePele(pele, range) {
+    if (pele && !semver.satisfies(pele.manifest.version ?? "", range)) {
+        conflict("Resolve the existing Pele peer version before enabling diagrams.");
+    }
+}