@anvpx/motion-cli 0.0.0-stage → 0.1.0

package/dist/doctor/checks.js

@@ -0,0 +1,571 @@
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { SHARED_THEMES_DIR, TEMPLATES_DIR } from "@anvpx/motion-templates";
+import { EXIT } from "../exit-codes.js";
+import { hyperframesCliPath, hyperframesPackagePath } from "../tooling/session.js";
+import { PIN_KEYS } from "./pins.js";
+import { checkSkills } from "./skills.js";
+import { formatVersion, parseVersion } from "./version.js";
+const nodeRequire = createRequire(import.meta.url);
+const MIN_NODE_MAJOR = 22;
+const MIN_FFMPEG_MAJOR = 6;
+const WANTED_PYTHON = "3.12";
+const KOKORO_VERSION = "0.9.4";
+const SOUNDFILE_VERSION = "0.14.0";
+const FASTER_WHISPER_VERSION = "1.2.1";
+/** DL-01b voice bar: Kokoro is the local primary; failures are manual-hint-only. */
+export const VOICE_LOCAL_PRIMARY = "Kokoro local primary";
+export const VOICE_WAV_FALLBACK = "pre-rendered WAV fallback in pack";
+export const VOICE_MANUAL_SETUP = "manual setup only; no auto-install";
+export const VOICE_NO_PAID_BACKEND = "no paid backend";
+export const VOICE_ALIGNER = "aligner";
+const VENV_PYS = [".venv-voice/Scripts/python", ".venv-voice/bin/python"];
+const ESPEAK_RELEASES = "https://github.com/espeak-ng/espeak-ng/releases";
+const FFMPEG_VERSION = /version\s+n?(\d+)\.(\d+)(?:\.(\d+))?/;
+const CHROME_CACHE = [".cache", "hyperframes", "chrome", "chrome-headless-shell"];
+const PLATFORM_PREFIX = /^[a-z]+[a-z0-9-]*?-(?=\d+\.\d)/;
+/** The program is not on PATH (the runner reports every spawn failure as 127). */
+const absent = (result) => result.code === EXIT.MISSING_TOOL;
+function lines(text) {
+    return text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+}
+const found = (id, version, required = false) => ({
+    id,
+    status: "ok",
+    required,
+    version,
+});
+export const checkNode = async ({ host }) => {
+    const version = parseVersion(host.nodeVersion);
+    const base = { id: "node", required: true, version: host.nodeVersion };
+    if (!version)
+        return { ...base, status: "unknown", hint: "cannot parse the node version" };
+    if (version.major >= MIN_NODE_MAJOR)
+        return { ...base, status: "ok" };
+    return { ...base, status: "missing", hint: `install Node ${MIN_NODE_MAJOR}+ (24 recommended)` };
+};
+export const checkPnpm = async ({ run }) => {
+    const id = "pnpm";
+    const result = await run("pnpm", ["--version"]);
+    if (absent(result)) {
+        return { id, status: "missing", required: true, hint: "corepack enable pnpm" };
+    }
+    const version = result.code === 0 ? parseVersion(result.stdout) : undefined;
+    if (!version) {
+        return { id, status: "unknown", required: true, hint: "pnpm ran but gave no version" };
+    }
+    return found(id, formatVersion(version), true);
+};
+function mediaTool(id) {
+    return async ({ run }) => {
+        const result = await run(id, ["-version"]);
+        if (absent(result)) {
+            const hint = `install ffmpeg >= ${MIN_FFMPEG_MAJOR} and put it on PATH`;
+            return { id, status: "missing", required: true, hint };
+        }
+        const version = result.code === 0 ? parseVersion(result.stdout, FFMPEG_VERSION) : undefined;
+        if (!version) {
+            return { id, status: "unknown", required: true, hint: "unparsable version (git build?)" };
+        }
+        const text = formatVersion(version);
+        if (version.major >= MIN_FFMPEG_MAJOR)
+            return found(id, text, true);
+        const hint = `upgrade ffmpeg to >= ${MIN_FFMPEG_MAJOR}`;
+        return { id, status: "missing", required: true, version: text, hint };
+    };
+}
+export const checkFfmpeg = mediaTool("ffmpeg");
+export const checkFfprobe = mediaTool("ffprobe");
+/** Version from an installed package manifest; undefined when absent or unparsable. */
+async function packageVersion(host, path) {
+    try {
+        const value = JSON.parse(await host.readText(path)).version;
+        const parsed = typeof value === "string" ? parseVersion(value) : undefined;
+        return parsed ? formatVersion(parsed) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export const checkHyperframes = async ({ run, pins, host }) => {
+    const id = "hyperframes";
+    const pin = pins.hyperframes;
+    if (!pin) {
+        let manifest;
+        try {
+            manifest = hyperframesPackagePath();
+        }
+        catch {
+            return {
+                id,
+                status: "missing",
+                required: false,
+                hint: "cannot resolve hyperframes; reinstall @anvpx/motion (it ships hyperframes as a runtime dependency)",
+            };
+        }
+        const version = await packageVersion(host, manifest);
+        if (!version) {
+            return {
+                id,
+                status: "unknown",
+                required: false,
+                hint: "cannot read the installed hyperframes version; reinstall @anvpx/motion",
+            };
+        }
+        return found(id, version);
+    }
+    let cli;
+    try {
+        cli = hyperframesCliPath();
+    }
+    catch {
+        return {
+            id,
+            status: "missing",
+            required: false,
+            hint: `cannot resolve hyperframes@${pin}; reinstall @anvpx/motion (it ships hyperframes@${pin} as a runtime dependency)`,
+        };
+    }
+    const result = await run(process.execPath, [cli, "--version"]);
+    if (result.code !== 0) {
+        return {
+            id,
+            status: "missing",
+            required: false,
+            hint: `cannot run hyperframes@${pin} (node ${cli}); reinstall @anvpx/motion so it is installed alongside it`,
+        };
+    }
+    const installed = parseVersion(result.stdout);
+    if (!installed) {
+        return { id, status: "unknown", required: false, hint: "hyperframes gave no version" };
+    }
+    const version = formatVersion(installed);
+    if (version === pin)
+        return found(id, version);
+    const hint = `pinned ${pin}: install hyperframes@${pin} alongside @anvpx/motion (or update ${PIN_KEYS.hyperframes})`;
+    return { id, status: "usable", required: false, version, hint };
+};
+async function chromeVersions(ctx) {
+    try {
+        const entries = await ctx.host.listDir(join(ctx.host.homeDir, ...CHROME_CACHE));
+        return entries.map((entry) => entry.replace(PLATFORM_PREFIX, ""));
+    }
+    catch {
+        return [];
+    }
+}
+export const checkChrome = async (ctx) => {
+    const id = "chrome-headless-shell";
+    const versions = await chromeVersions(ctx);
+    if (versions.length === 0) {
+        return {
+            id,
+            status: "missing",
+            required: false,
+            hint: "first render downloads it; prefetch: npx hyperframes browser ensure",
+        };
+    }
+    if (!ctx.pinsPresent)
+        return found(id, versions.join(", "));
+    const pin = ctx.pins.chromeHeadlessShell;
+    if (pin && versions.includes(pin))
+        return found(id, pin);
+    const hint = pin
+        ? `pinned ${pin}: install it or update ${PIN_KEYS.chromeHeadlessShell}`
+        : `add ${PIN_KEYS.chromeHeadlessShell}`;
+    return { id, status: "usable", required: false, version: versions.join(", "), hint };
+};
+const NO_GPU_HINT = "software GL is CI-only slow; install a GPU driver for local renders";
+async function gpuNames(ctx) {
+    const cim = await ctx.run("powershell", [
+        "-NoProfile",
+        "-Command",
+        "(Get-CimInstance Win32_VideoController).Name",
+    ]);
+    if (cim.code === 0 && lines(cim.stdout).length > 0)
+        return lines(cim.stdout);
+    const wmic = await ctx.run("wmic", ["path", "win32_videocontroller", "get", "name"]);
+    if (wmic.code !== 0)
+        return [];
+    return lines(wmic.stdout).filter((line) => line.toLowerCase() !== "name");
+}
+export const checkGpu = async (ctx) => {
+    const id = "gpu";
+    if (ctx.host.platform !== "win32") {
+        return { id, status: "unknown", required: false, hint: "detection is Windows-only" };
+    }
+    const names = await gpuNames(ctx);
+    if (names.length === 0) {
+        return { id, status: "missing", required: false, hint: NO_GPU_HINT };
+    }
+    return found(id, names.join(", "));
+};
+async function pythonVersion(ctx) {
+    for (const cmd of ["python3", "python"]) {
+        const result = await ctx.run(cmd, ["--version"]);
+        const version = result.code === 0 ? parseVersion(`${result.stdout}${result.stderr}`) : undefined;
+        if (version)
+            return formatVersion(version);
+    }
+    return undefined;
+}
+export const checkPython = async (ctx) => {
+    const id = "python";
+    const hint = `install Python ${WANTED_PYTHON} (voice phase only)`;
+    const version = await pythonVersion(ctx);
+    if (!version)
+        return { id, status: "missing", required: false, hint };
+    if (version.startsWith(`${WANTED_PYTHON}.`))
+        return found(id, version);
+    const tooNew = (parseVersion(version)?.minor ?? 0) > 12;
+    const note = tooNew ? "too new for TTS wheels; " : "";
+    return {
+        id,
+        status: "usable",
+        required: false,
+        version,
+        hint: `${note}want ${WANTED_PYTHON} (voice phase only)`,
+    };
+};
+async function pyLauncherState(run) {
+    const launcher = await run("py", ["-3.12", "--version"]);
+    if (absent(launcher))
+        return "missing";
+    if (launcher.code !== 0)
+        return "unknown";
+    if (!parseVersion(`${launcher.stdout}${launcher.stderr}`))
+        return "unknown";
+    return "ok";
+}
+async function venvPythonVersion(run) {
+    for (const cmd of VENV_PYS) {
+        const result = await run(cmd, ["--version"]);
+        if (result.code !== 0)
+            continue;
+        const parsed = parseVersion(`${result.stdout}${result.stderr}`);
+        if (!parsed)
+            continue;
+        const text = formatVersion(parsed);
+        return { text, usable: !text.startsWith(`${WANTED_PYTHON}.`) };
+    }
+    return undefined;
+}
+export const checkPythonVenv = async ({ run }) => {
+    const id = "python-venv";
+    const state = await pyLauncherState(run);
+    if (state === "missing") {
+        return {
+            id,
+            status: "missing",
+            required: false,
+            hint: "install Python 3.12 from https://www.python.org/downloads/ then py -3.12 -m venv .venv-voice (voice phase only)",
+        };
+    }
+    if (state === "unknown") {
+        return { id, status: "unknown", required: false, hint: "py -3.12 ran but gave no version" };
+    }
+    const venv = await venvPythonVersion(run);
+    if (!venv) {
+        return {
+            id,
+            status: "missing",
+            required: false,
+            hint: "py -3.12 -m venv .venv-voice then .venv-voice\\Scripts\\activate (voice phase only)",
+        };
+    }
+    if (!venv.usable)
+        return found(id, venv.text);
+    return {
+        id,
+        status: "usable",
+        required: false,
+        version: venv.text,
+        hint: "venv python is not 3.12; recreate with py -3.12 -m venv .venv-voice (voice phase only)",
+    };
+};
+function espeakVersion(text) {
+    const parsed = parseVersion(text);
+    return parsed ? formatVersion(parsed) : undefined;
+}
+async function espeakBinary(run) {
+    for (const cmd of ["espeak-ng", "espeak"]) {
+        const result = await run(cmd, ["--version"]);
+        if (result.code === 0) {
+            const version = espeakVersion(`${result.stdout}${result.stderr}`);
+            if (version)
+                return { version };
+            return { unknown: `${cmd} ran but gave no version` };
+        }
+        if (!absent(result))
+            return { unknown: `${cmd} ran but failed` };
+    }
+    return undefined;
+}
+async function espeakEnv(host) {
+    const envPath = host.env?.PHONEMIZER_ESPEAK_LIBRARY;
+    if (!envPath)
+        return undefined;
+    let exists = false;
+    try {
+        exists = await host.exists(envPath);
+    }
+    catch {
+        exists = false;
+    }
+    if (exists)
+        return { id: "espeak", status: "ok", required: false, version: envPath };
+    return {
+        id: "espeak",
+        status: "usable",
+        required: false,
+        version: envPath,
+        hint: `PHONEMIZER_ESPEAK_LIBRARY points at a missing file; reinstall espeak-ng from ${ESPEAK_RELEASES} and set it to libespeak-ng.dll (voice phase only)`,
+    };
+}
+export const checkEspeak = async ({ run, host }) => {
+    const id = "espeak";
+    const binary = await espeakBinary(run);
+    if (binary) {
+        if ("version" in binary)
+            return found(id, binary.version);
+        return { id, status: "unknown", required: false, hint: binary.unknown };
+    }
+    const env = await espeakEnv(host);
+    if (env)
+        return env;
+    return {
+        id,
+        status: "missing",
+        required: false,
+        hint: `install espeak-ng from ${ESPEAK_RELEASES} (.msi) and set PHONEMIZER_ESPEAK_LIBRARY to espeak-ng.dll, e.g. setx PHONEMIZER_ESPEAK_LIBRARY "C:\\Program Files\\eSpeak NG\\libespeak-ng.dll" (voice phase only)`,
+    };
+};
+function pipVersion(text) {
+    const match = /Version:\s*([^\s]+)/i.exec(text);
+    return match?.[1]?.trim() || undefined;
+}
+async function pipShowVersion(run, cmd, pkg) {
+    const result = await run(cmd, ["-m", "pip", "show", pkg]);
+    if (result.code === 0) {
+        const version = pipVersion(`${result.stdout}\n${result.stderr}`);
+        if (version)
+            return { ok: version };
+        return { unknown: true };
+    }
+    if (absent(result))
+        return { absent: true };
+    return { missing: true };
+}
+async function kokoroSoundfile(run, cmd, version) {
+    const id = "kokoro";
+    const sf = await pipShowVersion(run, cmd, "soundfile");
+    if ("ok" in sf)
+        return found(id, version);
+    if ("unknown" in sf) {
+        return { id, status: "unknown", required: false, hint: "pip show soundfile gave no version" };
+    }
+    return {
+        id,
+        status: "usable",
+        required: false,
+        version,
+        hint: `pip install soundfile==${SOUNDFILE_VERSION} in .venv-voice (.venv-voice\\Scripts\\activate then pip install soundfile==${SOUNDFILE_VERSION}) (voice phase only)`,
+    };
+}
+export const checkKokoro = async ({ run }) => {
+    const id = "kokoro";
+    const installHint = `activate the venv (.venv-voice\\Scripts\\activate) then pip install kokoro==${KOKORO_VERSION} soundfile==${SOUNDFILE_VERSION} (${VOICE_LOCAL_PRIMARY}; ${VOICE_MANUAL_SETUP}; ${VOICE_NO_PAID_BACKEND}; ${VOICE_WAV_FALLBACK} when env blocked; voice phase only)`;
+    let venvFound = false;
+    for (const cmd of VENV_PYS) {
+        const kok = await pipShowVersion(run, cmd, "kokoro");
+        if ("ok" in kok)
+            return kokoroSoundfile(run, cmd, kok.ok);
+        if ("unknown" in kok) {
+            return { id, status: "unknown", required: false, hint: "pip show kokoro gave no version" };
+        }
+        if ("missing" in kok)
+            venvFound = true;
+    }
+    if (!venvFound) {
+        return {
+            id,
+            status: "missing",
+            required: false,
+            hint: "create the voice venv first: py -3.12 -m venv .venv-voice then .venv-voice\\Scripts\\activate (voice phase only)",
+        };
+    }
+    return { id, status: "missing", required: false, hint: installHint };
+};
+export const checkFasterWhisper = async ({ run }) => {
+    const id = "faster-whisper";
+    const installHint = `activate the venv (.venv-voice\\Scripts\\activate) then pip install faster-whisper==${FASTER_WHISPER_VERSION} (${VOICE_ALIGNER}; ${VOICE_MANUAL_SETUP}; ${VOICE_NO_PAID_BACKEND}; ${VOICE_WAV_FALLBACK} when env blocked; voice phase only)`;
+    let venvFound = false;
+    for (const cmd of VENV_PYS) {
+        const result = await run(cmd, ["-m", "pip", "show", "faster-whisper"]);
+        if (result.code === 0) {
+            const version = pipVersion(`${result.stdout}\n${result.stderr}`);
+            if (!version) {
+                return {
+                    id,
+                    status: "unknown",
+                    required: false,
+                    hint: "pip show faster-whisper gave no version",
+                };
+            }
+            return found(id, version);
+        }
+        if (!absent(result))
+            venvFound = true;
+    }
+    if (!venvFound) {
+        return {
+            id,
+            status: "missing",
+            required: false,
+            hint: "create the voice venv first: py -3.12 -m venv .venv-voice then .venv-voice\\Scripts\\activate (voice phase only)",
+        };
+    }
+    return { id, status: "missing", required: false, hint: installHint };
+};
+export const checkFonts = async ({ vendored }) => {
+    const id = "fonts";
+    const missing = vendored.missingFonts();
+    if (missing.length === 0)
+        return { id, status: "ok", required: false };
+    return {
+        id,
+        status: "missing",
+        required: false,
+        version: missing.join(","),
+        hint: "reinstall @anvpx/motion (it vendors @fontsource/*)",
+    };
+};
+export const checkIcons = async ({ host, vendored }) => {
+    const id = "icons";
+    if (await host.exists(vendored.iconsFile))
+        return { id, status: "ok", required: false };
+    return {
+        id,
+        status: "missing",
+        required: false,
+        hint: "reinstall @anvpx/motion (it stages icons/icons.json)",
+    };
+};
+export const checkTemplates = async ({ host }) => {
+    const id = "templates";
+    try {
+        const stopwordsFile = join(dirname(TEMPLATES_DIR), "stopwords.json");
+        const missing = [];
+        if (!(await host.exists(TEMPLATES_DIR).catch(() => false)))
+            missing.push("templates");
+        if (!(await host.exists(SHARED_THEMES_DIR).catch(() => false)))
+            missing.push("shared-themes");
+        if (!(await host.exists(stopwordsFile).catch(() => false)))
+            missing.push("stopwords");
+        if (missing.length === 0)
+            return { id, status: "ok", required: false };
+        return {
+            id,
+            status: "missing",
+            required: false,
+            version: missing.join(","),
+            hint: "reinstall @anvpx/motion (it stages templates, shared themes and stopwords)",
+        };
+    }
+    catch {
+        return {
+            id,
+            status: "missing",
+            required: false,
+            hint: "reinstall @anvpx/motion (it stages templates, shared themes and stopwords)",
+        };
+    }
+};
+function resolveCliMain() {
+    try {
+        const entry = nodeRequire.resolve("@anvpx/motion-cli");
+        return join(dirname(entry), "main.js");
+    }
+    catch {
+        return fileURLToPath(new URL("../../dist/main.js", import.meta.url));
+    }
+}
+function resolveCoreMain() {
+    try {
+        const entry = nodeRequire.resolve("@anvpx/motion");
+        return join(dirname(entry), "main.js");
+    }
+    catch {
+        return fileURLToPath(new URL("../../../core/dist/main.js", import.meta.url));
+    }
+}
+export const checkBin = async ({ host }) => {
+    const id = "bin";
+    const cliMain = resolveCliMain();
+    const coreMain = resolveCoreMain();
+    const cliOk = await host.exists(cliMain).catch(() => false);
+    const coreOk = await host.exists(coreMain).catch(() => false);
+    if (cliOk && coreOk)
+        return { id, status: "ok", required: false };
+    const missing = [!cliOk ? "cli" : undefined, !coreOk ? "core" : undefined]
+        .filter((part) => part !== undefined)
+        .join(",");
+    return {
+        id,
+        status: "missing",
+        required: false,
+        version: missing,
+        hint: "reinstall @anvpx/motion (it ships the mk bin: core dist/main.js delegating to cli dist/main.js)",
+    };
+};
+function resolveStagedCatalog() {
+    try {
+        const entry = nodeRequire.resolve("@anvpx/motion");
+        return join(dirname(entry), "..", "CATALOG.md");
+    }
+    catch {
+        return fileURLToPath(new URL("../../../core/CATALOG.md", import.meta.url));
+    }
+}
+export const checkCatalog = async ({ host }) => {
+    const id = "catalog";
+    const staged = resolveStagedCatalog();
+    if (await host.exists(staged).catch(() => false)) {
+        return { id, status: "ok", required: false, version: "staged" };
+    }
+    const cwdFallback = join(process.cwd(), "CATALOG.md");
+    if (await host.exists(cwdFallback).catch(() => false)) {
+        return { id, status: "ok", required: false, version: "cwd" };
+    }
+    return {
+        id,
+        status: "missing",
+        required: false,
+        version: "CATALOG.md",
+        hint: "reinstall @anvpx/motion to restore staged CATALOG.md, or run mk catalog --write in this directory (cwd fallback: ./CATALOG.md)",
+    };
+};
+export const CHECKS = [
+    checkNode,
+    checkPnpm,
+    checkFfmpeg,
+    checkFfprobe,
+    checkHyperframes,
+    checkChrome,
+    checkGpu,
+    checkPython,
+    checkPythonVenv,
+    checkEspeak,
+    checkKokoro,
+    checkFasterWhisper,
+    checkFonts,
+    checkIcons,
+    checkTemplates,
+    checkBin,
+    checkCatalog,
+    checkSkills,
+];

package/dist/doctor/command.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "../types.ts";
+import type { Vendored } from "./types.ts";
+export declare const makeDoctorCommand: (vendored?: () => Vendored) => Command;
+export declare const doctorCommand: Command;

package/dist/doctor/command.js

@@ -0,0 +1,88 @@
+import { parseArgs } from "node:util";
+import { firstSentence } from "../args.js";
+import { EXIT } from "../exit-codes.js";
+import { CHECKS } from "./checks.js";
+import { exitCodeFor, formatJson, formatTable } from "./format.js";
+import { formatHealLines, formatJsonWithHeal, healSafeRows } from "./heal.js";
+import { hasPins, readPins } from "./pins.js";
+import { defaultVendored } from "./vendored.js";
+const USAGE = `mk doctor [--json] [--fix]
+
+Install is the npm package install plus this check (plugin install stays separate):
+  npm install @anvpx/motion (or npx -y @anvpx/motion@<version>) then mk doctor.
+  mk plugin install --out <dir> is a separate explicit step, never part of npm install.
+Check the local toolchain; each tool is ok | usable | missing | unknown.
+Exit 0 when no required tool (node, pnpm, ffmpeg, ffprobe) is missing; 127 when one is;
+2 when a required check could not be decided. chrome is optional: the first render
+downloads it. python is optional (voice phase); fonts and icons (vendored files) report
+ok or missing and never fail the exit code.
+Voice rows (python, python-venv, espeak, kokoro, faster-whisper) are hint-only and
+never auto-install system/pip deps; --fix leaves them untouched.
+  --json   one line: [{id, status, version?, hint?}]
+  --fix    safe autoheal only (hyperframes note, fonts/icons/templates/bin/catalog hint,
+           chrome: npx hyperframes browser ensure); prints healed/still-missing;
+           with --json prints {results, healed: [{id, healed, detail}]}.
+           Never deletes, never installs; exit codes unchanged.
+`;
+async function runChecks(io, vendored) {
+    const manifest = await io.host.readRootPackageJson();
+    const pins = readPins(manifest);
+    const ctx = {
+        run: io.run,
+        host: io.host,
+        pins,
+        pinsPresent: hasPins(manifest),
+        vendored,
+    };
+    return Promise.all(CHECKS.map((check) => check(ctx)));
+}
+function parseDoctorArgs(args) {
+    try {
+        const flags = parseArgs({
+            args: [...args],
+            options: {
+                json: { type: "boolean" },
+                fix: { type: "boolean" },
+                help: { type: "boolean", short: "h" },
+            },
+            allowPositionals: false,
+        }).values;
+        if (flags.help)
+            return { help: true };
+        return { flags };
+    }
+    catch (error) {
+        return { error: firstSentence(error.message) };
+    }
+}
+async function emitResults(results, fix, json, io) {
+    if (!fix) {
+        io.stdout(json ? formatJson(results) : formatTable(results));
+        return;
+    }
+    const healed = await healSafeRows(results, io);
+    if (json) {
+        io.stdout(formatJsonWithHeal(results, healed));
+        return;
+    }
+    io.stdout(`${formatTable(results)}${formatHealLines(healed)}`);
+}
+export const makeDoctorCommand = (vendored = defaultVendored) => ({
+    name: "doctor",
+    summary: "check node, pnpm, ffmpeg, ffprobe, hyperframes, chrome, gpu, python, fonts, icons",
+    async run(args, io) {
+        const parsed = parseDoctorArgs(args);
+        if ("error" in parsed) {
+            io.stderr(`mk doctor: ${parsed.error}\n`);
+            return EXIT.USAGE;
+        }
+        if ("help" in parsed) {
+            io.stdout(USAGE);
+            return EXIT.OK;
+        }
+        const results = await runChecks(io, vendored());
+        await emitResults(results, parsed.flags.fix === true, parsed.flags.json === true, io);
+        return exitCodeFor(results);
+    },
+});
+export const doctorCommand = makeDoctorCommand();

package/dist/doctor/format.d.ts

@@ -0,0 +1,7 @@
+import type { CheckResult, CheckStatus } from "./types.ts";
+export declare function summarize(results: readonly CheckResult[]): Record<CheckStatus, number>;
+/** 127 when a required tool is missing, else 2 when a required check is unknown, else 0. */
+export declare function exitCodeFor(results: readonly CheckResult[]): number;
+export declare function formatTable(results: readonly CheckResult[]): string;
+/** One compact line: [{id, status, version?, hint?}]. */
+export declare function formatJson(results: readonly CheckResult[]): string;