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

package/src/commands/create.js

@@ -1,10 +1,6 @@
 import Command from '#src/Command.js'
-import { Option } from 'commander'
-import { withOutputModes } from '#lib/commander/index.js'
 import fs from 'fs-extra'
-import { installer } from '#lib/installer/index.js'
-import { DirectoryNotEmptyError, ProjectCreateError } from '#src/errors/index.js'
-import reporter from '#lib/reporter/index.js'
+import { quire } from '#src/lib/quire/index.js'
 
 /**
  * Quire CLI `new` Command
@@ -17,17 +13,10 @@ import reporter from '#lib/reporter/index.js'
  * @extends    {Command}
  */
 export default class CreateCommand extends Command {
-  static definition = withOutputModes({
+  static definition = {
     name: 'new',
     description: 'Start a new Quire project from a template.',
     summary: 'create a new project',
-    docsLink: 'quire-commands/#start-and-preview-projects',
-    helpText: `
-Examples:
-  quire new my-project                        Use default starter
-  quire new my-project --quire-version 1.0.0  Pin quire-11ty version
-  quire new my-project --verbose              Create with detailed progress
-`,
     version: '1.0.0',
     args: [
       [ '[projectPath]', 'local path to the new project', '.' ],
@@ -36,10 +25,10 @@ Examples:
     options: [
       [ '--quire-path <path>', 'local path to quire-11ty package' ],
       [ '--quire-version <version>', 'quire-11ty version to install' ],
-      // Use Option object syntax to configure this as a hidden option
-      new Option('--clean-cache', 'force clean the npm cache').default(false).hideHelp(),
+      // [ '--eject', 'install quire-11ty into the project directory', true ],
+      [ '--debug', 'debug the `quire new` command', false ],
     ],
-  })
+  }
 
   constructor() {
     super(CreateCommand.definition)
@@ -52,16 +41,15 @@ Examples:
    * @return     {Promise}
    */
   async action(projectPath, starter, options = {}) {
-    this.debug('called with options %O', options)
-
-    // Configure reporter for this command
-    reporter.configure({ quiet: options.quiet, verbose: options.verbose })
+    if (options.debug) {
+      console.info('Command \'%s\' called with options %o', CreateCommand.name, options)
+    }
 
     starter = starter || this.config.get('projectTemplate')
 
     if (!projectPath && !starter) {
       // @TODO implement this case of interactively selecting starter templates
-      // from available subtrees in `lib/installer` module
+      // from available subtrees in `lib/quire` module
 
       // await interactivePrompt()
       // list sub-repositories in '@thegetty/quire/packages/starters'
@@ -77,30 +65,14 @@ Examples:
        */
       let quireVersion
       try {
-        quireVersion = await installer.initStarter(starter, projectPath, options)
+        quireVersion = await quire.initStarter(starter, projectPath, options)
       } catch (error) {
-        reporter.fail('Failed to initialize project')
-        this.logger.error(error.message)
-        /**
-         * Nota bene: Auto-deletion of projectPath is disabled to prevent accidental data loss.
-         * @TODO implement safe cleaup that either tracks whether quire created the directory,
-         * or prompt the user for confirmation before deleting any files.
-         */
-        // if (!(error instanceof DirectoryNotEmptyError)) {
-        //   fs.removeSync(projectPath)
-        // }
-        throw new ProjectCreateError(projectPath, error.message)
-      }
-
-      // Check if initStarter returned without a version
-      if (!quireVersion) {
-        // Nota bene: Auto-deletion disabled - see comment above
-        // fs.removeSync(projectPath)
-        throw new ProjectCreateError(projectPath, 'Failed to determine Quire version')
+        console.error(error.message)
+        fs.removeSync(projectPath)
+        return
       }
 
-      await installer.installInProject(projectPath, quireVersion, options)
-      reporter.succeed('Project created successfully')
+      await quire.installInProject(projectPath, quireVersion, options)
     }
   }
 }

package/src/commands/epub.js

@@ -1,17 +1,12 @@
 import Command from '#src/Command.js'
-import { withOutputModes } from '#lib/commander/index.js'
-import paths, { hasEpubOutput } from '#lib/project/index.js'
-import eleventy from '#lib/11ty/index.js'
+import { paths, projectRoot  } from '#lib/11ty/index.js'
 import fs from 'fs-extra'
-import generateEpub, { ENGINES } from '#lib/epub/index.js'
+import libEpub 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'
+import path from 'node:path'
 
 /**
- * Quire CLI `epub` Command
+ * Quire CLI `build epub` Command
  *
  * Generate EPUB from Eleventy `build` output.
  *
@@ -19,84 +14,53 @@ import { MissingBuildOutputError } from '#src/errors/index.js'
  * @extends    {Command}
  */
 export default class EpubCommand extends Command {
-  static definition = withOutputModes({
+  static definition = {
     name: 'epub',
     description: 'Generate publication EPUB',
-    summary: 'generate EPUB e-book',
-    docsLink: 'quire-commands/#output-files',
-    helpText: `
-Examples:
-  quire epub                        Generate EPUB using default engine
-  quire epub --engine pandoc        Generate EPUB using Pandoc
-  quire epub --open                 Generate and open EPUB
-  quire epub --build                Build site first, then generate EPUB
-  quire epub --output my-book.epub  Generate EPUB with custom output path
-`,
+    summary: 'run build epub',
     version: '1.0.0',
+    args: [],
     options: [
-      [ '--build', 'run build first if output is missing' ],
-      [ '--open', 'open EPUB in default application' ],
-      [ '-o, --output <path>', 'output file path (default: {engine}.epub)' ],
-      [
-        '--engine <name>', 'EPUB engine to use (default: from config or epubjs)',
-        { choices: ENGINES }
-      ],
       [
-        '--lib <name>', 'deprecated alias for --engine option',
-        { hidden: true, choices: ENGINES, conflicts: 'engine' }
+        '--lib <module>', 'use the specified epub library', 'epubjs',
+        { choices: ['epubjs', 'pandoc'], default: 'epubjs' }
       ],
+      [ '--open', 'open EPUB in default application' ],
+      [ '--debug', 'run epub with debug output' ],
     ],
-  })
+  }
 
   constructor() {
     super(EpubCommand.definition)
   }
 
   async action(options, command) {
-    this.debug('called with options %O', options)
-
-    // Configure reporter for this command
-    reporter.configure({ quiet: options.quiet, verbose: options.verbose })
-
-    // Resolve engine: CLI --engine > deprecated --lib > config epubEngine > default
-    if (!options.engine) {
-      if (options.lib) {
-        // Support deprecated --lib option
-        options.engine = options.lib
-      } else {
-        // Use config setting or fallback to default
-        options.engine = this.config.get('epubEngine') || 'epubjs'
-      }
+    if (options.debug) {
+      console.debug('[CLI] Command \'%s\' called with options %o', this.name(), options)
     }
 
-    // Run build first if --build flag is set and output is missing
-    if (options.build && !hasEpubOutput()) {
-      this.debug('running build before epub generation')
-      reporter.start('Building site...', { showElapsed: true })
-      await eleventy.build({ debug: options.debug })
-    }
+    const input = path.join(projectRoot, paths.epub)
 
-    // Check for build output (will throw if missing)
-    // TODO: Add interactive prompt when build output missing and --build not used
-    if (!hasEpubOutput()) {
-      throw new MissingBuildOutputError('EPUB', paths.getEpubDir())
+    if (!fs.existsSync(input)) {
+      console.error(`Unable to find Epub input at ${input}\nPlease first run the 'quire build' command.`)
+      return
     }
 
-    // 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 = path.join(projectRoot, `${options.lib}.epub`)
 
-    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
-    }
+    const epubLib = await libEpub(options.lib, { debug: options.debug })
+    await epubLib(input, output)
+
+    if (fs.existsSync(output) && options.open) open(output)
   }
 
-  preAction(thisCommand, actionCommand) {
-    testcwd(thisCommand)
+  /**
+   * @todo test if build site has already be run and output can be reused
+   */
+  preAction(command) {
+    const options = command.opts()
+    if (options.debug) {
+      console.debug('[CLI] Calling \'epub\' command pre-action with options', options)
+    }
   }
 }

package/src/commands/index.js

@@ -8,21 +8,14 @@ const __dirname = path.dirname(__filename)
 
 const thisfile = path.basename(__filename)
 
-/**
- * Filter out files that are not command modules
- * @param directory entry 
- * @returns Boolean 
- */
-const filterEntries = (entry) => entry !== thisfile && entry.match(/^.*(?<!spec|test)\.js$/)
-
 /**
  * Dynamically import command modules in parallel
  * and call the class constuctor for each command
  */
 const commands = await Promise.all(
   fs.readdirSync(__dirname)
-    .filter((entry) => filterEntries(entry))
-    .map(async (entry) => await dynamicImport(path.resolve(__dirname, entry)))
+    .filter((file) => file !== thisfile && file.match(/^.*\.js$/))
+    .map(async (file) => await dynamicImport(path.resolve(__dirname, file)))
 ).then((modules) => {
   return modules.map(({ default: CommandClass }) => new CommandClass())
 })

package/src/commands/info.js

@@ -1,59 +1,44 @@
 import Command from '#src/Command.js'
-import { withOutputModes } from '#lib/commander/index.js'
-import { binPath } from '#src/packageConfig.js'
+import { execaCommand } from 'execa'
 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
  *
- * 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.
+ * Runs the Eleventy `info` command to list the quire-cli, quire-11ty, node, and npm versions.
  *
  * @class      InfoCommand
  * @extends    {Command}
  */
 export default class InfoCommand extends Command {
-  static definition = withOutputModes({
+  static definition = {
     name: 'info',
-    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           Show project versions
-  quire info --debug   Include installation paths
-  quire info --json    Output version information as JSON
-  quire doctor         Check environment and project health
-`,
+    description: 'List Quire cli, quire-11ty, and node versions',
+    summary: 'list info',
     version: '1.0.0',
+    args: [],
     options: [
-      ['--json', 'output version information as JSON'],
+      ['--debug', 'include os versions in output']
     ],
-  })
+  }
 
   constructor() {
     super(InfoCommand.definition)
   }
 
   async action(options, command) {
-    this.debug('called with options %O', options)
+    if (options.debug) {
+      console.debug(
+        '[CLI] Command \'%s\' called with options %o',
+        this.name(),
+        options
+      )
+    } else {
+      console.debug('[CLI] Command \'%s\' called', this.name())
+    }
 
     // Load filename from config with a default constraint if it doesn't exist
     const versionFileName = this.config.get('versionFile')
@@ -61,72 +46,85 @@ Example:
 
     try {
       const versionFileData = fs.readFileSync(versionFileName, { encoding: 'utf8' })
-      versionInfo = JSON.parse(versionFileData)
+
+      versionInfo = JSON.parse(versionFileData)      
     } catch (error) {
-      this.logger.warn(
+      console.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())
 
-    // 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}`,
+    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 execaCommand('quire --version')
+              return stdout
+            },
+          },
+          {
+            debug: true,
+            name: 'node',
+            get: () => process.version,
+          },
+          {
+            debug: true,
+            name: 'npm',
+            get: async () => {
+              const { stdout } = await execaCommand('npm --version')
+              return stdout
+            },
+          },
+          {
+            debug: true,
+            name: 'os',
+            get: () => `${os.type()} ${os.release()}`,
+          },
+        ],
+      },
     ]
 
-    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'
+    /**
+     * Filter the command output based on `debug` settings
+     */
+    versions.forEach(async ({ items, title }) => {
+      const versions = await Promise.all(
+        items
+          .filter(({ debug }) => !debug || (options.debug && debug))
+          .map(async ({ name, get }) => `${name} ${await get()}`)
+      )
+      console.info(`${title}\n ${versions.join('\n ')}`)
+    })
   }
 
-  preAction(thisCommand, actionCommand) {
-    testcwd(thisCommand)
+  preAction(command) {
+    testcwd(command)
   }
 }

package/src/commands/pdf.js

@@ -1,14 +1,50 @@
+import { paths, projectRoot  } from '#lib/11ty/index.js'
 import Command from '#src/Command.js'
-import { withOutputModes } from '#lib/commander/index.js'
-import paths, { hasSiteOutput } from '#lib/project/index.js'
-import eleventy from '#lib/11ty/index.js'
-import generatePdf, { ENGINES } from '#lib/pdf/index.js'
+import fs from 'fs-extra'
+import libPdf 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'
+import { pathToFileURL } from 'node:url'
+import yaml from 'js-yaml'
+
+/**
+ * @function loadConfig(path) - loads and validates quire config, returns an empty object if not found
+ *  
+ * @param {path} string - file path to config file
+ * 
+ * @return {Object|undefined} User configuration object or undefined
+ * 
+ * @todo consider hardcoding a version check against .quire / project's package.json ver
+ */
+async function loadConfig(configPath) {
+  if (!fs.existsSync(configPath)) {
+    return undefined
+  }
+
+  const data = fs.readFileSync(configPath)
+  let config = yaml.load(data)
+
+  // NB: Schemas and validators are specific to the 11ty version of the project being built
+  const schemaPath = path.join(projectRoot,'_plugins','schemas','config.json')
+  const validatorPath = path.join(projectRoot, '_plugins', 'globalData', 'validator.js')
+
+  if (fs.existsSync(schemaPath) && fs.existsSync(validatorPath)) {
+
+    const { validateUserConfig } = await import(pathToFileURL(validatorPath))
+  
+    const schemaJSON = fs.readFileSync(schemaPath)
+    const schema = JSON.parse(schemaJSON)
+
+    try {
+      config = validateUserConfig('config', config, { config: schema })
+    } catch (error) {
+      console.error(error)
+      process.exit(1)
+    }
+  }
+
+  return config
+}
 
 /**
  * Quire CLI `pdf` Command
@@ -19,83 +55,66 @@ import { MissingBuildOutputError } from '#src/errors/index.js'
  * @extends    {Command}
  */
 export default class PDFCommand extends Command {
-  static definition = withOutputModes({
+  static definition = {
     name: 'pdf',
     description: 'Generate publication PDF',
-    summary: 'generate print-ready PDF',
-    docsLink: 'quire-commands/#output-files',
-    helpText: `
-Examples:
-  quire pdf                       Generate PDF using default engine
-  quire pdf --engine prince       Generate PDF using PrinceXML
-  quire pdf --build               Build site first, then generate PDF
-  quire pdf --output my-book.pdf  Generate PDF with custom output path
-  quire pdf --verbose             Generate with detailed progress
-`,
+    summary: 'run build pdf',
     version: '1.0.0',
+    args: [
+    ],
     options: [
-      [ '--build', 'run build first if output is missing' ],
-      [ '--open', 'open PDF in default application' ],
-      [ '-o, --output <path>', 'output file path (default: from project config)' ],
       [
-        '--engine <name>', 'PDF engine to use (default: from config or pagedjs)',
-        { choices: ENGINES }
-      ],
-      [
-        '--lib <name>', 'deprecated alias for --engine option',
-        { hidden: true, choices: ENGINES, conflicts: 'engine' }
+        '--lib <module>', 'use the specified pdf module', 'pagedjs',
+        { choices: ['pagedjs', 'prince'], default: 'pagedjs' }
       ],
+      [ '--open', 'open PDF in default application' ],
+      [ '--debug', 'run build with debug output to console' ],
     ],
-  })
+  }
 
   constructor() {
     super(PDFCommand.definition)
   }
 
   async action(options, command) {
-    this.debug('called with options %O', options)
-    /**
-     * Configure reporter for this command
-     * reporter lifecycle (start/succeed/fail) is handled by the façade,
-     * not by the command.
-     */
-    reporter.configure({ quiet: options.quiet, verbose: options.verbose })
-
-    // Resolve engine: CLI --engine > deprecated --lib > config pdfEngine > default
-    if (!options.engine) {
-      if (options.lib) {
-        // Support deprecated --lib option
-        options.engine = options.lib
-      } else {
-        // Use config setting or fallback to default
-        options.engine = this.config.get('pdfEngine') || 'pagedjs'
-      }
+    if (options.debug) {
+      console.debug('[CLI] Command \'%s\' called with options %o', this.name(), options)
+    }
+
+    const publicationInput = path.join(projectRoot, paths.output, 'pdf.html')
+    const coversInput = path.join(projectRoot, paths.output, 'pdf-covers.html')
+
+    const quireConfig = await loadConfig(path.join(projectRoot,'content','_data','config.yaml'))
+
+    if (quireConfig === undefined) {
+      console.error(`[quire pdf]: ERROR Unable to find a configuration file at ${path.join(projectRoot,'content','_data','config.yaml')}\nIs the command being run in a quire project?`)
+      process.exit(1)
     }
 
-    // Run build first if --build flag is set and output is missing
-    if (options.build && !hasSiteOutput()) {
-      this.debug('running build before pdf generation')
-      reporter.start('Building site...', { showElapsed: true })
-      await eleventy.build({ debug: options.debug })
-      reporter.succeed('Build complete')
+    if (!fs.existsSync(publicationInput)) {
+      console.error(`[quire pdf]: ERROR Unable to find PDF input at ${publicationInput}\nPlease first run the 'quire build' command.`)
+      process.exit(1)
     }
 
-    // Generate PDF - façade handles validation, progress, and errors
-    const pdfOptions = { ...options, lib: options.engine }
+    const output = quireConfig.pdf !== undefined
+      ? path.join(paths.output, quireConfig.pdf.outputDir, `${quireConfig.pdf.filename}.pdf`)
+      : path.join(projectRoot, `${options.lib}.pdf`)
+
+    const pdfLib = await libPdf(options.lib, { ...options, pdfConfig: quireConfig.pdf })
+    await pdfLib(publicationInput, coversInput, output)
 
     try {
-      const output = await generatePdf(pdfOptions)
-      recordStatus(paths.getProjectRoot(), 'pdf', 'ok')
-      if (options.open) {
-        open(output)
-      }
+      if (fs.existsSync(output) && options.open) open(output)
     } catch (error) {
-      recordStatus(paths.getProjectRoot(), 'pdf', 'failed')
-      throw error
+      console.error(`[quire pdf]: ERROR`,error)
+      process.exit(1)
     }
   }
 
-  preAction(thisCommand, actionCommand) {
-    testcwd(thisCommand)
+  /**
+   * @todo test if build has already be run and output can be reused
+   */
+  preAction(command) {
+    // testcwd(command)
   }
 }