plazbot-cli 0.1.3 → 0.1.4

package/src/commands/agent/files.ts

@@ -0,0 +1,158 @@
+import { Command } from 'commander';
+import { Agent } from 'plazbot';
+import { getStoredCredentials } from '../../utils/credentials';
+import { logger } from '../../utils/logger';
+import { createSpinner, createTable, theme, section, statusBadge } from '../../utils/ui';
+import { AgentCommandOptions } from '../../types/agent';
+
+const filesGroup = new Command('files')
+  .description('Gestionar archivos de la base de conocimiento del agente');
+
+// Listar archivos
+filesGroup.command('list')
+  .description('Listar archivos 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 archivos...');
+      spinner.start();
+      const agentData = await agent.getAgentById({ id: agentId });
+      spinner.stop();
+
+      const files = agentData.files || [];
+      console.log(section('Archivos - ' + (agentData.name || agentId)));
+
+      if (files.length === 0) {
+        console.log(theme.muted('\n  No hay archivos en la base de conocimiento'));
+        console.log(theme.muted('  Usa: plazbot agent files add <agentId> --url <url>\n'));
+        return;
+      }
+
+      const rows = files.map((f: any) => [
+        f.fileId || f.id || 'N/A',
+        f.name || f.reference || 'Sin nombre',
+        (f.tags || []).join(', ') || '-',
+      ]);
+
+      console.log(createTable(['ID', 'Nombre', 'Tags'], rows));
+
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Error desconocido';
+      logger.error(message);
+      process.exit(1);
+    }
+  });
+
+// Agregar archivo
+filesGroup.command('add')
+  .description('Agregar archivo a la base de conocimiento')
+  .argument('<agentId>', 'ID del agente')
+  .requiredOption('-u, --url <url>', 'URL del archivo (PDF, DOC, DOCX)')
+  .option('-r, --reference <name>', 'Nombre de referencia', 'documento')
+  .option('-t, --tags <tags>', 'Tags separados por coma', '')
+  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .action(async (agentId: string, options: any) => {
+    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('Subiendo archivo...');
+      spinner.start();
+
+      const tags = options.tags ? options.tags.split(',').map((t: string) => t.trim()) : [];
+      const result = await agent.addFile({
+        fileUrl: options.url,
+        reference: options.reference,
+        agentId,
+        tags,
+      });
+
+      spinner.succeed('Archivo agregado');
+
+      if (result?.fileId || result?.id) {
+        logger.label('File ID', result.fileId || result.id);
+        logger.dim('El archivo esta siendo procesado. Verifica con:');
+        logger.dim(`plazbot agent files status ${result.fileId || result.id}`);
+      }
+
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Error desconocido';
+      logger.error(message);
+      process.exit(1);
+    }
+  });
+
+// Verificar estado
+filesGroup.command('status')
+  .description('Verificar estado de procesamiento de un archivo')
+  .argument('<fileId>', 'ID del archivo')
+  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .action(async (fileId: 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('Verificando...');
+      spinner.start();
+      const result = await agent.validateFile({ fileId });
+      spinner.stop();
+
+      logger.title('Estado del archivo');
+      logger.label('File ID', fileId);
+      logger.label('Estado', result?.status || result?.stateId === 2 ? 'Completado' : 'En proceso');
+
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Error desconocido';
+      logger.error(message);
+      process.exit(1);
+    }
+  });
+
+// Eliminar archivo
+filesGroup.command('delete')
+  .description('Eliminar archivo de la base de conocimiento')
+  .argument('<agentId>', 'ID del agente')
+  .argument('<fileId>', 'ID del archivo')
+  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .action(async (agentId: string, fileId: 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('Eliminando archivo...');
+      spinner.start();
+      await agent.deleteFile({ fileId, agentId });
+      spinner.succeed('Archivo eliminado');
+
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Error desconocido';
+      logger.error(message);
+      process.exit(1);
+    }
+  });
+
+export const filesCommand = filesGroup;

package/src/commands/agent/index.ts

@@ -7,9 +7,15 @@ import { updateCommand } from './update';
 import { enableCommand } from './enable-widget';
 import { chatCommand } from './chat';
 import { messageCommand } from './on-message';
