@wabot-dev/create 0.0.4 → 1.0.1

package/README.md

@@ -1,189 +1,90 @@
 # `@wabot-dev/create`
 
-CLI para:
+CLI para crear un nuevo proyecto Wabot desde el template oficial e instalar las
+skills de agente que **vienen empaquetadas con `@wabot-dev/framework`**.
 
-- crear un nuevo proyecto Wabot desde el template oficial
-- instalar skills empaquetadas en distintos homes o targets de agentes
+> Las skills ya no viven en este paquete: son propiedad de `@wabot-dev/framework`
+> y se versionan junto con su API. Este CLI las descubre desde el framework
+> instalado en el proyecto y las copia a `.claude/`, `.codex/` y/o `.agents/`.
 
-## Instalación
+## Uso rápido
 
 ```bash
-npm install
+npm create @wabot-dev my-wabot-app
+# o
+npx @wabot-dev/create my-wabot-app
 ```
 
-Para probar el binario local:
+El asistente pregunta: nombre, almacenamiento (memoria/postgres), proveedores de
+IA e instalación de skills de agente (por defecto sí). Luego:
 
-```bash
-node ./bin/create-wabot.mjs --help
-```
+1. clona el template oficial,
+2. corre `npm install` (deja `@wabot-dev/framework` en `node_modules`),
+3. copia las skills de ese framework a las carpetas de agente elegidas.
 
-## Comando principal
+Si no pasás `project-directory`, se pregunta el nombre en modo interactivo.
 
-Crear un proyecto nuevo:
-
-```bash
-create-wabot <project-directory>
-```
-
-Ejemplo:
-
-```bash
-create-wabot my-wabot-app
-```
-
-Variaciones:
+Opciones:
 
 ```bash
 create-wabot my-wabot-app --db-url "postgres://localhost:5432/wabot"
-create-wabot my-wabot-app --llm-url "http://localhost:3000"
-create-wabot my-wabot-app --api-key "my-api-key"
-create-wabot my-wabot-app --db-url "postgres://localhost:5432/wabot" --llm-url "http://localhost:3000" --api-key "my-api-key"
-```
-
-Si no pasás `project-directory`, el CLI pregunta el nombre del proyecto en modo interactivo.
-
-## Comando de skills
-
-Instalar una skill empaquetada:
-
-```bash
-create-wabot skill add <skill-name>
+create-wabot my-wabot-app --lang es
 ```
 
-Skill disponible actualmente:
+## Canal beta
 
-```bash
-create-wabot skill add wabot-framework
-```
-
-## Variaciones de `skill add`
+Las builds beta de `@wabot-dev/create` (versión `X.Y.Z-beta.N`) scaffoldean desde
+la rama **`beta`** del template (`wabot-dev/wabot-template#beta`), que fija la
+versión beta del framework. Las builds estables usan la rama por defecto.
 
-### 1. Instalación global por defecto
-
-Usa el home del sistema y, si no se indica target, instala para `codex`.
+Para forzar una fuente concreta del template (p. ej. probar una rama antes de
+publicar) usá la variable de entorno:
 
 ```bash
-create-wabot skill add wabot-framework
+WABOT_TEMPLATE_REF="wabot-dev/wabot-template#beta" create-wabot my-app
 ```
 
-Resultado esperado:
-
-- `<os.homedir()>/.codex/skills/wabot-framework`
+## Skills en un proyecto existente
 
-### 2. Instalación local al proyecto
-
-Instala en el workspace actual:
+Las skills se instalan solas al crear el proyecto. Para **agregarlas o
+actualizarlas** más tarde (por ejemplo tras subir la versión del framework), usá
+el bin que ships el propio framework:
 
 ```bash
-create-wabot skill add wabot-framework --local
+npx wabot-skills list                     # lista las skills empaquetadas
+npx wabot-skills sync                      # refresca las skills del proyecto a la
+                                           # versión de framework instalada
+npx wabot-skills sync --agents claude,codex
 ```
 
-Resultado esperado:
-
-- `./.agents/skills/wabot-framework`
+`sync` sobrescribe en el lugar (resync); detecta las carpetas de agente ya
+presentes en el proyecto (`.claude`, `.codex`, `.agents`) o usá `--agents`.
 
-### 3. Instalación global con home explícito
+## `create-wabot skill add` (instalación puntual)
 
