plazbot-cli 0.1.3 → 0.1.4

package/src/cli.ts

@@ -4,14 +4,15 @@ import { portalCommands } from './commands/portal';
 import { authCommands } from './commands/auth';
 import { agentCommands } from './commands/agent';
 import { whatsappCommands } from './commands/whatsapp';
+import { showBanner } from './utils/banner';
 
-// Configuración básica del CLI
+// Configuracion basica del CLI
 program
   .name('plazbot')
-  .description('CLI para manejar agentes Plazbot')
-  .version('0.1.0');
+  .description('CLI oficial de Plazbot - Agentes de IA para WhatsApp, portales y desarrolladores')
+  .version('0.2.0');
 
-// Registrar todos los comandos de autenticación
+// Registrar todos los comandos de autenticacion
 authCommands.forEach(cmd => program.addCommand(cmd));
 
 // Registrar todos los comandos de agente
@@ -23,4 +24,11 @@ program.addCommand(portalCommands);
 // Registrar todos los comandos de WhatsApp
 program.addCommand(whatsappCommands);
 
-program.parse(process.argv);
+// Si no se pasan argumentos, mostrar banner
+if (process.argv.length <= 2) {
+  showBanner().then(() => {
+    program.outputHelp();
+  });
+} else {
+  program.parse(process.argv);
+}

package/src/commands/agent/ai-config.ts

@@ -0,0 +1,112 @@
+import { Command } from 'commander';
+import { Agent } from 'plazbot';
+import inquirer from 'inquirer';
+import { getStoredCredentials } from '../../utils/credentials';
+import { logger } from '../../utils/logger';
+import { createSpinner, theme, section, kvPair } from '../../utils/ui';
+import { AgentCommandOptions } from '../../types/agent';
+
+const MODELS: Record<string, string[]> = {
+  openai: ['gpt-4o', 'gpt-4', 'gpt-3.5-turbo', 'o1-preview', 'o1-mini'],
+  claude: ['claude-3-5-sonnet-20241022', 'claude-3-opus-20240229', 'claude-3-haiku-20240307'],
+  gemini: ['gemini-2.0-flash', 'gemini-1.5-pro', 'gemini-1.5-flash'],
+};
+
+export const aiConfigCommand = new Command('ai-config')
+  .description('Configurar proveedor de IA del agente')
+  .argument('<agentId>', 'ID del agente')
+  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .action(async (agentId: string, options: AgentCommandOptions) => {
+    try {
+      const credentials = await getStoredCredentials();
+      const agent = new Agent({
+        workspaceId: credentials.workspace,
+        apiKey: credentials.apiKey,
+        zone: credentials.zone,
+        ...(options.dev && { customUrl: "http://localhost:5090" })
+      });
+
+      const spinner = createSpinner('Cargando agente...');
+      spinner.start();
+      const agentData = await agent.getAgentById({ id: agentId });
+      spinner.stop();
+
+      console.log(section('Configuracion de IA - ' + (agentData.name || agentId)));
+
+      const currentProviders = agentData.aiProviders || [];
+      if (currentProviders.length > 0 && agentData.customAIConfig) {
+        console.log(theme.bold('\n  Configuracion actual:'));
+        currentProviders.forEach((p: any) => {
+          console.log(kvPair('  Proveedor', p.provider));
+          console.log(kvPair('  Modelo', p.model));
+          console.log(kvPair('  Temperatura', String(p.temperature)));
+          console.log(kvPair('  Max Tokens', String(p.maxTokens)));
+          console.log(kvPair('  Default', p.isDefault ? 'Si' : 'No'));
+        });
+      } else {
+        console.log(theme.muted('\n  Usando configuracion de IA por defecto (Plazbot)'));
+      }
+
+      const { action } = await (inquirer as any).prompt([{
+        type: 'list',
+        name: 'action',
+        message: 'Que deseas hacer?',
+        choices: [
+          { name: 'Configurar nuevo proveedor', value: 'set' },
+          { name: 'Usar configuracion por defecto', value: 'reset' },
+          { name: 'Salir', value: 'exit' },
+        ],
+      }]);
+
+      if (action === 'exit') return;
+
+      if (action === 'reset') {
+        const resetConfig = { ...agentData, customAIConfig: false, aiProviders: [] };
+        delete resetConfig.id;
+        delete resetConfig._id;
+        const resetSpinner = createSpinner('Reseteando configuracion...');
+        resetSpinner.start();
+        await agent.updateAgent(agentId, resetConfig);
+        resetSpinner.succeed('Usando configuracion por defecto');
+        return;
+      }
+
+      // Configurar nuevo proveedor
+      const ai = await (inquirer as any).prompt([
+        { type: 'list', name: 'provider', message: 'Proveedor:', choices: ['openai', 'claude', 'gemini'] },
+      ]);
+
+      const models = MODELS[ai.provider] || MODELS.openai;
+
+      const config = await (inquirer as any).prompt([
+        { type: 'list', name: 'model', message: 'Modelo:', choices: models },
+        { type: 'password', name: 'apiToken', message: 'API Token:', mask: '*', validate: (v: string) => v.length > 0 || 'Requerido' },
+        { type: 'number', name: 'temperature', message: 'Temperatura (0-2):', default: 0.7 },
+        { type: 'number', name: 'maxTokens', message: 'Max tokens (1024-16384):', default: 4096 },
+      ]);
+
+      const updatedConfig = {
+        ...agentData,
+        customAIConfig: true,
+        aiProviders: [{
+          provider: ai.provider,
+          model: config.model,
+          apiToken: config.apiToken,
+          temperature: config.temperature,
+          maxTokens: config.maxTokens,
+          isDefault: true,
+        }],
+      };
+      delete updatedConfig.id;
+      delete updatedConfig._id;
+      const updateSpinner = createSpinner('Guardando configuracion...');
+      updateSpinner.start();
+      await agent.updateAgent(agentId, updatedConfig);
+      updateSpinner.succeed(`Proveedor configurado: ${ai.provider} / ${config.model}`);
+
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Error desconocido';
+      logger.error(message);
+      process.exit(1);
+    }
+  });

