@saulwade/swl-ses 1.7.1 → 1.7.2

package/CLAUDE.md

@@ -1,4 +1,4 @@
-# CLAUDE.md — @saulwade/swl-ses v1.7.1
+# CLAUDE.md — @saulwade/swl-ses v1.7.2
 
 ## Reglas de máxima prioridad (aplican SIEMPRE, sin excepción)
 

package/README.md

@@ -1,4 +1,4 @@
-# swl-ses v1.7.1
+# swl-ses v1.7.2
 
 > El paquete anterior `@saulwadeleon/swl-software-engineering-system` está deprecado. Migrar a `@saulwade/swl-ses` (npmjs.org canónico) o `@saul-wade/swl-ses` (mirror en GitHub Packages) — el CLI `swl-ses` no cambia.
 

package/manifiestos/modulos.json

@@ -1218,11 +1218,12 @@
       "opt_in": true
     },
     "claudemd-auditor": {
-      "descripcion": "Auditor de calidad de CLAUDE.md según best practices Anthropic (ADR-0016). Detecta inflación (líneas excesivas, bullets gigantes, secciones canónicas ausentes, sin @references, placeholders). Usado por el comando /swl:claudemd y por el hook claudemd-bloat-detector. Zero-deps. Soporta --json y --strict. Umbrales configurables: SWL_CLAUDEMD_MAX_LINES (default 200), SWL_CLAUDEMD_MAX_BULLET_CHARS (default 1000).",
+      "descripcion": "Auditor de calidad de CLAUDE.md según best practices Anthropic (ADR-0016). Detecta inflación (líneas excesivas, bullets gigantes, secciones canónicas ausentes, sin @references, placeholders). Dimensión 8 (v1.7.0): duplicación inline de reglas globales ~/.claude/rules/ vía catálogo declarativo. Dimensión 9 (v1.7.2): auto-duplicación intra-archivo (2+ secciones H2 citan la misma regla global con prosa). Usado por el comando /swl:claudemd y por el hook claudemd-bloat-detector. Zero-deps. Soporta --json y --strict. Umbrales configurables: SWL_CLAUDEMD_MAX_LINES (default 200), SWL_CLAUDEMD_MAX_BULLET_CHARS (default 1000).",
       "tipo": "scripts",
       "archivos": [
         "scripts/auditar-claudemd.js",
         "scripts/lib/detector-reglas-duplicadas.js",
+        "scripts/lib/detector-autoduplicacion-intra-archivo.js",
         "scripts/lib/reglas-globales-conocidas.json",
         "docs/variables-entorno.md"
       ],

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@saulwade/swl-ses",
-  "version": "1.7.1",
-  "description": "Sistema de ingenieria de software auto-evolutivo multi-runtime polyglot con 61 agentes, 177 habilidades, 44 comandos, 71 reglas y 43 hooks. Soporta 11 lenguajes y 7 runtimes: Claude Code, OpenClaude, OpenCode, Gemini CLI, Cursor, Codex CLI (soporte completo); GitHub Copilot (soporte parcial). 100% en espanol (Mexico). Multi-target install (--target CSV / --all-runtimes), autoconfig MCP en Cursor/Codex con --with-mcp, agentes Codex en TOML, hooks Cursor (17 eventos) y Codex (6 eventos). Gateway bidireccional con relay Telegram y auditoria profunda Nemesis con loop evaluator-optimizer opt-in (ADR-0021) y 8 tools ejecutables. v1.7.1 introduce dimension 8 del auditor CLAUDE.md (deteccion de duplicacion de reglas globales) + hook PostToolUse claudemd-duplicacion-detector + regla sin-duplicacion-reglas-globales.md + catalogo declarativo reglas-globales-conocidas.json con 6 reglas (idioma, brevedad, git-coauthor, arreglar-al-detectar, debatir, context7).",
+  "version": "1.7.2",
+  "description": "Sistema de ingenieria de software auto-evolutivo multi-runtime polyglot con 61 agentes, 177 habilidades, 44 comandos, 71 reglas y 43 hooks. Soporta 11 lenguajes y 7 runtimes: Claude Code, OpenClaude, OpenCode, Gemini CLI, Cursor, Codex CLI (soporte completo); GitHub Copilot (soporte parcial). 100% en espanol (Mexico). Multi-target install (--target CSV / --all-runtimes), autoconfig MCP en Cursor/Codex con --with-mcp, agentes Codex en TOML, hooks Cursor (17 eventos) y Codex (6 eventos). Gateway bidireccional con relay Telegram y auditoria profunda Nemesis con loop evaluator-optimizer opt-in (ADR-0021) y 8 tools ejecutables. v1.7.2 introduce dimension 8 del auditor CLAUDE.md (deteccion de duplicacion de reglas globales) + hook PostToolUse claudemd-duplicacion-detector + regla sin-duplicacion-reglas-globales.md + catalogo declarativo reglas-globales-conocidas.json con 6 reglas (idioma, brevedad, git-coauthor, arreglar-al-detectar, debatir, context7).",
   "bin": {
     "swl-ses": "bin/swl-ses.js",
     "swl-telegram-bot": "bin/swl-telegram-bot.js",

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "swl-ses",
-  "version": "1.7.1",
-  "description": "Sistema de ingenieria de software auto-evolutivo multi-runtime polyglot. 61 agentes, 177 habilidades, 44 comandos, 71 reglas y 43 hooks. 62 librerias. 11 lenguajes. Soporta Claude Code, Copilot, OpenCode, Codex y Gemini CLI. Loop evaluator-optimizer en /swl:nemesis (ADR-0021). v1.7.1 introduce dimension 8 del auditor CLAUDE.md (deteccion de duplicacion de reglas globales), hook PostToolUse claudemd-duplicacion-detector, regla sin-duplicacion-reglas-globales y catalogo declarativo de 6 reglas globales conocidas (idioma, brevedad, git-coauthor, arreglar-al-detectar, debatir, context7).",
+  "version": "1.7.2",
+  "description": "Sistema de ingenieria de software auto-evolutivo multi-runtime polyglot. 61 agentes, 177 habilidades, 44 comandos, 71 reglas y 43 hooks. 62 librerias. 11 lenguajes. Soporta Claude Code, Copilot, OpenCode, Codex y Gemini CLI. Loop evaluator-optimizer en /swl:nemesis (ADR-0021). v1.7.2 introduce dimension 8 del auditor CLAUDE.md (deteccion de duplicacion de reglas globales), hook PostToolUse claudemd-duplicacion-detector, regla sin-duplicacion-reglas-globales y catalogo declarativo de 6 reglas globales conocidas (idioma, brevedad, git-coauthor, arreglar-al-detectar, debatir, context7).",
   "author": "Saul Wade Leon",
   "license": "MIT",
   "repository": "https://github.com/saul-wade/swl-ses",

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,
+};