@saulwade/swl-ses 1.0.0

package/scripts/verificar-release.js

@@ -0,0 +1,494 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * verificar-release.js
+ *
+ * Gate post-bump que verifica que la version nueva de `package.json` esta
+ * reflejada en TODOS los archivos de la checklist canonica. Bloquea el
+ * push si alguno quedo en version anterior.
+ *
+ * Motivado por el patron recurrente del agente release-manager-swl de
+ * omitir archivos pese al checklist textual del frontmatter: en los
+ * releases 5.10.3 y 5.10.5 el agente reporto "todo OK" pero dejo stale
+ * el campo nested del lockfile, los archivos de .planning/, o los 5
+ * documentos principales del root. Un checklist textual no basta — se
+ * necesita ejecucion.
+ *
+ * Uso:
+ *   node scripts/verificar-release.js [--json] [--version=X.Y.Z]
+ *
+ * Por defecto usa la version actual de package.json como referencia.
+ * Con --version=X.Y.Z verifica contra una version especifica.
+ *
+ * Exit codes:
+ *   0 — todos los archivos obligatorios tienen la version esperada
+ *   1 — al menos uno falla
+ *   2 — error de invocacion (package.json ausente, version invalida)
+ *
+ * Zero-deps. Compatible Windows (CRLF-safe), Node 18+.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const contadoresLib = require('./lib/contadores-inventario');
+
+const CWD = process.cwd();
+
+/**
+ * Checklist canonica derivada de la regla en CLAUDE.md "Mapa de propagacion
+ * de cambios" y del gap reportado en APRENDIZAJES.md el 2026-04-20.
+ *
+ * Cada entrada define:
+ *   - archivo: ruta relativa al cwd
+ *   - tipo: como verificar que tiene la version (ver matchers abajo)
+ *   - obligatorio: si true, faltante o desactualizado falla el script
+ */
+const CHECKLIST = [
+  // Archivos base y de configuracion
+  { archivo: 'package.json',            tipo: 'json_campo',      campo: 'version',             obligatorio: true },
+  { archivo: 'plugin.json',             tipo: 'json_campo',      campo: 'version',             obligatorio: true },
+  { archivo: 'package-lock.json',       tipo: 'json_doble',      campos: ['version', 'packages[""].version'], obligatorio: true },
+
+  // Documentacion principal
+  { archivo: 'CLAUDE.md',               tipo: 'md_encabezado',   minOcurrencias: 1,            obligatorio: true },
+  { archivo: 'README.md',               tipo: 'md_encabezado',   minOcurrencias: 1,            obligatorio: true },
+  { archivo: 'AGENTS.md',               tipo: 'md_encabezado',   minOcurrencias: 1,            obligatorio: true },
+  { archivo: 'INVENTARIO.md',           tipo: 'md_encabezado',   minOcurrencias: 1,            obligatorio: true },
+  { archivo: 'COMANDOS.md',             tipo: 'md_encabezado',   minOcurrencias: 1,            obligatorio: true },
+  { archivo: 'INSTALACION.md',          tipo: 'md_encabezado',   minOcurrencias: 1,            obligatorio: true },
+  { archivo: 'SALUD.md',                tipo: 'md_contiene',     minOcurrencias: 3,            obligatorio: true, nota: 'tres referencias obligatorias' },
+
+  // Planeacion y estado
+  { archivo: '.planning/ESTADO.md',             tipo: 'md_contiene', minOcurrencias: 1, obligatorio: true },
+  { archivo: '.planning/COMPACTACION.md',       tipo: 'md_contiene', minOcurrencias: 1, obligatorio: true },
+  { archivo: '.planning/MAPEO_SKILLS_AGENTES.md', tipo: 'md_contiene', minOcurrencias: 1, obligatorio: true },
+
+  // Historial
+  { archivo: 'CHANGELOG.md',            tipo: 'changelog_seccion', obligatorio: true },
+
+  // Opcional — solo aviso si no esta actualizado
+  { archivo: 'MANUAL_USO.md',           tipo: 'md_contiene',     minOcurrencias: 1,            obligatorio: false, nota: 'opcional: actualizar solo si hay cambios user-facing' },
+];
+
+function versionObjetivo(args) {
+  const override = args.find(a => a.startsWith('--version='));
+  if (override) {
+    const v = override.slice(10);
+    if (!/^\d+\.\d+\.\d+/.test(v)) {
+      console.error('[verificar-release] ERROR: version invalida "' + v + '"');
+      process.exit(2);
+    }
+    return v;
+  }
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(CWD, 'package.json'), 'utf8'));
+    if (!pkg.version) {
+      console.error('[verificar-release] ERROR: package.json sin campo version');
+      process.exit(2);
+    }
+    return pkg.version;
+  } catch (e) {
+    console.error('[verificar-release] ERROR: no pude leer package.json — ' + e.message);
+    process.exit(2);
+  }
+}
+
+function leerArchivoSeguro(filePath) {
+  try {
+    return fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+function escaparRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function contarOcurrencias(texto, version) {
+  // No usamos \b al inicio porque muchas refs tienen prefijo "v" (ej. "v5.10.5")
+  // y \b falla entre caracteres de palabra. Usamos lookbehind/lookahead de
+  // caracteres no-digit para aislar la version de otros numeros.
+  const re = new RegExp('(?<!\\d)' + escaparRegex(version) + '(?!\\d)', 'g');
+  const matches = texto.match(re);
+  return matches ? matches.length : 0;
+}
+
+/**
+ * Verificadores por tipo. Cada uno retorna { ok, problema?, info? }.
+ */
+function verificadorJsonCampo(filePath, version, campo) {
+  const raw = leerArchivoSeguro(filePath);
+  if (raw == null) return { ok: false, problema: 'archivo no existe' };
+  try {
+    const json = JSON.parse(raw);
+    const valor = json[campo];
+    if (valor === version) return { ok: true, info: campo + '=' + valor };
+    return { ok: false, problema: campo + '=' + (valor || 'ausente') + ' (esperado ' + version + ')' };
+  } catch (e) {
+    return { ok: false, problema: 'JSON malformado — ' + e.message };
+  }
+}
+
+function verificadorJsonDoble(filePath, version, campos) {
+  const raw = leerArchivoSeguro(filePath);
+  if (raw == null) return { ok: false, problema: 'archivo no existe' };
+  try {
+    const json = JSON.parse(raw);
+    const problemas = [];
+    const info = [];
+    for (const ruta of campos) {
+      // Resolver rutas tipo 'version' o 'packages[""].version'
+      let valor;
+      if (ruta === 'version') valor = json.version;
+      else if (ruta === 'packages[""].version') valor = json.packages && json.packages[''] && json.packages[''].version;
+      else valor = null;
+
+      if (valor === version) info.push(ruta + '=' + valor);
+      else problemas.push(ruta + '=' + (valor || 'ausente'));
+    }
+    if (problemas.length === 0) return { ok: true, info: info.join(', ') };
+    return { ok: false, problema: problemas.join('; ') + ' (esperado ' + version + ')' };
+  } catch (e) {
+    return { ok: false, problema: 'JSON malformado — ' + e.message };
+  }
+}
+
+function verificadorMdEncabezado(filePath, version) {
+  const raw = leerArchivoSeguro(filePath);
+  if (raw == null) return { ok: false, problema: 'archivo no existe' };
+  const primeraLinea = raw.split(/\r?\n/, 1)[0];
+  if (primeraLinea.includes(version)) {
+    return { ok: true, info: 'encabezado contiene ' + version };
+  }
+  return {
+    ok: false,
+    problema: 'primera linea no menciona ' + version + ' — actual: "' + primeraLinea.slice(0, 80) + '"',
+  };
+}
+
+function verificadorMdContiene(filePath, version, minOcurrencias) {
+  const raw = leerArchivoSeguro(filePath);
+  if (raw == null) return { ok: false, problema: 'archivo no existe' };
+  const n = contarOcurrencias(raw, version);
+  if (n >= minOcurrencias) return { ok: true, info: n + ' ocurrencia(s) de ' + version };
+  return {
+    ok: false,
+    problema: 'solo ' + n + ' ocurrencia(s) de ' + version + ' (minimo ' + minOcurrencias + ')',
+  };
+}
+
+function verificadorChangelogSeccion(filePath, version) {
+  const raw = leerArchivoSeguro(filePath);
+  if (raw == null) return { ok: false, problema: 'archivo no existe' };
+  // Buscar seccion "## [X.Y.Z]" con la version
+  const re = new RegExp('^## \\[' + escaparRegex(version) + '\\] - \\d{4}-\\d{2}-\\d{2}', 'm');
+  if (re.test(raw)) return { ok: true, info: 'seccion [' + version + '] presente con fecha' };
+  const reSinFecha = new RegExp('^## \\[' + escaparRegex(version) + '\\]', 'm');
+  if (reSinFecha.test(raw)) {
+    return { ok: false, problema: 'seccion [' + version + '] presente pero sin fecha YYYY-MM-DD' };
+  }
+  return { ok: false, problema: 'sin seccion [' + version + '] en CHANGELOG' };
+}
+
+function verificarEntrada(entrada, version) {
+  const filePath = path.join(CWD, entrada.archivo);
+  switch (entrada.tipo) {
+    case 'json_campo':
+      return verificadorJsonCampo(filePath, version, entrada.campo);
+    case 'json_doble':
+      return verificadorJsonDoble(filePath, version, entrada.campos);
+    case 'md_encabezado':
+      return verificadorMdEncabezado(filePath, version);
+    case 'md_contiene':
+      return verificadorMdContiene(filePath, version, entrada.minOcurrencias || 1);
+    case 'changelog_seccion':
+      return verificadorChangelogSeccion(filePath, version);
+    default:
+      return { ok: false, problema: 'tipo de verificador desconocido: ' + entrada.tipo };
+  }
+}
+
+function imprimirResultado(entrada, resultado) {
+  const marca = resultado.ok ? 'OK' : (entrada.obligatorio ? 'FALLA' : 'WARN');
+  const sufijo = resultado.ok ? resultado.info : resultado.problema;
+  const nota = entrada.nota ? ' — ' + entrada.nota : '';
+  process.stdout.write('[' + marca + '] ' + entrada.archivo + ': ' + sufijo + nota + '\n');
+}
+
+function main() {
+  const args = process.argv.slice(2);
+
+  if (args.includes('--help') || args.includes('-h')) {
+    process.stdout.write(
+      'Uso: verificar-release.js [--version=X.Y.Z] [--json]\n\n' +
+      'Verifica que la version nueva este reflejada en los ' + CHECKLIST.length +
+      ' archivos de la checklist canonica de release de swl-ses.\n' +
+      'Sin --version, usa la version actual de package.json.\n\n' +
+      'Exit 0 = OK, 1 = fallas en obligatorios, 2 = error de invocacion.\n'
+    );
+    process.exit(0);
+  }
+
+  const version = versionObjetivo(args);
+  const jsonOut = args.includes('--json');
+
+  const resultados = [];
+  let fallasObligatorias = 0;
+  let warningsOpcionales = 0;
+  let oks = 0;
+
+  for (const entrada of CHECKLIST) {
+    const r = verificarEntrada(entrada, version);
+    resultados.push({ entrada, resultado: r });
+    if (r.ok) oks++;
+    else if (entrada.obligatorio) fallasObligatorias++;
+    else warningsOpcionales++;
+  }
+
+  // Gate de contadores: contadores en docs canónicos vs INVENTARIO.md
+  // (fuente de verdad regenerada por scripts/generar-inventario.js).
+  // Bloqueante por defecto; cubrir el hueco entre `verificar-release.js`
+  // (que valida versión) y la regeneración de INVENTARIO (que valida cuántos
+  // hay en disco). Sin este gate, el drift recurrente de "153 skills" o
+  // "147 skills" en MAPEO/COMPACTACION puede llegar a producción.
+  const gateContadores = ejecutarGateContadores();
+  if (gateContadores.disponible && gateContadores.totalDiscrepancias > 0) {
+    fallasObligatorias++;
+  }
+
+  // Gate opt-in de AI-isms sobre CHANGELOG.md + RELEASE_NOTES.md
+  // Se activa solo cuando SWL_AIISMS_GATE=1 y bloquea si encuentra P0.
+  let aiismsGate = null;
+  if (process.env.SWL_AIISMS_GATE === '1') {
+    aiismsGate = ejecutarGateAiisms();
+    if (aiismsGate.p0Total > 0) {
+      fallasObligatorias++;
+    }
+  }
+
+  if (jsonOut) {
+    process.stdout.write(JSON.stringify({
+      version,
+      total: CHECKLIST.length,
+      ok: oks,
+      fallas_obligatorias: fallasObligatorias,
+      warnings_opcionales: warningsOpcionales,
+      contadores_gate: gateContadores,
+      aiisms_gate: aiismsGate,
+      resultados: resultados.map(({ entrada, resultado }) => ({
+        archivo: entrada.archivo,
+        obligatorio: entrada.obligatorio,
+        ok: resultado.ok,
+        detalle: resultado.ok ? resultado.info : resultado.problema,
+      })),
+    }, null, 2) + '\n');
+  } else {
+    process.stdout.write('Verificacion de release — version objetivo: ' + version + '\n');
+    process.stdout.write('='.repeat(60) + '\n');
+    for (const { entrada, resultado } of resultados) {
+      imprimirResultado(entrada, resultado);
+    }
+    process.stdout.write('\n');
+    process.stdout.write(
+      'Resultado: ' + oks + '/' + CHECKLIST.length + ' OK' +
+      (fallasObligatorias > 0 ? ', ' + fallasObligatorias + ' FALLA(S) obligatoria(s)' : '') +
+      (warningsOpcionales > 0 ? ', ' + warningsOpcionales + ' WARN opcional(es)' : '') +
+      '\n'
+    );
+    if (gateContadores.disponible) {
+      process.stdout.write('\n');
+      process.stdout.write('Gate de contadores (vs INVENTARIO.md):\n');
+      const ref = gateContadores.contadoresReales;
+      process.stdout.write(
+        '  Reales: ' + ref.agentes + ' agentes / ' + ref.skills + ' skills / ' +
+        ref.comandos + ' comandos / ' + ref.hooks + ' hooks / ' + ref.reglas + ' reglas\n'
+      );
+      for (const r of gateContadores.resultados) {
+        const icono = r.ok ? '[OK]' : '[FALLA]';
+        process.stdout.write('  ' + icono + ' ' + r.archivo + ' — ' + r.lineas_revisadas + ' linea(s) revisada(s)');
+        if (r.discrepancias.length > 0) process.stdout.write(', ' + r.discrepancias.length + ' discrepancia(s)');
+        process.stdout.write('\n');
+        for (const d of r.discrepancias) {
+          process.stdout.write(
+            '      L' + d.linea + ' ' + d.campo + ': encontrado ' + d.encontrado +
+            ', esperado ' + d.esperado + ' [' + d.tipo + ']\n'
+          );
+          process.stdout.write('         ctx: ' + d.contexto + '\n');
+        }
+      }
+      if (gateContadores.totalDiscrepancias > 0) {
+        process.stdout.write(
+          '  Bloqueo: ' + gateContadores.totalDiscrepancias +
+          ' discrepancia(s) detectada(s). Regenera INVENTARIO.md o corrige los docs antes de release.\n'
+        );
+      }
+    } else if (gateContadores.error) {
+      process.stdout.write('\n');
+      process.stdout.write('Gate de contadores: no disponible — ' + gateContadores.error + '\n');
+    }
+    if (aiismsGate) {
+      process.stdout.write('\n');
+      process.stdout.write('Gate AI-isms (SWL_AIISMS_GATE=1):\n');
+      for (const res of aiismsGate.archivos) {
+        const icono = res.p0 > 0 ? '[FALLA]' : res.p1 > 0 ? '[WARN]' : '[OK]';
+        process.stdout.write('  ' + icono + ' ' + res.archivo +
+          ' — P0:' + res.p0 + ' P1:' + res.p1 + ' P2:' + res.p2 +
+          ' probabilidad:' + res.probabilidad + '\n');
+      }
+      if (aiismsGate.p0Total > 0) {
+        process.stdout.write(
+          '  Bloqueo: ' + aiismsGate.p0Total +
+          ' AI-ism(s) P0 encontrado(s). Corregir antes de release.\n'
+        );
+      }
+    }
+    if (fallasObligatorias > 0) {
+      process.stdout.write('\n');
+      process.stdout.write('Corrige los archivos marcados como FALLA antes de hacer push o publicar.\n');
+    }
+  }
+
+  process.exit(fallasObligatorias > 0 ? 1 : 0);
+}
+
+/**
+ * Gate de contadores: valida los contadores de inventario citados en docs
+ * canónicos contra los reales declarados en `INVENTARIO.md` (regenerado por
+ * `scripts/generar-inventario.js`). Bloqueante por diseño.
+ *
+ * Cubre el hueco entre `verificar-release.js` (que solo valida versión) y
+ * la regeneración del inventario: el script puede dejar `INVENTARIO.md`
+ * actualizado pero CLAUDE/README/MANUAL_USO/COMANDOS/AGENTS/INSTALACION/SALUD/
+ * MAPEO_SKILLS_AGENTES siguen citando contadores viejos. Sin este gate, el
+ * drift documental se publica.
+ */
+function ejecutarGateContadores() {
+  const ARCHIVOS_OBJETIVO = [
+    'CLAUDE.md',
+    'README.md',
+    'MANUAL_USO.md',
+    'COMANDOS.md',
+    'AGENTS.md',
+    'INSTALACION.md',
+    'SALUD.md',
+    '.planning/MAPEO_SKILLS_AGENTES.md',
+    '.planning/ESTADO.md',
+    '.planning/COMPACTACION.md',
+  ];
+
+  const rawInv = leerArchivoSeguro(path.join(CWD, 'INVENTARIO.md'));
+  if (rawInv == null) {
+    return {
+      disponible: false,
+      error: 'INVENTARIO.md no existe — regenera con `node scripts/generar-inventario.js`',
+      resultados: [],
+      totalDiscrepancias: 0,
+    };
+  }
+
+  const contadoresReales = contadoresLib.parsearInventario(rawInv);
+  if (!contadoresReales.agentes || !contadoresReales.skills) {
+    return {
+      disponible: false,
+      error: 'No pude parsear contadores de INVENTARIO.md (sección "## Resumen" ausente o malformada)',
+      resultados: [],
+      totalDiscrepancias: 0,
+    };
+  }
+
+  const resultados = [];
+  let totalDiscrepancias = 0;
+  for (const archivo of ARCHIVOS_OBJETIVO) {
+    const raw = leerArchivoSeguro(path.join(CWD, archivo));
+    if (raw == null) continue;
+    const r = contadoresLib.validarArchivo(raw, contadoresReales);
+    resultados.push({
+      archivo,
+      ok: r.ok,
+      lineas_revisadas: r.lineas_revisadas,
+      discrepancias: r.discrepancias,
+    });
+    totalDiscrepancias += r.discrepancias.length;
+  }
+
+  return {
+    disponible: true,
+    contadoresReales,
+    resultados,
+    totalDiscrepancias,
+  };
+}
+
+/**
+ * Gate opt-in de AI-isms. Ejecuta detectar_aiisms.py contra los archivos
+ * que típicamente contienen prosa de release (CHANGELOG, RELEASE_NOTES).
+ *
+ * Activación: SWL_AIISMS_GATE=1
+ * Python 3.10+ debe estar disponible. Si falla la invocación, se reporta
+ * como warning pero no bloquea (el gate de versión es independiente).
+ */
+function ejecutarGateAiisms() {
+  const { spawnSync } = require('child_process');
+  const detector = path.join(CWD, 'habilidades', 'estilo-sin-ai-isms', 'scripts', 'detectar_aiisms.py');
+
+  if (!fs.existsSync(detector)) {
+    return {
+      disponible: false,
+      error: 'detector no existe: ' + detector,
+      archivos: [],
+      p0Total: 0,
+    };
+  }
+
+  const candidatos = ['CHANGELOG.md', 'RELEASE_NOTES.md'];
+  const archivos = [];
+  let p0Total = 0;
+
+  for (const archivo of candidatos) {
+    const ruta = path.join(CWD, archivo);
+    if (!fs.existsSync(ruta)) continue;
+
+    const pythonBin = process.env.PYTHON_BIN || 'python';
+    const r = spawnSync(pythonBin, [detector, '--archivo', ruta, '--json'], {
+      encoding: 'utf-8',
+      timeout: 30000,
+    });
+
+    if (r.status === 2 || r.error) {
+      archivos.push({
+        archivo,
+        error: (r.stderr || r.error?.message || 'error desconocido').trim(),
+        p0: 0, p1: 0, p2: 0,
+        probabilidad: 'desconocida',
+      });
+      continue;
+    }
+
+    try {
+      const reporte = JSON.parse(r.stdout);
+      archivos.push({
+        archivo,
+        p0: reporte.p0_count,
+        p1: reporte.p1_count,
+        p2: reporte.p2_count,
+        probabilidad: reporte.probabilidad_generacion_llm,
+      });
+      p0Total += reporte.p0_count;
+    } catch (e) {
+      archivos.push({
+        archivo,
+        error: 'stdout no es JSON válido',
+        p0: 0, p1: 0, p2: 0,
+        probabilidad: 'desconocida',
+      });
+    }
+  }
+
+  return { disponible: true, archivos, p0Total };
+}
+
+if (require.main === module) main();
+
+module.exports = { CHECKLIST, verificarEntrada, versionObjetivo };