@wabot-dev/create 0.0.2 → 0.0.3

package/README.md

@@ -0,0 +1,189 @@
+# `@wabot-dev/create`
+
+CLI para:
+
+- crear un nuevo proyecto Wabot desde el template oficial
+- instalar skills empaquetadas en distintos homes o targets de agentes
+
+## Instalación
+
+```bash
+npm install
+```
+
+Para probar el binario local:
+
+```bash
+node ./bin/create-wabot.mjs --help
+```
+
+## Comando principal
+
+Crear un proyecto nuevo:
+
+```bash
+create-wabot <project-directory>
+```
+
+Ejemplo:
+
+```bash
+create-wabot my-wabot-app
+```
+
+Variaciones:
+
+```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>
+```
+
+Skill disponible actualmente:
+
+```bash
+create-wabot skill add wabot-framework
+```
+
+## Variaciones de `skill add`
+
+### 1. Instalación global por defecto
+
+Usa el home del sistema y, si no se indica target, instala para `codex`.
+
+```bash
+create-wabot skill add wabot-framework
+```
+
+Resultado esperado:
+
+- `<os.homedir()>/.codex/skills/wabot-framework`
+
+### 2. Instalación local al proyecto
+
+Instala en el workspace actual:
+
+```bash
+create-wabot skill add wabot-framework --local
+```
+
+Resultado esperado:
+
+- `./.agents/skills/wabot-framework`
+
+### 3. Instalación global con home explícito
+
+Instala usando un home root manual:
+
+```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 --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
+```
+
+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
+
+- `--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
+```
+
+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
+```
+
+## Desarrollo
+
+Mostrar ayuda:
+
+```bash
+node ./bin/create-wabot.mjs --help
+node ./bin/create-wabot.mjs skill add --help
+```

package/bin/create-wabot.mjs

@@ -1,106 +1,13 @@
 #!/usr/bin/env node
 
-import { program } from 'commander'
 import chalk from 'chalk'
-import degit from 'degit'
-import prompts from 'prompts'
-import path from 'path'
-import fs from 'fs/promises'
+import { buildProgram } from '../lib/cli.mjs'
 
-async function createProject(projectName, options) {
-  try {
-    // Get the absolute path for the project
-    const targetDir = path.resolve(process.cwd(), projectName)
+const program = buildProgram()
 
-    // Check if directory exists
-    try {
-      await fs.access(targetDir)
-      console.error(chalk.red(`Error: Directory ${projectName} already exists`))
-      process.exit(1)
-    } catch {
-      // Directory doesn't exist, we can proceed
-    }
-
-    // Clone the template repository
-    console.log(chalk.blue(`Creating a new Wabot project in ${chalk.green(targetDir)}`))
-
-    const emitter = degit('wabot-dev/wabot-template', {
-      cache: false,
-      force: true,
-      verbose: true,
-    })
-
-    await emitter.clone(targetDir)
-
-    // Read the template's package.json
-    const packageJsonPath = path.join(targetDir, 'package.json')
-    const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'))
-
-    // Update package.json with the new project name
-    packageJson.name = projectName
-
-    // Write the updated package.json
-    await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2))
-
-    // Create .env file
-    await createEnvFile(targetDir, options.dbUrl, options.llmUrl, options.apiKey)
-
-    console.log(chalk.green('\nSuccess! 🎉 Created', projectName))
-    console.log(chalk.yellow('\n  .env file add DATABASE_URL, WABOT_LLM_URL, WABOT_API_KEY'))
-    console.log('\nInside that directory, you can run several commands:')
-    console.log(chalk.cyan('\n  npm install'))
-    console.log('    Install the project dependencies')
-    console.log(chalk.cyan('\n  npm start'))
-    console.log('    Starts the development server')
-    console.log('\nWe suggest that you begin by typing:')
-    console.log(chalk.cyan(`\n  cd ${projectName}`))
-    console.log(chalk.cyan('  npm install'))
-    console.log(chalk.cyan('  npm start'))
-    console.log('\nHappy hacking! 🚀\n')
-  } catch (error) {
-    console.error(chalk.red('Error:'), error)
-    process.exit(1)
-  }
+try {
+  await program.parseAsync(process.argv)
+} catch (error) {
+  console.error(chalk.red('Error:'), error.message)
+  process.exit(1)
 }
-
-async function createEnvFile(targetDir, dbUrl, llmUrl, apiKey) {
-  const envContent = `
-DATABASE_URL=${dbUrl}
-WABOT_LLM_URL=${llmUrl}
-WABOT_API_KEY=${apiKey}
-`
-
-  await fs.writeFile(path.join(targetDir, '.env'), envContent.trim())
-}
-
-// Set up the CLI
-program
-  .name('create-wabot')
-  .description('Create a new Wabot project')
-  .argument('[project-directory]', 'project name')
-  .option('--db-url <dbUrl>', 'database url')
-  .option('--llm-url <llmUrl>', 'llm url')
-  .option('--api-key <key>', 'api key')
-  .action(async (projectDirectory, options) => {
-    let projectName = projectDirectory
-
-    if (!projectName) {
-      const response = await prompts({
-        type: 'text',
-        name: 'projectName',
-        message: 'What is your project named?',
-        initial: 'my-wabot-app',
-      })
-
-      if (!response.projectName) {
-        console.log(chalk.red('Project name is required'))
-        process.exit(1)
-      }
-
-      projectName = response.projectName
-    }
-
-    await createProject(projectName, options)
-  })
-
-program.parse()

package/lib/cli.mjs

@@ -0,0 +1,49 @@
+import { Command } from 'commander'
+import chalk from 'chalk'
+
+import { runCreateProjectCommand } from './create-project.mjs'
+import { installSkill } from './skills/install.mjs'
+
+export function buildProgram() {
+  const program = new Command()
+
+  program
+    .name('create-wabot')
+    .description('Create a new Wabot project and install packaged Wabot skills')
+    .argument('[project-directory]', 'project name')
+    .option('--db-url <dbUrl>', 'postgres connection string (used as default when prompting)')
+    .action(async (projectDirectory, options) => {
+      await runCreateProjectCommand(projectDirectory, options)
+    })
+
+  const skillCommand = program.command('skill').description('Manage packaged Wabot skills')
+
+  skillCommand
+    .command('add <skill-name>')
+    .description('Install a packaged Wabot skill')
+    .option('--local', 'install into ./.agents/skills/<skill-name>')
+    .option('--global', 'install into one or more agent homes under the selected home root')
+    .option('--home <path>', 'global home root; defaults to $HOME')
+    .option('--target <name>', 'single global target (codex, claude, agents)')
+    .option('--targets <names>', 'comma-separated global targets (codex, claude, agents)')
+    .action(async (skillName, options) => {
+      const result = await installSkill(skillName, options)
+
+      if (result.mode === 'global') {
+        console.log(chalk.blue(`Home root: ${result.homeRoot}`))
+      } else {
+        console.log(chalk.blue('Agent target: local workspace (.agents/skills)'))
+      }
+
+      for (const installation of result.installations) {
+        console.log(
+          chalk.green(
+            `Installed ${result.skill.name} to ${chalk.cyan(installation.installDir)}`,
+          ),
+        )
+        console.log(chalk.blue(`Target: ${installation.agent}`))
+      }
+    })
+
+  return program
+}

package/lib/create-project.mjs

@@ -0,0 +1,299 @@
+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'
+
+const REQUIRED_NODE_MAJOR = 22
+
+const AI_PROVIDERS = [
+  {
+    value: 'openrouter',
+    title: 'OpenRouter',
+    description: 'Used by the included Pixel example',
+    envKey: 'OPENROUTER_API_KEY',
+  },
+  {
+    value: 'openai',
+    title: 'OpenAI',
+    description: 'GPT models via the official OpenAI API',
+    envKey: 'OPENAI_API_KEY',
+  },
+  {
+    value: 'anthropic',
+    title: 'Anthropic',
+    description: 'Claude models',
+    envKey: 'ANTHROPIC_API_KEY',
+  },
+  {
+    value: 'google',
+    title: 'Google',
+    description: 'Gemini models',
+    envKey: 'GOOGLE_API_KEY',
+  },
+]
+
+export async function runCreateProjectCommand(projectDirectory, options) {
+  printIntro()
+  ensureNodeVersion()
+
+  const projectName = await resolveProjectName(projectDirectory)
+  const setup = await collectSetup(options)
+
+  await createProject(projectName, setup)
+  await installDependencies(projectName)
+
+  printNextSteps(projectName, setup)
+  process.exit(0)
+}
+
+function printIntro() {
+  const line = chalk.gray('─'.repeat(60))
+  console.log()
+  console.log(line)
+  console.log(chalk.bold.cyan('  🤖  Wabot project creator'))
+  console.log()
+  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')}.`,
+  )
+  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(line)
+  console.log()
+}
+
+function ensureNodeVersion() {
+  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()
+  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()
+  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')}`,
+  )
+  console.log()
+  process.exit(1)
+}
+
+async function resolveProjectName(projectDirectory) {
+  if (projectDirectory) {
+    return projectDirectory
+  }
+
+  const response = await prompts({
+    type: 'text',
+    name: 'projectName',
+    message: 'What is your project named?',
+    initial: 'my-wabot-app',
+  })
+
+  if (!response.projectName) {
+    throw new Error('Project name is required')
+  }
+
+  return response.projectName
+}
+
+async function collectSetup(options) {
+  const onCancel = () => {
+    throw new Error('Setup cancelled')
+  }
+
+  const { storage } = await prompts(
+    {
+      type: 'select',
+      name: 'storage',
+      message: 'How do you want to store data?',
+      choices: [
+        {
+          title: 'In-memory (quickest start, data resets on restart)',
+          value: 'memory',
+        },
+        {
+          title: 'PostgreSQL (persistent, recommended for real bots)',
+          value: 'postgres',
+        },
+      ],
+      initial: 0,
+    },
+    { onCancel },
+  )
+
+  let databaseUrl = ''
+  if (storage === 'postgres') {
+    const dbResponse = await prompts(
+      {
+        type: 'text',
+        name: 'databaseUrl',
+        message: 'DATABASE_URL (leave blank to fill in later):',
+        initial: options.dbUrl ?? '',
+      },
+      { onCancel },
+    )
+    databaseUrl = dbResponse.databaseUrl ?? ''
+  }
+
+  const { providers } = await prompts(
+    {
+      type: 'multiselect',
+      name: 'providers',
+      message: 'Which AI providers will you use? (space to toggle, enter to confirm)',
+      choices: AI_PROVIDERS.map((p) => ({
+        title: p.title,
+        value: p.value,
+        description: p.description,
+        selected: p.value === 'openrouter',
+      })),
+      hint: 'At least one is required to run the included Pixel example',
+      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: `${provider.envKey} (leave blank to fill in later):`,
+      },
+      { onCancel },
+    )
+    providerKeys[provider.envKey] = apiKey ?? ''
+  }
+
+  return { storage, databaseUrl, providers, providerKeys }
+}
+
+async function createProject(projectName, setup) {
+  const targetDir = path.resolve(process.cwd(), projectName)
+
+  await ensureDirectoryDoesNotExist(targetDir, projectName)
+
+  console.log(chalk.blue(`\nCreating a new Wabot project in ${chalk.green(targetDir)}\n`))
+
+  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)
+}
+
+async function ensureDirectoryDoesNotExist(targetDir, projectName) {
+  try {
+    await fs.access(targetDir)
+    throw new Error(`Directory ${projectName} already exists`)
+  } catch (error) {
+    if (error?.code === 'ENOENT') {
+      return
+    }
+
+    throw error
+  }
+}
+
+async function writeEnvFile(targetDir, setup) {
+  const lines = []
+  lines.push('# debug important things')
+  lines.push('DEBUG=wabot:*:error,wabot:*:warn,wabot:*:info')
+  lines.push('')
+
+  if (setup.storage === 'postgres') {
+    lines.push('# postgres connection string')
+    lines.push(`DATABASE_URL=${setup.databaseUrl}`)
+  } else {
+    lines.push('# using in-memory storage (set DATABASE_URL to switch to postgres)')
+    lines.push('# DATABASE_URL=')
+  }
+  lines.push('')
+
+  lines.push('# AI provider keys')
+  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) {
+  const targetDir = path.resolve(process.cwd(), projectName)
+  const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm'
+
+  console.log(chalk.blue('\nInstalling dependencies with npm...\n'))
+
+  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(`npm install exited with code ${code}`))
+      }
+    })
+  })
+}
+
+function printNextSteps(projectName, setup) {
+  console.log(chalk.green(`\n✔ Project ${chalk.bold(projectName)} is ready.\n`))
+
+  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.'))
+  }
+  if (missingKeys.length > 0) {
+    console.log(
+      chalk.yellow(`  ⚠  Missing API keys in .env: ${missingKeys.join(', ')}`),
+    )
+  }
+
+  console.log('\nNext steps:')
+  console.log(chalk.cyan(`\n  cd ${projectName}`))
+  console.log(chalk.cyan('  npm run dev'))
+  console.log('\nHappy hacking! 🚀\n')
+}