@remix-run/cli 0.3.4 → 0.5.0

package/src/lib/commands/doctor.ts

@@ -1,50 +1,13 @@
-import * as path from 'node:path'
 import * as process from 'node:process'
 
-import { checkControllerConventions } from '../doctor/controllers.ts'
 import type { CliContext } from '../cli-context.ts'
-import { checkEnvironment, getEnvironmentFixPlans } from '../doctor/environment.ts'
-import { applyDoctorFixPlans } from '../doctor/fixes.ts'
-import { checkProject, getProjectFixPlans } from '../doctor/project.ts'
-import {
-  createDoctorSuite,
-  createSkippedDoctorSuite,
-  type DoctorAppliedFix,
-  type DoctorFinding,
-  type DoctorReport,
-  type DoctorSuiteName,
-  type DoctorSuiteResult,
-} from '../doctor/types.ts'
+import { runRemixDoctor, type RunRemixDoctorOptions } from '../doctor/run.ts'
 import { renderCliError, toCliError } from '../errors.ts'
 import { formatHelpText } from '../help-text.ts'
 import { parseArgs } from '../parse-args.ts'
-import {
-  createCommandReporter,
-  createStepProgressReporter,
-  type CommandReporter,
-  type StepProgressReporter,
-} from '../reporter.ts'
+import type { RemixDoctorCommandConfig } from '../remix-config.ts'
 
-const DOCTOR_SUITE_LABELS = {
-  actions: {
-    complete: 'actions',
-    running: 'Checking actions',
-  },
-  environment: {
-    complete: 'environment',
-    running: 'Checking environment',
-  },
-  project: {
-    complete: 'project',
-    running: 'Checking project',
-  },
-} satisfies Record<DoctorSuiteName, string | { complete: string; running: string }>
-
-interface DoctorCommandOptions {
-  fix: boolean
-  json: boolean
-  strict: boolean
-}
+type DoctorCommandOptions = Pick<RunRemixDoctorOptions, 'fix' | 'json' | 'strict'>
 
 export async function runDoctorCommand(argv: string[], context: CliContext): Promise<number> {
   if (argv.includes('-h') || argv.includes('--help')) {
@@ -52,43 +15,18 @@ export async function runDoctorCommand(argv: string[], context: CliContext): Pro
     return 0
   }
 
-  let reporter: CommandReporter | null = null
-  let progress: StepProgressReporter<DoctorSuiteName> | null = 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
   }
 }
@@ -109,7 +47,11 @@ export function getDoctorCommandHelpText(target: NodeJS.WriteStream = process.st
           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]'],
     },
@@ -117,274 +59,30 @@ export function getDoctorCommandHelpText(target: NodeJS.WriteStream = process.st
   )
 }
 
-function parseDoctorCommandArgs(argv: string[]): DoctorCommandOptions {
+export function resolveDoctorCommandOptions(
+  argv: string[],
+  config: RemixDoctorCommandConfig | undefined,
+): DoctorCommandOptions {
   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: StepProgressReporter<DoctorSuiteName> | null,
-  options: DoctorCommandOptions,
-  reporter: CommandReporter | null,
-  context: CliContext,
-): Promise<DoctorReport> {
-  let cwd = context.cwd
-  let appliedFixes: DoctorAppliedFix[] = []
-  let environment = await runDoctorSuite(progress, 'environment', async () => {
-    let result = await checkEnvironment(cwd)
-    let suiteAppliedFixes: DoctorAppliedFix[] = []
-    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: DoctorSuiteResult[] = [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: DoctorAppliedFix[] = []
-    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: DoctorAppliedFix[] = []
-
-    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: DoctorReport = {
-    appRoot: environment.projectRoot,
-    findings,
-    routesFile,
-    suites,
-  }
-
-  if (options.fix) {
-    report.appliedFixes = appliedFixes
-    report.remainingFindings = findings
-  }
-
-  return report
-}
-
-function hasWarningFindings(findings: DoctorFinding[]): boolean {
-  return findings.some((finding) => finding.severity === 'warn')
-}
-
-function formatAppliedFix(appliedFix: DoctorAppliedFix): string {
-  if (appliedFix.kind === 'update-file') {
-    return `Updated ${appliedFix.path}`
-  }
-
-  return `Created ${appliedFix.path}`
-}
-
-async function runDoctorSuite<
-  result extends { appliedFixes?: DoctorAppliedFix[]; suite: DoctorSuiteResult },
->(
-  progress: StepProgressReporter<DoctorSuiteName> | null,
-  label: DoctorSuiteName,
-  callback: () => Promise<result>,
-): Promise<result> {
-  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: CommandReporter,
-): StepProgressReporter<DoctorSuiteName> {
-  return createStepProgressReporter(reporter.status, DOCTOR_SUITE_LABELS)
-}
-
-function writeDoctorReport(reporter: CommandReporter, report: DoctorReport): void {
-  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.')
+    strict,
   }
-
-  reporter.out.line(`Summary: ${warningCount} warnings, ${adviceCount} advice.`)
-}
-
-function writeDoctorSuiteDetails(reporter: CommandReporter | null, suite: DoctorSuiteResult): void {
-  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/src/lib/commands/help.ts

@@ -27,6 +27,7 @@ export function getCliHelpText(target: NodeJS.WriteStream = process.stdout): str
         { description: 'Print shell completion scripts for Remix', label: 'completion' },
         { description: 'Show help for Remix commands', label: 'help [command]' },
         { description: 'Create a new Remix project', label: 'new <name>' },
+        { description: 'Manage the current app database', label: 'db <command>' },
         { description: 'Check project health for the current project', label: 'doctor' },
         { description: 'Show the route tree for the current project', label: 'routes' },
         { description: 'Run tests for the current project', label: 'test [glob]' },
@@ -37,6 +38,7 @@ export function getCliHelpText(target: NodeJS.WriteStream = process.stdout): str
         'remix help',
         'remix help completion',
         'remix help doctor',
+        'remix db status',
         'remix doctor',
         'remix new my-remix-app',
         'remix new my-remix-app --app-name "My Remix App"',
@@ -45,6 +47,7 @@ export function getCliHelpText(target: NodeJS.WriteStream = process.stdout): str
         'remix version',
       ],
       options: [
+        { description: 'Use a custom Remix config file', label: '--config <path>' },
         { description: 'Show help', label: '-h, --help' },
         { description: 'Disable ANSI color output', label: '--no-color' },
         { description: 'Show version', label: '-v, --version' },
@@ -62,6 +65,7 @@ export function getHelpCommandHelpText(target: NodeJS.WriteStream = process.stdo
       examples: [
         'remix help',
         'remix help completion',
+        'remix help db',
         'remix help doctor',
         'remix help new',
         'remix help routes',
@@ -100,6 +104,11 @@ async function getCommandHelpText(argv: string[]): Promise<string> {
     return getDoctorCommandHelpText()
   }
 
+  if (command === 'db' && rest.length === 0) {
+    let { getDbCommandHelpText } = await import('./db.ts')
+    return getDbCommandHelpText()
+  }
+
   if (command === 'routes' && rest.length === 0) {
     let { getRoutesCommandHelpText } = await import('./routes.ts')
     return getRoutesCommandHelpText()
@@ -107,7 +116,7 @@ async function getCommandHelpText(argv: string[]): Promise<string> {
 
   if (command === 'test' && rest.length === 0) {
     let { getTestCommandHelpText } = await import('./test.ts')
-    return await getTestCommandHelpText()
+    return getTestCommandHelpText()
   }
 
   if (command === 'version' && rest.length === 0) {