@cregis-dev/cckit 0.4.1 → 0.6.1

package/src/commands/update.js

@@ -1,430 +1,151 @@
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-import fse from 'fs-extra'
-import YAML from 'yaml'
-import { createLogger } from '../utils/logger.js'
-import { computeFileHash, interpolate, listFiles, TEXT_EXTENSIONS } from '../utils/fs.js'
-import { loadRegistry, resolveModules, getDefaultModules } from '../core/registry.js'
-import { ADAPTERS } from '../adapters/trae-adapter.js'
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url))
-const CCKIT_ROOT = path.resolve(__dirname, '../..')
-
-/**
- * Extract the fileRegistry from a manifest, handling both formats:
- * - cckit.fileRegistry (produced by init command)
- * - top-level fileRegistry (legacy/manual)
- *
- * @param {object} manifest - Parsed manifest object
- * @returns {object} File registry map { relativePath: hash }
- */
-function extractFileRegistry(manifest) {
-  if (manifest.cckit && manifest.cckit.fileRegistry) {
-    return manifest.cckit.fileRegistry
-  }
-  if (manifest.fileRegistry) {
-    return manifest.fileRegistry
-  }
-  return {}
-}
-
 /**
- * Build a sourceMap from registry modules and config.
+ * update command — re-run orchestration to update installed components.
  *
- * Maps each target directory to its source template info:
- *   { templateDir, adapter, prefix, moduleId }
- *
- * @param {object} registry - Loaded registry
- * @param {object} config - Config from manifest (ides, languages, etc.)
- * @returns {object} sourceMap keyed by targetDir
- */
-function buildSourceMap(registry, config) {
-  const selectedIds = getDefaultModules(registry)
-  const resolved = resolveModules(registry, selectedIds)
-  const sourceMap = {}
-  const ides = config.ides || ['claude-code']
-
-  for (const mod of resolved) {
-    if (mod.targets) {
-      for (const ide of ides) {
-        const target = mod.targets[ide]
-        if (!target) continue
-
-        const templateDir = path.resolve(
-          CCKIT_ROOT,
-          target.templateDir || mod.templateDir
-        )
-        sourceMap[target.targetDir] = {
-          templateDir,
-          adapter: target.adapter ? ADAPTERS[target.adapter] : undefined,
-          prefix: target.prefix || undefined,
-          moduleId: mod.id
-        }
-      }
-    } else if (mod.ideTarget) {
-      if (ides.includes(mod.ideTarget)) {
-        sourceMap[mod.targetDir] = {
-          templateDir: path.resolve(CCKIT_ROOT, mod.templateDir),
-          adapter: undefined,
-          prefix: undefined,
-          moduleId: mod.id
-        }
-      }
-    } else {
-      sourceMap[mod.targetDir] = {
-        templateDir: path.resolve(CCKIT_ROOT, mod.templateDir),
-        adapter: undefined,
-        prefix: undefined,
-        moduleId: mod.id
-      }
-    }
-  }
-
-  return sourceMap
-}
-
-/**
- * Find the source template file for an installed file.
- *
- * @param {string} relPath - Relative path of the installed file (e.g. '.claude/rules/common/coding-style.md')
- * @param {object} sourceMap - Map from targetDir to source info
- * @returns {object|null} { srcAbsPath, adapter } or null if not found
+ * Default behavior: apply mode (re-run all steps).
+ * --dry-run: show current manifest state only.
+ * --no-apply: check-only, update lastUpdated timestamp.
  */
