plazbot-cli 0.2.26 → 0.3.2

package/dist/commands/agent/tools.js

@@ -1,94 +1,89 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toolsCommand = void 0;
-const commander_1 = require("commander");
-const plazbot_1 = require("plazbot");
-const inquirer_1 = __importDefault(require("inquirer"));
-const credentials_1 = require("../../utils/credentials");
-const logger_1 = require("../../utils/logger");
-const ui_1 = require("../../utils/ui");
-exports.toolsCommand = new commander_1.Command('tools')
-    .description('Gestionar herramientas de Tool Calling del agente')
-    .argument('<agentId>', 'ID del agente')
-    .option('--dev', 'Usar ambiente de desarrollo', false)
+import { Command } from 'commander';
+import { Agent } from 'plazbot';
+import inquirer from 'inquirer';
+import { getStoredCredentials } from '../../utils/credentials.js';
+import { logger } from '../../utils/logger.js';
+import { addExamples } from '../../utils/help.js';
+import { createSpinner, createTable, theme, section, kvPair, statusBadge } from '../../utils/ui.js';
+export const toolsCommand = new Command('tools')
+    .description('Manage agent Tool Calling tools')
+    .argument('<agentId>', 'Agent ID')
+    .option('--dev', 'Use development environment', false)
     .action(async (agentId, options) => {
     try {
-        const credentials = await (0, credentials_1.getStoredCredentials)();
-        const agent = new plazbot_1.Agent({
+        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 = (0, ui_1.createSpinner)('Cargando agente...');
+        const spinner = createSpinner('Loading agent...');
         spinner.start();
         const _res = await agent.getAgentById({ id: agentId });
         const agentData = _res.agent || _res.data || _res;
         spinner.stop();
-        console.log((0, ui_1.section)('Tool Calling - ' + (agentData.name || agentId)));
-        console.log((0, ui_1.kvPair)('Estado', agentData.useToolCalling ? ui_1.theme.success('Activado') : ui_1.theme.error('Desactivado')));
+        console.log(section('Tool Calling - ' + (agentData.name || agentId)));
+        console.log(kvPair('Status', agentData.useToolCalling ? theme.success('Enabled') : theme.error('Disabled')));
         // Servicios
         const services = agentData.services || [];
         if (services.length > 0) {
-            console.log((0, ui_1.section)('Servicios (API calls)'));
+            console.log(section('Services (API calls)'));
             const rows = services.map((s) => [
                 s.intent,
                 s.method || 'POST',
                 s.endpoint ? s.endpoint.substring(0, 40) + '...' : 'N/A',
-                (0, ui_1.statusBadge)(s.enabled !== false),
+                statusBadge(s.enabled !== false),
             ]);
-            console.log((0, ui_1.createTable)(['Intent', 'Method', 'Endpoint', 'Estado'], rows));
+            console.log(createTable(['Intent', 'Method', 'Endpoint', 'Status'], rows));
         }
         else {
-            console.log(ui_1.theme.muted('\n  No hay servicios configurados'));
+            console.log(theme.muted('\n  No services configured'));
         }
         // Acciones
         const actions = agentData.actions || [];
         if (actions.length > 0) {
-            console.log((0, ui_1.section)('Acciones'));
+            console.log(section('Actions'));
             const rows = actions.map((a) => [
                 a.intent,
                 (a.action || []).map((ac) => ac.type).join(', '),
-                (0, ui_1.statusBadge)(a.enabled !== false),
+                statusBadge(a.enabled !== false),
             ]);
-            console.log((0, ui_1.createTable)(['Intent', 'Tipo', 'Estado'], rows));
+            console.log(createTable(['Intent', 'Type', 'Status'], rows));
         }
         else {
-            console.log(ui_1.theme.muted('\n  No hay acciones configuradas'));
+            console.log(theme.muted('\n  No actions configured'));
         }
         // Menu de opciones
         console.log();
-        const { action } = await inquirer_1.default.prompt([{
+        const { action } = await inquirer.prompt([{
                 type: 'list',
                 name: 'action',
-                message: 'Que deseas hacer?',
+                message: 'What would you like to do?',
                 choices: [
-                    { name: 'Agregar servicio (API call)', value: 'add-service' },
-                    { name: 'Agregar accion', value: 'add-action' },
-                    { name: agentData.useToolCalling ? 'Desactivar Tool Calling' : 'Activar Tool Calling', value: 'toggle' },
-                    { name: 'Salir', value: 'exit' },
+                    { name: 'Add service (API call)', value: 'add-service' },
+                    { name: 'Add action', value: 'add-action' },
+                    { name: agentData.useToolCalling ? 'Disable Tool Calling' : 'Enable Tool Calling', value: 'toggle' },
+                    { name: 'Exit', value: 'exit' },
                 ],
             }]);
         if (action === 'exit')
             return;
         if (action === 'toggle') {
-            const toggleSpinner = (0, ui_1.createSpinner)('Actualizando...');
+            const toggleSpinner = createSpinner('Updating...');
             toggleSpinner.start();
             const { id: _i1, _id: _o1, ...updatedConfig } = { ...agentData, useToolCalling: !agentData.useToolCalling };
             await agent.updateAgent(agentId, updatedConfig);
-            toggleSpinner.succeed(`Tool Calling ${!agentData.useToolCalling ? 'activado' : 'desactivado'}`);
+            toggleSpinner.succeed(`Tool Calling ${!agentData.useToolCalling ? 'enabled' : 'disabled'}`);
             return;
         }
         if (action === 'add-service') {
-            const svc = await inquirer_1.default.prompt([
-                { type: 'input', name: 'intent', message: 'Nombre/intent del servicio:', validate: (v) => v.length > 0 || 'Requerido' },
-                { type: 'input', name: 'reference', message: 'Palabras clave:', default: '' },
-                { type: 'list', name: 'method', message: 'Metodo HTTP:', choices: ['GET', 'POST'] },
-                { type: 'input', name: 'endpoint', message: 'URL del endpoint:', validate: (v) => v.length > 0 || 'Requerido' },
-                { type: 'input', name: 'responseMessage', message: 'Mensaje de respuesta:', default: '' },
+            const svc = await inquirer.prompt([
+                { type: 'input', name: 'intent', message: 'Service name/intent:', validate: (v) => v.length > 0 || 'Required' },
+                { type: 'input', name: 'reference', message: 'Keywords:', default: '' },
+                { type: 'list', name: 'method', message: 'HTTP method:', choices: ['GET', 'POST'] },
+                { type: 'input', name: 'endpoint', message: 'Endpoint URL:', validate: (v) => v.length > 0 || 'Required' },
+                { type: 'input', name: 'responseMessage', message: 'Response message:', default: '' },
             ]);
             const newService = {
                 intent: svc.intent,
@@ -105,32 +100,32 @@ exports.toolsCommand = new commander_1.Command('tools')
             };
             const updatedServices = [...services, newService];
             const { id: _i2, _id: _o2, ...updatedConfig } = { ...agentData, services: updatedServices, useToolCalling: true };
-            const updateSpinner = (0, ui_1.createSpinner)('Guardando servicio...');
+            const updateSpinner = createSpinner('Saving service...');
             updateSpinner.start();
             await agent.updateAgent(agentId, updatedConfig);
-            updateSpinner.succeed(`Servicio "${svc.intent}" agregado`);
+            updateSpinner.succeed(`Service "${svc.intent}" added`);
         }
         if (action === 'add-action') {
-            const act = await inquirer_1.default.prompt([
-                { type: 'input', name: 'intent', message: 'Nombre/intent de la accion:', validate: (v) => v.length > 0 || 'Requerido' },
-                { type: 'input', name: 'reference', message: 'Palabras clave:', default: '' },
+            const act = await inquirer.prompt([
+                { type: 'input', name: 'intent', message: 'Action name/intent:', validate: (v) => v.length > 0 || 'Required' },
+                { type: 'input', name: 'reference', message: 'Keywords:', default: '' },
                 {
-                    type: 'list', name: 'actionType', message: 'Tipo de accion:',
+                    type: 'list', name: 'actionType', message: 'Action type:',
                     choices: [
-                        { name: 'Agendar evento', value: 'action.event.add' },
-                        { name: 'Actualizar evento (reagendar)', value: 'action.event.update' },
-                        { name: 'Listar eventos', value: 'action.event.list' },
-                        { name: 'Eliminar evento (cancelar)', value: 'action.event.delete' },
-                        { name: 'Agregar tag', value: 'action.tag' },
-                        { name: 'Cambiar stage', value: 'action.stage' },
-                        { name: 'Derivar a agente humano', value: 'action.agentShutDown' },
-                        { name: 'Marcar como resuelto', value: 'action.solved' },
-                        { name: 'Asignar agente', value: 'action.asign' },
-                        { name: 'Segmentacion', value: 'action.segmentation' },
+                        { name: 'Schedule event', value: 'action.event.add' },
+                        { name: 'Update event (reschedule)', value: 'action.event.update' },
+                        { name: 'List events', value: 'action.event.list' },
+                        { name: 'Delete event (cancel)', value: 'action.event.delete' },
+                        { name: 'Add tag', value: 'action.tag' },
+                        { name: 'Change stage', value: 'action.stage' },
+                        { name: 'Hand off to human agent', value: 'action.agentShutDown' },
+                        { name: 'Mark as resolved', value: 'action.solved' },
+                        { name: 'Assign agent', value: 'action.asign' },
+                        { name: 'Segmentation', value: 'action.segmentation' },
                     ],
                 },
-                { type: 'input', name: 'actionValue', message: 'Valor (opcional):', default: '' },
-                { type: 'input', name: 'responseMessage', message: 'Mensaje de respuesta:', default: '' },
+                { type: 'input', name: 'actionValue', message: 'Value (optional):', default: '' },
+                { type: 'input', name: 'responseMessage', message: 'Response message:', default: '' },
             ]);
             const newAction = {
                 intent: act.intent,
@@ -142,15 +137,19 @@ exports.toolsCommand = new commander_1.Command('tools')
             };
             const updatedActions = [...actions, newAction];
             const { id: _i3, _id: _o3, ...updatedConfig } = { ...agentData, actions: updatedActions, useToolCalling: true };
-            const updateSpinner = (0, ui_1.createSpinner)('Guardando accion...');
+            const updateSpinner = createSpinner('Saving action...');
             updateSpinner.start();
             await agent.updateAgent(agentId, updatedConfig);
-            updateSpinner.succeed(`Accion "${act.intent}" agregada`);
+            updateSpinner.succeed(`Action "${act.intent}" added`);
         }
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : 'Error desconocido';
-        logger_1.logger.error(message);
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        logger.error(message);
         process.exit(1);
     }
 });
+addExamples(toolsCommand, [
+    { description: 'View services/actions and add new ones interactively',
+        command: 'plazbot agent tools agt_AbcDef123' },
+]);

package/dist/commands/agent/update.js

@@ -1,52 +1,53 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateCommand = void 0;
-const commander_1 = require("commander");
-const plazbot_1 = require("plazbot");
-const credentials_1 = require("../../utils/credentials");
-const logger_1 = require("../../utils/logger");
-const promises_1 = __importDefault(require("fs/promises"));
-exports.updateCommand = new commander_1.Command('update')
-    .description('Actualiza un agente existente en Plazbot')
-    .argument('<agentId>', 'ID del agente a actualizar')
-    .argument('<configPath>', 'Ruta al archivo de configuración JSON del agente')
-    .option('--dev', 'Usar ambiente de desarrollo', false)
+import { Command } from 'commander';
+import { Agent } from 'plazbot';
+import { getStoredCredentials } from '../../utils/credentials.js';
+import { logger } from '../../utils/logger.js';
+import { addExamples } from '../../utils/help.js';
+import fs from 'fs/promises';
+export const updateCommand = new Command('update')
+    .description('Update an existing agent in Plazbot')
+    .argument('<agentId>', 'Agent ID to update')
+    .argument('<configPath>', 'Path to the agent JSON configuration file')
+    .option('--dev', 'Use development environment', false)
     .action(async (agentId, configPath, options) => {
     try {
         // Obtener credenciales guardadas
-        const credentials = await (0, credentials_1.getStoredCredentials)();
+        const credentials = await getStoredCredentials();
         // Leer archivo de configuración del agente
         let agentConfig;
         try {
-            const fileContent = await promises_1.default.readFile(configPath, 'utf-8');
+            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}`);
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new Error(`Error reading configuration file: ${errorMessage}`);
         }
         // Crear instancia del agente con las credenciales guardadas
-        const agent = new plazbot_1.Agent({
+        const agent = new Agent({
             workspaceId: credentials.workspace,
             apiKey: credentials.apiKey,
             zone: credentials.zone,
             ...(options.dev && { customUrl: "http://localhost:5090" })
         });
-        logger_1.logger.dim('Actualizando agente...');
+        logger.dim('Updating agent...');
         // Actualizar el agente
         const result = await agent.updateAgent(agentId, agentConfig);
-        logger_1.logger.success('Agente actualizado exitosamente');
-        logger_1.logger.info(`Mensaje: ${result.message}`);
+        logger.success('Agent updated successfully');
+        logger.info(`Message: ${result.message}`);
         if (options.dev) {
-            logger_1.logger.warning('Ambiente: desarrollo');
+            logger.warning('Environment: development');
         }
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : 'Error desconocido al actualizar el agente';
-        logger_1.logger.error(message);
+        const message = error instanceof Error ? error.message : 'Unknown error while updating the agent';
+        logger.error(message);
         process.exit(1);
     }
 });
+addExamples(updateCommand, [
+    { description: 'Push a new configuration to the agent',
+        command: 'plazbot agent update agt_AbcDef123 ./agent.json' },
+    { description: 'Tip: export → edit → update workflow',
+        command: 'plazbot agent export agt_AbcDef123 -o agent.json && plazbot agent update agt_AbcDef123 ./agent.json' },
+]);

package/dist/commands/agent/validate.js

@@ -0,0 +1,127 @@
+import { Command } from 'commander';
+import { readFileSync, existsSync } from 'node:fs';
+import { resolve, dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+import chalk from 'chalk';
+import { logger } from '../../utils/logger.js';
+import { addExamples } from '../../utils/help.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// El schema se copia a dist/schemas durante el build.
+// Buscar primero en dist/schemas (produccion) y luego en src/schemas (dev/ts-node).
+function loadSchema() {
+    const candidates = [
+        join(__dirname, '..', '..', 'schemas', 'agent.config.schema.json'), // dist/commands/agent -> dist/schemas
+        join(__dirname, '..', '..', '..', 'src', 'schemas', 'agent.config.schema.json'), // fallback dev
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate)) {
+            return JSON.parse(readFileSync(candidate, 'utf-8'));
+        }
+    }
+    throw new Error('No se encontro el schema agent.config.schema.json. Reinstala el CLI.');
+}
+// Traduce una ruta de AJV (e.g. "/actions/0/action/2") en migas legibles
+// estilo "acciones -> 0 -> action -> 2".
+function humanizePath(instancePath) {
+    if (!instancePath || instancePath === '')
+        return '(raiz)';
+    return instancePath
+        .replace(/^\//, '')
+        .split('/')
+        .filter(Boolean)
+        .join(' -> ');
+}
+function formatError(err) {
+    const path = humanizePath(err.instancePath);
+    const keyword = err.keyword;
+    let detail = err.message || 'error de validacion';
+    if (keyword === 'required' && err.params && err.params.missingProperty) {
+        detail = `debe tener la propiedad requerida '${err.params.missingProperty}'`;
+    }
+    else if (keyword === 'enum' && err.params && err.params.allowedValues) {
+        const allowed = err.params.allowedValues;
+        detail = `debe ser uno de: ${allowed.join(', ')}`;
+    }
+    else if (keyword === 'type' && err.params && err.params.type) {
+        detail = `debe ser de tipo ${err.params.type}`;
+    }
+    else if (keyword === 'minLength') {
+        detail = 'no puede estar vacio';
+    }
+    else if (keyword === 'pattern') {
+        detail = `no cumple el patron ${err.params.pattern}`;
+    }
+    return `${path}: ${detail}`;
+}
+export const validateCommand = new Command('validate')
+    .description('Validate an agent JSON file against the official schema')
+    .argument('<file>', 'Path to the agent JSON file')
+    .option('--strict', 'Fail on additional unknown properties', false)
+    .option('--raw', 'Print raw AJV errors as JSON', false)
+    .action(async (file, options) => {
+    try {
+        const filePath = resolve(process.cwd(), file);
+        if (!existsSync(filePath)) {
+            logger.error(`No existe el archivo: ${filePath}`);
+            process.exit(1);
+        }
+        let data;
+        try {
+            data = JSON.parse(readFileSync(filePath, 'utf-8'));
+        }
+        catch (parseErr) {
+            const msg = parseErr instanceof Error ? parseErr.message : 'JSON invalido';
+            logger.error(`JSON con sintaxis invalida: ${msg}`);
+            process.exit(1);
+        }
+        const schema = loadSchema();
+        const ajv = new Ajv({
+            allErrors: true,
+            strict: false,
+            strictTypes: false,
+        });
+        addFormats(ajv);
+        const validate = ajv.compile(schema);
+        const ok = validate(data);
+        if (ok) {
+            console.log();
+            console.log(chalk.hex('#66BB6A')('  Schema valido'));
+            const name = data?.name ? ` (${data.name})` : '';
+            console.log(chalk.gray(`  El agente${name} cumple con el schema oficial.`));
+            console.log();
+            return;
+        }
+        // Filtrar errores AJV redundantes generados por allOf/if-then:
+        // "must match 'then' schema" siempre acompana a un error real con misma path.
+        const rawErrors = validate.errors || [];
+        const errors = rawErrors.filter(e => e.keyword !== 'if' && !/match "then" schema/.test(e.message || ''));
+        if (options.raw) {
+            console.log(JSON.stringify(errors, null, 2));
+            process.exit(1);
+        }
+        console.log();
+        console.log(chalk.hex('#EF5350')(`  Schema invalido (${errors.length} ${errors.length === 1 ? 'error' : 'errores'}):`));
+        console.log();
+        errors.forEach((err, i) => {
+            console.log(chalk.hex('#EF5350')(`  ${i + 1}. ${formatError(err)}`));
+        });
+        console.log();
+        console.log(chalk.gray('  Sugerencia: usa --raw para inspeccionar los errores AJV en JSON.'));
+        console.log();
+        process.exit(1);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Error desconocido';
+        logger.error(message);
+        process.exit(1);
+    }
+});
+addExamples(validateCommand, [
+    { description: 'Validate an exported agent file against the schema',
+        command: 'plazbot agent validate ./agent.json' },
+    { description: 'Print raw AJV errors as JSON for tooling',
+        command: 'plazbot agent validate ./agent.json --raw' },
+]);