@cregis-dev/cckit 0.2.0

package/src/cli.js

@@ -0,0 +1,88 @@
+import { Command } from 'commander'
+import { runInit } from './commands/init.js'
+
+export function run(argv) {
+  const program = new Command()
+
+  program
+    .name('cckit')
+    .description('Multi-IDE AI dev environment setup CLI — BMAD + ECC + Skills + MCP')
+    .version('0.1.0')
+
+  program
+    .command('init')
+    .description('Initialize project with BMAD + ECC + Trae + MCP')
+    .option('-y, --yes', 'Accept all defaults', false)
+    .option('-d, --dir <path>', 'Target directory', process.cwd())
+    .option('--user-name <name>', 'Your name for agents')
+    .option('-l, --lang <codes>', 'Languages: ts,py,go')
+    .option('-m, --modules <ids>', 'Module ids or "all"')
+    .option('--ides <ids>', 'IDE targets: claude-code,trae')
+    .option('--no-bmad', 'Skip BMAD modules')
+    .option('--no-ecc', 'Skip ECC modules')
+    .option('--no-trae', 'Skip Trae config')
+    .option('--no-mcp', 'Skip MCP config')
+    .option('--plugins <ids>', 'Plugin ids, "default", or "none"')
+    .option('--no-plugins', 'Skip plugin installation')
+    .option('--communication-language <lang>', 'Communication language')
+    .option('--doc-language <lang>', 'Document output language')
+    .option('--debug', 'Debug output', false)
+    .action(async (opts) => {
+      try {
+        await runInit(opts)
+      } catch (err) {
+        console.error(`\n  Error: ${err.message}\n`)
+        process.exit(1)
+      }
+    })
+
+  program
+    .command('status')
+    .description('Show installation status')
+    .option('-d, --dir <path>', 'Target directory', process.cwd())
+    .action(async (opts) => {
+      try {
+        const { runStatus } = await import('./commands/status.js')
+        await runStatus(opts)
+      } catch (err) {
+        console.error(`\n  Error: ${err.message}\n`)
+        process.exit(1)
+      }
+    })
+
+  program
+    .command('update')
+    .description('Check for and apply updates to installed modules')
+    .option('-d, --dir <path>', 'Target directory', process.cwd())
+    .option('--dry-run', 'Preview changes without applying', false)
+    .option('--no-apply', 'Check only, do not apply updates')
+    .option('--force', 'Force overwrite modified files without backup', false)
+    .option('--debug', 'Debug output', false)
+    .action(async (opts) => {
+      try {
+        const { runUpdate } = await import('./commands/update.js')
+        // Default: apply=true (Commander sets opts.apply=false when --no-apply is passed)
+        await runUpdate({ ...opts, apply: opts.apply !== false })
+      } catch (err) {
+        console.error(`\n  Error: ${err.message}\n`)
+        process.exit(1)
+      }
+    })
+
+  program
+    .command('add <url>')
+    .description('Install a third-party plugin from GitHub')
+    .option('-d, --dir <path>', 'Target directory', process.cwd())
+    .option('--debug', 'Debug output', false)
+    .action(async (url, opts) => {
+      try {
+        const { runAdd } = await import('./commands/add.js')
+        await runAdd({ url, ...opts })
+      } catch (err) {
+        console.error(`\n  Error: ${err.message}\n`)
+        process.exit(1)
+      }
+    })
+
+  program.parse(argv)
+}

package/src/commands/add.js

