@saulwade/swl-ses 1.4.2 → 1.5.1

package/scripts/instalador.js

@@ -411,6 +411,11 @@ async function install(opciones) {
     perfil,
     rutaBase: rutas.base,
     global: esGlobal,
+    // Persistir contexto de filtrado de reglas-lenguajes para que doctor
+    // verifique conteos contra el filtro real al instalar (no recalcule
+    // desde el cwd actual del doctor). Fix v1.4.3.
+    allLangs: allLangs === true,
+    stackInstalado: stackDetectado instanceof Set ? [...stackDetectado] : null,
   });
 
   let instalados = 0;
@@ -447,6 +452,11 @@ async function install(opciones) {
     }
   }
 
+  // Cargar transformador del target ANTES del loop de instalación —
+  // Sub-fase 11.5: permite que instalarArchivo invoque transformarAgente
+  // por archivo para targets que cambian formato (ej. codex .md → .toml).
+  const transformadorTarget = obtenerTransformador(target, runtime);
+
   // Instalar archivos core
   for (const archivo of resolucion.archivos) {
     try {
@@ -457,6 +467,7 @@ async function install(opciones) {
         estado,
         syncMode,
         flatNaming,
+        transformador: transformadorTarget,
       });
       if (resultado.instalado) {
         registrarArchivo(estado, {
@@ -612,6 +623,13 @@ async function install(opciones) {
         // transformador Claude pueda detectar stack/comandos/framework.
         // Otros transformadores ignoran este campo.
         dirProyecto: process.cwd(),
+        // ADR-0019 Sub-fase 1: el transformador Codex necesita saber el scope para
+        // resolver dirBase (~/.codex/ vs cwd) y registrar el MCP server.
+        // El runtime trae los paths absolutos calculados por detectar-runtime.js.
+        esGlobal,
+        dirRuntimeGlobal: runtime.global,
+        withMcp: Boolean(opciones.with_mcp) && !opciones.no_mcp,
+        swlBinPath: path.join(RAIZ_PKG, 'bin', 'swl-mcp-server.js'),
       });
 
       if (instrucciones) {
@@ -628,6 +646,7 @@ async function install(opciones) {
           console.log('  = CLAUDE.md no modificado (--no-claudemd)');
         } else if (instrucciones.merge && instrucciones.merge.tipo === 'marcadores') {
           // Merge idempotente con marcadores — preserva contenido del usuario.
+          // Aplica a CLAUDE.md (Claude Code) y AGENTS.md (Codex CLI) — ADR-0019 Sub-fase 1.
           if (!fs.existsSync(dirInstrucciones)) {
             fs.mkdirSync(dirInstrucciones, { recursive: true });
           }
@@ -637,12 +656,13 @@ async function install(opciones) {
             endTag:      instrucciones.merge.endTag,
             beginPrefix: instrucciones.merge.beginPrefix,
           });
+          const nombreArchivo = instrucciones.rutaRelativa;
           const etiqueta = {
-            'creado':       '+ CLAUDE.md creado con bloque SWL',
-            'append':       '+ Bloque SWL agregado al final de CLAUDE.md (contenido del usuario preservado)',
-            'reemplazado':  '* Bloque SWL actualizado en CLAUDE.md (contenido del usuario preservado)',
-            'sin-cambios':  '= CLAUDE.md ya tenía el bloque SWL actualizado',
-            'error':        '! Error al fusionar CLAUDE.md',
+            'creado':       `+ ${nombreArchivo} creado con bloque SWL`,
+            'append':       `+ Bloque SWL agregado al final de ${nombreArchivo} (contenido del usuario preservado)`,
+            'reemplazado':  `* Bloque SWL actualizado en ${nombreArchivo} (contenido del usuario preservado)`,
+            'sin-cambios':  `= ${nombreArchivo} ya tenía el bloque SWL actualizado`,
+            'error':        `! Error al fusionar ${nombreArchivo}`,
           }[resMerge.accion] || `${resMerge.accion} ${resMerge.archivo}`;
           console.log(`  ${etiqueta}${resMerge.detalle ? ': ' + resMerge.detalle : ''}`);
           registrarArchivo(estado, {
@@ -850,6 +870,33 @@ function instalarArchivo(archivo, rutas, runtime, opciones = {}) {
 
   let nombreArchivo = path.basename(archivo.origen);
 
+  // Sub-fase 11.5 v1.5.0: para tipo 'agentes', aplicar transformarAgente del
+  // transformador del target ANTES de la copia. Permite que codex emita TOML
+  // (.toml) en lugar del .md original, o que cursor normalice el frontmatter.
+  // Si transformarAgente devuelve `consolidar: true`, saltar — el archivo
+  // se incluirá en el archivoPrincipal (AGENTS.md) generado más adelante.
+  let contenidoTransformado = null;
+  if (archivo.tipo === 'agentes' && opciones.transformador && typeof opciones.transformador.transformarAgente === 'function') {
+    try {
+      const original = fs.readFileSync(archivo.origen, 'utf-8');
+      const t = opciones.transformador.transformarAgente(original, { nombreArchivo });
+      if (t && t.consolidar === true) {
+        // El transformador del target prefiere consolidar este agente en el
+        // archivoPrincipal en lugar de tener archivo individual. No instalar aquí.
+        return { instalado: false, razon: 'consolidado en archivoPrincipal' };
+      }
+      if (t && typeof t.contenido === 'string') {
+        contenidoTransformado = t.contenido;
+        if (t.rutaRelativa) {
+          // Usar el basename del rutaRelativa devuelto (puede cambiar extensión .md → .toml)
+          nombreArchivo = path.basename(t.rutaRelativa);
+        }
+      }
+    } catch (err) {
+      console.log(`  ! Transformación de agente falló (${err.message}), copia literal del .md`);
+    }
+  }
+
   // Flat naming: convierte rutas jerárquicas en nombres planos con __
   // Ejemplo: habilidades/build-errors-python → build-errors-python (sin cambio, ya es plano)
   // Ejemplo: reglas/lenguajes/java/java-estilo.md → java__java-estilo.md
@@ -991,6 +1038,10 @@ function instalarArchivo(archivo, rutas, runtime, opciones = {}) {
     // Copy mode (default) o fallback de symlink
     if (stat.isDirectory()) {
       copiarDirectorio(archivo.origen, path.join(dirDestino, nombreArchivo));
+    } else if (contenidoTransformado !== null) {
+      // Sub-fase 11.5: el transformador del target reescribió el contenido
+      // (ej. codex .md → .toml). Escribir el contenido transformado.
+      fs.writeFileSync(destino, contenidoTransformado, 'utf-8');
     } else {
       fs.copyFileSync(archivo.origen, destino);
     }

package/scripts/lib/detectar-runtime.js

@@ -81,19 +81,29 @@ const RUNTIMES = {
     tiposSoportados: ['agentes', 'habilidades', 'comandos', 'reglas', 'hooks'],
   },
   codex: {
+    // ADR-0019 Sub-fase 1 → ampliada en Sub-fase 8 (mismo v1.5.0).
+    // Codex CLI lee:
+    //   - AGENTS.md jerárquico (project + ~/.codex/AGENTS.md global)
+    //   - ${CODEX_HOME:-$HOME/.codex}/skills/<name>/SKILL.md (skills propias)
+    //   - ~/.codex/config.toml con [mcp_servers.NAME] (MCP)
+    //   - hooks.json con PreToolUse/PostToolUse/Stop (NO mapeado por SWL — formato distinto)
+    // Codex NO expone agents/ individual desde filesystem — los agentes SWL
+    // van consolidados en AGENTS.md como tabla referencial.
     nombre: 'Codex CLI',
     global: path.join(os.homedir(), '.codex'),
     local: '.codex',
-    archivosConfig: [],
-    dirAgentes: null,
-    dirHabilidades: null,
-    dirComandos: null,
-    dirReglas: null,
-    formatoAgente: 'consolidado',
-    soportaHooks: false,
-    soporte: 'parcial', // Solo agentes consolidados y reglas (limitacion de plataforma)
+    archivosConfig: ['config.toml'],
+    dirAgentes: 'agents',       // ~/.codex/agents/<name>.toml — Sub-fase 11 v1.5.0 (formato TOML)
+    dirHabilidades: 'skills',   // path real `~/.agents/skills/` resuelto por transformador (Sub-fase 10)
+    dirComandos: null,          // Codex no soporta slash custom filesystem
+    dirReglas: null,            // consolidado en AGENTS.md (Codex rules son Starlark, no portable)
+    formatoAgente: 'toml',      // Sub-fase 11: cada agente es un .toml individual
+    soportaHooks: true,         // Sub-fase 10: ~/.codex/hooks.json (6 eventos)
+    hookConfig: 'hooks.json',
+    soporte: 'completo',
     archivoPrincipal: 'AGENTS.md',
-    tiposSoportados: ['agentes', 'reglas'],
+    tiposSoportados: ['agentes', 'habilidades', 'reglas', 'hooks'],
+    notas: 'Agentes en ~/.codex/agents/<name>.toml (formato TOML — Sub-fase 11). Skills en ~/.agents/skills/ (path oficial OpenAI — Sub-fase 10). Hooks en ~/.codex/hooks.json. MCP server en ~/.codex/config.toml. AGENTS.md sigue conteniendo tabla referencial como índice.',
   },
   gemini: {
     nombre: 'Gemini CLI',
@@ -111,6 +121,34 @@ const RUNTIMES = {
     archivoPrincipal: 'GEMINI.md',
     tiposSoportados: ['agentes', 'habilidades', 'comandos', 'reglas', 'hooks'],
   },
+  cursor: {
+    // ADR-0019 Sub-fase 2 → refinada en Sub-fase 7 (mismo v1.5.0).
+    // Tras verificar docs oficiales de Cursor (cursor.com/es/docs/{subagents,skills,rules,mcp}):
+    // Cursor SÍ soporta subagents y skills filesystem nativamente.
+    //   - `.cursor/agents/<name>.md` con frontmatter Claude-compatible
+    //     (name, description, model=inherit, readonly, is_background).
+    //     Legacy: lee `.claude/agents/`, `.codex/agents/`.
+    //   - `.cursor/skills/<name>/SKILL.md` (mismo formato Anthropic Skills).
+    //     Legacy: lee `.agents/skills/`, `.claude/skills/`, `.codex/skills/`.
+    //   - `.cursor/rules/*.mdc` con frontmatter description/alwaysApply/globs.
+    //   - `.cursor/mcp.json` o `~/.cursor/mcp.json` para MCP servers.
+    //   - NO soporta nativamente: slash commands custom, hooks (PreToolUse, etc).
+    nombre: 'Cursor',
+    global: path.join(os.homedir(), '.cursor'),
+    local: '.cursor',
+    archivosConfig: ['mcp.json'],
+    dirAgentes: 'agents',           // .cursor/agents/<name>.md
+    dirHabilidades: 'skills',       // .cursor/skills/<name>/SKILL.md
+    dirComandos: null,              // Cursor no tiene slash custom filesystem (skills cumplen ese rol)
+    dirReglas: 'rules',             // .cursor/rules/*.mdc
+    formatoAgente: 'markdown-frontmatter',
+    soportaHooks: true,             // Sub-fase 10: .cursor/hooks.json (17 eventos)
+    hookConfig: 'hooks.json',
+    soporte: 'completo',
+    archivoPrincipal: null,
+    tiposSoportados: ['agentes', 'habilidades', 'reglas', 'hooks'],
+    notas: 'Subagents en .cursor/agents/, skills en .cursor/skills/<name>/SKILL.md, reglas en .cursor/rules/*.mdc, hooks en .cursor/hooks.json (17 eventos camelCase), MCP en .cursor/mcp.json. Slash commands custom: usar skills (se invocan con /<name>).',
+  },
 };
 
 /**
@@ -269,6 +307,33 @@ function detectarInstalacionesDuales(runtimeId, opciones = {}) {
   };
 }
 
+/**
+ * Lista los IDs de runtimes "instalables" — es decir, los que tienen
+ * transformador disponible y soporte declarado (completo o parcial).
+ *
+ * Se usa para expandir `--all-runtimes` en multi-target install (ADR-0019 Sub-fase 2.5).
+ *
+ * Excluye alias (openclaude comparte el dir .claude/ con claude — incluirlo en
+ * --all-runtimes produciría doble instalación al mismo destino).
+ *
+ * Orden estable: el orden de la lista importa porque define el orden de
+ * ejecución de --all-runtimes. Si un target falla los siguientes igual se
+ * intentan (ADR-0019 punto 9: atomicidad por target, no rollback).
+ *
+ * @returns {string[]} Lista de runtime IDs ordenada de "más usado" a "menos usado".
+ */
+function listarRuntimesInstalables() {
+  return [
+    'claude',     // Soporte completo, primer ciudadano
+    'cursor',     // Soporte parcial — reglas + MCP
+    'codex',      // Soporte parcial — AGENTS.md + MCP (v1.5.0+)
+    'opencode',   // Soporte completo
+    'gemini',     // Soporte completo
+    'copilot',    // Soporte parcial — agentes consolidados
+    // 'openclaude' intencionalmente excluido — comparte dir con claude
+  ];
+}
+
 module.exports = {
   RUNTIMES,
   detectarRuntimes,
@@ -276,4 +341,5 @@ module.exports = {
   obtenerRuntime,
   calcularRutas,
   resumenDeteccion,
+  listarRuntimesInstalables,
 };

package/scripts/lib/estado.js

@@ -21,7 +21,17 @@ try {
 const NOMBRE_ESTADO = '.swl-install-state.json';
 
 /**
- * Crea un nuevo registro de estado de instalación
+ * Crea un nuevo registro de estado de instalación.
+ *
+ * Persiste el contexto de filtrado de reglas-lenguajes (allLangs, stackInstalado)
+ * para que doctor verifique conteos contra el filtro real usado al instalar,
+ * no contra un nuevo filtro calculado desde el cwd actual del doctor.
+ *
+ * Bug histórico v1.4.2: doctor reportaba "reglas: 65 (perfil esperaba 25)" como
+ * falso positivo cuando el usuario instalaba globalmente desde un dir con
+ * indicadores de lenguaje y luego ejecutaba doctor desde otro dir sin esos
+ * indicadores. El recálculo del filtro daba 25 esperadas en lugar de las 65
+ * realmente instaladas.
  */
 function crearEstado(opciones) {
   return {
@@ -37,6 +47,8 @@ function crearEstado(opciones) {
     componentesExternos: [],
     hooksRegistrados: 0,
     settingsModificado: false,
+    allLangs: opciones.allLangs === true,
+    stackInstalado: Array.isArray(opciones.stackInstalado) ? opciones.stackInstalado : null,
     instaladoEn: new Date().toISOString(),
     actualizadoEn: new Date().toISOString(),
   };

package/scripts/lib/expandir-targets.js

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

package/scripts/lib/parsear-opciones.js

@@ -42,6 +42,9 @@ const BOOLEANAS = [
   'dry-run', 'simular',
   'force', 'forzar',
   'verbose', 'all', 'all-langs', 'no-claudemd',
+  // ADR-0019 — Codex/Cursor + MCP autoconfig opt-in
+  'with-mcp', 'no-mcp',
+  'all-runtimes',
 ];
 
 /**

package/scripts/lib/toml-merge.js

@@ -0,0 +1,204 @@
+'use strict';
+
+/**
+ * Merge mínimo de secciones TOML — zero-deps.
+ *
+ * Opera sobre el formato concreto de `~/.codex/config.toml` (OpenAI Codex CLI):
+ *   [mcp_servers.<name>]
+ *   command = "node"
+ *   args = ["...", "..."]
+ *   [mcp_servers.<name>.env]
+ *   KEY = "value"
+ *
+ * Reglas:
+ *  - NUNCA reescribe el archivo entero. Solo agrega o reemplaza la sección
+ *    `[mcp_servers.<name>]` indicada (incluyendo sub-tabla `.env`).
+ *  - Si el archivo no existe lo crea con permisos 0600.
+ *  - Si el archivo tiene comentarios o secciones desconocidas, las preserva.
+ *  - Bloque "owned" delimitado por marcadores `# SWL-MCP-BEGIN <name>` /
+ *    `# SWL-MCP-END <name>` para permitir actualizaciones idempotentes.
+ *
+ * NO soporta:
+ *  - TOML completo (arrays multilínea complejos, inline tables, etc.)
+ *  - Multi-section nested tables fuera de `mcp_servers.*`
+ *
+ * Si en el futuro Codex publica un comando idempotente `codex mcp add --idempotent`
+ * podemos delegarle el trabajo y deprecar este helper.
+ *
+ * @module scripts/lib/toml-merge
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { atomicWriteSync } = require('../../hooks/lib/atomic-write');
+
+const BEGIN_PREFIX = '# SWL-MCP-BEGIN';
+const END_PREFIX = '# SWL-MCP-END';
+
+/**
+ * Serializa un servidor MCP en bloque TOML.
+ *
+ * @param {string} name - Nombre del server (identificador en config.toml).
+ * @param {{ command: string, args?: string[], env?: Record<string,string> }} cfg
+ * @returns {string} Bloque TOML con marcadores.
+ */
+function serializarServidor(name, cfg) {
+  if (!name || typeof name !== 'string' || !/^[a-zA-Z0-9_-]+$/.test(name)) {
+    throw new Error(`Nombre de MCP server inválido: "${name}". Solo [a-zA-Z0-9_-].`);
+  }
+  if (!cfg || typeof cfg.command !== 'string' || cfg.command.length === 0) {
+    throw new Error(`MCP server "${name}" requiere "command" string no vacío.`);
+  }
+
+  const lineas = [];
+  lineas.push(`${BEGIN_PREFIX} ${name}`);
+  lineas.push(`[mcp_servers.${name}]`);
+  lineas.push(`command = ${tomlString(cfg.command)}`);
+
+  if (Array.isArray(cfg.args) && cfg.args.length > 0) {
+    const items = cfg.args.map(tomlString).join(', ');
+    lineas.push(`args = [${items}]`);
+  }
+
+  if (cfg.env && typeof cfg.env === 'object' && Object.keys(cfg.env).length > 0) {
+    lineas.push('');
+    lineas.push(`[mcp_servers.${name}.env]`);
+    for (const [k, v] of Object.entries(cfg.env)) {
+      if (typeof v !== 'string') {
+        throw new Error(`MCP server "${name}" env.${k} debe ser string (recibido: ${typeof v}).`);
+      }
+      // Solo claves alfanuméricas/_ en env names — TOML restricción razonable
+      if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(k)) {
+        throw new Error(`MCP server "${name}" env key inválido: "${k}".`);
+      }
+      lineas.push(`${k} = ${tomlString(v)}`);
+    }
+  }
+
+  lineas.push(`${END_PREFIX} ${name}`);
+  return lineas.join('\n');
+}
+
+/**
+ * Escapa un string para TOML usando comillas dobles.
+ * No usa basic-string raw para evitar pitfalls con backslashes.
+ */
+function tomlString(s) {
+  // TOML basic string: escape backslash, doblequote, control chars.
+  const escapado = String(s)
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+    .replace(/\n/g, '\\n')
+    .replace(/\r/g, '\\r')
+    .replace(/\t/g, '\\t');
+  return `"${escapado}"`;
+}
+
+/**
+ * Inserta o actualiza un servidor MCP en `config.toml`.
+ *
+ * Idempotente: si el bloque ya existe con el mismo contenido, no escribe.
+ * Si existe con contenido distinto, lo reemplaza dentro de los marcadores.
+ * Si no existe, lo agrega al final del archivo precedido de línea en blanco.
+ *
+ * @param {string} rutaConfig - Path absoluto a config.toml (típicamente ~/.codex/config.toml).
+ * @param {string} name - Nombre del MCP server (clave de [mcp_servers.<name>]).
+ * @param {{ command: string, args?: string[], env?: Record<string,string> }} cfg
+ * @returns {{ accion: 'creado' | 'agregado' | 'actualizado' | 'sin-cambios', ruta: string }}
+ */
+function upsertMcpServer(rutaConfig, name, cfg) {
+  const bloqueNuevo = serializarServidor(name, cfg);
+
+  let existente = '';
+  let existia = false;
+  try {
+    existente = fs.readFileSync(rutaConfig, 'utf-8');
+    existia = true;
+  } catch (err) {
+    if (err.code !== 'ENOENT') throw err;
+    // Archivo no existe — se crea
+  }
+
+  const beginTag = `${BEGIN_PREFIX} ${name}`;
+  const endTag = `${END_PREFIX} ${name}`;
+
+  if (!existia) {
+    const dir = path.dirname(rutaConfig);
+    fs.mkdirSync(dir, { recursive: true });
+    const contenido = `# config.toml de Codex CLI — gestionado parcialmente por swl-ses\n# Bloques delimitados por SWL-MCP-BEGIN/END son regenerables.\n\n${bloqueNuevo}\n`;
+    atomicWriteSync(rutaConfig, contenido, 'utf8', { mode: 0o600 });
+    return { accion: 'creado', ruta: rutaConfig };
+  }
+
+  const idxBegin = existente.indexOf(beginTag);
+  const idxEnd = existente.indexOf(endTag);
+
+  // Caso 1: no existe el bloque → append al final
+  if (idxBegin === -1 || idxEnd === -1) {
+    const separador = existente.endsWith('\n') ? '\n' : '\n\n';
+    const contenido = existente + separador + bloqueNuevo + '\n';
+    atomicWriteSync(rutaConfig, contenido, 'utf8', { mode: 0o600 });
+    return { accion: 'agregado', ruta: rutaConfig };
+  }
+
+  // Caso 2: existe — comparar contenido
+  // Calculamos fin REAL incluyendo el endTag completo.
+  const finBloqueExistente = idxEnd + endTag.length;
+  const bloqueExistente = existente.slice(idxBegin, finBloqueExistente);
+
+  if (bloqueExistente === bloqueNuevo) {
+    return { accion: 'sin-cambios', ruta: rutaConfig };
+  }
+
+  const contenido = existente.slice(0, idxBegin) + bloqueNuevo + existente.slice(finBloqueExistente);
+  atomicWriteSync(rutaConfig, contenido, 'utf8', { mode: 0o600 });
+  return { accion: 'actualizado', ruta: rutaConfig };
+}
+
+/**
+ * Elimina un bloque MCP server por nombre. Idempotente: si no existe, no hace nada.
+ *
+ * @param {string} rutaConfig
+ * @param {string} name
+ * @returns {{ accion: 'eliminado' | 'sin-cambios', ruta: string }}
+ */
+function removeMcpServer(rutaConfig, name) {
+  let existente = '';
+  try {
+    existente = fs.readFileSync(rutaConfig, 'utf-8');
+  } catch (err) {
+    if (err.code === 'ENOENT') return { accion: 'sin-cambios', ruta: rutaConfig };
+    throw err;
+  }
+
+  const beginTag = `${BEGIN_PREFIX} ${name}`;
+  const endTag = `${END_PREFIX} ${name}`;
+  const idxBegin = existente.indexOf(beginTag);
+  const idxEnd = existente.indexOf(endTag);
+
+  if (idxBegin === -1 || idxEnd === -1) {
+    return { accion: 'sin-cambios', ruta: rutaConfig };
+  }
+
+  // Quitar bloque + posible newline previo y posterior (cosmético)
+  let inicio = idxBegin;
+  let fin = idxEnd + endTag.length;
+  // Comer un \n previo si existe (no comer doble \n para preservar separadores entre secciones)
+  if (inicio > 0 && existente[inicio - 1] === '\n') inicio--;
+  if (fin < existente.length && existente[fin] === '\n') fin++;
+
+  const contenido = existente.slice(0, inicio) + existente.slice(fin);
+  atomicWriteSync(rutaConfig, contenido, 'utf8', { mode: 0o600 });
+  return { accion: 'eliminado', ruta: rutaConfig };
+}
+
+module.exports = {
+  upsertMcpServer,
+  removeMcpServer,
+  serializarServidor,
+  // Para tests
+  _tomlString: tomlString,
+  BEGIN_PREFIX,
+  END_PREFIX,
+};

package/scripts/lib/transformadores/base.js

@@ -8,27 +8,61 @@ class TransformadorBase {
     this.runtime = runtimeConfig;
   }
 
-  // Parsea frontmatter YAML de un archivo markdown
+  // Parsea frontmatter YAML de un archivo markdown.
+  // Maneja CRLF (Windows) y LF (Unix). Soporta valores multi-línea con `>` y `|`.
   // Retorna { frontmatter: object, cuerpo: string }
   parsearFrontmatter(contenido) {
-    const match = contenido.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+    // Normalizar a LF para que el regex funcione con archivos Windows (CRLF).
+    const norm = String(contenido).replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    const match = norm.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
     if (!match) return { frontmatter: {}, cuerpo: contenido };
 
     const yamlStr = match[1];
     const cuerpo = match[2];
     const frontmatter = {};
 
-    for (const linea of yamlStr.split('\n')) {
-      const idx = linea.indexOf(':');
-      if (idx === -1) continue;
-      const clave = linea.slice(0, idx).trim();
-      let valor = linea.slice(idx + 1).trim();
-      // Booleans
+    const lineas = yamlStr.split('\n');
+    let i = 0;
+    while (i < lineas.length) {
+      const linea = lineas[i];
+      const idxColon = linea.indexOf(':');
+      if (idxColon === -1) { i++; continue; }
+      const clave = linea.slice(0, idxColon).trim();
+      let valorRaw = linea.slice(idxColon + 1).trim();
+
+      // Multi-línea con `>` (folded) o `|` (literal):
+      // capturar líneas indentadas siguientes y colapsarlas a single-line para `>`,
+      // mantener saltos para `|`. Soporta el patrón estándar de YAML en SWL agents.
+      if (valorRaw === '>' || valorRaw === '|') {
+        const folded = valorRaw === '>';
+        const partes = [];
+        i++;
+        while (i < lineas.length) {
+          const sig = lineas[i];
+          // Línea no indentada y no vacía → fin del bloque multi-línea.
+          if (sig.length > 0 && !/^\s/.test(sig)) break;
+          // Línea vacía dentro del bloque → mantener como separador.
+          if (sig.trim().length === 0) {
+            partes.push('');
+            i++;
+            continue;
+          }
+          partes.push(sig.replace(/^\s+/, ''));
+          i++;
+        }
+        frontmatter[clave] = folded
+          ? partes.filter(p => p.length > 0).join(' ').trim()
+          : partes.join('\n').trim();
+        continue;
+      }
+
+      // Valor inline simple
+      let valor = valorRaw;
       if (valor === 'true') valor = true;
       else if (valor === 'false') valor = false;
-      // Numbers
       else if (/^\d+$/.test(valor)) valor = parseInt(valor, 10);
       frontmatter[clave] = valor;
+      i++;
     }
 
     return { frontmatter, cuerpo };