@saulwade/swl-ses 1.5.0 → 1.5.2

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).
   //
@@ -324,8 +351,14 @@ async function doctor(opciones = {}) {
   // 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.
+  // Sub-fase 12 v1.5.0: deduplicar paths cuando cwd === homedir (runtime.local
+  // y runtime.global colapsan al mismo directorio) — evita reporte doble.
   for (const runtime of runtimes) {
-    for (const dir of [runtime.global, path.resolve(runtime.local)]) {
+    const dirsUnicos = Array.from(new Set([
+      path.resolve(runtime.global),
+      path.resolve(runtime.local),
+    ]));
+    for (const dir of dirsUnicos) {
     if (!fs.existsSync(dir)) continue;
     const estado = cargarEstado(dir);
     if (!estado || !estado.perfil) continue;
@@ -367,8 +400,21 @@ async function doctor(opciones = {}) {
         resolucion.archivos = filtrado.archivos;
       }
 
-      // Contar esperados por tipo (solo tipos principales)
-      const tiposPrincipales = ['agentes', 'habilidades', 'comandos', 'reglas'];
+      // Sub-fase 12 v1.5.0: filtrar tipos principales por runtime.tiposSoportados
+      // Y por la presencia de `dir<Tipo>` no-null. Codex declara `reglas` en
+      // tiposSoportados pero las consolida en AGENTS.md (dirReglas: null) — los
+      // archivos individuales no existen aunque el resolver los liste como esperados.
+      // Reportar "faltan reglas: 0/N" en ese caso es falso positivo que dispara
+      // loop infinito de auto-reparación.
+      const TIPO_A_DIR = {
+        agentes: 'dirAgentes',
+        habilidades: 'dirHabilidades',
+        comandos: 'dirComandos',
+        reglas: 'dirReglas',
+      };
+      const tiposPrincipales = ['agentes', 'habilidades', 'comandos', 'reglas']
+        .filter(t => !runtime.tiposSoportados || runtime.tiposSoportados.includes(t))
+        .filter(t => runtime[TIPO_A_DIR[t]]);
       const esperadosPorTipo = {};
       for (const archivo of resolucion.archivos) {
         const tipo = archivo.tipo || 'otros';
@@ -451,8 +497,16 @@ async function doctor(opciones = {}) {
     }
   }
 
-  // 5c. Verificar optimizaciones de rendimiento en settings.json
+  // 5c. Verificar optimizaciones de rendimiento en settings.json.
+  // Sub-fase 12 v1.5.0: las optimizaciones `ENABLE_TOOL_SEARCH` y
+  // `showThinkingSummaries` son específicas de Claude Code `settings.json`.
+  // Codex usa `config.toml` con schema TOML; Cursor usa schema propio.
+  // Aplicar estas claves a Codex/Cursor poluciona su config con keys que
+  // no tienen efecto. Restringir el check al runtime claude/openclaude.
+  const RUNTIMES_CON_OPTIMIZACIONES = new Set(['claude', 'openclaude']);
   for (const runtime of runtimes) {
+    if (!RUNTIMES_CON_OPTIMIZACIONES.has(runtime.id)) continue;
+
     const dir = path.resolve(runtime.local);
     if (!fs.existsSync(dir)) continue;
     const estado = cargarEstado(dir);