@cregis-dev/cckit 0.4.1 → 0.6.1

package/src/utils/fs.js

@@ -3,46 +3,24 @@ import path from 'node:path'
 import crypto from 'node:crypto'
 import { glob } from 'glob'
 
-const INTERPOLATE_EXTENSIONS = new Set(['.md', '.yaml', '.yml', '.json', '.csv', '.txt'])
-
-export { INTERPOLATE_EXTENSIONS as TEXT_EXTENSIONS }
-
-export async function copyWithInterpolation(srcDir, destDir, variables) {
-  const files = await listFiles(srcDir)
-  let count = 0
-
-  for (const relPath of files) {
-    const srcFile = path.join(srcDir, relPath)
-    const destFile = path.join(destDir, relPath)
-    const ext = path.extname(relPath).toLowerCase()
-
-    await fse.ensureDir(path.dirname(destFile))
-
-    if (INTERPOLATE_EXTENSIONS.has(ext)) {
-      let content = await fse.readFile(srcFile, 'utf8')
-      content = interpolate(content, variables)
-      await fse.writeFile(destFile, content, 'utf8')
-    } else {
-      await fse.copy(srcFile, destFile)
-    }
-    count++
-  }
-
-  return count
-}
-
-export function interpolate(content, variables) {
-  return content.replace(/\{(\w+)\}/g, (match, key) => {
-    return key in variables ? variables[key] : match
-  })
-}
-
+/**
+ * Compute SHA256 hash of a file.
+ *
+ * @param {string} filePath - Absolute path to file
+ * @returns {Promise<string>} Hash in format "sha256:<hex>"
+ */
 export async function computeFileHash(filePath) {
   const content = await fse.readFile(filePath)
   const hash = crypto.createHash('sha256').update(content).digest('hex')
   return `sha256:${hash}`
 }
 
+/**
+ * List all files in a directory recursively.
+ *
+ * @param {string} dir - Directory to scan
+ * @returns {Promise<string[]>} Relative file paths
+ */
 export async function listFiles(dir) {
   const pattern = '**/*'
   const files = await glob(pattern, {

package/src/utils/manifest.js

@@ -0,0 +1,99 @@
+/**
+ * Manifest utilities — read/write the cckit installation manifest.
+ *
+ * Manifest lives at `_bmad/_config/manifest.yaml` and tracks:
+ * - Installation config (user preferences)
+ * - Step execution results
+ * - File registry (SHA256 hashes for tracked files)
+ */
+
+import path from 'node:path'
+import fse from 'fs-extra'
+import YAML from 'yaml'
+
+export const MANIFEST_REL = path.join('_bmad', '_config', 'manifest.yaml')
+
+/**
+ * Read and parse the manifest from a project directory.
+ *
+ * @param {string} dir - Project root directory
+ * @returns {Promise<object>} Parsed manifest object
+ * @throws {Error} If manifest does not exist
+ */
+export async function readManifest(dir) {
+  const manifestPath = path.join(path.resolve(dir), MANIFEST_REL)
+  try {
+    const content = await fse.readFile(manifestPath, 'utf8')
+    return YAML.parse(content)
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      throw new Error('cckit is not installed. Run `cckit init` first.')
+    }
+    throw err
+  }
+}
+
+/**
+ * Write manifest to a project directory.
+ *
+ * @param {string} dir - Project root directory
+ * @param {object} manifest - Manifest data to write
+ * @returns {Promise<void>}
+ */
+export async function writeManifest(dir, manifest) {
+  const manifestPath = path.join(path.resolve(dir), MANIFEST_REL)
+  await fse.ensureDir(path.dirname(manifestPath))
+  await fse.writeFile(manifestPath, YAML.stringify(manifest), 'utf8')
+}
+
+/**
+ * Serialize step results for manifest storage.
+ *
+ * @param {Array<import('../core/orchestrator.js').StepResult>} steps
+ * @returns {Array<object>}
+ */
+export function serializeSteps(steps) {
+  return steps.map(s => ({
+    stepId: s.stepId,
+    success: s.success,
+    skipped: s.skipped || false,
+    ...(s.details ? { details: s.details } : {}),
+    ...(s.error ? { error: s.error } : {}),
+  }))
+}
+
+/**
+ * Build a new manifest from orchestration results.
+ *
+ * @param {object} params
+ * @param {object} params.config - Merged config
+ * @param {import('../core/orchestrator.js').RunReport} params.report - Orchestration report
+ * @param {string} params.version - cckit version
+ * @returns {object} Manifest object
+ */
+export function buildManifest({ config, report, version }) {
+  return {
+    cckit: {
+      version,
+      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,
+      },
+      steps: serializeSteps(report.steps),
+      fileRegistry: report.fileRegistry,
+    }
+  }
+}
+
+/**
+ * Check if a manifest uses the legacy v1 format (modules-based).
+ *
+ * @param {object} manifest - Parsed manifest
+ * @returns {boolean}
+ */
+export function isLegacyManifest(manifest) {
+  return !!(manifest.cckit?.modules) && !manifest.cckit?.steps
+}

package/src/utils/prompt.js

@@ -0,0 +1,41 @@
+/**
+ * Readline utility for interactive prompts.
+ */
+
+import { createInterface } from 'node:readline'
+
+/**
+ * Prompt user for input via readline.
+ * Returns empty string if user presses Enter without typing.
+ *
+ * @param {string} question - Prompt text
+ * @param {object} [_deps] - Injectable dependencies for testing
+ * @param {object} [_deps.rl] - Mock readline interface
+ * @returns {Promise<string>} User input (trimmed)
+ */
+export function askQuestion(question, _deps = {}) {
+  const { rl: mockRl } = _deps
+
+  // If mock is provided, use it directly
+  if (mockRl) {
+    return new Promise((resolve) => {
+      mockRl.question(question, (answer) => {
+        mockRl.close()
+        resolve((answer == null ? '' : String(answer)).trim())
+      })
+    })
+  }
+
+  // Default: use real readline
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  })
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close()
+      resolve((answer == null ? '' : String(answer)).trim())
+    })
+  })
+}

