@remix-run/cli 0.3.4 → 0.5.0

package/dist/lib/commands/db.js

@@ -0,0 +1,283 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as process from 'node:process';
+import { runRemixDb } from '@remix-run/data-table/cli';
+import { loadMigrations, loadSeed } from '@remix-run/data-table/migrations/node';
+import { findAppRoot } from '../app-root.js';
+import { isDatabaseCommand, } from '../database-command.js';
+import { dbConfigRequired, dbForceRequired, invalidOptionValue, remixConfigNotFound, renderCliError, toCliError, unknownCommand, } from '../errors.js';
+import { formatHelpText } from '../help-text.js';
+import { parseArgs } from '../parse-args.js';
+import { loadRemixConfig, } from '../remix-config.js';
+const connectionOption = { flag: '--connection-env', type: 'string' };
+const journalOption = { flag: '--journal-table', type: 'string' };
+const migrationsOption = { flag: '--migrations', type: 'string' };
+const seedOption = { flag: '--seed', type: 'string' };
+export async function runDbCommand(argv, context) {
+    if (argv.length === 0 || argv.includes('-h') || argv.includes('--help')) {
+        process.stdout.write(getDbCommandHelpText());
+        return 0;
+    }
+    try {
+        let invocation = parseDbCommandArgs(argv);
+        let resolved = await resolveDbConfig(context);
+        let plan = resolveDatabaseCommandPlan(invocation, resolved.config, context.cwd);
+        return await runDatabaseCommand(plan, resolved.configDir);
+    }
+    catch (error) {
+        process.stderr.write(renderCliError(toCliError(error), { helpText: getDbCommandHelpText(process.stderr) }));
+        return 1;
+    }
+}
+export function getDbCommandHelpText(target = process.stdout) {
+    return formatHelpText({
+        description: 'Manage the current app database.',
+        examples: [
+            'remix db wipe --force',
+            'remix db migrate',
+            'remix db migrate --to 20260715123000_add_users',
+            'remix db status',
+            'remix db seed',
+            'remix db reset --force',
+        ],
+        options: [
+            {
+                description: 'Read the database connection from an environment variable',
+                label: '--connection-env <name>',
+            },
+            { description: 'Confirm a destructive command (wipe and reset only)', label: '--force' },
+            {
+                description: 'Use a migration journal table (migrate, status, and reset only)',
+                label: '--journal-table <name>',
+            },
+            {
+                description: 'Load migrations from a directory (migrate, status, and reset only)',
+                label: '--migrations <path>',
+            },
+            { description: 'Run a SQL seed file (seed and reset only)', label: '--seed <path>' },
+            {
+                description: 'Stop after applying the specified migration (migrate only)',
+                label: '--to <migration>',
+            },
+        ],
+        usage: [
+            'remix db wipe --force [options]',
+            'remix db migrate [--to <migration>] [options]',
+            'remix db status [options]',
+            'remix db seed [options]',
+            'remix db reset --force [options]',
+        ],
+    }, target);
+}
+function parseDbCommandArgs(argv) {
+    let [command, ...commandArgv] = argv;
+    if (!isDatabaseCommand(command)) {
+        throw unknownCommand(`db ${command}`);
+    }
+    if (command === 'migrate') {
+        let parsed = parseArgs(commandArgv, {
+            connectionEnv: connectionOption,
+            journalTable: journalOption,
+            migrations: migrationsOption,
+            to: { flag: '--to', type: 'string' },
+        }, { maxPositionals: 0 });
+        return { command, ...parsed.options };
+    }
+    if (command === 'reset') {
+        let parsed = parseArgs(commandArgv, {
+            connectionEnv: connectionOption,
+            force: { flag: '--force', type: 'boolean' },
+            journalTable: journalOption,
+            migrations: migrationsOption,
+            seed: seedOption,
+        }, { maxPositionals: 0 });
+        if (!parsed.options.force)
+            throw dbForceRequired(command);
+        let { force: _, ...options } = parsed.options;
+        return { command, ...options };
+    }
+    if (command === 'wipe') {
+        let parsed = parseArgs(commandArgv, {
+            connectionEnv: connectionOption,
+            force: { flag: '--force', type: 'boolean' },
+        }, { maxPositionals: 0 });
+        if (!parsed.options.force)
+            throw dbForceRequired(command);
+        return { command, connectionEnv: parsed.options.connectionEnv };
+    }
+    if (command === 'seed') {
+        let parsed = parseArgs(commandArgv, { connectionEnv: connectionOption, seed: seedOption }, { maxPositionals: 0 });
+        return { command, ...parsed.options };
+    }
+    let parsed = parseArgs(commandArgv, {
+        connectionEnv: connectionOption,
+        journalTable: journalOption,
+        migrations: migrationsOption,
+    }, { maxPositionals: 0 });
+    return { command, ...parsed.options };
+}
+async function resolveDbConfig(context) {
+    let configPath;
+    let config;
+    if (context.configPath !== undefined) {
+        configPath = path.resolve(context.cwd, context.configPath);
+        config = await context.loadConfig();
+    }
+    else {
+        let configDir = await findAppRoot(context.cwd, 'remix.json');
+        if (configDir === null)
+            throw remixConfigNotFound(path.join(context.cwd, 'remix.json'));
+        configPath = path.join(configDir, 'remix.json');
+        config = await loadRemixConfig(configDir, undefined);
+    }
+    if (config.db === undefined)
+        throw dbConfigRequired(configPath);
+    return { config: config.db, configDir: path.dirname(configPath) };
+}
+function resolveDatabaseCommandPlan(invocation, config, cwd) {
+    let adapter = overrideConnection(config.adapter, invocation.connectionEnv, cwd);
+    let migrations = invocation.migrations
+        ? path.resolve(cwd, invocation.migrations)
+        : config.migrations?.directory;
+    let journalTable = invocation.journalTable ?? config.migrations?.journalTable;
+    let seed = invocation.seed ? path.resolve(cwd, invocation.seed) : config.seed;
+    if ((invocation.command === 'migrate' ||
+        invocation.command === 'reset' ||
+        invocation.command === 'status') &&
+        migrations === undefined) {
+        throw invalidOptionValue(`Database command "${invocation.command}" requires db.migrations.directory or --migrations`);
+    }
+    if (invocation.command === 'seed' && seed === undefined) {
+        throw invalidOptionValue('Database command "seed" requires db.seed or --seed');
+    }
+    return {
+        adapter,
+        command: invocation.command,
+        journalTable,
+        migrations,
+        seed,
+        to: invocation.to,
+    };
+}
+function overrideConnection(adapter, environmentName, cwd) {
+    if (environmentName === undefined)
+        return adapter;
+    if (adapter.type === 'sqlite') {
+        // Resolve a relative sqlite filename here, against the directory the
+        // command was invoked from (like --migrations and --seed). Filenames from
+        // remix.json resolve against the config directory instead, which would
+        // silently retarget the path.
+        let filename = process.env[environmentName];
+        if (filename === undefined || filename === '') {
+            throw invalidOptionValue(`Database environment variable ${environmentName} is not set`);
+        }
+        return {
+            ...adapter,
+            filename: filename === ':memory:' ? filename : path.resolve(cwd, filename),
+        };
+    }
+    if (adapter.type === 'postgres') {
+        return { ...adapter, connectionString: { env: environmentName } };
+    }
+    return { ...adapter, uri: { env: environmentName } };
+}
+async function runDatabaseCommand(plan, configDir) {
+    let db = await createConfiguredDatabase(plan.adapter, configDir);
+    let result;
+    try {
+        result = await executeDatabaseCommand(plan, db);
+    }
+    catch (error) {
+        try {
+            await db.close();
+        }
+        catch (closeError) {
+            throw new AggregateError([error, closeError], 'Database command and close both failed', {
+                cause: error,
+            });
+        }
+        throw error;
+    }
+    await db.close();
+    return result;
+}
+async function executeDatabaseCommand(plan, db) {
+    if (plan.command === 'wipe') {
+        return runRemixDb({ command: plan.command, db });
+    }
+    if (plan.command === 'seed') {
+        if (plan.seed === undefined) {
+            throw invalidOptionValue('Database command "seed" requires db.seed or --seed');
+        }
+        return runRemixDb({ command: plan.command, db, seed: await loadSeed(plan.seed) });
+    }
+    if (plan.migrations === undefined) {
+        throw invalidOptionValue(`Database command "${plan.command}" requires db.migrations.directory or --migrations`);
+    }
+    let migrations = await loadMigrations(plan.migrations);
+    if (plan.command === 'migrate') {
+        return runRemixDb({
+            command: plan.command,
+            db,
+            migrations,
+            to: plan.to,
+            journalTable: plan.journalTable,
+        });
+    }
+    if (plan.command === 'reset') {
+        let seed = plan.seed === undefined ? undefined : await loadSeed(plan.seed);
+        return runRemixDb({
+            command: plan.command,
+            db,
+            migrations,
+            seed,
+            journalTable: plan.journalTable,
+        });
+    }
+    return runRemixDb({
+        command: plan.command,
+        db,
+        migrations,
+        journalTable: plan.journalTable,
+    });
+}
+async function createConfiguredDatabase(adapter, configDir) {
+    // Adapter packages are imported lazily because their database drivers are
+    // optional peer dependencies; only the configured adapter's driver needs to
+    // be installed.
+    if (adapter.type === 'sqlite') {
+        let { createSqliteDatabase } = await import('@remix-run/data-table-sqlite');
+        let filename = resolveDbString(adapter.filename);
+        if (filename !== ':memory:') {
+            // Filenames from remix.json are config-relative; explicit flag overrides
+            // arrive here already resolved against the invocation directory.
+            filename = path.resolve(configDir, filename);
+            await fs.mkdir(path.dirname(filename), { recursive: true });
+        }
+        return createSqliteDatabase({
+            filename,
+            foreignKeys: adapter.foreignKeys,
+            busyTimeout: adapter.busyTimeout,
+        });
+    }
+    if (adapter.type === 'postgres') {
+        let { createPostgresDatabase } = await import('@remix-run/data-table-postgres');
+        return createPostgresDatabase({ connectionString: resolveDbString(adapter.connectionString) }, {
+            maintenanceDatabase: adapter.maintenanceDatabase,
+            template: adapter.template,
+        });
+    }
+    let { createMysqlDatabase } = await import('@remix-run/data-table-mysql');
+    return createMysqlDatabase({ uri: resolveDbString(adapter.uri), multipleStatements: true }, { characterSet: adapter.characterSet, collation: adapter.collation });
+}
+function resolveDbString(value) {
+    if (typeof value === 'string')
+        return value;
+    // An env var that is set but empty is treated as unset so it falls back to
+    // the configured default instead of producing an empty connection value.
+    let resolved = process.env[value.env] || value.default;
+    if (resolved === undefined || resolved === '') {
+        throw invalidOptionValue(`Database environment variable ${value.env} is not set`);
+    }
+    return resolved;
+}

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

