@wabot-dev/create 0.0.2 → 0.0.4

package/lib/create-project.mjs

@@ -0,0 +1,386 @@
+import chalk from 'chalk'
+import degit from 'degit'
+import prompts from 'prompts'
+import path from 'path'
+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 AI_PROVIDERS = [
+  {
+    value: 'openrouter',
+    title: 'OpenRouter',
+    descriptionKey: 'providers.openrouter',
+    envKey: 'OPENROUTER_API_KEY',
+  },
+  {
+    value: 'openai',
+    title: 'OpenAI',
+    descriptionKey: 'providers.openai',
+    envKey: 'OPENAI_API_KEY',
+  },
+  {
+    value: 'anthropic',
+    title: 'Anthropic',
+    descriptionKey: 'providers.anthropic',
+    envKey: 'ANTHROPIC_API_KEY',
+  },
+  {
+    value: 'google',
+    title: 'Google',
+    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) {
+  const t = createTranslator(options?.lang)
+
+  printIntro(t)
+  ensureNodeVersion(t)
+
+  const projectName = await resolveProjectName(projectDirectory, t)
+  const setup = await collectSetup(options, t)
+
+  await createProject(projectName, setup, t)
+  await installDependencies(projectName, t)
+
+  if (setup.skills.install) {
+    await installAgentSkills(projectName, setup.skills, t)
+  }
+
+  printNextSteps(projectName, setup, t)
+  process.exit(0)
+}
+
+function printIntro(t) {
+  const line = chalk.gray('─'.repeat(60))
+  console.log()
+  console.log(line)
+  console.log(chalk.bold.cyan(`  ${t('intro.title')}`))
+  console.log()
+  console.log(`  ${t('intro.line1')}`)
+  console.log(
+    `  ${t('intro.line2', chalk.cyan('@wabot-dev/template'), chalk.cyan('.env'))}`,
+  )
+  console.log()
+  console.log(`  ${t('intro.askAbout')}`)
+  console.log(`    • ${t('intro.bullet.storage')}`)
+  console.log(`    • ${t('intro.bullet.providers')}`)
+  console.log(line)
+  console.log()
+}
+
+function ensureNodeVersion(t) {
+  const major = Number(process.versions.node.split('.')[0])
+  if (major === REQUIRED_NODE_MAJOR) {
+    return
+  }
+
+  console.log(chalk.red(t('node.required', REQUIRED_NODE_MAJOR, process.versions.node)))
+  console.log()
+  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(
+    t('node.noNvm', chalk.underline('https://github.com/nvm-sh/nvm#installing-and-updating')),
+  )
+  console.log()
+  process.exit(1)
+}
+
+async function resolveProjectName(projectDirectory, t) {
+  if (projectDirectory) {
+    return projectDirectory
+  }
+
+  const response = await prompts({
+    type: 'text',
+    name: 'projectName',
+    message: t('project.namePrompt'),
+    initial: 'my-wabot-app',
+  })
+
+  if (!response.projectName) {
+    throw new Error(t('project.nameRequired'))
+  }
+
+  return response.projectName
+}
+
+async function collectSetup(options, t) {
+  const onCancel = () => {
+    throw new Error(t('project.cancelled'))
+  }
+
+  const { storage } = await prompts(
+    {
+      type: 'select',
+      name: 'storage',
+      message: t('storage.prompt'),
+      choices: [
+        { title: t('storage.memory'), value: 'memory' },
+        { title: t('storage.postgres'), value: 'postgres' },
+      ],
+      initial: 0,
+    },
+    { onCancel },
+  )
+
+  let databaseUrl = ''
+  if (storage === 'postgres') {
+    const dbResponse = await prompts(
+      {
+        type: 'text',
+        name: 'databaseUrl',
+        message: t('storage.dbUrlPrompt'),
+        initial: options.dbUrl ?? '',
+      },
+      { onCancel },
+    )
+    databaseUrl = dbResponse.databaseUrl ?? ''
+  }
+
+  const { providers } = await prompts(
+    {
+      type: 'multiselect',
+      name: 'providers',
+      message: t('providers.prompt'),
+      choices: AI_PROVIDERS.map((p) => ({
+        title: p.title,
+        value: p.value,
+        description: t(p.descriptionKey),
+        selected: p.value === 'openrouter',
+      })),
+      hint: t('providers.hint'),
+      instructions: false,
+      min: 1,
+    },
+    { onCancel },
+  )
+
+  const providerKeys = {}
+  for (const value of providers) {
+    const provider = AI_PROVIDERS.find((p) => p.value === value)
+    const { apiKey } = await prompts(
+      {
+        type: 'password',
+        name: 'apiKey',
+        message: t('providers.apiKeyPrompt', provider.envKey),
+      },
+      { onCancel },
+    )
+    providerKeys[provider.envKey] = apiKey ?? ''
+  }
+
+  const skills = await collectSkillsSetup({ onCancel }, t)
+
+  return { 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),
+      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 },
+  )
+
+  return {
+    install: true,
+    agents,
+    skills: availableSkills.map((skill) => skill.name),
+  }
+}
+
+async function createProject(projectName, setup, t) {
+  const targetDir = path.resolve(process.cwd(), projectName)
+
+  await ensureDirectoryDoesNotExist(targetDir, projectName, t)
+
+  console.log(chalk.blue(t('project.creating', chalk.green(targetDir))))
+
+  const emitter = degit('wabot-dev/wabot-template', {
+    cache: false,
+    force: true,
+    verbose: true,
+  })
+
+  await emitter.clone(targetDir)
+
+  const packageJsonPath = path.join(targetDir, 'package.json')
+  const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'))
+  packageJson.name = projectName
+  await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n')
+
+  await writeEnvFile(targetDir, setup, t)
+}
+
+async function ensureDirectoryDoesNotExist(targetDir, projectName, t) {
+  try {
+    await fs.access(targetDir)
+    throw new Error(t('project.exists', projectName))
+  } catch (error) {
+    if (error?.code === 'ENOENT') {
+      return
+    }
+
+    throw error
+  }
+}
+
+async function writeEnvFile(targetDir, setup, t) {
+  const lines = []
+  lines.push(t('env.debugComment'))
+  lines.push('DEBUG=wabot:*:error,wabot:*:warn,wabot:*:info')
+  lines.push('')
+
+  if (setup.storage === 'postgres') {
+    lines.push(t('env.postgresComment'))
+    lines.push(`DATABASE_URL=${setup.databaseUrl}`)
+  } else {
+    lines.push(t('env.inMemoryComment'))
+    lines.push('# DATABASE_URL=')
+  }
+  lines.push('')
+
+  lines.push(t('env.providersComment'))
+  for (const provider of AI_PROVIDERS) {
+    const selected = setup.providers.includes(provider.value)
+    if (selected) {
+      lines.push(`${provider.envKey}=${setup.providerKeys[provider.envKey] ?? ''}`)
+    } else {
+      lines.push(`# ${provider.envKey}=`)
+    }
+  }
+  lines.push('')
+
+  await fs.writeFile(path.join(targetDir, '.env'), lines.join('\n'))
+}
+
+async function installDependencies(projectName, t) {
+  const targetDir = path.resolve(process.cwd(), projectName)
+  const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm'
+
+  console.log(chalk.blue(t('deps.installing')))
+
+  await new Promise((resolve, reject) => {
+    const child = spawn(npmCmd, ['install'], {
+      cwd: targetDir,
+      stdio: 'inherit',
+    })
+
+    child.on('error', reject)
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve()
+      } else {
+        reject(new Error(t('deps.exitCode', code)))
+      }
+    })
+  })
+}
+
+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(t('next.dbUrlEmpty')))
+  }
+  if (missingKeys.length > 0) {
+    console.log(chalk.yellow(t('next.missingKeys', missingKeys.join(', '))))
+  }
+
+  console.log(t('next.heading'))
+  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(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`,
+
+    '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': (count) =>
+      `Install Wabot agent skills (${count}) 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 them later with `create-wabot skill add <skill>`.',
+
+    '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`,
+
+    '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': (count) =>
+      `¿Instalar las skills de agente de Wabot (${count}) 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 más tarde con `create-wabot skill add <skill>`.',
+
+    '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
+  }
+}