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

package/src/lib/11ty/api.js

@@ -1,275 +1,133 @@
-/**
- * Quire11ty façade for Eleventy integration
- *
- * Provides a unified interface for Eleventy operations with path resolution.
- * Follows the singleton pattern like lib/npm and lib/git for consistency
- * and easy mocking in tests.
- *
- * @example Production usage
- * import eleventy from '#lib/11ty/index.js'
- * await eleventy.build({ debug: true })
- * const outputDir = eleventy.paths.getOutputDir()
- *
- * @example Path-only usage
- * import { paths } from '#lib/11ty/index.js'
- * const projectRoot = paths.getProjectRoot()
- *
- * @example Test mocking
- * const mockEleventy = {
- *   build: sandbox.stub().resolves(),
- *   serve: sandbox.stub().resolves(),
- *   paths: {
- *     getProjectRoot: () => '/project',
- *     getOutputDir: () => '_site'
- *   }
- * }
- * const MyCommand = await esmock('./mycommand.js', {
- *   '#lib/11ty/index.js': { default: mockEleventy }
- * })
- *
- * @see https://www.11ty.dev/docs/programmatic/
- * @module lib/11ty
- */
 import { dynamicImport } from '#helpers/os-utils.js'
+import { pathToFileURL } from 'node:url'
 import path from 'node:path'
-import paths from '#lib/project/index.js'
-import reporter from '#lib/reporter/index.js'
-import createDebug from '#debug'
-
-const debug = createDebug('lib:11ty:api')
+import paths, { eleventyRoot, projectRoot } from './paths.js'
 
 /**
- * Configure environment variables required for Eleventy.
+ * A factory function to configure an instance of Eleventy
+ * @see https://www.11ty.dev/docs/config/#configuration-options
  *
- * These must be set before the Eleventy instance is created and the
- * `.eleventy.js` configuration file is parsed.
- *
- * Sets QUIRE_LOG_LEVEL to control output from multiple systems:
- *   - quire-11ty chalk logger (_lib/chalk) — reads env var as level ceiling
- *   - Vite bundler (_plugins/vite) — maps env var to Vite's logLevel option
- *   - Directory output plugin (.eleventy.js) — conditionally registered
- *
- * CLI flag mapping:
- *   (default)   → 'warn'   — spinner + warn/error only
- *   --verbose   → 'info'   — adds chalk info output, directory listing, Vite info
- *   --debug     → 'debug'  — adds chalk debug output, Eleventy DEBUG traces
- *   --quiet     → 'silent' — suppresses all chalk/Vite/directory output
- *
- * @see https://github.com/11ty/eleventy/issues/2655
- * @see packages/cli/docs/cli-output-modes.md
- *
- * @param {Object} options
- * @param {'production'|'development'} options.mode - Build mode
- * @param {boolean} options.debug - Enable Eleventy debug output
- * @param {boolean} options.verbose - Enable verbose output
- * @param {boolean} options.quiet - Suppress output
+ * @param  {Object}  options  Eleventy configuration options
+ * @return  {Eleventy}  A configured instance of Eleventy
  */