@@ -0,0 +1,192 @@
+/**
+ * add command — install a third-party plugin from a GitHub URL.
+ *
+ * Flow:
+ * 1. Validate cckit is installed (manifest exists)
+ * 2. Validate URL is GitHub
+ * 3. Clone repo to temp dir (depth 1)
+ * 4. Read and validate cckit-plugin.json
+ * 5. Install plugin content per IDE config
+ * 6. Update manifest with new plugin entry
+ * 7. Cleanup temp dir
+ */
+
+import path from 'node:path'
+import fse from 'fs-extra'
+import os from 'node:os'
+import YAML from 'yaml'
+import { execFile as execFileCb } from 'node:child_process'
+import { promisify } from 'node:util'
+import { mkdtemp } from 'node:fs/promises'
+import { createLogger } from '../utils/logger.js'
+import { installForTrae } from '../core/plugin-installer.js'
+
+const execFile = promisify(execFileCb)
+
+const GITHUB_URL_RE = /^https?:\/\/github\.com\/[\w.-]+\/[\w.-]+/
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+/**
+ * Extract repository name from a GitHub URL.
+ * @param {string} url - GitHub URL
+ * @returns {string} Repo name (last path segment, without .git)
+ */
+function extractRepoName(url) {
+  const cleaned = url.replace(/\.git$/, '').replace(/\/+$/, '')
+  const segments = cleaned.split('/')
+  return segments[segments.length - 1]
+}
+
+/**
+ * Validate cckit-plugin.json manifest fields.
+ * @param {object} manifest - Parsed plugin manifest
+ * @throws {Error} if required fields are missing
+ */
+function validatePluginManifest(manifest) {
+  if (!manifest || typeof manifest !== 'object') {
+    throw new Error('cckit-plugin.json must be a valid JSON object')
+  }
+  if (!manifest.name || typeof manifest.name !== 'string') {
+    throw new Error('cckit-plugin.json must have a "name" field (string)')
+  }
+  if (!manifest.version || typeof manifest.version !== 'string') {
+    throw new Error('cckit-plugin.json must have a "version" field (string)')
+  }
+  if (!manifest.contents || typeof manifest.contents !== 'object') {
+    throw new Error('cckit-plugin.json must have a "contents" field (object)')
+  }
+}
+
+/**
+ * Default git clone implementation (depth 1).
+ * @param {string} url - Repository URL
+ * @param {string} dest - Destination directory
+ */
+async function defaultCloneRepo(url, dest) {
+  await execFile('git', ['clone', '--depth', '1', url, dest])
+}
+
+/**
+ * Install a plugin for Trae IDE.
+ * Reuses the installForTrae function from plugin-installer, but wraps
+ * the cloned repo data into the format it expects.
+ * @param {string} pluginDir - Clone directory root
+ * @param {object} pluginManifest - Parsed cckit-plugin.json
+ * @param {string} pluginId - Plugin identifier
+ * @param {string} targetDir - Project root
+ * @param {object} variables - Interpolation variables
+ * @param {object} logger - Logger instance
+ */
+async function installPluginForTrae(pluginDir, pluginManifest, pluginId, targetDir, variables, logger) {
+  // Build a plugin entry compatible with installForTrae's expected format
+  const pluginEntry = {
+    id: pluginId,
+    def: pluginManifest,
+    templateDir: pluginDir,
+  }
+
+  return installForTrae([pluginEntry], targetDir, variables, logger)
+}
+
+// ─── Main Command ────────────────────────────────────────────────────────────
+
+/**
+ * Run the `add` command — install a third-party plugin from GitHub.
+ *
+ * @param {object} opts
+ * @param {string} opts.url - GitHub repository URL
+ * @param {string} [opts.dir] - Target project directory
+ * @param {boolean} [opts.debug] - Enable debug output
+ * @param {object} [opts._deps] - Dependency injection for testing
+ * @returns {Promise<{ pluginId: string, installed: boolean }>}
+ */
+export async function runAdd(opts = {}) {
+  const { url, dir = process.cwd(), debug = false, _deps = {} } = opts
+  const logger = _deps.logger || createLogger({ debug })
+  const cloneRepo = _deps.cloneRepo || defaultCloneRepo
+
+  // 1. Validate cckit is installed (manifest exists)
+  const manifestPath = path.join(dir, '_bmad', '_config', 'manifest.yaml')
+  if (!(await fse.pathExists(manifestPath))) {
+    throw new Error('cckit is not installed in this directory. Run "cckit init" first.')
+  }
+
+  // 2. Validate URL is GitHub
+  if (!GITHUB_URL_RE.test(url)) {
+    throw new Error('Only GitHub URLs are supported. Please provide a valid GitHub repository URL.')
+  }
+
+  // 3. Clone repo to temp dir
+  const tmpBase = await mkdtemp(path.join(os.tmpdir(), 'cckit-add-'))
+  const repoName = extractRepoName(url)
+  const cloneDir = path.join(tmpBase, repoName)
+
+  try {
+    logger.step(1, 4, 'Cloning repository...')
+    await cloneRepo(url, cloneDir)
+
+    // 4. Read and validate cckit-plugin.json
+    const pluginJsonPath = path.join(cloneDir, 'cckit-plugin.json')
+    if (!(await fse.pathExists(pluginJsonPath))) {
+      throw new Error(
+        `Repository does not contain a cckit-plugin.json file. ` +
+        `This is required for cckit plugins.`
+      )
+    }
+
+    const pluginManifest = await fse.readJson(pluginJsonPath)
+    validatePluginManifest(pluginManifest)
+
+    const pluginId = pluginManifest.name
+
+    // Read project manifest to get IDE config
+    const manifest = YAML.parse(await fse.readFile(manifestPath, 'utf8'))
+    const config = manifest.cckit?.config || {}
+    const ides = config.ides || ['claude-code']
+
+    // Build interpolation variables
+    const variables = {
+      user_name: config.user_name || '',
+      communication_language: config.communication_language || 'English',
+      document_output_language: config.document_output_language || 'English',
+      languages: (config.languages || []).join(', '),
+      'project-root': '.',
+    }
+
+    // 5. Install plugin content for Trae
+    logger.step(2, 4, `Installing plugin "${pluginId}"...`)
+
+    if (ides.includes('trae')) {
+      logger.debug('Installing for Trae...')
+      await installPluginForTrae(cloneDir, pluginManifest, pluginId, dir, variables, logger)
+    }
+
+    // 6. Update manifest with new plugin entry
+    logger.step(3, 4, 'Updating manifest...')
+    const pluginEntry = {
+      id: pluginId,
+      version: pluginManifest.version,
+      source: url,
+    }
+
+    const existingPlugins = manifest.cckit.plugins || []
+    const updatedManifest = {
+      ...manifest,
+      cckit: {
+        ...manifest.cckit,
+        plugins: [...existingPlugins, pluginEntry],
+      },
+    }
+
+    await fse.writeFile(manifestPath, YAML.stringify(updatedManifest), 'utf8')
+
+    logger.step(4, 4, 'Done!')
+    logger.success(`Plugin "${pluginId}" (v${pluginManifest.version}) installed successfully.`)
+
+    return { pluginId, installed: true }
+  } finally {
+    // 7. Cleanup temp dir
+    await fse.remove(tmpBase).catch(() => {})
+  }
+}

