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

package/src/commands/epub.js

@@ -5,6 +5,7 @@ import eleventy from '#lib/11ty/index.js'
 import fs from 'fs-extra'
 import generateEpub, { ENGINES } from '#lib/epub/index.js'
 import open from 'open'
+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'
@@ -84,9 +85,15 @@ Examples:
     // Pass engine as lib (matching lib/pdf interface)
     // Reporter lifecycle is owned by the façade (lib/epub/index.js)
     const epubOptions = { ...options, lib: options.engine }
-    const output = await generateEpub(epubOptions)
 
-    if (fs.existsSync(output) && options.open) open(output)
+    try {
+      const output = await generateEpub(epubOptions)
+      recordStatus(paths.getProjectRoot(), 'epub', 'ok')
+      if (fs.existsSync(output) && options.open) open(output)
+    } catch (error) {
+      recordStatus(paths.getProjectRoot(), 'epub', 'failed')
+      throw error
+    }
   }
 
   preAction(thisCommand, actionCommand) {

package/src/commands/info.js

@@ -1,34 +1,52 @@
 import Command from '#src/Command.js'
-import npm from '#lib/npm/index.js'
-import { execa } from 'execa'
+import { withOutputModes } from '#lib/commander/index.js'
+import { binPath } from '#src/packageConfig.js'
 import fs from 'node:fs'
-import os from 'node:os'
 import path from 'node:path'
 import testcwd from '#helpers/test-cwd.js'
 
 /**
  * Quire CLI `info` Command
  *
- * Runs the Eleventy `info` command to list the quire-cli, quire-11ty, node, and npm versions.
+ * Display version information for the current Quire project.
+ * Shows the versions of quire-cli and quire-11ty that the project was
+ * created with, plus the starter template version.
+ *
+ * With --debug, also shows the full filesystem path to the quire-cli
+ * executable.
+ *
+ * For system environment information (OS, Node.js, npm, Git),
+ * use the `quire doctor` command instead.
  *
  * @class      InfoCommand
  * @extends    {Command}
  */
 export default class InfoCommand extends Command {
-  static definition = {
+  static definition = withOutputModes({
     name: 'info',
-    description: 'List Quire cli, quire-11ty, and node versions',
-    summary: 'show version information',
+    description: 'Display version information for the current project',
+    summary: 'show project version information',
     docsLink: 'quire-commands/#get-help',
     helpText: `
+Shows the versions used when this project was created:
+  • quire-cli version that created the project
+  • quire-11ty version installed in the project
+  • starter template version (if available)
+
+For system environment checks (OS, Node.js, npm, Git),
+use 'quire doctor' instead.
+
 Example:
-  quire info --debug    Include node, npm, and OS versions
+  quire info           Show project versions
+  quire info --debug   Include installation paths
+  quire info --json    Output version information as JSON
+  quire doctor         Check environment and project health
 `,
     version: '1.0.0',
     options: [
-      ['--debug', 'include os versions in output']
+      ['--json', 'output version information as JSON'],
     ],
-  }
+  })
 
   constructor() {
     super(InfoCommand.definition)
@@ -43,79 +61,69 @@ Example:
 
     try {
       const versionFileData = fs.readFileSync(versionFileName, { encoding: 'utf8' })
-
-      versionInfo = JSON.parse(versionFileData)      
+      versionInfo = JSON.parse(versionFileData)
     } catch (error) {
       this.logger.warn(
         `This project was generated with the quire-cli prior to version 1.0.0.rc-8. Updating the version file to the new format, though this project's version file will not contain specific starter version information.`
       )
-
       fs.writeFileSync(versionFileName, JSON.stringify(versionInfo))
     }
 
     const { name: projectDirectory } = path.parse(process.cwd())
 
-    const versions = [
-      {
-        title: `[${projectDirectory}]`,
-        items: [
-          {
-            name: 'quire-cli',
-            get: () => versionInfo.cli,
-          },
-          {
-            name: 'quire-11ty',
-            get: () => {
-              const { version } = JSON.parse(fs.readFileSync('./package.json'))
-              return version
-            },
-          },
-          {
-            name: 'starter',
-            get: () => versionInfo.starter,
-          },
-        ],
-      },
-      {
-        title: '[System]',
-        items: [
-          {
-            name: 'quire-cli',
-            get: async () => {
-              const { stdout } = await execa('quire', ['--version'])
-              return stdout
-            },
-          },
-          {
-            debug: true,
-            name: 'node',
-            get: () => process.version,
-          },
-          {
-            debug: true,
-            name: 'npm',
-            get: async () => await npm.version(),
-          },
-          {
-            debug: true,
-            name: 'os',
-            get: () => `${os.type()} ${os.release()}`,
-          },
-        ],
-      },
+    // Read quire-11ty version from project's package.json
+    let quire11tyVersion = 'unknown'
+    try {
+      const packageJson = JSON.parse(fs.readFileSync('./package.json', 'utf8'))
+      quire11tyVersion = packageJson.version
+    } catch {
+      this.debug('Could not read package.json')
+    }
+
+    if (options.json) {
+      const result = {
+        project: {
+          directory: projectDirectory,
+          cli: versionInfo.cli,
+          quire11ty: quire11tyVersion,
+          starter: versionInfo.starter || null,
+        },
+      }
+      console.log(JSON.stringify(result, null, 2))
+      return
+    }
+
+    const lines = [
+      `Project: ${projectDirectory}`,
+      '',
+      `  quire-cli    ${versionInfo.cli || 'unknown'}`,
+      `  quire-11ty   ${quire11tyVersion}`,
     ]
 
-    /**
-     * Filter the command output based on `debug` settings
-     */
-    for (const { items, title } of versions) {
-      const versionList = await Promise.all(
-        items
-          .filter(({ debug }) => !debug || (options.debug && debug))
-          .map(async ({ name, get }) => `${name} ${await get()}`)
-      )
-      this.logger.info(`${title}\n ${versionList.join('\n ')}`)
+    if (versionInfo.starter) {
+      lines.push(`  starter      ${versionInfo.starter}`)
+    }
+
+    if (options.debug) {
+      lines.push('')
+      lines.push(this.resolveCliPath())
     }
+
+    lines.push('')
+    lines.push('Tip: Run \'quire doctor\' for system environment checks')
+
+    this.logger.info(lines.join('\n'))
+  }
+
+  /**
+   * Resolve the full filesystem path to the quire CLI executable
+   * @returns {string} Formatted path line
+   */
+  resolveCliPath() {
+    const resolved = binPath()
+    return resolved
+      ? `  quire-cli    ${resolved}`
+      : '  quire-cli    not found in PATH'
   }
 
   preAction(thisCommand, actionCommand) {

package/src/commands/info.spec.js

@@ -40,15 +40,22 @@ test('registered command has correct options', (t) => {
   const { command } = t.context
 
   // Get all options
+  const jsonOption = command.options.find((opt) => opt.long === '--json')
   const debugOption = command.options.find((opt) => opt.long === '--debug')
 
   // Verify all options exist
+  t.truthy(jsonOption, '--json 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(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(debugOption.long, '--debug')
   t.truthy(debugOption.description)
   t.false(debugOption.required, '--debug should not require a value')
@@ -60,5 +67,6 @@ 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('--debug'))
 })

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
     }
   }