@@ -1,4 +1,9 @@
 import type { CliContext } from '../cli-context.ts';
+import { type RunRemixDoctorOptions } from '../doctor/run.ts';
+import type { RemixDoctorCommandConfig } from '../remix-config.ts';
+type DoctorCommandOptions = Pick<RunRemixDoctorOptions, 'fix' | 'json' | 'strict'>;
 export declare function runDoctorCommand(argv: string[], context: CliContext): Promise<number>;
 export declare function getDoctorCommandHelpText(target?: NodeJS.WriteStream): string;
+export declare function resolveDoctorCommandOptions(argv: string[], config: RemixDoctorCommandConfig | undefined): DoctorCommandOptions;
+export {};
 //# sourceMappingURL=doctor.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../../src/lib/commands/doctor.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AACnD,OAAO,EAAkB,KAAK,qBAAqB,EAAE,MAAM,kBAAkB,CAAA;AAI7E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAA;AAElE,KAAK,oBAAoB,GAAG,IAAI,CAAC,qBAAqB,EAAE,KAAK,GAAG,MAAM,GAAG,QAAQ,CAAC,CAAA;AAElF,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAoB3F;AAED,wBAAgB,wBAAwB,CAAC,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CA0B5F;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,MAAM,EAAE,EACd,MAAM,EAAE,wBAAwB,GAAG,SAAS,GAC3C,oBAAoB,CAuBtB"}

