@saulwade/swl-ses 1.0.0

package/scripts/validar-memoria.js

@@ -0,0 +1,321 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * validar-memoria.js
+ *
+ * Detecta violaciones de la regla reglas/memoria-consolidada.md.
+ * Reporta:
+ *   - Entradas de APRENDIZAJES.md que lucen como preferencia del usuario
+ *     (deberían ir al perfil).
+ *   - Entradas del perfil-usuario.yaml que lucen como anti-patrón técnico
+ *     (deberían ir a APRENDIZAJES).
+ *   - Duplicación cross-canal por similitud de título > 0.7.
+ *   - Secretos evidentes en cualquier canal.
+ *
+ * Exit codes:
+ *   0 — sin violaciones
+ *   1 — violaciones encontradas (no críticas, warnings)
+ *   2 — violaciones críticas (secretos)
+ *   3 — error de lectura
+ *
+ * Uso:
+ *   node scripts/validar-memoria.js          — reporta
+ *   node scripts/validar-memoria.js --json   — salida JSON
+ *
+ * Zero-deps.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const CWD = process.cwd();
+const APRENDIZAJES = path.join(CWD, '.planning', 'APRENDIZAJES.md');
+const INSTINTOS_PROYECTO = path.join(CWD, 'instintos', 'proyecto.yaml');
+const INSTINTOS_GLOBAL = path.join(CWD, 'instintos', 'global.yaml');
+const PERFIL = path.join(CWD, 'instintos', 'perfil-usuario.yaml');
+
+const flags = {
+  json: process.argv.includes('--json'),
+};
+
+// ---------------------------------------------------------------------------
+// Detectores
+// ---------------------------------------------------------------------------
+
+const PATTERNS_USUARIO = [
+  /\bprefiero\b/i,
+  /\bno me gusta\b/i,
+  /\bsiempre quiero\b/i,
+  /\bmi (stack|idioma|editor|herramienta)\b/i,
+];
+
+const PATTERNS_ANTI_TECNICO = [
+  /\banti[-\s]?patrón\b/i,
+  /\bbug\b/i,
+  /\bfalla[s]?\b/i,
+  /\berror de\b/i,
+  /\bMissingGreenlet|N\+1|race condition\b/i,
+];
+
+const PATTERNS_SECRETOS = [
+  /\bsk-(?:proj|live|test|ant)-[A-Za-z0-9_-]{20,}\b/,  // OpenAI/Anthropic con prefijo explicito
+  /\bsk-[a-z0-9]{20,}/i,                               // OpenAI legacy (sk-*)
+  /\baws_secret_access_key\s*[:=]/i,
+  /\bAKIA[0-9A-Z]{16}\b/,                              // AWS access key id
+  /\beyJ[a-zA-Z0-9_-]{20,}\./,                          // JWT
+  /\bghp_[a-zA-Z0-9]{30,}\b/,                          // GitHub PAT
+  /\bgh[oprsu]_[a-zA-Z0-9]{30,}\b/,                    // GitHub OAuth/refresh/user-to-server/server-to-server
+  /-----BEGIN (RSA|OPENSSH|EC|DSA|PGP) PRIVATE KEY-----/,
+  /\bAPI[_-]?KEY\s*[:=]\s*['"][^'"]{10,}/i,
+];
+
+function normTitle(s) {
+  return String(s).toLowerCase().replace(/[^a-z0-9áéíóúñ]/g, ' ').replace(/\s+/g, ' ').trim();
+}
+
+function jaccard(a, b) {
+  const sa = new Set(a.split(' '));
+  const sb = new Set(b.split(' '));
+  const inter = [...sa].filter(x => sb.has(x)).length;
+  const union = sa.size + sb.size - inter;
+  return union === 0 ? 0 : inter / union;
+}
+
+// ---------------------------------------------------------------------------
+// Parsers
+// ---------------------------------------------------------------------------
+
+function parsearAprendizajes() {
+  if (!fs.existsSync(APRENDIZAJES)) return [];
+  const texto = fs.readFileSync(APRENDIZAJES, 'utf8');
+  const lineas = texto.split(/\r?\n/);
+  const entradas = [];
+  let seccion = '';
+  let actual = null;
+  for (const raw of lineas) {
+    const linea = raw.replace(/\s+$/, '');
+    const mSec = linea.match(/^##\s+(.+)$/);
+    if (mSec && !linea.startsWith('###')) {
+      if (actual) { entradas.push(actual); actual = null; }
+      seccion = mSec[1];
+      continue;
+    }
+    const mEntry = linea.match(/^###\s+\[(\d{4}-\d{2}-\d{2})\]\s+(.+)$/);
+    if (mEntry) {
+      if (actual) entradas.push(actual);
+      actual = { titulo: mEntry[2], fecha: mEntry[1], seccion, desc: '' };
+      continue;
+    }
+    if (actual) actual.desc += ' ' + linea.trim();
+  }
+  if (actual) entradas.push(actual);
+  return entradas;
+}
+
+function parsearInstintosYaml(p) {
+  if (!fs.existsSync(p)) return [];
+  const texto = fs.readFileSync(p, 'utf8');
+  const lineas = texto.split(/\r?\n/);
+  const entradas = [];
+  let actual = null;
+  for (const raw of lineas) {
+    const mId = raw.match(/^\s*- id:\s*(\S+)/);
+    if (mId) {
+      if (actual) entradas.push(actual);
+      actual = { id: mId[1], pattern: '', description: '' };
+      continue;
+    }
+    if (actual) {
+      const mPat = raw.match(/^\s*pattern:\s*"(.+)"/);
+      if (mPat) actual.pattern = mPat[1];
+      const mDesc = raw.match(/^\s*description:\s*"(.+)"/);
+      if (mDesc) actual.description = mDesc[1];
+    }
+  }
+  if (actual) entradas.push(actual);
+  return entradas;
+}
+
+function extraerTextoPerfil() {
+  if (!fs.existsSync(PERFIL)) return '';
+  return fs.readFileSync(PERFIL, 'utf8');
+}
+
+// ---------------------------------------------------------------------------
+// Validaciones
+// ---------------------------------------------------------------------------
+
+function validar() {
+  const issues = {
+    usuario_en_aprendizajes: [],
+    anti_tecnico_en_perfil: [],
+    duplicados_cross_canal: [],
+    secretos: [],
+    pii: [],
+  };
+
+  const aprendizajes = parsearAprendizajes();
+  const instintos = [
+    ...parsearInstintosYaml(INSTINTOS_PROYECTO),
+    ...parsearInstintosYaml(INSTINTOS_GLOBAL),
+  ];
+  const perfil = extraerTextoPerfil();
+
+  // 1. Aprendizajes que lucen como preferencia de usuario
+  for (const a of aprendizajes) {
+    const blob = (a.titulo + ' ' + a.desc).toLowerCase();
+    for (const p of PATTERNS_USUARIO) {
+      if (p.test(blob)) {
+        issues.usuario_en_aprendizajes.push({
+          titulo: a.titulo,
+          fecha: a.fecha,
+          patron: p.source,
+          sugerencia: 'Mover a instintos/perfil-usuario.yaml (vía perfilador-usuario-swl)',
+        });
+        break;
+      }
+    }
+  }
+
+  // 2. Perfil con contenido técnico que luce como anti-patrón
+  for (const p of PATTERNS_ANTI_TECNICO) {
+    const m = perfil.match(p);
+    if (m) {
+      issues.anti_tecnico_en_perfil.push({
+        match: m[0].slice(0, 100),
+        patron: p.source,
+        sugerencia: 'Mover a .planning/APRENDIZAJES.md (anti-patrones técnicos)',
+      });
+    }
+  }
+
+  // 3. Duplicación cross-canal — titulo de APRENDIZAJES vs pattern de instintos
+  // El bootstrap copia aprendizajes → instintos, así que esto detecta casos
+  // DESPUÉS de bootstrap que siguen duplicados sin evolución.
+  for (const a of aprendizajes) {
+    const na = normTitle(a.titulo);
+    for (const i of instintos) {
+      const ni = normTitle(i.pattern);
+      const sim = jaccard(na, ni);
+      if (sim > 0.75 && sim < 1.0) {
+        // Solo reportar similaridad alta pero no idéntica (idéntica = bootstrap ok)
+        issues.duplicados_cross_canal.push({
+          aprendizaje: a.titulo,
+          instinto: i.id + ': ' + i.pattern,
+          similitud: Math.round(sim * 100) / 100,
+          sugerencia: 'Revisar si son el mismo concepto; si sí, consolidar en un solo canal',
+        });
+      }
+    }
+  }
+
+  // 4. Secretos en cualquier canal
+  const archivos = [
+    { nombre: 'APRENDIZAJES.md', path: APRENDIZAJES },
+    { nombre: 'instintos/proyecto.yaml', path: INSTINTOS_PROYECTO },
+    { nombre: 'instintos/global.yaml', path: INSTINTOS_GLOBAL },
+    { nombre: 'instintos/perfil-usuario.yaml', path: PERFIL },
+  ];
+  // Cargar detector de PII del hook privacy-filter (zero-deps, require local)
+  let detectarPII = null;
+  try {
+    ({ detectarPII } = require(path.join(CWD, 'hooks', 'lib', 'privacy-filter.js')));
+  } catch { /* sin detector — skippear check de PII */ }
+
+  for (const a of archivos) {
+    if (!fs.existsSync(a.path)) continue;
+    const texto = fs.readFileSync(a.path, 'utf8');
+    for (const p of PATTERNS_SECRETOS) {
+      const m = texto.match(p);
+      if (m) {
+        issues.secretos.push({
+          archivo: a.nombre,
+          tipo: p.source.slice(0, 30),
+          // NO incluimos el match — evitamos propagarlo
+        });
+      }
+    }
+
+    // Deteccion de PII estructurada (tarjeta, CURP, RFC, NSS, IFE, telefono, email).
+    // Solo reporta — la decision de bloquear o redactar es del caller.
+    if (detectarPII) {
+      const hallazgos = detectarPII(texto);
+      for (const h of hallazgos) {
+        issues.pii.push({ archivo: a.nombre, tipo: h.tipo, muestra: h.muestra });
+      }
+    }
+  }
+
+  return issues;
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+const issues = validar();
+const totalNoCriticas =
+  issues.usuario_en_aprendizajes.length +
+  issues.anti_tecnico_en_perfil.length +
+  issues.duplicados_cross_canal.length;
+const totalCriticas = issues.secretos.length + issues.pii.length;
+
+if (flags.json) {
+  console.log(JSON.stringify({
+    totalNoCriticas,
+    totalCriticas,
+    issues,
+  }, null, 2));
+} else {
+  console.log('Validador de memoria consolidada');
+  console.log('================================');
+  console.log('');
+  if (issues.secretos.length > 0) {
+    console.log(`[CRÍTICO] ${issues.secretos.length} posible(s) secreto(s) detectado(s):`);
+    for (const s of issues.secretos) console.log(`  - ${s.archivo} (patrón: ${s.tipo})`);
+    console.log('');
+  }
+  if (issues.pii.length > 0) {
+    console.log(`[CRÍTICO] ${issues.pii.length} posible(s) dato(s) personal(es) detectado(s):`);
+    for (const p of issues.pii.slice(0, 10)) {
+      console.log(`  - ${p.archivo} (tipo: ${p.tipo}, muestra: ${p.muestra})`);
+    }
+    if (issues.pii.length > 10) console.log(`  ... y ${issues.pii.length - 10} más`);
+    console.log('');
+  }
+  if (issues.usuario_en_aprendizajes.length > 0) {
+    console.log(`[WARN] ${issues.usuario_en_aprendizajes.length} entrada(s) de APRENDIZAJES.md lucen como preferencia del usuario:`);
+    for (const u of issues.usuario_en_aprendizajes.slice(0, 5)) {
+      console.log(`  - [${u.fecha}] ${u.titulo}`);
+    }
+    if (issues.usuario_en_aprendizajes.length > 5) console.log(`  ... y ${issues.usuario_en_aprendizajes.length - 5} más`);
+    console.log('');
+  }
+  if (issues.anti_tecnico_en_perfil.length > 0) {
+    console.log(`[WARN] ${issues.anti_tecnico_en_perfil.length} match(es) técnicos en perfil-usuario.yaml:`);
+    for (const a of issues.anti_tecnico_en_perfil.slice(0, 5)) {
+      console.log(`  - ${a.match}`);
+    }
+    console.log('');
+  }
+  if (issues.duplicados_cross_canal.length > 0) {
+    console.log(`[WARN] ${issues.duplicados_cross_canal.length} posible(s) duplicación(es) cross-canal:`);
+    for (const d of issues.duplicados_cross_canal.slice(0, 5)) {
+      console.log(`  - APRENDIZAJES: "${d.aprendizaje}"`);
+      console.log(`    INSTINTOS:    "${d.instinto}"`);
+      console.log(`    similitud:    ${d.similitud}`);
+    }
+    if (issues.duplicados_cross_canal.length > 5) console.log(`  ... y ${issues.duplicados_cross_canal.length - 5} más`);
+    console.log('');
+  }
+  if (totalNoCriticas === 0 && totalCriticas === 0) {
+    console.log('✓ Sin violaciones detectadas.');
+  } else {
+    console.log(`Total: ${totalCriticas} crítico(s), ${totalNoCriticas} warning(s).`);
+  }
+}
+
+if (totalCriticas > 0) process.exit(2);
+if (totalNoCriticas > 0) process.exit(1);
+process.exit(0);

package/scripts/validar-tests-aislamiento.js

@@ -0,0 +1,184 @@
+'use strict';
+
+/**
+ * validar-tests-aislamiento.js
+ *
+ * Análisis estático: detecta tests que llaman init(), repair() o disable()
+ * sin pasar _settingsPathOverride dentro de las siguientes 30 líneas.
+ *
+ * Propósito: prevenir que tests futuros rompan el aislamiento del settings.json
+ * real (~/.claude/settings.json) introducido en Slice 015-B del plan v5.12.0.
+ *
+ * Uso:
+ *   node scripts/validar-tests-aislamiento.js
+ *   node scripts/validar-tests-aislamiento.js [directorio]
+ *
+ * Salida:
+ *   0 — ningún problema encontrado
+ *   1 — se encontraron llamadas sin _settingsPathOverride
+ */
+
+const fs   = require('node:fs');
+const path = require('node:path');
+
+// ─── Configuración ─────────────────────────────────────────────────────────
+
+const DIRECTORIO_DEFAULT = path.join(__dirname, '..', 'tests');
+const EXTENSION          = '.test.js';
+
+// Funciones que escriben a settings.json y que requieren _settingsPathOverride
+const FUNCIONES_RIESGO = ['init(', 'repair(', 'disable('];
+
+// Ventana de líneas hacia adelante para buscar _settingsPathOverride
+const VENTANA_LINEAS = 30;
+
+// Archivos explícitamente exentos (ninguno por ahora)
+const EXENTOS = new Set([]);
+
+// Comentario de exención explícita en la misma línea o en la línea anterior
+// Úsalo cuando init()/repair()/disable() NO puede llegar al merge de settings:
+//   esTty:true sin token, dryRun:true, token/chatId inválido, omitir:true, confirmar:false
+// Ejemplo: await notif.init({ token: 'TOKEN_INVALIDO', ... }); // swl-aislamiento:ok
+const EXENCION_COMENTARIO = 'swl-aislamiento:ok';
+
+// ─── Utilidades ────────────────────────────────────────────────────────────
+
+/**
+ * Recorre un directorio recursivamente y devuelve todos los archivos .test.js
+ * @param {string} dir
+ * @returns {string[]}
+ */
+function obtenerArchivosTest(dir) {
+  const resultado = [];
+  if (!fs.existsSync(dir)) return resultado;
+
+  for (const entrada of fs.readdirSync(dir, { withFileTypes: true })) {
+    const ruta = path.join(dir, entrada.name);
+    if (entrada.isDirectory()) {
+      resultado.push(...obtenerArchivosTest(ruta));
+    } else if (entrada.isFile() && entrada.name.endsWith(EXTENSION)) {
+      resultado.push(ruta);
+    }
+  }
+  return resultado;
+}
+
+// Expresiones regulares para verificar cada override individualmente
+const RX_OVERRIDE_SETTINGS = /_settingsPathOverride\s*:/;
+const RX_OVERRIDE_ENV      = /_envPathOverride\s*:/;
+
+/**
+ * Analiza un archivo de test línea por línea.
+ * Devuelve la lista de violaciones encontradas.
+ *
+ * @param {string} rutaArchivo
+ * @returns {{ archivo: string, linea: number, funcion: string, tipo: string, contexto: string }[]}
+ */
+function analizarArchivo(rutaArchivo) {
+  const violaciones = [];
+  const lineas = fs.readFileSync(rutaArchivo, 'utf8').split('\n');
+
+  for (let i = 0; i < lineas.length; i++) {
+    const lineaActual = lineas[i];
+
+    // Ignorar líneas de comentario
+    const lineaTrimmed = lineaActual.trim();
+    if (lineaTrimmed.startsWith('//') || lineaTrimmed.startsWith('*')) continue;
+
+    for (const funcion of FUNCIONES_RIESGO) {
+      if (!lineaActual.includes('notif.' + funcion) &&
+          !lineaActual.includes('await notif.' + funcion) &&
+          !lineaActual.includes('await init(') &&
+          !lineaActual.includes('await repair(') &&
+          !lineaActual.includes('await disable(')) continue;
+
+      // Verificar que la línea no es una definición de función ni comentario
+      if (lineaTrimmed.startsWith('async function') || lineaTrimmed.startsWith('function')) continue;
+
+      // Recopilar el bloque de la llamada hasta su cierre (ventana de VENTANA_LINEAS)
+      const limite = Math.min(i + VENTANA_LINEAS, lineas.length);
+      let ventana = '';
+      let cerrado = false;
+
+      for (let j = i; j < limite; j++) {
+        ventana += lineas[j] + '\n';
+        // Si encontramos el cierre de la llamada antes de completar la ventana
+        if (j > i && (lineas[j].includes(');') || lineas[j].includes('})'))) {
+          cerrado = true;
+          break;
+        }
+      }
+      // Si no se encontró cierre explícito, usar toda la ventana
+      if (!cerrado) ventana = lineas.slice(i, limite).join('\n');
+
+      // Verificar exención explícita: comentario swl-aislamiento:ok en línea actual o anterior
+      const lineaAnterior = i > 0 ? lineas[i - 1] : '';
+      const tieneExencion =
+        lineaActual.includes(EXENCION_COMENTARIO) ||
+        lineaAnterior.includes(EXENCION_COMENTARIO);
+
+      if (tieneExencion) continue;
+
+      // Verificar cada override por separado y reportar violación individual
+      if (!RX_OVERRIDE_SETTINGS.test(ventana)) {
+        violaciones.push({
+          archivo:  rutaArchivo,
+          linea:    i + 1,
+          funcion,
+          tipo:     '_settingsPathOverride',
+          contexto: lineaActual.trim().substring(0, 80),
+        });
+      }
+      if (!RX_OVERRIDE_ENV.test(ventana)) {
+        violaciones.push({
+          archivo:  rutaArchivo,
+          linea:    i + 1,
+          funcion,
+          tipo:     '_envPathOverride',
+          contexto: lineaActual.trim().substring(0, 80),
+        });
+      }
+    }
+  }
+
+  return violaciones;
+}
+
+// ─── Main ───────────────────────────────────────────────────────────────────
+
+function main() {
+  const args       = process.argv.slice(2);
+  const directorio = args[0] ? path.resolve(args[0]) : DIRECTORIO_DEFAULT;
+
+  console.log(`Validando aislamiento de tests en: ${directorio}`);
+  console.log(`Buscando llamadas a init/repair/disable sin _settingsPathOverride...\n`);
+
+  const archivos    = obtenerArchivosTest(directorio);
+  const todasViolaciones = [];
+
+  for (const archivo of archivos) {
+    if (EXENTOS.has(path.basename(archivo))) continue;
+    const violaciones = analizarArchivo(archivo);
+    todasViolaciones.push(...violaciones);
+  }
+
+  if (todasViolaciones.length === 0) {
+    console.log(`OK: ${archivos.length} archivo(s) analizados — ningún problema de aislamiento.`);
+    process.exit(0);
+  }
+
+  console.error(`ERROR: Se encontraron ${todasViolaciones.length} llamada(s) sin override requerido:\n`);
+  for (const v of todasViolaciones) {
+    const rutaRelativa = path.relative(process.cwd(), v.archivo);
+    console.error(`  ${rutaRelativa}:${v.linea} — falta ${v.tipo}`);
+    console.error(`    → ${v.contexto}`);
+    console.error('');
+  }
+  console.error(
+    'Solución: pasar _settingsPathOverride y _envPathOverride apuntando a tmpDirs en cada llamada.\n' +
+    'Ver scripts/lib/notificaciones-telegram.js (Fix Slice 015-B y v5.12.2) para referencia.'
+  );
+  process.exit(1);
+}
+
+main();