@remix-run/cli 0.0.0 → 0.2.0

package/dist/lib/bootstrap-project.js

@@ -0,0 +1,137 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as process from 'node:process';
+import { fileURLToPath } from 'node:url';
+import semver from 'semver';
+import { appNameUnavailable, invalidPackageName, targetDirectoryNotEmpty, targetPathNotDirectory, } from "./errors.js";
+import { runProgressStep } from "./reporter.js";
+const BOOTSTRAP_DIRECTORY = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../bootstrap');
+const BOOTSTRAP_EXCLUDED_NAMES = new Set(['.gitkeep', 'node_modules']);
+export const MINIMUM_SUPPORTED_NODE_VERSION = '24.3.0';
+export async function bootstrapProject(options, progress) {
+    let cwd = options.cwd ?? process.cwd();
+    let targetDir = path.resolve(cwd, options.targetDir);
+    let rawAppName = options.appName ?? path.basename(targetDir);
+    if (rawAppName.length === 0) {
+        throw appNameUnavailable(targetDir);
+    }
+    let config = {
+        appDisplayName: options.appName ?? humanizeName(rawAppName),
+        packageName: toPackageName(rawAppName),
+        remixVersion: readDefaultRemixVersion(options.remixVersion),
+    };
+    await runProgressStep(progress, 'prepare-target-directory', () => ensureTargetDirectory(targetDir, options.force));
+    await runProgressStep(progress, 'generate-scaffold-files', () => copyBootstrapDirectory({
+        sourceDir: BOOTSTRAP_DIRECTORY,
+        targetDir,
+        templateValues: createTemplateValues(config),
+    }));
+    await runProgressStep(progress, 'finalize-package-json', () => writeScaffoldPackageJson(targetDir, config));
+    return {
+        appDisplayName: config.appDisplayName,
+        targetDir,
+    };
+}
+function readDefaultRemixVersion(runtimeVersion) {
+    let overriddenVersion = process.env.REMIX_VERSION?.trim();
+    if (overriddenVersion) {
+        return overriddenVersion;
+    }
+    if (runtimeVersion == null) {
+        return 'latest';
+    }
+    let validRuntimeVersion = semver.valid(runtimeVersion);
+    return validRuntimeVersion == null ? runtimeVersion : `^${validRuntimeVersion}`;
+}
+function createTemplateValues(config) {
+    return {
+        '%%RMX_APP_DISPLAY_NAME%%': config.appDisplayName,
+        '%%RMX_APP_DISPLAY_NAME_URI_COMPONENT%%': encodeURIComponent(config.appDisplayName),
+    };
+}
+async function writeScaffoldPackageJson(targetDir, config) {
+    let packageJsonPath = path.join(targetDir, 'package.json');
+    let packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
+    packageJson.name = config.packageName;
+    packageJson.dependencies = {
+        ...packageJson.dependencies,
+        remix: config.remixVersion,
+        tsx: 'latest',
+    };
+    packageJson.devDependencies = {
+        ...packageJson.devDependencies,
+        '@types/node': 'latest',
+        typescript: 'latest',
+    };
+    packageJson.engines = {
+        ...packageJson.engines,
+        node: `>=${MINIMUM_SUPPORTED_NODE_VERSION}`,
+    };
+    await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n', 'utf8');
+}
+async function ensureTargetDirectory(targetDir, force) {
+    try {
+        let stats = await fs.stat(targetDir);
+        if (!stats.isDirectory()) {
+            throw targetPathNotDirectory(targetDir);
+        }
+        let entries = await fs.readdir(targetDir);
+        if (entries.length > 0 && !force) {
+            throw targetDirectoryNotEmpty(targetDir);
+        }
+    }
+    catch (error) {
+        let nodeError = error;
+        if (nodeError.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    await fs.mkdir(targetDir, { recursive: true });
+}
+async function copyBootstrapDirectory({ sourceDir, targetDir, templateValues, }) {
+    let entries = await fs.readdir(sourceDir, { withFileTypes: true });
+    for (let entry of entries) {
+        let sourcePath = path.join(sourceDir, entry.name);
+        let targetPath = path.join(targetDir, entry.name);
+        if (BOOTSTRAP_EXCLUDED_NAMES.has(entry.name)) {
+            continue;
+        }
+        if (entry.isDirectory()) {
+            await fs.mkdir(targetPath, { recursive: true });
+            await copyBootstrapDirectory({ sourceDir: sourcePath, targetDir: targetPath, templateValues });
+            continue;
+        }
+        let content = await fs.readFile(sourcePath, 'utf8');
+        await fs.writeFile(targetPath, replaceTemplateValues(content, templateValues), 'utf8');
+    }
+}
+function replaceTemplateValues(content, templateValues) {
+    for (let [token, value] of Object.entries(templateValues)) {
+        content = content.split(token).join(value);
+    }
+    return content;
+}
+function humanizeName(value) {
+    let parts = value.split(/[-_\s]+/).filter(Boolean);
+    if (parts.length === 0) {
+        return 'Remix App';
+    }
+    return parts
+        .map((part) => {
+        let head = part.slice(0, 1).toUpperCase();
+        let tail = part.slice(1);
+        return `${head}${tail}`;
+    })
+        .join(' ');
+}
+function toPackageName(value) {
+    let packageName = value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    if (packageName.length === 0) {
+        throw invalidPackageName(value);
+    }
+    return packageName;
+}

package/dist/lib/cli-context.d.ts

@@ -0,0 +1,11 @@
+interface ResolveCliContextOptions {
+    cwd?: string;
+    remixVersion?: string;
+}
+export interface CliContext {
+    cwd: string;
+    remixVersion?: string;
+}
+export declare function resolveCliContext(options?: ResolveCliContextOptions): Promise<CliContext>;
+export {};
+//# sourceMappingURL=cli-context.d.ts.map

package/dist/lib/cli-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-context.d.ts","sourceRoot":"","sources":["../../src/lib/cli-context.ts"],"names":[],"mappings":"AAKA,UAAU,wBAAwB;IAChC,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,MAAM,CAAA;IACX,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED,wBAAsB,iBAAiB,CACrC,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,UAAU,CAAC,CAQrB"}

package/dist/lib/cli-context.js

@@ -0,0 +1,19 @@
+import * as path from 'node:path';
+import * as process from 'node:process';
+import { resolveDefaultRemixVersion } from "./remix-version.js";
+export async function resolveCliContext(options = {}) {
+    let cwd = resolveCwd(options.cwd);
+    let remixVersion = normalizeRemixVersion(options.remixVersion);
+    return {
+        cwd,
+        remixVersion: remixVersion ?? (await resolveDefaultRemixVersion(cwd)),
+    };
+}
+function resolveCwd(cwd) {
+    let normalizedCwd = cwd?.trim();
+    return path.resolve(normalizedCwd == null || normalizedCwd.length === 0 ? process.cwd() : normalizedCwd);
+}
+function normalizeRemixVersion(remixVersion) {
+    let normalizedVersion = remixVersion?.trim();
+    return normalizedVersion == null || normalizedVersion.length === 0 ? undefined : normalizedVersion;
+}

package/dist/lib/cli.d.ts

@@ -0,0 +1,6 @@
+export interface RunRemixOptions {
+    cwd?: string;
+    remixVersion?: string;
+}
+export declare function runRemix(argv?: string[], options?: RunRemixOptions): Promise<number>;
+//# sourceMappingURL=cli.d.ts.map

package/dist/lib/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/lib/cli.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,eAAe;IAC9B,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED,wBAAsB,QAAQ,CAC5B,IAAI,GAAE,MAAM,EAA0B,EACtC,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,MAAM,CAAC,CA4BjB"}

package/dist/lib/cli.js

@@ -0,0 +1,84 @@
+import * as process from 'node:process';
+import { getCliHelpText, runHelpCommand } from "./commands/help.js";
+import { resolveCliContext } from "./cli-context.js";
+import { renderCliError, unknownCommand } from "./errors.js";
+import { configureColors, restoreTerminalFormatting } from "./terminal.js";
+export async function runRemix(argv = process.argv.slice(2), options = {}) {
+    let context = await resolveCliContext(options);
+    try {
+        while (argv[0] === '--') {
+            argv = argv.slice(1);
+        }
+        let globalOptions = extractGlobalOptions(argv);
+        argv = globalOptions.argv;
+        configureColors({ disabled: globalOptions.noColor });
+        if (argv.length === 0) {
+            process.stdout.write(getCliHelpText());
+            return 0;
+        }
+        let [command, ...rest] = argv;
+        if (command === '-h' || command === '--help') {
+            process.stdout.write(getCliHelpText());
+            return 0;
+        }
+        return await runCommand(command, rest, context);
+    }
+    finally {
+        restoreTerminalFormatting();
+    }
+}
+async function runCommand(command, argv, context) {
+    if (command === 'help') {
+        return runHelpCommand(argv);
+    }
+    if (command === '-v' || command === '--version') {
+        let { runVersionCommand } = await import("./commands/version.js");
+        return runVersionCommand([], context);
+    }
+    if (command === 'new') {
+        let { runNewCommand } = await import("./commands/new.js");
+        return runNewCommand(argv, context);
+    }
+    if (command === 'completion') {
+        let { runCompletionCommand } = await import("./commands/completion.js");
+        return runCompletionCommand(argv);
+    }
+    if (command === 'doctor') {
+        let { runDoctorCommand } = await import("./commands/doctor.js");
+        return runDoctorCommand(argv, context);
+    }
+    if (command === 'routes') {
+        let { runRoutesCommand } = await import("./commands/routes.js");
+        return runRoutesCommand(argv, context);
+    }
+    if (command === 'test') {
+        let { runTestCommand } = await import("./commands/test.js");
+        return runTestCommand(argv, context);
+    }
+    if (command === 'version') {
+        let { runVersionCommand } = await import("./commands/version.js");
+        return runVersionCommand(argv, context);
+    }
+    process.stderr.write(renderCliError(unknownCommand(command), { helpText: getCliHelpText(process.stderr) }));
+    return 1;
+}
+function extractGlobalOptions(argv) {
+    let filteredArgv = [];
+    let noColor = false;
+    for (let index = 0; index < argv.length; index++) {
+        let arg = argv[index];
+        if (arg === '--') {
+            filteredArgv.push(...argv.slice(index));
+            break;
+        }
+        if (arg === '--no-color') {
+            noColor = true;
+            continue;
+        }
+        filteredArgv.push(arg);
+    }
+    return {
+        argv: filteredArgv,
+        noColor,
+    };
+}

package/dist/lib/commands/completion.d.ts

@@ -0,0 +1,3 @@
+export declare function runCompletionCommand(argv: string[]): Promise<number>;
+export declare function getCompletionCommandHelpText(target?: NodeJS.WriteStream): string;
+//# sourceMappingURL=completion.d.ts.map

package/dist/lib/commands/completion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"completion.d.ts","sourceRoot":"","sources":["../../../src/lib/commands/completion.ts"],"names":[],"mappings":"AAiBA,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CA6B1E;AAED,wBAAgB,4BAA4B,CAAC,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAShG"}

package/dist/lib/commands/completion.js

@@ -0,0 +1,51 @@
+import * as process from 'node:process';
+import { getCompletionResult, getCompletionScript, isCompletionShell, renderCompletionResult, } from "../completion.js";
+import { invalidCompletionRequest, renderCliError, toCliError, unknownCompletionShell, } from "../errors.js";
+import { formatHelpText } from "../help-text.js";
+import { parseArgs } from "../parse-args.js";
+export async function runCompletionCommand(argv) {
+    if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
+        process.stdout.write(getCompletionCommandHelpText());
+        return 0;
+    }
+    if (argv[0] === '--') {
+        return runCompletionPlumbing(argv.slice(1));
+    }
+    let [shell, ...rest] = argv;
+    try {
+        parseArgs(rest, {}, { maxPositionals: 0 });
+        if (!isCompletionShell(shell)) {
+            throw unknownCompletionShell(shell);
+        }
+        process.stdout.write(getCompletionScript());
+        return 0;
+    }
+    catch (error) {
+        process.stderr.write(renderCliError(toCliError(error), {
+            helpText: getCompletionCommandHelpText(process.stderr),
+        }));
+        return 1;
+    }
+}
+export function getCompletionCommandHelpText(target = process.stdout) {
+    return formatHelpText({
+        description: 'Print a shell completion script for Remix.',
+        examples: ['remix completion bash >> ~/.bashrc', 'remix completion zsh >> ~/.zshrc'],
+        usage: ['remix completion <bash|zsh>'],
+    }, target);
+}
+function runCompletionPlumbing(argv) {
+    try {
+        let [currentIndexArg, ...words] = argv;
+        if (currentIndexArg == null || !/^\d+$/.test(currentIndexArg)) {
+            throw invalidCompletionRequest();
+        }
+        let currentIndex = Number(currentIndexArg);
+        process.stdout.write(renderCompletionResult(getCompletionResult(words, currentIndex)));
+        return 0;
+    }
+    catch (error) {
+        process.stderr.write(renderCliError(toCliError(error)));
+        return 1;
+    }
+}

