@cregis-dev/cckit 0.4.0 → 0.5.0

package/src/core/plugin-installer.js

@@ -1,278 +0,0 @@
-/**
- * Plugin installer — handles distributing plugins to Claude Code and Trae.
- *
- * Claude Code: writes plugin IDs into `.claude/settings.json` enabledPlugins.
- * Trae: extracts skills/commands/agents from plugin templates into `.trae/`.
- */
-
-import path from 'node:path'
-import fse from 'fs-extra'
-import { listFiles, copyWithInterpolation, interpolate } from '../utils/fs.js'
-import { convertAgentForTrae, convertCommandForTrae } from '../adapters/trae-adapter.js'
-
-// ─── Claude Code Base Settings ──────────────────────────────────────────────
-
-/**
- * Default environment overrides written to `.claude/settings.json`.
- * These disable telemetry, error reporting, and the /bug command.
- */
-const CLAUDE_CODE_ENV_DEFAULTS = {
-  DISABLE_BUG_COMMAND: '1',
-  DISABLE_ERROR_REPORTING: '1',
-  DISABLE_TELEMETRY: '1',
-  MCP_TIMEOUT: '60000',
-  MAX_THINKING_TOKENS: '31999',
-  CLAUDE_CODE_MAX_OUTPUT_TOKENS: '64000',
-}
-
-// ─── Plugin Resolution ──────────────────────────────────────────────────────
-
-/**
- * Get plugin IDs marked as default in the registry.
- *
- * @param {object} registry - Registry object with plugins section
- * @returns {string[]} Default plugin IDs
- */
-export function getDefaultPlugins(registry) {
-  const plugins = registry.plugins || {}
-  return Object.entries(plugins)
-    .filter(([, def]) => def.default)
-    .map(([id]) => id)
-}
-
-/**
- * Resolve requested plugin IDs to plugin definitions with constructed template paths.
- * Note: Template directory existence is validated later by installPlugins().
- *
- * @param {object} registry - Registry object
- * @param {string[]} pluginIds - Requested plugin IDs
- * @param {string} templateBase - Absolute path to cckit templates/ directory
- * @param {object} logger - Logger instance
- * @returns {{ found: Array<{ id: string, def: object, templateDir: string }>, skipped: Array<{ id: string, reason: string }> }}
- */
-export function resolvePlugins(registry, pluginIds, templateBase, logger) {
-  const plugins = registry.plugins || {}
-  const found = []
-  const skipped = []
-
-  for (const id of pluginIds) {
-    const def = plugins[id]
-    if (!def) {
-      logger.warn(`Plugin "${id}" not found in registry, skipping`)
-      skipped.push({ id, reason: 'not in registry' })
-      continue
-    }
-
-    const templateDir = path.join(templateBase, 'plugins', id)
-    found.push({ id, def, templateDir })
-  }
-
-  return { found, skipped }
-}
-
-// ─── Claude Code Installation ───────────────────────────────────────────────
-
-/**
- * Install plugins for Claude Code by writing enabledPlugins and
- * extraKnownMarketplaces (for non-built-in marketplaces) to settings.json.
- *
- * Plugins with a `marketplaceSource` field in their registry definition will
- * have their marketplace source added to `extraKnownMarketplaces`, enabling
- * Claude Code to auto-prompt users for marketplace trust and plugin installation.
- *
- * @param {Array<{ id: string, def: object }>} plugins - Resolved plugins
- * @param {string} targetDir - Project root directory
- * @param {object} logger - Logger instance
- * @returns {Promise<string[]>} List of enabled plugin keys
- */
-export async function installForClaudeCode(plugins, targetDir, logger) {
-  const settingsPath = path.join(targetDir, '.claude', 'settings.json')
-  let existing = {}
-
-  try {
-    if (await fse.pathExists(settingsPath)) {
-      const raw = await fse.readFile(settingsPath, 'utf8')
-      existing = JSON.parse(raw)
-    }
-  } catch (err) {
-    logger.warn(`settings.json parse error, backing up and recreating: ${err.message}`)
-    const backupPath = `${settingsPath}.bak.${Date.now()}`
-    await fse.copy(settingsPath, backupPath)
-    existing = {}
-  }
-
-  const newPlugins = {}
-  const newMarketplaces = {}
-
-  for (const { id, def } of plugins) {
-    const key = `${id}@${def.marketplace}`
-    newPlugins[key] = true
-
-    // Collect non-built-in marketplace sources (dedupe by marketplace name)
-    if (def.marketplaceSource && !newMarketplaces[def.marketplace]) {
-      newMarketplaces[def.marketplace] = { source: { ...def.marketplaceSource } }
-    }
-  }
-
-  const merged = {
-    ...existing,
-    env: {
-      ...(existing.env || {}),
-      ...CLAUDE_CODE_ENV_DEFAULTS,
-    },
-    enabledPlugins: {
-      ...(existing.enabledPlugins || {}),
-      ...newPlugins,
-    },
-  }
-
-  const enabledKeys = Object.keys(newPlugins)
-  const marketplaceNames = Object.keys(newMarketplaces)
-
-  // Only write extraKnownMarketplaces when there are non-built-in marketplaces
-  if (marketplaceNames.length > 0) {
-    merged.extraKnownMarketplaces = {
-      ...(existing.extraKnownMarketplaces || {}),
-      ...newMarketplaces,
-    }
-  }
-
-  await fse.ensureDir(path.dirname(settingsPath))
-  await fse.writeFile(settingsPath, JSON.stringify(merged, null, 2) + '\n', 'utf8')
-
-  logger.debug(`Claude Code: enabled ${enabledKeys.length} plugins in settings.json`)
-  if (marketplaceNames.length > 0) {
-    logger.debug(`Claude Code: registered ${marketplaceNames.length} extra marketplace(s): ${marketplaceNames.join(', ')}`)
-  }
-  return enabledKeys
-}
-
-// ─── Trae Installation ──────────────────────────────────────────────────────
-
-/**
- * Install a category of plugin markdown files with adapter transformation.
- *
- * @param {string} srcDir - Source directory containing .md files
- * @param {string} destDir - Destination directory
- * @param {Function} adapter - Content transform function (content, filename) => content
- * @param {object} variables - Interpolation variables
- * @returns {Promise<number>} Number of files installed
- */
-async function installPluginCategory(srcDir, destDir, adapter, variables) {
-  if (!await fse.pathExists(srcDir)) return 0
-
-  await fse.ensureDir(destDir)
-  const files = await listFiles(srcDir)
-  let count = 0
-
-  for (const relPath of files) {
-    if (!relPath.endsWith('.md')) continue
-    const srcFile = path.join(srcDir, relPath)
-    let content = await fse.readFile(srcFile, 'utf8')
-    content = interpolate(content, variables)
-
-    const destName = `${path.basename(relPath, '.md')}.md`
-    content = adapter(content, destName)
-    await fse.writeFile(path.join(destDir, destName), content, 'utf8')
-    count++
-  }
-
-  return count
-}
-
-/**
- * Install plugins for Trae by extracting skills/commands/agents.
- *
- * @param {Array<{ id: string, def: object, templateDir: string }>} plugins - Resolved plugins with template paths
- * @param {string} targetDir - Project root directory
- * @param {object} variables - Interpolation variables
- * @param {object} logger - Logger instance
- * @returns {Promise<{ files: number, details: Array<{ id: string, skills: number, commands: number, agents: number }> }>}
- */
-export async function installForTrae(plugins, targetDir, variables, logger) {
-  let totalFiles = 0
-  const details = []
-
-  for (const { id, templateDir } of plugins) {
-    try {
-      const counts = { skills: 0, commands: 0, agents: 0 }
-
-      // Skills → .trae/skills/<pluginId>/ (direct copy + interpolation)
-      const skillsSrc = path.join(templateDir, 'skills')
-      if (await fse.pathExists(skillsSrc)) {
-        const skillsDest = path.join(targetDir, '.trae', 'skills', id)
-        counts.skills = await copyWithInterpolation(skillsSrc, skillsDest, variables)
-        totalFiles += counts.skills
-      }
-
-      // Commands → .trae/rules/<pluginId>/commands/<name>.md (with adapter)
-      counts.commands = await installPluginCategory(
-        path.join(templateDir, 'commands'),
-        path.join(targetDir, '.trae', 'rules', id, 'commands'),
-        convertCommandForTrae,
-        variables
-      )
-      totalFiles += counts.commands
-
-      // Agents → .trae/rules/<pluginId>/agents/<name>.md (with adapter)
-      counts.agents = await installPluginCategory(
-        path.join(templateDir, 'agents'),
-        path.join(targetDir, '.trae', 'rules', id, 'agents'),
-        convertAgentForTrae,
-        variables
-      )
-      totalFiles += counts.agents
-
-      details.push({ id, ...counts })
-      logger.debug(`  Trae plugin "${id}": ${counts.skills} skills, ${counts.commands} commands, ${counts.agents} agents`)
-    } catch (err) {
-      throw new Error(`Failed to install Trae content for plugin "${id}": ${err.message}`)
-    }
-  }
-
-  return { files: totalFiles, details }
-}
-
-// ─── Main Entry ─────────────────────────────────────────────────────────────
-
-/**
- * Install plugins for all selected IDEs.
- *
- * @param {{
- *   plugins: Array<{ id: string, def: object, templateDir: string }>,
- *   targetDir: string,
- *   ides: string[],
- *   variables: object,
- *   logger: object
- * }} opts
- * @returns {Promise<{ claudeCode: string[], trae: object, installed: string[] }>}
- */
-export async function installPlugins({ plugins, targetDir, ides, variables, logger }) {
-  const result = { claudeCode: [], trae: { files: 0, details: [] }, installed: [] }
-
-  // Claude Code: write settings.json (env defaults + plugin IDs + marketplace sources)
-  if (ides.includes('claude-code')) {
-    result.claudeCode = await installForClaudeCode(plugins, targetDir, logger)
-  }
-
-  // Trae: extract content from plugins that have templates
-  if (ides.includes('trae') && plugins.length > 0) {
-    const available = []
-    for (const p of plugins) {
-      if (await fse.pathExists(p.templateDir)) {
-        available.push(p)
-      } else {
-        logger.warn(`Plugin "${p.id}" template not found at ${p.templateDir}, skipping Trae extraction`)
-      }
-    }
-
-    if (available.length > 0) {
-      result.trae = await installForTrae(available, targetDir, variables, logger)
-    }
-  }
-
-  // Track all plugins as installed (settings.json counts even without templates)
-  result.installed = plugins.map(p => p.id)
-  return result
-}
-

