plazbot-cli 0.4.1 → 0.5.0

package/dist/commands/agent/validate.js

@@ -5,7 +5,7 @@ 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 { jsonOption, isJsonMode, printJson, fail, CliError } from '../../utils/output.js';
 import { addExamples } from '../../utils/help.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -21,63 +21,86 @@ function loadSchema() {
             return JSON.parse(readFileSync(candidate, 'utf-8'));
         }
     }
-    throw new Error('No se encontro el schema agent.config.schema.json. Reinstala el CLI.');
+    throw new CliError('The agent schema (agent.config.schema.json) was not found.', 'schema_missing', 'Reinstall the CLI: npm install -g plazbot-cli');
+}
+// --strict: cierra con additionalProperties:false todo objeto del schema que declare
+// properties y no lo fije ya, para detectar campos desconocidos (typos) en objetos anidados.
+function closeObjects(node) {
+    if (!node || typeof node !== 'object')
+        return;
+    if (node.properties && typeof node.properties === 'object') {
+        if (node.additionalProperties === undefined)
+            node.additionalProperties = false;
+        Object.values(node.properties).forEach(closeObjects);
+    }
+    if (Array.isArray(node.items))
+        node.items.forEach(closeObjects);
+    else
+        closeObjects(node.items);
+    if (typeof node.additionalProperties === 'object')
+        closeObjects(node.additionalProperties);
 }
 // Traduce una ruta de AJV (e.g. "/actions/0/action/2") en migas legibles
-// estilo "acciones -> 0 -> action -> 2".
+// estilo "actions -> 0 -> action -> 2".
 function humanizePath(instancePath) {
     if (!instancePath || instancePath === '')
-        return '(raiz)';
+        return '(root)';
     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}'`;
+function describeAjvError(err) {
+    const params = (err.params || {});
+    let detail = err.message || 'validation error';
+    if (err.keyword === 'required' && params.missingProperty) {
+        detail = `missing required property '${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 (err.keyword === 'enum' && params.allowedValues) {
+        detail = `must be one of: ${params.allowedValues.join(', ')}`;
     }
-    else if (keyword === 'type' && err.params && err.params.type) {
-        detail = `debe ser de tipo ${err.params.type}`;
+    else if (err.keyword === 'type' && params.type) {
+        detail = `must be of type ${params.type}`;
     }
-    else if (keyword === 'minLength') {
-        detail = 'no puede estar vacio';
+    else if (err.keyword === 'minLength') {
+        detail = 'cannot be empty';
     }
-    else if (keyword === 'pattern') {
-        detail = `no cumple el patron ${err.params.pattern}`;
+    else if (err.keyword === 'pattern') {
+        detail = `does not match the pattern ${params.pattern}`;
     }
-    return `${path}: ${detail}`;
+    else if (err.keyword === 'additionalProperties' && params.additionalProperty) {
+        detail = `unknown property '${params.additionalProperty}'`;
+    }
+    return { path: humanizePath(err.instancePath), message: 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)
+    .option('--strict', 'Also fail on unknown properties (catches typos in nested objects)', false)
+    .option('--raw', 'Print the raw AJV errors as JSON', false)
+    .addOption(jsonOption('Print the result as JSON ({"valid","errors":[{"path","message"}]})'))
     .action(async (file, options) => {
     try {
         const filePath = resolve(process.cwd(), file);
         if (!existsSync(filePath)) {
-            logger.error(`No existe el archivo: ${filePath}`);
-            process.exit(1);
+            throw new CliError(`File not found: ${filePath}`, 'file_not_found');
         }
         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 msg = parseErr instanceof Error ? parseErr.message : 'invalid JSON';
+            if (isJsonMode()) {
+                printJson({ valid: false, errors: [{ path: '(root)', message: `Invalid JSON syntax: ${msg}` }] });
+                process.exit(1);
+            }
+            throw new CliError(`Invalid JSON syntax: ${msg}`, 'invalid_json');
         }
         const schema = loadSchema();
+        if (options.strict)
+            closeObjects(schema);
         const ajv = new Ajv({
             allErrors: true,
             strict: false,
@@ -87,10 +110,14 @@ export const validateCommand = new Command('validate')
         const validate = ajv.compile(schema);
         const ok = validate(data);
         if (ok) {
+            if (isJsonMode()) {
+                printJson({ valid: true, errors: [] });
+                return;
+            }
             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(chalk.hex('#66BB6A')('  Valid schema'));
+            const name = data?.name ? ` "${data.name}"` : '';
+            console.log(chalk.gray(`  The agent${name} matches the official schema${options.strict ? ' (strict mode)' : ''}.`));
             console.log();
             return;
         }
@@ -99,29 +126,34 @@ export const validateCommand = new Command('validate')
         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));
+            printJson(errors);
+            process.exit(1);
+        }
+        const described = errors.map(describeAjvError);
+        if (isJsonMode()) {
+            printJson({ valid: false, errors: described });
             process.exit(1);
         }
         console.log();
-        console.log(chalk.hex('#EF5350')(`  Schema invalido (${errors.length} ${errors.length === 1 ? 'error' : 'errores'}):`));
+        console.log(chalk.hex('#EF5350')(`  Invalid schema (${described.length} ${described.length === 1 ? 'error' : 'errors'}):`));
         console.log();
-        errors.forEach((err, i) => {
-            console.log(chalk.hex('#EF5350')(`  ${i + 1}. ${formatError(err)}`));
+        described.forEach((err, i) => {
+            console.log(chalk.hex('#EF5350')(`  ${i + 1}. ${err.path}: ${err.message}`));
         });
         console.log();
-        console.log(chalk.gray('  Sugerencia: usa --raw para inspeccionar los errores AJV en JSON.'));
+        console.log(chalk.gray('  Tip: use --raw to inspect the AJV errors as JSON.'));
         console.log();
         process.exit(1);
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : 'Error desconocido';
-        logger.error(message);
-        process.exit(1);
+        fail(error);
     }
 });
 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' },
+    { description: 'Also flag unknown properties (typos)',
+        command: 'plazbot agent validate ./agent.json --strict' },
+    { description: 'Get a machine-readable result (exit code 1 when invalid)',
+        command: 'plazbot agent validate ./agent.json --json' },
 ]);