+import { toolsCommand } from './tools';
+import { aiConfigCommand } from './ai-config';
+import { templatesCommand } from './templates';
+import { copyCommand } from './copy';
+import { filesCommand } from './files';
+import { setCommand } from './set';
 
 export const agentCommands = new Command('agent')
-  .description('Comandos relacionados con agentes')
+  .description('Comandos relacionados con agentes de IA')
   .addCommand(listCommand)
   .addCommand(getCommand)
   .addCommand(deleteCommand)
@@ -17,4 +23,10 @@ export const agentCommands = new Command('agent')
   .addCommand(updateCommand)
   .addCommand(enableCommand)
   .addCommand(chatCommand)
-  .addCommand(messageCommand); 
+  .addCommand(messageCommand)
+  .addCommand(toolsCommand)
+  .addCommand(aiConfigCommand)
+  .addCommand(templatesCommand)
+  .addCommand(copyCommand)
+  .addCommand(filesCommand)
+  .addCommand(setCommand);

package/src/commands/agent/set.ts

@@ -0,0 +1,137 @@
+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 setGroup = new Command('set')
+  .description('Configurar rapidamente propiedades del agente');
+
+// Set greeting
+setGroup.command('greeting')
+  .description('Cambiar el saludo del agente')
+  .argument('<agentId>', 'ID del agente')
+  .argument('<greeting>', 'Nuevo saludo')
+  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .action(async (agentId: string, greeting: 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('Actualizando saludo...');
+      spinner.start();
+      await agent.setGreeting(agentId, greeting);
+      spinner.succeed('Saludo actualizado');
+      logger.label('Nuevo saludo', greeting);
+
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Error desconocido';
+      logger.error(message);
+      process.exit(1);
+    }
+  });
+
+// Set instructions (wizard)
+setGroup.command('instructions')
+  .description('Configurar instrucciones 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" })
+      });
+
+      // Cargar instrucciones actuales
+      const loadSpinner = createSpinner('Cargando...');
+      loadSpinner.start();
+      const agentData = await agent.getAgentById({ id: agentId });
+      loadSpinner.stop();
+
+      const current = agentData.instructions || {};
+      console.log(section('Instrucciones - ' + (agentData.name || agentId)));
+
+      const answers = await (inquirer as any).prompt([
+        { type: 'list', name: 'tone', message: 'Tono:', choices: ['profesional', 'amigable', 'formal', 'casual', 'tecnico', 'empatico'], default: current.tone || 'profesional' },
+        { type: 'list', name: 'style', message: 'Estilo:', choices: ['conciso', 'detallado', 'conversacional', 'directo'], default: current.style || 'conciso' },
+        { type: 'input', name: 'personality', message: 'Personalidad:', default: current.personality || '' },
+        { type: 'input', name: 'objective', message: 'Objetivo:', default: current.objective || '' },
+        { type: 'list', name: 'language', message: 'Idioma:', choices: ['Espanol', 'English', 'Portugues'], default: current.language || 'Espanol' },
+        { type: 'confirm', name: 'useEmojis', message: 'Usar emojis?', default: current.useEmojis === 'si' },
+      ]);
+
+      const instructions = {
+        ...current,
+        tone: answers.tone,
+        style: answers.style,
+        personality: answers.personality,
+        objective: answers.objective,
+        language: answers.language,
+        useEmojis: answers.useEmojis ? 'si' : 'no',
+      };
+
+      const spinner = createSpinner('Guardando instrucciones...');
+      spinner.start();
+      await agent.setInstructions(agentId, instructions);
+      spinner.succeed('Instrucciones actualizadas');
+
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Error desconocido';
+      logger.error(message);
+      process.exit(1);
+    }
+  });
+
+// Set persona (wizard)
+setGroup.command('persona')
+  .description('Configurar la persona 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 loadSpinner = createSpinner('Cargando...');
+      loadSpinner.start();
+      const agentData = await agent.getAgentById({ id: agentId });
+      loadSpinner.stop();
+
+      const current = agentData.person || {};
+      console.log(section('Persona - ' + (agentData.name || agentId)));
+
+      const answers = await (inquirer as any).prompt([
+        { type: 'input', name: 'name', message: 'Nombre del personaje:', default: current.name || '' },
+        { type: 'input', name: 'role', message: 'Rol:', default: current.role || '' },
+        { type: 'confirm', name: 'firstPerson', message: 'Hablar en primera persona?', default: current.firstPerson !== false },
+      ]);
+
+      const spinner = createSpinner('Guardando persona...');
+      spinner.start();
+      await agent.setPersona(agentId, answers);
+      spinner.succeed('Persona actualizada');
+
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Error desconocido';
+      logger.error(message);
+      process.exit(1);
+    }
+  });
+
+export const setCommand = setGroup;

