@cregis-dev/cckit 0.6.5 → 0.6.7

package/src/core/orchestrator.js

@@ -1,79 +1,79 @@
-/**
- * Orchestrator — executes installation steps in sequence
- * and collects results into a unified RunReport.
- *
- * Each step is independently retriable; the orchestrator
- * never throws — it captures failures in step results.
- */
-
-/**
- * @typedef {object} StepResult
- * @property {string} stepId - Stable identifier
- * @property {string} name - Human-readable label
- * @property {boolean} success
- * @property {boolean} skipped
- * @property {object} details - Step-specific metadata
- * @property {string} [error] - Error message if !success
- */
-
-/**
- * @typedef {object} StepSpec
- * @property {string} id
- * @property {Function} fn - async (opts, logger, _deps?) => StepResult
- * @property {object} opts - Step-specific options
- */
-
-/**
- * @typedef {object} RunReport
- * @property {StepResult[]} steps
- * @property {boolean} success - True if all non-skipped steps succeeded
- * @property {object} fileRegistry - Hash registry (currently MCP only)
- */
-
-/**
- * Execute steps sequentially, collecting results.
- *
- * @param {StepSpec[]} steps - Ordered step specifications
- * @param {object} logger - Logger instance
- * @returns {Promise<RunReport>}
- */
-export async function orchestrate(steps, logger) {
-  const results = []
-  const fileRegistry = {}
-
-  for (let i = 0; i < steps.length; i++) {
-    const { id, fn, opts } = steps[i]
-    logger.step(i + 1, steps.length, id)
-
-    try {
-      const result = await fn(opts, logger)
-      results.push(result)
-
-      // Collect file hashes from steps that produce them
-      if (result.details?.hash && result.details?.target) {
-        fileRegistry[result.details.target] = result.details.hash
-      }
-
-      if (result.skipped) {
-        logger.debug(`  Skipped: ${id}`)
-      } else if (result.success) {
-        logger.success(result.name || id)
-      } else {
-        logger.warn(`${result.name || id}: ${result.error || 'completed with errors'}`)
-      }
-    } catch (err) {
-      logger.error(`${id} threw unexpectedly: ${err.message}`)
-      results.push({
-        stepId: id,
-        name: id,
-        success: false,
-        skipped: false,
-        details: {},
-        error: err.message,
-      })
-    }
-  }
-
-  const success = results.every(r => r.skipped || r.success)
-  return { steps: results, success, fileRegistry }
-}
+/**
+ * Orchestrator — executes installation steps in sequence
+ * and collects results into a unified RunReport.
+ *
+ * Each step is independently retriable; the orchestrator
+ * never throws — it captures failures in step results.
+ */
+
+/**
+ * @typedef {object} StepResult
+ * @property {string} stepId - Stable identifier
+ * @property {string} name - Human-readable label
+ * @property {boolean} success
+ * @property {boolean} skipped
+ * @property {object} details - Step-specific metadata
+ * @property {string} [error] - Error message if !success
+ */
+
+/**
+ * @typedef {object} StepSpec
+ * @property {string} id
+ * @property {Function} fn - async (opts, logger, _deps?) => StepResult
+ * @property {object} opts - Step-specific options
+ */
+
+/**
+ * @typedef {object} RunReport
+ * @property {StepResult[]} steps
+ * @property {boolean} success - True if all non-skipped steps succeeded
+ * @property {object} fileRegistry - Hash registry (currently MCP only)
+ */
+
+/**
+ * Execute steps sequentially, collecting results.
+ *
+ * @param {StepSpec[]} steps - Ordered step specifications
+ * @param {object} logger - Logger instance
+ * @returns {Promise<RunReport>}
+ */
+export async function orchestrate(steps, logger) {
+  const results = []
+  const fileRegistry = {}
+
+  for (let i = 0; i < steps.length; i++) {
+    const { id, fn, opts } = steps[i]
+    logger.step(i + 1, steps.length, id)
+
+    try {
+      const result = await fn(opts, logger)
+      results.push(result)
+
+      // Collect file hashes from steps that produce them
+      if (result.details?.hash && result.details?.target) {
+        fileRegistry[result.details.target] = result.details.hash
+      }
+
+      if (result.skipped) {
+        logger.debug(`  Skipped: ${id}`)
+      } else if (result.success) {
+        logger.success(result.name || id)
+      } else {
+        logger.warn(`${result.name || id}: ${result.error || 'completed with errors'}`)
+      }
+    } catch (err) {
+      logger.error(`${id} threw unexpectedly: ${err.message}`)
+      results.push({
+        stepId: id,
+        name: id,
+        success: false,
+        skipped: false,
+        details: {},
+        error: err.message,
+      })
+    }
+  }
+
+  const success = results.every(r => r.skipped || r.success)
+  return { steps: results, success, fileRegistry }
+}

