plazbot-cli 0.1.3 → 0.2.0

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 as any).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) {
+        logger.label('File ID', result.fileId);
+        logger.dim('El archivo esta siendo procesado. Verifica con:');
+        logger.dim(`plazbot agent files status ${result.fileId}`);
+      }
+
+    } 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 ? '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/get.ts

@@ -22,8 +22,7 @@ export const getCommand = new Command('get')
       });
 
       // Obtener detalles del agente
-      const agentDetails = await agent.getAgentById({ id: agentId });
-      const agentData = agentDetails.agent;
+      const agentData = await agent.getAgentById({ id: agentId });
       
       logger.info('\nDetalles del Agente:');
       logger.doubleDivider();

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/list.ts

@@ -2,7 +2,7 @@ import { Command } from 'commander';
 import { Agent } from 'plazbot';
 import { getStoredCredentials } from '../../utils/credentials';
 import { logger } from '../../utils/logger';
-import { ListAgentsOptions, AgentListItem } from '../../types/agent';
+import { ListAgentsOptions } from '../../types/agent';
 
 export const listCommand = new Command('list')
   .description('Lista todos los agentes del workspace')
@@ -31,12 +31,12 @@ export const listCommand = new Command('list')
       logger.info('\nLista de Agentes:');
       logger.doubleDivider();
       
-      agents.forEach((agent: AgentListItem, index: number) => {
-        logger.info(`${index + 1}. ID: ${agent.id}`);
-        logger.info(`   Nombre: ${agent.name}`);
-        logger.info(`   Estado: ${agent.enable ? '✅ Activo' : '❌ Inactivo'}`);
-        logger.info(`   Descripción: ${agent.description}`);
-        logger.info(`   Creado: ${new Date(agent.createdAt).toLocaleString()}`);
+      agents.forEach((a: any, index: number) => {
+        logger.info(`${index + 1}. ID: ${a.id}`);
+        logger.info(`   Nombre: ${a.name}`);
+        logger.info(`   Estado: ${a.enable ? '✅ Activo' : '❌ Inactivo'}`);
+        logger.info(`   Descripción: ${a.description}`);
+        logger.info(`   Creado: ${a.createdAt ? new Date(a.createdAt).toLocaleString() : 'N/A'}`);
         logger.divider();
       });
 

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: 'emojis', message: 'Usar emojis?', default: current.emojis === true },
+      ]);
+
+      const instructions = {
+        ...current,
+        tone: answers.tone,
+        style: answers.style,
+        personality: answers.personality,
+        objective: answers.objective,
+        language: answers.language,
+        emojis: answers.emojis,
+      };
+
+      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: 'speaksInFirstPerson', message: 'Hablar en primera persona?', default: current.speaksInFirstPerson !== 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;