@saulwade/swl-ses 1.5.1 → 1.6.0

package/scripts/desinstalar.js

@@ -3,6 +3,22 @@
 /**
  * swl-ses uninstall
  * Desinstala componentes SWL del runtime especificado.
+ *
+ * Contrato adicional: opciones.onProgress(evento)
+ *
+ * Si se pasa una función onProgress, el desinstalador emite eventos
+ * estructurados en vez de imprimir cada archivo a stdout:
+ *   { tipo: 'archivo-eliminado',  componente, archivo, destino }
+ *   { tipo: 'bloque-eliminado',   archivo, etiqueta }
+ *   { tipo: 'archivo-no-encontrado', archivo }
+ *   { tipo: 'error',              archivo, mensaje }
+ *   { tipo: 'log',                linea }
+ *
+ * Backward compat: si onProgress no se pasa, los console.log son idénticos
+ * a antes. El CLI clásico (uninstall sin TUI) no cambia.
+ *
+ * Devuelve { eliminados, noEncontrados, bloquesEliminados } para que el
+ * caller (TUI) pueda mostrar resumen sin re-parsear stdout.
  */
 
 const fs = require('fs');
@@ -15,23 +31,40 @@ const { eliminarBloque } = require('./lib/append-con-marcadores');
 function uninstall(opciones) {
   const target = opciones.target || 'claude';
   const esGlobal = opciones.global || false;
+  const onProgress = typeof opciones.onProgress === 'function' ? opciones.onProgress : null;
 
-  console.log('swl-ses uninstall');
-  console.log('='.repeat(40));
+  function _emitir(evento, mensajeFallback) {
+    if (onProgress) {
+      onProgress(evento);
+    } else if (mensajeFallback) {
+      console.log(mensajeFallback);
+    }
+  }
+
+  if (!onProgress) {
+    console.log('swl-ses uninstall');
+    console.log('='.repeat(40));
+  }
 
   const runtime = obtenerRuntime(target);
   const rutas = calcularRutas(target, { global: esGlobal });
 
   const estado = cargarEstado(rutas.base);
   if (!estado) {
+    if (onProgress) {
+      onProgress({ tipo: 'log', linea: `No se encontró instalación SWL en ${rutas.base}` });
+      return { eliminados: 0, noEncontrados: 0, bloquesEliminados: 0, error: 'instalacion-no-encontrada' };
+    }
     console.log(`No se encontró instalación SWL en ${rutas.base}`);
     process.exit(1);
   }
 
-  console.log(`Target: ${target} (${runtime.nombre})`);
-  console.log(`Ubicación: ${rutas.base}`);
-  console.log(`Archivos a eliminar: ${estado.archivosInstalados.length}`);
-  console.log('');
+  if (!onProgress) {
+    console.log(`Target: ${target} (${runtime.nombre})`);
+    console.log(`Ubicación: ${rutas.base}`);
+    console.log(`Archivos a eliminar: ${estado.archivosInstalados.length}`);
+    console.log('');
+  }
 
   let eliminados = 0;
   let noEncontrados = 0;
@@ -56,10 +89,17 @@ function uninstall(opciones) {
       if (accionInstall === 'creado') {
         try {
           fs.unlinkSync(archivo.destino);
-          console.log(`  - ${archivo.destino} (creado por swl-ses, eliminación completa)`);
+          _emitir(
+            { tipo: 'archivo-eliminado', componente: archivo.tipo, archivo: archivo.destino, motivo: 'creado-por-swl' },
+            `  - ${archivo.destino} (creado por swl-ses, eliminación completa)`
+          );
           eliminados++;
         } catch (err) {
-          console.error(`  ! Error eliminando ${archivo.destino}: ${err.message}`);
+          _emitir(
+            { tipo: 'error', archivo: archivo.destino, mensaje: err.message },
+            null
+          );
+          if (!onProgress) console.error(`  ! Error eliminando ${archivo.destino}: ${err.message}`);
         }
       } else {
         try {
@@ -70,12 +110,19 @@ function uninstall(opciones) {
             'sin-cambios':        'sin bloque SWL presente (ya limpio)',
             'error':              `error: ${r.detalle || 'desconocido'}`,
           }[r.accion] || r.accion;
-          console.log(`  ~ ${archivo.destino} (${etiqueta})`);
+          _emitir(
+            { tipo: 'bloque-eliminado', archivo: archivo.destino, etiqueta, accion: r.accion },
+            `  ~ ${archivo.destino} (${etiqueta})`
+          );
           if (r.accion === 'bloque-eliminado' || r.accion === 'archivo-eliminado') {
             bloquesEliminados++;
           }
         } catch (err) {
-          console.error(`  ! Error limpiando bloque en ${archivo.destino}: ${err.message}`);
+          _emitir(
+            { tipo: 'error', archivo: archivo.destino, mensaje: err.message },
+            null
+          );
+          if (!onProgress) console.error(`  ! Error limpiando bloque en ${archivo.destino}: ${err.message}`);
         }
       }
       continue;
@@ -88,26 +135,47 @@ function uninstall(opciones) {
       } else {
         fs.unlinkSync(archivo.destino);
       }
-      console.log(`  - ${archivo.destino}`);
+      _emitir(
+        { tipo: 'archivo-eliminado', componente: archivo.tipo, archivo: archivo.destino },
+        `  - ${archivo.destino}`
+      );
       eliminados++;
     } catch (err) {
-      console.error(`  ! Error eliminando ${archivo.destino}: ${err.message}`);
+      _emitir(
+        { tipo: 'error', archivo: archivo.destino, mensaje: err.message },
+        null
+      );
+      if (!onProgress) console.error(`  ! Error eliminando ${archivo.destino}: ${err.message}`);
     }
   }
 
   // Desregistrar hooks de settings.json