package/dist/lib/commands/doctor.js

@@ -1,65 +1,24 @@
-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 = {
-    actions: {
-        complete: 'actions',
-        running: 'Checking actions',
-    },
-    environment: {
-        complete: 'environment',
-        running: 'Checking environment',
-    },
-    project: {
-        complete: 'project',
-        running: 'Checking project',
-    },
-};
+import { runRemixDoctor } from '../doctor/run.js';
+import { renderCliError, toCliError } from '../errors.js';
+import { formatHelpText } from '../help-text.js';
+import { parseArgs } from '../parse-args.js';
 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;
+        let config = await context.loadConfig();
+        let options = resolveDoctorCommandOptions(argv, config.doctor);
+        return await runRemixDoctor({
+            ...options,
+            cwd: context.cwd,
+            remixVersion: context.remixVersion,
+        });
     }
     catch (error) {
-        progress?.writeSummaryGap();
         process.stderr.write(renderCliError(toCliError(error), { helpText: getDoctorCommandHelpText(process.stderr) }));
-        reporter?.finish();
         return 1;
     }
 }
@@ -78,216 +37,32 @@ export function getDoctorCommandHelpText(target = process.stdout) {
                 description: 'Exit with status 1 when warning-level findings are present',
                 label: '--strict',
             },