package/src/commands/agent/chat.ts

@@ -3,24 +3,34 @@ import { Agent } from 'plazbot';
 import { getStoredCredentials } from '../../utils/credentials';
 import { logger } from '../../utils/logger';
 import { AgentCommandOptions, AgentResponse, AgentSource } from '../../types/agent';
+import { theme, section } from '../../utils/ui';
 import crypto from 'crypto';
 import readline from 'readline';
+import chalk from 'chalk';
+
+const COMMANDS_HELP = `
+  ${chalk.bold('Comandos disponibles:')}
+  ${chalk.hex('#4CAF50')('/exit')}      Terminar conversacion
+  ${chalk.hex('#4CAF50')('/clear')}     Limpiar pantalla
+  ${chalk.hex('#4CAF50')('/info')}      Informacion de la sesion
+  ${chalk.hex('#4CAF50')('/sources')}   Mostrar/ocultar fuentes
+  ${chalk.hex('#4CAF50')('/help')}      Mostrar estos comandos
+`;
 
 export const chatCommand = new Command('chat')
-  .description('Inicia una sesión de chat interactiva con un agente')
+  .description('Inicia una sesion de chat interactiva con un agente')
   .requiredOption('-a, --agent-id <id>', 'ID del agente')
-  .option('-s, --session-id <id>', 'ID de sesión (opcional)')
-  .option('-m, --multiple-answers', 'Permitir múltiples respuestas', false)
+  .option('-s, --session-id <id>', 'ID de sesion (opcional)')
+  .option('-m, --multiple-answers', 'Permitir multiples respuestas', false)
   .option('--dev', 'Usar ambiente de desarrollo', false)
