@saulwade/swl-ses 1.0.0

package/hooks/lib/auto-consolidator.js

@@ -0,0 +1,335 @@
+'use strict';
+
+/**
+ * Auto-Consolidator — Consolidación automática de aprendizajes sin intervención humana.
+ *
+ * Cierra el ciclo: captura automática (extraccion-aprendizajes.js) →
+ * consolidación automática (este módulo) → aplicación (instintos/skills).
+ *
+ * Criterios conservadores para operar sin supervisión:
+ *   - Solo promueve aprendizajes con ≥3 confirmaciones cruzadas
+ *   - Solo degrada con ≥3 contradicciones
+ *   - Solo poda entradas con >30 días sin referencia
+ *   - Nunca modifica CLAUDE.md ni skills (eso requiere /swl:aprender manual)
+ *   - Solo opera sobre APRENDIZAJES.md e instintos/proyecto.yaml
+ *
+ * Zero dependencias externas.
+ *
+ * @module hooks/lib/auto-consolidator
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+// ---------------------------------------------------------------------------
+// Constantes
+// ---------------------------------------------------------------------------
+
+/** Días sin referencia para considerar un aprendizaje como candidato a poda. */
+const DIAS_PODA = 30;
+
+/** Mínimo de confirmaciones para promover un aprendizaje. */
+const MIN_CONFIRMACIONES_PROMOCION = 3;
+
+/** Mínimo de contradicciones para degradar un aprendizaje. */
+const MIN_CONTRADICCIONES_DEGRADACION = 3;
+
+/** Máximo de entradas automáticas a procesar por consolidación. */
+const MAX_ENTRADAS_POR_CICLO = 50;
+
+/** Patrón para detectar entradas automáticas del hook extraccion-aprendizajes. */
+const PATRON_ENTRADA_AUTO = /^## \[(\d{4}-\d{2}-\d{2})\] ([\w\u00C0-\u024F-]+) — (.+)$/;
+
+/** Patrón para detectar confirmaciones. */
+const PATRON_CONFIRMADO = /\[CONFIRMADO(?:\s+x(\d+))?\]/;
+
+/** Patrón para detectar contradicciones. */
+const PATRON_CONTRADICHO = /\[CONTRADICHO(?::\s*\d{4}-\d{2}-\d{2})?\]/g;
+
+/** Patrón para detectar degradados. */
+const PATRON_DEGRADADO = /\[DEGRADADO\]/;
+
+// ---------------------------------------------------------------------------
+// Parsing de APRENDIZAJES.md
+// ---------------------------------------------------------------------------
+
+/**
+ * @typedef {object} EntradaAprendizaje
+ * @property {string} fecha       - YYYY-MM-DD
+ * @property {string} tipo        - anti-patrón, patrón, gotcha, decisión, bug-fix, descubrimiento
+ * @property {string} titulo      - Descripción corta
+ * @property {string} contenido   - Contenido completo de la entrada
+ * @property {number} confirmaciones - Número de confirmaciones
+ * @property {number} contradicciones - Número de contradicciones
+ * @property {boolean} degradado  - Si ya fue marcado como degradado
+ * @property {number} lineaInicio - Línea donde empieza en el archivo
+ * @property {number} lineaFin    - Línea donde termina
+ */
+
+/**
+ * Parsea APRENDIZAJES.md en entradas estructuradas.
+ *
+ * @param {string} contenido
+ * @returns {EntradaAprendizaje[]}
+ */
+function parsearAprendizajes(contenido) {
+  const lineas = contenido.split('\n');
+  const entradas = [];
+  let actual = null;
+
+  for (let i = 0; i < lineas.length; i++) {
+    const match = lineas[i].match(PATRON_ENTRADA_AUTO);
+    if (match) {
+      if (actual) {
+        actual.lineaFin = i - 1;
+        actual.contenido = lineas.slice(actual.lineaInicio, i).join('\n');
+        entradas.push(actual);
+      }
+
+      const [, fecha, tipo, titulo] = match;
+
+      // Contar confirmaciones
+      const textoHastaAhora = lineas[i];
+      const confMatch = textoHastaAhora.match(PATRON_CONFIRMADO);
+      const confirmaciones = confMatch ? parseInt(confMatch[1] || '1', 10) : 0;
+
+      actual = {
+        fecha,
+        tipo,
+        titulo,
+        contenido: '',
+        confirmaciones,
+        contradicciones: 0,
+        degradado: PATRON_DEGRADADO.test(lineas[i]),
+        lineaInicio: i,
+        lineaFin: i,
+      };
+    } else if (actual) {
+      // Buscar confirmaciones y contradicciones en el contenido
+      const confMatch = lineas[i].match(PATRON_CONFIRMADO);
+      if (confMatch) {
+        actual.confirmaciones = Math.max(actual.confirmaciones, parseInt(confMatch[1] || '1', 10));
+      }
+      const contMatches = lineas[i].match(PATRON_CONTRADICHO);
+      if (contMatches) actual.contradicciones += contMatches.length;
+      if (PATRON_DEGRADADO.test(lineas[i])) actual.degradado = true;
+    }
+  }
+
+  if (actual) {
+    actual.lineaFin = lineas.length - 1;
+    actual.contenido = lineas.slice(actual.lineaInicio).join('\n');
+    entradas.push(actual);
+  }
+
+  return entradas;
+}
+
+// ---------------------------------------------------------------------------
+// Deduplicación
+// ---------------------------------------------------------------------------
+
+/**
+ * Detecta entradas duplicadas por similitud de título.
+ * Usa comparación simple normalizada (lowercase, sin acentos, sin puntuación).
+ *
+ * @param {EntradaAprendizaje[]} entradas
+ * @returns {number[]} Índices de entradas duplicadas (las más antiguas se eliminan)
+ */
+function detectarDuplicados(entradas) {
+  const duplicados = [];
+  const vistos = new Map(); // título normalizado → índice de la versión más reciente
+
+  for (let i = 0; i < entradas.length; i++) {
+    const normalizado = entradas[i].titulo
+      .toLowerCase()
+      .normalize('NFD').replace(/[\u0300-\u036f]/g, '')
+      .replace(/[^a-z0-9\s]/g, '')
+      .replace(/\s+/g, ' ')
+      .trim();
+
+    if (vistos.has(normalizado)) {
+      // Mantener la más reciente (mayor fecha) o la más confirmada
+      const prevIdx = vistos.get(normalizado);
+      const prev = entradas[prevIdx];
+      const curr = entradas[i];
+
+      // Priorizar por confirmaciones, luego por fecha
+      const currGana = curr.confirmaciones > prev.confirmaciones
+        || (curr.confirmaciones === prev.confirmaciones && curr.fecha > prev.fecha);
+      if (currGana) {
+        duplicados.push(prevIdx);
+        vistos.set(normalizado, i);
+      } else {
+        duplicados.push(i);
+      }
+    } else {
+      vistos.set(normalizado, i);
+    }
+  }
+
+  return duplicados;
+}
+
+// ---------------------------------------------------------------------------
+// Poda
+// ---------------------------------------------------------------------------
+
+/**
+ * Identifica entradas candidatas a poda (>30 días sin actualización, sin confirmaciones).
+ *
+ * @param {EntradaAprendizaje[]} entradas
+ * @returns {number[]} Índices de entradas a podar
+ */
+function detectarObsoletos(entradas) {
+  const ahora = new Date();
+  const obsoletos = [];
+
+  for (let i = 0; i < entradas.length; i++) {
+    const e = entradas[i];
+
+    // Nunca podar entradas confirmadas
+    if (e.confirmaciones >= 2) continue;
+
+    // Nunca podar secciones curadas manualmente (no tienen fecha de hook)
+    if (!e.fecha) continue;
+
+    const fechaEntrada = new Date(e.fecha);
+    const diasDesde = (ahora - fechaEntrada) / (1000 * 60 * 60 * 24);
+
+    // Podar si: >30 días + 0 confirmaciones + no degradado (ya marcado)
+    if (diasDesde > DIAS_PODA && e.confirmaciones === 0 && !e.degradado) {
+      obsoletos.push(i);
+    }
+  }
+
+  return obsoletos;
+}
+
+// ---------------------------------------------------------------------------
+// Consolidación
+// ---------------------------------------------------------------------------
+
+/**
+ * Ejecuta la consolidación automática sobre APRENDIZAJES.md.
+ *
+ * Operaciones (en orden):
+ *   1. Parsear entradas
+ *   2. Detectar y eliminar duplicados
+ *   3. Podar obsoletos (>30 días sin confirmación)
+ *   4. Marcar degradados (≥3 contradicciones)
+ *
+ * NO hace (requiere /swl:aprender manual):
+ *   - Promover a CLAUDE.md (tipo A)
+ *   - Crear skills nuevos (tipo C)
+ *   - Modificar comandos (tipo D)
+ *
+ * @param {string} baseDir - Raíz del proyecto
+ * @returns {{ ejecutado: boolean, detalles: object }}
+ */
+function consolidar(baseDir) {
+  const ruta = path.join(baseDir, '.planning', 'APRENDIZAJES.md');
+
+  if (!fs.existsSync(ruta)) {
+    return { ejecutado: false, detalles: { razon: 'archivo no existe' } };
+  }
+
+  const contenidoOriginal = fs.readFileSync(ruta, 'utf8');
+  const entradas = parsearAprendizajes(contenidoOriginal);
+
+  if (entradas.length === 0) {
+    return { ejecutado: false, detalles: { razon: 'sin entradas para consolidar' } };
+  }
+
+  // Limitar procesamiento por ciclo
+  const aConsolidar = entradas.slice(-MAX_ENTRADAS_POR_CICLO);
+
+  // Detectar duplicados
+  const duplicados = detectarDuplicados(aConsolidar);
+
+  // Detectar obsoletos
+  const obsoletos = detectarObsoletos(aConsolidar);
+
+  // Detectar degradables (≥3 contradicciones sin marcar)
+  const degradables = [];
+  for (let i = 0; i < aConsolidar.length; i++) {
+    if (aConsolidar[i].contradicciones >= MIN_CONTRADICCIONES_DEGRADACION && !aConsolidar[i].degradado) {
+      degradables.push(i);
+    }
+  }
+
+  // Si no hay nada que hacer, salir
+  const totalAcciones = duplicados.length + obsoletos.length + degradables.length;
+  if (totalAcciones === 0) {
+    return {
+      ejecutado: false,
+      detalles: {
+        razon: 'sin acciones necesarias',
+        entradasAnalizadas: aConsolidar.length,
+      },
+    };
+  }
+
+  // Construir índice de líneas a eliminar y entradas a modificar
+  const lineasAEliminar = new Set();
+  const indicesAEliminar = new Set([...duplicados, ...obsoletos]);
+
+  for (const idx of indicesAEliminar) {
+    const e = aConsolidar[idx];
+    for (let l = e.lineaInicio; l <= e.lineaFin; l++) {
+      lineasAEliminar.add(l);
+    }
+  }
+
+  // Reconstruir archivo
+  const lineas = contenidoOriginal.split('\n');
+  const nuevasLineas = [];
+
+  for (let i = 0; i < lineas.length; i++) {
+    if (lineasAEliminar.has(i)) continue;
+
+    // Marcar degradables
+    let linea = lineas[i];
+    for (const idx of degradables) {
+      const e = aConsolidar[idx];
+      if (i === e.lineaInicio && !PATRON_DEGRADADO.test(linea)) {
+        linea = linea + ' [DEGRADADO]';
+      }
+    }
+
+    nuevasLineas.push(linea);
+  }
+
+  // Limpiar líneas vacías consecutivas (más de 2)
+  const resultado = nuevasLineas.join('\n').replace(/\n{4,}/g, '\n\n\n');
+
+  // Escribir resultado
+  fs.writeFileSync(ruta, resultado, 'utf8');
+
+  return {
+    ejecutado: true,
+    detalles: {
+      entradasAnalizadas: aConsolidar.length,
+      duplicadosEliminados: duplicados.length,
+      obsoletoPodados: obsoletos.length,
+      degradados: degradables.length,
+      lineasAntes: lineas.length,
+      lineasDespues: resultado.split('\n').length,
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+
+module.exports = {
+  consolidar,
+  parsearAprendizajes,
+  detectarDuplicados,
+  detectarObsoletos,
+  DIAS_PODA,
+  MIN_CONFIRMACIONES_PROMOCION,
+  MIN_CONTRADICCIONES_DEGRADACION,
+  MAX_ENTRADAS_POR_CICLO,
+};

package/hooks/lib/canary-skills.js

@@ -0,0 +1,187 @@
+'use strict';
+
+/**
+ * canary-skills.js — Validación sintáctica y estructural de SKILL.md
+ * antes de persistir una evolución.
+ *
+ * Patrón adaptado de `temp/evolver-main/src/canary.js` (14 líneas, MIT).
+ * Diferencias: no forkea proceso hijo (innecesario para validar markdown
+ * zero-deps); integra verificaciones específicas del estándar SWL de skills
+ * definido en `reglas/skills-estandar.md`.
+ *
+ * Uso programático:
+ *   const canary = require('./canary-skills');
+ *   const r = canary.validarSkill('/ruta/a/SKILL.md');
+ *   if (!r.ok) { abortar con r.errores.join('\n') }
+ *
+ * Uso CLI:
+ *   node hooks/lib/canary-skills.js /ruta/a/SKILL.md
+ *   exit 0 si válido, 1 si inválido.
+ *
+ * Invocado por `hooks/auto-evolucion.js` (y cualquier hook que escriba
+ * SKILL.md evolucionado) ANTES de invocar `atomicWrite` para prevenir
+ * que un error sintáctico llegue al disco.
+ *
+ * @module hooks/lib/canary-skills
+ */
+
+const fs = require('fs');
+
+const MAX_LINEAS = 300;
+const MAX_NAME_LEN = 64;
+const MAX_DESC_LEN = 1024;
+const RX_KEBAB = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const PALABRAS_RESERVADAS = ['anthropic', 'claude'];
+
+/**
+ * Parser minimalista de frontmatter YAML para validación.
+ * No reemplaza js-yaml — solo extrae pares key: value de primer nivel.
+ * Suficiente para validar name, description, version.
+ *
+ * @param {string} texto
+ * @returns {{ok: boolean, frontmatter: object, cuerpo: string, error?: string}}
+ */
+function extraerFrontmatter(texto) {
+  if (!texto.startsWith('---')) {
+    return { ok: false, error: 'El archivo no comienza con delimitador de frontmatter "---"' };
+  }
+  const fin = texto.indexOf('\n---', 3);
+  if (fin === -1) {
+    return { ok: false, error: 'Frontmatter sin cierre "---" encontrado' };
+  }
+  const bloque = texto.slice(3, fin).trim();
+  const cuerpo = texto.slice(fin + 4).replace(/^\r?\n/, '');
+
+  const frontmatter = {};
+  let keyActual = null;
+  let valorMultilinea = null;
+  const lineas = bloque.split(/\r?\n/);
+
+  for (const linea of lineas) {
+    if (/^\s*#/.test(linea) || linea.trim() === '') continue;
+
+    // Continuación de valor multilínea con >
+    if (keyActual && valorMultilinea !== null && /^\s+/.test(linea) && !/^\S/.test(linea)) {
+      valorMultilinea += ' ' + linea.trim();
+      frontmatter[keyActual] = valorMultilinea;
+      continue;
+    }
+
+    const m = linea.match(/^([A-Za-z_][A-Za-z0-9_-]*)\s*:\s*(.*)$/);
+    if (!m) continue;
+    const [, k, rawV] = m;
+    const v = rawV.trim();
+
+    if (v === '>' || v === '|') {
+      keyActual = k;
+      valorMultilinea = '';
+      frontmatter[k] = '';
+    } else {
+      keyActual = k;
+      valorMultilinea = null;
+      frontmatter[k] = v.replace(/^["'](.*)["']$/, '$1');
+    }
+  }
+
+  return { ok: true, frontmatter, cuerpo };
+}
+
+/**
+ * Valida un archivo SKILL.md contra el estándar SWL.
+ *
+ * Verificaciones:
+ *   1. Archivo existe y es legible
+ *   2. Frontmatter YAML bien formado (abre y cierra con ---)
+ *   3. Campo `name` presente, kebab-case, ≤ 64 chars, sin palabras reservadas
+ *   4. Campo `description` presente, ≤ 1024 chars
+ *   5. Cuerpo ≤ 300 líneas (advertencia si se excede)
+ *   6. Sin placeholders sin reemplazar (`[COMPLETAR]`, `[TBD]`, `[PENDIENTE]`)
+ *
+ * @param {string} rutaSkill - Ruta absoluta al SKILL.md
+ * @returns {{ok: boolean, errores: string[], advertencias: string[]}}
+ */
+function validarSkill(rutaSkill) {
+  const errores = [];
+  const advertencias = [];
+
+  let contenido;
+  try {
+    contenido = fs.readFileSync(rutaSkill, 'utf8');
+  } catch (err) {
+    return { ok: false, errores: [`No se pudo leer: ${err.message}`], advertencias };
+  }
+
+  const { ok, frontmatter, cuerpo, error } = extraerFrontmatter(contenido);
+  if (!ok) {
+    return { ok: false, errores: [`Frontmatter inválido: ${error}`], advertencias };
+  }
+
+  // Campo name
+  const name = frontmatter.name;
+  if (!name) {
+    errores.push('Campo `name` faltante en frontmatter');
+  } else {
+    if (name.length > MAX_NAME_LEN) {
+      errores.push(`Campo \`name\` excede ${MAX_NAME_LEN} caracteres (actual: ${name.length})`);
+    }
+    if (!RX_KEBAB.test(name)) {
+      errores.push(`Campo \`name\` no es kebab-case válido: "${name}"`);
+    }
+    for (const reservada of PALABRAS_RESERVADAS) {
+      if (name.toLowerCase().includes(reservada)) {
+        errores.push(`Campo \`name\` contiene palabra reservada "${reservada}"`);
+      }
+    }
+  }
+
+  // Campo description
+  const desc = frontmatter.description;
+  if (!desc || desc.trim() === '') {
+    errores.push('Campo `description` vacío o faltante');
+  } else if (desc.length > MAX_DESC_LEN) {
+    errores.push(`Campo \`description\` excede ${MAX_DESC_LEN} caracteres (actual: ${desc.length})`);
+  }
+
+  // Cuerpo
+  const lineasCuerpo = cuerpo.split(/\r?\n/).length;
+  if (lineasCuerpo > MAX_LINEAS) {
+    advertencias.push(
+      `Cuerpo excede ${MAX_LINEAS} líneas (actual: ${lineasCuerpo}). ` +
+      `Considera extraer contenido a recursos/`
+    );
+  }
+
+  // Placeholders
+  const placeholders = cuerpo.match(/\[(COMPLETAR|TBD|PENDIENTE)\]/g);
+  if (placeholders) {
+    errores.push(`Placeholders sin reemplazar detectados: ${placeholders.join(', ')}`);
+  }
+
+  return { ok: errores.length === 0, errores, advertencias };
+}
+
+module.exports = {
+  validarSkill,
+  _internals: { extraerFrontmatter, MAX_LINEAS, MAX_NAME_LEN, MAX_DESC_LEN },
+};
+
+// Modo CLI
+if (require.main === module) {
+  const ruta = process.argv[2];
+  if (!ruta) {
+    process.stderr.write('Uso: node canary-skills.js <ruta-a-SKILL.md>\n');
+    process.exit(1);
+  }
+  const r = validarSkill(ruta);
+  if (r.advertencias.length > 0) {
+    process.stderr.write('Advertencias:\n');
+    for (const a of r.advertencias) process.stderr.write(`  - ${a}\n`);
+  }
+  if (!r.ok) {
+    process.stderr.write('Errores:\n');
+    for (const e of r.errores) process.stderr.write(`  - ${e}\n`);
+    process.exit(1);
+  }
+  process.stdout.write(`OK: ${ruta}\n`);
+  process.exit(0);
+}