plazbot-cli 0.2.25 → 0.3.1

package/src/commands/agent/validate.ts

@@ -0,0 +1,135 @@
+import { Command } from 'commander';
+import { readFileSync, existsSync } from 'node:fs';
+import { resolve, dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import Ajv, { ErrorObject } 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(): any {
+  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: string): string {
+  if (!instancePath || instancePath === '') return '(raiz)';
+  return instancePath
+    .replace(/^\//, '')
+    .split('/')
+    .filter(Boolean)
+    .join(' -> ');
+}
+
+function formatError(err: ErrorObject): string {
+  const path = humanizePath(err.instancePath);
+  const keyword = err.keyword;
+  let detail = err.message || 'error de validacion';
+
+  if (keyword === 'required' && err.params && (err.params as any).missingProperty) {
+    detail = `debe tener la propiedad requerida '${(err.params as any).missingProperty}'`;
+  } else if (keyword === 'enum' && err.params && (err.params as any).allowedValues) {
+    const allowed = (err.params as any).allowedValues as string[];
+    detail = `debe ser uno de: ${allowed.join(', ')}`;
+  } else if (keyword === 'type' && err.params && (err.params as any).type) {
+    detail = `debe ser de tipo ${(err.params as any).type}`;
+  } else if (keyword === 'minLength') {
+    detail = 'no puede estar vacio';
+  } else if (keyword === 'pattern') {
+    detail = `no cumple el patron ${(err.params as any).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: string, options: { strict: boolean; raw: boolean }) => {
+    try {
+      const filePath = resolve(process.cwd(), file);
+      if (!existsSync(filePath)) {
+        logger.error(`No existe el archivo: ${filePath}`);
+        process.exit(1);
+      }
+
+      let data: unknown;
+      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 as any)({
+        allErrors: true,
+        strict: false,
+        strictTypes: false,
+      });
+      (addFormats as any)(ajv);
+
+      const validate = ajv.compile(schema);
+      const ok = validate(data);
+
+      if (ok) {
+        console.log();
+        console.log(chalk.hex('#66BB6A')('  Schema valido'));
+        const name = (data as any)?.name ? ` (${(data as any).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: ErrorObject[] = 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: ErrorObject, i: number) => {
+        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' },
+]);