package/src/core/templatize.js

@@ -1,42 +0,0 @@
-/**
- * Config.yaml templatization for upstream sync.
- *
- * When syncing from upstream BMAD, config.yaml files contain real values
- * (e.g. user_name: "John"). This module converts them back to template
- * placeholders (e.g. user_name: {user_name}) so cckit's interpolation
- * can fill them at install time.
- */
-
-const TEMPLATIZE_RULES = [
-  { pattern: /^(user_name:\s*).+$/m, replacement: '$1{user_name}' },
-  { pattern: /^(communication_language:\s*).+$/m, replacement: '$1{communication_language}' },
-  { pattern: /^(document_output_language:\s*).+$/m, replacement: '$1{document_output_language}' },
-  { pattern: /^(#\s*Date:\s*).+$/m, replacement: '$1{install_date}' },
-]
-
-/**
- * Apply templatization rules to config.yaml content.
- * Replaces concrete values with {placeholder} tokens.
- *
- * @param {string} content - Raw config.yaml content from upstream
- * @returns {string} Templatized content with placeholders
- */
-export function templatizeConfigYaml(content) {
-  let result = content
-  for (const { pattern, replacement } of TEMPLATIZE_RULES) {
-    result = result.replace(pattern, replacement)
-  }
-  return result
-}
-
-/**
- * Determine whether a file at the given relative path should be templatized.
- * Only config.yaml files under bmad/core, bmad/bmm, or bmad/tea qualify.
- *
- * @param {string} relPath - Relative file path (forward-slash normalized)
- * @returns {boolean}
- */
-export function shouldTemplatize(relPath) {
-  const normalized = relPath.replace(/\\/g, '/')
-  return /^bmad\/(core|bmm|tea)\/config\.yaml$/.test(normalized)
-}

package/src/core/upstream.js

@@ -1,357 +0,0 @@
-/**
- * Upstream source fetching, path mapping, and file copying for sync.
- *
- * Handles pulling content from BMAD (npm), ECC (git), plugins (git),
- * and external skills (git) upstreams, then copying files to the local
- * templates/ directory via configurable path mappings with optional
- * filters, excludes, and post-processing.
- */
-
-import path from 'node:path'
-import fse from 'fs-extra'
-import os from 'node:os'
-import { execFile as execFileCb } from 'node:child_process'
-import { promisify } from 'node:util'
-import { mkdtemp } from 'node:fs/promises'
-import { listFiles, TEXT_EXTENSIONS } from '../utils/fs.js'
-
-const execFile = promisify(execFileCb)
-
-// ─── Path Mappings ──────────────────────────────────────────────────────────
-
-export const BMAD_PATH_MAPPINGS = [
-  { src: '_bmad/core', dest: 'bmad/core' },
-  { src: '_bmad/bmm', dest: 'bmad/bmm' },
-  { src: '_bmad/tea', dest: 'bmad/tea' },
-  { src: '_bmad/_config', dest: 'bmad/_config', exclude: ['manifest.yaml'] },
-  { src: '.claude/commands', dest: 'bmad/commands', filter: /^bmad-/ },
-  { src: '.trae/rules', dest: 'trae-bmad/rules', filter: /^bmad-/ },
-]
-
-export const ECC_REPO_URL = 'https://github.com/affaan-m/everything-claude-code'
-
-export const ECC_PATH_MAPPINGS = [
-  { src: 'rules', dest: 'ecc/rules' },
-  { src: 'agents', dest: 'ecc/agents' },
-  { src: 'skills', dest: 'ecc/skills' },
-  { src: 'commands', dest: 'ecc/commands' },
-]
-
-// ─── Fetch Functions ────────────────────────────────────────────────────────
-
-/**
- * Fetch BMAD content by running `npx bmad-method install` in a temp directory.
- * BMAD v6+ uses a CLI with `install` subcommand and module selection.
- *
- * @param {{ tmpDir: string, logger: object }} opts
- * @returns {Promise<{ version: string, dir: string }>} Extracted npm package version and install dir
- */
-export async function fetchBmad({ tmpDir, logger }) {
-  logger.debug('Fetching BMAD via npx bmad-method install...')
-
-  const bmadDir = path.join(tmpDir, 'bmad')
-  await fse.ensureDir(bmadDir)
-
-  // BMAD v6 CLI: install --yes --modules bmm,tea --tools claude-code,trae
-  await execFile('npx', [
-    '-y', 'bmad-method@latest', 'install',
-    '--yes',
-    '--directory', bmadDir,
-    '--modules', 'bmm,tea',
-    '--tools', 'claude-code,trae',
-    '--user-name', 'User',
-    '--communication-language', 'English',
-    '--document-output-language', 'English',
-  ], {
-    cwd: bmadDir,
-    timeout: 120_000,
-    shell: process.platform === 'win32',
-  })
-
-  // Extract version from the installed manifest
-  let version = 'unknown'
-  try {
-    const manifestPath = path.join(bmadDir, '_bmad', '_config', 'manifest.yaml')
-    if (await fse.pathExists(manifestPath)) {
-      const content = await fse.readFile(manifestPath, 'utf8')
-      const match = content.match(/version:\s*['"]?([^\s'"]+)/)
-      if (match) version = match[1]
-    }
-  } catch {
-    // Fallback: try package.json in npm cache
-  }
-
-  if (version === 'unknown') {
-    try {
-      const { stdout } = await execFile('npx', ['-y', 'bmad-method@latest', '--version'], {
-        timeout: 30_000,
-        shell: process.platform === 'win32',
-      })
-      version = stdout.trim() || 'unknown'
-    } catch {
-      logger.warn('Could not determine BMAD package version')
-    }
-  }
-
-  logger.debug(`BMAD fetched, version: ${version}`)
-  return { version, dir: bmadDir }
-}
-
-/**
- * Fetch ECC content by cloning the git repository.
- *
- * @param {{ tmpDir: string, logger: object }} opts
- * @returns {Promise<{ sha: string }>} HEAD commit SHA
- */
-export async function fetchEcc({ tmpDir, logger }) {
-  const repo = `${ECC_REPO_URL}.git`
-  const eccDir = path.join(tmpDir, 'ecc')
-
-  logger.debug(`Cloning ECC from ${repo}...`)
-
-  await execFile('git', ['clone', '--depth', '1', repo, eccDir], {
-    timeout: 120_000,
-    shell: process.platform === 'win32',
-  })
-
-  // Get HEAD SHA
-  let sha = 'unknown'
-  try {
-    const { stdout } = await execFile('git', ['rev-parse', 'HEAD'], {
-      cwd: eccDir,
-      shell: process.platform === 'win32',
-    })
-    sha = stdout.trim()
-  } catch {
-    logger.warn('Could not determine ECC commit SHA')
-  }
-
-  logger.debug(`ECC cloned, SHA: ${sha}`)
-  return { sha, dir: eccDir }
-}
-
-// ─── Mapping & Copy ─────────────────────────────────────────────────────────
-
-/**
- * Apply path mappings to copy files from source to destination.
- *
- * @param {{
- *   srcBase: string,
- *   destBase: string,
- *   mappings: Array<{ src: string, dest: string, exclude?: string[], filter?: RegExp }>,
- *   postProcess?: (content: string, relPath: string) => string,
- *   logger: object
- * }} opts
- * @returns {Promise<number>} Total number of files copied
- */
-export async function applyMappings({ srcBase, destBase, mappings, postProcess, logger }) {
-  let totalFiles = 0
-
-  for (const mapping of mappings) {
-    const srcDir = path.join(srcBase, mapping.src)
-    const destDir = path.join(destBase, mapping.dest)
-
-    if (!await fse.pathExists(srcDir)) {
-      logger.warn(`Source directory not found, skipping: ${mapping.src}`)
-      continue
-    }
-
-    const files = await listFiles(srcDir)
-
-    for (const relPath of files) {
-      const fileName = path.basename(relPath)
-
-      // Apply exclude list
-      if (mapping.exclude && mapping.exclude.includes(fileName)) {
-        logger.debug(`  Excluded: ${mapping.src}/${relPath}`)
-        continue
-      }
-
-      // Apply filename filter (regex must match basename)
-      if (mapping.filter && !mapping.filter.test(fileName)) {
-        continue
-      }
-
-      const srcFile = path.join(srcDir, relPath)
-      const destFile = path.join(destDir, relPath)
-
-      await fse.ensureDir(path.dirname(destFile))
-
-      // Read, optionally post-process, then write
-      const ext = path.extname(relPath).toLowerCase()
-      const isText = TEXT_EXTENSIONS.has(ext)
-
-      if (isText && postProcess) {
-        let content = await fse.readFile(srcFile, 'utf8')
-        const destRelPath = path.join(mapping.dest, relPath).replace(/\\/g, '/')
-        content = postProcess(content, destRelPath)
-        await fse.writeFile(destFile, content, 'utf8')
-      } else {
-        await fse.copy(srcFile, destFile)
-      }
-
-      totalFiles++
-    }
-
-    logger.debug(`  Mapped ${mapping.src} → ${mapping.dest}`)
-  }
-
-  return totalFiles
-}
-
-// ─── Plugin Fetch ───────────────────────────────────────────────────────────
-
-/**
- * Fetch plugin content by cloning a marketplace GitHub repository.
- *
- * @param {{ tmpDir: string, logger: object, registry: object }} opts
- * @returns {Promise<{ sha: string, dir: string }>} HEAD commit SHA and clone directory
- */
-export async function fetchPlugins({ tmpDir, logger, registry }) {
-  const upstream = registry.upstream?.plugins
-  if (!upstream?.repo) {
-    throw new Error('No plugins upstream configured in registry.json')
-  }
-
-  const repo = upstream.repo.endsWith('.git') ? upstream.repo : `${upstream.repo}.git`
-  const pluginsDir = path.join(tmpDir, 'plugins')
-
-  logger.debug(`Cloning plugins from ${repo}...`)
-
-  await execFile('git', ['clone', '--depth', '1', repo, pluginsDir], {
-    timeout: 120_000,
-    shell: process.platform === 'win32',
-  })
-
-  // Get HEAD SHA
-  let sha = 'unknown'
-  try {
-    const { stdout } = await execFile('git', ['rev-parse', 'HEAD'], {
-      cwd: pluginsDir,
-      shell: process.platform === 'win32',
-    })
-    sha = stdout.trim()
-  } catch {
-    logger.warn('Could not determine plugins commit SHA')
-  }
-
-  logger.debug(`Plugins cloned, SHA: ${sha}`)
-  return { sha, dir: pluginsDir }
-}
-
-/**
- * Build path mappings for plugins based on registry.plugins entries.
- * Each plugin maps from its source directory in the marketplace repo
- * to its destination in templates/plugins/.
- *
- * @param {object} registry - Registry object with plugins section
- * @returns {Array<{ src: string, dest: string }>} Path mappings
- */
-export function buildPluginMappings(registry) {
-  const pluginsPath = registry.upstream?.plugins?.pluginsPath || 'plugins'
-  const plugins = registry.plugins || {}
-
-  return Object.keys(plugins).map(id => ({
-    src: `${pluginsPath}/${id}`,
-    dest: `plugins/${id}`,
-  }))
-}
-
-// ─── External Skills Fetch ─────────────────────────────────────────────────
-
-/**
- * Fetch external skills by cloning each registered repo and extracting
- * the configured skillPath into a unified output directory.
- *
- * Each skill entry in `registry.upstream['ext-skills']` is cloned
- * independently, allowing skills from different repos to coexist.
- *
- * @param {{ tmpDir: string, logger: object, registry: object }} opts
- * @returns {Promise<{ skills: Record<string, { sha: string }>, dir: string }>}
- */
-export async function fetchExtSkills({ tmpDir, logger, registry }) {
-  const entries = registry.upstream?.['ext-skills'] || {}
-  const ids = Object.keys(entries)
-
-  if (ids.length === 0) {
-    throw new Error('No ext-skills upstream configured in registry.json')
-  }
-
-  const outputDir = path.join(tmpDir, 'ext-skills')
-  await fse.ensureDir(outputDir)
-
-  const skills = {}
-
-  for (const id of ids) {
-    const entry = entries[id]
-    if (entry.type !== 'git' || !entry.repo) {
-      logger.warn(`ext-skill "${id}" has invalid config, skipping`)
-      continue
-    }
-
-    const repo = entry.repo.endsWith('.git') ? entry.repo : `${entry.repo}.git`
-    const cloneDir = path.join(tmpDir, `ext-skill-${id}`)
-
-    logger.debug(`Cloning ext-skill "${id}" from ${repo}...`)
-
-    await execFile('git', ['clone', '--depth', '1', repo, cloneDir], {
-      timeout: 120_000,
-      shell: process.platform === 'win32',
-    })
-
-    // Get HEAD SHA
-    let sha = 'unknown'
-    try {
-      const { stdout } = await execFile('git', ['rev-parse', 'HEAD'], {
-        cwd: cloneDir,
-        shell: process.platform === 'win32',
-      })
-      sha = stdout.trim()
-    } catch {
-      logger.warn(`Could not determine commit SHA for ext-skill "${id}"`)
-    }
-
-    // Copy skillPath contents to output/<id>/
-    const skillSrc = path.join(cloneDir, entry.skillPath || id)
-    const skillDest = path.join(outputDir, id)
-
-    if (await fse.pathExists(skillSrc)) {
-      await fse.copy(skillSrc, skillDest)
-      logger.debug(`ext-skill "${id}": copied ${entry.skillPath} → ${id}/, SHA: ${sha}`)
-    } else {
-      logger.warn(`ext-skill "${id}": skillPath "${entry.skillPath}" not found in repo`)
-    }
-
-    skills[id] = { sha }
-  }
-
-  return { skills, dir: outputDir }
-}
-
-/**
- * Build path mappings for external skills based on registry.upstream['ext-skills'].
- * Each skill maps from its ID subdirectory to templates/ext-skills/<id>.
- *
- * @param {object} registry - Registry object
- * @returns {Array<{ src: string, dest: string }>} Path mappings
- */
-export function buildExtSkillMappings(registry) {
-  const entries = registry.upstream?.['ext-skills'] || {}
-
-  return Object.keys(entries).map(id => ({
-    src: id,
-    dest: `ext-skills/${id}`,
-  }))
-}
-
-// ─── Temp Directory Helper ──────────────────────────────────────────────────
-
-/**
- * Create a uniquely-named temporary directory.
- *
- * @param {string} prefix - Prefix for the temp directory name
- * @returns {Promise<string>} Absolute path to the created directory
- */
-export async function createTempDir(prefix = 'cckit-sync') {
-  return mkdtemp(path.join(os.tmpdir(), `${prefix}-`))
-}