-  .action(async (options: AgentCommandOptions & { 
+  .action(async (options: AgentCommandOptions & {
     agentId: string;
     sessionId?: string;
     multipleAnswers?: boolean;
   }) => {
     try {
-      // Obtener credenciales guardadas
       const credentials = await getStoredCredentials();
-      
+
       const agent = new Agent({
         workspaceId: credentials.workspace,
         apiKey: credentials.apiKey,
@@ -28,76 +38,175 @@ export const chatCommand = new Command('chat')
         ...(options.dev && { customUrl: "http://localhost:5090" })
       });
 
-      // Generar un sessionId si no se proporcionó uno
       const sessionId = options.sessionId || crypto.randomUUID();
+      let showSources = true;
+
+      // Cargar info del agente
+      let agentInfo: any = null;
+      try {
+        process.stdout.write(chalk.gray('  Conectando con agente...'));
+        agentInfo = await agent.getAgentById({ id: options.agentId });
+        process.stdout.write('\r' + ' '.repeat(40) + '\r');
+      } catch {
+        process.stdout.write('\r' + ' '.repeat(40) + '\r');
+      }
 
-      // Crear interfaz de readline
       const rl = readline.createInterface({
         input: process.stdin,
         output: process.stdout
       });
 
-      // Limpiar la pantalla
+      // Pantalla de chat
       console.clear();
+      const agentName = agentInfo?.name || 'Agente';
+      const toolCalling = agentInfo?.useToolCalling ? chalk.hex('#4CAF50')(' [Tool Calling]') : '';
+
+      console.log();
+      console.log(chalk.hex('#4CAF50')('  ┌' + '─'.repeat(58) + '┐'));
+      console.log(chalk.hex('#4CAF50')('  │') + chalk.bold(`  ${agentName}${toolCalling}`).padEnd(68) + chalk.hex('#4CAF50')('│'));
+      console.log(chalk.hex('#4CAF50')('  │') + chalk.gray(`  Session: ${sessionId.substring(0, 8)}...`).padEnd(68) + chalk.hex('#4CAF50')('│'));
+      console.log(chalk.hex('#4CAF50')('  │') + chalk.gray('  /help para ver comandos').padEnd(68) + chalk.hex('#4CAF50')('│'));
+      console.log(chalk.hex('#4CAF50')('  └' + '─'.repeat(58) + '┘'));
+      console.log();
+
+      // Saludo del agente
+      if (agentInfo?.instructions?.greeting) {
+        const timestamp = new Date().toLocaleTimeString('es-ES', { hour: '2-digit', minute: '2-digit' });
+        console.log(chalk.hex('#4CAF50')(`  ${agentName}`) + chalk.gray(` ${timestamp}`));
+        console.log(chalk.white(`  ${agentInfo.instructions.greeting}`));
+        console.log();
+      }
 
-      // Mostrar encabezado
-      console.log('Chat session initialized\n');
-      console.log('┌' + '─'.repeat(60) + '┐');
-      console.log('│' + ' Plazbot Agent Chat'.padEnd(59) + '│');
-      console.log('│' + ''.padEnd(59) + '│');
-      console.log('│' + ' Type your messages and press Enter to send.'.padEnd(59) + '│');
-      console.log('│' + ' Type "/exit" or press Ctrl+C to end the conversation.'.padEnd(59) + '│');
-      console.log('└' + '─'.repeat(60) + '┘\n');
-      console.log('Session ID:', sessionId, '\n');
-
-      // Función para preguntar
       const askQuestion = () => {
-        rl.question('You: ', async (question) => {
+        rl.question(chalk.hex('#2196F3')('  Tu > '), async (question) => {
+          if (!question.trim()) {
+            askQuestion();
+            return;
+          }
+
+          // Comandos especiales
           if (question.toLowerCase() === '/exit') {
-            console.log('\nChat session ended.');
+            console.log(chalk.gray('\n  Sesion terminada.\n'));
             rl.close();
             return;
           }
 
+          if (question.toLowerCase() === '/clear') {
+            console.clear();
+            askQuestion();
+            return;
+          }
+
+          if (question.toLowerCase() === '/help') {
+            console.log(COMMANDS_HELP);
+            askQuestion();
+            return;
+          }
+
+          if (question.toLowerCase() === '/info') {
+            console.log(section('Informacion de sesion'));
+            logger.label('Agent ID', options.agentId);
+            logger.label('Session ID', sessionId);
+            logger.label('Agente', agentName);
+            logger.label('Tool Calling', agentInfo?.useToolCalling ? 'Activado' : 'Desactivado');
+            logger.label('AI Provider', agentInfo?.customAIConfig ? (agentInfo.aiProviders?.[0]?.provider || 'Custom') : 'Default');
+            console.log();
+            askQuestion();
+            return;
+          }
+
+          if (question.toLowerCase() === '/sources') {
+            showSources = !showSources;
+            console.log(chalk.gray(`  Fuentes: ${showSources ? 'activadas' : 'desactivadas'}`));
+            console.log();
+            askQuestion();
+            return;
+          }
+
           try {
-            console.log('⋮ Waiting for response...');
-            
+            process.stdout.write(chalk.gray('  ...pensando\n'));
+
             const response = await agent.onMessage({
               agentId: options.agentId,
               question,
               sessionId,
               multipleAnswers: options.multipleAnswers
-            }) as AgentResponse;
+            }) as AgentResponse & { actionsExecuted?: any[] };
 
-            console.log('\nAssistant:');
-            console.log('  ' + response.answer);
-            console.log(); // Línea en blanco para separar mensajes
+            const timestamp = new Date().toLocaleTimeString('es-ES', { hour: '2-digit', minute: '2-digit' });
 
-            // Si hay fuentes, mostrarlas
-            if (response.sources && response.sources.length > 0) {
-              console.log('Sources:');
+            // Mostrar tool calls si hay
+            if (response.actionsExecuted && response.actionsExecuted.length > 0) {
+              response.actionsExecuted.forEach((action: any) => {
+                console.log(chalk.hex('#FFA726')(`  ⚡ Tool: ${action.name || action.intent || 'action'}`));
+              });
+            }
+
+            // Respuesta del agente
+            console.log();
+            console.log(chalk.hex('#4CAF50')(`  ${agentName}`) + chalk.gray(` ${timestamp}`));
+
+            // Formatear respuesta (soporte basico de markdown)
+            const formattedAnswer = formatResponse(response.answer);
+            console.log(formattedAnswer);
+            console.log();
+
+            // Fuentes
+            if (showSources && response.sources && response.sources.length > 0) {
+              console.log(chalk.gray('  Fuentes:'));
               response.sources.forEach((source: AgentSource) => {
-                console.log(`  - ${source.title || 'Untitled'}`);
-                if (source.url) console.log(`    ${source.url}`);
+                console.log(chalk.gray(`    - ${source.title || 'Sin titulo'}`));
+                if (source.url) console.log(chalk.gray(`      ${source.url}`));
               });
-              console.log(); // Línea en blanco después de las fuentes
+              console.log();
             }
 
-            askQuestion(); // Continuar el ciclo de preguntas
+            askQuestion();
           } catch (error) {
             const message = error instanceof Error ? error.message : 'Error desconocido';
-            console.error('\n❌ Error:', message);
-            askQuestion(); // Continuar a pesar del error
+            console.log(chalk.hex('#EF5350')(`\n  ✖ Error: ${message}\n`));
+            askQuestion();
           }
         });
       };
 
-      // Iniciar el ciclo de preguntas
       askQuestion();
 
     } catch (error) {
       const message = error instanceof Error ? error.message : 'Error desconocido';
-      console.error('\n❌ Error:', message);
+      logger.error(message);
       process.exit(1);
     }
-  }); 
+  });
+
+function formatResponse(text: string): string {
+  if (!text) return '';
+
+  return text.split('\n').map(line => {
+    // Headers
+    if (line.startsWith('### ')) return chalk.bold.hex('#4CAF50')('  ' + line.substring(4));
+    if (line.startsWith('## ')) return chalk.bold.hex('#4CAF50')('  ' + line.substring(3));
+    if (line.startsWith('# ')) return chalk.bold.hex('#4CAF50')('  ' + line.substring(2));
+
+    // Bold
+    line = line.replace(/\*\*(.*?)\*\*/g, (_, text) => chalk.bold(text));
+
+    // Italic
+    line = line.replace(/\*(.*?)\*/g, (_, text) => chalk.italic(text));
+
+    // Code inline
+    line = line.replace(/`(.*?)`/g, (_, text) => chalk.hex('#FFA726')(text));
+
+    // List items
+    if (line.match(/^\s*[-*]\s/)) {
+      return chalk.white('  ' + line.replace(/^\s*[-*]\s/, '  • '));
+    }
+
+    // Numbered lists
+    if (line.match(/^\s*\d+\.\s/)) {
+      return chalk.white('  ' + line);
+    }
+
+    return chalk.white('  ' + line);
+  }).join('\n');
+}

package/src/commands/agent/copy.ts

@@ -0,0 +1,40 @@
+import { Command } from 'commander';
+import { Agent } from 'plazbot';
+import { getStoredCredentials } from '../../utils/credentials';
+import { logger } from '../../utils/logger';
+import { createSpinner } from '../../utils/ui';
+import { AgentCommandOptions } from '../../types/agent';
+
+export const copyCommand = new Command('copy')
+  .description('Clonar un agente existente')
+  .argument('<agentId>', 'ID del agente a clonar')
+  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .action(async (agentId: string, options: AgentCommandOptions) => {
+    try {
+      const credentials = await getStoredCredentials();
+      const agent = new Agent({
+        workspaceId: credentials.workspace,
+        apiKey: credentials.apiKey,
+        zone: credentials.zone,
+        ...(options.dev && { customUrl: "http://localhost:5090" })
+      });
+
+      const spinner = createSpinner('Clonando agente...');
+      spinner.start();
+
+      const result = await (agent as any).copyAgent({ id: agentId });
+
+      spinner.succeed('Agente clonado exitosamente');
+
+      logger.title('Agente clonado');
+      if (result?.agentId || result?.id) {
+        logger.label('Nuevo ID', result.agentId || result.id);
+      }
+      logger.dim('\nEl agente clonado tiene el widget deshabilitado por defecto.');
+
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Error desconocido';
+      logger.error(message);
+      process.exit(1);
+    }
+  });

package/src/commands/agent/create.ts

@@ -3,17 +3,18 @@ import { Agent } from 'plazbot';
 import { getStoredCredentials } from '../../utils/credentials';
 import { logger } from '../../utils/logger';
 import { AgentCommandOptions } from '../../types/agent';
+import { createSpinner } from '../../utils/ui';
+import { runAgentWizard } from './wizard';
 import fs from 'fs/promises';
 
 export const createCommand = new Command('create')
-  .description('Crea un nuevo agente en Plazbot usando el archivo de configuración')
-  .argument('<configPath>', 'Ruta al archivo de configuración JSON')
+  .description('Crea un nuevo agente de IA (wizard interactivo o archivo JSON)')
+  .argument('[configPath]', 'Ruta al archivo de configuracion JSON (opcional)')
   .option('--dev', 'Usar ambiente de desarrollo', false)
-  .action(async (configPath: string, options: AgentCommandOptions) => {
+  .action(async (configPath: string | undefined, options: AgentCommandOptions) => {
     try {
-      // Obtener credenciales guardadas
       const credentials = await getStoredCredentials();
-      
+
       const agent = new Agent({
         workspaceId: credentials.workspace,
         apiKey: credentials.apiKey,
@@ -21,28 +22,62 @@ export const createCommand = new Command('create')
         ...(options.dev && { customUrl: "http://localhost:5090" })
       });
 
-      // Leer archivo de configuración
-      let agentConfig;
-      try {
-        const fileContent = await fs.readFile(configPath, 'utf-8');
-        agentConfig = JSON.parse(fileContent);
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Error desconocido';
-        throw new Error(`Error al leer el archivo de configuración: ${errorMessage}`);
+      let agentConfig: any;
+
+      if (configPath) {
+        // Modo archivo: leer JSON
+        try {
+          const fileContent = await fs.readFile(configPath, 'utf-8');
+          agentConfig = JSON.parse(fileContent);
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : 'Error desconocido';
+          throw new Error(`Error al leer el archivo de configuracion: ${errorMessage}`);
+        }
+        logger.title('Creando agente desde archivo');
+        logger.json(agentConfig);
+      } else {
+        // Modo wizard interactivo
+        agentConfig = await runAgentWizard(credentials.zone);
+
+        const inquirer = await import('inquirer');
+        const { confirm } = await inquirer.default.prompt([{
+          type: 'confirm',
+          name: 'confirm',
+          message: 'Crear el agente con esta configuracion?',
+          default: true,
+        }]);
+
+        if (!confirm) {
+          logger.warning('Creacion cancelada');
+          return;
+        }
       }
 
-      logger.info('\n🤖 Creando nuevo agente...');
-      logger.info('Configuración:');
-      logger.info(JSON.stringify(agentConfig, null, 2));
-      
+      const spinner = createSpinner('Creando agente...');
+      spinner.start();
+
       const result = await agent.addAgent(agentConfig);
 
-      logger.success('Agente creado exitosamente');
-      logger.info('\n📋 Detalles del agente:');
-      logger.info(JSON.stringify(result, null, 2));
-      
+      spinner.succeed('Agente creado exitosamente');
+
+      logger.title('Detalles del agente');
+      if (result.agentId) {
+        logger.label('ID', result.agentId);
+      }
+      if (agentConfig.name) {
+        logger.label('Nombre', agentConfig.name);
+      }
+      logger.label('Tool Calling', agentConfig.useToolCalling ? 'Activado' : 'Desactivado');
+
+      if (agentConfig.channels && agentConfig.channels.length > 0) {
+        logger.label('WhatsApp', agentConfig.channels[0].key);
+      }
+
+      console.log();
+      logger.dim('Siguiente paso: plazbot agent chat -a ' + (result.agentId || '<agentId>'));
+
       if (options.dev) {
-        logger.warning('\nAmbiente: desarrollo');
+        logger.warning('Ambiente: desarrollo');
       }
 
     } catch (error) {
@@ -50,4 +85,4 @@ export const createCommand = new Command('create')
       logger.error(message);
       process.exit(1);
     }
-  }); 
+  });