@wabot-dev/create 0.0.3 → 2.0.0-beta.0

package/lib/create-project.mjs

@@ -5,97 +5,122 @@ import path from 'path'
 import fs from 'fs/promises'
 import { spawn } from 'child_process'
 
+import { installSkillsInProject, listSupportedAgents } from './skills/install.mjs'
+import { createTranslator } from './i18n.mjs'
+
 const REQUIRED_NODE_MAJOR = 22
 
+const TEMPLATE_REPO = 'wabot-dev/wabot-template'
+const TEMPLATE_BETA_BRANCH = 'beta'
+
+// Beta builds of @wabot-dev/create scaffold from the matching `beta` branch of the
+// template (which pins the beta framework); stable builds use the default branch.
+// `WABOT_TEMPLATE_REF` overrides both (e.g. to test a branch before release).
+async function resolveTemplateRepo() {
+  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')
+
+  return isBeta ? `${TEMPLATE_REPO}#${TEMPLATE_BETA_BRANCH}` : TEMPLATE_REPO
+}
+
 const AI_PROVIDERS = [
   {
     value: 'openrouter',
     title: 'OpenRouter',
-    description: 'Used by the included Pixel example',
+    descriptionKey: 'providers.openrouter',
     envKey: 'OPENROUTER_API_KEY',
   },
   {
     value: 'openai',
     title: 'OpenAI',
-    description: 'GPT models via the official OpenAI API',
+    descriptionKey: 'providers.openai',
     envKey: 'OPENAI_API_KEY',
   },
   {
     value: 'anthropic',
     title: 'Anthropic',
-    description: 'Claude models',
+    descriptionKey: 'providers.anthropic',
     envKey: 'ANTHROPIC_API_KEY',
   },
   {
     value: 'google',
     title: 'Google',
-    description: 'Gemini models',
+    descriptionKey: 'providers.google',
     envKey: 'GOOGLE_API_KEY',
   },
 ]
 
+function agentLabel(t, agent) {
+  const key = `agent.label.${agent}`
+  const value = t(key)
+  return value === key ? agent : value
+}
+
 export async function runCreateProjectCommand(projectDirectory, options) {
-  printIntro()
-  ensureNodeVersion()
+  const t = createTranslator(options?.lang)
+
+  printIntro(t)
+  ensureNodeVersion(t)
 
-  const projectName = await resolveProjectName(projectDirectory)
-  const setup = await collectSetup(options)
+  const projectName = await resolveProjectName(projectDirectory, t)
+  const setup = await collectSetup(options, t)
 
-  await createProject(projectName, setup)
-  await installDependencies(projectName)
+  await createProject(projectName, setup, t)
+  await installDependencies(projectName, t)
+
+  if (setup.skills.install) {
+    await installAgentSkills(projectName, setup.skills, t)
+  }
 
-  printNextSteps(projectName, setup)
+  printNextSteps(projectName, setup, t)
   process.exit(0)
 }
 
