@cregis-dev/cckit 0.4.1 → 0.5.0

package/src/commands/init.js

@@ -1,16 +1,22 @@
+/**
+ * init command — orchestrate installation of all components.
+ *
+ * Flow: load registry → merge config → build steps → orchestrate → write manifest
+ */
+
 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 { loadRegistry, resolvePlugins, resolveModelId } from '../core/registry.js'
+import { mergeConfig, DEFAULT_API_URL } from '../core/config.js'
+import { orchestrate } from '../core/orchestrator.js'
+import { MANIFEST_REL, buildManifest, writeManifest } from '../utils/manifest.js'
 import { createLogger } from '../utils/logger.js'
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url))
-const CCKIT_ROOT = path.resolve(__dirname, '../..')
+import { enablePlugins } from '../steps/enable-plugins.js'
+import { installBmad } from '../steps/install-bmad.js'
+import { installRules } from '../steps/install-rules.js'
+import { installSkills } from '../steps/install-skills.js'
+import { installMcp } from '../steps/install-mcp.js'
+import { configureUser } from '../steps/configure-user.js'
 
 const SCAFFOLD_DIRS = [
   '_bmad-output/planning-artifacts',
@@ -19,196 +25,20 @@ const SCAFFOLD_DIRS = [
   '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)
-}
+const VERSION = '0.5.0'
 
 /**
  * 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
+ * @param {object} [_deps] - Injectable dependencies for testing
+ * @returns {Promise<import('../core/orchestrator.js').RunReport>}
  */
-export async function runInit(opts = {}) {
+export async function runInit(opts = {}, _deps = {}) {
   const targetDir = path.resolve(opts.dir || process.cwd())
-  const logger = createLogger({ debug: opts.debug })
+  const logger = _deps.logger || createLogger({ debug: opts.debug })
 
-  // Step 1: Check if already installed
+  // Guard: already installed
   const manifestPath = path.join(targetDir, MANIFEST_REL)
   if (await fse.pathExists(manifestPath)) {
     throw new Error(
@@ -220,118 +50,111 @@ export async function runInit(opts = {}) {
 
   logger.banner('cckit init')
 
-  // Step 2: Load registry
-  const registry = await loadRegistry()
-
-  // Step 3: Merge config from flags (--yes = use defaults)
+  // Load registry and merge config
+  const registry = _deps.registry || await loadRegistry()
   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 + Claude Code settings
-  let pluginResult = { claudeCode: [], trae: { files: 0, details: [] }, installed: [] }
-  let pluginSkippedEntries = []
-
-  let resolvedPlugins = []
-  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)
-      resolvedPlugins = found
-
-      pluginSkippedEntries = pluginSkipped.map(ps => ({
-        id: `plugin:${ps.id}`,
-        name: ps.id,
-        reason: ps.reason,
-      }))
-    }
-  }
-
-  // Always call installPlugins when claude-code is selected (writes env settings)
-  // or when there are resolved plugins to install
-  if (resolvedPlugins.length > 0 || config.ides.includes('claude-code')) {
-    pluginResult = await installPlugins({
-      plugins: resolvedPlugins,
-      targetDir,
-      ides: config.ides,
-      variables,
-      logger,
-    })
-
-    if (pluginResult.installed.length > 0) {
-      logger.success(`Plugins: ${pluginResult.installed.join(', ')}`)
-    }
-  }
+  // Resolve plugins
+  const plugins = resolvePlugins(registry, config)
+
+  // Resolve model ID
+  const userSettings = registry.userSettings || {}
+  const modelId = resolveModelId(userSettings, config.model)
+
+  // Build step list
+  const steps = [
+    {
+      id: 'configure-user',
+      fn: _deps.configureUser || configureUser,
+      opts: {
+        apiUrl: config.apiUrl || userSettings.apiUrl || DEFAULT_API_URL,
+        apiKey: config.apiKey,
+        forceApiKey: config.forceApiKey,
+        modelId,
+        modelEnvKeys: userSettings.modelEnvKeys || [],
+        yes: opts.yes,
+        skip: false,
+      },
+    },
+    {
+      id: 'enable-plugins',
+      fn: _deps.enablePlugins || enablePlugins,
+      opts: {
+        targetDir,
+        plugins,
+        skip: config.plugins === 'none',
+      },
+    },
+    {
+      id: 'install-bmad',
+      fn: _deps.installBmad || installBmad,
+      opts: {
+        targetDir,
+        bmadConfig: registry.bmad,
+        // Only pass explicit CLI overrides (not defaults) to avoid overwriting registry defaults
+        config: {
+          communication_language: opts.communicationLanguage || undefined,
+          document_output_language: opts.docLanguage || undefined,
+        },
+        skip: config.excludeGroups.includes('bmad'),
+      },
+    },
+    {
+      id: 'install-rules',
+      fn: _deps.installRules || installRules,
+      opts: {
+        targetDir,
+        rulesConfig: registry.rules.ecc,
+        skip: config.excludeGroups.includes('ecc'),
+      },
+    },
+    {
+      id: 'install-skills',
+      fn: _deps.installSkills || installSkills,
+      opts: {
+        targetDir,
+        skills: registry.skills || [],
+        skip: config.skipSkills || false,
+      },
+    },
+    {
+      id: 'install-mcp',
+      fn: _deps.installMcp || installMcp,
+      opts: {
+        targetDir,
+        mcpConfig: registry.mcp,
+        skip: config.excludeGroups.includes('mcp'),
+      },
+    },
+  ]
 
-  const allSkipped = [...skipped, ...pluginSkippedEntries]
+  // Orchestrate
+  const report = await orchestrate(steps, logger)
 
-  // 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}`)
-  }
+  // Scaffold directories
+  await Promise.all(SCAFFOLD_DIRS.map(dir => {
+    logger.debug(`Creating scaffold: ${dir}`)
+    return fse.ensureDir(path.join(targetDir, 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')
+  // Write manifest
+  const manifest = buildManifest({ config, report, version: VERSION })
+  await writeManifest(targetDir, manifest)
   logger.success(`Manifest written to ${MANIFEST_REL}`)
 
-  // Step 12: Summary
+  // 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)`)
-  }
+
+  const successCount = report.steps.filter(s => s.success && !s.skipped).length
+  const skipCount = report.steps.filter(s => s.skipped).length
+  const failCount = report.steps.filter(s => !s.success && !s.skipped).length
+
+  logger.info(`  Successful: ${successCount} steps`)
+  if (skipCount > 0) logger.info(`  Skipped:    ${skipCount} steps`)
+  if (failCount > 0) logger.warn(`Failed:     ${failCount} steps`)
   logger.newline()
 
-  return {
-    installed: installResult.installed,
-    skipped: allSkipped,
-    fileRegistry: installResult.fileRegistry,
-    plugins: pluginResult.installed,
-  }
+  return report
 }

package/src/commands/status.js

@@ -1,50 +1,79 @@
+/**
+ * status command — display installation state from manifest.
+ */
+
 import path from 'node:path'
-import fse from 'fs-extra'
-import YAML from 'yaml'
 import chalk from 'chalk'
+import { readManifest, isLegacyManifest } from '../utils/manifest.js'
 
+/**
+ * @param {object} opts
+ * @param {string} [opts.dir] - Target directory
+ * @returns {Promise<object>}
+ */
 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)) {
+  let manifest
+  try {
+    manifest = await readManifest(targetDir)
+  } catch {
     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)
+  // Legacy manifest check
+  if (isLegacyManifest(manifest)) {
+    const msg = 'Legacy manifest detected (v1). Please run `cckit init` to reinstall with the new format.'
+    console.log(`\n  ${chalk.yellow('!')} ${msg}\n`)
+    return { installed: true, legacy: true, output: msg }
+  }
 
   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)}`
+  // Step results
+  const steps = manifest.cckit?.steps || []
+  const header = `${'Step'.padEnd(20)} ${'Status'.padEnd(12)} ${'Details'.padEnd(40)}`
   lines.push(header)
-  lines.push('-'.repeat(50))
+  lines.push('-'.repeat(72))
+
+  for (const step of steps) {
+    const status = step.skipped
+      ? chalk.gray('skipped')
+      : step.success
+        ? chalk.green('ok')
+        : chalk.red('failed')
 
-  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)
+    let detail = ''
+    if (step.skipped) {
+      detail = '-'
+    } else if (step.error) {
+      detail = chalk.red(step.error.slice(0, 38))
+    } else if (step.details) {
+      const d = step.details
+      if (d.enabledKeys) detail = `${d.enabledKeys.length} plugins`
+      else if (d.outputDirs) detail = d.outputDirs.join(', ')
+      else if (d.files) detail = `${d.files} files -> ${d.target}`
+      else if (d.results) {
+        const ok = d.results.filter(r => r.success).length
+        detail = `${ok}/${d.results.length} skills`
+      } else if (d.target) detail = d.target
+    }
+
+    lines.push(`${(step.stepId || '-').padEnd(20)} ${status.padEnd(21)} ${detail}`)
   }
 
   lines.push('')
-  lines.push(`Directory: ${targetDir}`)
-  lines.push(`Install date: ${manifest.cckit?.installedAt || manifest.cckit?.installDate || '-'}`)
+  lines.push(`Directory:     ${targetDir}`)
+  lines.push(`Install date:  ${manifest.cckit?.installedAt || '-'}`)
   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}`)
-    }
+  if (manifest.cckit?.lastUpdated) {
+    lines.push(`Last updated:  ${manifest.cckit.lastUpdated}`)
   }
 
   lines.push('')
@@ -52,11 +81,5 @@ export async function runStatus(opts = {}) {
   const output = lines.join('\n')
   console.log(output)
 
-  return {
-    installed: true,
-    cckit: manifest.cckit,
-    config: manifest.config,
-    modules: manifest.modules || [],
-    output
-  }
+  return { installed: true, cckit: manifest.cckit, output }
 }