-function findSourceForFile(relPath, sourceMap) {
-  // Normalize to forward slashes for matching
-  const normalizedRel = relPath.replace(/\\/g, '/')
-
-  // Collect all matching entries, pick the one with the longest prefix (most specific)
-  let bestMatch = null
-  let bestPrefixLen = -1
-
-  for (const [targetDir, source] of Object.entries(sourceMap)) {
-    const normalizedTarget = targetDir.replace(/\\/g, '/')
-    // Check if file is under this target directory
-    // Handle both "dir/file" and "dir" == "." (root-level targets)
-    const prefix = normalizedTarget === '.'
-      ? ''
-      : normalizedTarget + '/'
-
-    if (prefix === '' ? true : normalizedRel.startsWith(prefix)) {
-      if (prefix.length > bestPrefixLen) {
-        const remainder = prefix === ''
-          ? normalizedRel
-          : normalizedRel.slice(prefix.length)
-
-        // If a prefix was applied to the filename during install, strip it to find source
-        let srcRelPath = remainder
-        if (source.prefix) {
-          const fileName = path.basename(remainder)
-          if (fileName.startsWith(source.prefix)) {
-            const originalName = fileName.slice(source.prefix.length)
-            const dir = path.dirname(remainder)
-            srcRelPath = dir === '.' ? originalName : path.join(dir, originalName)
-          }
-        }
-
-        const srcAbsPath = path.join(source.templateDir, srcRelPath)
-        bestPrefixLen = prefix.length
-        bestMatch = {
-          srcAbsPath,
-          adapter: source.adapter
-        }
-      }
-    }
-  }
-  return bestMatch
-}
-
-/**
- * Reinstall a single file from its template source.
- *
- * @param {string} targetDir - Project root directory
- * @param {string} relPath - Relative path of the file
- * @param {object} source - { srcAbsPath, adapter }
- * @param {object} variables - Template interpolation variables
- * @returns {Promise<boolean>} true if successfully reinstalled
- */
-async function reinstallFile(targetDir, relPath, source, variables) {
-  const destPath = path.join(targetDir, relPath)
-  const ext = path.extname(relPath).toLowerCase()
-
-  if (!await fse.pathExists(source.srcAbsPath)) {
-    return false
-  }
-
-  await fse.ensureDir(path.dirname(destPath))
-
-  if (TEXT_EXTENSIONS.has(ext)) {
-    let content = await fse.readFile(source.srcAbsPath, 'utf8')
-    content = interpolate(content, variables)
-    if (source.adapter) {
-      content = source.adapter(content, path.basename(relPath))
-    }
-    await fse.writeFile(destPath, content, 'utf8')
-  } else {
-    await fse.copy(source.srcAbsPath, destPath)
-  }
-
-  return true
-}
-
-/**
- * Discover new files from templates that are not yet tracked in fileRegistry.
- * This handles newly added modules/skills in cckit updates.
- *
- * @param {object} sourceMap - Map from targetDir to source info
- * @param {object} fileRegistry - Current file registry from manifest
- * @returns {Promise<Array<{ relPath: string, source: { srcAbsPath: string, adapter?: Function } }>>}
- */
-async function discoverNewFiles(sourceMap, fileRegistry) {
-  const newFiles = []
-
-  for (const [targetDir, source] of Object.entries(sourceMap)) {
-    if (!await fse.pathExists(source.templateDir)) continue
-
-    const templateFiles = await listFiles(source.templateDir)
-
-    for (const relPath of templateFiles) {
-      const fileName = path.basename(relPath)
-      const dir = path.dirname(relPath)
 
-      // Apply prefix if configured (e.g. ecc-agent- prefix)
-      const installedName = source.prefix
-        ? `${source.prefix}${fileName}`
-        : fileName
-
-      // Build the installed relative path
-      const installedRelPath = targetDir === '.'
-        ? (dir === '.' ? installedName : `${dir}/${installedName}`)
-        : (dir === '.' ? `${targetDir}/${installedName}` : `${targetDir}/${dir}/${installedName}`)
-
-      const normalizedPath = installedRelPath.replace(/\\/g, '/')
-
-      if (!(normalizedPath in fileRegistry)) {
-        newFiles.push({
-          relPath: normalizedPath,
-          source: {
-            srcAbsPath: path.join(source.templateDir, relPath),
-            adapter: source.adapter,
-          },
-        })
-      }
-    }
-  }
-
-  return newFiles
-}
+import path from 'node:path'
+import fse from 'fs-extra'
+import { loadRegistry, resolvePlugins, resolveModelId } from '../core/registry.js'
+import { DEFAULT_API_URL } from '../core/config.js'
+import { orchestrate } from '../core/orchestrator.js'
+import { readManifest, writeManifest, isLegacyManifest, serializeSteps } from '../utils/manifest.js'
+import { createLogger } from '../utils/logger.js'
+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'
 
 /**
- * Run the update command.
- *
- * Reads the installed manifest, compares current file hashes against
- * the recorded fileRegistry, and reports which files are unchanged,
- * modified by the user, or missing.
- *
- * When --apply is set, reinstalls files from cckit templates.
- *
- * @param {object} opts - Command options
- * @param {string} [opts.dir] - Target directory (default: cwd)
- * @param {boolean} [opts.dryRun] - Preview changes without applying
- * @param {boolean} [opts.apply] - Reinstall files from templates
- * @param {boolean} [opts.force] - Force overwrite modified files without backup
- * @param {boolean} [opts.debug] - Enable debug output
- * @returns {Promise<object>} Result with { checked, modified, unchanged, missing, applied? }
- * @throws {Error} If cckit is not installed
+ * @param {object} opts
+ * @param {string} [opts.dir] - Target directory
+ * @param {boolean} [opts.dryRun] - Preview only
+ * @param {boolean} [opts.apply] - Apply updates (default: true)
+ * @param {boolean} [opts.force] - Force overwrite
+ * @param {boolean} [opts.debug] - Debug output
+ * @param {object} [_deps] - Injectable dependencies
+ * @returns {Promise<object>}
  */