+  let hooksDesregistrados = 0;
+  let hooksPreservados = 0;
   if (runtime.soportaHooks) {
     const settingsPath = rutaSettings(runtime, rutas.base);
     try {
       const resultado = desregistrarHooks(settingsPath);
-      if (resultado.eliminados > 0) {
-        console.log(`  - Hooks desregistrados de settings.json: ${resultado.eliminados}`);
+      hooksDesregistrados = resultado.eliminados || 0;
+      hooksPreservados = resultado.preservados || 0;
+      if (hooksDesregistrados > 0) {
+        _emitir(
+          { tipo: 'hooks-desregistrados', cuenta: hooksDesregistrados },
+          `  - Hooks desregistrados de settings.json: ${hooksDesregistrados}`
+        );
       }
-      if (resultado.preservados > 0) {
-        console.log(`    (${resultado.preservados} hooks externos preservados)`);
+      if (hooksPreservados > 0) {
+        _emitir(
+          { tipo: 'hooks-preservados', cuenta: hooksPreservados },
+          `    (${hooksPreservados} hooks externos preservados)`
+        );
       }
     } catch (err) {
-      console.error(`  ! Error desregistrando hooks: ${err.message}`);
+      _emitir(
+        { tipo: 'error', mensaje: `Error desregistrando hooks: ${err.message}` },
+        null
+      );
+      if (!onProgress) console.error(`  ! Error desregistrando hooks: ${err.message}`);
     }
   }
 
@@ -117,14 +185,27 @@ function uninstall(opciones) {
     fs.unlinkSync(estadoPath);
   }
 
-  console.log('');
-  console.log(`Eliminados: ${eliminados}`);
-  if (bloquesEliminados > 0) {
-    console.log(`Bloques SWL quitados (contenido de usuario preservado): ${bloquesEliminados}`);
+  if (!onProgress) {
+    console.log('');
+    console.log(`Eliminados: ${eliminados}`);
+    if (bloquesEliminados > 0) {
+      console.log(`Bloques SWL quitados (contenido de usuario preservado): ${bloquesEliminados}`);
+    }
+    console.log(`No encontrados: ${noEncontrados}`);
+    console.log('');
+    console.log('Nota: .planning/ y _userland/ no se eliminan (contienen datos del proyecto).');
   }
-  console.log(`No encontrados: ${noEncontrados}`);
-  console.log('');
-  console.log('Nota: .planning/ y _userland/ no se eliminan (contienen datos del proyecto).');
+
+  return {
+    eliminados,
+    noEncontrados,
+    bloquesEliminados,
+    hooksDesregistrados,
+    hooksPreservados,
+    target,
+    scope: esGlobal ? 'global' : 'proyecto',
+    ubicacion: rutas.base,
+  };
 }
 
 module.exports = uninstall;

package/scripts/detectar-aprendizajes-duplicados.js

@@ -1,151 +1,151 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * detectar-aprendizajes-duplicados.js
- *
- * Detecta pares de entradas en `.planning/APRENDIZAJES.md` con alta similitud
- * de tokens (Jaccard > umbral). Útil para identificar candidatos a fusionar
- * cuando el hook de auto-extracción genera entradas redundantes.
- *
- * Patrón adoptado de `temp/agentmemory-main/src/functions/auto-forget.ts`
- * (contradiction detection con Jaccard >= 0.9). Aquí se usa con threshold
- * configurable más bajo (0.6 default) porque queremos sugerir, no auto-borrar.
- *
- * NO modifica APRENDIZAJES.md. Solo reporta. La acción de fusión queda en
- * manos del usuario o de un comando separado (`/swl:aprender consolidar`).
- *
- * Uso:
- *   node scripts/detectar-aprendizajes-duplicados.js [threshold]
- *
- * Argumentos:
- *   threshold  - Similitud mínima para reportar (default: 0.6, rango [0, 1]).
- *
- * Exit codes:
- *   0 - Ejecución OK (haya o no duplicados)
- *   1 - Error de I/O o parseo
- *
- * Output: tabla legible en stdout. Si se detectan ≥ 1 duplicados, también
- * imprime sugerencia para revisar/consolidar.
- */
-
-const fs   = require('fs');
-const path = require('path');
-
-const { tokenize, jaccard } = require('./lib/jaccard-similarity');
-
-const RUTA_APRENDIZAJES = path.join(process.cwd(), '.planning', 'APRENDIZAJES.md');
-const DEFAULT_THRESHOLD = 0.6;
-const MAX_PARES_REPORTADOS = 30;
-
-function parsearEntradas(contenido) {
-  const lineas = contenido.split('\n');
-  const entradas = [];
-  let actual = null;
-
-  for (let i = 0; i < lineas.length; i++) {
-    const linea = lineas[i];
-    if (linea.startsWith('## ')) {
-      if (actual) entradas.push(actual);
-      actual = {
-        lineaInicio: i + 1,
-        titulo: linea.slice(3).trim(),
-        contenido: '',
-      };
-    } else if (actual) {
-      actual.contenido += linea + '\n';
-    }
-  }
-  if (actual) entradas.push(actual);
-
-  // Filtrar entradas vacías o triviales (< 50 chars de contenido real)
-  return entradas.filter(e => e.contenido.replace(/\s/g, '').length >= 50);
-}
-
-function detectarDuplicados(entradas, threshold) {
-  const tokensCache = entradas.map(e => tokenize(e.titulo + ' ' + e.contenido));
-  const pares = [];
-
-  for (let i = 0; i < entradas.length; i++) {
-    for (let j = i + 1; j < entradas.length; j++) {
-      const sim = jaccard(tokensCache[i], tokensCache[j]);
-      if (sim >= threshold) {
-        pares.push({
-          entradaA: entradas[i],
-          entradaB: entradas[j],
-          similitud: sim,
-        });
-      }
-    }
-  }
-
-  pares.sort((a, b) => b.similitud - a.similitud);
-  return pares;
-}
-
-function reportarTexto(pares) {
-  if (pares.length === 0) {
-    console.log('Sin duplicados detectados sobre el umbral.');
-    return;
-  }
-
-  console.log(`Pares con similitud Jaccard ≥ umbral: ${pares.length}`);
-  console.log('');
-
-  const limite = Math.min(pares.length, MAX_PARES_REPORTADOS);
-  for (let i = 0; i < limite; i++) {
-    const p = pares[i];
-    console.log(`  [${(p.similitud * 100).toFixed(1)}%] ` +
-      `L${p.entradaA.lineaInicio} ↔ L${p.entradaB.lineaInicio}`);
-    console.log('         A: ' + p.entradaA.titulo.slice(0, 80));
-    console.log('         B: ' + p.entradaB.titulo.slice(0, 80));
-    console.log('');
-  }
-
-  if (pares.length > limite) {
-    console.log(`  ... ${pares.length - limite} pares adicionales no mostrados`);
-  }
-
-  console.log('Sugerencia: revisa los pares con mayor similitud y considera ' +
-    'fusionarlos en una sola entrada con `/swl:aprender consolidar` o manualmente.');
-}
-
-function main() {
-  const threshold = parseFloat(process.argv[2]) || DEFAULT_THRESHOLD;
-
-  if (!Number.isFinite(threshold) || threshold < 0 || threshold > 1) {
-    console.error(`Threshold inválido: ${process.argv[2]}. Usar valor en [0, 1].`);
-    process.exit(1);
-  }
-
-  if (!fs.existsSync(RUTA_APRENDIZAJES)) {
-    console.error(`No existe ${RUTA_APRENDIZAJES}.`);
-    process.exit(1);
-  }
-
-  let contenido;
-  try {
-    contenido = fs.readFileSync(RUTA_APRENDIZAJES, 'utf8');
-  } catch (err) {
-    console.error(`Error leyendo ${RUTA_APRENDIZAJES}: ${err.message}`);
-    process.exit(1);
-  }
-
-  const entradas = parsearEntradas(contenido);
-  console.log(`Entradas encontradas: ${entradas.length}`);
-  console.log(`Threshold de similitud: ${threshold}`);
-  console.log('');
-
-  const pares = detectarDuplicados(entradas, threshold);
-  reportarTexto(pares);
-}
-
-if (require.main === module) {
-  main();
-}
-
-module.exports = {
-  parsearEntradas,
-  detectarDuplicados,
-  reportarTexto,
-};
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * detectar-aprendizajes-duplicados.js
+ *
+ * Detecta pares de entradas en `.planning/APRENDIZAJES.md` con alta similitud
+ * de tokens (Jaccard > umbral). Útil para identificar candidatos a fusionar
+ * cuando el hook de auto-extracción genera entradas redundantes.
+ *
+ * Patrón adoptado de `temp/agentmemory-main/src/functions/auto-forget.ts`
+ * (contradiction detection con Jaccard >= 0.9). Aquí se usa con threshold
+ * configurable más bajo (0.6 default) porque queremos sugerir, no auto-borrar.
+ *
+ * NO modifica APRENDIZAJES.md. Solo reporta. La acción de fusión queda en
+ * manos del usuario o de un comando separado (`/swl:aprender consolidar`).
+ *
+ * Uso:
+ *   node scripts/detectar-aprendizajes-duplicados.js [threshold]
+ *
+ * Argumentos:
+ *   threshold  - Similitud mínima para reportar (default: 0.6, rango [0, 1]).
+ *
+ * Exit codes:
+ *   0 - Ejecución OK (haya o no duplicados)
+ *   1 - Error de I/O o parseo
+ *
+ * Output: tabla legible en stdout. Si se detectan ≥ 1 duplicados, también
+ * imprime sugerencia para revisar/consolidar.
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+const { tokenize, jaccard } = require('./lib/jaccard-similarity');
+
+const RUTA_APRENDIZAJES = path.join(process.cwd(), '.planning', 'APRENDIZAJES.md');
+const DEFAULT_THRESHOLD = 0.6;
+const MAX_PARES_REPORTADOS = 30;
+
+function parsearEntradas(contenido) {
+  const lineas = contenido.split('\n');
+  const entradas = [];
+  let actual = null;
+
+  for (let i = 0; i < lineas.length; i++) {
+    const linea = lineas[i];
+    if (linea.startsWith('## ')) {
+      if (actual) entradas.push(actual);
+      actual = {
+        lineaInicio: i + 1,
+        titulo: linea.slice(3).trim(),
+        contenido: '',
+      };
+    } else if (actual) {
+      actual.contenido += linea + '\n';
+    }
+  }
+  if (actual) entradas.push(actual);
+
+  // Filtrar entradas vacías o triviales (< 50 chars de contenido real)
+  return entradas.filter(e => e.contenido.replace(/\s/g, '').length >= 50);
+}
+
+function detectarDuplicados(entradas, threshold) {
+  const tokensCache = entradas.map(e => tokenize(e.titulo + ' ' + e.contenido));
+  const pares = [];
+
+  for (let i = 0; i < entradas.length; i++) {
+    for (let j = i + 1; j < entradas.length; j++) {
+      const sim = jaccard(tokensCache[i], tokensCache[j]);
+      if (sim >= threshold) {
+        pares.push({
+          entradaA: entradas[i],
+          entradaB: entradas[j],
+          similitud: sim,
+        });
+      }
+    }
+  }
+
+  pares.sort((a, b) => b.similitud - a.similitud);
+  return pares;
+}
+
+function reportarTexto(pares) {
+  if (pares.length === 0) {
+    console.log('Sin duplicados detectados sobre el umbral.');
+    return;
+  }
+
+  console.log(`Pares con similitud Jaccard ≥ umbral: ${pares.length}`);
+  console.log('');
+
+  const limite = Math.min(pares.length, MAX_PARES_REPORTADOS);
+  for (let i = 0; i < limite; i++) {
+    const p = pares[i];
+    console.log(`  [${(p.similitud * 100).toFixed(1)}%] ` +
+      `L${p.entradaA.lineaInicio} ↔ L${p.entradaB.lineaInicio}`);
+    console.log('         A: ' + p.entradaA.titulo.slice(0, 80));
+    console.log('         B: ' + p.entradaB.titulo.slice(0, 80));
+    console.log('');
+  }
+
+  if (pares.length > limite) {
+    console.log(`  ... ${pares.length - limite} pares adicionales no mostrados`);
+  }
+
+  console.log('Sugerencia: revisa los pares con mayor similitud y considera ' +
+    'fusionarlos en una sola entrada con `/swl:aprender consolidar` o manualmente.');
+}
+
+function main() {
+  const threshold = parseFloat(process.argv[2]) || DEFAULT_THRESHOLD;
+
+  if (!Number.isFinite(threshold) || threshold < 0 || threshold > 1) {
+    console.error(`Threshold inválido: ${process.argv[2]}. Usar valor en [0, 1].`);
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(RUTA_APRENDIZAJES)) {
+    console.error(`No existe ${RUTA_APRENDIZAJES}.`);
+    process.exit(1);
+  }
+
+  let contenido;
+  try {
+    contenido = fs.readFileSync(RUTA_APRENDIZAJES, 'utf8');
+  } catch (err) {
+    console.error(`Error leyendo ${RUTA_APRENDIZAJES}: ${err.message}`);
+    process.exit(1);
+  }
+
+  const entradas = parsearEntradas(contenido);
+  console.log(`Entradas encontradas: ${entradas.length}`);
+  console.log(`Threshold de similitud: ${threshold}`);
+  console.log('');
+
+  const pares = detectarDuplicados(entradas, threshold);
+  reportarTexto(pares);
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  parsearEntradas,
+  detectarDuplicados,
+  reportarTexto,
+};

package/scripts/doctor.js

@@ -50,6 +50,33 @@ async function doctor(opciones = {}) {
     advertencias++;
   }
 
+  // 0a. Estado del hook automático check-update.js (ADR-0021 opt-in visibility).
+  // Permite al usuario diagnosticar si el hook está ejecutándose correctamente
+  // sin tener que esperar a que aparezca una nueva versión real.
+  try {
+    const os = require('os');
+    // SWL_UPDATE_FLAG_PATH permite a los tests aislar el flag por test (evita
+    // race entre tests paralelos sobre el flag único de producción).
+    const flagPath = process.env.SWL_UPDATE_FLAG_PATH || path.join(os.tmpdir(), 'swl-ses-update-check.json');
+    if (fs.existsSync(flagPath)) {
+      const flag = JSON.parse(fs.readFileSync(flagPath, 'utf8'));
+      const horas = ((Date.now() - flag.timestamp) / 3600000).toFixed(1);
+      const detalle = `local=${flag.local}, remota=${flag.remota || '?'}, hace ${horas}h`;
+      if (flag.hayNueva) {
+        console.log(formatearAdvertencia('Hook check-update', `${detalle} — hay versión nueva pendiente`));
+        advertencias++;
+      } else {
+        console.log(formatearPaso('Hook check-update', detalle));
+        ok++;
+      }
+    } else {
+      console.log(formatearAdvertencia('Hook check-update', 'Sin flag de throttle — el hook nunca se ejecutó en este equipo'));
+      console.log(`    ${color.dim('Diagnóstico: SWL_FORCE_UPDATE_NOTIFICATION=1 + abre Claude Code para forzar una ejecución.')}`);
+      advertencias++;
+    }
+  } catch { /* nunca bloquear el doctor por este check */ }
+  console.log('');
+
   // 0b. Verificar drift entre versionSistema instalado y versión del binario CLI
   //     ejecutándose (bug D v1.3.5).
   //