package/src/core/registry.js

@@ -1,60 +1,60 @@
-import fse from 'fs-extra'
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url))
-
-/**
- * Load and parse registry.json from disk.
- *
- * @param {string} [customPath] - Override path to registry.json
- * @returns {Promise<object>} Parsed registry object
- */
-export async function loadRegistry(customPath) {
-  const registryPath = customPath || path.resolve(__dirname, '../../registry.json')
-  const content = await fse.readFile(registryPath, 'utf8')
-  return JSON.parse(content)
-}
-
-/**
- * Get IDs of all plugins marked as default.
- *
- * @param {object} registry - Loaded registry object
- * @returns {string[]} Array of plugin IDs
- */
-export function getDefaultPlugins(registry) {
-  return Object.entries(registry.plugins || {})
-    .filter(([, def]) => def.default)
-    .map(([id]) => id)
-}
-
-/**
- * Resolve requested plugin IDs to plugin definitions.
- *
- * @param {object} registry - Registry object
- * @param {object} config - Merged config (uses config.plugins)
- * @returns {Array<{id: string, def: object}>} Resolved plugin entries
- */
-export function resolvePlugins(registry, config) {
-  const pluginIds = config.plugins === 'default'
-    ? getDefaultPlugins(registry)
-    : config.plugins === 'none'
-      ? []
-      : Array.isArray(config.plugins) ? config.plugins : []
-
-  return pluginIds
-    .map(id => ({ id, def: registry.plugins?.[id] }))
-    .filter(p => p.def)
-}
-
-/**
- * Resolve a model alias to a model ID using the registry's model map.
- *
- * @param {object} userSettings - registry.userSettings
- * @param {string} [preferredAlias] - User-specified model alias (e.g. 'kimi')
- * @returns {string} Resolved model ID (e.g. 'Kimi-K2.5')
- */
-export function resolveModelId(userSettings = {}, preferredAlias) {
-  const alias = preferredAlias || userSettings.defaultModel || 'minimax'
-  return (userSettings.models || {})[alias] || alias
-}
+import fse from 'fs-extra'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+/**
+ * Load and parse registry.json from disk.
+ *
+ * @param {string} [customPath] - Override path to registry.json
+ * @returns {Promise<object>} Parsed registry object
+ */
+export async function loadRegistry(customPath) {
+  const registryPath = customPath || path.resolve(__dirname, '../../registry.json')
+  const content = await fse.readFile(registryPath, 'utf8')
+  return JSON.parse(content)
+}
+
+/**
+ * Get IDs of all plugins marked as default.
+ *
+ * @param {object} registry - Loaded registry object
+ * @returns {string[]} Array of plugin IDs
+ */
+export function getDefaultPlugins(registry) {
+  return Object.entries(registry.plugins || {})
+    .filter(([, def]) => def.default)
+    .map(([id]) => id)
+}
+
+/**
+ * Resolve requested plugin IDs to plugin definitions.
+ *
+ * @param {object} registry - Registry object
+ * @param {object} config - Merged config (uses config.plugins)
+ * @returns {Array<{id: string, def: object}>} Resolved plugin entries
+ */
+export function resolvePlugins(registry, config) {
+  const pluginIds = config.plugins === 'default'
+    ? getDefaultPlugins(registry)
+    : config.plugins === 'none'
+      ? []
+      : Array.isArray(config.plugins) ? config.plugins : []
+
+  return pluginIds
+    .map(id => ({ id, def: registry.plugins?.[id] }))
+    .filter(p => p.def)
+}
+
+/**
+ * Resolve a model alias to a model ID using the registry's model map.
+ *
+ * @param {object} userSettings - registry.userSettings
+ * @param {string} [preferredAlias] - User-specified model alias (e.g. 'kimi')
+ * @returns {string} Resolved model ID (e.g. 'Kimi-K2.5')
+ */
+export function resolveModelId(userSettings = {}, preferredAlias) {
+  const alias = preferredAlias || userSettings.defaultModel || 'minimax'
+  return (userSettings.models || {})[alias] || alias
+}

