@mizen-labs/cli 0.0.0-stage → 0.1.0

package/dist/cli.js

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises";
+import { parseArgs } from "node:util";
+import { formatInfo, formatSearch, info, search } from "./discover.js";
+import { CliError, commandLine, errorDocument, formatError, invalidUsage, normalizeError, } from "./errors.js";
+import { argumentOptions, help, isCommand, unknownCommand, validateOptions, } from "./help.js";
+import { nextStep, styleFor, unstyled } from "./output.js";
+// --no-color applies before any stream decides its styling.
+if (process.argv.includes("--no-color")) {
+    process.env.NO_COLOR = "1";
+}
+const out = styleFor(process.stdout);
+const err = styleFor(process.stderr);
+function runSearch(catalog, query) {
+    const components = search(catalog.components, query);
+    const data = { components, query, uiVersion: catalog.uiVersion };
+    if (components.length) {
+        return {
+            command: "search",
+            data,
+            text: formatSearch(out, components, process.stdout),
+        };
+    }
+    return {
+        command: "search",
+        data,
+        note: [
+            `No components match "${query}".`,
+            "",
+            nextStep(err, "List every component", "mizen search"),
+        ].join("\n"),
+        // A pipe still gets the table header, so a parser sees the columns.
+        text: process.stdout.isTTY ? "" : "Component\tDescription",
+    };
+}
+function runInfo(catalog, query) {
+    if (!query.trim()) {
+        throw new CliError("missing_name", "Can't show a component without its name.", 2, {
+            next: { argv: ["mizen", "search"], benefit: "Find a component" },
+        });
+    }
+    const component = info(catalog.components, query);
+    return {
+        command: "info",
+        data: { component, uiVersion: catalog.uiVersion },
+        text: formatInfo(out, component),
+    };
+}
+async function runDoctor(catalog, values) {
+    const cwd = values.cwd ?? process.cwd();
+    const { doctor } = await import("./doctor/doctor.js");
+    const { formatReport } = await import("./doctor/report.js");
+    const { formatWorkspace, workspaceDoctor } = await import("./doctor/workspace.js");
+    const failed = (summary) => summary.errors > 0 || Boolean(values.strict && summary.unverified);
+    if (values.workspace) {
+        const data = await workspaceDoctor(cwd, catalog.nodeRange);
+        const text = formatWorkspace(out, data);
+        return {
+            command: "doctor",
+            data,
+            exitCode: failed(data.summary) ? 1 : 0,
+            text,
+        };
+    }
+    const data = await doctor(cwd, catalog.nodeRange);
+    const text = formatReport(out, data);
+    return {
+        command: "doctor",
+        data,
+        exitCode: failed(data.summary) ? 1 : 0,
+        text,
+    };
+}
+// What to run after init: apply a plan, or check the app after a failure.
+function initNext(values, project, state) {
+    if (state === "planned") {
+        const argv = [
+            "mizen",
+            "init",
+            "--cwd",
+            project,
+            ...(values.package ? ["--package", values.package] : []),
+            ...(values["package-manager"]
+                ? ["--package-manager", values["package-manager"]]
+                : []),
+            ...(values.feature ?? []).flatMap((feature) => ["--feature", feature]),
+            "--yes",
+        ];
+        return { argv, benefit: "Apply the plan" };
+    }
+    if (state === "install-failed" || state === "verification-failed") {
+        return {
+            argv: ["mizen", "doctor", "--cwd", project],
+            benefit: "See what needs attention",
+        };
+    }
+    return null;
+}
+async function runInit(catalog, values) {
+    const { formatInit, init } = await import("./init/init.js");
+    const data = await init({
+        cwd: values.cwd,
+        dryRun: values["dry-run"],
+        feature: values.feature,
+        package: values.package,
+        packageManager: values["package-manager"],
+        yes: values.yes,
+    }, catalog);
+    const next = initNext(values, data.plan.project, data.status);
+    return {
+        command: "init",
+        data,
+        exitCode: ["install-failed", "verification-failed"].includes(data.status)
+            ? 1
+            : 0,
+        text: formatInit(out, data),
+        ...(next
+            ? { note: nextStep(err, next.benefit, commandLine(next.argv)) }
+            : {}),
+    };
+}
+function dispatch(catalog, positionals, values) {
+    const [command, ...args] = positionals;
+    if (!isCommand(command)) {
+        return unknownCommand(command ?? "");
+    }
+    validateOptions(command, values);
+    if ((command === "init" || command === "doctor") && args.length) {
+        invalidUsage(`Can't use arguments with mizen ${command}. Select the app with --cwd.`, command);
+    }
+    if (command === "init") {
+        return runInit(catalog, values);
+    }
+    if (command === "doctor") {
+        return runDoctor(catalog, values);
+    }
+    return command === "search"
+        ? runSearch(catalog, args.join(" "))
+        : runInfo(catalog, args.join(" "));
+}
+function json(value, stream) {
+    return JSON.stringify(value, null, stream.isTTY ? 2 : undefined);
+}
+function write(asJson, result) {
+    if (asJson) {
+        const document = {
+            command: result.command,
+            data: result.data,
+            schemaVersion: 1,
+        };
+        process.stdout.write(`${json(document, process.stdout)}\n`);
+    }
+    else {
+        if (result.text) {
+            process.stdout.write(`${result.text}\n`);
+        }
+        if (result.note) {
+            process.stderr.write(`${result.text ? "\n" : ""}${result.note}\n`);
+        }
+    }
+    process.exitCode = result.exitCode ?? 0;
+}
+async function version() {
+    const manifest = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
+    return manifest.version;
+}
+// `mizen help [command]` and `--help` at any depth print the same help;
+// bare `mizen` prints it too, unless it asks for the version.
+function helpTopic(positionals, values) {
+    if (positionals[0] === "help") {
+        return { topic: positionals[1] };
+    }
+    const bare = positionals.length === 0 && !values.version;
+    return values.help || bare ? { topic: positionals[0] } : null;
+}
+async function main() {
+    const { values, positionals } = parseArgs({
+        allowPositionals: true,
+        options: argumentOptions,
+    });
+    const asked = helpTopic(positionals, values);
+    if (asked) {
+        const text = help(out, asked.topic);
+        const usage = values.json ? help(unstyled, asked.topic) : text;
+        write(values.json, { command: "help", data: { usage }, text });
+        return;
+    }
+    if (values.version) {
+        const current = await version();
+        write(values.json, {
+            command: "version",
+            data: { version: current },
+            text: current,
+        });
+        return;
+    }
+    const catalog = JSON.parse(await readFile(new URL("./catalog.json", import.meta.url), "utf8"));
+    write(values.json, await dispatch(catalog, positionals, values));
+}
+function requestedJson(args) {
+    const terminator = args.indexOf("--");
+    return (terminator < 0 ? args : args.slice(0, terminator)).includes("--json");
+}
+main().catch((error) => {
+    const args = process.argv.slice(2);
+    const failure = normalizeError(error, isCommand(args[0]) ? args[0] : undefined);
+    const text = requestedJson(args)
+        ? JSON.stringify(errorDocument(failure))
+        : formatError(err, failure);
+    process.stderr.write(`${text}\n`);
+    process.exitCode = failure.exitCode;
+});

