@saulwade/swl-ses 2.4.3 → 2.5.1

package/scripts/lib/expandir-targets.js

@@ -1,71 +1,71 @@
-'use strict';
-
-/**
- * Expansión de --target (CSV) y --all-runtimes para multi-target install.
- *
- * ADR-0019 Sub-fase 2.5.
- *
- * Extraído de bin/swl-ses.js para permitir tests unitarios. NUNCA debe tener
- * side effects fuera de logging — solo manipula la lista de strings.
- *
- * @module scripts/lib/expandir-targets
- */
-
-const { listarRuntimesInstalables, RUNTIMES } = require('./detectar-runtime');
-
-/**
- * Expande las opciones del CLI a un array de target IDs.
- *
- * Reglas:
- *  - `all_runtimes` tiene prioridad sobre `target`. Si ambos vienen, se loggea
- *    aviso (vía `logger.warn`) y se usa `all_runtimes`.
- *  - `target='a,b,c'` → ['a','b','c'].
- *  - `target='claude'` → ['claude'].
- *  - Sin nada → ['claude'] (default histórico, backward-compat).
- *  - Duplicados se deduplican preservando el primer orden.
- *  - Targets desconocidos se omiten con aviso (logger.warn).
- *
- * @param {object} opciones - Objeto con `target` (string|undefined) y `all_runtimes` (bool).
- * @param {object} [logger] - Sustituible para tests. Default console.
- * @returns {{ targets: string[], omitidos: string[], errores: string[] }}
- */
-function expandirTargets(opciones, logger) {
-  const log = logger || console;
-  const omitidos = [];
-  const errores = [];
-
-  let candidatos;
-  if (opciones.all_runtimes) {
-    if (opciones.target && typeof opciones.target === 'string') {
-      log.warn && log.warn('[expandir-targets] --all-runtimes tiene prioridad sobre --target; se ignora --target.');
-    }
-    candidatos = listarRuntimesInstalables();
-  } else if (typeof opciones.target === 'string' && opciones.target.includes(',')) {
-    candidatos = opciones.target.split(',').map(s => s.trim()).filter(Boolean);
-  } else if (typeof opciones.target === 'string' && opciones.target.length > 0) {
-    candidatos = [opciones.target.trim()];
-  } else {
-    candidatos = ['claude']; // backward-compat
-  }
-
-  const visto = new Set();
-  const targets = [];
-  for (const t of candidatos) {
-    if (visto.has(t)) continue;
-    visto.add(t);
-    if (!RUNTIMES[t]) {
-      log.warn && log.warn(`[expandir-targets] Target desconocido omitido: "${t}". Disponibles: ${Object.keys(RUNTIMES).join(', ')}`);
-      omitidos.push(t);
-      continue;
-    }
-    targets.push(t);
-  }
-
-  if (targets.length === 0) {
-    errores.push('Ningún target válido tras expansión.');
-  }
-
-  return { targets, omitidos, errores };
-}
-
-module.exports = { expandirTargets };
+'use strict';
+
+/**
+ * Expansión de --target (CSV) y --all-runtimes para multi-target install.
+ *
+ * ADR-0019 Sub-fase 2.5.
+ *
+ * Extraído de bin/swl-ses.js para permitir tests unitarios. NUNCA debe tener
+ * side effects fuera de logging — solo manipula la lista de strings.
+ *
+ * @module scripts/lib/expandir-targets
+ */
+
+const { listarRuntimesInstalables, RUNTIMES } = require('./detectar-runtime');
+
+/**
+ * Expande las opciones del CLI a un array de target IDs.
+ *
+ * Reglas:
+ *  - `all_runtimes` tiene prioridad sobre `target`. Si ambos vienen, se loggea
+ *    aviso (vía `logger.warn`) y se usa `all_runtimes`.
+ *  - `target='a,b,c'` → ['a','b','c'].
+ *  - `target='claude'` → ['claude'].
+ *  - Sin nada → ['claude'] (default histórico, backward-compat).
+ *  - Duplicados se deduplican preservando el primer orden.
+ *  - Targets desconocidos se omiten con aviso (logger.warn).
+ *
+ * @param {object} opciones - Objeto con `target` (string|undefined) y `all_runtimes` (bool).
+ * @param {object} [logger] - Sustituible para tests. Default console.
+ * @returns {{ targets: string[], omitidos: string[], errores: string[] }}
+ */
+function expandirTargets(opciones, logger) {
+  const log = logger || console;
+  const omitidos = [];
+  const errores = [];
+
+  let candidatos;
+  if (opciones.all_runtimes) {
+    if (opciones.target && typeof opciones.target === 'string') {
+      log.warn && log.warn('[expandir-targets] --all-runtimes tiene prioridad sobre --target; se ignora --target.');
+    }
+    candidatos = listarRuntimesInstalables();
+  } else if (typeof opciones.target === 'string' && opciones.target.includes(',')) {
+    candidatos = opciones.target.split(',').map(s => s.trim()).filter(Boolean);
+  } else if (typeof opciones.target === 'string' && opciones.target.length > 0) {
+    candidatos = [opciones.target.trim()];
+  } else {
+    candidatos = ['claude']; // backward-compat
+  }
+
+  const visto = new Set();
+  const targets = [];
+  for (const t of candidatos) {
+    if (visto.has(t)) continue;
+    visto.add(t);
+    if (!RUNTIMES[t]) {
+      log.warn && log.warn(`[expandir-targets] Target desconocido omitido: "${t}". Disponibles: ${Object.keys(RUNTIMES).join(', ')}`);
+      omitidos.push(t);
+      continue;
+    }
+    targets.push(t);
+  }
+
+  if (targets.length === 0) {
+    errores.push('Ningún target válido tras expansión.');
+  }
+
+  return { targets, omitidos, errores };
+}
+
+module.exports = { expandirTargets };

