@thegetty/quire-cli 1.0.0-rc.37 → 1.0.0-rc.39

package/src/commands/info.test.js

@@ -23,16 +23,8 @@ test.beforeEach((t) => {
   // Mock testcwd helper
   t.context.mockTestcwd = t.context.sandbox.stub()
 
-  // Mock execaCommand for external commands
-  t.context.mockExecaCommand = t.context.sandbox.stub()
-  t.context.mockExecaCommand.withArgs('quire --version').resolves({ stdout: '1.0.0-rc.33' })
-  t.context.mockExecaCommand.withArgs('npm --version').resolves({ stdout: '10.2.4' })
-
-  // Mock os module
-  t.context.mockOs = {
-    type: t.context.sandbox.stub().returns('Darwin'),
-    release: t.context.sandbox.stub().returns('23.0.0')
-  }
+  // Mock packageConfig binPath
+  t.context.mockBinPath = t.context.sandbox.stub().returns('/usr/local/bin/quire')
 
   // Mock fs module
   t.context.mockFs = {
@@ -72,16 +64,15 @@ test.afterEach.always((t) => {
 })
 
 test('info command should validate Quire project in preAction', async (t) => {
-  const { sandbox, mockLogger, mockTestcwd, mockConfig, mockExecaCommand, mockOs, mockFs } = t.context
+  const { sandbox, mockLogger, mockTestcwd, mockConfig, mockBinPath, mockFs } = t.context
 
   const { default: InfoCommand } = await esmock('./info.js', {
     '#helpers/test-cwd.js': {
       default: mockTestcwd
     },
-    'execa': {
-      execaCommand: mockExecaCommand
+    '#src/packageConfig.js': {
+      binPath: mockBinPath
     },
-    'node:os': mockOs,
     'node:fs': mockFs
   }, {
     '#lib/logger/index.js': {
@@ -108,16 +99,15 @@ test('info command should validate Quire project in preAction', async (t) => {
 })
 
 test('info command should display project version information', async (t) => {
-  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockExecaCommand, mockOs, mockFs } = t.context
+  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockBinPath, mockFs } = t.context
 
   const { default: InfoCommand } = await esmock('./info.js', {
     '#helpers/test-cwd.js': {
       default: mockTestcwd
     },
-    'execa': {
-      execaCommand: mockExecaCommand
+    '#src/packageConfig.js': {
+      binPath: mockBinPath
     },
-    'node:os': mockOs,
     'node:fs': mockFs
   }, {
     '#lib/logger/index.js': {
@@ -135,31 +125,42 @@ test('info command should display project version information', async (t) => {
   // Verify logger.info was called with project information
   t.true(mockLogger.info.called, 'logger.info should be called')
 
-  // Check for project section header (uses current directory name)
+  // Check for project header
   const calls = mockLogger.info.getCalls()
   const hasProjectInfo = calls.some((call) =>
-    call.args[0] && call.args[0].includes('[') && call.args[0].includes(']')
+    call.args[0] && call.args[0].includes('Project:')
   )
-  t.true(hasProjectInfo, 'should display project section')
+  t.true(hasProjectInfo, 'should display project header')
 
   // Check for quire-cli version in output
   const hasCliVersion = calls.some((call) =>
     call.args[0] && call.args[0].includes('quire-cli') && call.args[0].includes('1.0.0-rc.33')
   )
   t.true(hasCliVersion, 'should display quire-cli version')
+
+  // Check for quire-11ty version in output
+  const has11tyVersion = calls.some((call) =>
+    call.args[0] && call.args[0].includes('quire-11ty')
+  )
+  t.true(has11tyVersion, 'should display quire-11ty version')
+
+  // Check for doctor tip
+  const hasDoctorTip = calls.some((call) =>
+    call.args[0] && call.args[0].includes('quire doctor')
+  )
+  t.true(hasDoctorTip, 'should display doctor tip')
 })
 
-test('info command should display system information with debug flag', async (t) => {
-  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockExecaCommand, mockOs, mockFs } = t.context
+test('info command should display starter version when available', async (t) => {
+  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockBinPath, mockFs } = t.context
 
   const { default: InfoCommand } = await esmock('./info.js', {
     '#helpers/test-cwd.js': {
       default: mockTestcwd
     },
-    'execa': {
-      execaCommand: mockExecaCommand
+    '#src/packageConfig.js': {
+      binPath: mockBinPath
     },
-    'node:os': mockOs,
     'node:fs': mockFs
   }, {
     '#lib/logger/index.js': {
@@ -172,42 +173,63 @@ test('info command should display system information with debug flag', async (t)
   command.logger = mockLogger
   command.debug = sandbox.stub()
 
-  await command.action({ debug: true }, {})
+  await command.action({}, {})
 
   // Verify logger.info was called
   t.true(mockLogger.info.called, 'logger.info should be called')
 
-  // Check for system section header
+  // Check for starter version in output (from version file)
   const calls = mockLogger.info.getCalls()
-  const hasSystemInfo = calls.some((call) =>
-    call.args[0] && call.args[0].includes('[System]')
+  const hasStarterVersion = calls.some((call) =>
+    call.args[0] && call.args[0].includes('starter')
   )
-  t.true(hasSystemInfo, 'should display system section with debug flag')
+  t.true(hasStarterVersion, 'should display starter version when available')
+})
 
-  // Check for node version in output (only shown with debug)
-  const hasNodeVersion = calls.some((call) =>
-    call.args[0] && call.args[0].includes('node')
-  )
-  t.true(hasNodeVersion, 'should display node version with debug flag')
+test('info command --debug shows installation paths', async (t) => {
+  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockBinPath, mockFs } = t.context
 
-  // Check for npm version in output (only shown with debug)
-  const hasNpmVersion = calls.some((call) =>
-    call.args[0] && call.args[0].includes('npm')
-  )
-  t.true(hasNpmVersion, 'should display npm version with debug flag')
+  const { default: InfoCommand } = await esmock('./info.js', {
+    '#helpers/test-cwd.js': {
+      default: mockTestcwd
+    },
+    '#src/packageConfig.js': {
+      binPath: mockBinPath
+    },
+    'node:fs': mockFs
+  }, {
+    '#lib/logger/index.js': {
+      default: () => mockLogger
+    }
+  })
+
+  const command = new InfoCommand()
+  command.config = mockConfig
+  command.logger = mockLogger
+  command.debug = sandbox.stub()
+
+  await command.action({ debug: true }, {})
+
+  const calls = mockLogger.info.getCalls()
+  const output = calls.map((call) => call.args[0]).join('\n')
+
+  // Check for quire-cli path
+  t.true(output.includes('/usr/local/bin/quire'), 'should display quire-cli path')
 })
 
-test('info command should hide system details without debug flag', async (t) => {
-  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockExecaCommand, mockOs, mockFs } = t.context
+test('info command --debug handles missing quire-cli in PATH', async (t) => {
+  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockFs } = t.context
+
+  // binPath returns null when executable is not found
+  const mockBinPathNotFound = sandbox.stub().returns(null)
 
   const { default: InfoCommand } = await esmock('./info.js', {
     '#helpers/test-cwd.js': {
       default: mockTestcwd
     },
-    'execa': {
-      execaCommand: mockExecaCommand
+    '#src/packageConfig.js': {
+      binPath: mockBinPathNotFound
     },
-    'node:os': mockOs,
     'node:fs': mockFs
   }, {
     '#lib/logger/index.js': {
@@ -220,23 +242,16 @@ test('info command should hide system details without debug flag', async (t) =>
   command.logger = mockLogger
   command.debug = sandbox.stub()
 
-  await command.action({}, {})
-
-  // Verify logger.info was called
-  t.true(mockLogger.info.called, 'logger.info should be called')
+  await command.action({ debug: true }, {})
 
-  // Check that system details are NOT shown without debug flag
   const calls = mockLogger.info.getCalls()
+  const output = calls.map((call) => call.args[0]).join('\n')
 
-  // Node version should not appear in non-debug output
-  const hasNodeVersion = calls.some((call) =>
-    call.args[0] && call.args[0].toLowerCase().includes('node') && !call.args[0].includes('quire')
-  )
-  t.false(hasNodeVersion, 'should not display node version without debug flag')
+  t.true(output.includes('not found in PATH'), 'should show not found message for quire-cli')
 })
 
 test('info command should handle missing version file', async (t) => {
-  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockExecaCommand, mockOs, mockFs } = t.context
+  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockBinPath, mockFs } = t.context
 
   // Setup mockFs to throw error for missing version file (simulating file not found)
   mockFs.readFileSync.callsFake((filePath, options) => {
@@ -253,10 +268,9 @@ test('info command should handle missing version file', async (t) => {
     '#helpers/test-cwd.js': {
       default: mockTestcwd
     },
-    'execa': {
-      execaCommand: mockExecaCommand
+    '#src/packageConfig.js': {
+      binPath: mockBinPath
     },
-    'node:os': mockOs,
     'node:fs': mockFs
   }, {
     '#lib/logger/index.js': {
@@ -283,7 +297,7 @@ test('info command should handle missing version file', async (t) => {
 })
 
 test('info command should handle malformed version file', async (t) => {
-  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockExecaCommand, mockOs, mockFs } = t.context
+  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockBinPath, mockFs } = t.context
 
   // Setup mockFs to return malformed JSON (simulating corrupted file)
   mockFs.readFileSync.callsFake((filePath, options) => {
@@ -300,10 +314,9 @@ test('info command should handle malformed version file', async (t) => {
     '#helpers/test-cwd.js': {
       default: mockTestcwd
     },
-    'execa': {
-      execaCommand: mockExecaCommand
+    '#src/packageConfig.js': {
+      binPath: mockBinPath
     },
-    'node:os': mockOs,
     'node:fs': mockFs
   }, {
     '#lib/logger/index.js': {
@@ -333,7 +346,7 @@ test('info command should handle malformed version file', async (t) => {
 })
 
 test('info command should read quire-11ty version from package.json', async (t) => {
-  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockExecaCommand, mockOs, mockFs } = t.context
+  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockBinPath, mockFs } = t.context
 
   // Override package.json to have specific version
   mockFs.readFileSync.callsFake((filePath, options) => {
@@ -353,10 +366,9 @@ test('info command should read quire-11ty version from package.json', async (t)
     '#helpers/test-cwd.js': {
       default: mockTestcwd
     },
-    'execa': {
-      execaCommand: mockExecaCommand
+    '#src/packageConfig.js': {
+      binPath: mockBinPath
     },
-    'node:os': mockOs,
     'node:fs': mockFs
   }, {
     '#lib/logger/index.js': {
@@ -382,8 +394,8 @@ test('info command should read quire-11ty version from package.json', async (t)
   t.true(hasEleventyVersion, 'should display quire-11ty version from package.json')
 })
 
-test('info command should log debug information when debug flag is set', async (t) => {
-  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockExecaCommand, mockOs, mockFs } = t.context
+test('info command should log debug information', async (t) => {
+  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockBinPath, mockFs } = t.context
 
   const mockDebug = sandbox.stub()
 
@@ -391,10 +403,9 @@ test('info command should log debug information when debug flag is set', async (
     '#helpers/test-cwd.js': {
       default: mockTestcwd
     },
-    'execa': {
-      execaCommand: mockExecaCommand
+    '#src/packageConfig.js': {
+      binPath: mockBinPath
     },
-    'node:os': mockOs,
     'node:fs': mockFs
   }, {
     '#lib/logger/index.js': {
@@ -407,9 +418,95 @@ test('info command should log debug information when debug flag is set', async (
   command.logger = mockLogger
   command.debug = mockDebug
 
-  await command.action({ debug: true }, {})
+  await command.action({}, {})
 
   // Verify debug was called
-  t.true(mockDebug.called, 'debug should be called with debug flag')
-  t.true(mockDebug.calledWith('called with options %O', { debug: true }))
+  t.true(mockDebug.called, 'debug should be called')
+  t.true(mockDebug.calledWith('called with options %O', {}))
+})
+
+// ─────────────────────────────────────────────────────────────────────────────
+// JSON output tests
+// ─────────────────────────────────────────────────────────────────────────────
+
+test.serial('info --json should output valid JSON with project versions', async (t) => {
+  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockBinPath, mockFs } = t.context
+  const consoleLogStub = sandbox.stub(console, 'log')
+
+  const { default: InfoCommand } = await esmock('./info.js', {
+    '#helpers/test-cwd.js': {
+      default: mockTestcwd
+    },
+    '#src/packageConfig.js': {
+      binPath: mockBinPath
+    },
+    'node:fs': mockFs
+  }, {
+    '#lib/logger/index.js': {
+      default: () => mockLogger
+    }
+  })
+
+  const command = new InfoCommand()
+  command.config = mockConfig
+  command.logger = mockLogger
+  command.debug = sandbox.stub()
+
+  await command.action({ json: true }, {})
+
+  // Should output via console.log, not logger.info
+  t.true(consoleLogStub.calledOnce, 'console.log should be called once')
+  t.false(mockLogger.info.called, 'logger.info should not be called in JSON mode')
+
+  // Parse and validate the JSON structure
+  const output = JSON.parse(consoleLogStub.firstCall.args[0])
+
+  t.truthy(output.project, 'JSON should have project section')
+
+  // Project section
+  t.is(output.project.cli, '1.0.0-rc.33')
+  t.is(output.project.quire11ty, '1.0.0')
+  t.is(output.project.starter, 'https://github.com/thegetty/quire-starter-default')
+  t.is(typeof output.project.directory, 'string')
+})
+
+test.serial('info --json should set starter to null when not available', async (t) => {
+  const { sandbox, mockLogger, mockConfig, mockTestcwd, mockBinPath, mockFs } = t.context
+  const consoleLogStub = sandbox.stub(console, 'log')
+
+  // Version file without starter
+  t.context.mockFs.readFileSync.callsFake((filePath, options) => {
+    if (filePath === './.quire-version') {
+      return JSON.stringify({ cli: '1.0.0-rc.33' })
+    }
+    if (filePath === './package.json') {
+      return t.context.packageJsonContent
+    }
+    return ''
+  })
+
+  const { default: InfoCommand } = await esmock('./info.js', {
+    '#helpers/test-cwd.js': {
+      default: mockTestcwd
+    },
+    '#src/packageConfig.js': {
+      binPath: mockBinPath
+    },
+    'node:fs': mockFs
+  }, {
+    '#lib/logger/index.js': {
+      default: () => mockLogger
+    }
+  })
+
+  const command = new InfoCommand()
+  command.config = mockConfig
+  command.logger = mockLogger
+  command.debug = sandbox.stub()
+
+  await command.action({ json: true }, {})
+
+  const output = JSON.parse(consoleLogStub.firstCall.args[0])
+
+  t.is(output.project.starter, null, 'starter should be null when not in version file')
 })

package/src/commands/pdf.js

@@ -5,6 +5,7 @@ import eleventy from '#lib/11ty/index.js'
 import generatePdf, { ENGINES } from '#lib/pdf/index.js'
 import open from 'open'
 import path from 'node:path'
+import { recordStatus } from '#lib/conf/build-status.js'
 import reporter from '#lib/reporter/index.js'
 import testcwd from '#helpers/test-cwd.js'
 import { MissingBuildOutputError } from '#src/errors/index.js'
@@ -81,10 +82,16 @@ Examples:
 
     // Generate PDF - façade handles validation, progress, and errors
     const pdfOptions = { ...options, lib: options.engine }
-    const output = await generatePdf(pdfOptions)
 
-    if (options.open) {
-      open(output)
+    try {
+      const output = await generatePdf(pdfOptions)
+      recordStatus(paths.getProjectRoot(), 'pdf', 'ok')
+      if (options.open) {
+        open(output)
+      }
+    } catch (error) {
+      recordStatus(paths.getProjectRoot(), 'pdf', 'failed')
+      throw error
     }
   }
 

package/src/commands/validate.js

@@ -25,11 +25,14 @@ export default class ValidateCommand extends Command {
 Examples:
   quire validate               Check YAML syntax in content/_data/
   quire validate --verbose     Validate with detailed file listing
+  quire validate --json        Output validation results as JSON
 
 Validates YAML files in content/_data/ directory.
 `,
     version: '1.0.0',
-    options: [],
+    options: [
+      ['--json', 'output validation results as JSON'],
+    ],
   })
 
   constructor() {
@@ -45,21 +48,50 @@ Validates YAML files in content/_data/ directory.
       .map(file => path.join(dataPath, file)
       )
 
-    let errorList = []
-    this.logger.info('Validating YAML files..')
+    const results = []
+    if (!options.json) {
+      this.logger.info('Validating YAML files..')
+    }
 
     for (const file of files) {
       try {
         yamlValidation(file)
+        results.push({ file, status: 'passed' })
       } catch (error){
-        errorList.push(error)
+        results.push({ file, status: 'failed', error: error.reason })
+      }
+    }
+
+    const errors = results.filter((r) => r.status === 'failed')
+
+    if (options.json) {
+      const output = {
+        summary: {
+          files: results.length,
+          passed: results.length - errors.length,
+          failed: errors.length,
+        },
+        files: results,
+      }
+      console.log(JSON.stringify(output, null, 2))
+
+      // Still throw so exit code reflects failure
+      if (errors.length > 0) {
+        throw new ValidationError(
+          `Validation failed with ${errors.length} error(s)`,
+          {
+            code: 'VALIDATION_FAILED',
+            suggestion: 'Fix the errors listed above and run validation again'
+          }
+        )
       }
+      return
     }
 
-    if(errorList.length > 0) {
-      errorList.forEach(err => { this.logger.error(`${err.reason}`) })
+    if (errors.length > 0) {
+      errors.forEach((r) => { this.logger.error(`${r.error}`) })
       throw new ValidationError(
-        `Validation failed with ${errorList.length} error(s)`,
+        `Validation failed with ${errors.length} error(s)`,
         {
           code: 'VALIDATION_FAILED',
           suggestion: 'Fix the errors listed above and run validation again'

package/src/commands/validate.spec.js

@@ -40,21 +40,28 @@ test('registered command has correct options', (t) => {
   const { command } = t.context
 
   // Get all options
+  const jsonOption = command.options.find((opt) => opt.long === '--json')
   const quietOption = command.options.find((opt) => opt.long === '--quiet')
   const verboseOption = command.options.find((opt) => opt.long === '--verbose')
   const debugOption = command.options.find((opt) => opt.long === '--debug')
 
   // Verify all options exist
+  t.truthy(jsonOption, '--json option should exist')
   t.truthy(quietOption, '--quiet option should exist')
   t.truthy(verboseOption, '--verbose option should exist')
   t.truthy(debugOption, '--debug option should exist')
 
   // Verify they are Option instances
+  t.true(jsonOption instanceof Option, '--json should be Option instance')
   t.true(quietOption instanceof Option, '--quiet should be Option instance')
   t.true(verboseOption instanceof Option, '--verbose should be Option instance')
   t.true(debugOption instanceof Option, '--debug should be Option instance')
 
   // Verify option properties
+  t.is(jsonOption.long, '--json')
+  t.truthy(jsonOption.description)
+  t.false(jsonOption.required, '--json should not require a value')
+
   t.is(quietOption.long, '--quiet')
   t.is(quietOption.short, '-q')
   t.truthy(quietOption.description)
@@ -76,6 +83,7 @@ test('command options are accessible via public API', (t) => {
   // Test that options can be accessed the way Commander.js does
   const optionNames = command.options.map((opt) => opt.long)
 
+  t.true(optionNames.includes('--json'))
   t.true(optionNames.includes('--quiet'))
   t.true(optionNames.includes('--verbose'))
   t.true(optionNames.includes('--debug'))