package/templates/mcp/claude-code/.mcp.json

@@ -4,22 +4,26 @@
     "cf-bindings": {
       "command": "npx",
       "args": ["-y", "mcp-remote", "https://bindings.mcp.cloudflare.com/mcp"],
-      "description": "Workers Bindings: D1, R2, KV, Queues 资源管理"
+      "description": "Workers Bindings: D1, R2, KV, Queues 资源管理",
+      "disabled": true
     },
     "cf-observability": {
       "command": "npx",
       "args": ["-y", "mcp-remote", "https://observability.mcp.cloudflare.com/mcp"],
-      "description": "Workers 日志分析与调试"
+      "description": "Workers 日志分析与调试",
+      "disabled": true
     },
     "cf-builds": {
       "command": "npx",
       "args": ["-y", "mcp-remote", "https://builds.mcp.cloudflare.com/mcp"],
-      "description": "Workers 构建状态监控"
+      "description": "Workers 构建状态监控",
+      "disabled": true
     },
     "cf-docs": {
       "command": "npx",
       "args": ["-y", "mcp-remote", "https://docs.mcp.cloudflare.com/sse"],
-      "description": "Cloudflare 官方文档查询"
+      "description": "Cloudflare 官方文档查询",
+      "disabled": true
     },
     "context7": {
       "command": "npx",
@@ -29,7 +33,8 @@
     "playwright": {
       "command": "npx",
       "args": ["-y", "@anthropic-ai/mcp-playwright@latest"],
-      "description": "Playwright 浏览器自动化，用于 E2E 测试和 UI 验证"
+      "description": "Playwright 浏览器自动化，用于 E2E 测试和 UI 验证",
+      "disabled": true
     }
   }
 }

package/src/adapters/trae-adapter.js

@@ -1,90 +0,0 @@
-import path from 'node:path'
-
-/**
- * Detects whether markdown content already has YAML frontmatter.
- * Frontmatter starts with '---' (optionally preceded by whitespace).
- */
-export function hasFrontmatter(content) {
-  return content.trimStart().startsWith('---')
-}
-
-/**
- * Converts a rule file for Trae by prepending alwaysApply frontmatter.
- * Skips injection if frontmatter already exists.
- */
-export function convertRuleForTrae(content, filename) {
-  if (hasFrontmatter(content)) return content
-
-  const frontmatter = [
-    '---',
-    'alwaysApply: true',
-    '---',
-    ''
-  ].join('\n')
-
-  return frontmatter + content
-}
-
-/**
- * Extracts the text of the first markdown heading (# ...) from content.
- * Returns null if no heading is found.
- */
-function extractFirstHeading(content) {
-  const match = content.match(/^#\s+(.+)/m)
-  return match ? match[1].trim() : null
-}
-
-/**
- * Derives a short name from a filename by stripping the extension.
- */
-function deriveNameFromFilename(filename) {
-  return path.basename(filename, path.extname(filename))
-}
-
-/**
- * Converts an agent file for Trae by prepending name/description/disable-model-invocation frontmatter.
- */
-export function convertAgentForTrae(content, filename) {
-  const name = deriveNameFromFilename(filename)
-  const description = extractFirstHeading(content) || name
-
-  const frontmatter = [
-    '---',
-    `name: '${name}'`,
-    `description: '${description}'`,
-    'disable-model-invocation: true',
-    '---',
-    ''
-  ].join('\n')
-
-  return frontmatter + content
-}
-
-/**
- * Converts a command file for Trae by prepending name/description/disable-model-invocation frontmatter.
- */
-export function convertCommandForTrae(content, filename) {
-  const name = deriveNameFromFilename(filename)
-  const description = extractFirstHeading(content) || name
-
-  const frontmatter = [
-    '---',
-    `name: '${name}'`,
-    `description: '${description}'`,
-    'disable-model-invocation: true',
-    '---',
-    ''
-  ].join('\n')
-
-  return frontmatter + content
-}
-
-/**
- * Adapter lookup map used by the Installer.
- * Keys correspond to the `adapter` field in module definitions.
- */
-export const ADAPTERS = {
-  'trae-rules': convertRuleForTrae,
-  'trae-agents': convertAgentForTrae,
-  'trae-commands': convertCommandForTrae
-}

package/src/commands/add.js

@@ -1,192 +0,0 @@
-/**
- * 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(() => {})
-  }
-}