package/scripts/lib/frontmatter-md.js

@@ -0,0 +1,63 @@
+'use strict';
+
+/**
+ * frontmatter-md.js — Parser mínimo zero-deps de frontmatter YAML en archivos .md.
+ *
+ * Soporta el subconjunto que usan los componentes SWL:
+ *   - pares `clave: valor` de una línea (comillas opcionales)
+ *   - escalares plegados (`clave: >`, `|`, `>-`, `|-`) juntando las líneas indentadas
+ *   - listas inline (`tools: [Read, Write]`) — se devuelven como string; usar
+ *     `parsearListaInline()` para convertirlas a array
+ *
+ * NO es un parser YAML completo (sin listas multilínea ni objetos anidados) —
+ * suficiente y determinista para frontmatter de agentes/skills/comandos.
+ * Consumidores: scripts/generar-inventario.js, scripts/generar-comandos.js.
+ */
+
+const fs = require('fs');
+
+function leerFrontmatter(ruta) {
+  try {
+    const contenido = fs.readFileSync(ruta, 'utf8');
+    const match = contenido.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match) return {};
+    const fm = {};
+    const lineas = match[1].split(/\r?\n/);
+    for (let i = 0; i < lineas.length; i++) {
+      const linea = lineas[i];
+      if (/^\s/.test(linea)) continue; // continuación de multilínea
+      const idx = linea.indexOf(':');
+      if (idx <= 0) continue;
+      const key = linea.slice(0, idx).trim();
+      let val = linea.slice(idx + 1).trim().replace(/^["']|["']$/g, '');
+      if (val === '>' || val === '|' || val === '>-' || val === '|-' || val === '') {
+        const partes = [];
+        for (let j = i + 1; j < lineas.length && /^\s+\S/.test(lineas[j]); j++) {
+          partes.push(lineas[j].trim());
+        }
+        if (partes.length > 0) val = partes.join(' ');
+      }
+      fm[key] = val;
+    }
+    return fm;
+  } catch { return {}; }
+}
+
+/** `[a, b, c]` → ['a','b','c']; string vacío → []. */
+function parsearListaInline(valor) {
+  return String(valor || '')
+    .replace(/^\[|\]$/g, '')
+    .split(',')
+    .map(s => s.trim())
+    .filter(Boolean);
+}
+
+/** Recorta a n caracteres en límite de palabra, colapsando whitespace y pipes. */
+function resumir(texto, n = 110) {
+  const limpio = String(texto || '').replace(/\s+/g, ' ').replace(/\|/g, '/').trim();
+  if (limpio.length <= n) return limpio;
+  const corte = limpio.lastIndexOf(' ', n);
+  return limpio.slice(0, corte > 40 ? corte : n) + '…';
+}
+
+module.exports = { leerFrontmatter, parsearListaInline, resumir };

package/scripts/lib/parsear-opciones.js

@@ -48,6 +48,8 @@ const BOOLEANAS = [
   // TUI opt-out (Fase 4 instalador visual). Default: si stdin es TTY y no
   // hay flags, lanza el TUI. Con --no-tui cae al install-asistido clásico.
   'no-tui', 'tui',
+  // prune (DT-INSTALADOR-PRUNE): --confirmar ejecuta el plan; --json salida machine-readable
+  'confirmar', 'json',
 ];
 
 /**

package/scripts/lib/prune-componentes.js

@@ -0,0 +1,180 @@
+'use strict';
+
+/**
+ * prune-componentes — Purga de componentes retirados en instalaciones SWL.
+ *
+ * Cierra DT-INSTALADOR-PRUNE: cuando el paquete retira un componente
+ * (skill/agente/comando/regla/hook), las instalaciones existentes lo
+ * conservaban para siempre. Este módulo compara el `.swl-install-state.json`
+ * del destino contra el paquete actual y elimina SOLO lo que cumple las dos
+ * condiciones de seguridad:
+ *
+ *   1. El `origen` registrado ya NO existe en el paquete (componente retirado).
+ *   2. El contenido instalado coincide con un hash canónico conocido del
+ *      componente (manifiestos/canonical-hashes.json, cualquier versión) —
+ *      es contenido de fábrica sin tocar.
+ *
+ * Si el contenido difiere de todo hash canónico conocido (evolución del
+ * usuario) o el componente no tiene hash registrado (p. ej. recursos/ de un
+ * skill), NUNCA se elimina: se reporta como `preservados` para revisión
+ * manual. Invariante merge-no-overwrite (ADR-0040) extendida al borrado.
+ *
+ * API pura respecto de rutas: recibe `rutaBase` (instalación destino) y
+ * `raizPaquete` (paquete fuente actual). El caller (scripts/prune.js) resuelve
+ * ambos; los tests inyectan sandboxes.
+ *
+ * @module scripts/lib/prune-componentes
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { cargarEstado, guardarEstado } = require('./estado.js');
+const { canonicalHash } = require('./canonical-hash.js');
+
+/**
+ * Construye el índice rutaRelativa → Set(hashes canónicos de todas las
+ * versiones) desde manifiestos/canonical-hashes.json del paquete.
+ *
+ * @param {string} raizPaquete
+ * @returns {Map<string, Set<string>>}
+ */
+function cargarHashesConocidos(raizPaquete) {
+  const indice = new Map();
+  try {
+    const ruta = path.join(raizPaquete, 'manifiestos', 'canonical-hashes.json');
+    const porVersion = JSON.parse(fs.readFileSync(ruta, 'utf-8'));
+    for (const version of Object.keys(porVersion)) {
+      const componentes = porVersion[version];
+      if (!componentes || typeof componentes !== 'object') continue;
+      for (const [rutaRel, hash] of Object.entries(componentes)) {
+        const clave = rutaRel.replace(/\\/g, '/');
+        if (!indice.has(clave)) indice.set(clave, new Set());
+        indice.get(clave).add(String(hash));
+      }
+    }
+  } catch { /* sin manifiesto de hashes → índice vacío → todo se preserva */ }
+  return indice;
+}
+
+/**
+ * Clasifica los archivos instalados contra el paquete actual.
+ *
+ * @param {object} opciones
+ * @param {string} opciones.rutaBase     Directorio de la instalación (contiene .swl-install-state.json)
+ * @param {string} opciones.raizPaquete  Raíz del paquete swl-ses actual
+ * @returns {{
+ *   error?: string,
+ *   eliminables: Array<{origen: string, destino: string, tipo: string}>,
+ *   preservados: Array<{origen: string, destino: string, tipo: string, razon: string}>,
+ *   yaAusentes: Array<{origen: string, destino: string}>,
+ *   vigentes: number,
+ * }}
+ */
+function planPrune({ rutaBase, raizPaquete }) {
+  const estado = cargarEstado(rutaBase);
+  if (!estado) {
+    return { error: `No hay .swl-install-state.json en ${rutaBase} — nada que podar.`, eliminables: [], preservados: [], yaAusentes: [], vigentes: 0 };
+  }
+
+  const hashesConocidos = cargarHashesConocidos(raizPaquete);
+  const eliminables = [];
+  const preservados = [];
+  const yaAusentes = [];
+  let vigentes = 0;
+
+  for (const archivo of estado.archivosInstalados || []) {
+    const origenRel = String(archivo.origen || '').replace(/\\/g, '/');
+    if (!origenRel) continue;
+
+    if (fs.existsSync(path.join(raizPaquete, origenRel))) {
+      vigentes++;
+      continue; // el paquete todavía distribuye este componente
+    }
+
+    // Componente retirado del paquete.
+    if (!fs.existsSync(archivo.destino)) {
+      yaAusentes.push({ origen: origenRel, destino: archivo.destino });
+      continue;
+    }
+
+    const hashes = hashesConocidos.get(origenRel);
+    if (!hashes || hashes.size === 0) {
+      preservados.push({
+        origen: origenRel,
+        destino: archivo.destino,
+        tipo: archivo.tipo || '?',
+        razon: 'sin hash canónico registrado — revisar y borrar manualmente si aplica',
+      });
+      continue;
+    }
+
+    let hashLocal;
+    try {
+      hashLocal = canonicalHash(fs.readFileSync(archivo.destino, 'utf-8'));
+    } catch {
+      preservados.push({ origen: origenRel, destino: archivo.destino, tipo: archivo.tipo || '?', razon: 'destino ilegible' });
+      continue;
+    }
+
+    if (hashes.has(hashLocal)) {
+      eliminables.push({ origen: origenRel, destino: archivo.destino, tipo: archivo.tipo || '?' });
+    } else {
+      preservados.push({
+        origen: origenRel,
+        destino: archivo.destino,
+        tipo: archivo.tipo || '?',
+        razon: 'contenido evolucionado por el usuario (hash ≠ canónico) — merge-no-overwrite',
+      });
+    }
+  }
+
+  return { eliminables, preservados, yaAusentes, vigentes };
+}
+
+/**
+ * Ejecuta el plan: borra los eliminables, limpia del estado las entradas
+ * eliminadas y las ya ausentes, y persiste el estado actualizado.
+ *
+ * @param {object} plan        Resultado de planPrune
+ * @param {object} opciones
+ * @param {string} opciones.rutaBase
+ * @returns {{eliminados: string[], erroresBorrado: Array<{destino: string, error: string}>, entradasLimpiadas: number}}
+ */
+function ejecutarPrune(plan, { rutaBase }) {
+  const eliminados = [];
+  const erroresBorrado = [];
+
+  for (const item of plan.eliminables) {
+    try {
+      fs.unlinkSync(item.destino);
+      eliminados.push(item.destino);
+      // Si el directorio del skill quedó vacío (p. ej. habilidades/x/), retirarlo.
+      const dir = path.dirname(item.destino);
+      try {
+        if (fs.readdirSync(dir).length === 0) fs.rmdirSync(dir);
+      } catch { /* dir compartido o ya ausente — irrelevante */ }
+    } catch (err) {
+      erroresBorrado.push({ destino: item.destino, error: err.message });
+    }
+  }
+
+  // Limpiar el estado: fuera las entradas eliminadas y las ya ausentes.
+  const estado = cargarEstado(rutaBase);
+  let entradasLimpiadas = 0;
+  if (estado) {
+    const quitar = new Set([
+      ...eliminados,
+      ...plan.yaAusentes.map(a => a.destino),
+    ]);
+    const antes = estado.archivosInstalados.length;
+    estado.archivosInstalados = estado.archivosInstalados.filter(a => !quitar.has(a.destino));
+    entradasLimpiadas = antes - estado.archivosInstalados.length;
+    estado.actualizadoEn = new Date().toISOString();
+    guardarEstado(estado, rutaBase);
+  }
+
+  return { eliminados, erroresBorrado, entradasLimpiadas };
+}
+
+module.exports = { planPrune, ejecutarPrune, cargarHashesConocidos };

package/scripts/lib/reglas-globales-conocidas.json

@@ -1,8 +1,8 @@
 {
   "$schema-version": "1.0.0",
   "description": "Catálogo de reglas globales ~/.claude/rules/ que NO deben duplicarse inline en CLAUDE.md de proyectos. Consumido por scripts/lib/detector-reglas-duplicadas.js y por scripts/auditar-claudemd.js dimensión 'duplicacion-reglas-globales'. Cada entrada lista: nombre canónico, archivo origen, sección canónica para referenciar, patrones de detección (regex), y reemplazo sugerido.",
-  "version": "1.1.0",
-  "actualizado": "2026-05-22",
+  "version": "1.2.0",
+  "actualizado": "2026-07-08",
   "reglas": [
     {
       "id": "idioma-espanol-mexico",
@@ -168,6 +168,20 @@
       "min_matches": 1,
       "scope": "project-level",
       "remediacion_sugerida": "Eliminar el bloque local. La regla global aplica a cualquier proyecto con vault Obsidian disponible."
+    },
+    {
+      "id": "usar-code-review-graph",
+      "regla_global": "usar-code-review-graph.md",
+      "seccion_canonica": "Usar code-review-graph antes de Read/Grep/Glob para explorar",
+      "referencia_canonica": "@~/.claude/rules/usar-code-review-graph.md",
+      "descripcion": "Comportamiento completo del MCP code-review-graph (tabla de herramientas, workflow, excepciones). El CLAUDE.md del proyecto solo declara la disponibilidad del grafo — re-derivar el comportamiento inline es duplicación. Caso real: CLAUDE.md de swl-ses acumuló 37 líneas re-derivándolo en inglés (removido 2026-07-08).",
+      "patrones": [
+        "ALWAYS use thes+code-review-graph",
+        "code-review-graph MCP tools BEFORE",
+        "graph tools FIRST",
+        "detect_changes.*get_review_context|get_impact_radius.*blast radius"
+      ],
+      "remediacion_sugerida": "Una línea en Stack: 'MCP del proyecto: code-review-graph disponible vía .mcp.json. Comportamiento: @~/.claude/rules/usar-code-review-graph.md'"
     }
   ],
   "configuracion": {

package/scripts/lib/scoring-instintos.js

@@ -203,8 +203,8 @@ function applyFeedback(instinto, type, currentDate) {
     throw new Error(`Tipo de feedback inválido: ${type}`);
   }
   const now = (currentDate instanceof Date)
-    ? currentDate.toISOString().slice(0, 10)
-    : (currentDate || new Date().toISOString().slice(0, 10));
+    ? currentDate.toLocaleDateString('sv')
+    : (currentDate || new Date().toLocaleDateString('sv'));
 
   const next = { ...instinto };
   if (type === 'helpful') next.helpful_count = (next.helpful_count || 0) + 1;