package/dist/discover.js

@@ -0,0 +1,108 @@
+import { CliError } from "./errors.js";
+import { closest } from "./help.js";
+import { indent, row } from "./output.js";
+function normalize(value) {
+    return value.toLowerCase().trim().replaceAll(/\s+/gu, " ");
+}
+/** Components matching every query word, in slug order. */
+export function search(components, query) {
+    const words = normalize(query).split(" ").filter(Boolean);
+    return components
+        .filter((component) => {
+        const text = normalize([
+            component.slug,
+            component.name,
+            component.category,
+            component.description,
+            ...component.guidance.recommendations,
+            ...component.guidance.boundaries,
+        ].join(" "));
+        return words.every((word) => text.includes(word));
+    })
+        .toSorted((a, b) => a.slug.localeCompare(b.slug, "en"))
+        .map(({ slug, name, category, description, status, entryPoint }) => ({
+        category,
+        description,
+        entryPoint,
+        name,
+        slug,
+        status,
+    }));
+}
+/** One component by slug or name; a near miss gets one suggestion. */
+export function info(components, query) {
+    const slug = normalize(query).replaceAll(" ", "-");
+    const component = components.find((item) => item.slug === slug);
+    if (component) {
+        return component;
+    }
+    const suggestion = closest(slug, components.map((item) => item.slug));
+    throw new CliError("not_found", `Couldn't find component ${query}.${suggestion ? ` Did you mean ${suggestion}?` : ""}`, 1, {
+        ...(suggestion ? { data: { suggestion } } : {}),
+        next: suggestion
+            ? { argv: ["mizen", "info", suggestion], benefit: "Show it" }
+            : { argv: ["mizen", "search", query], benefit: "Search for it" },
+    });
+}
+function fit(text, width) {
+    return text.length > width
+        ? `${text.slice(0, Math.max(width - 1, 0))}…`
+        : text;
+}
+/**
+ * A table on a terminal, the description shortened to fit; tab-separated
+ * values, never shortened, anywhere else.
+ */
+export function formatSearch(style, results, stream) {
+    if (!stream.isTTY) {
+        return [
+            "Component\tDescription",
+            ...results.map((item) => `${item.slug}\t${item.description}`),
+        ].join("\n");
+    }
+    const width = Math.max(...results.map((item) => item.slug.length), 9) + 3;
+    const room = (stream.columns || 80) - width - 2;
+    return [
+        `  ${style.bold(`${"Component".padEnd(width)}Description`)}`,
+        ...results.map((item) => `  ${item.slug.padEnd(width)}${fit(item.description, room)}`),
+    ].join("\n");
+}
+function propertyRow(property) {
+    const fallback = property.defaultValue.replaceAll("—", "").trim();
+    return row(property.name, [
+        property.type,
+        `${property.description}${fallback ? ` (default: ${fallback})` : ""}`,
+    ]);
+}
+function heading(style, title, lines) {
+    return lines.length ? ["", style.bold(title), ...lines] : [];
+}
+export function formatInfo(style, component) {
+    const examples = (component.usageSections ?? []).flatMap((section) => [
+        "",
+        style.bold(section.title),
+        ...(section.description ? [indent(section.description)] : []),
+        indent(section.code, 2),
+    ]);
+    return [
+        style.bold(component.name),
+        component.description,
+        "",
+        row("Category", component.category),
+        row("Import", component.entryPoint),
+        row("Docs", component.documentationPath),
+        ...heading(style, "Guidance", component.guidance.recommendations.map((line) => indent(line))),
+        ...heading(style, "Boundaries", component.guidance.boundaries.map((line) => indent(line))),
+        ...heading(style, "API", component.api.map(propertyRow)),
+        ...(component.apiSections ?? []).flatMap((section) => heading(style, section.name, [
+            indent(section.description),
+            ...section.properties.map(propertyRow),
+        ])),
+        ...(component.contract
+            ? heading(style, "Contract", [
+                indent(JSON.stringify(component.contract, null, 2)),
+            ])
+            : []),
+        ...examples,
+    ].join("\n");
+}