-const configureEleventyEnv = ({ mode = 'production', debug = false, verbose = false, quiet = false } = {}) => {
-  // Path configuration for decoupling quire-11ty from project input directory
-  process.env.ELEVENTY_DATA = paths.getDataDir()
-  process.env.ELEVENTY_INCLUDES = paths.getIncludesDir()
-  process.env.ELEVENTY_LAYOUTS = paths.getLayoutsDir()
-
-  // Build mode
-  process.env.ELEVENTY_ENV = mode
+const factory = async (options = {}) => {
+  const { config, input, output } = paths
 
-  // Log level for quire-11ty's chalk logger
-  if (quiet) {
-    process.env.QUIRE_LOG_LEVEL = 'silent'
-  } else if (debug) {
-    process.env.QUIRE_LOG_LEVEL = 'debug'
-  } else if (verbose) {
-    process.env.QUIRE_LOG_LEVEL = 'info'
-  } else {
-    process.env.QUIRE_LOG_LEVEL = 'warn'
+  if (options.debug) {
+    console.debug('[CLI:11ty] projectRoot %s\n%o', projectRoot, paths)
   }
 
-  // QUIRE_LOG_PREFIX and QUIRE_LOG_SHOW_LEVEL are set by the preAction hook
-  // in main.js from config values. No action needed here — they are already
-  // in process.env and will be read by the chalk logger at instantiation time.
-
-  // Debug output
-  if (debug) {
-    process.env.DEBUG = 'Eleventy*'
-  }
-}
-
-/**
- * Create an instance of Eleventy configured for Quire projects
- *
- * @param {Object} options - Eleventy configuration options
- * @param {boolean} [options.debug=false] - Enable debug output
- * @param {boolean} [options.quiet=false] - Suppress output
- * @param {string} [options.config] - Custom config path override
- * @param {'build'|'serve'|'watch'} [options.runMode='build'] - Eleventy run mode
- * @returns {Promise<Eleventy>} Configured Eleventy instance
- */
-const createEleventyInstance = async (options = {}) => {
-  const config = paths.getConfigPath()
-  const eleventyRoot = paths.getEleventyRoot()
-  const input = paths.getInputDir()
-  const output = paths.getOutputDir()
-  const projectRoot = paths.getProjectRoot()
-
-  debug('projectRoot: %s', projectRoot)
-  debug('paths: %O', paths.toObject())
-
-  // Dynamically import the correct version of Eleventy
+  /**
+   * Dynamically import the correct version of Eleventy
+   */
   const modulePath = path.join(eleventyRoot, 'node_modules', '@11ty', 'eleventy', 'src', 'Eleventy.js')
   const { default: Eleventy } = await dynamicImport(modulePath)
 
-  // Create Eleventy instance
-  // @see https://github.com/11ty/eleventy/blob/src/Eleventy.js
-  const eleventy = new Eleventy(input, output, {
-    config: (eleventyConfig) => {
-      // Event callback when a build completes
-      // @see https://www.11ty.dev/docs/events/#eleventy.after
-      eleventyConfig.on('eleventy.after', async () => {
-        debug('build complete')
-      })
-
-      return eleventyConfig
-    },
-    configPath: options.config || config,
-    quietMode: options.quiet || !options.verbose,
-    runMode: options.runMode || 'build',
-  })
-
-  return eleventy
-}
-
-/**
- * Quire11ty façade class
- *
- * Provides abstracted Eleventy operations with unified logging,
- * error handling, and path resolution. Stores active Eleventy
- * instance for cleanup registration with ProcessManager.
- */
-class Quire11ty {
   /**
-   * Create Quire11ty instance
-   * @param {Object} pathsInstance - Paths instance for path resolution
+   * Set Eleventy passthrough copy options
+   * @see https://www.11ty.dev/docs/copy/#advanced-options
+   * @see https://github.com/timkendrick/recursive-copy
    */
-  constructor(pathsInstance) {
-    this.paths = pathsInstance
-    /**
-     * Active Eleventy instance (for API mode)
-     * @type {Eleventy|null}
-     */
-    this.activeInstance = null
+  const copyOptions = {
+    debug: options.debug || false
   }
 
   /**
-   * Check if an Eleventy process is currently active
-   * @returns {boolean}
+   * Set environment variables for paths relative to eleventy `input` dir,
+   * to allow `quire-11ty` to be decouple from the project input directory.
+   * Nota bene: environment variables read into the eleventy configuration
+   * file _must_ be set before the eleventy configuration file is parsed.
+   * @see https://github.com/11ty/eleventy/issues/2655
    */
-  isActive() {
-    return this.activeInstance !== null
-  }
+  process.env.ELEVENTY_DATA = paths.data
+  process.env.ELEVENTY_INCLUDES = paths.includes
+  process.env.ELEVENTY_LAYOUTS = paths.layouts
 
   /**
-   * Gracefully close any active Eleventy process
+   * Get an instance of the runtime of eleventy.
+   * @see https://github.com/11ty/eleventy/blob/src/Eleventy.js
    *
-   * Calls eleventy.close() to stop the dev server and file watchers.
-   * This method is registered with ProcessManager for signal handling.
+   * @param {String} input  Path from which to read content templates
+   * @param {String} output  Path where rendered files will be written
+   * @param {Object} options  Options are merged with the Eleventy UserConfig
+   * @param {Object} config  An eleventy configurtion object
    *
-   * @returns {Promise<void>}
+   * @returns {module:11ty/eleventy/Eleventy~Eleventy}
    */
-  async close() {
-    if (this.activeInstance) {
-      debug('shutting down Eleventy')
-      try {
-        await this.activeInstance.close()
-      } catch (error) {
-        // Ignore errors during shutdown (may already be closing)
-        debug('close error (may be expected): %s', error.message)
+  const eleventy = new Eleventy(input, output, {
+    config: (eleventyConfig) => {
+      /**
+       * Override addPassthroughCopy to use _absolute_ system paths.
+       * @see https://www.11ty.dev/docs/copy/#passthrough-file-copy
+       * Nota bene: Eleventy addPassthroughCopy assumes paths are _relative_
+       * to the `config` file however the quire-cli separates 11ty from the
+       * project directory (`input`) and needs to use absolute system paths.
+       */
+      const addPassthroughCopy = eleventyConfig.addPassthroughCopy.bind(eleventyConfig)
+      eleventyConfig.addPassthroughCopy = (entry) => {
+        if (typeof entry === 'string') {
+          const filePath = path.resolve(entry) //path.join(projectRoot, file)
+          // console.debug('[11ty:API] passthrough copy %s', filePath)
+          return addPassthroughCopy(filePath, copyOptions)
+        } else {
+          // console.debug('[11ty:API] passthrough copy %o', entry)
+          entry = Object.fromEntries(
+            Object.entries(entry).map(([ src, dest ]) => {
+              return [ path.join(eleventyRoot, src), path.resolve(dest) ]
+            })
+          )
+          // console.debug('[11ty:API] passthrough copy %o', entry)
+          return addPassthroughCopy(entry, copyOptions)
+        }
       }
-      this.activeInstance = null
-    }
-  }
-
-  /**
-   * Run Eleventy production build
-   *
-   * @param {Object} options - Build options
-   * @param {boolean} [options.debug=false] - Enable debug output
-   * @param {boolean} [options.dryRun=false] - Perform dry run without writing files
-   * @param {boolean} [options.quiet=false] - Suppress output
-   * @returns {Promise<void>}
-   */
-  async build(options = {}) {
-    const projectRoot = this.paths.getProjectRoot()
-    process.chdir(projectRoot)
-
-    configureEleventyEnv({ mode: 'production', ...options })
-
-    const eleventy = await createEleventyInstance(options)
 
-    eleventy.setDryRun(options.dryRun)
+      /**
+       * Event callback when a build completes
+       * @see https://www.11ty.dev/docs/events/#eleventy.after
+       */
+      eleventyConfig.on('eleventy.after', async () => {
+        console.debug('[11ty:API] build complete')
+      })
 
-    reporter.start('Building site...', { showElapsed: true })
+      return eleventyConfig
+    },
+    configPath: options.config || config,
+    quietMode: options.quiet || false,
+  })
 
-    try {
-      await eleventy.write()
-      reporter.succeed('Build complete')
-    } catch (error) {
-      reporter.fail('Build failed')
-      throw error
-    }
-  }
+  return eleventy
+}
 
-  /**
-   * Run Eleventy development server
-   *
-   * @param {Object} options - Serve options
-   * @param {boolean} [options.debug=false] - Enable debug output
-   * @param {number} [options.port] - Server port
-   * @param {boolean} [options.quiet=false] - Suppress output
-   * @returns {Promise<void>}
-   */
-  async serve(options = {}) {
-    const projectRoot = this.paths.getProjectRoot()
-    process.chdir(projectRoot)
+/**
+ * A wrapper module for using the Eleventy programmatic API
+ * @see https://www.11ty.dev/docs/programmatic/
+ * @todo read paths from the Quire project configuration
+ */
+export default {
+  build: async (options = {}) => {
+    process.cwd(projectRoot)
 
-    configureEleventyEnv({ mode: 'development', ...options })
+    console.info('[CLI:11ty] running eleventy build')
 
-    const eleventy =
-      await createEleventyInstance({ ...options, runMode: 'serve' })
+    process.env.ELEVENTY_ENV = 'production'
+    if (options.debug) process.env.DEBUG = 'Eleventy*'
 
-    // Store reference for lifecycle management (graceful shutdown)
-    this.activeInstance = eleventy
+    const eleventy = await factory(options)
 
-    // Initialize Eleventy (required before watch/serve)
-    await eleventy.init()
+    eleventy.setDryRun(options.dryrun)
 
-    reporter.start('Building site...', { showElapsed: true })
+    await eleventy.write()
+  },
+  serve: async (options = {}) => {
+    process.cwd(projectRoot)
 
-    // Build the site and start file watchers.
-    // watch() performs the initial build via write(), then sets up chokidar
-    // file watchers for incremental rebuilds on file changes.
-    // This matches the Eleventy CLI sequence: init() → watch() → serve()
-    // @see https://github.com/11ty/eleventy/blob/main/cmd.cjs
-    await eleventy.watch()
+    console.info('[CLI:11ty] running development server')
 
-    reporter.succeed('Build complete')
-    reporter.start('Starting development server...')
+    process.env.ELEVENTY_ENV = 'development'
+    if (options.debug) process.env.DEBUG = 'Eleventy*'
 
-    // Register a ready callback to resolve the spinner when the server is listening
-    // @see https://www.11ty.dev/docs/dev-server/#options
-    eleventy.eleventyServe.config.serverOptions = {
-      ...eleventy.eleventyServe.config.serverOptions,
-      ready: (server) => {
-        const url = server.getServerUrl('localhost')
-        reporter.succeed(`Server running at ${url}`)
-        if (options.open) {
-          import('open').then(({ default: open }) => open(url))
-        }
-      },
-    }
+    const eleventy = await factory(options)
 
-    // Start the HTTP dev server (serves the built _site/ directory)
     await eleventy.serve(options.port)
   }
 }
-
-export { Quire11ty, createEleventyInstance, configureEleventyEnv }

package/src/lib/11ty/cli.js

@@ -1,35 +1,7 @@
 import { execa } from 'execa'
 import fs from 'node:fs'
 import path from 'node:path'
-import paths from '#lib/project/index.js'
-import processManager from '#lib/process/manager.js'
-import reporter from '#lib/reporter/index.js'
-import { BuildFailedError } from '#src/errors/index.js'
-import createDebug from '#debug'
-
-const debug = createDebug('lib:11ty')
-
-/**
- * Spawn a cancellable subprocess with output piped to stdout
- *
- * @param {string[]} command - Command arguments for node
- * @param {Object} options - Spawn options
- * @param {string} options.cwd - Working directory
- * @param {Object} options.env - Environment variables
- * @returns {import('execa').ExecaChildProcess}
- */
-const spawn = (command, { cwd, env }) => {
-  const subprocess = execa('node', command, {
-    all: true,
-    cwd,
-    env,
-    execPath: process.execPath,
-    cancelSignal: processManager.signal,
-    gracefulCancel: true,
-  })
-  subprocess.all.pipe(process.stdout)
-  return subprocess
-}
+import paths, { eleventyRoot, projectRoot } from './paths.js'
 
 /**
  * A factory function to configure an Eleventy CLI command
@@ -38,21 +10,20 @@ const spawn = (command, { cwd, env }) => {
  * @return  {Array} Eleventy CLI options
  */
 const factory = (options = {}) => {
-  const config = paths.getConfigPath()
-  const eleventyRoot = paths.getEleventyRoot()
-  const input = paths.getInputDir()
-  const output = paths.getOutputDir()
-  const projectRoot = paths.getProjectRoot()
+  const { config, input, output } = paths
 
-  debug('projectRoot: %s', projectRoot)
-  debug('paths: %O', paths.toObject())
+  if (options.debug) {
+    console.debug('[CLI:11ty] projectRoot %s\n%o', projectRoot, paths)
+  }
 
   /**
    * Use the version of Eleventy installed to `lib/quire/versions`
-   * Nota bene: in eleventy v3 the CLI extension (".cjs") is load-bearing but v2 is simply ".js"
+   * 
+   * NB: in eleventy v3 the CLI extension (".cjs") is load-bearing but v2 is simply ".js"
+   * 
    */
   const eleventyModuleDir = path.join(eleventyRoot, 'node_modules', '@11ty', 'eleventy')
-  const packagePath = path.join(eleventyModuleDir,'package.json')
+  const packagePath = path.join(eleventyModuleDir,'package.json')  
 
   const pack = JSON.parse(fs.readFileSync(packagePath))
 
@@ -88,35 +59,14 @@ const factory = (options = {}) => {
    * @see https://github.com/11ty/eleventy/issues/2655
    */
   const env = {
-    ELEVENTY_DATA: paths.getDataDir(),
-    ELEVENTY_INCLUDES: paths.getIncludesDir(),
-    ELEVENTY_LAYOUTS: paths.getLayoutsDir(),
-  }
-
-  // QUIRE_LOG_LEVEL controls output from the quire-11ty chalk logger,
-  // the Vite plugin logLevel, and the directory output plugin registration.
-  // @see packages/cli/docs/cli-output-modes.md
-  if (options.quiet) {
-    env.QUIRE_LOG_LEVEL = 'silent'
-  } else if (options.debug) {
-    env.QUIRE_LOG_LEVEL = 'debug'
-  } else if (options.verbose) {
-    env.QUIRE_LOG_LEVEL = 'info'
-  } else {
-    env.QUIRE_LOG_LEVEL = 'warn'
-  }
-
-  // Forward CLI log prefix and show-level settings (set by configureLogEnv)
-  if (process.env.QUIRE_LOG_PREFIX !== undefined) {
-    env.QUIRE_LOG_PREFIX = process.env.QUIRE_LOG_PREFIX
-  }
-  if (process.env.QUIRE_LOG_SHOW_LEVEL !== undefined) {
-    env.QUIRE_LOG_SHOW_LEVEL = process.env.QUIRE_LOG_SHOW_LEVEL
+    ELEVENTY_DATA: paths.data,
+    ELEVENTY_INCLUDES: paths.includes,
+    ELEVENTY_LAYOUTS: paths.layouts,
   }
 
   if (options.debug) env.DEBUG = 'Eleventy*'
 
-  return { command, env, projectRoot }
+  return { command, env }
 }
 
 /**
@@ -124,70 +74,45 @@ const factory = (options = {}) => {
  * @see https://www.11ty.dev/docs/usage/#command-line-usage
  */
 export default {
-  /**
-   * Run Eleventy build via CLI
-   * @param {Object} options - Build options
-   */
   build: async (options = {}) => {
-    const { command, env, projectRoot } = factory(options)
+    console.info('[CLI:11ty] running eleventy build')
+
+    const { command, env } = factory(options)
 
     if (options.dryRun) command.push('--dryrun')
 
     env.ELEVENTY_ENV = 'production'
 
-    reporter.start('Building site...', { showElapsed: true })
-
-    try {
-      const build = spawn(command, { cwd: projectRoot, env })
-      await build
-
-      if (build.exitCode !== 0) {
-        throw new BuildFailedError(`Eleventy exited with code ${build.exitCode}`)
-      }
-      reporter.succeed('Build complete')
-    } catch (error) {
-      if (error.isCanceled) {
-        debug('build cancelled')
-        return
-      }
-      reporter.fail('Build failed')
-      throw error
+    const build = execa('node', command, {
+      all: true,
+      cwd: projectRoot,
+      env,
+      execPath: process.execPath
+    })
+    build.all.pipe(process.stdout)
+    await build
+
+    if (build.exitCode !== 0) {
+      process.exit(build.exitCode)
     }
   },
 
-  /**
-   * Run Eleventy development server via CLI
-   * @param {Object} options - Serve options
-   */
   serve: async (options = {}) => {
-    const { command, env, projectRoot } = factory(options)
+    console.info(`[CLI:11ty] running eleventy serve`)
+
+    const { command, env } = factory(options)
 
     command.push('--serve')
 
-    const port = options.port || 8080
     if (options.port) command.push(`--port=${options.port}`)
 
     env.ELEVENTY_ENV = 'development'
 
-    reporter.start('Starting development server...')
-
-    // Resolve the spinner before the subprocess takes over stdout
-    const url = `http://localhost:${port}`
-    reporter.succeed(`Server running at ${url}`)
-
-    if (options.open) {
-      const { default: open } = await import('open')
-      open(url)
-    }
-
-    try {
-      await spawn(command, { cwd: projectRoot, env })
-    } catch (error) {
-      if (error.isCanceled) {
-        debug('server stopped')
-        return
-      }
-      throw error
-    }
-  },
+    await execa('node', command, {
+      all: true,
+      cwd: projectRoot,
+      env,
+      execPath: process.execPath
+    }).all.pipe(process.stdout)
+  }
 }

package/src/lib/11ty/index.js

@@ -1,70 +1,11 @@
-/**
- * Quire Eleventy integration module
- *
- * Provides a unified façade for Eleventy operations following the singleton
- * pattern established by lib/npm and lib/git. Integrates with the central
- * ProcessManager for graceful shutdown on process signals.
- *
- * @example Recommended usage
- * import eleventy from '#lib/11ty/index.js'
- * await eleventy.build({ debug: true })
- * const outputDir = eleventy.paths.getOutputDir()
- *
- * @example Path-only usage (for consumers that only need paths)
- * import { paths } from '#lib/11ty/index.js'
- * const projectRoot = paths.getProjectRoot()
- *
- * @example Legacy usage (deprecated)
- * import { api, cli, paths } from '#lib/11ty/index.js'
- *
- * @module lib/11ty
- */
-import { Quire11ty } from './api.js'
-import cliModule from './cli.js'
-import paths, { Paths } from '#lib/project/index.js'
-import processManager from '#lib/process/manager.js'
+import cli from './cli.js'
+import api from './api.js'
+import paths, { eleventyRoot, projectRoot } from './paths.js'
 
-/**
- * Quire11ty singleton instance
- * @type {Quire11ty}
- */
-const eleventy = new Quire11ty(paths)
-
-/**
- * CLI wrapper - delegates to cli.js which imports processManager directly
- */
-const cli = {
-  build: async (options) => cliModule.build(options),
-  serve: async (options) => cliModule.serve(options),
-}
-
-/**
- * Legacy API export for backwards compatibility
- *
- * Wraps the singleton methods to register cleanup handlers with
- * ProcessManager for graceful shutdown support.
- *
- * @deprecated Use default export instead: `import eleventy from '#lib/11ty/index.js'`
- */
-const api = {
-  build: async (options) => eleventy.build(options),
-  serve: async (options) => {
-    processManager.onShutdown('eleventy', () => eleventy.close())
-    try {
-      return await eleventy.serve(options)
-    } finally {
-      processManager.onShutdownComplete('eleventy')
-    }
-  },
-}
-
-// Default export: unified façade
-export default eleventy
-
-// Named exports for backwards compatibility and path-only consumers
 export {
   api,
   cli,
+  eleventyRoot,
   paths,
-  Paths,
+  projectRoot,
 }