package/src/commands/agent/templates.ts

@@ -0,0 +1,249 @@
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import { logger } from '../../utils/logger';
+import { theme, section, kvPair, createTable } from '../../utils/ui';
+
+interface Template {
+  name: string;
+  description: string;
+  industry: string;
+  config: any;
+}
+
+const TEMPLATES: Template[] = [
+  {
+    name: 'Asistente de Ventas',
+    description: 'Agente especializado en atencion al cliente y ventas',
+    industry: 'Ventas',
+    config: {
+      name: 'Asistente de Ventas',
+      prompt: 'Eres un asistente de ventas profesional y amigable. Tu objetivo es ayudar a los clientes a encontrar los productos o servicios que necesitan, responder sus preguntas y guiarlos en el proceso de compra.',
+      buffer: 10,
+      color: 'blue',
+      useToolCalling: true,
+      instructions: {
+        tone: 'amigable',
+        style: 'conversacional',
+        personality: 'Entusiasta y servicial',
+        objective: 'Ayudar al cliente a encontrar el producto ideal y cerrar la venta',
+        language: 'Espanol',
+        emojis: true,
+      },
+      person: { name: 'Ana', role: 'Asesora de ventas', speaksInFirstPerson: true },
+      fallbacks: {
+        noAnswer: 'No tengo informacion sobre eso, pero puedo conectarte con un asesor especializado.',
+        serviceError: 'Disculpa, estamos experimentando dificultades. Un asesor te atendera pronto.',
+        doNotUnderstand: 'Podrias darme mas detalles sobre lo que buscas?',
+      },
+      actions: [
+        { intent: 'derivar_asesor', reference: 'hablar con humano, asesor, agente', enabled: true, requiredFields: [], responseMessage: 'Te conecto con un asesor ahora mismo.', action: [{ type: 'action.agentShutDown', value: '' }] },
+        { intent: 'etiquetar_interesado', reference: 'interesado, quiere comprar', enabled: true, requiredFields: [], responseMessage: '', action: [{ type: 'action.tag', value: 'interesado' }] },
+      ],
+      services: [],
+      channels: [],
+      examples: [
+        { value: 'Usuario: Hola, quiero informacion sobre sus productos\nAgente: Hola! Con gusto te ayudo. Que tipo de producto estas buscando?', color: 'blue' },
+        { value: 'Usuario: Cuanto cuesta?\nAgente: El precio depende del plan que elijas. Te cuento las opciones disponibles...', color: 'blue' },
+      ],
+      tags: ['ventas', 'atencion-cliente'],
+    },
+  },
+  {
+    name: 'Soporte Tecnico IT',
+    description: 'Agente para soporte tecnico y resolucion de problemas',
+    industry: 'Tecnologia',
+    config: {
+      name: 'Soporte Tecnico',
+      prompt: 'Eres un agente de soporte tecnico especializado. Tu objetivo es diagnosticar problemas tecnicos, guiar al usuario paso a paso en la solucion y escalar cuando sea necesario.',
+      buffer: 8,
+      color: 'green',
+      useToolCalling: true,
+      instructions: {
+        tone: 'profesional',
+        style: 'detallado',
+        personality: 'Paciente y tecnico',
+        objective: 'Resolver problemas tecnicos del usuario de forma eficiente',
+        language: 'Espanol',
+        emojis: false,
+      },
+      person: { name: 'Carlos', role: 'Especialista de soporte', speaksInFirstPerson: true },
+      fallbacks: {
+        noAnswer: 'No puedo resolver este caso automaticamente. Voy a escalarlo a un tecnico especializado.',
+        serviceError: 'Hay un problema con nuestros sistemas. Un tecnico te contactara pronto.',
+        doNotUnderstand: 'Puedes describir el problema con mas detalle? Que mensaje de error ves?',
+      },
+      actions: [
+        { intent: 'escalar_ticket', reference: 'escalar, tecnico, no funciona', enabled: true, requiredFields: [], responseMessage: 'Escalando tu caso a un tecnico especializado.', action: [{ type: 'action.agentShutDown', value: '' }] },
+        { intent: 'etiquetar_urgente', reference: 'urgente, critico, caido', enabled: true, requiredFields: [], responseMessage: '', action: [{ type: 'action.tag', value: 'urgente' }] },
+      ],
+      services: [],
+      channels: [],
+      examples: [],
+      tags: ['soporte', 'IT'],
+    },
+  },
+  {
+    name: 'Asistente de Clinica',
+    description: 'Agente para clinicas medicas: citas, horarios e informacion',
+    industry: 'Salud',
+    config: {
+      name: 'Asistente de Clinica',
+      prompt: 'Eres un asistente virtual de una clinica medica. Tu objetivo es ayudar a los pacientes a agendar citas, consultar horarios de atencion, y proporcionar informacion general sobre los servicios de la clinica. NUNCA des diagnosticos medicos ni recomendaciones de tratamiento.',
+      buffer: 5,
+      color: 'green',
+      useToolCalling: true,
+      instructions: {
+        tone: 'empatico',
+        style: 'conciso',
+        personality: 'Amable y profesional',
+        objective: 'Facilitar la gestion de citas y brindar informacion de la clinica',
+        language: 'Espanol',
+        emojis: true,
+      },
+      person: { name: 'Sofia', role: 'Asistente de clinica', speaksInFirstPerson: true },
+      fallbacks: {
+        noAnswer: 'No tengo esa informacion. Te recomiendo llamar directamente a la clinica.',
+        serviceError: 'Disculpa, nuestro sistema esta temporalmente fuera de servicio.',
+        doNotUnderstand: 'Podrias repetir tu consulta? Estoy aqui para ayudarte con citas, horarios o informacion de la clinica.',
+      },
+      actions: [
+        { intent: 'derivar_recepcion', reference: 'hablar con recepcion, persona real', enabled: true, requiredFields: [], responseMessage: 'Te conecto con recepcion ahora.', action: [{ type: 'action.agentShutDown', value: '' }] },
+      ],
+      services: [],
+      channels: [],
+      examples: [],
+      tags: ['clinica', 'salud', 'citas'],
+    },
+  },
+  {
+    name: 'Asistente de Restaurante',
+    description: 'Agente para restaurantes: menu, reservas y pedidos',
+    industry: 'Gastronomia',
+    config: {
+      name: 'Asistente de Restaurante',
+      prompt: 'Eres un asistente virtual de un restaurante. Tu objetivo es ayudar a los clientes con informacion del menu, tomar reservas, informar sobre horarios de atencion y responder consultas generales sobre el restaurante.',
+      buffer: 5,
+      color: 'orange',
+      useToolCalling: true,
+      instructions: {
+        tone: 'amigable',
+        style: 'conversacional',
+        personality: 'Calido y entusiasta sobre la comida',
+        objective: 'Brindar informacion del restaurante y facilitar reservas',
+        language: 'Espanol',
+        emojis: true,
+      },
+      person: { name: 'Marco', role: 'Anfitrion virtual', speaksInFirstPerson: true },
+      fallbacks: {
+        noAnswer: 'No tengo esa informacion. Te recomiendo llamar al restaurante.',
+        serviceError: 'Disculpa, nuestro sistema tiene problemas. Llamanos para hacer tu reserva.',
+        doNotUnderstand: 'Perdon, no entendi. Puedo ayudarte con el menu, reservas u horarios.',
+      },
+      actions: [],
+      services: [],
+      channels: [],
+      examples: [
+        { value: 'Usuario: Quiero hacer una reserva\nAgente: Con gusto! Para cuantas personas y que dia tienes en mente?', color: 'orange' },
+      ],
+      tags: ['restaurante', 'reservas'],
+    },
+  },
+  {
+    name: 'Asistente Inmobiliario',
+    description: 'Agente para inmobiliarias: propiedades, visitas y consultas',
+    industry: 'Inmobiliario',
+    config: {
+      name: 'Asistente Inmobiliario',
+      prompt: 'Eres un asistente virtual de una inmobiliaria. Tu objetivo es ayudar a los clientes a encontrar propiedades que se ajusten a sus necesidades, agendar visitas y responder consultas sobre el proceso de compra o alquiler.',
+      buffer: 8,
+      color: 'blue',
+      useToolCalling: true,
+      instructions: {
+        tone: 'profesional',
+        style: 'detallado',
+        personality: 'Conocedor y confiable',
+        objective: 'Ayudar al cliente a encontrar la propiedad ideal',
+        language: 'Espanol',
+        emojis: true,
+      },
+      person: { name: 'Diego', role: 'Asesor inmobiliario', speaksInFirstPerson: true },
+      fallbacks: {
+        noAnswer: 'No tengo informacion sobre esa propiedad. Dejame conectarte con un asesor.',
+        serviceError: 'Nuestro sistema esta temporalmente fuera de servicio. Un asesor te contactara.',
+        doNotUnderstand: 'Podrias darme mas detalles? Que tipo de propiedad buscas?',
+      },
+      actions: [
+        { intent: 'derivar_asesor', reference: 'asesor, visita, contactar', enabled: true, requiredFields: [], responseMessage: 'Te conecto con un asesor inmobiliario.', action: [{ type: 'action.agentShutDown', value: '' }] },
+        { intent: 'etiquetar_interesado', reference: 'interesado, quiere comprar, quiere alquilar', enabled: true, requiredFields: [], responseMessage: '', action: [{ type: 'action.tag', value: 'interesado' }] },
+      ],
+      services: [],
+      channels: [],
+      examples: [],
+      tags: ['inmobiliario', 'propiedades'],
+    },
+  },
+];
+
+export const templatesCommand = new Command('templates')
+  .description('Ver y usar plantillas de agentes pre-configurados')
+  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .action(async () => {
+    try {
+      console.log(section('Plantillas de agentes'));
+      console.log(theme.muted('  Selecciona una plantilla para crear un agente pre-configurado\n'));
+
+      const rows = TEMPLATES.map((t, i) => [
+        String(i + 1),
+        t.name,
+        t.industry,
+        t.description,
+      ]);
+      console.log(createTable(['#', 'Nombre', 'Industria', 'Descripcion'], rows));
+
+      const { selected } = await (inquirer as any).prompt([{
+        type: 'list',
+        name: 'selected',
+        message: 'Selecciona una plantilla:',
+        choices: [
+          ...TEMPLATES.map((t, i) => ({ name: `${t.name} (${t.industry})`, value: i })),
+          { name: 'Cancelar', value: -1 },
+        ],
+      }]);
+
+      if (selected === -1) return;
+
+      const template = TEMPLATES[selected];
+      console.log(section(template.name));
+      console.log(kvPair('Industria', template.industry));
+      console.log(kvPair('Descripcion', template.description));
+      console.log(kvPair('Tool Calling', template.config.useToolCalling ? 'Si' : 'No'));
+      console.log(kvPair('Acciones', String(template.config.actions.length)));
+      console.log(kvPair('Persona', `${template.config.person.name} - ${template.config.person.role}`));
+      console.log();
+
+      const { action } = await (inquirer as any).prompt([{
+        type: 'list',
+        name: 'action',
+        message: 'Que deseas hacer?',
+        choices: [
+          { name: 'Crear agente con esta plantilla', value: 'create' },
+          { name: 'Ver JSON completo', value: 'json' },
+          { name: 'Cancelar', value: 'cancel' },
+        ],
+      }]);
+
+      if (action === 'json') {
+        logger.json(template.config);
+      }
+
+      if (action === 'create') {
+        logger.success(`Usa: plazbot agent create y selecciona la plantilla "${template.name}" durante el wizard`);
+        logger.dim('O exporta el JSON: plazbot agent templates (selecciona Ver JSON)');
+      }
+
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Error desconocido';
+      logger.error(message);
+      process.exit(1);
+    }
+  });