package/dist/doctor/doctor.js

@@ -0,0 +1,44 @@
+import { resolve } from "node:path";
+import { InvalidManifestError } from "./files.js";
+import { frameworkVersionCheck, PackageResolutionError, packageChecks, versionCheck, } from "./packages.js";
+import { frameworkOf, packageManagerCheck, targetProject } from "./project.js";
+import { check, report } from "./report.js";
+import { setupChecks } from "./setup.js";
+export async function doctor(cwd, nodeRange, options = {}) {
+    try {
+        return await inspectProject(cwd, nodeRange, options);
+    }
+    catch (error) {
+        if (error instanceof PackageResolutionError) {
+            return report(resolve(cwd), [
+                check("package.metadata", "error", error.message, [error.directory], "Repair the installed package metadata or reinstall dependencies, then rerun doctor."),
+            ]);
+        }
+        if (!(error instanceof InvalidManifestError)) {
+            throw error;
+        }
+        return report(resolve(cwd), [
+            check("package.metadata", "error", "An installed or workspace package manifest is invalid.", [error.path], "Repair the named manifest or reinstall dependencies, then rerun doctor."),
+        ]);
+    }
+}
+async function inspectProject(cwd, nodeRange, options) {
+    const target = await targetProject(resolve(cwd), options);
+    if (!(target.manifest && target.project)) {
+        return report(target.project, target.diagnostic ? [target.diagnostic] : []);
+    }
+    const { project, manifest } = target;
+    const framework = frameworkOf(manifest);
+    const { diagnostics, ui } = await packageChecks(project);
+    diagnostics.unshift(versionCheck("runtime.node", process.versions.node, nodeRange, []));
+    diagnostics.push(await packageManagerCheck(project));
+    diagnostics.push(check("project.framework", framework === "unknown" ? "unverified" : "pass", `Framework: ${framework}.`, [project], "Setup checks target Next.js App Router, TanStack Start, and React + Vite. Select the application package when using a workspace."));
+    if (framework !== "unknown") {
+        diagnostics.push(await frameworkVersionCheck(project, framework), ...(await setupChecks(project, framework)));
+    }
+    return {
+        ...report(project, diagnostics),
+        framework,
+        uiVersion: ui?.manifest.version ?? null,
+    };
+}

