@saulwade/swl-ses 1.3.4 → 1.3.5

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,55 @@ async function doctor(opciones = {}) {
     advertencias++;
   }
 
+  // 0b. Verificar drift entre versionSistema instalado y versión del binario CLI
+  //     ejecutándose (bug D v1.3.5).
+  //
+  // El check de la sección 0 solo compara VERSION (binario) vs versionRemota (npm).
+  // Pero existe otro drift: la versión instalada físicamente en ~/.claude/ (de un
+  // install previo) puede estar por debajo del binario CLI ejecutándose. En ese
+  // caso `update` no detecta nada porque VERSION === versionRemota, mientras
+  // `versionSistema` del install-state se queda atrás y los archivos copiados
+  // a destino mantienen contenido de la versión vieja.
+  //
+  // Síntoma del usuario: `/swl:claudemd` falla porque ~/.claude/commands/swl/
+  // claudemd.md tiene `node scripts/X.js` (patrón v1.3.2) mientras el binario
+  // CLI ya es v1.3.4 y los slash commands de v1.3.3+ usan subcomandos del CLI.
+  const driftsDetectados = [];
+  try {
+    const runtimesParaDrift = detectarRuntimes();
+    for (const runtime of runtimesParaDrift) {
+      for (const dir of [runtime.global, path.resolve(runtime.local)]) {
+        if (!fs.existsSync(dir)) continue;
+        const estado = cargarEstado(dir);
+        if (!estado || !estado.versionSistema) continue;
+
+        if (estado.versionSistema !== VERSION) {
+          driftsDetectados.push({
+            runtime: runtime.nombre,
+            runtimeId: runtime.id,
+            scope: dir === runtime.global ? 'global' : 'proyecto',
+            dir,
+            versionInstalada: estado.versionSistema,
+            perfil: estado.perfil || 'desconocido',
+          });
+        }
+      }
+    }
+  } catch { /* nunca bloquear el doctor por este check */ }
+
+  if (driftsDetectados.length > 0) {
+    for (const drift of driftsDetectados) {
+      console.log(formatearAdvertencia(
+        `Drift ${drift.runtime}`,
+        `Binario CLI v${VERSION}, pero ${drift.scope} instalado en v${drift.versionInstalada}`
+      ));
+      console.log(`    ${color.dim('Los archivos en disco pueden tener contenido viejo aunque el binario sea nuevo.')}`);
+      console.log(`    ${color.dim('Para sincronizar:')} ${color.amarillo(`npx @saulwade/swl-ses@latest install --${drift.scope === 'global' ? 'global' : 'local'} --profile ${drift.perfil} --force`)}`);
+      advertencias++;
+    }
+    console.log('');
+  }
+
   // 1. Verificar Node.js
   const nodeVersion = process.version;
   const major = parseInt(nodeVersion.slice(1).split('.')[0], 10);
@@ -272,9 +321,11 @@ async function doctor(opciones = {}) {
     advertencias++;
   }
 
-  // 5b-2. Verificar conteo de componentes contra perfil esperado
+  // 5b-2. Verificar conteo de componentes contra perfil esperado.
+  // Bug H v1.3.5: antes solo verificaba runtime.local; instalaciones globales
+  // (~/.claude/) quedaban sin check de conteo. Ahora itera ambos scopes.
   for (const runtime of runtimes) {
-    const dir = path.resolve(runtime.local);
+    for (const dir of [runtime.global, path.resolve(runtime.local)]) {
     if (!fs.existsSync(dir)) continue;
     const estado = cargarEstado(dir);
     if (!estado || !estado.perfil) continue;
@@ -310,12 +361,25 @@ async function doctor(opciones = {}) {
 
       // Comparar tipos principales
       const discrepancias = [];
+      const excedentes = [];
       for (const [tipo, esperado] of Object.entries(esperadosPorTipo)) {
         const instalado = instaladosPorTipo[tipo] || 0;
         if (instalado < esperado) {
           discrepancias.push(`${tipo}: ${instalado}/${esperado}`);
         }
       }
+      // Bug E v1.3.5: detectar excedente — archivos del perfil completo que
+      // quedaron tras un cambio de perfil (ej: completo → core sin uninstall
+      // previo). El install no los borra, así que conviven con contenido viejo
+      // hasta que un install con el perfil correcto los sobreescriba. Sin
+      // esta advertencia, el usuario veía "Sistema en perfecto estado" mientras
+      // commands/swl/claudemd.md (parte de completo) seguía con contenido v1.3.2.
+      for (const [tipo, instalado] of Object.entries(instaladosPorTipo)) {
+        const esperado = esperadosPorTipo[tipo] || 0;
+        if (instalado > esperado) {
+          excedentes.push(`${tipo}: ${instalado} (perfil esperaba ${esperado})`);
+        }
+      }
 
       const totalEsperado = resolucion.archivos.length;
       const totalInstalado = estado.archivosInstalados.length;
@@ -323,9 +387,18 @@ async function doctor(opciones = {}) {
         .map(([t, n]) => `${instaladosPorTipo[t] || 0}/${n} ${t}`)
         .join(', ');
 
-      if (discrepancias.length === 0) {
+      if (discrepancias.length === 0 && excedentes.length === 0) {
         console.log(formatearPaso(`Conteo ${runtime.nombre}`, `${totalInstalado} archivos (${detalle})`));
         ok++;
+      } else if (excedentes.length > 0 && discrepancias.length === 0) {
+        console.log(formatearAdvertencia(
+          `Conteo ${runtime.nombre}`,
+          `${totalInstalado} archivos — excedente del perfil ${estado.perfil}: ${excedentes.join(', ')}`
+        ));
+        console.log(`    ${color.dim('Posible residuo de instalación previa con perfil más amplio.')}`);
+        console.log(`    ${color.dim('Sugerencia: si el perfil declarado es correcto, desinstala primero y reinstala limpio:')}`);
+        console.log(`      ${color.dim(`swl-ses uninstall${estado.global ? ' --global' : ''} && swl-ses install --profile ${estado.perfil}${estado.global ? ' --global' : ''}`)}`);
+        advertencias++;
       } else {
         console.log(formatearAdvertencia(`Conteo ${runtime.nombre}`, `${totalInstalado} archivos — faltan: ${discrepancias.join(', ')}`));
         advertencias++;
@@ -348,6 +421,7 @@ async function doctor(opciones = {}) {
       console.log(formatearAdvertencia(`Conteo ${runtime.nombre}`, `No se pudo verificar: ${err.message}`));
       advertencias++;
     }
+    }
   }
 
   // 5c. Verificar optimizaciones de rendimiento en settings.json