@saulwade/swl-ses 2.6.1 → 2.8.0

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

@@ -168,41 +168,41 @@ async function doctor(opciones = {}) {
     advertencias++;
   }
 
-  // C-2: doctor DIAGNOSTICA; no siembra dirs de proyecto (.planning/_userland)
-  // en un cwd que no es un proyecto swl. Correr `doctor` desde un directorio
-  // cualquiera no debe generar clutter. Marcadores de proyecto: .planning/ o
-  // _userland/ ya presentes, o un install-state de scope proyecto.
-  //
-  // El HOME es la EXCEPCIÓN: un install global crea ~/_userland ahí, pero el
-  // HOME NO es un proyecto — doctor no debe sembrar ~/.planning/ (bug 2026-07-15:
-  // sembraba un scaffold espurio y los hooks volcaban telemetría en el HOME vía
-  // raiz-proyecto). Ver scripts/lib/limpiar-basura-global.js.
-  const { esPlanningEspurio, esUserlandVacio, limpiarBasuraGlobal } = require('./lib/limpiar-basura-global');
-  const esHome = path.resolve(cwd) === path.resolve(require('os').homedir());
-  const esProyectoSwl = !esHome && (
-    fs.existsSync(path.join(cwd, '.planning')) ||
-    fs.existsSync(path.join(cwd, '_userland')) ||
-    fs.existsSync(path.join(cwd, '.swl-install-state.json'))
-  );
-
-  // 3. Verificar .planning/
+  // C-2: doctor DIAGNOSTICA según la CLASE del directorio (clasificar-directorio):
+  //  - 'home'     : ubicación de una instalación global, NUNCA un proyecto. Un
+  //                 ~/.planning (backups del install, scaffold de doctor,
+  //                 telemetría mal dirigida) o ~/_userland vacío es basura →
+  //                 OFRECER eliminar, jamás scaffoldear marcadores.
+  //  - 'proyecto' : proyecto de desarrollo real (.git/stack/.planning) →
+  //                 verificar/reparar/inicializar la estructura .planning.
+  //  - 'nuevo'/'otro' : no scaffoldear a ciegas — "No aplica".
+  // Origen del rediseño (bug 2026-07-15): `install --global` desde el HOME
+  // sembraba ~/.planning/backups y doctor ofrecía scaffoldear marcadores ahí.
+  const { clasificarDirectorio } = require('./lib/clasificar-directorio');
+  const { esUserlandVacio, esPlanningRemovibleEnHome, limpiarBasuraGlobal } = require('./lib/limpiar-basura-global');
+  const claseDir = clasificarDirectorio(cwd);
+  const esProyectoSwl = claseDir === 'proyecto'; // consumido también por la sección 4 (_userland)
+
+  // 3. Verificar .planning/ según la clase del directorio
   const planningDir = path.join(cwd, '.planning');
-  const basuraHome = [];
-  if (esHome && esPlanningEspurio(cwd)) basuraHome.push('~/.planning (scaffold de doctor)');
-  if (esHome && esUserlandVacio(cwd)) basuraHome.push('~/_userland (vacío)');
-  if (basuraHome.length > 0) {
-    // Basura de instalación global en el HOME: NO "reparar" (el HOME no es un
-    // proyecto) — OFRECER eliminarla. Ver scripts/lib/limpiar-basura-global.js.
-    console.log(formatearAdvertencia('instalación global', `Directorios basura en el HOME: ${basuraHome.join(', ')} — el HOME no es un proyecto`));
-    advertencias++;
-    reparables.push({
-      descripcion: `Eliminar ${basuraHome.length} directorio(s) basura del HOME: ${basuraHome.join(', ')}`,
-      reparar: () => {
-        const r = limpiarBasuraGlobal({ home: cwd });
-        return r.eliminados.length ? `Eliminado: ${r.eliminados.join(', ')}` : 'Nada que eliminar';
-      },
-    });
-  } else if (fs.existsSync(planningDir)) {
+  if (claseDir === 'home') {
+    const basura = [];
+    if (esPlanningRemovibleEnHome(cwd)) basura.push('~/.planning');
+    if (esUserlandVacio(cwd)) basura.push('~/_userland (vacío)');
+    if (basura.length > 0) {
+      console.log(formatearAdvertencia('instalación global', `Directorios basura en el HOME: ${basura.join(', ')} — el HOME no es un proyecto`));
+      advertencias++;
+      reparables.push({
+        descripcion: `Eliminar del HOME: ${basura.join(', ')}`,
+        reparar: () => {
+          const r = limpiarBasuraGlobal({ home: cwd });
+          return r.eliminados.length ? `Eliminado: ${r.eliminados.join(', ')}` : 'Nada que eliminar';
+        },
+      });
+    } else {
+      console.log(formatearPaso('.planning/', 'No aplica — el HOME es la ubicación de instalación global, no un proyecto'));
+    }
+  } else if (claseDir === 'proyecto' && fs.existsSync(planningDir)) {
     const archivosEsperados = ['PROYECTO.md', 'REQUISITOS.md', 'HOJA-RUTA.md', 'ESTADO.md'];
     const faltantes = archivosEsperados.filter(
       f => !fs.existsSync(path.join(planningDir, f))
@@ -261,9 +261,10 @@ async function doctor(opciones = {}) {
     });
   }
 
-  // 4. Verificar _userland/
+  // 4. Verificar _userland/ (solo relevante en un proyecto de desarrollo; en el
+  //    HOME un _userland vacío ya se ofreció eliminar en la sección 3).
   const userlandDir = path.join(cwd, '_userland');
-  if (fs.existsSync(userlandDir)) {
+  if (claseDir === 'proyecto' && fs.existsSync(userlandDir)) {
     console.log(formatearPaso('_userland/', 'Presente'));
     ok++;
 
@@ -694,6 +695,30 @@ async function doctor(opciones = {}) {
     }
   }
 
+  // X. Diagnóstico Core-3 (Claude Code, Codex CLI, Gemini CLI) — F31-T07.
+  // Puramente informativo: read-only, best-effort, nunca repara ni evalúa
+  // canarios conductuales. Disponibilidad != certificación (ADR-0047); por
+  // eso no suma a ok/advertencias/errores — un runtime experimental ausente
+  // no es un problema de instalación de SWL.
+  try {
+    const { diagnosticarCore3 } = require('./lib/runtime-doctor-core3');
+    const { pathEntriesFromEnv, emptyRuntimeMap } = require('./lib/runtime-doctor-input');
+    const diagnosticoCore3 = await diagnosticarCore3({
+      now: new Date().toISOString(),
+      pathEntries: pathEntriesFromEnv(),
+      bundles: emptyRuntimeMap(),
+      buildEvents: emptyRuntimeMap(),
+    });
+    console.log(formatearPaso('Runtimes Core-3', 'experimental/unverified — `swl-ses runtime-doctor --json` para detalle'));
+    for (const runtime of diagnosticoCore3.runtimes) {
+      const detalle = runtime.availability.status === 'available'
+        ? `available v${runtime.availability.version}`
+        : runtime.availability.status;
+      console.log(`      ${color.dim(`${runtime.runtimeId}: ${detalle}`)}`);
+    }
+    console.log('');
+  } catch { /* nunca bloquear el doctor por este check */ }
+
   // Reporte final
   console.log('');
   console.log(`  ${lineaSeparadora()}`);