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

package/src/commands/epub.spec.js

@@ -1,114 +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() === 'epub')
-})
-
-test('command is registered in CLI program', (t) => {
-  const { command } = t.context
-
-  t.truthy(command, 'command "epub" 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(), 'epub')
-  t.truthy(command.description())
-  t.is(typeof command._actionHandler, 'function', 'command should have action handler')
-})
-
-test('registered command has no arguments', (t) => {
-  const { command } = t.context
-  const registeredArguments = command.registeredArguments
-
-  t.is(registeredArguments.length, 0, 'epub command should have no arguments')
-})
-
-test('registered command has correct options', (t) => {
-  const { command } = t.context
-
-  // Get all options
-  const engineOption = command.options.find((opt) => opt.long === '--engine')
-  const libOption = command.options.find((opt) => opt.long === '--lib')
-  const buildOption = command.options.find((opt) => opt.long === '--build')
-  const openOption = command.options.find((opt) => opt.long === '--open')
-  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(engineOption, '--engine option should exist')
-  t.truthy(libOption, '--lib option should exist (deprecated alias)')
-  t.truthy(buildOption, '--build option should exist')
-  t.truthy(openOption, '--open 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(engineOption instanceof Option, '--engine should be Option instance')
-  t.true(libOption instanceof Option, '--lib should be Option instance')
-  t.true(buildOption instanceof Option, '--build should be Option instance')
-  t.true(openOption instanceof Option, '--open 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 --engine option properties
-  t.is(engineOption.long, '--engine')
-  t.truthy(engineOption.description)
-  t.true(engineOption.required, '--engine should require a value')
-
-  // Verify --lib is hidden (deprecated alias)
-  t.is(libOption.long, '--lib')
-  t.true(libOption.hidden, '--lib should be hidden (deprecated)')
-
-  t.is(buildOption.long, '--build')
-  t.truthy(buildOption.description)
-  t.false(buildOption.required, '--build should not require a value')
-
-  t.is(openOption.long, '--open')
-  t.truthy(openOption.description)
-  t.false(openOption.required, '--open should not require a value')
-
-  t.is(quietOption.long, '--quiet')
-  t.is(quietOption.short, '-q', '--quiet should have -q short flag')
-  t.truthy(quietOption.description)
-  t.false(quietOption.required, '--quiet should not require a value')
-
-  t.is(verboseOption.long, '--verbose')
-  t.is(verboseOption.short, '-v', '--verbose should have -v short flag')
-  t.truthy(verboseOption.description)
-  t.false(verboseOption.required, '--verbose should not require a value')
-
-  t.is(debugOption.long, '--debug')
-  t.truthy(debugOption.description)
-  t.false(debugOption.required, '--debug should not require a value')
-})
-
-test('command options are accessible via public API', (t) => {
-  const { command } = t.context
-
-  // Test that options can be accessed the way Commander.js does
-  const optionNames = command.options.map((opt) => opt.long)
-
-  t.true(optionNames.includes('--engine'))
-  t.true(optionNames.includes('--lib'))  // deprecated alias still exists
-  t.true(optionNames.includes('--build'))
-  t.true(optionNames.includes('--open'))
-  t.true(optionNames.includes('--quiet'))
-  t.true(optionNames.includes('--verbose'))
-  t.true(optionNames.includes('--debug'))
-})

package/src/commands/epub.test.js

@@ -1,503 +0,0 @@
-import test from 'ava'
-import sinon from 'sinon'
-import esmock from 'esmock'
-
-test.beforeEach((t) => {
-  t.context.sandbox = sinon.createSandbox()
-
-  // Create mock reporter
-  t.context.mockReporter = {
-    configure: t.context.sandbox.stub().returnsThis(),
-    start: t.context.sandbox.stub().returnsThis(),
-    update: t.context.sandbox.stub().returnsThis(),
-    succeed: t.context.sandbox.stub().returnsThis(),
-    fail: t.context.sandbox.stub().returnsThis(),
-    stop: t.context.sandbox.stub().returnsThis(),
-  }
-})
-
-test.afterEach.always((t) => {
-  t.context.sandbox.restore()
-})
-
-test('epub command should call generateEpub with epubjs engine', async (t) => {
-  const { sandbox, mockReporter } = t.context
-
-  const mockGenerateEpub = sandbox.stub().resolves('/project/epubjs.epub')
-
-  const EPUBCommand = await esmock('./epub.js', {
-    '#lib/epub/index.js': {
-      default: mockGenerateEpub
-    },
-    '#lib/project/index.js': {
-      hasEpubOutput: () => true
-    },
-    '#lib/reporter/index.js': {
-      default: mockReporter
-    },
-    'fs-extra': {
-      existsSync: () => true
-    },
-    open: {
-      default: sandbox.stub()
-    }
-  })
-
-  const command = new EPUBCommand()
-  command.name = sandbox.stub().returns('epub')
-
-  await command.action({ engine: 'epubjs' }, command)
-
-  t.true(mockGenerateEpub.called, 'generateEpub should be called')
-  t.is(mockGenerateEpub.firstCall.args[0].lib, 'epubjs', 'should pass lib to generateEpub')
-  // Nota bene: reporter.start/succeed are called by façade (lib/epub/index.js), not the command
-})
-
-test('epub command should call generateEpub with pandoc engine', async (t) => {
-  const { sandbox, mockReporter } = t.context
-
-  const mockGenerateEpub = sandbox.stub().resolves('/project/pandoc.epub')
-
-  const EPUBCommand = await esmock('./epub.js', {
-    '#lib/epub/index.js': {
-      default: mockGenerateEpub
-    },
-    '#lib/project/index.js': {
-      hasEpubOutput: () => true
-    },
-    '#lib/reporter/index.js': {
-      default: mockReporter
-    },
-    'fs-extra': {
-      existsSync: () => true
-    },
-    open: {
-      default: sandbox.stub()
-    }
-  })
-
-  const command = new EPUBCommand()
-  command.name = sandbox.stub().returns('epub')
-
-  await command.action({ engine: 'pandoc' }, command)
-
-  t.true(mockGenerateEpub.called, 'generateEpub should be called')
-  t.is(mockGenerateEpub.firstCall.args[0].lib, 'pandoc', 'should pass lib to generateEpub')
-})
-
-test('epub command should open EPUB when --open flag is provided', async (t) => {
-  const { sandbox, mockReporter } = t.context
-
-  const outputPath = '/project/epubjs.epub'
-  const mockGenerateEpub = sandbox.stub().resolves(outputPath)
-  const mockOpen = sandbox.stub()
-
-  const EPUBCommand = await esmock('./epub.js', {
-    '#lib/epub/index.js': {
-      default: mockGenerateEpub
-    },
-    '#lib/project/index.js': {
-      hasEpubOutput: () => true
-    },
-    '#lib/reporter/index.js': {
-      default: mockReporter
-    },
-    'fs-extra': {
-      existsSync: () => true
-    },
-    open: {
-      default: mockOpen
-    }
-  })
-
-  const command = new EPUBCommand()
-  command.name = sandbox.stub().returns('epub')
-
-  await command.action({ engine: 'epubjs', open: true }, command)
-
-  t.true(mockGenerateEpub.called, 'generateEpub should be called')
-  t.true(mockOpen.called, 'open should be called when --open flag is provided')
-  t.is(mockOpen.firstCall.args[0], outputPath, 'should open the generated EPUB path')
-})
-
-test('epub command should not open EPUB when --open flag is not provided', async (t) => {
-  const { sandbox, mockReporter } = t.context
-
-  const mockGenerateEpub = sandbox.stub().resolves('/project/epubjs.epub')
-  const mockOpen = sandbox.stub()
-
-  const EPUBCommand = await esmock('./epub.js', {
-    '#lib/epub/index.js': {
-      default: mockGenerateEpub
-    },
-    '#lib/project/index.js': {
-      hasEpubOutput: () => true
-    },
-    '#lib/reporter/index.js': {
-      default: mockReporter
-    },
-    'fs-extra': {
-      existsSync: () => true
-    },
-    open: {
-      default: mockOpen
-    }
-  })
-
-  const command = new EPUBCommand()
-  command.name = sandbox.stub().returns('epub')
-
-  await command.action({ engine: 'epubjs' }, command)
-
-  t.true(mockGenerateEpub.called, 'generateEpub should be called')
-  t.false(mockOpen.called, 'open should not be called without --open flag')
-})
-
-test('epub command should pass debug option to generateEpub', async (t) => {
-  const { sandbox, mockReporter } = t.context
-
-  const mockGenerateEpub = sandbox.stub().resolves('/project/epubjs.epub')
-
-  const EPUBCommand = await esmock('./epub.js', {
-    '#lib/epub/index.js': {
-      default: mockGenerateEpub
-    },
-    '#lib/project/index.js': {
-      hasEpubOutput: () => true
-    },
-    '#lib/reporter/index.js': {
-      default: mockReporter
-    },
-    'fs-extra': {
-      existsSync: () => true
-    },
-    open: {
-      default: sandbox.stub()
-    }
-  })
-
-  const command = new EPUBCommand()
-  command.name = sandbox.stub().returns('epub')
-
-  await command.action({ engine: 'epubjs', debug: true }, command)
-
-  t.true(mockGenerateEpub.called, 'generateEpub should be called')
-  t.is(mockGenerateEpub.firstCall.args[0].lib, 'epubjs', 'should pass lib to generateEpub')
-  t.true(mockGenerateEpub.firstCall.args[0].debug, 'should pass debug option')
-})
-
-test('epub command should throw MissingBuildOutputError when build output is missing', async (t) => {
-  const { sandbox, mockReporter } = t.context
-
-  const mockGenerateEpub = sandbox.stub().resolves('/project/epubjs.epub')
-
-  const EPUBCommand = await esmock('./epub.js', {
-    '#lib/epub/index.js': {
-      default: mockGenerateEpub
-    },
-    '#lib/project/index.js': {
-      default: { getEpubDir: () => '_epub' },
-      hasEpubOutput: () => false
-    },
-    '#lib/reporter/index.js': {
-      default: mockReporter
-    },
-    'fs-extra': {
-      existsSync: () => true
-    },
-    open: {
-      default: sandbox.stub()
-    }
-  })
-
-  const command = new EPUBCommand()
-  command.name = sandbox.stub().returns('epub')
-
-  const error = await t.throwsAsync(() => command.action({ engine: 'epubjs' }, command))
-
-  t.is(error.code, 'BUILD_OUTPUT_MISSING', 'should throw BUILD_OUTPUT_MISSING error')
-  t.regex(error.message, /EPUB/, 'error should mention EPUB')
-  t.false(mockGenerateEpub.called, 'generateEpub should not be called when build output is missing')
-})
-
-test('epub command should run build first when --build flag is set and output missing', async (t) => {
-  const { sandbox, mockReporter } = t.context
-
-  const mockGenerateEpub = sandbox.stub().resolves('/project/epubjs.epub')
-  const mockBuild = sandbox.stub().resolves()
-  let buildCalled = false
-
-  const EPUBCommand = await esmock('./epub.js', {
-    '#lib/epub/index.js': {
-      default: mockGenerateEpub
-    },
-    '#lib/project/index.js': {
-      hasEpubOutput: () => {
-        // Return false first (before build), true after build
-        if (!buildCalled) return false
-        return true
-      }
-    },
-    '#lib/11ty/index.js': {
-      default: {
-        build: async (opts) => {
-          buildCalled = true
-          return mockBuild(opts)
-        }
-      }
-    },
-    '#lib/reporter/index.js': {
-      default: mockReporter
-    },
-    'fs-extra': {
-      existsSync: () => true
-    },
-    open: {
-      default: sandbox.stub()
-    }
-  })
-
-  const command = new EPUBCommand()
-  command.name = sandbox.stub().returns('epub')
-
-  await command.action({ engine: 'epubjs', build: true }, command)
-
-  t.true(mockBuild.called, 'build should be called when --build flag is set')
-  t.true(mockGenerateEpub.called, 'generateEpub should be called after build')
-})
-
-test('epub command should support deprecated --lib option', async (t) => {
-  const { sandbox, mockReporter } = t.context
-
-  const mockGenerateEpub = sandbox.stub().resolves('/project/pandoc.epub')
-
-  const EPUBCommand = await esmock('./epub.js', {
-    '#lib/epub/index.js': {
-      default: mockGenerateEpub
-    },
-    '#lib/project/index.js': {
-      hasEpubOutput: () => true
-    },
-    '#lib/reporter/index.js': {
-      default: mockReporter
-    },
-    'fs-extra': {
-      existsSync: () => true
-    },
-    open: {
-      default: sandbox.stub()
-    }
-  })
-
-  const command = new EPUBCommand()
-  command.name = sandbox.stub().returns('epub')
-
-  // Use deprecated --lib option (should still work)
-  await command.action({ lib: 'pandoc' }, command)
-
-  t.true(mockGenerateEpub.called, 'generateEpub should be called with deprecated --lib')
-  t.is(mockGenerateEpub.firstCall.args[0].lib, 'pandoc', 'should pass lib to generateEpub from deprecated option')
-})
-
-test('epub command should propagate errors from generateEpub', async (t) => {
-  const { sandbox, mockReporter } = t.context
-
-  const epubError = new Error('EPUB generation failed')
-  const mockGenerateEpub = sandbox.stub().rejects(epubError)
-
-  const EPUBCommand = await esmock('./epub.js', {
-    '#lib/epub/index.js': {
-      default: mockGenerateEpub
-    },
-    '#lib/project/index.js': {
-      hasEpubOutput: () => true
-    },
-    '#lib/reporter/index.js': {
-      default: mockReporter
-    },
-    'fs-extra': {
-      existsSync: () => true
-    },
-    open: {
-      default: sandbox.stub()
-    }
-  })
-
-  const command = new EPUBCommand()
-  command.name = sandbox.stub().returns('epub')
-
-  // Error is propagated; reporter lifecycle is handled by façade (lib/epub/index.js)
-  await t.throwsAsync(() => command.action({ engine: 'epubjs' }, command), { message: 'EPUB generation failed' })
-})
-
-test('epub command should configure reporter with quiet option', async (t) => {
-  const { sandbox, mockReporter } = t.context
-
-  const mockGenerateEpub = sandbox.stub().resolves('/project/epubjs.epub')
-
-  const EPUBCommand = await esmock('./epub.js', {
-    '#lib/epub/index.js': {
-      default: mockGenerateEpub
-    },
-    '#lib/project/index.js': {
-      hasEpubOutput: () => true
-    },
-    '#lib/reporter/index.js': {
-      default: mockReporter
-    },
-    'fs-extra': {
-      existsSync: () => true
-    },
-    open: {
-      default: sandbox.stub()
-    }
-  })
-
-  const command = new EPUBCommand()
-  command.name = sandbox.stub().returns('epub')
-
-  await command.action({ engine: 'epubjs', quiet: true }, command)
-
-  t.true(
-    mockReporter.configure.calledWith(sinon.match({ quiet: true })),
-    'reporter.configure should be called with quiet option'
-  )
-})
-
-test('epub command should pass output option to generateEpub', async (t) => {
-  const { sandbox, mockReporter } = t.context
-
-  const customOutput = '/custom/path/my-book.epub'
-  const mockGenerateEpub = sandbox.stub().resolves(customOutput)
-
-  const EPUBCommand = await esmock('./epub.js', {
-    '#lib/epub/index.js': {
-      default: mockGenerateEpub
-    },
-    '#lib/project/index.js': {
-      hasEpubOutput: () => true
-    },
-    '#lib/reporter/index.js': {
-      default: mockReporter
-    },
-    'fs-extra': {
-      existsSync: () => true
-    },
-    open: {
-      default: sandbox.stub()
-    }
-  })
-
-  const command = new EPUBCommand()
-  command.name = sandbox.stub().returns('epub')
-
-  await command.action({ engine: 'epubjs', output: customOutput }, command)
-
-  t.true(mockGenerateEpub.called, 'generateEpub should be called')
-  t.is(mockGenerateEpub.firstCall.args[0].output, customOutput, 'should pass output option to generateEpub')
-})
-
-test('epub command should use epubEngine from config when --engine not specified', async (t) => {
-  const { sandbox, mockReporter } = t.context
-
-  const mockGenerateEpub = sandbox.stub().resolves('/project/pandoc.epub')
-
-  const EPUBCommand = await esmock('./epub.js', {
-    '#lib/epub/index.js': {
-      default: mockGenerateEpub
-    },
-    '#lib/project/index.js': {
-      hasEpubOutput: () => true
-    },
-    '#lib/reporter/index.js': {
-      default: mockReporter
-    },
-    'fs-extra': {
-      existsSync: () => true
-    },
-    open: {
-      default: sandbox.stub()
-    }
-  })
-
-  const command = new EPUBCommand()
-  command.name = sandbox.stub().returns('epub')
-  // Mock config to return 'pandoc' for epubEngine
-  command.config = { get: (key) => key === 'epubEngine' ? 'pandoc' : undefined }
-
-  // No --engine specified, should use config value
-  await command.action({}, command)
-
-  t.true(mockGenerateEpub.called, 'generateEpub should be called')
-  t.is(mockGenerateEpub.firstCall.args[0].lib, 'pandoc', 'should use epubEngine from config')
-})
-
-test('epub command should use default engine when --engine not specified and config not set', async (t) => {
-  const { sandbox, mockReporter } = t.context
-
-  const mockGenerateEpub = sandbox.stub().resolves('/project/epubjs.epub')
-
-  const EPUBCommand = await esmock('./epub.js', {
-    '#lib/epub/index.js': {
-      default: mockGenerateEpub
-    },
-    '#lib/project/index.js': {
-      hasEpubOutput: () => true
-    },
-    '#lib/reporter/index.js': {
-      default: mockReporter
-    },
-    'fs-extra': {
-      existsSync: () => true
-    },
-    open: {
-      default: sandbox.stub()
-    }
-  })
-
-  const command = new EPUBCommand()
-  command.name = sandbox.stub().returns('epub')
-  // Mock config to return undefined (no epubEngine set)
-  command.config = { get: () => undefined }
-
-  // No --engine specified, no config, should use default 'epubjs'
-  await command.action({}, command)
-
-  t.true(mockGenerateEpub.called, 'generateEpub should be called')
-  t.is(mockGenerateEpub.firstCall.args[0].lib, 'epubjs', 'should use default epubjs when no config')
-})
-
-test('epub command --engine flag should override config epubEngine', async (t) => {
-  const { sandbox, mockReporter } = t.context
-
-  const mockGenerateEpub = sandbox.stub().resolves('/project/epubjs.epub')
-
-  const EPUBCommand = await esmock('./epub.js', {
-    '#lib/epub/index.js': {
-      default: mockGenerateEpub
-    },
-    '#lib/project/index.js': {
-      hasEpubOutput: () => true
-    },
-    '#lib/reporter/index.js': {
-      default: mockReporter
-    },
-    'fs-extra': {
-      existsSync: () => true
-    },
-    open: {
-      default: sandbox.stub()
-    }
-  })
-
-  const command = new EPUBCommand()
-  command.name = sandbox.stub().returns('epub')
-  // Mock config to return 'pandoc' for epubEngine
-  command.config = { get: (key) => key === 'epubEngine' ? 'pandoc' : undefined }
-
-  // --engine epubjs should override config's 'pandoc'
-  await command.action({ engine: 'epubjs' }, command)
-
-  t.true(mockGenerateEpub.called, 'generateEpub should be called')
-  t.is(mockGenerateEpub.firstCall.args[0].lib, 'epubjs', 'CLI --engine should override config')
-})

package/src/commands/help.js

@@ -1,60 +0,0 @@
-import Command from '#src/Command.js'
-import { outputWithPaging } from '#helpers/pager.js'
-import { getTopicContent, getTopicList } from '#lib/help/index.js'
-
-/**
- * Quire CLI `help` Command
- *
- * Display help for a specific topic or list available topics.
- * Complements Commander's built-in help with extended documentation.
- *
- * @example
- * quire help                 # List available topics
- * quire help workflows       # Show workflows topic
- * quire help --list          # List available topics
- *
- * @class      HelpCommand
- * @extends    {Command}
- */
-export default class HelpCommand extends Command {
-  static definition = {
-    name: 'help',
-    aliases: ['h'],
-    description: 'Display help for a topic or list available topics',
-    summary: 'show help for a topic',
-    docsLink: 'quire-commands/',
-    helpText: `
-Examples:
-  quire help                 List available help topics
-  quire help workflows       Show common workflow examples
-  quire help pdf             Show PDF generation guide
-  quire help --list          List all available topics
-`,
-    version: '1.0.0',
-    args: [
-      ['[topic]', 'help topic to display']
-    ],
-    options: [
-      ['--list', 'list all available topics'],
-    ],
-  }
-
-  constructor() {
-    super(HelpCommand.definition)
-  }
-
-  async action(topic, options, command) {
-    this.debug('called with topic=%s options=%O', topic, options)
-
-    // List topics if no topic specified or --list flag
-    if (!topic || options.list) {
-      const list = await getTopicList()
-      process.stdout.write(list + '\n')
-      return
-    }
-
-    // Display requested topic with paging (throws HelpTopicNotFoundError if missing)
-    const content = await getTopicContent(topic)
-    await outputWithPaging(content)
-  }
-}