-function printIntro() {
+function printIntro(t) {
   const line = chalk.gray('─'.repeat(60))
   console.log()
   console.log(line)
-  console.log(chalk.bold.cyan('  🤖  Wabot project creator'))
+  console.log(chalk.bold.cyan(`  ${t('intro.title')}`))
   console.log()
+  console.log(`  ${t('intro.line1')}`)
   console.log(
-    '  This wizard will scaffold a new chat-bot project from the',
-  )
-  console.log(
-    `  ${chalk.cyan('@wabot-dev/template')} starter and configure your ${chalk.cyan('.env')}.`,
+    `  ${t('intro.line2', chalk.cyan('@wabot-dev/template'), chalk.cyan('.env'))}`,
   )
   console.log()
-  console.log('  You will be asked about:')
-  console.log('    • where to store data (in-memory or PostgreSQL)')
-  console.log('    • which AI providers you want to use')
+  console.log(`  ${t('intro.askAbout')}`)
+  console.log(`    • ${t('intro.bullet.storage')}`)
+  console.log(`    • ${t('intro.bullet.providers')}`)
   console.log(line)
   console.log()
 }
 
-function ensureNodeVersion() {
+function ensureNodeVersion(t) {
   const major = Number(process.versions.node.split('.')[0])
   if (major === REQUIRED_NODE_MAJOR) {
     return
   }
 
-  console.log(
-    chalk.red(
-      `✖ Node.js ${REQUIRED_NODE_MAJOR} is required (you are running ${process.versions.node}).`,
-    ),
-  )
+  console.log(chalk.red(t('node.required', REQUIRED_NODE_MAJOR, process.versions.node)))
   console.log()
-  console.log(
-    `The Wabot template pins Node ${REQUIRED_NODE_MAJOR} in its ${chalk.cyan('.nvmrc')}.`,
-  )
-  console.log(`We recommend installing it with ${chalk.cyan('nvm')}:`)
+  console.log(t('node.templatePin', REQUIRED_NODE_MAJOR, chalk.cyan('.nvmrc')))
+  console.log(t('node.installHint', chalk.cyan('nvm')))
   console.log()
   console.log(chalk.cyan(`  nvm install ${REQUIRED_NODE_MAJOR}`))
   console.log(chalk.cyan(`  nvm use ${REQUIRED_NODE_MAJOR}`))
   console.log()
   console.log(
-    `Don't have nvm? See ${chalk.underline('https://github.com/nvm-sh/nvm#installing-and-updating')}`,
+    t('node.noNvm', chalk.underline('https://github.com/nvm-sh/nvm#installing-and-updating')),
   )
   console.log()
   process.exit(1)
 }
 
-async function resolveProjectName(projectDirectory) {
+async function resolveProjectName(projectDirectory, t) {
   if (projectDirectory) {
     return projectDirectory
   }
@@ -103,36 +128,30 @@ async function resolveProjectName(projectDirectory) {
   const response = await prompts({
     type: 'text',
     name: 'projectName',
-    message: 'What is your project named?',
+    message: t('project.namePrompt'),
     initial: 'my-wabot-app',
   })
 
   if (!response.projectName) {
-    throw new Error('Project name is required')
+    throw new Error(t('project.nameRequired'))
   }
 
   return response.projectName
 }
 
-async function collectSetup(options) {
+async function collectSetup(options, t) {
   const onCancel = () => {
-    throw new Error('Setup cancelled')
+    throw new Error(t('project.cancelled'))
   }
 
   const { storage } = await prompts(
     {
       type: 'select',
       name: 'storage',
-      message: 'How do you want to store data?',
+      message: t('storage.prompt'),
       choices: [
-        {
-          title: 'In-memory (quickest start, data resets on restart)',
-          value: 'memory',
-        },
-        {
-          title: 'PostgreSQL (persistent, recommended for real bots)',
-          value: 'postgres',
-        },
+        { title: t('storage.memory'), value: 'memory' },
+        { title: t('storage.postgres'), value: 'postgres' },
       ],
       initial: 0,
     },
@@ -145,7 +164,7 @@ async function collectSetup(options) {
       {
         type: 'text',
         name: 'databaseUrl',
-        message: 'DATABASE_URL (leave blank to fill in later):',
+        message: t('storage.dbUrlPrompt'),
         initial: options.dbUrl ?? '',
       },
       { onCancel },
@@ -157,14 +176,14 @@ async function collectSetup(options) {
     {
       type: 'multiselect',
       name: 'providers',
-      message: 'Which AI providers will you use? (space to toggle, enter to confirm)',
+      message: t('providers.prompt'),
       choices: AI_PROVIDERS.map((p) => ({
         title: p.title,
         value: p.value,
-        description: p.description,
+        description: t(p.descriptionKey),
         selected: p.value === 'openrouter',
       })),
-      hint: 'At least one is required to run the included Pixel example',
+      hint: t('providers.hint'),
       instructions: false,
       min: 1,
     },
@@ -178,24 +197,74 @@ async function collectSetup(options) {
       {
         type: 'password',
         name: 'apiKey',
-        message: `${provider.envKey} (leave blank to fill in later):`,
+        message: t('providers.apiKeyPrompt', provider.envKey),
       },
       { onCancel },
     )
     providerKeys[provider.envKey] = apiKey ?? ''
   }
 
-  return { storage, databaseUrl, providers, providerKeys }
+  const skills = await collectSkillsSetup({ onCancel }, t)
+
+  return { storage, databaseUrl, providers, providerKeys, skills }
 }
 
-async function createProject(projectName, setup) {
+async function collectSkillsSetup({ onCancel }, t) {
+  const supportedAgents = listSupportedAgents()
+
+  const { install } = await prompts(
+    {
+      type: 'confirm',
+      name: 'install',
+      message: t('skills.installPrompt'),
+      initial: true,
+    },
+    { onCancel },
+  )
+
+  if (!install) {
+    return { install: false, agents: [], skills: [] }
+  }
+
+  const { agents } = await prompts(
+    {
+      type: 'multiselect',
+      name: 'agents',
+      message: t('skills.agentsPrompt'),
+      choices: supportedAgents.map((agent) => ({
+        title: agentLabel(t, agent),
+        value: agent,
+        selected: true,
+      })),
+      hint: t('skills.agentsHint'),
+      instructions: false,
+      min: 1,
+    },
+    { onCancel },
+  )
+
+  // Empty list = install every skill the installed framework ships; the actual
+  // set is resolved at install time from @wabot-dev/framework in the new project.
+  return {
+    install: true,
+    agents,
+    skills: [],
+  }
+}
+
+async function createProject(projectName, setup, t) {
   const targetDir = path.resolve(process.cwd(), projectName)
 
-  await ensureDirectoryDoesNotExist(targetDir, projectName)
+  await ensureDirectoryDoesNotExist(targetDir, projectName, t)
+
+  console.log(chalk.blue(t('project.creating', chalk.green(targetDir))))
 
-  console.log(chalk.blue(`\nCreating a new Wabot project in ${chalk.green(targetDir)}\n`))
+  const templateRepo = await resolveTemplateRepo()
+  if (templateRepo !== TEMPLATE_REPO) {
+    console.log(chalk.gray(t('project.templateSource', templateRepo)))
+  }
 
-  const emitter = degit('wabot-dev/wabot-template', {
+  const emitter = degit(templateRepo, {
     cache: false,
     force: true,
     verbose: true,
@@ -208,13 +277,13 @@ async function createProject(projectName, setup) {
   packageJson.name = projectName
   await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n')
 
-  await writeEnvFile(targetDir, setup)
+  await writeEnvFile(targetDir, setup, t)
 }
 
-async function ensureDirectoryDoesNotExist(targetDir, projectName) {
+async function ensureDirectoryDoesNotExist(targetDir, projectName, t) {
   try {
     await fs.access(targetDir)
-    throw new Error(`Directory ${projectName} already exists`)
+    throw new Error(t('project.exists', projectName))
   } catch (error) {
     if (error?.code === 'ENOENT') {
       return
@@ -224,22 +293,22 @@ async function ensureDirectoryDoesNotExist(targetDir, projectName) {
   }
 }
 
-async function writeEnvFile(targetDir, setup) {
+async function writeEnvFile(targetDir, setup, t) {
   const lines = []
-  lines.push('# debug important things')
+  lines.push(t('env.debugComment'))
   lines.push('DEBUG=wabot:*:error,wabot:*:warn,wabot:*:info')
   lines.push('')
 
   if (setup.storage === 'postgres') {
-    lines.push('# postgres connection string')
+    lines.push(t('env.postgresComment'))
     lines.push(`DATABASE_URL=${setup.databaseUrl}`)
   } else {
-    lines.push('# using in-memory storage (set DATABASE_URL to switch to postgres)')
+    lines.push(t('env.inMemoryComment'))
     lines.push('# DATABASE_URL=')
   }
   lines.push('')
 
-  lines.push('# AI provider keys')
+  lines.push(t('env.providersComment'))
   for (const provider of AI_PROVIDERS) {
     const selected = setup.providers.includes(provider.value)
     if (selected) {
@@ -253,11 +322,11 @@ async function writeEnvFile(targetDir, setup) {
   await fs.writeFile(path.join(targetDir, '.env'), lines.join('\n'))
 }
 
-async function installDependencies(projectName) {
+async function installDependencies(projectName, t) {
   const targetDir = path.resolve(process.cwd(), projectName)
   const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm'
 
-  console.log(chalk.blue('\nInstalling dependencies with npm...\n'))
+  console.log(chalk.blue(t('deps.installing')))
 
   await new Promise((resolve, reject) => {
     const child = spawn(npmCmd, ['install'], {
@@ -270,30 +339,71 @@ async function installDependencies(projectName) {
       if (code === 0) {
         resolve()
       } else {
-        reject(new Error(`npm install exited with code ${code}`))
+        reject(new Error(t('deps.exitCode', code)))
       }
     })
   })
 }
 
-function printNextSteps(projectName, setup) {
-  console.log(chalk.green(`\n✔ Project ${chalk.bold(projectName)} is ready.\n`))
+async function installAgentSkills(projectName, skillsSetup, t) {
+  const targetDir = path.resolve(process.cwd(), projectName)
+
+  console.log(chalk.blue(t('skills.installing')))
+
+  try {
+    const result = await installSkillsInProject(targetDir, skillsSetup.agents, skillsSetup.skills)
+
+    const installed = result.installations.filter((i) => i.status === 'installed')
+    const skipped = result.installations.filter((i) => i.status === 'skipped')
+
+    if (installed.length > 0) {
+      const byAgent = new Map()
+      for (const item of installed) {
+        const list = byAgent.get(item.agent) ?? []
+        list.push(item.skill)
+        byAgent.set(item.agent, list)
+      }
+      for (const [agent, names] of byAgent) {
+        const dir = path.join(projectName, ...resolveAgentDir(agent))
+        console.log(chalk.green(t('skills.installed', agent, names.length, dir)))
+      }
+    }
+    if (skipped.length > 0) {
+      console.log(chalk.yellow(t('skills.skipped', skipped.length)))
+    }
+  } catch (error) {
+    console.log(chalk.red(t('skills.failed', error.message)))
+    console.log(chalk.yellow(t('skills.installLater')))
+  }
+}
+
+function resolveAgentDir(agent) {
+  switch (agent) {
+    case 'claude': return ['.claude', 'skills']
+    case 'codex': return ['.codex', 'skills']
+    case 'agents': return ['.agents', 'skills']
+    default: return [`.${agent}`, 'skills']
+  }
+}
+
+function printNextSteps(projectName, setup, t) {
+  console.log(chalk.green(t('next.ready', chalk.bold(projectName))))
 
   const missingKeys = AI_PROVIDERS.filter(
     (p) => setup.providers.includes(p.value) && !setup.providerKeys[p.envKey],
   ).map((p) => p.envKey)
 
   if (setup.storage === 'postgres' && !setup.databaseUrl) {
-    console.log(chalk.yellow('  ⚠  DATABASE_URL is empty — set it in .env before running.'))
+    console.log(chalk.yellow(t('next.dbUrlEmpty')))
   }
   if (missingKeys.length > 0) {
-    console.log(
-      chalk.yellow(`  ⚠  Missing API keys in .env: ${missingKeys.join(', ')}`),
-    )
+    console.log(chalk.yellow(t('next.missingKeys', missingKeys.join(', '))))
   }
 
-  console.log('\nNext steps:')
+  console.log(t('next.heading'))
   console.log(chalk.cyan(`\n  cd ${projectName}`))
-  console.log(chalk.cyan('  npm run dev'))
-  console.log('\nHappy hacking! 🚀\n')
+  console.log(chalk.cyan('  npm run dev:watch'))
+  console.log(t('next.cmdChannelHint'))
+  console.log(chalk.cyan('\n  npm run cmd:channel'))
+  console.log(t('next.happy'))
 }

package/lib/i18n.mjs

@@ -0,0 +1,167 @@
+const STRINGS = {
+  en: {
+    'intro.title': '🤖  Wabot project creator',
+    '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.storage': 'where to store data (in-memory or PostgreSQL)',
+    'intro.bullet.providers': 'which AI providers you want to use',
+
+    'node.required': (required, current) =>
+      `✖ Node.js ${required} is required (you are running ${current}).`,
+    'node.templatePin': (required, nvmrc) =>
+      `The Wabot template pins Node ${required} in its ${nvmrc}.`,
+    'node.installHint': (nvm) => `We recommend installing it with ${nvm}:`,
+    'node.noNvm': (url) => `Don't have nvm? See ${url}`,
+
+    'project.namePrompt': 'What is your project named?',
+    'project.nameRequired': 'Project name is required',
+    '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)',
+    'storage.postgres': 'PostgreSQL (persistent, recommended for real bots)',
+    'storage.dbUrlPrompt': 'DATABASE_URL (leave blank to fill in later):',
+
+    'providers.prompt': 'Which AI providers will you use? (space to toggle, enter to confirm)',
+    'providers.hint': 'At least one is required to run the included Pixel example',
+    'providers.apiKeyPrompt': (envKey) => `${envKey} (leave blank to fill in later):`,
+    'providers.openrouter': 'Used by the included Pixel example',
+    'providers.openai': 'GPT models via the official OpenAI API',
+    'providers.anthropic': 'Claude models',
+    'providers.google': 'Gemini models',
+
+    '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',
+    'skills.installed': (agent, count, dir) =>
+      `  ✔ ${agent}: installed ${count} skill(s) into ${dir}`,
+    'skills.skipped': (count) =>
+      `  ⚠  ${count} skill folder(s) already existed and were left untouched.`,
+    'skills.failed': (msg) => `  ✖ Failed to install agent skills: ${msg}`,
+    'skills.installLater':
+      '  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}`,
+
+    'env.debugComment': '# debug important things',
+    'env.postgresComment': '# postgres connection string',
+    'env.inMemoryComment':
+      '# using in-memory storage (set DATABASE_URL to switch to postgres)',
+    'env.providersComment': '# AI provider keys',
+
+    'next.ready': (name) => `\n✔ Project ${name} is ready.\n`,
+    'next.dbUrlEmpty': '  ⚠  DATABASE_URL is empty — set it in .env before running.',
+    'next.missingKeys': (keys) => `  ⚠  Missing API keys in .env: ${keys}`,
+    'next.heading': '\nNext steps:',
+    'next.cmdChannelHint':
+      '\nIn another terminal, open a CLI to chat with your bot:',
+    'next.happy': '\nHappy hacking! 🚀\n',
+
+    'agent.label.claude': 'Claude Code (.claude/skills)',
+    'agent.label.codex': 'Codex (.codex/skills)',
+    'agent.label.agents': 'Generic agents (.agents/skills)',
+  },
+
+  es: {
+    'intro.title': '🤖  Creador de proyectos Wabot',
+    'intro.line1': 'Este asistente generará un nuevo proyecto de chat-bot a partir de',
+    'intro.line2': (template, env) =>
+      `la plantilla ${template} y configurará tu archivo ${env}.`,
+    'intro.askAbout': 'Te preguntaremos sobre:',
+    'intro.bullet.storage': 'dónde almacenar los datos (en memoria o PostgreSQL)',
+    'intro.bullet.providers': 'qué proveedores de IA deseas usar',
+
+    'node.required': (required, current) =>
+      `✖ Se requiere Node.js ${required} (estás usando ${current}).`,
+    'node.templatePin': (required, nvmrc) =>
+      `La plantilla de Wabot fija Node ${required} en su ${nvmrc}.`,
+    'node.installHint': (nvm) => `Recomendamos instalarlo con ${nvm}:`,
+    'node.noNvm': (url) => `¿No tienes nvm? Consulta ${url}`,
+
+    'project.namePrompt': '¿Cómo se llama tu proyecto?',
+    'project.nameRequired': 'El nombre del proyecto es obligatorio',
+    '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)',
+    'storage.postgres': 'PostgreSQL (persistente, recomendado para bots reales)',
+    'storage.dbUrlPrompt': 'DATABASE_URL (déjalo en blanco para completarlo después):',
+
+    'providers.prompt':
+      '¿Qué proveedores de IA usarás? (espacio para alternar, enter para confirmar)',
+    'providers.hint':
+      'Se requiere al menos uno para ejecutar el ejemplo Pixel incluido',
+    'providers.apiKeyPrompt': (envKey) =>
+      `${envKey} (déjalo en blanco para completarlo después):`,
+    'providers.openrouter': 'Usado por el ejemplo Pixel incluido',
+    'providers.openai': 'Modelos GPT mediante la API oficial de OpenAI',
+    'providers.anthropic': 'Modelos Claude',
+    'providers.google': 'Modelos Gemini',
+
+    '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':
+      'Cada uno añade una carpeta <agente>/skills en la raíz del proyecto',
+    'skills.installing': '\nInstalando skills de agente Wabot...\n',
+    'skills.installed': (agent, count, dir) =>
+      `  ✔ ${agent}: se instalaron ${count} skill(s) en ${dir}`,
+    'skills.skipped': (count) =>
+      `  ⚠  ${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/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}`,
+
+    'env.debugComment': '# depurar lo importante',
+    'env.postgresComment': '# cadena de conexión de postgres',
+    'env.inMemoryComment':
+      '# usando almacenamiento en memoria (define DATABASE_URL para cambiar a postgres)',
+    'env.providersComment': '# claves de proveedores de IA',
+
+    'next.ready': (name) => `\n✔ El proyecto ${name} está listo.\n`,
+    'next.dbUrlEmpty':
+      '  ⚠  DATABASE_URL está vacío — defínelo en .env antes de ejecutar.',
+    'next.missingKeys': (keys) => `  ⚠  Faltan claves de API en .env: ${keys}`,
+    'next.heading': '\nPróximos pasos:',
+    'next.cmdChannelHint':
+      '\nEn otra terminal, abre una CLI para chatear con tu bot:',
+    'next.happy': '\n¡Feliz desarrollo! 🚀\n',
+
+    'agent.label.claude': 'Claude Code (.claude/skills)',
+    'agent.label.codex': 'Codex (.codex/skills)',
+    'agent.label.agents': 'Agentes genéricos (.agents/skills)',
+  },
+}
+
+export const SUPPORTED_LANGS = Object.keys(STRINGS)
+export const DEFAULT_LANG = 'en'
+
+export function resolveLang(lang) {
+  if (!lang) return DEFAULT_LANG
+  const normalized = String(lang).toLowerCase()
+  return SUPPORTED_LANGS.includes(normalized) ? normalized : DEFAULT_LANG
+}
+
+export function createTranslator(lang) {
+  const resolved = resolveLang(lang)
+  const dict = STRINGS[resolved]
+  const fallback = STRINGS[DEFAULT_LANG]
+
+  return function t(key, ...args) {
+    const value = dict[key] ?? fallback[key]
+    if (value === undefined) return key
+    return typeof value === 'function' ? value(...args) : value
+  }
+}

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).`,
+  )
+}