package/src/steps/add-plugin.js

@@ -0,0 +1,148 @@
+/**
+ * Step: Install plugins using Claude Code CLI.
+ *
+ * Uses `claude plugin install <plugin>@<marketplace> --scope <scope>` commands
+ * to install plugins at project scope.
+ *
+ * Requires `claude` CLI to be installed. If not found, the step is skipped
+ * with a warning instead of failing the entire installation.
+ */
+
+import { spawn, execSync } from 'node:child_process'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+/**
+ * Check if the `claude` CLI is available on PATH.
+ *
+ * @returns {boolean}
+ */
+function isClaudeCliAvailable() {
+  try {
+    execSync('command -v claude', { stdio: 'pipe' })
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * @param {object} opts
+ * @param {string} opts.targetDir - Project root
+ * @param {Array<{id: string, def: object}>} opts.plugins - Resolved plugins with scope
+ * @param {boolean} opts.skip - Skip this step
+ * @param {object} logger
+ * @param {object} [_deps] - Injectable dependencies for testing
+ * @returns {Promise<import('../core/orchestrator.js').StepResult>}
+ */
+export async function addPlugin(opts, logger, _deps = {}) {
+  if (opts.skip) {
+    return { stepId: 'add-plugin', name: 'Add Plugin (CLI)', success: true, skipped: true, details: {} }
+  }
+
+  // Check if claude CLI is available
+  const checkCli = _deps.isClaudeCliAvailable || isClaudeCliAvailable
+  if (!checkCli()) {
+    logger.warn('Claude Code CLI not found. Skipping CLI plugin installation.')
+    logger.warn('Install Claude Code CLI (https://docs.anthropic.com/en/docs/claude-code) to enable this step.')
+    return {
+      stepId: 'add-plugin',
+      name: 'Add Plugin (CLI)',
+      success: true,
+      skipped: true,
+      details: { reason: 'claude CLI not found' },
+    }
+  }
+
+  const projectPlugins = opts.plugins.filter(p => p.def.scope === 'project' || !p.def.scope)
+
+  if (projectPlugins.length === 0) {
+    logger.debug('No project-scoped plugins to install via CLI')
+    return {
+      stepId: 'add-plugin',
+      name: 'Add Plugin (CLI)',
+      success: true,
+      skipped: false,
+      details: { installed: [], errors: [] },
+    }
+  }
+
+  const installed = []
+  const errors = []
+
+  for (const { id, def } of projectPlugins) {
+    const pluginKey = `${id}@${def.marketplace}`
+    const scope = def.scope || 'project'
+
+    try {
+      logger.info(`  Installing ${pluginKey} (scope: ${scope})...`)
+
+      await execCommand('claude', [
+        'plugin',
+        'install',
+        pluginKey,
+        '--scope',
+        scope,
+      ], logger)
+
+      installed.push({ id: pluginKey, scope })
+      logger.success(`  ✓ ${pluginKey} installed`)
+    } catch (err) {
+      errors.push({ id: pluginKey, error: err.message })
+      logger.warn(`  ✗ Failed to install ${pluginKey}: ${err.message}`)
+    }
+  }
+
+  return {
+    stepId: 'add-plugin',
+    name: 'Add Plugin (CLI)',
+    success: errors.length === 0,
+    skipped: false,
+    details: {
+      installed,
+      errors,
+    },
+  }
+}
+
+/**
+ * Execute a command and return a promise.
+ *
+ * @param {string} command - Command to run
+ * @param {string[]} args - Command arguments
+ * @param {object} logger - Logger instance
+ * @returns {Promise<void>}
+ */
+function execCommand(command, args, logger) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(command, args, {
+      shell: true,
+      stdio: 'pipe',
+    })
+
+    let stdout = ''
+    let stderr = ''
+
+    proc.stdout.on('data', (data) => {
+      stdout += data.toString()
+    })
+
+    proc.stderr.on('data', (data) => {
+      stderr += data.toString()
+    })
+
+    proc.on('close', (code) => {
+      if (code === 0) {
+        resolve()
+      } else {
+        reject(new Error(stderr || stdout || `Exit code: ${code}`))
+      }
+    })
+
+    proc.on('error', (err) => {
+      reject(err)
+    })
+  })
+}