@saulwade/swl-ses 1.7.0 → 1.7.2

package/scripts/auditar-claudemd.js

@@ -40,6 +40,15 @@ function cargarDetectorReglasDuplicadas() {
   }
 }
 
+// Dimensión 9 (v1.7.2): auto-duplicación intra-archivo. Lazy igual que dim 8.
+function cargarDetectorAutoduplicacion() {
+  try {
+    return require('./lib/detector-autoduplicacion-intra-archivo').detectarAutoduplicacionIntraArchivo;
+  } catch (_) {
+    return null;
+  }
+}
+
 // ─── Config ───────────────────────────────────────────────────────────────
 const MAX_LINES = parseInt(process.env.SWL_CLAUDEMD_MAX_LINES, 10) || 200;
 const MAX_BULLET_CHARS =
@@ -188,6 +197,30 @@ function auditar(rutaClaudeMd) {
     }
   }
 
+  // 8. Dimensión 9 (v1.7.2): auto-duplicación intra-archivo. 2+ secciones H2
+  //    del mismo CLAUDE.md citando la misma regla global con prosa (no tabla
+  //    ni @-reference standalone) → boilerplate redundante.
+  let resultadoAutoduplicacion = { evaluado: false, autoduplicaciones: [], total_secciones: 0 };
+  const detectarAutoduplicacion = cargarDetectorAutoduplicacion();
+  if (detectarAutoduplicacion) {
+    try {
+      resultadoAutoduplicacion = detectarAutoduplicacion(contenido, {
+        esUserLevel: !esProjectLevel,
+      });
+      for (const dup of resultadoAutoduplicacion.autoduplicaciones) {
+        hallazgos.push({
+          severidad: dup.severidad || 'WARN',
+          regla: 'autoduplicacion-intra-archivo',
+          mensaje: `${dup.cantidad_secciones} secciones citan la misma regla global \`${dup.regla_global}\`: ${dup.secciones.map(s => `"${s.titulo}" (L${s.linea})`).join(', ')}`,
+          sugerencia: dup.remediacion,
+          referencia_canonica: dup.referencia_canonica,
+        });
+      }
+    } catch (e) {
+      // Falla silenciosa: no bloquea la auditoría.
+    }
+  }
+
   // ─── Veredicto ───────────────────────────────────────────────────────────
   const tieneError = hallazgos.some(h => h.severidad === 'ERROR');
   const tieneWarn = hallazgos.some(h => h.severidad === 'WARN');
@@ -212,6 +245,12 @@ function auditar(rutaClaudeMd) {
         detectadas: resultadoDuplicaciones.duplicaciones.length,
         ids: resultadoDuplicaciones.duplicaciones.map(d => d.id),
       },
+      autoduplicacion_intra_archivo: {
+        evaluado: resultadoAutoduplicacion.evaluado,
+        total_secciones: resultadoAutoduplicacion.total_secciones,
+        detectadas: resultadoAutoduplicacion.autoduplicaciones.length,
+        ids: resultadoAutoduplicacion.autoduplicaciones.map(d => d.id),
+      },
     },
     hallazgos,
   };
@@ -343,6 +382,10 @@ function imprimirReporte(resultado) {
       const d = m.duplicaciones_reglas_globales;
       console.log(`  - Duplicaciones de reglas globales: ${d.detectadas}/${d.total_reglas_evaluadas} reglas duplicadas${d.detectadas > 0 ? ' (' + d.ids.join(', ') + ')' : ''}`);
     }
+    if (m.autoduplicacion_intra_archivo && m.autoduplicacion_intra_archivo.evaluado) {
+      const a = m.autoduplicacion_intra_archivo;
+      console.log(`  - Auto-duplicación intra-archivo: ${a.detectadas} regla(s) citada(s) en 2+ secciones del mismo CLAUDE.md${a.detectadas > 0 ? ' (' + a.ids.join(', ') + ')' : ''}`);
+    }
     console.log('');
   }
 
@@ -400,4 +443,5 @@ module.exports = {
   KARPATHY_MIN_LINES,
   // Re-export lazy del detector (puede ser null si lib/ no está disponible):
   cargarDetectorReglasDuplicadas,
+  cargarDetectorAutoduplicacion,
 };

package/scripts/lib/detector-autoduplicacion-intra-archivo.js