-Instala usando un home root manual:
+También podés instalar una skill suelta con este CLI. La fuente es el
+`@wabot-dev/framework` resoluble desde el proyecto/entorno actual.
 
 ```bash
-create-wabot skill add wabot-framework --global --home "/Users/demo"
-create-wabot skill add wabot-framework --global --home "C:\\Users\\demo"
-```
-
-### 4. Instalación global para un target único
-
-```bash
-create-wabot skill add wabot-framework --global --target codex
+create-wabot skill add wabot-framework --local          # ./.agents/skills/...
 create-wabot skill add wabot-framework --global --target claude
-create-wabot skill add wabot-framework --global --target agents
-```
-
-Con `--home`:
-
-```bash
-create-wabot skill add wabot-framework --global --home "C:\\Users\\demo" --target codex
-create-wabot skill add wabot-framework --global --home "C:\\Users\\demo" --target claude
-create-wabot skill add wabot-framework --global --home "C:\\Users\\demo" --target agents
+create-wabot skill add wabot-framework --global --targets agents,codex,claude --home "/Users/demo"
 ```
 
-Rutas esperadas:
-
-- `codex` -> `<home>/.codex/skills/wabot-framework`
-- `claude` -> `<home>/.claude/skills/wabot-framework`
-- `agents` -> `<home>/.agents/skills/wabot-framework`
-
-### 5. Instalación global para múltiples targets
-
-```bash
-create-wabot skill add wabot-framework --global --targets codex,claude
-create-wabot skill add wabot-framework --global --targets agents,codex,claude
-```
-
-Con `--home`:
-
-```bash
-create-wabot skill add wabot-framework --global --home "C:\\Users\\demo" --targets agents,codex,claude
-```
-
-Esto instala la misma skill en múltiples destinos dentro del mismo home root.
-
-## Reglas útiles
+Reglas:
 
 - `--local` y `--global` son excluyentes.
 - `--home`, `--target` y `--targets` aplican solo con `--global`.
-- Si no se pasa `--target` ni `--targets`, el default es `codex`.
-- Si el destino ya existe, el comando falla y no sobreescribe.
-- Si el target no existe en la lista soportada, el comando falla.
-
-## Targets soportados
-
-```text
-agents
-codex
-claude
-```
-
-## Ejemplos completos
-
-Crear un proyecto:
-
-```bash
-create-wabot my-bot
-```
+- Si no se pasa `--target`/`--targets`, el default es `codex`.
+- Si el destino ya existe, falla y no sobrescribe (usá `wabot-skills sync` para refrescar).
 
-Crear un proyecto con variables iniciales:
-
-```bash
-create-wabot my-bot \
-  --db-url "postgres://localhost:5432/mybot" \
-  --llm-url "http://localhost:3000" \
-  --api-key "secret"
-```
-
-Instalar la skill local al repo:
-
-```bash
-create-wabot skill add wabot-framework --local
-```
-
-Instalar la skill para Claude en otro home:
-
-```bash
-create-wabot skill add wabot-framework --global --home "C:\\Users\\another-user" --target claude
-```
-
-Instalar la skill para varios agentes en el mismo home:
-
-```bash
-create-wabot skill add wabot-framework --global --home "C:\\Users\\another-user" --targets agents,codex,claude
-```
+Targets soportados: `agents`, `codex`, `claude`.
 
 ## Desarrollo
 
-Mostrar ayuda:
-
 ```bash
+npm install                # linkea @wabot-dev/framework (file:../wabot-ts) para tests
+npm run test:smoke         # smokes del instalador de skills
 node ./bin/create-wabot.mjs --help
 node ./bin/create-wabot.mjs skill add --help
 ```

package/lib/create-project.mjs

@@ -6,11 +6,39 @@ import fs from 'fs/promises'
 import { spawn } from 'child_process'
 
 import { installSkillsInProject, listSupportedAgents } from './skills/install.mjs'
-import { listSkills } from './skills/registry.mjs'
 import { createTranslator } from './i18n.mjs'
 
 const REQUIRED_NODE_MAJOR = 22
 