package/src/commands/init.js

@@ -0,0 +1,333 @@
+import path from 'node:path'
+import fse from 'fs-extra'
+import { fileURLToPath } from 'node:url'
+import YAML from 'yaml'
+import { loadRegistry, getDefaultModules, resolveModules } from '../core/registry.js'
+import { mergeConfig } from '../core/config.js'
+import { Installer } from '../core/installer.js'
+import { ADAPTERS } from '../adapters/trae-adapter.js'
+import { getDefaultPlugins, resolvePlugins, installPlugins } from '../core/plugin-installer.js'
+import { createLogger } from '../utils/logger.js'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const CCKIT_ROOT = path.resolve(__dirname, '../..')
+
+const SCAFFOLD_DIRS = [
+  '_bmad-output/planning-artifacts',
+  '_bmad-output/implementation-artifacts',
+  '_bmad-output/test-artifacts',
+  'docs'
+]
+
+const MANIFEST_REL = path.join('_bmad', '_config', 'manifest.yaml')
+
+/**
+ * Resolve modules with per-IDE targets into a flat list of installable entries.
+ *
+ * - Modules with `targets` map: expanded into one entry per selected IDE
+ * - Modules with `ideTarget`: included only if matching IDE is selected
+ * - IDE-agnostic modules: included once as-is
+ *
+ * Each expanded entry gets an absolute `templateDir` and the correct
+ * `adapter` function / `prefix` from the ADAPTERS map.
+ *
+ * @param {Array<object>} modules - Resolved module objects from registry
+ * @param {string[]} ides - Selected IDE identifiers
+ * @returns {Array<object>} Flat list of installable module entries
+ */
+export function resolveModuleTargets(modules, ides) {
+  const resolved = []
+
+  for (const mod of modules) {
+    if (mod.targets) {
+      for (const ide of ides) {
+        if (mod.targets[ide]) {
+          const target = mod.targets[ide]
+          resolved.push({
+            ...mod,
+            targetDir: target.targetDir,
+            templateDir: target.templateDir || mod.templateDir,
+            adapter: target.adapter ? ADAPTERS[target.adapter] : undefined,
+            prefix: target.prefix || undefined,
+            id: `${mod.id}@${ide}`
+          })
+        }
+      }
+    } else if (mod.ideTarget) {
+      if (ides.includes(mod.ideTarget)) {
+        resolved.push(mod)
+      }
+    } else {
+      resolved.push(mod)
+    }
+  }
+
+  return resolved
+}
+
+/**
+ * Make templateDir paths absolute relative to cckit package root.
+ *
+ * @param {Array<object>} modules - Module entries with relative templateDir
+ * @returns {Array<object>} New array with absolute templateDir paths
+ */
+function absolutizeTemplateDirs(modules) {
+  return modules.map(mod => ({
+    ...mod,
+    templateDir: path.resolve(CCKIT_ROOT, mod.templateDir)
+  }))
+}
+
+/**
+ * Filter out modules whose template directories don't exist yet.
+ * Returns a tuple of [installable, skipped] arrays.
+ *
+ * @param {Array<object>} modules - Module entries with absolute templateDir
+ * @param {object} logger - Logger instance
+ * @returns {Promise<[Array<object>, Array<object>]>} [installable, skipped]
+ */
+async function filterExistingTemplates(modules, logger) {
+  const installable = []
+  const skipped = []
+
+  for (const mod of modules) {
+    const exists = await fse.pathExists(mod.templateDir)
+    if (exists) {
+      // Also check the directory is not empty
+      const files = await fse.readdir(mod.templateDir)
+      if (files.length > 0) {
+        installable.push(mod)
+      } else {
+        logger.warn(`Skipping ${mod.name} (${mod.id}): template directory is empty`)
+        skipped.push({ id: mod.id, name: mod.name, reason: 'empty template directory' })
+      }
+    } else {
+      logger.warn(`Skipping ${mod.name} (${mod.id}): template not found at ${mod.templateDir}`)
+      skipped.push({ id: mod.id, name: mod.name, reason: 'template directory not found' })
+    }
+  }
+
+  return [installable, skipped]
+}
+
+/**
+ * Filter modules by excludeGroups config.
+ * Module id prefixes map to groups: bmad-* -> bmad, ecc-* -> ecc, mcp -> mcp.
+ *
+ * @param {Array<object>} modules - Module entries
+ * @param {string[]} excludeGroups - Groups to exclude
+ * @returns {Array<object>} Filtered modules
+ */
+function filterByGroups(modules, excludeGroups) {
+  if (!excludeGroups || excludeGroups.length === 0) return modules
+
+  return modules.filter(mod => {
+    // Extract base id (before @ide suffix)
+    const baseId = mod.id.includes('@') ? mod.id.split('@')[0] : mod.id
+    for (const group of excludeGroups) {
+      if (baseId === group || baseId.startsWith(`${group}-`)) {
+        return false
+      }
+    }
+    return true
+  })
+}
+
+/**
+ * Build the interpolation variables object from config.
+ *
+ * @param {object} config - Merged config
+ * @returns {object} Variables for template interpolation
+ */
+function buildVariables(config) {
+  return {
+    user_name: config.user_name,
+    communication_language: config.communication_language,
+    document_output_language: config.document_output_language,
+    languages: config.languages.join(', '),
+    'project-root': '.'
+  }
+}
+
+/**
+ * Create the manifest.yaml content.
+ *
+ * @param {object} params
+ * @param {object} params.config - Merged config
+ * @param {Array<object>} params.installed - Installed module summaries
+ * @param {Array<object>} params.skipped - Skipped module summaries
+ * @param {object} params.fileRegistry - File hash registry
+ * @param {string[]} [params.plugins] - Installed plugin IDs
+ * @returns {string} YAML content
+ */
+function buildManifest({ config, installed, skipped, fileRegistry, plugins }) {
+  const manifest = {
+    cckit: {
+      version: '0.1.0',
+      installedAt: new Date().toISOString(),
+      config: {
+        user_name: config.user_name,
+        communication_language: config.communication_language,
+        document_output_language: config.document_output_language,
+        languages: config.languages,
+        ides: config.ides
+      },
+      modules: {
+        installed: installed.map(m => ({ id: m.id, name: m.name, files: m.files })),
+        skipped: skipped.map(m => ({ id: m.id, reason: m.reason }))
+      },
+      plugins: plugins || [],
+      fileRegistry
+    }
+  }
+
+  return YAML.stringify(manifest)
+}
+
+/**
+ * Run the init command.
+ *
+ * @param {object} opts - Commander options
+ * @param {string} [opts.dir] - Target directory (default: cwd)
+ * @param {boolean} [opts.yes] - Accept all defaults
+ * @param {string} [opts.userName] - User name override
+ * @param {string} [opts.communicationLanguage] - Communication language override
+ * @param {string} [opts.docLanguage] - Document output language override
+ * @param {string} [opts.lang] - Comma-separated language aliases
+ * @param {string} [opts.modules] - "all" or comma-separated module IDs
+ * @param {string} [opts.ides] - Comma-separated IDE identifiers
+ * @param {boolean} [opts.trae] - Set to false to exclude trae
+ * @param {boolean} [opts.bmad] - Set to false to exclude bmad modules
+ * @param {boolean} [opts.ecc] - Set to false to exclude ecc modules
+ * @param {boolean} [opts.mcp] - Set to false to exclude mcp modules
+ * @param {boolean} [opts.debug] - Enable debug output
+ * @returns {Promise<object>} Result with installed/skipped arrays
+ * @throws {Error} If already installed
+ */
+export async function runInit(opts = {}) {
+  const targetDir = path.resolve(opts.dir || process.cwd())
+  const logger = createLogger({ debug: opts.debug })
+
+  // Step 1: Check if already installed
+  const manifestPath = path.join(targetDir, MANIFEST_REL)
+  if (await fse.pathExists(manifestPath)) {
+    throw new Error(
+      `cckit is already installed in this project. ` +
+      `Found existing manifest at ${MANIFEST_REL}. ` +
+      `Use "cckit update" to modify your installation.`
+    )
+  }
+
+  logger.banner('cckit init')
+
+  // Step 2: Load registry
+  const registry = await loadRegistry()
+
+  // Step 3: Merge config from flags (--yes = use defaults)
+  const config = mergeConfig(opts)
+  logger.debug(`Config: ${JSON.stringify(config, null, 2)}`)
+
+  // Step 4: Resolve modules from config
+  const selectedIds = config.modules === 'all'
+    ? getDefaultModules(registry)
+    : config.modules
+
+  const resolvedModules = resolveModules(registry, selectedIds)
+  logger.debug(`Resolved ${resolvedModules.length} modules from registry`)
+
+  // Step 5: Resolve per-IDE targets
+  const targetModules = resolveModuleTargets(resolvedModules, config.ides)
+  logger.debug(`Expanded to ${targetModules.length} target entries for IDEs: ${config.ides.join(', ')}`)
+
+  // Step 6: Filter by excludeGroups
+  const filteredModules = filterByGroups(targetModules, config.excludeGroups)
+  logger.debug(`After group filtering: ${filteredModules.length} modules`)
+
+  // Step 7: Absolutize template paths
+  const withAbsPaths = absolutizeTemplateDirs(filteredModules)
+
+  // Step 8: Filter out modules with missing templates
+  const [installable, skipped] = await filterExistingTemplates(withAbsPaths, logger)
+  logger.info(`  ${installable.length} modules to install, ${skipped.length} skipped (templates pending)`)
+
+  // Step 9: Run installer for modules that have templates
+  const variables = buildVariables(config)
+  let installResult = { installed: [], fileRegistry: {} }
+
+  if (installable.length > 0) {
+    const installer = new Installer({ targetDir, logger })
+    installResult = await installer.install(installable, variables)
+  }
+
+  // Step 9.5: Install plugins
+  let pluginResult = { claudeCode: [], trae: { files: 0, details: [] }, installed: [] }
+  let pluginSkippedEntries = []
+
+  if (config.plugins !== 'none') {
+    const pluginIds = config.plugins === 'default'
+      ? getDefaultPlugins(registry)
+      : Array.isArray(config.plugins) ? config.plugins : []
+
+    if (pluginIds.length > 0) {
+      const templatesBase = path.resolve(CCKIT_ROOT, 'templates')
+      const { found, skipped: pluginSkipped } = resolvePlugins(registry, pluginIds, templatesBase, logger)
+
+      if (found.length > 0) {
+        pluginResult = await installPlugins({
+          plugins: found,
+          targetDir,
+          ides: config.ides,
+          variables,
+          logger,
+        })
+
+        if (pluginResult.installed.length > 0) {
+          logger.success(`Plugins: ${pluginResult.installed.join(', ')}`)
+        }
+      }
+
+      pluginSkippedEntries = pluginSkipped.map(ps => ({
+        id: `plugin:${ps.id}`,
+        name: ps.id,
+        reason: ps.reason,
+      }))
+    }
+  }
+
+  const allSkipped = [...skipped, ...pluginSkippedEntries]
+
+  // Step 10: Create scaffold directories
+  for (const dir of SCAFFOLD_DIRS) {
+    const fullPath = path.join(targetDir, dir)
+    await fse.ensureDir(fullPath)
+    logger.debug(`Created scaffold: ${dir}`)
+  }
+
+  // Step 11: Ensure manifest directory exists and write manifest
+  await fse.ensureDir(path.dirname(manifestPath))
+  const manifestContent = buildManifest({
+    config,
+    installed: installResult.installed,
+    skipped: allSkipped,
+    fileRegistry: installResult.fileRegistry,
+    plugins: pluginResult.installed,
+  })
+  await fse.writeFile(manifestPath, manifestContent, 'utf8')
+  logger.success(`Manifest written to ${MANIFEST_REL}`)
+
+  // Step 12: Summary
+  logger.newline()
+  logger.banner('Init complete!')
+  logger.info(`  Installed: ${installResult.installed.length} modules`)
+  if (allSkipped.length > 0) {
+    logger.info(`  Skipped:   ${allSkipped.length} modules (templates pending)`)
+  }
+  logger.newline()
+
+  return {
+    installed: installResult.installed,
+    skipped: allSkipped,
+    fileRegistry: installResult.fileRegistry,
+    plugins: pluginResult.installed,
+  }
+}