package/dist/lib/commands/doctor.d.ts

@@ -0,0 +1,4 @@
+import type { CliContext } from '../cli-context.ts';
+export declare function runDoctorCommand(argv: string[], context: CliContext): Promise<number>;
+export declare function getDoctorCommandHelpText(target?: NodeJS.WriteStream): string;
+//# sourceMappingURL=doctor.d.ts.map

package/dist/lib/commands/doctor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../../src/lib/commands/doctor.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AA4CnD,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CA6C3F;AAED,wBAAgB,wBAAwB,CAAC,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAsB5F"}

package/dist/lib/commands/doctor.js

@@ -0,0 +1,293 @@
+import * as path from 'node:path';
+import * as process from 'node:process';
+import { checkControllerConventions } from "../doctor/controllers.js";
+import { checkEnvironment, getEnvironmentFixPlans } from "../doctor/environment.js";
+import { applyDoctorFixPlans } from "../doctor/fixes.js";
+import { checkProject, getProjectFixPlans } from "../doctor/project.js";
+import { createDoctorSuite, createSkippedDoctorSuite, } from "../doctor/types.js";
+import { renderCliError, toCliError } from "../errors.js";
+import { formatHelpText } from "../help-text.js";
+import { parseArgs } from "../parse-args.js";
+import { createCommandReporter, createStepProgressReporter, } from "../reporter.js";
+const DOCTOR_SUITE_LABELS = {
+    controllers: {
+        complete: 'controllers',
+        running: 'Checking controllers',
+    },
+    environment: {
+        complete: 'environment',
+        running: 'Checking environment',
+    },
+    project: {
+        complete: 'project',
+        running: 'Checking project',
+    },
+};
+export async function runDoctorCommand(argv, context) {
+    if (argv.includes('-h') || argv.includes('--help')) {
+        process.stdout.write(getDoctorCommandHelpText());
+        return 0;
+    }
+    let reporter = null;
+    let progress = null;
+    try {
+        let options = parseDoctorCommandArgs(argv);
+        reporter = options.json
+            ? null
+            : createCommandReporter({
+                remixVersion: context.remixVersion,
+                stderr: process.stdout,
+                stdout: process.stdout,
+            });
+        progress = reporter == null ? null : createDoctorProgressReporter(reporter);
+        if (reporter != null) {
+            await reporter.status.commandHeader('doctor');
+        }
+        let report = await collectDoctorReport(progress, options, reporter, context);
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+        }
+        else if (reporter != null) {
+            writeDoctorReport(reporter, report);
+            reporter.finish();
+        }
+        if ((options.fix || options.strict) && hasWarningFindings(report.findings)) {
+            return 1;
+        }
+        return 0;
+    }
+    catch (error) {
+        progress?.writeSummaryGap();
+        process.stderr.write(renderCliError(toCliError(error), { helpText: getDoctorCommandHelpText(process.stderr) }));
+        reporter?.finish();
+        return 1;
+    }
+}
+export function getDoctorCommandHelpText(target = process.stdout) {
+    return formatHelpText({
+        description: 'Check project environment and Remix app conventions for the current project.',
+        examples: [
+            'remix doctor',
+            'remix doctor --json',
+            'remix doctor --strict',
+            'remix doctor --fix',
+        ],
+        options: [
+            { description: 'Print doctor findings as JSON', label: '--json' },
+            {
+                description: 'Exit with status 1 when warning-level findings are present',
+                label: '--strict',
+            },
+            { description: 'Apply low-risk project and controller fixes', label: '--fix' },
+        ],
+        usage: ['remix doctor [--json] [--strict] [--fix] [--no-color]'],
+    }, target);
+}
+function parseDoctorCommandArgs(argv) {
+    let parsed = parseArgs(argv, {
+        fix: { flag: '--fix', type: 'boolean' },
+        json: { flag: '--json', type: 'boolean' },
+        strict: { flag: '--strict', type: 'boolean' },
+    }, { maxPositionals: 0 });
+    return {
+        fix: parsed.options.fix,
+        json: parsed.options.json,
+        strict: parsed.options.strict,
+    };
+}
+async function collectDoctorReport(progress, options, reporter, context) {
+    let cwd = context.cwd;
+    let appliedFixes = [];
+    let environment = await runDoctorSuite(progress, 'environment', async () => {
+        let result = await checkEnvironment(cwd);
+        let suiteAppliedFixes = [];
+        let finalResult = result;
+        if (options.fix && result.projectRoot != null) {
+            let fixPlans = getEnvironmentFixPlans(result, context.remixVersion);
+            if (fixPlans.length > 0) {
+                suiteAppliedFixes = await applyDoctorFixPlans(result.projectRoot, fixPlans);
+                finalResult = await checkEnvironment(result.projectRoot);
+            }
+        }
+        let suite = finalResult.suite;
+        if (suiteAppliedFixes.length > 0) {
+            suite = {
+                ...suite,
+                appliedFixes: suiteAppliedFixes,
+            };
+        }
+        return {
+            appliedFixes: suiteAppliedFixes,
+            projectRoot: finalResult.projectRoot ?? result.projectRoot,
+            suite,
+        };
+    });
+    let findings = [...environment.suite.findings];
+    appliedFixes.push(...(environment.appliedFixes ?? []));
+    let suites = [environment.suite];
+    let routesFile = environment.projectRoot == null
+        ? undefined
+        : path.join(environment.projectRoot, 'app', 'routes.ts');
+    writeDoctorSuiteDetails(reporter, environment.suite);
+    progress?.writeSummaryGap();
+    if (hasWarningFindings(environment.suite.findings)) {
+        let projectSuite = createSkippedDoctorSuite('project', 'Blocked by environment warnings.');
+        let controllersSuite = createSkippedDoctorSuite('controllers', 'Blocked by environment warnings.');
+        suites.push(projectSuite, controllersSuite);
+        progress?.skip(projectSuite.name, projectSuite.reason);
+        writeDoctorSuiteDetails(reporter, projectSuite);
+        progress?.writeSummaryGap();
+        progress?.skip(controllersSuite.name, controllersSuite.reason);
+        writeDoctorSuiteDetails(reporter, controllersSuite);
+        progress?.writeSummaryGap();
+        return {
+            appRoot: environment.projectRoot,
+            appliedFixes,
+            findings,
+            remainingFindings: findings,
+            routesFile,
+            suites,
+        };
+    }
+    let project = await runDoctorSuite(progress, 'project', async () => {
+        let result = await checkProject(environment.projectRoot);
+        let suiteAppliedFixes = [];
+        let finalResult = result;
+        if (options.fix) {
+            let fixPlans = await getProjectFixPlans(environment.projectRoot);
+            if (fixPlans.length > 0) {
+                suiteAppliedFixes = await applyDoctorFixPlans(environment.projectRoot, fixPlans);
+                finalResult = await checkProject(environment.projectRoot);
+            }
+        }
+        let suite = finalResult.suite;
+        if (suiteAppliedFixes.length > 0) {
+            suite = {
+                ...suite,
+                appliedFixes: suiteAppliedFixes,
+            };
+        }
+        return {
+            appliedFixes: suiteAppliedFixes,
+            routeManifest: finalResult.routeManifest,
+            routesFile: finalResult.routesFile,
+            suite,
+        };
+    });
+    findings.push(...project.suite.findings);
+    appliedFixes.push(...(project.appliedFixes ?? []));
+    routesFile = project.routesFile;
+    suites.push(project.suite);
+    writeDoctorSuiteDetails(reporter, project.suite);
+    progress?.writeSummaryGap();
+    if (hasWarningFindings(project.suite.findings)) {
+        let controllersSuite = createSkippedDoctorSuite('controllers', 'Blocked by project warnings.');
+        suites.push(controllersSuite);
+        progress?.skip(controllersSuite.name, controllersSuite.reason);
+        writeDoctorSuiteDetails(reporter, controllersSuite);
+        progress?.writeSummaryGap();
+        return {
+            appRoot: environment.projectRoot,
+            appliedFixes,
+            findings,
+            remainingFindings: findings,
+            routesFile,
+            suites,
+        };
+    }
+    let controllers = await runDoctorSuite(progress, 'controllers', async () => {
+        let controllerResult = await checkControllerConventions(project.routeManifest.appRoot, project.routeManifest.tree);
+        let remainingFindings = controllerResult.suite.findings;
+        let suiteAppliedFixes = [];
+        if (options.fix && controllerResult.fixPlans.length > 0) {
+            suiteAppliedFixes = await applyDoctorFixPlans(project.routeManifest.appRoot, controllerResult.fixPlans);
+            let finalControllerResult = await checkControllerConventions(project.routeManifest.appRoot, project.routeManifest.tree);
+            remainingFindings = finalControllerResult.suite.findings;
+        }
+        let suite = createDoctorSuite('controllers', remainingFindings);
+        if (suiteAppliedFixes.length > 0) {
+            suite.appliedFixes = suiteAppliedFixes;
+        }
+        return { appliedFixes: suiteAppliedFixes, suite };
+    });
+    findings.push(...controllers.suite.findings);
+    appliedFixes.push(...(controllers.appliedFixes ?? []));
+    suites.push(controllers.suite);
+    writeDoctorSuiteDetails(reporter, controllers.suite);
+    progress?.writeSummaryGap();
+    let report = {
+        appRoot: environment.projectRoot,
+        findings,
+        routesFile,
+        suites,
+    };
+    if (options.fix) {
+        report.appliedFixes = appliedFixes;
+        report.remainingFindings = findings;
+    }
+    return report;
+}
+function hasWarningFindings(findings) {
+    return findings.some((finding) => finding.severity === 'warn');
+}
+function formatAppliedFix(appliedFix) {
+    if (appliedFix.kind === 'update-file') {
+        return `Updated ${appliedFix.path}`;
+    }
+    return `Created ${appliedFix.path}`;
+}
+async function runDoctorSuite(progress, label, callback) {
+    progress?.start(label);
+    try {
+        let result = await callback();
+        if (result.suite.status === 'ok') {
+            progress?.succeed(label);
+        }
+        else if (result.suite.status === 'issues') {
+            progress?.fail(label);
+        }
+        else {
+            progress?.skip(label, result.suite.reason);
+        }
+        return result;
+    }
+    catch (error) {
+        progress?.fail(label);
+        throw error;
+    }
+}
+function createDoctorProgressReporter(reporter) {
+    return createStepProgressReporter(reporter.status, DOCTOR_SUITE_LABELS);
+}
+function writeDoctorReport(reporter, report) {
+    let warningCount = report.findings.filter((finding) => finding.severity === 'warn').length;
+    let adviceCount = report.findings.length - warningCount;
+    if ((report.appliedFixes?.length ?? 0) > 0) {
+        let fixCount = report.appliedFixes.length;
+        reporter.out.line(`Applied ${fixCount} ${fixCount === 1 ? 'fix' : 'fixes'}.`);
+    }
+    if (report.findings.length === 0) {
+        reporter.out.line('Doctor found no issues.');
+    }
+    reporter.out.line(`Summary: ${warningCount} warnings, ${adviceCount} advice.`);
+}
+function writeDoctorSuiteDetails(reporter, suite) {
+    if (reporter == null) {
+        return;
+    }
+    if (suite.findings.length === 0 && (suite.appliedFixes?.length ?? 0) === 0) {
+        return;
+    }
+    reporter.out.withIndent(() => {
+        for (let finding of suite.findings) {
+            reporter.out.bullet(reporter.out.label(finding.severity.toUpperCase(), finding.message, {
+                tone: finding.severity === 'warn' ? 'warn' : undefined,
+            }));
+        }
+        if ((suite.appliedFixes?.length ?? 0) > 0) {
+            reporter.out.section('Applied fixes:', () => {
+                reporter.out.bullets((suite.appliedFixes ?? []).map(formatAppliedFix));
+            });
+        }
+    });
+}

package/dist/lib/commands/help.d.ts

@@ -0,0 +1,4 @@
+export declare function runHelpCommand(argv: string[]): Promise<number>;
+export declare function getCliHelpText(target?: NodeJS.WriteStream): string;
+export declare function getHelpCommandHelpText(target?: NodeJS.WriteStream): string;
+//# sourceMappingURL=help.d.ts.map

package/dist/lib/commands/help.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"help.d.ts","sourceRoot":"","sources":["../../../src/lib/commands/help.ts"],"names":[],"mappings":"AAKA,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAepE;AAED,wBAAgB,cAAc,CAAC,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAiClF;AAED,wBAAgB,sBAAsB,CAAC,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAiB1F"}