-export async function runUpdate(opts = {}) {
-  const logger = createLogger({ debug: opts.debug })
+export async function runUpdate(opts = {}, _deps = {}) {
+  const logger = _deps.logger || createLogger({ debug: opts.debug })
   const targetDir = path.resolve(opts.dir || process.cwd())
-  const manifestPath = path.join(targetDir, '_bmad', '_config', 'manifest.yaml')
 
-  if (!await fse.pathExists(manifestPath)) {
-    throw new Error('cckit is not installed. Run `cckit init` first.')
-  }
-
-  const manifestContent = await fse.readFile(manifestPath, 'utf8')
-  const manifest = YAML.parse(manifestContent)
-
-  logger.banner('cckit update')
-
-  const fileRegistry = extractFileRegistry(manifest)
-  const modified = []
-  const unchanged = []
-  const missing = []
-
-  for (const [relPath, expectedHash] of Object.entries(fileRegistry)) {
-    const fullPath = path.join(targetDir, relPath)
+  const manifest = await readManifest(targetDir)
 
-    if (!await fse.pathExists(fullPath)) {
-      missing.push(relPath)
-      continue
-    }
-
-    const currentHash = await computeFileHash(fullPath)
-    if (currentHash !== expectedHash) {
-      modified.push(relPath)
-    } else {
-      unchanged.push(relPath)
-    }
-  }
-
-  // Report results
-  const totalFiles = Object.keys(fileRegistry).length
-  if (totalFiles > 0) {
-    logger.info(`  Checked ${totalFiles} registered file(s)`)
-  }
-
-  if (unchanged.length > 0) {
-    logger.success(`${unchanged.length} file(s) unchanged`)
-  }
-
-  if (modified.length > 0) {
-    logger.warn(`${modified.length} file(s) modified by user:`)
-    for (const f of modified) {
-      logger.info(`    ${f}`)
-    }
+  if (isLegacyManifest(manifest)) {
+    throw new Error(
+      'Legacy manifest detected (v1 module-based format). ' +
+      'Please run `cckit init` to reinstall with the new orchestration format.'
+    )
   }
 
-  if (missing.length > 0) {
-    logger.warn(`${missing.length} file(s) missing:`)
-    for (const f of missing) {
-      logger.info(`    ${f}`)
-    }
-  }
+  logger.banner('cckit update')
 
-  if (totalFiles === 0) {
-    logger.info('  No files registered in manifest.')
-  } else if (modified.length === 0 && missing.length === 0) {
-    logger.success('All files match. Nothing to update.')
+  // Show current step status
+  const steps = manifest.cckit?.steps || []
+  for (const step of steps) {
+    const status = step.skipped ? 'skipped' : step.success ? 'ok' : 'FAILED'
+    logger.info(`  ${step.stepId}: ${status}`)
   }
 
   if (opts.dryRun) {
     logger.info('\n  (dry run - no changes made)')
-    return { checked: true, modified, unchanged, missing }
+    return { dryRun: true, steps }
   }
 
-  // Apply mode: reinstall files from templates
-  if (opts.apply) {
-    const applied = { updated: 0, backedUp: 0, restored: 0, added: 0, failed: 0, orphaned: 0 }
-
-    let registry
-    let sourceMap
-    let variables
-
-    try {
-      registry = await loadRegistry()
-      const config = manifest.cckit && manifest.cckit.config
-        ? manifest.cckit.config
-        : {}
-
-      sourceMap = buildSourceMap(registry, config)
-      variables = {
-        user_name: config.user_name || '',
-        communication_language: config.communication_language || '',
-        document_output_language: config.document_output_language || '',
-        languages: Array.isArray(config.languages)
-          ? config.languages.join(', ')
-          : (config.languages || ''),
-        'project-root': '.'
-      }
-    } catch (err) {
-      logger.debug(`Failed to load registry for apply: ${err.message}`)
-      // Return result with empty applied if registry cannot be loaded
-      if (manifest.cckit) {
-        manifest.cckit.lastUpdated = new Date().toISOString()
-      }
-      await fse.writeFile(manifestPath, YAML.stringify(manifest), 'utf8')
-      logger.success('Update complete.')
-      return { checked: true, modified, unchanged, missing, applied }
-    }
-
-    // Process all files: unchanged + modified + missing
-    const allFiles = [...unchanged, ...modified, ...missing]
-
-    for (const relPath of allFiles) {
-      const source = findSourceForFile(relPath, sourceMap)
-      if (!source || !await fse.pathExists(source.srcAbsPath)) {
-        logger.debug(`No source template found for: ${relPath} (orphaned)`)
-        applied.orphaned += 1
-        // Remove orphaned file from registry so it's no longer tracked
-        delete fileRegistry[relPath]
-        continue
-      }
-
-      const fullPath = path.join(targetDir, relPath)
-      const isModified = modified.includes(relPath)
-
-      // Backup modified files unless --force
-      if (isModified && !opts.force) {
-        const bakPath = `${fullPath}.bak.${Date.now()}`
-        try {
-          await fse.copy(fullPath, bakPath)
-          applied.backedUp += 1
-          logger.debug(`Backed up: ${relPath} -> ${path.basename(bakPath)}`)
-        } catch (err) {
-          logger.debug(`Failed to backup ${relPath}: ${err.message}`)
-        }
-      }
-
-      // Reinstall file
-      const success = await reinstallFile(targetDir, relPath, source, variables)
-      if (success) {
-        applied.updated += 1
-        // Recompute hash for updated file
-        const newHash = await computeFileHash(fullPath)
-        fileRegistry[relPath] = newHash
-
-        if (missing.includes(relPath)) {
-          applied.restored += 1
-        }
-      } else {
-        applied.failed += 1
-        logger.debug(`Source not found for: ${relPath}`)
-      }
-    }
-
-    // Discover and install new files from templates not yet in fileRegistry
-    const newFiles = await discoverNewFiles(sourceMap, fileRegistry)
-    if (newFiles.length > 0) {
-      logger.info(`  Discovered ${newFiles.length} new file(s) from updated templates`)
-      for (const { relPath, source } of newFiles) {
-        const success = await reinstallFile(targetDir, relPath, source, variables)
-        if (success) {
-          applied.added += 1
-          const fullPath = path.join(targetDir, relPath)
-          const newHash = await computeFileHash(fullPath)
-          fileRegistry[relPath] = newHash
-        } else {
-          applied.failed += 1
-          logger.debug(`Failed to install new file: ${relPath}`)
-        }
-      }
-    }
-
-    // Update manifest with new fileRegistry
-    if (manifest.cckit) {
-      manifest.cckit.fileRegistry = fileRegistry
-      manifest.cckit.lastUpdated = new Date().toISOString()
-    }
-    await fse.writeFile(manifestPath, YAML.stringify(manifest), 'utf8')
-
-    logger.newline()
-    if (applied.orphaned > 0) {
-      logger.warn(`${applied.orphaned} file(s) orphaned (module removed, no longer tracked)`)
-    }
-    logger.success(
-      `Applied: ${applied.updated} updated, ${applied.added} added, ${applied.restored} restored, ${applied.backedUp} backed up, ${applied.failed} failed`
-    )
-
-    return { checked: true, modified, unchanged, missing, applied }
-  }
-
-  // Non-dry-run, non-apply: update the lastUpdated timestamp only
-  if (manifest.cckit) {
+  if (opts.apply === false) {
+    // Check-only: update timestamp
     manifest.cckit.lastUpdated = new Date().toISOString()
-  }
-  await fse.writeFile(manifestPath, YAML.stringify(manifest), 'utf8')
-
+    await writeManifest(targetDir, manifest)
+    logger.success('Check complete.')
+    return { checked: true, steps }
+  }
+
+  // Apply mode: re-run orchestrator
+  const registry = _deps.registry || await loadRegistry()
+  const config = manifest.cckit?.config || {}
+  const plugins = resolvePlugins(registry, { plugins: config.plugins || 'default' })
+
+  // Resolve model for user settings
+  const userSettings = registry.userSettings || {}
+  const modelId = resolveModelId(userSettings, opts.model || config.model)
+
+  const stepSpecs = [
+    {
+      id: 'configure-user',
+      fn: _deps.configureUser || configureUser,
+      opts: {
+        apiUrl: opts.apiUrl || config.apiUrl || userSettings.apiUrl || DEFAULT_API_URL,
+        apiKey: opts.apiKey,
+        forceApiKey: opts.forceApiKey,
+        modelId,
+        modelEnvKeys: userSettings.modelEnvKeys || [],
+        yes: true, // update mode is non-interactive by default
+        skip: false,
+      },
+    },
+    {
+      id: 'enable-plugins',
+      fn: _deps.enablePlugins || enablePlugins,
+      opts: { targetDir, plugins, skip: false },
+    },
+    {
+      id: 'install-bmad',
+      fn: _deps.installBmad || installBmad,
+      opts: {
+        targetDir,
+        bmadConfig: registry.bmad,
+        // Pass saved config values only if they differ from BMAD defaults (Chinese)
+        config: {
+          communication_language: config.communication_language !== 'Chinese' ? config.communication_language : undefined,
+          document_output_language: config.document_output_language !== 'Chinese' ? config.document_output_language : undefined,
+        },
+        skip: false,
+      },
+    },
+    {
+      id: 'install-rules',
+      fn: _deps.installRules || installRules,
+      opts: {
+        targetDir,
+        rulesConfig: registry.rules.ecc,
+        skip: false,
+        forceRefresh: true,
+      },
+    },
+    {
+      id: 'install-skills',
+      fn: _deps.installSkills || installSkills,
+      opts: { targetDir, skills: registry.skills || [], skip: false },
+    },
+    {
+      id: 'install-mcp',
+      fn: _deps.installMcp || installMcp,
+      opts: {
+        targetDir,
+        mcpConfig: registry.mcp,
+        skip: false,
+        forceOverwrite: opts.force || false,
+      },
+    },
+  ]
+
+  const report = await orchestrate(stepSpecs, logger)
+
+  // Update manifest
+  manifest.cckit.steps = serializeSteps(report.steps)
+  manifest.cckit.fileRegistry = {
+    ...(manifest.cckit.fileRegistry || {}),
+    ...report.fileRegistry,
+  }
+  manifest.cckit.lastUpdated = new Date().toISOString()
+
+  await writeManifest(targetDir, manifest)
   logger.success('Update complete.')
-  return { checked: true, modified, unchanged, missing }
+
+  return { applied: true, report }
 }

package/src/core/config.js

@@ -4,34 +4,32 @@ const LANG_MAP = {
   go: 'golang', golang: 'golang'
 }
 
+export const VERSION = '0.5.0'
+
+export const DEFAULT_API_URL = 'https://gateway.cregis.ai'
+
 export const DEFAULT_CONFIG = {
   user_name: 'User',
-  communication_language: '汉语',
-  document_output_language: '汉语',
+  communication_language: 'Chinese',
+  document_output_language: 'Chinese',
   languages: ['typescript', 'python', 'golang'],
-  modules: 'all',
   plugins: 'default',
-  ides: ['claude-code', 'trae'],
   excludeGroups: []
 }
 
 /**
- * Merge CLI flags into a config object, falling back to DEFAULT_CONFIG
- * for any values not provided.
+ * Merge CLI flags into a config object, falling back to DEFAULT_CONFIG.
  *
  * Supported flags:
- *   userName            - Override user_name
+ *   userName              - Override user_name
  *   communicationLanguage - Override communication_language
- *   docLanguage         - Override document_output_language
- *   lang                - Comma-separated language aliases (ts,py,go)
- *   modules             - "all" or comma-separated module IDs
- *   ides                - Comma-separated IDE identifiers
- *   trae                - Set to false to exclude trae from ides
- *   bmad                - Set to false to add "bmad" to excludeGroups
- *   ecc                 - Set to false to add "ecc" to excludeGroups
- *   mcp                 - Set to false to add "mcp" to excludeGroups
- *   plugins             - "default", "none", or comma-separated plugin IDs.
- *                          Set to false (via --no-plugins) to disable plugins.
+ *   docLanguage           - Override document_output_language
+ *   lang                  - Comma-separated language aliases (ts,py,go)
+ *   bmad                  - Set to false to add "bmad" to excludeGroups
+ *   ecc                   - Set to false to add "ecc" to excludeGroups
+ *   mcp                   - Set to false to add "mcp" to excludeGroups
+ *   plugins               - "default", "none", or comma-separated plugin IDs
+ *   skills                - Set to false to skip skill installation
  *
  * @param {object} [flags={}] - CLI flags parsed by commander
  * @returns {object} Merged config
@@ -50,22 +48,6 @@ export function mergeConfig(flags = {}) {
       .filter(Boolean)
   }
 
-  if (flags.modules) {
-    config.modules = flags.modules === 'all'
-      ? 'all'
-      : flags.modules.split(',').map(m => m.trim())
-  }
-
-  if (flags.ides) {
-    config.ides = flags.ides.split(',').map(i => i.trim())
-  } else {
-    // Handle --no-trae / --no-claude-code negation flags
-    const ides = ['claude-code', 'trae']
-    if (flags.trae === false) {
-      config.ides = ides.filter(i => i !== 'trae')
-    }
-  }
-
   if (flags.bmad === false) config.excludeGroups.push('bmad')
   if (flags.ecc === false) config.excludeGroups.push('ecc')
   if (flags.mcp === false) config.excludeGroups.push('mcp')
@@ -78,5 +60,15 @@ export function mergeConfig(flags = {}) {
       : flags.plugins.split(',').map(p => p.trim())
   }
 
+  if (flags.skills === false) {
+    config.skipSkills = true
+  }
+
+  // User-level settings
+  if (flags.apiUrl) config.apiUrl = flags.apiUrl
+  if (flags.apiKey) config.apiKey = flags.apiKey
+  if (flags.forceApiKey) config.forceApiKey = true
+  if (flags.model) config.model = flags.model
+
   return config
 }