-            { description: 'Apply low-risk project and action fixes', label: '--fix' },
+            {
+                description: 'Do not exit with status 1 when warning-level findings are present',
+                label: '--no-strict',
+            },
+            { description: 'Apply available low-risk fixes', label: '--fix' },
         ],
         usage: ['remix doctor [--json] [--strict] [--fix] [--no-color]'],
     }, target);
 }
-function parseDoctorCommandArgs(argv) {
+export function resolveDoctorCommandOptions(argv, config) {
     let parsed = parseArgs(argv, {
         fix: { flag: '--fix', type: 'boolean' },
         json: { flag: '--json', type: 'boolean' },
+        noStrict: { flag: '--no-strict', type: 'boolean' },
         strict: { flag: '--strict', type: 'boolean' },
     }, { maxPositionals: 0 });
+    let strict = config?.strict ?? false;
+    for (let arg of argv) {
+        if (arg === '--strict')
+            strict = true;
+        if (arg === '--no-strict')
+            strict = false;
+    }
     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 actionsSuite = createSkippedDoctorSuite('actions', 'Blocked by environment warnings.');
-        suites.push(projectSuite, actionsSuite);
-        progress?.skip(projectSuite.name, projectSuite.reason);
-        writeDoctorSuiteDetails(reporter, projectSuite);
-        progress?.writeSummaryGap();
-        progress?.skip(actionsSuite.name, actionsSuite.reason);
-        writeDoctorSuiteDetails(reporter, actionsSuite);
-        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 actionsSuite = createSkippedDoctorSuite('actions', 'Blocked by project warnings.');
-        suites.push(actionsSuite);
-        progress?.skip(actionsSuite.name, actionsSuite.reason);
-        writeDoctorSuiteDetails(reporter, actionsSuite);
-        progress?.writeSummaryGap();
-        return {
-            appRoot: environment.projectRoot,
-            appliedFixes,
-            findings,
-            remainingFindings: findings,
-            routesFile,
-            suites,
-        };
-    }
-    let actions = await runDoctorSuite(progress, 'actions', 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('actions', remainingFindings);
-        if (suiteAppliedFixes.length > 0) {
-            suite.appliedFixes = suiteAppliedFixes;
-        }
-        return { appliedFixes: suiteAppliedFixes, suite };
-    });
-    findings.push(...actions.suite.findings);
-    appliedFixes.push(...(actions.appliedFixes ?? []));
-    suites.push(actions.suite);
-    writeDoctorSuiteDetails(reporter, actions.suite);
-    progress?.writeSummaryGap();
-    let report = {
-        appRoot: environment.projectRoot,
-        findings,
-        routesFile,
-        suites,
+        strict,
     };
-    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.map

@@ -1 +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"}
+{"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,CAoClF;AAED,wBAAgB,sBAAsB,CAAC,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAkB1F"}