@saulwade/swl-ses 1.0.1 → 1.1.2

package/scripts/migrar-csv-a-array.js

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+/**
+ * Migración 3A — convierte campos CSV a array YAML inline en frontmatter de
+ * agentes. Afecta `tools`, `skillsInvocables`, `skillsRestringidos`.
+ *
+ * Antes:  tools: Read, Write, Edit, Bash
+ * Después: tools: [Read, Write, Edit, Bash]
+ *
+ * Razón: el schema declara `type: array` pero el uso real es CSV string. YAML
+ * estándar NO convierte CSV a array — el parser produce una sola string. Esto
+ * causó bugs históricos documentados en CLAUDE.md ("regla obligatoria CSV
+ * estricto"). Migrar a array inline elimina la ambigüedad.
+ *
+ * Idempotente: skip si ya es array.
+ *
+ * Casos especiales detectados en agentes:
+ *   - skillsInvocables: <ninguno>      → mantener literal
+ *   - skillsRestringidos: ninguno      → convertir a [] (array vacío)
+ *   - skillsRestringidos: \n  - x\n    → ya es array YAML multilinea, mantener
+ *
+ * Uso:
+ *   node scripts/migrar-csv-a-array.js [--dry-run]
+ *
+ * Zero-dependencies. Compatible Windows (CRLF-safe), Node 18+.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const AGENTES_DIR = path.join(__dirname, '..', 'agentes');
+const DRY_RUN = process.argv.includes('--dry-run');
+
+// Campos que migran de CSV a array
+const CAMPOS_CSV = ['tools', 'skillsInvocables', 'skillsRestringidos'];
+
+// Valores especiales que NO son listas y deben preservarse
+const VALORES_LITERAL = new Set(['ninguno', 'ninguna', '<ninguno>', '<ninguna>', 'none', 'null']);
+
+function parsearValorCSV(valorStr) {
+  // Detectar si ya es array inline `[a, b, c]`
+  if (/^\s*\[/.test(valorStr)) return null;
+
+  // Limpiar
+  const valor = valorStr.trim();
+  if (!valor) return [];
+
+  // Valor especial literal
+  if (VALORES_LITERAL.has(valor.toLowerCase())) return [];
+
+  // CSV split
+  return valor
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+function migrarFrontmatter(contenido) {
+  const match = contenido.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n/);
+  if (!match) return { contenido, cambios: 0 };
+
+  const eol = match[0].includes('\r\n') ? '\r\n' : '\n';
+  const fmCompleto = match[0];
+
+  let nuevoFm = fmCompleto;
+  let cambios = 0;
+
+  for (const campo of CAMPOS_CSV) {
+    // Patrón 2 PRIMERO: array YAML multilínea
+    //   skillsRestringidos:
+    //     - angular-moderno
+    //     - typescript-avanzado
+    // El campo está solo en su línea (sin valor) seguido de líneas con `  - X`
+    const re2 = new RegExp(`^(${campo}):[ \\t]*\\r?\\n((?:[ \\t]+-[ \\t]+[^\\r\\n]+\\r?\\n)+)`, 'm');
+    const m2 = nuevoFm.match(re2);
+    if (m2) {
+      const bloque = m2[2];
+      const items = bloque
+        .split(/\r?\n/)
+        .map((l) => l.trim())
+        .filter((l) => l.startsWith('- '))
+        .map((l) => l.slice(2).trim().replace(/^["']|["']$/g, ''));
+      if (items.length > 0) {
+        const arrayInline = `[${items.join(', ')}]`;
+        const reemplazo = `${campo}: ${arrayInline}${eol}`;
+        nuevoFm = nuevoFm.replace(re2, reemplazo);
+        cambios++;
+      }
+      continue; // procesado, no aplicar regex 1
+    }
+
+    // Patrón 1: campo en una sola línea con valor (CSV o array inline)
+    //   tools: Read, Write
+    //   skillsRestringidos: ninguno
+    //   tools: [Read, Write]   ← skip, ya es array
+    // CRÍTICO: usar [ \\t]* (NO \\s*) para no consumir newlines
+    const re1 = new RegExp(`^(${campo}):[ \\t]*([^\\r\\n]+)$`, 'm');
+    const m1 = nuevoFm.match(re1);
+    if (m1) {
+      const valorStr = m1[2];
+      const items = parsearValorCSV(valorStr);
+      if (items === null) continue; // ya es array, skip
+      const arrayInline = `[${items.join(', ')}]`;
+      const reemplazo = `${campo}: ${arrayInline}`;
+      if (m1[0] !== reemplazo) {
+        nuevoFm = nuevoFm.replace(re1, reemplazo);
+        cambios++;
+      }
+    }
+  }
+
+  if (cambios === 0) return { contenido, cambios: 0 };
+
+  return { contenido: contenido.replace(fmCompleto, nuevoFm), cambios };
+}
+
+function migrarAgente(archivo) {
+  const contenido = fs.readFileSync(archivo, 'utf-8');
+  const { contenido: nuevo, cambios } = migrarFrontmatter(contenido);
+
+  if (cambios === 0) {
+    return { archivo: path.basename(archivo), status: 'sin-cambios' };
+  }
+
+  if (DRY_RUN) {
+    return { archivo: path.basename(archivo), status: 'dry-run', cambios };
+  }
+
+  fs.writeFileSync(archivo, nuevo, 'utf-8');
+  return { archivo: path.basename(archivo), status: 'migrado', cambios };
+}
+
+function main() {
+  console.log(`Migrando CSV → array YAML${DRY_RUN ? ' (dry-run)' : ''}...\n`);
+
+  const archivos = fs
+    .readdirSync(AGENTES_DIR)
+    .filter((f) => f.endsWith('.md') && !f.startsWith('_'))
+    .map((f) => path.join(AGENTES_DIR, f));
+
+  const resultados = archivos.map(migrarAgente);
+
+  const stats = {
+    'sin-cambios': 0,
+    migrado: 0,
+    'dry-run': 0,
+    totalCambios: 0,
+  };
+
+  for (const r of resultados) {
+    stats[r.status] = (stats[r.status] || 0) + 1;
+    if (r.cambios) stats.totalCambios += r.cambios;
+  }
+
+  console.log(`Sin cambios: ${stats['sin-cambios']}`);
+  console.log(`Migrados: ${stats.migrado}`);
+  console.log(`Dry-run: ${stats['dry-run']}`);
+  console.log(`Total ediciones: ${stats.totalCambios}`);
+
+  process.exit(0);
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { parsearValorCSV, migrarFrontmatter };

package/scripts/migrar-fase-dominio.js

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+/**
+ * Migración Sprint 2B — añade campos `fase` y `dominio` al frontmatter de los
+ * 59 agentes de SWL. Skip si ya los tiene. Inserta antes de `exclusiones:` o
+ * al final del frontmatter.
+ *
+ * Idempotente: corre dos veces sin efectos.
+ *
+ * Uso:
+ *   node scripts/migrar-fase-dominio.js [--dry-run]
+ *
+ * Origen: análisis de temp/ + propuesta consolidada (mayo 2026).
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const AGENTES_DIR = path.join(__dirname, '..', 'agentes');
+const DRY_RUN = process.argv.includes('--dry-run');
+
+// Mapeo agente → (fase, dominio). Vocabulario controlado del schema.
+const MAPEO = {
+  'accesibilidad-wcag-swl': ['verify', 'ux'],
+  'arquitecto-swl': ['plan', 'general'],
+  'auto-evolucion-swl': ['learn', 'meta'],
+  'backend-api-swl': ['implement', 'backend'],
+  'backend-csharp-swl': ['implement', 'backend'],
+  'backend-go-swl': ['implement', 'backend'],
+  'backend-java-swl': ['implement', 'backend'],
+  'backend-node-swl': ['implement', 'backend'],
+  'backend-python-swl': ['implement', 'backend'],
+  'backend-rust-swl': ['implement', 'backend'],
+  'backend-workers-swl': ['implement', 'backend'],
+  'cloud-infra-swl': ['release', 'infra'],
+  'consolidador-swl': ['learn', 'meta'],
+  'datos-swl': ['implement', 'data'],
+  'depurador-swl': ['implement', 'general'],
+  'devops-ci-swl': ['release', 'infra'],
+  'disenador-ui-swl': ['plan', 'ux'],
+  'documentador-swl': ['meta', 'docs'],
+  'frontend-angular-swl': ['implement', 'frontend'],
+  'frontend-css-swl': ['implement', 'frontend'],
+  'frontend-react-swl': ['implement', 'frontend'],
+  'frontend-swl': ['implement', 'frontend'],
+  'frontend-tailwind-swl': ['implement', 'frontend'],
+  'implementador-swl': ['implement', 'general'],
+  'investigador-swl': ['discover', 'general'],
+  'investigador-ux-swl': ['discover', 'ux'],
+  'llm-apps-swl': ['implement', 'backend'],
+  'migrador-swl': ['implement', 'data'],
+  'mobile-android-swl': ['implement', 'mobile'],
+  'mobile-cross-swl': ['implement', 'mobile'],
+  'mobile-ios-swl': ['implement', 'mobile'],
+  'mobile-testing-swl': ['verify', 'quality'],
+  'notificador-swl': ['meta', 'meta'],
+  'observabilidad-swl': ['release', 'infra'],
+  'orquestador-swl': ['meta', 'process'],
+  'pagos-swl': ['implement', 'backend'],
+  'perfilador-usuario-swl': ['meta', 'meta'],
+  'planificador-swl': ['plan', 'process'],
+  'producto-prd-swl': ['discover', 'process'],
+  'red-team-swl': ['verify', 'security'],
+  'release-manager-swl': ['release', 'process'],
+  'rendimiento-swl': ['verify', 'quality'],
+  'resolutor-build-swl': ['implement', 'general'],
+  'revisor-angular-swl': ['verify', 'quality'],
+  'revisor-codigo-swl': ['verify', 'quality'],
+  'revisor-csharp-swl': ['verify', 'quality'],
+  'revisor-go-swl': ['verify', 'quality'],
+  'revisor-java-swl': ['verify', 'quality'],
+  'revisor-kotlin-swl': ['verify', 'quality'],
+  'revisor-nextjs-swl': ['verify', 'quality'],
+  'revisor-php-swl': ['verify', 'quality'],
+  'revisor-react-swl': ['verify', 'quality'],
+  'revisor-rust-swl': ['verify', 'quality'],
+  'revisor-seguridad-swl': ['verify', 'security'],
+  'revisor-swift-swl': ['verify', 'quality'],
+  'revisor-typescript-swl': ['verify', 'quality'],
+  'sre-swl': ['release', 'infra'],
+  'tdd-qa-swl': ['verify', 'quality'],
+  'ux-disenador-swl': ['plan', 'ux'],
+};
+
+function migrarAgente(nombre) {
+  const archivo = path.join(AGENTES_DIR, `${nombre}.md`);
+  if (!fs.existsSync(archivo)) {
+    return { nombre, status: 'no-existe' };
+  }
+
+  const par = MAPEO[nombre];
+  if (!par) {
+    return { nombre, status: 'sin-mapeo' };
+  }
+  const [fase, dominio] = par;
+
+  const contenido = fs.readFileSync(archivo, 'utf-8');
+
+  // Detectar el frontmatter delimitado por `---` (acepta CRLF y LF)
+  const match = contenido.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n/);
+  if (!match) {
+    return { nombre, status: 'sin-frontmatter' };
+  }
+
+  const frontmatter = match[1];
+
+  // Idempotencia: skip si ya tiene fase y dominio
+  const tieneFase = /^fase:\s*\S+/m.test(frontmatter);
+  const tieneDominio = /^dominio:\s*\S+/m.test(frontmatter);
+  if (tieneFase && tieneDominio) {
+    return { nombre, status: 'ya-migrado', fase, dominio };
+  }
+
+  // Insertar antes de `exclusiones:` o al final del frontmatter
+  let nuevoFrontmatter;
+  if (/^exclusiones:/m.test(frontmatter)) {
+    nuevoFrontmatter = frontmatter.replace(
+      /^(exclusiones:)/m,
+      `fase: ${fase}\ndominio: ${dominio}\n$1`
+    );
+  } else {
+    // Sin exclusiones: agregar al final del frontmatter
+    nuevoFrontmatter = frontmatter.trimEnd() + `\nfase: ${fase}\ndominio: ${dominio}\n`;
+  }
+
+  // Preservar el line ending detectado
+  const eol = match[0].includes('\r\n') ? '\r\n' : '\n';
+  const fm = nuevoFrontmatter.replace(/\r\n/g, '\n').replace(/\n/g, eol);
+  const nuevoContenido = contenido.replace(match[0], `---${eol}${fm}${eol}---${eol}`);
+
+  if (DRY_RUN) {
+    return { nombre, status: 'dry-run-ok', fase, dominio };
+  }
+
+  fs.writeFileSync(archivo, nuevoContenido, 'utf-8');
+  return { nombre, status: 'migrado', fase, dominio };
+}
+
+function main() {
+  console.log(`Migrando fase/dominio en agentes${DRY_RUN ? ' (dry-run)' : ''}...\n`);
+
+  const archivosEnDisco = fs
+    .readdirSync(AGENTES_DIR)
+    .filter((f) => f.endsWith('.md') && !f.startsWith('_'))
+    .map((f) => f.replace(/\.md$/, ''));
+
+  const resultados = archivosEnDisco.map(migrarAgente);
+
+  const stats = {
+    migrado: 0,
+    'ya-migrado': 0,
+    'dry-run-ok': 0,
+    'sin-mapeo': [],
+    'sin-frontmatter': [],
+    'no-existe': [],
+  };
+
+  for (const r of resultados) {
+    if (typeof stats[r.status] === 'number') {
+      stats[r.status]++;
+    } else if (Array.isArray(stats[r.status])) {
+      stats[r.status].push(r.nombre);
+    }
+  }
+
+  console.log(`Migrados: ${stats.migrado}`);
+  console.log(`Ya migrados (skip): ${stats['ya-migrado']}`);
+  console.log(`Dry-run OK: ${stats['dry-run-ok']}`);
+  if (stats['sin-mapeo'].length) {
+    console.log(`\n⚠️  Sin mapeo en MAPEO (${stats['sin-mapeo'].length}):`);
+    stats['sin-mapeo'].forEach((n) => console.log(`  - ${n}`));
+  }
+  if (stats['sin-frontmatter'].length) {
+    console.log(`\n❌ Sin frontmatter detectable:`);
+    stats['sin-frontmatter'].forEach((n) => console.log(`  - ${n}`));
+  }
+
+  // Validación: el mapeo debe cubrir todos los agentes en disco
+  const enMapeo = new Set(Object.keys(MAPEO));
+  const enDisco = new Set(archivosEnDisco);
+  const faltanEnMapeo = [...enDisco].filter((n) => !enMapeo.has(n));
+  const sobranEnMapeo = [...enMapeo].filter((n) => !enDisco.has(n));
+
+  if (faltanEnMapeo.length) {
+    console.log(`\n⚠️  Agentes en disco sin entrada en MAPEO:`);
+    faltanEnMapeo.forEach((n) => console.log(`  - ${n}`));
+  }
+  if (sobranEnMapeo.length) {
+    console.log(`\nℹ️  Entradas en MAPEO sin archivo en disco (probablemente renombrados):`);
+    sobranEnMapeo.forEach((n) => console.log(`  - ${n}`));
+  }
+
+  process.exit(stats['sin-frontmatter'].length || faltanEnMapeo.length ? 1 : 0);
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { MAPEO, migrarAgente };

package/scripts/publicar.js

@@ -62,6 +62,26 @@ function leerPkg() {
   return JSON.parse(fs.readFileSync(PKG_PATH, 'utf-8'));
 }
 
+/**
+ * Clasifica el error de `npm whoami` capturado en stderr para distinguir
+ * causas raíz comunes y permitir mensajes accionables al usuario.
+ *
+ * Tipos retornados:
+ *   - 'no-token'  : no hay _authToken configurado para ese registry.
+ *   - 'token-401' : token presente pero rechazado (expirado/revocado).
+ *   - 'token-403' : token válido pero sin permiso (cuenta sin acceso al scope).
+ *   - 'registry-404' : el registry no responde el endpoint whoami (URL incorrecta).
+ *   - 'desconocido'  : error de red, npm no en PATH, timeout, etc.
+ */
+function clasificarErrorAuth(stderr, mensaje) {
+  const blob = (stderr || '') + '\n' + (mensaje || '');
+  if (/\b401\b/.test(blob))             return 'token-401';
+  if (/\b403\b/.test(blob))             return 'token-403';
+  if (/\b404\b/.test(blob))             return 'registry-404';
+  if (/ENEEDAUTH|need to authorize/i.test(blob)) return 'no-token';
+  return 'desconocido';
+}
+
 function verificarLogin(registry) {
   try {
     const result = npmExec(['whoami', `--registry=${registry}`], {
@@ -69,16 +89,66 @@ function verificarLogin(registry) {
       encoding: 'utf-8',
       timeout:  15_000,
     });
-    return String(result).trim();
+    return { ok: true, usuario: String(result).trim() };
   } catch (err) {
-    // Distinguir "no autenticado" (lo más común) de "error de red" o "npm
-    // no en PATH" requiere inspección del mensaje. Emitir el motivo real
-    // a stderr para que el usuario lo vea pero retornar null al caller
-    // que ya tiene un mensaje específico para "No autenticado".
-    const motivo = String(err.message || err).split('\n')[0].slice(0, 120);
-    process.stderr.write(`[verificarLogin ${registry}] ${motivo}\n`);
-    return null;
+    // Capturar stderr del proceso para clasificar la causa raíz.
+    // execFileSync expone stderr en err.stderr cuando stdio fue 'pipe'.
+    const stderrBuf = err.stderr ? String(err.stderr) : '';
+    const motivo = (stderrBuf || String(err.message || err)).split('\n')[0].slice(0, 200);
+    const tipo   = clasificarErrorAuth(stderrBuf, err.message);
+    process.stderr.write(`[verificarLogin ${registry}] ${tipo}: ${motivo}\n`);
+    return { ok: false, tipo, motivo };
+  }
+}
+
+/**
+ * Imprime guía accionable según el tipo de fallo de auth y el registry.
+ * Se llama desde publicarNpmjs/publicarGitHub cuando verificarLogin falla.
+ */
+function imprimirGuiaAuth(registry, pkgName, tipo) {
+  const esGithub = /npm\.pkg\.github\.com/.test(registry);
+  console.error('');
+  switch (tipo) {
+    case 'token-401':
+      console.error('CAUSA: token de autenticación rechazado (HTTP 401 — expirado o revocado).');
+      if (esGithub) {
+        console.error('FIX:   GitHub Packages NO acepta `npm login`. Genera un nuevo PAT en');
+        console.error('       Settings → Developer settings → Personal access tokens (classic)');
+        console.error('       con scopes `read:packages` y `write:packages`, y reemplaza la línea');
+        console.error('       en ~/.npmrc:');
+        console.error('         //npm.pkg.github.com/:_authToken=<NUEVO_TOKEN>');
+      } else {
+        console.error(`FIX:   npm login --registry=${registry}`);
+        console.error('       (abrirá el navegador para autenticar y reescribirá ~/.npmrc).');
+      }
+      break;
+    case 'token-403':
+      console.error('CAUSA: token válido pero la cuenta no tiene permiso al scope del paquete.');
+      console.error(`FIX:   Verifica el dueño del scope con:`);
+      console.error(`         npm owner ls ${pkgName} --registry=${registry}`);
+      console.error('       Si la cuenta autenticada no aparece como owner, autenticate con la');
+      console.error('       cuenta dueña del scope o pide ser agregado como maintainer.');
+      break;
+    case 'registry-404':
+      console.error('CAUSA: el registry no responde el endpoint whoami (URL probablemente incorrecta).');
+      console.error(`FIX:   Verifica que la URL sea exactamente '${registry}' (incluyendo https:// y trailing slash si aplica).`);
+      break;
+    case 'no-token':
+      console.error('CAUSA: no hay token configurado para este registry en ~/.npmrc.');
+      if (esGithub) {
+        console.error('FIX:   GitHub Packages requiere PAT manual. Agrega a ~/.npmrc:');
+        console.error('         //npm.pkg.github.com/:_authToken=<TU_PAT>');
+        console.error('       (NO uses `npm login` con GitHub Packages — devuelve 404/403.)');
+      } else {
+        console.error(`FIX:   npm login --registry=${registry}`);
+      }
+      break;
+    default:
+      console.error('CAUSA: error desconocido al consultar whoami.');
+      console.error('       Verifica conectividad de red y que `npm` esté en PATH.');
+      console.error(`       Para diagnóstico manual:  npm whoami --registry=${registry}`);
   }
+  console.error('');
 }
 
 function copiarDir(src, dest) {
@@ -165,13 +235,13 @@ function publicarNpmjs(pkg, dryRun) {
   console.log(`Paquete: ${pkg.name}@${pkg.version}`);
   console.log(`Registry: ${NPMJS_REGISTRY}`);
 
-  const usuario = verificarLogin(NPMJS_REGISTRY);
-  if (!usuario) {
-    console.error('ERROR: No autenticado en npmjs.');
-    console.error(`Ejecuta: npm login --registry=${NPMJS_REGISTRY}`);
+  const auth = verificarLogin(NPMJS_REGISTRY);
+  if (!auth.ok) {
+    console.error(`ERROR: No autenticado en npmjs (${auth.tipo}).`);
+    imprimirGuiaAuth(NPMJS_REGISTRY, pkg.name, auth.tipo);
     return false;
   }
-  console.log(`Autenticado como: ${usuario}`);
+  console.log(`Autenticado como: ${auth.usuario}`);
 
   const args = ['publish', `--registry=${NPMJS_REGISTRY}`, '--access', 'public'];
   if (dryRun) args.push('--dry-run');
@@ -190,13 +260,13 @@ function publicarGitHub(pkg, dryRun) {
   console.log(`Paquete: ${GITHUB_NAME}@${pkg.version}`);
   console.log(`Registry: ${GITHUB_REGISTRY}`);
 
-  const usuario = verificarLogin(GITHUB_REGISTRY);
-  if (!usuario) {
-    console.error('ERROR: No autenticado en GitHub Packages.');
-    console.error(`Ejecuta: npm login --registry=${GITHUB_REGISTRY}`);
+  const auth = verificarLogin(GITHUB_REGISTRY);
+  if (!auth.ok) {
+    console.error(`ERROR: No autenticado en GitHub Packages (${auth.tipo}).`);
+    imprimirGuiaAuth(GITHUB_REGISTRY, GITHUB_NAME, auth.tipo);
     return false;
   }
-  console.log(`Autenticado como: ${usuario}`);
+  console.log(`Autenticado como: ${auth.usuario}`);
 
   const tmpDir = prepararDirectorioTemporal(pkg, GITHUB_NAME, GITHUB_REGISTRY);