@thegetty/quire-cli 1.0.0-rc.44 → 1.0.0-rc.46

package/src/commands/doctor.js

@@ -1,251 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import Command from '#src/Command.js'
-import { withOutputModes } from '#lib/commander/index.js'
-import { clearStatus } from '#lib/conf/build-status.js'
-import { runAllChecksWithSections, checkSections, SECTION_NAMES, CHECK_IDS } from '#lib/doctor/index.js'
-import { formatHuman } from '#lib/doctor/formatters/human.js'
-import { formatJson } from '#lib/doctor/formatters/json.js'
-
-/**
- * Map section name to its check IDs
- */
-const SECTION_CHECK_MAP = Object.fromEntries(
-  checkSections.map((s) => [s.name.toLowerCase(), s.checks.map((c) => c.id)])
-)
-
-/**
- * Quire CLI `doctor` Command
- *
- * Diagnose common issues with the Quire environment and project setup.
- *
- * @class      DoctorCommand
- * @extends    {Command}
- */
-export default class DoctorCommand extends Command {
-  static definition = withOutputModes({
-    name: 'doctor',
-    aliases: ['checkup', 'check', 'diagnostic', 'health'],
-    description: 'Diagnose common issues with your Quire setup',
-    summary: 'check environment and project health',
-    docsLink: 'quire-commands/#troubleshooting',
-    helpText: `
-Runs diagnostic checks organized into four sections:
-  • Environment: os, cli, node, runtime, npm, git
-  • Tools: prince, pandoc
-  • Project: project, deps, 11ty, data
-  • Outputs: build, pdf, epub
-
-Examples:
-  quire doctor                          Run all diagnostic checks
-  quire doctor all                      Run all checks (same as no argument)
-  quire doctor environment              Check environment section only
-  quire doctor node                     Check Node.js version only
-  quire doctor node git                 Check multiple items
-  quire doctor --errors                 Show only failed checks
-  quire doctor --warnings               Show only warnings
-  quire doctor --verbose                Show additional details (paths, versions)
-  quire doctor --json                   Output results as JSON (to stdout)
-  quire doctor --json report.json       Save JSON results to file
-  quire doctor --reset                  Clear stored build status
-  quire checkup                         Alias for doctor command
-
-CI/Scripting:
-  quire doctor --quiet                  Exit code only (0=success, 1=failure)
-  quire doctor --quiet --json out.json  Save JSON report silently
-`,
-    version: '1.0.0',
-    args: [
-      [
-        '[checks...]',
-        `run specific check(s): all, ${SECTION_NAMES.join(', ')}, or ${CHECK_IDS.join(', ')}`,
-      ],
-    ],
-    options: [
-      ['-e, --errors', 'show only failed checks'],
-      ['-w, --warnings', 'show only warnings'],
-      ['--json [file]', 'output results as JSON (to standard out or a file)'],
-      ['--reset', 'clear stored build status for the current project'],
-    ],
-  })
-
-  constructor() {
-    super(DoctorCommand.definition)
-  }
-
-  async action(checks, options, command) {
-    this.debug('called with checks=%O options=%O', checks, options)
-
-    // --reset: clear stored build status and exit without running checks
-    if (options.reset) {
-      clearStatus(process.cwd())
-      if (!options.quiet) {
-        this.logger.info('Build status cleared for this project')
-      }
-      return
-    }
-
-    // Parse variadic checks argument into sections and individual checks
-    const filterOptions = { sections: null, checks: null }
-    let label = 'diagnostic checks'
-
-    if (checks.length > 0) {
-      const values = checks.map((v) => v.toLowerCase())
-
-      // "all" means no filtering
-      if (!values.includes('all')) {
-        // Separate section names from individual check IDs
-        const sectionValues = values.filter((v) => SECTION_NAMES.includes(v))
-        const checkValues = values.filter((v) => CHECK_IDS.includes(v))
-
-        // If we have section names, use them as section filter
-        if (sectionValues.length > 0 && checkValues.length === 0) {
-          filterOptions.sections = sectionValues
-          label = sectionValues.length === 1
-            ? `${sectionValues[0]} checks`
-            : `${sectionValues.join(', ')} checks`
-        } else if (checkValues.length > 0) {
-          // If we have individual checks (with or without sections),
-          // expand sections to their check IDs and combine
-          const expandedChecks = new Set(checkValues)
-          for (const section of sectionValues) {
-            const sectionCheckIds = SECTION_CHECK_MAP[section] || []
-            sectionCheckIds.forEach((id) => expandedChecks.add(id))
-          }
-          filterOptions.checks = [...expandedChecks]
-          label = filterOptions.checks.length === 1
-            ? `${filterOptions.checks[0]} check`
-            : `${filterOptions.checks.join(', ')} checks`
-        }
-      }
-    }
-
-    const sections = await runAllChecksWithSections(filterOptions)
-
-    // JSON output mode (options.json is true for flag-only, or string for file path)
-    if (options.json) {
-      this.outputJson(sections, options)
-      return
-    }
-
-    // Quiet mode without JSON: just exit with appropriate code
-    if (options.quiet) {
-      this.outputQuiet(sections)
-      return
-    }
-
-    // Human-readable output
-    this.outputHuman(sections, options, label)
-  }
-
-  /**
-   * Quiet mode: no output, just exit code
-   * @param {Array} sections - Check results organized by section
-   */
-  outputQuiet(sections) {
-    const { exitCode } = formatJson(sections, {})
-    if (exitCode !== 0) {
-      process.exitCode = exitCode
-    }
-  }
-
-  /**
-   * Output results as JSON for programmatic consumption
-   * @param {Array} sections - Check results organized by section
-   * @param {Object} options - Command options (options.json is true or filename string)
-   */
-  outputJson(sections, options) {
-    const { json, exitCode } = formatJson(sections, {
-      errors: options.errors,
-      warnings: options.warnings,
-      verbose: options.verbose,
-    })
-
-    // Write to file (if string path provided) or stdout (if just --json flag)
-    if (typeof options.json === 'string') {
-      const outputPath = path.resolve(options.json)
-      fs.writeFileSync(outputPath, json + '\n')
-      if (!options.quiet) {
-        this.logger.info(`Results written to ${outputPath}`)
-      }
-    } else if (!options.quiet) {
-      // Write to stdout (bypassing logger formatting) unless quiet mode
-      console.log(json)
-    }
-
-    // Set exit code if any checks failed
-    if (exitCode !== 0) {
-      process.exitCode = exitCode
-    }
-  }
-
-  /**
-   * Map log level to console method for direct output
-   *
-   * Nota bene: doctor output bypasses the logger to avoid the `[quire]`
-   * prefix on every line. The formatter already handles its own formatting
-   * (icons, indentation, section headers). Using console methods directly
-   * routes output to the correct output stream (stdout for info, stderr for
-   * warn/error) without logger prefix and level labels.
-   */
-  static #consoleMethods = {
-    info: console.log,
-    warn: console.warn,
-    error: console.error,
-  }
-
-  /**
-   * Output results in human-readable format
-   * @param {Array} sections - Check results organized by section
-   * @param {Object} options - Command options
-   * @param {string} label - Description of checks being run
-   */
-  outputHuman(sections, options, label) {
-    const { lines, summary, key, exitCode, isEmpty } = formatHuman(sections, {
-      errors: options.errors,
-      warnings: options.warnings,
-      verbose: options.verbose,
-      label,
-    })
-
-    // Handle case where filters excluded all results
-    if (isEmpty) {
-      for (const { text, level } of lines) {
-        this.#log(level, text)
-      }
-      return
-    }
-
-    // Output all formatted lines routed by log level
-    for (const { text, level } of lines) {
-      this.#log(level, text)
-    }
-
-    // Output summary
-    if (summary) {
-      this.#log(summary.level, summary.text)
-    }
-
-    // Output symbol key
-    if (key) {
-      this.#log('info', '')
-      this.#log(key.level, key.text)
-    }
-
-    // Set exit code if any checks failed
-    if (exitCode !== 0) {
-      process.exitCode = exitCode
-    }
-  }
-
-  /**
-   * Write a line to the console, routed by log level
-   *
-   * @param {string} level - Log level (info, warn, error)
-   * @param {string} text - Text to output
-   */
-  #log(level, text) {
-    const method = DoctorCommand.#consoleMethods[level] || console.log
-    method(text)
-  }
-}