+const TEMPLATE_REPO = 'wabot-dev/wabot-template'
+
+// Each starter variant lives on its own branch of the template repo, with a
+// matching `*-beta` branch that pins the beta framework. Beta builds of
+// @wabot-dev/create scaffold from the beta branch, stable builds from the
+// default one. `WABOT_TEMPLATE_REF` overrides everything (e.g. to test a branch).
+//
+//   variant   stable branch   beta branch
+//   full      (default)       beta
+//   empty     empty           empty-beta
+const TEMPLATE_BRANCHES = {
+  full: { stable: '', beta: 'beta' },
+  empty: { stable: 'empty', beta: 'empty-beta' },
+}
+
+async function resolveTemplateRepo(variant = 'empty') {
+  if (process.env.WABOT_TEMPLATE_REF) {
+    return process.env.WABOT_TEMPLATE_REF
+  }
+
+  const pkgRaw = await fs.readFile(new URL('../package.json', import.meta.url), 'utf-8')
+  const version = JSON.parse(pkgRaw).version ?? ''
+  const isBeta = version.includes('-beta')
+
+  const branches = TEMPLATE_BRANCHES[variant] ?? TEMPLATE_BRANCHES.empty
+  const branch = isBeta ? branches.beta : branches.stable
+  return branch ? `${TEMPLATE_REPO}#${branch}` : TEMPLATE_REPO
+}
+
 const AI_PROVIDERS = [
   {
     value: 'openrouter',
@@ -76,6 +104,7 @@ function printIntro(t) {
   )
   console.log()
   console.log(`  ${t('intro.askAbout')}`)
+  console.log(`    • ${t('intro.bullet.template')}`)
   console.log(`    • ${t('intro.bullet.storage')}`)
   console.log(`    • ${t('intro.bullet.providers')}`)
   console.log(line)
@@ -127,6 +156,20 @@ async function collectSetup(options, t) {
     throw new Error(t('project.cancelled'))
   }
 
+  const { template } = await prompts(
+    {
+      type: 'select',
+      name: 'template',
+      message: t('template.prompt'),
+      choices: [
+        { title: t('template.empty'), value: 'empty' },
+        { title: t('template.full'), value: 'full' },
+      ],
+      initial: 0,
+    },
+    { onCancel },
+  )
+
   const { storage } = await prompts(
     {
       type: 'select',
@@ -189,25 +232,24 @@ async function collectSetup(options, t) {
 
   const skills = await collectSkillsSetup({ onCancel }, t)
 
-  return { storage, databaseUrl, providers, providerKeys, skills }
+  return { template, storage, databaseUrl, providers, providerKeys, skills }
 }
 
 async function collectSkillsSetup({ onCancel }, t) {
   const supportedAgents = listSupportedAgents()
-  const availableSkills = listSkills()
 
   const { install } = await prompts(
     {
       type: 'confirm',
       name: 'install',
-      message: t('skills.installPrompt', availableSkills.length),
+      message: t('skills.installPrompt'),
       initial: true,
     },
     { onCancel },
   )
 
   if (!install) {
-    return { install: false, agents: [], skills: [] }
+    return { install: false, agents: [], skills: [], exclude: [] }
   }
 
   const { agents } = await prompts(
@@ -227,10 +269,26 @@ async function collectSkillsSetup({ onCancel }, t) {
     { onCancel },
   )
 
+  // Always offer the design-system skill explicitly — it's opt-in regardless of
+  // the chosen starter.
+  const { installDesign } = await prompts(
+    {
+      type: 'confirm',
+      name: 'installDesign',
+      message: t('design.prompt'),
+      initial: true,
+    },
+    { onCancel },
+  )
+
+  // Empty skills list = install every skill the framework ships (resolved at
+  // install time from @wabot-dev/framework in the new project); `exclude` drops
+  // wabot-design when the dev opts out.
   return {
     install: true,
     agents,
-    skills: availableSkills.map((skill) => skill.name),
+    skills: [],
+    exclude: installDesign ? [] : ['wabot-design'],
   }
 }
 
@@ -241,7 +299,12 @@ async function createProject(projectName, setup, t) {
 
   console.log(chalk.blue(t('project.creating', chalk.green(targetDir))))
 
-  const emitter = degit('wabot-dev/wabot-template', {
+  const templateRepo = await resolveTemplateRepo(setup.template)
+  if (templateRepo !== TEMPLATE_REPO) {
+    console.log(chalk.gray(t('project.templateSource', templateRepo)))
+  }
+
+  const emitter = degit(templateRepo, {
     cache: false,
     force: true,
     verbose: true,
@@ -287,9 +350,13 @@ async function writeEnvFile(targetDir, setup, t) {
 
   lines.push(t('env.providersComment'))
   for (const provider of AI_PROVIDERS) {
+    const apiKey = setup.providerKeys[provider.envKey]
     const selected = setup.providers.includes(provider.value)
-    if (selected) {
-      lines.push(`${provider.envKey}=${setup.providerKeys[provider.envKey] ?? ''}`)
+    // The framework refuses to boot on a key that is defined but empty, so a
+    // provider chosen without a key ships commented out like an unchosen one —
+    // the project still runs, and printNextSteps warns which keys to fill in.
+    if (selected && apiKey) {
+      lines.push(`${provider.envKey}=${apiKey}`)
     } else {
       lines.push(`# ${provider.envKey}=`)
     }
@@ -328,7 +395,12 @@ async function installAgentSkills(projectName, skillsSetup, t) {
   console.log(chalk.blue(t('skills.installing')))
 
   try {
-    const result = await installSkillsInProject(targetDir, skillsSetup.agents, skillsSetup.skills)
+    const result = await installSkillsInProject(
+      targetDir,
+      skillsSetup.agents,
+      skillsSetup.skills,
+      skillsSetup.exclude,
+    )
 
     const installed = result.installations.filter((i) => i.status === 'installed')
     const skipped = result.installations.filter((i) => i.status === 'skipped')
@@ -381,6 +453,6 @@ function printNextSteps(projectName, setup, t) {
   console.log(chalk.cyan(`\n  cd ${projectName}`))
   console.log(chalk.cyan('  npm run dev:watch'))
   console.log(t('next.cmdChannelHint'))
-  console.log(chalk.cyan('\n  npm run cmd:channel'))
+  console.log(chalk.cyan('\n  npm run cmd'))
   console.log(t('next.happy'))
 }

package/lib/i18n.mjs

@@ -4,9 +4,15 @@ const STRINGS = {
     'intro.line1': 'This wizard will scaffold a new chat-bot project from the',
     'intro.line2': (template, env) => `${template} starter and configure your ${env}.`,
     'intro.askAbout': 'You will be asked about:',
+    'intro.bullet.template': 'which starter to scaffold (empty or full example)',
     'intro.bullet.storage': 'where to store data (in-memory or PostgreSQL)',
     'intro.bullet.providers': 'which AI providers you want to use',
 
+    'template.prompt': 'Which starter do you want?',
+    'template.empty': 'Empty (just the runner — build from scratch with the skills)',
+    'template.full': 'Full example (local chat bot + web UI, no third-party channels)',
+    'design.prompt': 'Also install the wabot-design design-system skill?',
+
     'node.required': (required, current) =>
       `✖ Node.js ${required} is required (you are running ${current}).`,
     'node.templatePin': (required, nvmrc) =>
@@ -19,6 +25,7 @@ const STRINGS = {
     'project.cancelled': 'Setup cancelled',
     'project.exists': (name) => `Directory ${name} already exists`,
     'project.creating': (dir) => `\nCreating a new Wabot project in ${dir}\n`,
+    'project.templateSource': (repo) => `  Using template source: ${repo}`,
 
     'storage.prompt': 'How do you want to store data?',
     'storage.memory': 'In-memory (quickest start, data resets on restart)',
@@ -33,8 +40,7 @@ const STRINGS = {
     'providers.anthropic': 'Claude models',
     'providers.google': 'Gemini models',
 
-    'skills.installPrompt': (count) =>
-      `Install Wabot agent skills (${count}) into the new project?`,
+    'skills.installPrompt': 'Install Wabot agent skills into the new project?',
     'skills.agentsPrompt': 'Install for which agents? (space to toggle, enter to confirm)',
     'skills.agentsHint': 'Each adds a folder of <agent>/skills under the project root',
     'skills.installing': '\nInstalling Wabot agent skills...\n',
@@ -44,7 +50,7 @@ const STRINGS = {
       `  ⚠  ${count} skill folder(s) already existed and were left untouched.`,
     'skills.failed': (msg) => `  ✖ Failed to install agent skills: ${msg}`,
     'skills.installLater':
-      '  You can install them later with `create-wabot skill add <skill>`.',
+      '  You can install/refresh them later with `npx wabot-skills sync`.',
 
     'deps.installing': '\nInstalling dependencies with npm...\n',
     'deps.exitCode': (code) => `npm install exited with code ${code}`,
@@ -74,9 +80,15 @@ const STRINGS = {
     'intro.line2': (template, env) =>
       `la plantilla ${template} y configurará tu archivo ${env}.`,
     'intro.askAbout': 'Te preguntaremos sobre:',
+    'intro.bullet.template': 'con qué plantilla empezar (vacía o ejemplo completo)',
     'intro.bullet.storage': 'dónde almacenar los datos (en memoria o PostgreSQL)',
     'intro.bullet.providers': 'qué proveedores de IA deseas usar',
 
+    'template.prompt': '¿Con qué plantilla quieres empezar?',
+    'template.empty': 'Vacía (solo el runner — construye desde cero con las skills)',
+    'template.full': 'Ejemplo completo (chat bot local + UI web, sin canales de terceros)',
+    'design.prompt': '¿Instalar también la skill del sistema de diseño wabot-design?',
+
     'node.required': (required, current) =>
       `✖ Se requiere Node.js ${required} (estás usando ${current}).`,
     'node.templatePin': (required, nvmrc) =>
@@ -89,6 +101,7 @@ const STRINGS = {
     'project.cancelled': 'Configuración cancelada',
     'project.exists': (name) => `El directorio ${name} ya existe`,
     'project.creating': (dir) => `\nCreando un nuevo proyecto Wabot en ${dir}\n`,
+    'project.templateSource': (repo) => `  Usando fuente del template: ${repo}`,
 
     'storage.prompt': '¿Cómo deseas almacenar los datos?',
     'storage.memory': 'En memoria (inicio más rápido, los datos se pierden al reiniciar)',
@@ -106,8 +119,7 @@ const STRINGS = {
     'providers.anthropic': 'Modelos Claude',
     'providers.google': 'Modelos Gemini',
 
-    'skills.installPrompt': (count) =>
-      `¿Instalar las skills de agente de Wabot (${count}) en el nuevo proyecto?`,
+    'skills.installPrompt': '¿Instalar las skills de agente de Wabot en el nuevo proyecto?',
     'skills.agentsPrompt':
       '¿Para qué agentes instalarlas? (espacio para alternar, enter para confirmar)',
     'skills.agentsHint':
@@ -119,7 +131,7 @@ const STRINGS = {
       `  ⚠  ${count} carpeta(s) de skill ya existían y no se modificaron.`,
     'skills.failed': (msg) => `  ✖ Fallo al instalar las skills de agente: ${msg}`,
     'skills.installLater':
-      '  Puedes instalarlas más tarde con `create-wabot skill add <skill>`.',
+      '  Puedes instalarlas/actualizarlas más tarde con `npx wabot-skills sync`.',
 
     'deps.installing': '\nInstalando dependencias con npm...\n',
     'deps.exitCode': (code) => `npm install terminó con código ${code}`,

package/lib/skills/framework-source.mjs

@@ -0,0 +1,68 @@
+import { createRequire } from 'module'
+import fs from 'fs'
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+const require = createRequire(import.meta.url)
+
+const FRAMEWORK_PKG = '@wabot-dev/framework'
+const FRAMEWORK_SEGMENTS = FRAMEWORK_PKG.split('/')
+
+function packageRootFromEntry(entryPath) {
+  let dir = path.dirname(entryPath)
+  const { root } = path.parse(dir)
+  while (dir && dir !== root) {
+    const pkgFile = path.join(dir, 'package.json')
+    if (fs.existsSync(pkgFile)) {
+      try {
+        if (JSON.parse(fs.readFileSync(pkgFile, 'utf8')).name === FRAMEWORK_PKG) {
+          return dir
+        }
+      } catch {
+        // ignore malformed package.json and keep walking up
+      }
+    }
+    dir = path.dirname(dir)
+  }
+  return null
+}
+
+// Locate the packaged `skills/` directory shipped by @wabot-dev/framework.
+//
+// The framework owns the skills and versions them with its API. When bootstrapping
+// or resyncing a project, resolve them from the framework installed *in that
+// project* (`fromDir`) so the copied skills match the project's pinned framework
+// version. For standalone use (e.g. `skill add`) fall back to the framework
+// resolvable from this package.
+export function resolveFrameworkSkillsDir(fromDir) {
+  const candidates = []
+
+  if (fromDir) {
+    candidates.push(path.join(fromDir, 'node_modules', ...FRAMEWORK_SEGMENTS, 'skills'))
+  }
+
+  try {
+    const pkgRoot = packageRootFromEntry(require.resolve(FRAMEWORK_PKG))
+    if (pkgRoot) candidates.push(path.join(pkgRoot, 'skills'))
+  } catch {
+    // framework not resolvable via node resolution; try the node_modules lookups below
+  }
+
+  const createPkgRoot = fileURLToPath(new URL('../../', import.meta.url))
+  candidates.push(path.join(createPkgRoot, 'node_modules', ...FRAMEWORK_SEGMENTS, 'skills'))
+  candidates.push(path.join(process.cwd(), 'node_modules', ...FRAMEWORK_SEGMENTS, 'skills'))
+
+  // Monorepo dev fallback: the framework lives beside this package as a sibling
+  // checkout (`../wabot-ts`). Used so smoke tests can resolve skills without the
+  // framework being installed as a dependency; installed lookups above win.
+  candidates.push(path.join(createPkgRoot, '..', 'wabot-ts', 'skills'))
+
+  for (const dir of candidates) {
+    if (dir && fs.existsSync(dir)) return dir
+  }
+
+  throw new Error(
+    `Could not locate ${FRAMEWORK_PKG} skills. Ensure ${FRAMEWORK_PKG} is installed ` +
+      `(the packaged skills ship with the framework as of the version that added them).`,
+  )
+}

package/lib/skills/install.mjs

@@ -3,6 +3,7 @@ import os from 'os'
 import path from 'path'
 
 import { getSkill, listSkillNames, listSkills } from './registry.mjs'
+import { resolveFrameworkSkillsDir } from './framework-source.mjs'
 
 const supportedAgents = {
   codex: ['.codex', 'skills'],
@@ -14,7 +15,7 @@ export function listSupportedAgents() {
   return Object.keys(supportedAgents)
 }
 
-export async function installSkillsInProject(projectDir, agents, skillNames) {
+export async function installSkillsInProject(projectDir, agents, skillNames, excludeSkills = []) {
   if (!projectDir) {
     throw new Error('installSkillsInProject: projectDir is required')
   }
@@ -28,8 +29,13 @@ export async function installSkillsInProject(projectDir, agents, skillNames) {
     return agent
   })
 
-  const skills =
-    skillNames && skillNames.length > 0 ? skillNames.map((name) => requireSkill(name)) : listSkills()
+  const skillsDir = resolveFrameworkSkillsDir(projectDir)
+  const excluded = new Set(excludeSkills ?? [])
+  const skills = (
+    skillNames && skillNames.length > 0
+      ? skillNames.map((name) => requireSkill(name, skillsDir))
+      : listSkills(skillsDir)
+  ).filter((skill) => !excluded.has(skill.name))
 
   const installations = []
 
@@ -59,22 +65,23 @@ export async function installSkillsInProject(projectDir, agents, skillNames) {
   return { agents: resolvedAgents, skills: skills.map((skill) => skill.name), installations }
 }
 
-function requireSkill(name) {
-  const skill = getSkill(name)
+function requireSkill(name, skillsDir) {
+  const skill = getSkill(name, skillsDir)
   if (!skill) {
     throw new Error(
-      `Unknown skill "${name}". Available skills: ${listSkillNames().join(', ')}`,
+      `Unknown skill "${name}". Available skills: ${listSkillNames(skillsDir).join(', ')}`,
     )
   }
   return skill
 }
 
 export async function installSkill(skillName, options, cwd = process.cwd()) {
-  const skill = getSkill(skillName)
+  const skillsDir = resolveFrameworkSkillsDir(cwd)
+  const skill = getSkill(skillName, skillsDir)
 
   if (!skill) {
     throw new Error(
-      `Unknown skill "${skillName}". Available skills: ${listSkillNames().join(', ')}`,
+      `Unknown skill "${skillName}". Available skills: ${listSkillNames(skillsDir).join(', ')}`,
     )
   }