@@ -0,0 +1,234 @@
+'use strict';
+
+/**
+ * scripts/lib/detector-autoduplicacion-intra-archivo.js
+ *
+ * Dimensión 9 del auditor CLAUDE.md (v1.7.2). Detecta auto-duplicación
+ * INTRA-archivo: cuando 2+ secciones H2 del mismo CLAUDE.md citan el
+ * mismo archivo de regla global de ~/.claude/rules/. Complementa la
+ * dimensión 8 (detector-reglas-duplicadas.js) que detecta duplicación
+ * INTER-archivo (paráfrasis de regla global).
+ *
+ * Caso de uso típico:
+ *   ## Reglas obligatorias
+ *   ...referencia a usar-sistema-swl.md...
+ *
+ *   ## Flujo de trabajo
+ *   ...referencia a usar-sistema-swl.md + matiz local...
+ *
+ * Diagnóstico: ambas secciones citan la misma regla. Una probablemente
+ * es boilerplate sin contenido propio; consolidar en UNA sola sección
+ * con referencia + matiz local (si lo hay).
+ *
+ * Excepciones (no cuenta como duplicación):
+ *   - Citas dentro de tabla Markdown (catálogo organizado intencional):
+ *     `| usar-sistema-swl.md | Siempre — matriz operacional |`
+ *   - Archivos < 20 LOC.
+ *   - User-level (~/.claude/CLAUDE.md): preferencias personales aceptadas.
+ *
+ * Public API:
+ *   detectarAutoduplicacionIntraArchivo(contenido, opciones) → { autoduplicaciones }
+ *   parsearSeccionesH2(contenido) → [{titulo, lineaInicio, contenido, fin}]
+ *
+ * Zero-dependency (solo fs/path).
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const RUTA_CATALOGO_DEFAULT = path.join(__dirname, 'reglas-globales-conocidas.json');
+
+function cargarCatalogo(rutaJson = RUTA_CATALOGO_DEFAULT) {
+  if (!fs.existsSync(rutaJson)) {
+    throw new Error(`Catálogo no encontrado: ${rutaJson}`);
+  }
+  return JSON.parse(fs.readFileSync(rutaJson, 'utf8'));
+}
+
+/**
+ * Parsea el contenido en secciones H2 (encabezados `## `). Cada sección
+ * incluye todo el contenido hasta el siguiente H2 (o EOF), incluyendo
+ * sub-secciones H3/H4 anidadas.
+ *
+ * Sección virtual "preludio" si el archivo tiene contenido antes del
+ * primer H2 (típicamente H1 + descripción).
+ *
+ * @returns {Array} secciones con {titulo, lineaInicio, lineaFin, contenido}
+ */
+function parsearSeccionesH2(contenido) {
+  const lineas = contenido.split(/\r?\n/);
+  const secciones = [];
+  let actual = {
+    titulo: '__preludio__',
+    lineaInicio: 1,
+    inicio: 0,
+    fin: null,
+    contenido: '',
+  };
+
+  for (let i = 0; i < lineas.length; i++) {
+    const linea = lineas[i];
+    // H2 exacto (## seguido de espacio, NO ### ni más)
+    const matchH2 = linea.match(/^##\s+(?!#)(.+?)\s*$/);
+    if (matchH2) {
+      // cerrar la sección actual antes de abrir la nueva
+      actual.fin = i;
+      actual.contenido = lineas.slice(actual.inicio, actual.fin).join('\n');
+      if (actual.titulo !== '__preludio__' || actual.contenido.trim().length > 0) {
+        secciones.push(actual);
+      }
+      actual = {
+        titulo: matchH2[1].trim(),
+        lineaInicio: i + 1,
+        inicio: i,
+        fin: null,
+        contenido: '',
+      };
+    }
+  }
+  // cerrar última sección
+  actual.fin = lineas.length;
+  actual.contenido = lineas.slice(actual.inicio, actual.fin).join('\n');
+  if (actual.titulo !== '__preludio__' || actual.contenido.trim().length > 0) {
+    secciones.push(actual);
+  }
+  return secciones;
+}
+
+/**
+ * Verifica si TODAS las menciones del archivo de regla en una sección
+ * están dentro de patrones excluidos (no son prosa boilerplate). Si todas
+ * están excluidas, la sección NO cuenta como mención sustantiva.
+ *
+ * Patrones excluidos:
+ *   1. Mención dentro de tabla Markdown (línea empieza con `|`)
+ *      → catálogo organizado intencional, no boilerplate
+ *   2. Mención como @-reference standalone (línea entera es `@path/X.md`)
+ *      → @-include que carga el contenido de la regla, no descripción
+ *
+ * Una sección con todas sus menciones excluidas se considera "catálogo o
+ * include" y no entra en el conteo de auto-duplicación intra-archivo.
+ */
+function todasLasMencionesEstanExcluidas(seccionContenido, reglaArchivo) {
+  const lineas = seccionContenido.split(/\r?\n/);
+  let totalMenciones = 0;
+  let mencionesExcluidas = 0;
+  const reFilename = new RegExp('\\b' + escapeRegex(reglaArchivo), 'i');
+
+  for (const linea of lineas) {
+    if (!reFilename.test(linea)) continue;
+    totalMenciones++;
+    const trimmed = linea.trim();
+    // Excepción 1: línea de tabla Markdown
+    if (/^\|/.test(trimmed)) {
+      mencionesExcluidas++;
+      continue;
+    }
+    // Excepción 2: @-reference standalone (línea entera es @path/X.md)
+    if (/^@[\w./~\-]+\.md\s*$/.test(trimmed)) {
+      mencionesExcluidas++;
+      continue;
+    }
+  }
+  return totalMenciones > 0 && mencionesExcluidas === totalMenciones;
+}
+
+/**
+ * Detecta auto-duplicación intra-archivo.
+ *
+ * @param {string} contenido - CLAUDE.md completo
+ * @param {object} [opciones]
+ * @param {boolean} [opciones.skipUserLevel=true]
+ * @param {boolean} [opciones.esUserLevel=false]
+ * @param {object} [opciones.catalogo] - catálogo precargado (opcional)
+ * @returns {object} { evaluado, autoduplicaciones, total_secciones }
+ */
+function detectarAutoduplicacionIntraArchivo(contenido, opciones = {}) {
+  const skipUserLevel = opciones.skipUserLevel !== false;
+  const esUserLevel = opciones.esUserLevel === true;
+
+  if (skipUserLevel && esUserLevel) {
+    return {
+      evaluado: false,
+      razon: 'user-level — no evaluado',
+      autoduplicaciones: [],
+      total_secciones: 0,
+    };
+  }
+
+  const catalogo = opciones.catalogo || cargarCatalogo();
+  const minLineas = catalogo.configuracion?.min_lineas_archivo ?? 20;
+  const lineas = contenido.split(/\r?\n/);
+
+  if (lineas.length < minLineas) {
+    return {
+      evaluado: false,
+      razon: `archivo < ${minLineas} LOC — no acumula auto-duplicaciones`,
+      autoduplicaciones: [],
+      total_secciones: 0,
+    };
+  }
+
+  const secciones = parsearSeccionesH2(contenido);
+
+  if (secciones.length < 2) {
+    return {
+      evaluado: true,
+      autoduplicaciones: [],
+      total_secciones: secciones.length,
+    };
+  }
+
+  const autoduplicaciones = [];
+
+  for (const regla of catalogo.reglas) {
+    const reFilename = new RegExp('\\b' + escapeRegex(regla.regla_global), 'i');
+    const seccionesQueLaCitan = [];
+
+    for (const sec of secciones) {
+      if (!reFilename.test(sec.contenido)) continue;
+      // Excluir si TODAS las menciones en esta sección están en tabla
+      if (todasLasMencionesEstanExcluidas(sec.contenido, regla.regla_global)) continue;
+      seccionesQueLaCitan.push({
+        titulo: sec.titulo,
+        linea: sec.lineaInicio,
+      });
+    }
+
+    if (seccionesQueLaCitan.length >= 2) {
+      autoduplicaciones.push({
+        id: regla.id,
+        regla_global: regla.regla_global,
+        referencia_canonica: regla.referencia_canonica,
+        secciones: seccionesQueLaCitan,
+        cantidad_secciones: seccionesQueLaCitan.length,
+        remediacion:
+          `${seccionesQueLaCitan.length} secciones del mismo CLAUDE.md citan ` +
+          `\`${regla.regla_global}\`: ${seccionesQueLaCitan.map(s => `"${s.titulo}" (L${s.linea})`).join(', ')}. ` +
+          `Consolidar en UNA sola sección con referencia canónica + matiz local ` +
+          `(si lo hay). Si ninguna sección agrega matiz operacional propio sobre ` +
+          `la regla global, eliminar todas menos una.`,
+        severidad: catalogo.configuracion?.severidad_default || 'WARN',
+      });
+    }
+  }
+
+  return {
+    evaluado: true,
+    autoduplicaciones,
+    total_secciones: secciones.length,
+  };
+}
+
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+module.exports = {
+  cargarCatalogo,
+  parsearSeccionesH2,
+  detectarAutoduplicacionIntraArchivo,
+  // exports privados para tests
+  _todasLasMencionesEstanExcluidas: todasLasMencionesEstanExcluidas,
+  RUTA_CATALOGO_DEFAULT,
+};

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

@@ -1,7 +1,7 @@
 {
   "$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.0.0",
+  "version": "1.1.0",
   "actualizado": "2026-05-22",
   "reglas": [
     {
@@ -17,7 +17,7 @@
         "\\bgram[aá]tica\\s+normativa\\b",
         "\\bevitar\\s+anglicismos\\b",
         "^\\s*#+\\s*Language\\s*$",
-        "\\bdomain\\s+terms\\b.*\\bin\\s+\\*?\\*?Spanish\\*?\\*?",
+        "\\bdomain\\s+terms\\b.*\\bin\\s+\\*?\\*?Spanish\\b",
         "\\bmensajes?\\s+de\\s+commit.*siempre\\s+en\\s+español\\b"
       ],
       "min_matches": 2,
@@ -48,9 +48,10 @@
       "descripcion": "Los commits NO deben incluir Co-Authored-By de Claude/IA. Ya cubierto globalmente.",
       "patrones": [
         "\\bSin\\s+co-?autores\\s+en\\s+commits\\b",
-        "\\bNO\\s+incluir\\s+Co-Authored-By\\b",
-        "\\bnunca\\s+incluir\\s+[\"']?Co-Authored-By:\\s+Claude",
-        "\\bsin\\s+atribuci[oó]n\\s+a\\s+Claude\\b"
+        "\\bNO\\s+incluir\\s+\\W?Co-?Authored-?By\\b",
+        "\\bnunca\\s+incluir\\s+[\"'`]?Co-Authored-By:?\\s+Claude",
+        "\\bsin\\s+atribuci[oó]n\\s+a\\s+Claude\\b",
+        "\\bcommits?\\s+son\\s+del\\s+desarrollador\\b"
       ],
       "min_matches": 1,
       "scope": "project-level",
@@ -100,6 +101,73 @@
       "min_matches": 1,
       "scope": "project-level",
       "remediacion_sugerida": "Eliminar el bloque local. La regla global aplica."
+    },
+    {
+      "id": "usar-sistema-swl",
+      "regla_global": "usar-sistema-swl.md",
+      "seccion_canonica": "Uso obligatorio del sistema SWL",
+      "referencia_canonica": "@~/.claude/rules/usar-sistema-swl.md",
+      "descripcion": "Uso obligatorio del sistema SWL: invocar agentes/skills/comandos especializados en lugar de trabajo directo con Read/Write/Edit. Ya cubierto globalmente.",
+      "patrones": [
+        "\\bSIEMPRE\\s+usar\\s+el\\s+sistema\\s+SWL\\b",
+        "\\busar\\s+el\\s+sistema\\s+SWL\\s+completo\\b",
+        "\\bNO\\s+hacer\\s+trabajo\\s+directo\\s+que\\s+un\\s+agente\\s+SWL\\b",
+        "\\bagentes?\\s+especializados?\\b.*\\borquestador-swl\\b",
+        "\\binvocar\\s+`?orquestador-swl`?\\b.*\\bpunto\\s+de\\s+entrada\\b",
+        "\\bFlujo\\s+de\\s+trabajo\\s+obligatorio\\s*[—\\-]\\s*Sistema\\s+SWL\\b"
+      ],
+      "min_matches": 2,
+      "scope": "project-level",
+      "remediacion_sugerida": "Eliminar el bloque local de flujo de trabajo SWL. La regla global `~/.claude/rules/usar-sistema-swl.md` cubre el principio y la matriz operacional completa (qué componente usar para cada tipo de tarea, excepciones legítimas, anti-patrones). Si el proyecto tiene matices propios (ej: agentes específicos del dominio, ejemplos de invocaciones validadas, casos edge), conservar SOLO esos matices con frase corta + referencia: \"Ver @~/.claude/rules/usar-sistema-swl.md. En este proyecto, además: <matiz>\"."
+    },
+    {
+      "id": "analisis-previo-tareas-grandes",
+      "regla_global": "analisis-previo-tareas-grandes.md",
+      "seccion_canonica": "Análisis previo ante tareas grandes",
+      "referencia_canonica": "@~/.claude/rules/analisis-previo-tareas-grandes.md",
+      "descripcion": "Tareas grandes (>10 archivos, >500 LOC, cross-módulo, replicar/portar todo) requieren tabla comparativa + 3 opciones (mínima/media/completa) + recomendación + confirmación. Ya cubierto globalmente.",
+      "patrones": [
+        "\\btabla\\s+comparativa\\b.*\\bgap\\b",
+        "\\btres\\s+opciones\\s+de\\s+alcance\\b",
+        "\\b(mínima|minima)\\s*[\\/\\|]\\s*media\\s*[\\/\\|]\\s*completa\\b",
+        "\\breplicar\\s+íntegramente\\b.*\\banálisis\\s+comparativo\\b"
+      ],
+      "min_matches": 2,
+      "scope": "project-level",
+      "remediacion_sugerida": "Eliminar el bloque local. La regla global cubre el protocolo de auditoría previa + 3 opciones + recomendación + confirmación. Si el proyecto tiene umbrales propios (ej: >5 archivos en lugar de >10), conservar solo el umbral con referencia."
+    },
+    {
+      "id": "registro-componentes-nuevos",
+      "regla_global": "registro-componentes-nuevos.md",
+      "seccion_canonica": "Registro obligatorio de componentes nuevos en manifiestos",
+      "referencia_canonica": "@~/.claude/rules/registro-componentes-nuevos.md",
+      "descripcion": "Todo componente nuevo (agente/skill/comando/hook/regla) DEBE registrarse en manifiestos + plugin.json + INVENTARIO en el mismo commit. Ya cubierto globalmente.",
+      "patrones": [
+        "\\btodo\\s+componente\\s+nuevo\\b.*\\bregistr(?:ar(?:se)?|o|ado)\\b",
+        "\\bregistro\\s+obligatorio\\s+(de\\s+)?componentes?\\s+nuevos\\b",
+        "\\bmanifiestos?\\s*\\/\\s*modulos\\.json\\b.*\\bplugin\\.json\\b",
+        "\\bplugin\\.json\\b.*\\bmanifiestos?\\s*\\/\\s*modulos\\.json\\b",
+        "\\bregistro\\s+obligatorio\\s+en\\s+manifiestos\\b",
+        "\\ben\\s+el\\s+mismo\\s+commit\\b.*\\bmanifiestos?\\b"
+      ],
+      "min_matches": 2,
+      "scope": "project-level",
+      "remediacion_sugerida": "Eliminar el bloque local. La regla global `~/.claude/rules/registro-componentes-nuevos.md` cubre la tabla de propagación obligatoria (qué archivos tocar por tipo de componente) y los gates de CI que la enforzan. Si el proyecto tiene componentes propios además de los del sistema, conservar SOLO esos matices."
+    },
+    {
+      "id": "consultar-vault-primero",
+      "regla_global": "consultar-vault-primero.md",
+      "seccion_canonica": "Consultar el vault Obsidian antes de leer múltiples archivos",
+      "referencia_canonica": "@~/.claude/rules/consultar-vault-primero.md",
+      "descripcion": "Antes de leer 3+ archivos del codebase para construir contexto general, consultar el vault Obsidian con obsidian_simple_search. Ya cubierto globalmente.",
+      "patrones": [
+        "\\bconsultar\\s+el\\s+vault\\s+Obsidian\\s+primero\\b",
+        "\\bantes\\s+de\\s+leer\\s+3\\+?\\s+archivos\\b.*\\bvault\\b",
+        "\\bobsidian_simple_search\\b.*\\bantes\\b"
+      ],
+      "min_matches": 1,
+      "scope": "project-level",
+      "remediacion_sugerida": "Eliminar el bloque local. La regla global aplica a cualquier proyecto con vault Obsidian disponible."
     }
   ],
   "configuracion": {