package/src/commands/status.js

@@ -0,0 +1,62 @@
+import path from 'node:path'
+import fse from 'fs-extra'
+import YAML from 'yaml'
+import chalk from 'chalk'
+
+export async function runStatus(opts = {}) {
+  const targetDir = path.resolve(opts.dir || process.cwd())
+  const manifestPath = path.join(targetDir, '_bmad', '_config', 'manifest.yaml')
+
+  if (!await fse.pathExists(manifestPath)) {
+    const msg = 'cckit is not installed in this directory. Run `cckit init` first.'
+    console.log(`\n  ${chalk.yellow('!')} ${msg}\n`)
+    return { installed: false, output: msg }
+  }
+
+  const content = await fse.readFile(manifestPath, 'utf8')
+  const manifest = YAML.parse(content)
+
+  const lines = []
+  lines.push('')
+  lines.push(chalk.bold('cckit installation status'))
+  lines.push('')
+
+  const installedModules = manifest.cckit?.modules?.installed || manifest.modules || []
+
+  const header = `${'Module'.padEnd(25)} ${'Version'.padEnd(15)} ${'Files'.padEnd(8)}`
+  lines.push(header)
+  lines.push('-'.repeat(50))
+
+  for (const mod of installedModules) {
+    const row = `${(mod.id || mod.name || '-').padEnd(25)} ${(mod.version || '-').padEnd(15)} ${String(mod.files || 0).padEnd(8)}`
+    lines.push(row)
+  }
+
+  lines.push('')
+  lines.push(`Directory: ${targetDir}`)
+  lines.push(`Install date: ${manifest.cckit?.installedAt || manifest.cckit?.installDate || '-'}`)
+  lines.push(`cckit version: ${manifest.cckit?.version || '-'}`)
+
+  // Show plugins if installed
+  const plugins = manifest.cckit?.plugins || []
+  if (plugins.length > 0) {
+    lines.push('')
+    lines.push(chalk.bold('Plugins'))
+    for (const p of plugins) {
+      lines.push(`  ${chalk.green('+')} ${p}`)
+    }
+  }
+
+  lines.push('')
+
+  const output = lines.join('\n')
+  console.log(output)
+
+  return {
+    installed: true,
+    cckit: manifest.cckit,
+    config: manifest.config,
+    modules: manifest.modules || [],
+    output
+  }
+}