package/src/commands/doctor.spec.js

@@ -1,115 +0,0 @@
-import { Command, Option } from 'commander'
-import program from '#src/main.js'
-import test from 'ava'
-
-/**
- * Command Contract/Interface Tests
- *
- * Verifies the command's public API and Commander.js integration.
- * @see docs/testing-commands.md
- */
-
-test.before((t) => {
-  // Get the registered command (from program.commands) once and share across all tests
-  t.context.command = program.commands.find((cmd) => cmd.name() === 'doctor')
-})
-
-test('command is registered in CLI program', (t) => {
-  const { command } = t.context
-
-  t.truthy(command, 'command "doctor" should be registered in program')
-  t.true(command instanceof Command, 'registered command should be Commander.js Command instance')
-})
-
-test('registered command has correct metadata', (t) => {
-  const { command } = t.context
-
-  t.is(command.name(), 'doctor')
-  t.truthy(command.description())
-  t.is(typeof command._actionHandler, 'function', 'command should have action handler')
-})
-
-test('registered command has correct aliases', (t) => {
-  const { command } = t.context
-  const aliases = command.aliases()
-
-  t.true(aliases.includes('checkup'), 'should have "checkup" alias')
-  t.true(aliases.includes('diagnostic'), 'should have "diagnostic" alias')
-  t.true(aliases.includes('health'), 'should have "health" alias')
-})
-
-test('registered command has variadic checks argument', (t) => {
-  const { command } = t.context
-  const registeredArguments = command.registeredArguments
-
-  t.is(registeredArguments.length, 1, 'doctor command should have one argument')
-
-  const checksArg = registeredArguments[0]
-  t.is(checksArg.name(), 'checks', 'argument should be named "checks"')
-  t.false(checksArg.required, 'checks argument should be optional')
-  t.true(checksArg.variadic, 'checks argument should be variadic')
-  t.truthy(checksArg.description, 'checks argument should have a description')
-  t.true(checksArg.description.includes('all'), 'description should mention "all"')
-  t.true(checksArg.description.includes('environment'), 'description should mention section names')
-  t.true(checksArg.description.includes('node'), 'description should mention check IDs')
-})
-
-test('registered command has correct options', (t) => {
-  const { command } = t.context
-
-  // Doctor command has 4 local + 4 shared output mode options = 8
-  // Local: --errors, --warnings, --json, --reset
-  // Shared (via withOutputModes): --quiet, --verbose, --progress, --debug
-  t.is(command.options.length, 8, 'doctor command should have 8 options')
-
-  // Verify --errors option
-  const errorsOption = command.options.find((opt) => opt.long === '--errors')
-  t.truthy(errorsOption, '--errors option should exist')
-  t.true(errorsOption instanceof Option, '--errors should be Option instance')
-  t.is(errorsOption.short, '-e', '--errors should have -e short flag')
-  t.truthy(errorsOption.description)
-
-  // Verify --warnings option
-  const warningsOption = command.options.find((opt) => opt.long === '--warnings')
-  t.truthy(warningsOption, '--warnings option should exist')
-  t.true(warningsOption instanceof Option, '--warnings should be Option instance')
-  t.is(warningsOption.short, '-w', '--warnings should have -w short flag')
-  t.truthy(warningsOption.description)
-
-  // Verify --json option with optional file parameter
-  const jsonOption = command.options.find((opt) => opt.long === '--json')
-  t.truthy(jsonOption, '--json option should exist')
-  t.true(jsonOption instanceof Option, '--json should be Option instance')
-  t.truthy(jsonOption.description)
-  t.true(jsonOption.description.includes('JSON'), 'description should mention JSON')
-  t.true(jsonOption.description.includes('file'), 'description should mention file output')
-
-  // Verify --reset option
-  const resetOption = command.options.find((opt) => opt.long === '--reset')
-  t.truthy(resetOption, '--reset option should exist')
-  t.true(resetOption instanceof Option, '--reset should be Option instance')
-  t.truthy(resetOption.description)
-
-  // Verify shared output mode options (via withOutputModes)
-  const quietOption = command.options.find((opt) => opt.long === '--quiet')
-  t.truthy(quietOption, '--quiet option should exist')
-  t.is(quietOption.short, '-q', '--quiet should have -q short flag')
-
-  const verboseOption = command.options.find((opt) => opt.long === '--verbose')
-  t.truthy(verboseOption, '--verbose option should exist')
-  t.is(verboseOption.short, '-v', '--verbose should have -v short flag')
-
-  const progressOption = command.options.find((opt) => opt.long === '--progress')
-  t.truthy(progressOption, '--progress option should exist (hidden alias for --verbose)')
-
-  const debugOption = command.options.find((opt) => opt.long === '--debug')
-  t.truthy(debugOption, '--debug option should exist')
-})
-
-test('command is accessible via checkup alias', (t) => {
-  // Find command by alias
-  const command = program.commands.find((cmd) => cmd.aliases().includes('checkup'))
-
-  t.truthy(command, 'command should be findable via "checkup" alias')
-  t.is(command.name(), 'doctor', 'alias should resolve to doctor command')
-})