package/dist/doctor/files.js

@@ -0,0 +1,77 @@
+import { readFile, stat } from "node:fs/promises";
+import { dirname, join } from "node:path";
+export class InvalidManifestError extends Error {
+    path;
+    constructor(path, options) {
+        super(`Invalid package manifest: ${path}`, options);
+        this.path = path;
+    }
+}
+function isMissing(error) {
+    return (error instanceof Error &&
+        "code" in error &&
+        ["ENOENT", "ENOTDIR"].includes(String(error.code)));
+}
+export async function exists(path) {
+    try {
+        return (await stat(path)).isFile();
+    }
+    catch (error) {
+        if (isMissing(error)) {
+            return false;
+        }
+        throw error;
+    }
+}
+export async function readOptional(path) {
+    try {
+        return await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (isMissing(error)) {
+            return null;
+        }
+        throw error;
+    }
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function validManifest(value) {
+    const maps = [
+        value.dependencies,
+        value.devDependencies,
+        value.peerDependencies,
+    ];
+    const strings = [value.name, value.version, value.packageManager];
+    return (maps.every((map) => map === undefined ||
+        (isRecord(map) &&
+            Object.values(map).every((item) => typeof item === "string"))) && strings.every((item) => item === undefined || typeof item === "string"));
+}
+export async function manifestAt(path) {
+    const source = await readOptional(path);
+    if (source === null) {
+        return null;
+    }
+    return parseManifest(source, path);
+}
+export function parseManifest(source, path) {
+    let value;
+    try {
+        value = JSON.parse(source);
+    }
+    catch (error) {
+        throw new InvalidManifestError(path, { cause: error });
+    }
+    if (!(isRecord(value) && validManifest(value))) {
+        throw new InvalidManifestError(path);
+    }
+    return value;
+}
+export async function findProject(directory) {
+    if (await exists(join(directory, "package.json"))) {
+        return directory;
+    }
+    const parent = dirname(directory);
+    return parent === directory ? null : findProject(parent);
+}

package/dist/doctor/packages.js

@@ -0,0 +1,114 @@
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import semver from "semver";
+import { manifestAt } from "./files.js";
+import { check } from "./report.js";
+export class PackageResolutionError extends Error {
+    directory;
+    constructor(message, options) {
+        super(message, options);
+        this.directory = options.directory;
+    }
+}
+async function findPackage(directory, name) {
+    const path = join(directory, "package.json");
+    const manifest = await manifestAt(path);
+    if (manifest?.name === name) {
+        return { manifest, path };
+    }
+    const parent = dirname(directory);
+    return parent === directory ? null : findPackage(parent, name);
+}
+export async function installedFrom(directory, name) {
+    const { resolve } = createRequire(join(directory, "package.json"));
+    try {
+        const path = resolve(`${name}/package.json`);
+        const manifest = await manifestAt(path);
+        return manifest ? { manifest, path } : null;
+    }
+    catch (error) {
+        if (!(error instanceof Error && "code" in error)) {
+            throw error;
+        }
+        if (error.code === "ERR_INVALID_PACKAGE_CONFIG") {
+            throw new PackageResolutionError(`Node could not read package metadata while resolving ${name}.`, { cause: error, directory });
+        }
+        if (error.code === "MODULE_NOT_FOUND") {
+            return null;
+        }
+        if (error.code !== "ERR_PACKAGE_PATH_NOT_EXPORTED") {
+            throw error;
+        }
+    }
+    return findPackage(dirname(resolve(name)), name);
+}
+export function versionCheck(id, version, range, evidence) {
+    if (typeof version !== "string" ||
+        typeof range !== "string" ||
+        !semver.valid(version) ||
+        !semver.validRange(range)) {
+        return check(id, "unverified", "No valid version or compatibility range is available.", evidence, "Check the installed package metadata.");
+    }
+    return check(id, semver.satisfies(version, range) ? "pass" : "error", `Installed ${version}; required ${range}.`, evidence, `Use a version satisfying ${range}.`);
+}
+async function peerChecks(project, ui, name) {
+    const [host, library] = await Promise.all([
+        installedFrom(project, name),
+        installedFrom(dirname(ui.path), name),
+    ]);
+    if (!host) {
+        return [
+            check(`package.${name}`, "error", `${name} cannot be resolved from this app.`, [], `Install ${name} using the Mizen peer range.`),
+        ];
+    }
+    const same = host.path === library?.path;
+    return [
+        versionCheck(`package.${name}`, host.manifest.version, ui.manifest.peerDependencies?.[name], [host.path, ui.path]),
+        check(`identity.${name}`, same ? "pass" : "error", `${name} ${same ? "shares" : "does not share"} the app's module identity.`, [host.path, ...(library ? [library.path] : [])], "Align workspace dependencies and deduplicate React; do not bundle a separate React copy in Mizen."),
+    ];
+}
+export async function packageChecks(project) {
+    const ui = await installedFrom(project, "@mizen-labs/ui");
+    if (!ui) {
+        return {
+            diagnostics: [
+                check("package.mizen", "error", "@mizen-labs/ui cannot be resolved from this app.", [join(project, "package.json")], "Install Mizen in the target app, then rerun doctor."),
+            ],
+            ui: null,
+        };
+    }
+    const peers = await Promise.all(["react", "react-dom"].map((name) => peerChecks(project, ui, name)));
+    return {
+        diagnostics: [
+            check("package.mizen", "pass", `Resolved @mizen-labs/ui ${ui.manifest.version ?? "(unknown version)"}.`, [ui.path]),
+            ...peers.flat(),
+            ...(await reactPairCheck(project)),
+        ],
+        ui,
+    };
+}
+export async function frameworkVersionCheck(project, framework) {
+    const name = { next: "next", start: "@tanstack/react-start", vite: "vite" }[framework];
+    const installed = await installedFrom(project, name);
+    if (!installed) {
+        return check("project.framework-version", "error", `${name} is declared but cannot be resolved.`, [], "Install the app's framework dependencies.");
+    }
+    return check("project.framework-version", "pass", `Resolved ${name} ${installed.manifest.version ?? "(unknown version)"}. No broader framework compatibility range is claimed.`, [installed.path]);
+}
+async function reactPairCheck(project) {
+    const [react, dom] = await Promise.all([
+        installedFrom(project, "react"),
+        installedFrom(project, "react-dom"),
+    ]);
+    if (!(react && dom)) {
+        return [];
+    }
+    const versions = [react.manifest.version, dom.manifest.version];
+    if (!versions.every((version) => typeof version === "string" && semver.valid(version))) {
+        return [];
+    }
+    const same = versions[0] === versions[1];
+    return [
+        check("package.react-pair", same ? "pass" : "error", `React ${versions[0]} and ReactDOM ${versions[1]} ${same ? "match" : "differ"}.`, [react.path, dom.path], "Install matching React and ReactDOM versions."),
+    ];
+}

package/dist/doctor/project.js

@@ -0,0 +1,133 @@
+import { stat } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { exists, findProject, manifestAt } from "./files.js";
+import { check } from "./report.js";
+import { hasPnpmWorkspacePackages, WorkspaceConfigError, } from "./workspace-config.js";
+const LOCKFILES = {
+    "bun.lock": "bun",
+    "bun.lockb": "bun",
+    "npm-shrinkwrap.json": "npm",
+    "package-lock.json": "npm",
+    "pnpm-lock.yaml": "pnpm",
+    "yarn.lock": "yarn",
+};
+export function frameworkOf(manifest) {
+    const dependencies = {
+        ...manifest.dependencies,
+        ...manifest.devDependencies,
+    };
+    const next = "next" in dependencies;
+    const start = "@tanstack/react-start" in dependencies;
+    if (next && start) {
+        return "unknown";
+    }
+    if (next) {
+        return "next";
+    }
+    if (start) {
+        return "start";
+    }
+    if (["astro", "@react-router/dev", "@sveltejs/kit"].some((name) => name in dependencies)) {
+        return "unknown";
+    }
+    return "vite" in dependencies && "react" in dependencies ? "vite" : "unknown";
+}
+const MANAGER = /^(?<manager>npm|pnpm|yarn|bun)@/u;
+async function managerMetadata(directory) {
+    const path = join(directory, "package.json");
+    const manifest = await manifestAt(path);
+    const field = manifest?.packageManager;
+    const manager = field?.match(MANAGER)?.[1];
+    const workspace = manifest?.workspaces ||
+        (await exists(join(directory, "pnpm-workspace.yaml")));
+    const diagnostic = field && !manager
+        ? check("project.package-manager", "unverified", "The declared package manager is not recognized.", [path], "Declare npm, pnpm, yarn, or bun with a version.")
+        : null;
+    return {
+        declaration: manager ? { manager, path } : undefined,
+        diagnostic,
+        workspace,
+    };
+}
+export async function packageManagerCheck(directory, declaration) {
+    const metadata = await managerMetadata(directory);
+    if (!declaration && metadata.diagnostic) {
+        return metadata.diagnostic;
+    }
+    const selected = declaration ?? metadata.declaration;
+    const files = await Promise.all(Object.keys(LOCKFILES).map(async (name) => (await exists(join(directory, name))) ? name : null));
+    const found = files.filter((item) => item !== null);
+    if (found.length) {
+        return lockfileCheck(directory, found, selected);
+    }
+    const parent = dirname(directory);
+    if (parent !== directory && !metadata.workspace) {
+        return packageManagerCheck(parent, selected);
+    }
+    return missingLockfile(selected);
+}
+function missingLockfile(declaration) {
+    return {
+        ...check("project.package-manager", "unverified", `No package-manager lockfile was found${declaration ? `; declared manager: ${declaration.manager}` : ""}.`, declaration ? [declaration.path] : [], "Install dependencies with your chosen package manager first."),
+        packageManager: declaration?.manager,
+    };
+}
+function lockfileCheck(directory, files, declaration) {
+    const managers = [...new Set(files.map((name) => LOCKFILES[name]))];
+    const matches = !declaration || managers[0] === declaration.manager;
+    const verified = managers.length === 1 && matches;
+    return {
+        ...check("project.package-manager", verified ? "pass" : "unverified", `Lockfiles indicate ${managers.join(", ")}${declaration ? `; declared manager: ${declaration.manager}` : ""}.`, [
+            ...files.map((name) => join(directory, name)),
+            ...(declaration ? [declaration.path] : []),
+        ], "Keep the intended package manager's lockfile and align the packageManager field before setup."),
+        packageManager: verified ? managers[0] : undefined,
+    };
+}
+export async function targetProject(requested, options = {}) {
+    try {
+        if (!(await stat(requested)).isDirectory()) {
+            throw new Error("Not a directory.");
+        }
+    }
+    catch {
+        return {
+            diagnostic: check("project.target", "error", "The target directory is unavailable.", [requested], "Use --cwd with an existing, readable app directory."),
+            project: null,
+        };
+    }
+    const project = await findProject(requested);
+    if (!project) {
+        return {
+            diagnostic: check("project.target", "error", "No package.json was found.", [requested], "Run the command in an app directory, or pass one with --cwd <APP_DIR>."),
+            project: null,
+        };
+    }
+    return inspectManifest(project, options.allowWorkspaceRoot);
+}
+async function inspectManifest(project, allowWorkspaceRoot = false) {
+    const path = join(project, "package.json");
+    try {
+        const manifest = await manifestAt(path);
+        if (!manifest) {
+            throw new Error("Missing manifest.");
+        }
+        if (!allowWorkspaceRoot &&
+            (manifest.workspaces || (await hasPnpmWorkspacePackages(project)))) {
+            return {
+                diagnostic: check("project.target", "error", "This directory is a workspace root; select an app explicitly.", [path], "Run mizen doctor --cwd <APP_DIR>."),
+                project,
+            };
+        }
+        return { manifest, project };
+    }
+    catch (error) {
+        if (error instanceof WorkspaceConfigError) {
+            return { diagnostic: error.diagnostic, project };
+        }
+        return {
+            diagnostic: check("project.manifest", "error", "The app package.json is invalid or unreadable.", [path], "Repair package.json, then rerun mizen doctor."),
+            project,
+        };
+    }
+}